v8: add cpu profile APIs

Author: theanarkh

lib/v8.js

@@ -112,6 +112,8 @@ const binding = internalBinding('v8');
 const {
   cachedDataVersionTag,
   setFlagsFromString: _setFlagsFromString,
+  startCpuProfile: _startCpuProfile,
+  stopCpuProfile: _stopCpuProfile,
   isStringOneByteRepresentation: _isStringOneByteRepresentation,
   updateHeapStatisticsBuffer,
   updateHeapSpaceStatisticsBuffer,
@@ -166,6 +168,28 @@ function setFlagsFromString(flags) {
   _setFlagsFromString(flags);
 }
 
+/**
+ * Starting CPU Profile.
+ * @param {string} name
+ * @returns {void}
+ */
+function startCpuProfile(name) {
+  validateString(name, 'name');
+  const status = _startCpuProfile(name);
+
+}
+
+/**
+ * Stopping CPU Profile.
+ * @param {string} name
+ * @returns {string}
+ */
+function stopCpuProfile(name) {
+  validateString(name, 'name');
+  const profile = _stopCpuProfile(name);
+  return profile;
+}
+
 /**
  * Return whether this string uses one byte as underlying representation or not.
  * @param {string} content
@@ -478,4 +502,6 @@ module.exports = {
   setHeapSnapshotNearHeapLimit,
   GCProfiler,
   isStringOneByteRepresentation,
+  startCpuProfile,
+  stopCpuProfile,
 };

src/env-inl.h

@@ -916,6 +916,14 @@ inline void Environment::RemoveHeapSnapshotNearHeapLimitCallback(
                                         heap_limit);
 }
 
+inline void Environment::set_cpu_profiler(v8::CpuProfiler* cpu_profiler) {
+  cpu_profiler_ = cpu_profiler;
+}
+
+inline v8::CpuProfiler* Environment::cpu_profiler() {
+  return cpu_profiler_;
+}
+
 }  // namespace node
 
 // These two files depend on each other. Including base_object-inl.h after this

src/env.cc

@@ -1068,6 +1068,11 @@ Environment::~Environment() {
   }
 
   delete external_memory_accounter_;
+
+  if (!cpu_profiler_) {
+    cpu_profiler_->Dispose();
+    cpu_profiler_ = nullptr;
+  }
 }
 
 void Environment::InitializeLibuv() {

src/env.h

@@ -50,6 +50,7 @@
 #include "uv.h"
 #include "v8-external-memory-accounter.h"
 #include "v8.h"
+#include "v8-profiler.h"
 
 #if HAVE_OPENSSL
 #include <openssl/evp.h>
@@ -1011,6 +1012,9 @@ class Environment final : public MemoryRetainer {
   inline void set_heap_prof_interval(uint64_t interval);
   inline uint64_t heap_prof_interval() const;
 
+  void set_cpu_profiler(v8::CpuProfiler* cpu_profiler);
+  v8::CpuProfiler* cpu_profiler();
+
 #endif  // HAVE_INSPECTOR
 
   inline const EmbedderPreloadCallback& embedder_preload() const;
@@ -1244,6 +1248,8 @@ class Environment final : public MemoryRetainer {
   // track of the BackingStore for a given pointer.
   std::unordered_map<char*, std::unique_ptr<v8::BackingStore>>
       released_allocated_buffers_;
+
+  v8::CpuProfiler* cpu_profiler_ = nullptr;
 };
 
 }  // namespace node

src/node_v8.cc

@@ -28,13 +28,17 @@
 #include "node_external_reference.h"
 #include "util-inl.h"
 #include "v8.h"
+#include "v8-profiler.h"
 
 namespace node {
 namespace v8_utils {
 using v8::Array;
 using v8::BigInt;
 using v8::CFunction;
 using v8::Context;
+using v8::CpuProfile;
+using v8::CpuProfiler;
+using v8::CpuProfilingStatus;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
@@ -243,6 +247,62 @@ void SetFlagsFromString(const FunctionCallbackInfo<Value>& args) {
   V8::SetFlagsFromString(*flags, static_cast<size_t>(flags.length()));
 }
 
+class JSONOutputStream : public v8::OutputStream {
+  public:
+   JSONOutputStream() {}
+
+   int GetChunkSize() override { return 65536; }
+
+   void EndOfStream() override {}
+
+   WriteResult WriteAsciiChunk(char* data, const int size) override {
+     out_stream_.write(data, size);
+     return kContinue;
+   }
+
+   std::ostringstream& out_stream() { return out_stream_; }
+
+  private:
+   std::ostringstream out_stream_;
+};
+
+void StartCpuProfile(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args[0]->IsString());
+  String::Utf8Value name(env->isolate(), args[0]);
+  if (!env->cpu_profiler()) {
+    env->set_cpu_profiler(CpuProfiler::New(env->isolate()));
+  }
+  Local<String> title = String::NewFromUtf8(isolate,
+                                            *name,
+                                            NewStringType::kNormal,
+                                            name.length())
+                                            .ToLocalChecked();
+  CpuProfilingStatus status = env->cpu_profiler()->StartProfiling(title, true);
+  args.GetReturnValue().Set(Number::New(env->isolate(), static_cast<double>(status)));
+}
+
+void StopCpuProfile(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(args[0]->IsString());
+  String::Utf8Value name(env->isolate(), args[0]);
+  Local<String> title = String::NewFromUtf8(env->isolate(),
+                                            *name,
+                                            NewStringType::kNormal,
+                                            name.length())
+                                            .ToLocalChecked();
+  auto json_out_stream = std::make_unique<JSONOutputStream>();
+  if (env->cpu_profiler()) {
+    CpuProfile* profile = env->cpu_profiler()->StopProfiling(title);
+    if (profile) {
+      profile->Serialize(json_out_stream.get(),
+                          CpuProfile::SerializationFormat::kJSON);
+      profile->Delete();
+    }
+  }
+  args.GetReturnValue().Set(json_out_stream->out_stream().str());
+}
+
 static void IsStringOneByteRepresentation(
     const FunctionCallbackInfo<Value>& args) {
   CHECK_EQ(args.Length(), 1);
@@ -682,6 +742,9 @@ void Initialize(Local<Object> target,
   // Export symbols used by v8.setFlagsFromString()
   SetMethod(context, target, "setFlagsFromString", SetFlagsFromString);
 
+  SetMethod(context, target, "startCpuProfile", StartCpuProfile);
+  SetMethod(context, target, "stopCpuProfile", StopCpuProfile);
+
   // Export symbols used by v8.isStringOneByteRepresentation()
   SetFastMethodNoSideEffect(context,
                             target,
@@ -726,6 +789,8 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(GetCppHeapStatistics);
   registry->Register(IsStringOneByteRepresentation);
   registry->Register(fast_is_string_one_byte_representation_);
+  registry->Register(StartCpuProfile);
+  registry->Register(StopCpuProfile);
 }
 
 }  // namespace v8_utils