libraries/source/spidermonkey/include-win32-release/js/TraceLoggerAPI.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /* SpiderMonkey TraceLogger APIs. */
   7
   8 #ifndef js_TraceLoggerAPI_h
   9 #define js_TraceLoggerAPI_h
  10
  11 #include "jstypes.h"
  12
  13 #include "js/TypeDecls.h"
  14
  15 namespace mozilla {
  16 class JSONWriteFunc;
  17 class TimeStamp;
  18 };  // namespace mozilla
  19
  20 namespace JS {
  21
  22 // Used to lock any tracelogger activities, and consequently, will also block
  23 // any further JS execution when a thread hits an atomic tracelogger activity
  24 // such as payload creation.
  25 class AutoTraceLoggerLockGuard {
  26  public:
  27   AutoTraceLoggerLockGuard();
  28   ~AutoTraceLoggerLockGuard();
  29 };
  30
  31 // An implementation type must be defined in order to gather data using the
  32 // TraceLoggerCollectorBuffer. Each implementation must define the type that is
  33 // being collected in the buffer, along with a static method that is used to
  34 // actually write into the buffer from the tracelogger.
  35 struct TraceLoggerDictionaryImpl {
  36   using ImplType = char;
  37   static size_t NextChunk(JSContext* cx, size_t* dataIndex, ImplType buffer[],
  38                           size_t bufferSize);
  39 };
  40
  41 struct TraceLoggerIdImpl {
  42   using ImplType = uint32_t;
  43   static size_t NextChunk(JSContext* cx, size_t* dataIndex, ImplType buffer[],
  44                           size_t bufferSize);
  45 };
  46
  47 struct TraceLoggerLineNoImpl {
  48   using ImplType = int32_t;
  49   static size_t NextChunk(JSContext* cx, size_t* dataIndex, ImplType buffer[],
  50                           size_t bufferSize);
  51 };
  52
  53 struct TraceLoggerColNoImpl {
  54   using ImplType = int32_t;
  55   static size_t NextChunk(JSContext* cx, size_t* dataIndex, ImplType buffer[],
  56                           size_t bufferSize);
  57 };
  58
  59 struct TraceLoggerTimeStampImpl {
  60   using ImplType = mozilla::TimeStamp;
  61   static size_t NextChunk(JSContext* cx, size_t* dataIndex, ImplType buffer[],
  62                           size_t bufferSize);
  63 };
  64
  65 struct TraceLoggerDurationImpl {
  66   using ImplType = double;
  67   static size_t NextChunk(JSContext* cx, size_t* dataIndex, ImplType buffer[],
  68                           size_t bufferSize);
  69 };
  70
  71 // Buffer that is used to retrieve tracelogger data in fixed size chunks so that
  72 // allocation of a large array is not necessary.  The TraceLoggerCollectorBuffer
  73 // class will manage an internal state which points to the next data index being
  74 // collected.  Each call to NextChunk will also clobber the internal buffer used
  75 // to store the data.
  76 template <class T>
  77 class TraceLoggerCollectorBuffer {
  78   using ImplType = typename T::ImplType;
  79
  80  public:
  81   class Iterator {
  82    public:
  83     Iterator(ImplType* buffer, size_t index)
  84         : iteratorIndex(index), buf(buffer) {}
  85
  86     Iterator operator++() {
  87       iteratorIndex++;
  88       return *this;
  89     }
  90
  91     bool operator!=(const Iterator& other) const {
  92       return iteratorIndex != other.iteratorIndex;
  93     }
  94
  95     ImplType operator*() const { return buf[iteratorIndex]; }
  96
  97    private:
  98     size_t iteratorIndex;
  99     ImplType* buf;
 100   };
 101
 102   explicit TraceLoggerCollectorBuffer(AutoTraceLoggerLockGuard& lockGuard,
 103                                       JSContext* cx = nullptr,
 104                                       size_t length = 4096)
 105       : cx_(cx), length_(length), dataIndex_(0), bufferIndex_(0) {
 106     buffer_ = js_pod_malloc<ImplType>(length);
 107   }
 108
 109   ~TraceLoggerCollectorBuffer() { js_free(buffer_); }
 110
 111   Iterator begin() const { return Iterator(buffer_, 0); }
 112
 113   Iterator end() const { return Iterator(buffer_, bufferIndex_); }
 114
 115   ImplType* internalBuffer() const { return buffer_; }
 116
 117   bool NextChunk() {
 118     bufferIndex_ = T::NextChunk(cx_, &dataIndex_, buffer_, length_);
 119     return (bufferIndex_ != 0) ? true : false;
 120   }
 121
 122  private:
 123   JSContext* cx_;
 124   size_t length_;
 125   size_t dataIndex_;
 126   size_t bufferIndex_;
 127   ImplType* buffer_;
 128 };
 129
 130 #ifdef JS_TRACE_LOGGING
 131
 132 // Initialize the trace logger.  This must be called before using any of the
 133 // other trace logging functions.
 134 extern JS_PUBLIC_API bool InitTraceLogger();
 135
 136 // Return whether the trace logger is supported in this browser session.
 137 extern JS_PUBLIC_API bool TraceLoggerSupported();
 138
 139 // Begin trace logging events.  This will activate some of the
 140 // textId's for various events and set the global option
 141 // JSJITCOMPILER_ENABLE_TRACELOGGER to true.
 142 // This does nothing except return if the trace logger is already active.
 143 extern JS_PUBLIC_API void StartTraceLogger(JSContext* cx);
 144
 145 // Stop trace logging events.  All textId's will be set to false, and the
 146 // global JSJITCOMPILER_ENABLE_TRACELOGGER will be set to false.
 147 // This does nothing except return if the trace logger is not active.
 148 extern JS_PUBLIC_API void StopTraceLogger(JSContext* cx);
 149
 150 // Clear and free any event data that was recorded by the trace logger.
 151 extern JS_PUBLIC_API void ResetTraceLogger(void);
 152
 153 // Spew trace logger statistics.
 154 extern JS_PUBLIC_API void SpewTraceLoggerThread(JSContext* cx);
 155
 156 // Spew trace logger statistics.
 157 extern JS_PUBLIC_API void SpewTraceLoggerForCurrentProcess();
 158
 159 #else
 160 // Define empty inline functions for when trace logging compilation is not
 161 // enabled.  TraceLogging.cpp will not be built in that case so we need to
 162 // provide something for any routines that reference these.
 163 inline bool InitTraceLogger() { return true; }
 164 inline bool TraceLoggerSupported() { return false; }
 165 inline void StartTraceLogger(JSContext* cx) {}
 166 inline void StopTraceLogger(JSContext* cx) {}
 167 inline void ResetTraceLogger(void) {}
 168 inline void SpewTraceLoggerThread(JSContext* cx) {}
 169 inline void SpewTraceLoggerForCurrentProcess() {}
 170 inline size_t TraceLoggerDictionaryImpl::NextChunk(JSContext* cx,
 171                                                    size_t* dataIndex,
 172                                                    ImplType buffer[],
 173                                                    size_t bufferSize) {
 174   return 0;
 175 }
 176 inline size_t TraceLoggerIdImpl::NextChunk(JSContext* cx, size_t* dataIndex,
 177                                            ImplType buffer[],
 178                                            size_t bufferSize) {
 179   return 0;
 180 }
 181 inline size_t TraceLoggerTimeStampImpl::NextChunk(JSContext* cx,
 182                                                   size_t* dataIndex,
 183                                                   ImplType buffer[],
 184                                                   size_t bufferSize) {
 185   return 0;
 186 }
 187 inline size_t TraceLoggerDurationImpl::NextChunk(JSContext* cx,
 188                                                  size_t* dataIndex,
 189                                                  ImplType buffer[],
 190                                                  size_t bufferSize) {
 191   return 0;
 192 }
 193 inline size_t TraceLoggerLineNoImpl::NextChunk(JSContext* cx, size_t* dataIndex,
 194                                                ImplType buffer[],
 195                                                size_t bufferSize) {
 196   return 0;
 197 }
 198 inline size_t TraceLoggerColNoImpl::NextChunk(JSContext* cx, size_t* dataIndex,
 199                                               ImplType buffer[],
 200                                               size_t bufferSize) {
 201   return 0;
 202 }
 203 inline AutoTraceLoggerLockGuard::AutoTraceLoggerLockGuard() {}
 204 inline AutoTraceLoggerLockGuard::~AutoTraceLoggerLockGuard() {}
 205 #endif
 206 using TraceLoggerDictionaryBuffer =
 207     TraceLoggerCollectorBuffer<JS::TraceLoggerDictionaryImpl>;
 208 using TraceLoggerIdBuffer = TraceLoggerCollectorBuffer<JS::TraceLoggerIdImpl>;
 209 using TraceLoggerTimeStampBuffer =
 210     TraceLoggerCollectorBuffer<JS::TraceLoggerTimeStampImpl>;
 211 using TraceLoggerDurationBuffer =
 212     TraceLoggerCollectorBuffer<JS::TraceLoggerDurationImpl>;
 213 using TraceLoggerLineNoBuffer =
 214     TraceLoggerCollectorBuffer<JS::TraceLoggerLineNoImpl>;
 215 using TraceLoggerColNoBuffer =
 216     TraceLoggerCollectorBuffer<JS::TraceLoggerColNoImpl>;
 217 };  // namespace JS
 218
 219 #endif /* js_TraceLoggerAPI_h */