Store profiling context in the CPED

Author: szegedi

bindings/profilers/wall.cc

@@ -323,7 +323,7 @@ void SignalHandler::HandleProfilerSignal(int sig,
   auto time_from = Now();
   old_handler(sig, info, context);
   auto time_to = Now();
-  prof->PushContext(time_from, time_to, cpu_time);
+  prof->PushContext(time_from, time_to, cpu_time, isolate);
 }
 #else
 class SignalHandler {
@@ -509,6 +509,8 @@ WallProfiler::WallProfiler(std::chrono::microseconds samplingPeriod,
 #endif
   jsArray_ = v8::Global<v8::Uint32Array>(isolate, jsArray);
   std::fill(fields_, fields_ + kFieldCount, 0);
+
+  cpedSymbol_ = v8::Global<v8::Symbol>(isolate, v8::Symbol::New(isolate));
 }
 
 WallProfiler::~WallProfiler() {
@@ -953,23 +955,66 @@ v8::CpuProfiler* WallProfiler::CreateV8CpuProfiler() {
 }
 
 v8::Local<v8::Value> WallProfiler::GetContext(Isolate* isolate) {
-  auto context = GetContextPtr();
+  auto context = GetContextPtr(isolate);
   if (!context) return v8::Undefined(isolate);
   return context->Get(isolate);
 }
 
 void WallProfiler::SetContext(Isolate* isolate, Local<Value> value) {
+  auto cped = isolate->GetContinuationPreservedEmbedderData();
+  // No Node AsyncContextFrame in this continuation yet
+  if (!cped->IsObject()) return;
+
+  auto cpedObj = cped.As<Object>();
+  auto localSymbol = cpedSymbol_.Get(isolate);
+  auto v8Ctx = isolate->GetCurrentContext();
+  auto maybeProfData = cpedObj->Get(v8Ctx, localSymbol);
+  if (maybeProfData.IsEmpty()) return;
+  auto profData = maybeProfData.ToLocalChecked();
+
+  ContextPtr* contextPtr = nullptr;
+  if (profData->IsNullOrUndefined()) {
+    contextPtr = new ContextPtr();
+    auto maybeSetResult = cpedObj->Set(v8Ctx, localSymbol, External::New(isolate, contextPtr));
+    if (maybeSetResult.IsNothing()) {
+      delete contextPtr;
+      return;
+    }
+
+    // Register a callback to delete contextPtr when the CPED object is GCed
+    Persistent<Object>(isolate, cpedObj).SetWeak(contextPtr, [](const WeakCallbackInfo<ContextPtr>& data) {
+      // Using SetSecondPassCallback as shared_ptr can trigger ~Global and any V8 API use needs to be in the second pass
+      data.SetSecondPassCallback([](const WeakCallbackInfo<ContextPtr>& data) {
+        delete data.GetParameter();
+      });
+    }, WeakCallbackType::kParameter);
+  } else {
+    contextPtr = reinterpret_cast<ContextPtr*>(profData.As<External>()->Value());
+  }
+
+  // Signal-atomic update
   std::atomic_signal_fence(std::memory_order_release);
   std::atomic_store_explicit(
-    &curContext_,
+    contextPtr,
     value->IsNullOrUndefined()
       ? std::shared_ptr<Global<Value>>()
       : std::make_shared<Global<Value>>(isolate, value),
     std::memory_order_relaxed);
 }
 
-ContextPtr WallProfiler::GetContextPtr() {
-  auto contextPtr = atomic_load_explicit(&curContext_, std::memory_order_relaxed);
+ContextPtr WallProfiler::GetContextPtr(Isolate* isolate) {
+  auto cped = isolate->GetContinuationPreservedEmbedderData(); // signal safe?
+  if (!cped->IsObject()) return std::shared_ptr<Global<Value>>();
+
+  auto cpedObj = cped.As<Object>();
+  auto localSymbol = cpedSymbol_.Get(isolate); // signal safe?
+  auto maybeProfData = cpedObj->Get(isolate->GetCurrentContext(), localSymbol); // signal safe?
+  if (maybeProfData.IsEmpty()) return std::shared_ptr<Global<Value>>();
+  auto profData = maybeProfData.ToLocalChecked();
+
+  if (profData->IsNullOrUndefined()) return std::shared_ptr<Global<Value>>();
+
+  auto contextPtr = std::atomic_load_explicit(reinterpret_cast<ContextPtr*>(profData.As<External>()->Value()), std::memory_order_relaxed);
   std::atomic_signal_fence(std::memory_order_acquire);
   return contextPtr;
 }
@@ -1001,12 +1046,14 @@ NAN_METHOD(WallProfiler::Dispose) {
 
 void WallProfiler::PushContext(int64_t time_from,
                                int64_t time_to,
-                               int64_t cpu_time) {
+                               int64_t cpu_time,
+                               Isolate* isolate) {
   // Be careful this is called in a signal handler context therefore all
   // operations must be async signal safe (in particular no allocations).
   // Our ring buffer avoids allocations.
   if (contexts_.size() < contexts_.capacity()) {
-    contexts_.push_back({GetContextPtr(), time_from, time_to, cpu_time});
+    HandleScope handle_scope(isolate); // will this fly in a signal handler?
+    contexts_.push_back({GetContextPtr(isolate), time_from, time_to, cpu_time});
     std::atomic_fetch_add_explicit(
         reinterpret_cast<std::atomic<uint32_t>*>(&fields_[kSampleCount]),
         1U,

bindings/profilers/wall.hh

@@ -51,7 +51,7 @@ class WallProfiler : public Nan::ObjectWrap {
   // avoid heap allocation. Need to figure out the right move/copy semantics in
   // and out of the ring buffer.
 
-  ContextPtr curContext_;
+  v8::Global<v8::Symbol> cpedSymbol_;
 
   std::atomic<CollectionMode> collectionMode_;
   std::atomic<uint64_t> noCollectCallCount_;
@@ -95,7 +95,7 @@ class WallProfiler : public Nan::ObjectWrap {
                                    int64_t startCpuTime);
 
   bool waitForSignal(uint64_t targetCallCount = 0);
-  ContextPtr GetContextPtr();
+  ContextPtr GetContextPtr(v8::Isolate* isolate);
 
  public:
   /**
@@ -115,7 +115,7 @@ class WallProfiler : public Nan::ObjectWrap {
 
   v8::Local<v8::Value> GetContext(v8::Isolate*);
   void SetContext(v8::Isolate*, v8::Local<v8::Value>);
-  void PushContext(int64_t time_from, int64_t time_to, int64_t cpu_time);
+  void PushContext(int64_t time_from, int64_t time_to, int64_t cpu_time, v8::Isolate* isolate);
   Result StartImpl();
   std::string StartInternal();
   Result StopImpl(bool restart, v8::Local<v8::Value>& profile);