worker: add cpu profile APIs for worker

Author: theanarkh

doc/api/errors.md

@@ -826,6 +826,36 @@ when an error occurs (and is caught) during the creation of the
 context, for example, when the allocation fails or the maximum call stack
 size is reached when the context is created.
 
+<aid="ERR_CPU_PROFILE_ALREADY_STARTED"></a>
+
+### `ERR_CPU_PROFILE_ALREADY_STARTED`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The CPU profile with the given name is already started.
+
+<aid="ERR_CPU_PROFILE_NOT_STARTED"></a>
+
+### `ERR_CPU_PROFILE_NOT_STARTED`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The CPU profile with the given name is not started.
+
+<aid="ERR_CPU_PROFILE_TOO_MANY"></a>
+
+### `ERR_CPU_PROFILE_TOO_MANY`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+There are too many CPU profiles being collected.
+
 <aid="ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED"></a>
 
 ### `ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED`

doc/api/worker_threads.md

@@ -1957,6 +1957,20 @@ this matches its values.
 
 If the worker has stopped, the return value is an empty object.
 
+### `worker.startCpuProfile(name)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* name:{string}
+* Returns:{Promise}
+
+Starting a CPU profile with the given `name`, then return a Promise that fulfills
+with an error or an object which has a `stop` method. Calling the `stop` method will
+stop collecting the profile, then return a Promise that fulfills with an error or the
+profile data.
+
 ### `worker.stderr`
 
 <!-- YAML

lib/internal/worker.js

@@ -506,6 +506,40 @@ class Worker extends EventEmitter{
 };
 });
 }
+
+// TODO(theanarkh): add options, such as sample_interval, CpuProfilingMode
+startCpuProfile(name){
+validateString(name,'name');
+conststartTaker=this[kHandle]?.startCpuProfile(name);
+returnnewPromise((resolve,reject)=>{
+if(!startTaker)returnreject(newERR_WORKER_NOT_RUNNING());
+startTaker.ondone=(err)=>{
+if(err){
+returnreject(err);
+}
+letstopped=false;
+conststop=()=>{
+if(stopped){
+return;
+}
+stopped=true;
+conststopTaker=this[kHandle]?.stopCpuProfile(name);
+returnnewPromise((resolve,reject)=>{
+if(!stopTaker)returnreject(newERR_WORKER_NOT_RUNNING());
+stopTaker.ondone=(status,profile)=>{
+if(err){
+returnreject(err);
+}
+resolve(profile);
+};
+});
+};
+resolve({
+ stop,
+});
+};
+});
+}
 }
 
 /**

src/async_wrap.h

@@ -79,6 +79,7 @@ namespace node{
 V(UDPWRAP) \
 V(SIGINTWATCHDOG) \
 V(WORKER) \
+V(WORKERCPUPROFILE) \
 V(WORKERCPUUSAGE) \
 V(WORKERHEAPSNAPSHOT) \
 V(WORKERHEAPSTATISTICS) \

src/env-inl.h

@@ -915,7 +915,6 @@ inline void Environment::RemoveHeapSnapshotNearHeapLimitCallback(
  isolate_->RemoveNearHeapLimitCallback(Environment::NearHeapLimitCallback,
  heap_limit);
 }
-
 } // namespace node
 
 // These two files depend on each other. Including base_object-inl.h after this

src/env.cc

@@ -1068,6 +1068,13 @@ Environment::~Environment(){
  }
 
 delete external_memory_accounter_;
+if (cpu_profiler_){
+for (auto& it : pending_profiles_){
+ cpu_profiler_->Stop(it.second);
+ }
+ cpu_profiler_->Dispose();
+ cpu_profiler_ = nullptr;
+ }
 }
 
 voidEnvironment::InitializeLibuv(){
@@ -2231,4 +2238,35 @@ void Environment::MemoryInfo(MemoryTracker* tracker) const{
 voidEnvironment::RunWeakRefCleanup(){
 isolate()->ClearKeptObjects();
 }
+
+v8::CpuProfilingResult Environment::StartCpuProfile(
+ std::string_view name){
+if (!cpu_profiler_){
+ cpu_profiler_ = v8::CpuProfiler::New(isolate_);
+ }
+ Local<Value> title = node::ToV8Value(context(),
+ name,
+isolate()).ToLocalChecked();
+ v8::CpuProfilingResult result = cpu_profiler_->Start(title.As<String>(),
+true);
+if (result.status == v8::CpuProfilingStatus::kStarted){
+ pending_profiles_.emplace(name, result.id);
+ }
+return result;
+}
+
+v8::CpuProfile* Environment::StopCpuProfile(
+ std::string_view name){
+if (!cpu_profiler_){
+returnnullptr;
+ }
+auto it = pending_profiles_.find(std::string(name));
+if (it == pending_profiles_.end()){
+returnnullptr;
+ }
+ v8::CpuProfile* profile = cpu_profiler_->Stop(it->second);
+ pending_profiles_.erase(it);
+return profile;
+}
+
 } // namespace node

src/env.h

@@ -49,6 +49,7 @@
 #include"util.h"
 #include"uv.h"
 #include"v8-external-memory-accounter.h"
+#include"v8-profiler.h"
 #include"v8.h"
 
 #if HAVE_OPENSSL
@@ -1048,6 +1049,9 @@ class Environment final : public MemoryRetainer{
 
 inlinevoidRemoveHeapSnapshotNearHeapLimitCallback(size_t heap_limit);
 
+ v8::CpuProfilingResult StartCpuProfile(std::string_view name);
+ v8::CpuProfile* StopCpuProfile(std::string_view name);
+
 // Field identifiers for exit_info_
 enum ExitInfoField{
 kExiting = 0,
@@ -1244,6 +1248,9 @@ 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;
+ std::unordered_map<std::string, v8::ProfilerId> pending_profiles_;
 };
 
 } // namespace node

src/env_properties.h

@@ -483,6 +483,7 @@
  V(tcp_constructor_template, v8::FunctionTemplate) \
  V(tty_constructor_template, v8::FunctionTemplate) \
  V(write_wrap_template, v8::ObjectTemplate) \
+ V(worker_cpu_profile_taker_template, v8::ObjectTemplate) \
  V(worker_cpu_usage_taker_template, v8::ObjectTemplate) \
  V(worker_heap_snapshot_taker_template, v8::ObjectTemplate) \
  V(worker_heap_statistics_taker_template, v8::ObjectTemplate) \

src/node_errors.h

@@ -48,6 +48,9 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details);
 V(ERR_CLOSED_MESSAGE_PORT, Error) \
 V(ERR_CONSTRUCT_CALL_REQUIRED, TypeError) \
 V(ERR_CONSTRUCT_CALL_INVALID, TypeError) \
+V(ERR_CPU_PROFILE_ALREADY_STARTED, Error) \
+V(ERR_CPU_PROFILE_NOT_STARTED, Error) \
+V(ERR_CPU_PROFILE_TOO_MANY, Error) \
 V(ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED, Error) \
 V(ERR_CRYPTO_INITIALIZATION_FAILED, Error) \
 V(ERR_CRYPTO_INVALID_AUTH_TAG, TypeError) \