tracing: Update to use new Platform tracing apis

V8 modified the platform API to accept a tracing controller at platform creation time that is required to be present for the lifetime of the platform if tracing will every be enabled. This will simplify the implementation of a v8::Platform subclass for node. PR-URL: nodejs/node#14001 Reviewed-By: Anna Henningsen <[email protected]> Reviewed-By: Ben Noordhuis <[email protected]> Reviewed-By: Tobias Nießen <[email protected]>
brave · Sep 27, 2017 · 7535fd3 · 7535fd3
1 parent 803470e
commit 7535fd3
Show file tree

Hide file tree

Showing 5 changed files with 37 additions and 37 deletions.
diff --git a/src/node.cc b/src/node.cc
@@ -213,12 +213,15 @@ static node::DebugOptions debug_options;
 static struct {
 #if NODE_USE_V8_PLATFORM
   void Initialize(int thread_pool_size) {
+    tracing_agent_ =
+      trace_enabled ? new tracing::Agent() : nullptr;
     platform_ = v8::platform::CreateDefaultPlatform(
-        thread_pool_size,
-        v8::platform::IdleTaskSupport::kDisabled,
-        v8::platform::InProcessStackDumping::kDisabled);
+      thread_pool_size, v8::platform::IdleTaskSupport::kDisabled,
+      v8::platform::InProcessStackDumping::kDisabled,
+      trace_enabled ? tracing_agent_->GetTracingController() : nullptr);
     V8::InitializePlatform(platform_);
-    tracing::TraceEventHelper::SetCurrentPlatform(platform_);
+    tracing::TraceEventHelper::SetTracingController(
+      trace_enabled ? tracing_agent_->GetTracingController() : nullptr);
   }
 
   void PumpMessageLoop(Isolate* isolate) {

diff --git a/src/tracing/agent.cc b/src/tracing/agent.cc
@@ -12,20 +12,18 @@ namespace tracing {
 using v8::platform::tracing::TraceConfig;
 using std::string;
 
-Agent::Agent() {}
-
-void Agent::Start(v8::Platform* platform, const string& enabled_categories) {
-  platform_ = platform;
-
+Agent::Agent() {
   int err = uv_loop_init(&tracing_loop_);
   CHECK_EQ(err, 0);
 
   NodeTraceWriter* trace_writer = new NodeTraceWriter(&tracing_loop_);
   TraceBuffer* trace_buffer = new NodeTraceBuffer(
       NodeTraceBuffer::kBufferChunks, trace_writer, &tracing_loop_);
-
   tracing_controller_ = new TracingController();
+  tracing_controller_->Initialize(trace_buffer);
+}
 
+void Agent::Start(const string& enabled_categories) {
   TraceConfig* trace_config = new TraceConfig();
   if (!enabled_categories.empty()) {
     std::stringstream category_list(enabled_categories);
@@ -42,27 +40,25 @@ void Agent::Start(v8::Platform* platform, const string& enabled_categories) {
   // This thread should be created *after* async handles are created
   // (within NodeTraceWriter and NodeTraceBuffer constructors).
   // Otherwise the thread could shut down prematurely.
-  err = uv_thread_create(&thread_, ThreadCb, this);
+  int err = uv_thread_create(&thread_, ThreadCb, this);
   CHECK_EQ(err, 0);
 
-  tracing_controller_->Initialize(trace_buffer);
   tracing_controller_->StartTracing(trace_config);
-  v8::platform::SetTracingController(platform, tracing_controller_);
+  started_ = true;
 }
 
 void Agent::Stop() {
-  if (!IsStarted()) {
+  if (!started_) {
     return;
   }
   // Perform final Flush on TraceBuffer. We don't want the tracing controller
   // to flush the buffer again on destruction of the V8::Platform.
   tracing_controller_->StopTracing();
   tracing_controller_->Initialize(nullptr);
-  tracing_controller_ = nullptr;
+  started_ = false;
 
   // Thread should finish when the tracing loop is stopped.
   uv_thread_join(&thread_);
-  v8::platform::SetTracingController(platform_, nullptr);
 }
 
 // static

diff --git a/src/tracing/agent.h b/src/tracing/agent.h
@@ -11,17 +11,18 @@ namespace tracing {
 
 class Agent {
  public:
-  explicit Agent();
-  void Start(v8::Platform* platform, const std::string& enabled_categories);
+  Agent();
+  void Start(const std::string& enabled_categories);
   void Stop();
 
+  TracingController* GetTracingController() { return tracing_controller_; }
+
  private:
-  bool IsStarted() { return platform_ != nullptr; }
   static void ThreadCb(void* arg);
 
   uv_thread_t thread_;
   uv_loop_t tracing_loop_;
-  v8::Platform* platform_ = nullptr;
+  bool started_ = false;
   TracingController* tracing_controller_ = nullptr;
 };
 

diff --git a/src/tracing/trace_event.cc b/src/tracing/trace_event.cc
@@ -3,14 +3,14 @@
 namespace node {
 namespace tracing {
 
-v8::Platform* platform_ = nullptr;
+v8::TracingController* controller_ = nullptr;
 
-void TraceEventHelper::SetCurrentPlatform(v8::Platform* platform) {
-  platform_ = platform;
+void TraceEventHelper::SetTracingController(v8::TracingController* controller) {
+  controller_ = controller;
 }
 
-v8::Platform* TraceEventHelper::GetCurrentPlatform() {
-  return platform_;
+v8::TracingController* TraceEventHelper::GetTracingController() {
+  return controller_;
 }
 
 }  // namespace tracing

diff --git a/src/tracing/trace_event.h b/src/tracing/trace_event.h
@@ -70,7 +70,7 @@ enum CategoryGroupEnabledFlags {
 // const uint8_t*
 //     TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(const char* category_group)
 #define TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED              \
-  node::tracing::TraceEventHelper::GetCurrentPlatform() \
+  node::tracing::TraceEventHelper::GetTracingController() \
       ->GetCategoryGroupEnabled
 
 // Get the number of times traces have been recorded. This is used to implement
@@ -99,7 +99,7 @@ enum CategoryGroupEnabledFlags {
 //     const char* name,
 //     uint64_t id)
 #define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION             \
-  node::tracing::TraceEventHelper::GetCurrentPlatform() \
+  node::tracing::TraceEventHelper::GetTracingController() \
       ->UpdateTraceEventDuration
 
 // Defines atomic operations used internally by the tracing system.
@@ -258,8 +258,8 @@ extern intptr_t kRuntimeCallStatsTracingEnabled;
 
 class TraceEventHelper {
  public:
-  static v8::Platform* GetCurrentPlatform();
-  static void SetCurrentPlatform(v8::Platform* platform);
+  static v8::TracingController* GetTracingController();
+  static void SetTracingController(v8::TracingController* controller);
 };
 
 // TraceID encapsulates an ID that can either be an integer or pointer. Pointers
@@ -396,21 +396,21 @@ static inline uint64_t AddTraceEventImpl(
     const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
     const char** arg_names, const uint8_t* arg_types,
     const uint64_t* arg_values, unsigned int flags) {
-  std::unique_ptr<v8::ConvertableToTraceFormat> arg_convertables[2];
+  std::unique_ptr<v8::ConvertableToTraceFormat> arg_convertibles[2];
   if (num_args > 0 && arg_types[0] == TRACE_VALUE_TYPE_CONVERTABLE) {
-    arg_convertables[0].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
+    arg_convertibles[0].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
         static_cast<intptr_t>(arg_values[0])));
   }
   if (num_args > 1 && arg_types[1] == TRACE_VALUE_TYPE_CONVERTABLE) {
-    arg_convertables[1].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
+    arg_convertibles[1].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
         static_cast<intptr_t>(arg_values[1])));
   }
   // DCHECK(num_args <= 2);
-  v8::Platform* platform =
-      node::tracing::TraceEventHelper::GetCurrentPlatform();
-  return platform->AddTraceEvent(phase, category_group_enabled, name, scope, id,
-                                 bind_id, num_args, arg_names, arg_types,
-                                 arg_values, arg_convertables, flags);
+  v8::TracingController* controller =
+      node::tracing::TraceEventHelper::GetTracingController();
+  return controller->AddTraceEvent(phase, category_group_enabled, name, scope, id,
+                                   bind_id, num_args, arg_names, arg_types,
+                                   arg_values, arg_convertibles, flags);
 }
 
 // Define SetTraceValue for each allowed type. It stores the type and