Move GetAsyncId and GC callbacks out of the header file.

Use relaxed load/store with appropriate signal fences for cheaper reading/writing of gcCount.

Author: szegedi

bindings/profilers/wall.cc

@@ -531,6 +531,7 @@ WallProfiler::WallProfiler(std::chrono::microseconds samplingPeriod,
 
   curContext_.store(&context1_, std::memory_order_relaxed);
   collectionMode_.store(CollectionMode::kNoCollect, std::memory_order_relaxed);
+  gcCount.store(0, std::memory_order_relaxed);
 
   // TODO: bind to this isolate? Would fix the Dispose(nullptr) issue.
   auto isolate = v8::Isolate::GetCurrent();
@@ -543,7 +544,6 @@ WallProfiler::WallProfiler(std::chrono::microseconds samplingPeriod,
   jsArray_ = v8::Global<v8::Uint32Array>(isolate, jsArray);
   std::fill(fields_, fields_ + kFieldCount, 0);
 
-  gcCount = 0;
   isolate->AddGCPrologueCallback(&GCPrologueCallback, this);
   isolate->AddGCEpilogueCallback(&GCEpilogueCallback, this);
 }
@@ -1044,6 +1044,42 @@ NAN_METHOD(WallProfiler::Dispose) {
   delete profiler;
 }
 
+int64_t GetAsyncIdNoGC(v8::Isolate* isolate) {
+  return isolate->InContext()
+             ? static_cast<int64_t>(
+                   node::AsyncHooksGetExecutionAsyncId(isolate))
+             : -1;
+}
+
+int64_t WallProfiler::GetAsyncId(v8::Isolate* isolate) {
+  auto curGcCount = gcCount.load(std::memory_order_relaxed);
+  std::atomic_signal_fence(std::memory_order_acquire);
+  if (curGcCount > 0) {
+    return gcAsyncId;
+  }
+  return GetAsyncIdNoGC(isolate);
+}
+
+void WallProfiler::OnGCStart(v8::Isolate* isolate) {
+  auto curCount = gcCount.load(std::memory_order_relaxed);
+  std::atomic_signal_fence(std::memory_order_acquire);
+  if (curCount == 0) {
+    gcAsyncId = GetAsyncIdNoGC(isolate);
+  }
+  gcCount.store(curCount + 1, std::memory_order_relaxed);
+  std::atomic_signal_fence(std::memory_order_release);
+}
+
+void WallProfiler::OnGCEnd() {
+  auto newCount = gcCount.load(std::memory_order_relaxed) - 1;
+  std::atomic_signal_fence(std::memory_order_acquire);
+  gcCount.store(newCount, std::memory_order_relaxed);
+  std::atomic_signal_fence(std::memory_order_release);
+  if (newCount == 0) {
+    gcAsyncId = -1;
+  }
+}
+
 void WallProfiler::PushContext(int64_t time_from,
                                int64_t time_to,
                                int64_t cpu_time,

bindings/profilers/wall.hh

@@ -152,29 +152,9 @@ class WallProfiler : public Nan::ObjectWrap {
     return threadCpuStopWatch_.GetAndReset();
   }
 
-  int64_t GetAsyncId(v8::Isolate* isolate) const {
-    if (gcCount > 0) {
-      return gcAsyncId;
-    } else if (isolate->InContext()) {
-      return static_cast<int64_t>(node::AsyncHooksGetExecutionAsyncId(isolate));
-    }
-    return -1;
-  }
-
-  void OnGCStart(v8::Isolate* isolate) {
-    if (gcCount == 0) {
-      gcAsyncId = GetAsyncId(isolate);
-      gcCount = 1;
-    } else {
-      ++gcCount;
-    }
-  }
-
-  void OnGCEnd() {
-    if (--gcCount == 0) {
-      gcAsyncId = -1;
-    }
-  }
+  int64_t GetAsyncId(v8::Isolate* isolate);
+  void OnGCStart(v8::Isolate* isolate);
+  void OnGCEnd();
 
   static NAN_METHOD(New) GENERAL_REGS_ONLY;
   static NAN_METHOD(Start);