1 // Copyright 2016 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_LIBPLATFORM_V8_TRACING_H_ 6 #define V8_LIBPLATFORM_V8_TRACING_H_ 7 8 #include <atomic> 9 #include <fstream> 10 #include <memory> 11 #include <unordered_set> 12 #include <vector> 13 14 #include "libplatform/libplatform-export.h" 15 #include "v8-platform.h" // NOLINT(build/include_directory) 16 17 namespace perfetto { 18 namespace trace_processor { 19 class TraceProcessorStorage; 20 } 21 class TracingSession; 22 } 23 24 namespace v8 { 25 26 namespace base { 27 class Mutex; 28 } // namespace base 29 30 namespace platform { 31 namespace tracing { 32 33 class TraceEventListener; 34 35 const int kTraceMaxNumArgs = 2; 36 37 class V8_PLATFORM_EXPORT TraceObject { 38 public: 39 union ArgValue { 40 V8_DEPRECATED("use as_uint ? true : false") bool as_bool; 41 uint64_t as_uint; 42 int64_t as_int; 43 double as_double; 44 const void* as_pointer; 45 const char* as_string; 46 }; 47 48 TraceObject() = default; 49 ~TraceObject(); 50 void Initialize( 51 char phase, const uint8_t* category_enabled_flag, const char* name, 52 const char* scope, uint64_t id, uint64_t bind_id, int num_args, 53 const char** arg_names, const uint8_t* arg_types, 54 const uint64_t* arg_values, 55 std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables, 56 unsigned int flags, int64_t timestamp, int64_t cpu_timestamp); 57 void UpdateDuration(int64_t timestamp, int64_t cpu_timestamp); 58 void InitializeForTesting( 59 char phase, const uint8_t* category_enabled_flag, const char* name, 60 const char* scope, uint64_t id, uint64_t bind_id, int num_args, 61 const char** arg_names, const uint8_t* arg_types, 62 const uint64_t* arg_values, 63 std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables, 64 unsigned int flags, int pid, int tid, int64_t ts, int64_t tts, 65 uint64_t duration, uint64_t cpu_duration); 66 pid()67 int pid() const { return pid_; } tid()68 int tid() const { return tid_; } phase()69 char phase() const { return phase_; } category_enabled_flag()70 const uint8_t* category_enabled_flag() const { 71 return category_enabled_flag_; 72 } name()73 const char* name() const { return name_; } scope()74 const char* scope() const { return scope_; } id()75 uint64_t id() const { return id_; } bind_id()76 uint64_t bind_id() const { return bind_id_; } num_args()77 int num_args() const { return num_args_; } arg_names()78 const char** arg_names() { return arg_names_; } arg_types()79 uint8_t* arg_types() { return arg_types_; } arg_values()80 ArgValue* arg_values() { return arg_values_; } arg_convertables()81 std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables() { 82 return arg_convertables_; 83 } flags()84 unsigned int flags() const { return flags_; } ts()85 int64_t ts() { return ts_; } tts()86 int64_t tts() { return tts_; } duration()87 uint64_t duration() { return duration_; } cpu_duration()88 uint64_t cpu_duration() { return cpu_duration_; } 89 90 private: 91 int pid_; 92 int tid_; 93 char phase_; 94 const char* name_; 95 const char* scope_; 96 const uint8_t* category_enabled_flag_; 97 uint64_t id_; 98 uint64_t bind_id_; 99 int num_args_ = 0; 100 const char* arg_names_[kTraceMaxNumArgs]; 101 uint8_t arg_types_[kTraceMaxNumArgs]; 102 ArgValue arg_values_[kTraceMaxNumArgs]; 103 std::unique_ptr<v8::ConvertableToTraceFormat> 104 arg_convertables_[kTraceMaxNumArgs]; 105 char* parameter_copy_storage_ = nullptr; 106 unsigned int flags_; 107 int64_t ts_; 108 int64_t tts_; 109 uint64_t duration_; 110 uint64_t cpu_duration_; 111 112 // Disallow copy and assign 113 TraceObject(const TraceObject&) = delete; 114 void operator=(const TraceObject&) = delete; 115 }; 116 117 class V8_PLATFORM_EXPORT TraceWriter { 118 public: 119 TraceWriter() = default; 120 virtual ~TraceWriter() = default; 121 virtual void AppendTraceEvent(TraceObject* trace_event) = 0; 122 virtual void Flush() = 0; 123 124 static TraceWriter* CreateJSONTraceWriter(std::ostream& stream); 125 static TraceWriter* CreateJSONTraceWriter(std::ostream& stream, 126 const std::string& tag); 127 128 static TraceWriter* CreateSystemInstrumentationTraceWriter(); 129 130 private: 131 // Disallow copy and assign 132 TraceWriter(const TraceWriter&) = delete; 133 void operator=(const TraceWriter&) = delete; 134 }; 135 136 class V8_PLATFORM_EXPORT TraceBufferChunk { 137 public: 138 explicit TraceBufferChunk(uint32_t seq); 139 140 void Reset(uint32_t new_seq); IsFull()141 bool IsFull() const { return next_free_ == kChunkSize; } 142 TraceObject* AddTraceEvent(size_t* event_index); GetEventAt(size_t index)143 TraceObject* GetEventAt(size_t index) { return &chunk_[index]; } 144 seq()145 uint32_t seq() const { return seq_; } size()146 size_t size() const { return next_free_; } 147 148 static const size_t kChunkSize = 64; 149 150 private: 151 size_t next_free_ = 0; 152 TraceObject chunk_[kChunkSize]; 153 uint32_t seq_; 154 155 // Disallow copy and assign 156 TraceBufferChunk(const TraceBufferChunk&) = delete; 157 void operator=(const TraceBufferChunk&) = delete; 158 }; 159 160 class V8_PLATFORM_EXPORT TraceBuffer { 161 public: 162 TraceBuffer() = default; 163 virtual ~TraceBuffer() = default; 164 165 virtual TraceObject* AddTraceEvent(uint64_t* handle) = 0; 166 virtual TraceObject* GetEventByHandle(uint64_t handle) = 0; 167 virtual bool Flush() = 0; 168 169 static const size_t kRingBufferChunks = 1024; 170 171 static TraceBuffer* CreateTraceBufferRingBuffer(size_t max_chunks, 172 TraceWriter* trace_writer); 173 174 private: 175 // Disallow copy and assign 176 TraceBuffer(const TraceBuffer&) = delete; 177 void operator=(const TraceBuffer&) = delete; 178 }; 179 180 // Options determines how the trace buffer stores data. 181 enum TraceRecordMode { 182 // Record until the trace buffer is full. 183 RECORD_UNTIL_FULL, 184 185 // Record until the user ends the trace. The trace buffer is a fixed size 186 // and we use it as a ring buffer during recording. 187 RECORD_CONTINUOUSLY, 188 189 // Record until the trace buffer is full, but with a huge buffer size. 190 RECORD_AS_MUCH_AS_POSSIBLE, 191 192 // Echo to console. Events are discarded. 193 ECHO_TO_CONSOLE, 194 }; 195 196 class V8_PLATFORM_EXPORT TraceConfig { 197 public: 198 typedef std::vector<std::string> StringList; 199 200 static TraceConfig* CreateDefaultTraceConfig(); 201 TraceConfig()202 TraceConfig() : enable_systrace_(false), enable_argument_filter_(false) {} GetTraceRecordMode()203 TraceRecordMode GetTraceRecordMode() const { return record_mode_; } GetEnabledCategories()204 const StringList& GetEnabledCategories() const { 205 return included_categories_; 206 } IsSystraceEnabled()207 bool IsSystraceEnabled() const { return enable_systrace_; } IsArgumentFilterEnabled()208 bool IsArgumentFilterEnabled() const { return enable_argument_filter_; } 209 SetTraceRecordMode(TraceRecordMode mode)210 void SetTraceRecordMode(TraceRecordMode mode) { record_mode_ = mode; } EnableSystrace()211 void EnableSystrace() { enable_systrace_ = true; } EnableArgumentFilter()212 void EnableArgumentFilter() { enable_argument_filter_ = true; } 213 214 void AddIncludedCategory(const char* included_category); 215 216 bool IsCategoryGroupEnabled(const char* category_group) const; 217 218 private: 219 TraceRecordMode record_mode_; 220 bool enable_systrace_ : 1; 221 bool enable_argument_filter_ : 1; 222 StringList included_categories_; 223 224 // Disallow copy and assign 225 TraceConfig(const TraceConfig&) = delete; 226 void operator=(const TraceConfig&) = delete; 227 }; 228 229 #if defined(_MSC_VER) 230 #define V8_PLATFORM_NON_EXPORTED_BASE(code) \ 231 __pragma(warning(suppress : 4275)) code 232 #else 233 #define V8_PLATFORM_NON_EXPORTED_BASE(code) code 234 #endif // defined(_MSC_VER) 235 236 class V8_PLATFORM_EXPORT TracingController V8_PLATFORM_NON_EXPORTED_BASE(v8::TracingController)237 : public V8_PLATFORM_NON_EXPORTED_BASE(v8::TracingController) { 238 public: 239 TracingController(); 240 ~TracingController() override; 241 242 #if defined(V8_USE_PERFETTO) 243 // Must be called before StartTracing() if V8_USE_PERFETTO is true. Provides 244 // the output stream for the JSON trace data. 245 void InitializeForPerfetto(std::ostream* output_stream); 246 // Provide an optional listener for testing that will receive trace events. 247 // Must be called before StartTracing(). 248 void SetTraceEventListenerForTesting(TraceEventListener* listener); 249 #else // defined(V8_USE_PERFETTO) 250 // The pointer returned from GetCategoryGroupEnabled() points to a value with 251 // zero or more of the following bits. Used in this class only. The 252 // TRACE_EVENT macros should only use the value as a bool. These values must 253 // be in sync with macro values in TraceEvent.h in Blink. 254 enum CategoryGroupEnabledFlags { 255 // Category group enabled for the recording mode. 256 ENABLED_FOR_RECORDING = 1 << 0, 257 // Category group enabled by SetEventCallbackEnabled(). 258 ENABLED_FOR_EVENT_CALLBACK = 1 << 2, 259 // Category group enabled to export events to ETW. 260 ENABLED_FOR_ETW_EXPORT = 1 << 3 261 }; 262 263 // Takes ownership of |trace_buffer|. 264 void Initialize(TraceBuffer* trace_buffer); 265 266 // v8::TracingController implementation. 267 const uint8_t* GetCategoryGroupEnabled(const char* category_group) override; 268 uint64_t AddTraceEvent( 269 char phase, const uint8_t* category_enabled_flag, const char* name, 270 const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args, 271 const char** arg_names, const uint8_t* arg_types, 272 const uint64_t* arg_values, 273 std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables, 274 unsigned int flags) override; 275 uint64_t AddTraceEventWithTimestamp( 276 char phase, const uint8_t* category_enabled_flag, const char* name, 277 const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args, 278 const char** arg_names, const uint8_t* arg_types, 279 const uint64_t* arg_values, 280 std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables, 281 unsigned int flags, int64_t timestamp) override; 282 void UpdateTraceEventDuration(const uint8_t* category_enabled_flag, 283 const char* name, uint64_t handle) override; 284 285 static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag); 286 #endif // !defined(V8_USE_PERFETTO) 287 288 void AddTraceStateObserver( 289 v8::TracingController::TraceStateObserver* observer) override; 290 void RemoveTraceStateObserver( 291 v8::TracingController::TraceStateObserver* observer) override; 292 293 void StartTracing(TraceConfig* trace_config); 294 void StopTracing(); 295 296 protected: 297 #if !defined(V8_USE_PERFETTO) 298 virtual int64_t CurrentTimestampMicroseconds(); 299 virtual int64_t CurrentCpuTimestampMicroseconds(); 300 #endif // !defined(V8_USE_PERFETTO) 301 302 private: 303 #if !defined(V8_USE_PERFETTO) 304 void UpdateCategoryGroupEnabledFlag(size_t category_index); 305 void UpdateCategoryGroupEnabledFlags(); 306 #endif // !defined(V8_USE_PERFETTO) 307 308 std::unique_ptr<base::Mutex> mutex_; 309 std::unique_ptr<TraceConfig> trace_config_; 310 std::atomic_bool recording_{false}; 311 std::unordered_set<v8::TracingController::TraceStateObserver*> observers_; 312 313 #if defined(V8_USE_PERFETTO) 314 std::ostream* output_stream_ = nullptr; 315 std::unique_ptr<perfetto::trace_processor::TraceProcessorStorage> 316 trace_processor_; 317 TraceEventListener* listener_for_testing_ = nullptr; 318 std::unique_ptr<perfetto::TracingSession> tracing_session_; 319 #else // !defined(V8_USE_PERFETTO) 320 std::unique_ptr<TraceBuffer> trace_buffer_; 321 #endif // !defined(V8_USE_PERFETTO) 322 323 // Disallow copy and assign 324 TracingController(const TracingController&) = delete; 325 void operator=(const TracingController&) = delete; 326 }; 327 328 #undef V8_PLATFORM_NON_EXPORTED_BASE 329 330 } // namespace tracing 331 } // namespace platform 332 } // namespace v8 333 334 #endif // V8_LIBPLATFORM_V8_TRACING_H_ 335