worker: add cpu profile APIs for worker

Author: theanarkh

doc/api/errors.md

@@ -826,6 +826,24 @@ 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`
+
+The CPU profile with the given name is already started.
+
+<aid="ERR_CPU_PROFILE_NOT_STARTED"></a>
+
+### `ERR_CPU_PROFILE_NOT_STARTED`
+
+The CPU profile with the given name is not started.
+
+<aid="ERR_CPU_PROFILE_TOO_MANY"></a>
+
+### `ERR_CPU_PROFILE_TOO_MANY`
+
+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,18 @@ 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` for the worker thread. The profile can be stopped
+with [`worker.stopCpuProfile(name)`][].
+
 ### `worker.stderr`
 
 <!-- YAML
@@ -1995,6 +2007,18 @@ inside the worker thread. If `stdout: true` was not passed to the
 [`Worker`][] constructor, then data is piped to the parent thread's
 [`process.stdout`][] stream.
 
+### `worker.stopCpuProfile(name)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* name:{string}
+* Returns:{Promise}
+
+Stopping a CPU profile with the given `name` which is passed to [`worker.startCpuProfile(name)`][]
+for the worker thread. Returns a Promise that fulfills with the profile data or throws an error.
+
 ### `worker.terminate()`
 
 <!--YAML
@@ -2176,6 +2200,8 @@ thread spawned will spawn another until the application crashes.
 [`worker.SHARE_ENV`]: #workershare_env
 [`worker.on('message')`]: #event-message_1
 [`worker.postMessage()`]: #workerpostmessagevalue-transferlist
+[`worker.startCpuProfile(name)`]: #workerstartcpuprofilename
+[`worker.stopCpuProfile(name)`]: #workerstopcpuprofilename
 [`worker.terminate()`]: #workerterminate
 [`worker.threadId`]: #workerthreadid_1
 [`worker.threadName`]: #workerthreadname_1

lib/internal/errors.js

@@ -1163,6 +1163,9 @@ E('ERR_CONSOLE_WRITABLE_STREAM',
 'Console expects a writable stream instance for %s',TypeError);
 E('ERR_CONSTRUCT_CALL_REQUIRED','Class constructor %s cannot be invoked without `new`',TypeError);
 E('ERR_CONTEXT_NOT_INITIALIZED','context used is not initialized',Error);
+E('ERR_CPU_PROFILE_ALREADY_STARTED','CPU profile already started with name(%s)',Error);
+E('ERR_CPU_PROFILE_NOT_STARTED','CPU profile not started with name(%s)',Error);
+E('ERR_CPU_PROFILE_TOO_MANY','There are too many CPU profiles',Error);
 E('ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED',
 'Custom engines not supported by this OpenSSL',Error);
 E('ERR_CRYPTO_ECDH_INVALID_FORMAT','Invalid ECDH format: %s',TypeError);

lib/internal/worker.js

@@ -36,6 +36,9 @@ const{
 
 consterrorCodes=require('internal/errors').codes;
 const{
+ERR_CPU_PROFILE_ALREADY_STARTED,
+ERR_CPU_PROFILE_NOT_STARTED,
+ERR_CPU_PROFILE_TOO_MANY,
 ERR_WORKER_NOT_RUNNING,
 ERR_WORKER_PATH,
 ERR_WORKER_UNSERIALIZABLE_ERROR,
@@ -506,6 +509,32 @@ class Worker extends EventEmitter{
 };
 });
 }
+
+// TODO(theanarkh): add options
+startCpuProfile(name){
+validateString(name,'name');
+conststartTaker=this[kHandle]?.startCpuProfile(name);
+returnnewPromise((resolve,reject)=>{
+if(!startTaker)returnreject(newERR_WORKER_NOT_RUNNING());
+startTaker.ondone=(status)=>{
+if(status===1)returnreject(newERR_CPU_PROFILE_ALREADY_STARTED(name));
+if(status===2)returnreject(newERR_CPU_PROFILE_TOO_MANY());
+resolve();
+};
+});
+}
+
+stopCpuProfile(name){
+validateString(name,'name');
+conststopTaker=this[kHandle]?.stopCpuProfile(name);
+returnnewPromise((resolve,reject)=>{
+if(!stopTaker)returnreject(newERR_WORKER_NOT_RUNNING());
+stopTaker.ondone=(status,profile)=>{
+if(status===1)returnreject(newERR_CPU_PROFILE_NOT_STARTED(name));
+resolve(profile);
+};
+});
+}
 }
 
 /**

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

@@ -557,6 +557,13 @@ inline uint64_t Environment::heap_prof_interval() const{
 return heap_prof_interval_;
 }
 
+inline v8::CpuProfiler* Environment::cpu_profiler(){
+if (!cpu_profiler_){
+ cpu_profiler_ = v8::CpuProfiler::New(isolate_);
+ }
+return cpu_profiler_;
+}
+
 #endif// HAVE_INSPECTOR
 
 inline

src/env.cc

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

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
@@ -1011,6 +1012,8 @@ class Environment final : public MemoryRetainer{
 inlinevoidset_heap_prof_interval(uint64_t interval);
 inlineuint64_theap_prof_interval() const;
 
+inline v8::CpuProfiler* cpu_profiler();
+
 #endif// HAVE_INSPECTOR
 
 inlineconst EmbedderPreloadCallback& embedder_preload() const;
@@ -1244,6 +1247,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/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) \