worker: set up child Isolate inside Worker thread

src/env.cc

@@ -186,8 +186,7 @@ Environment::Environment(IsolateData* isolate_data,
       trace_category_state_(isolate_, kTraceCategoryCount),
       stream_base_state_(isolate_, StreamBase::kNumStreamBaseStateFields),
       flags_(flags),
-      thread_id_(thread_id == static_cast<uint64_t>(-1) ?
-          AllocateThreadId() : thread_id),
+      thread_id_(thread_id == kNoThreadId ? AllocateThreadId() : thread_id),
       fs_stats_field_array_(isolate_, kFsStatsBufferLength),
       fs_stats_field_bigint_array_(isolate_, kFsStatsBufferLength),
       context_(context->GetIsolate(), context) {

src/env.h

@@ -619,7 +619,7 @@ class Environment {
   Environment(IsolateData* isolate_data,
               v8::Local<v8::Context> context,
               Flags flags = Flags(),
-              uint64_t thread_id = static_cast<uint64_t>(-1));
+              uint64_t thread_id = kNoThreadId);
   ~Environment();
 
   void Start(bool start_profiler_idle_notifier);
@@ -771,6 +771,7 @@ class Environment {
   inline void set_has_run_bootstrapping_code(bool has_run_bootstrapping_code);
 
   static uint64_t AllocateThreadId();
+  static constexpr uint64_t kNoThreadId = -1;
 
   inline bool is_main_thread() const;
   inline bool owns_process_state() const;

src/node_worker.cc

@@ -152,7 +152,7 @@ class WorkerThreadData {
   }
 
  private:
-  Worker* w_;
+  Worker* const w_;
   uv_loop_t loop_;
   DeleteFnPtr<ArrayBufferAllocator, FreeArrayBufferAllocator>
     array_buffer_allocator_;
@@ -181,7 +181,7 @@ void Worker::Run() {
     bool inspector_started = false;
 
     DeleteFnPtr<Environment, FreeEnvironment> env_;
-    OnScopeLeave cleanup_env([&]{
+    OnScopeLeave cleanup_env([&]() {
       if (!env_) return;
       env_->set_can_call_into_js(false);
       Isolate::DisallowJavascriptExecutionScope disallow_js(isolate_,
@@ -204,7 +204,7 @@ void Worker::Run() {
         RunAtExit(env_.get());
 #if NODE_USE_V8_PLATFORM && HAVE_INSPECTOR
           if (inspector_started)
-            WaitForWorkerInspectorToStop(env_.get());
+              WaitForWorkerInspectorToStop(env_.get());
 #endif
 
         {

test/parallel/test-worker-prof.js

@@ -0,0 +1,41 @@
+'use strict';
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const fs = require('fs');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const { Worker } = require('worker_threads');
+
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
+// Test that --prof also tracks Worker threads.
+// Refs: https://github.com/nodejs/node/issues/24016
+
+if (process.argv[2] === 'child') {
+  const spin = `
+  const start = Date.now();
+  while (Date.now() - start < 200);
+  `;
+  new Worker(spin, { eval: true });
+  eval(spin);
+  return;
+}
+
+tmpdir.refresh();
+process.chdir(tmpdir.path);
+spawnSync(process.execPath, ['--prof', __filename, 'child']);
+const logfiles = fs.readdirSync('.').filter((name) => /\.log$/.test(name));
+assert.strictEqual(logfiles.length, 2);  // Parent thread + child thread.
+
+for (const logfile of logfiles) {
+  const lines = fs.readFileSync(logfile, 'utf8').split('\n');
+  const ticks = lines.filter((line) => /^tick,/.test(line)).length;
+
+  // Test that at least 20 ticks have been recorded for both parent and child
+  // threads. When not tracking Worker threads, only 1 or 2 ticks would
+  // have been recorded.
+  // When running locally on x64 Linux, this number is usually at least 150
+  // for both threads, so 15 seems like a very safe threshold.
+  assert(ticks >= 15, `${ticks} >= 15`);
+}