cli: implement --cpu-prof[-path]

doc/api/cli.md

@@ -75,6 +75,37 @@ $ node --completion-bash > node_bash_completion
 $ source node_bash_completion
 ```
 
+### `--cpu-prof`
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Starts the V8 CPU profiler on start up, and writes the CPU profile to disk
+before exit. If `--cpu-prof-path` is not specified, the profile will be
+written to `${cwd}/CPU.${yyyymmdd}.${hhmmss}.${pid}.${tid}.${seq}.cpuprofile`.
+
+```console
+$ node --cpu-prof index.js
+$ ls *.cpuprofile
+CPU.20190409.202950.15293.0.0.cpuprofile
+```
+
+### `--cpu-prof-path`
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Location where the CPU profile generated by `--cpu-prof`
+should be written to. When used alone, it implies `--cpu-prof`.
+
+```console
+$ node --cpu-prof-path /tmp/test.cpuprofile index.js
+```
+
 ### `--diagnostic-report-directory=directory`
 <!-- YAML
 added: v11.8.0

doc/node.1

@@ -78,6 +78,18 @@ Aborting instead of exiting causes a core file to be generated for analysis.
 .It Fl -completion-bash
 Print source-able bash completion script for Node.js.
 .
+.It Fl -cpu-prof
+Start the V8 CPU profiler on start up, and write the CPU profile to disk
+before exit. If
+.Fl -cpu-prof-path
+is not specified, the profile will be written to the current working directory.
+.
+.It Fl -cpu-prof-path
+Path the V8 CPU profile generated with
+.Fl -cpu-prof
+will be written to. When used alone, it implies
+.Fl -cpu-prof
+.
 .It Fl -diagnostic-report-directory
 Location at which the
 .Sy diagnostic report

src/env-inl.h

@@ -656,6 +656,25 @@ inline profiler::V8CoverageConnection* Environment::coverage_connection() {
 inline const std::string& Environment::coverage_directory() const {
  return coverage_directory_;
 }
+
+inline void Environment::set_cpu_profiler_connection(
+ std::unique_ptr<profiler::V8CpuProfilerConnection> connection) {
+ CHECK_NULL(cpu_profiler_connection_);
+ std::swap(cpu_profiler_connection_, connection);
+}
+
+inline profiler::V8CpuProfilerConnection*
+Environment::cpu_profiler_connection() {
+ return cpu_profiler_connection_.get();
+}
+
+inline void Environment::set_cpu_profile_path(const std::string& path) {
+ cpu_profile_path_ = path;
+}
+
+inline const std::string& Environment::cpu_profile_path() const {
+ return cpu_profile_path_;
+}
 #endif // HAVE_INSPECTOR
 
 inline std::shared_ptr<HostPort> Environment::inspector_host_port() {

src/env.h

@@ -71,6 +71,7 @@ class AgentWriterHandle;
 #if HAVE_INSPECTOR
 namespace profiler {
 class V8CoverageConnection;
+class V8CpuProfilerConnection;
 } // namespace profiler
 #endif // HAVE_INSPECTOR
 
@@ -1129,6 +1130,13 @@ class Environment : public MemoryRetainer {
 
  inline void set_coverage_directory(const char* directory);
  inline const std::string& coverage_directory() const;
+
+ void set_cpu_profiler_connection(
+ std::unique_ptr<profiler::V8CpuProfilerConnection> connection);
+ profiler::V8CpuProfilerConnection* cpu_profiler_connection();
+
+ inline void set_cpu_profile_path(const std::string& path);
+ inline const std::string& cpu_profile_path() const;
 #endif // HAVE_INSPECTOR
 
  private:
@@ -1163,7 +1171,9 @@ class Environment : public MemoryRetainer {
 
 #if HAVE_INSPECTOR
  std::unique_ptr<profiler::V8CoverageConnection> coverage_connection_;
+ std::unique_ptr<profiler::V8CpuProfilerConnection> cpu_profiler_connection_;
  std::string coverage_directory_;
+ std::string cpu_profile_path_;
 #endif // HAVE_INSPECTOR
 
  std::shared_ptr<EnvironmentOptions> options_;

src/inspector_profiler.cc

@@ -23,10 +23,14 @@ using v8::Value;
 using v8_inspector::StringBuffer;
 using v8_inspector::StringView;
 
-#ifdef __POSIX__
-const char* const kPathSeparator = "/";
-#else
+#ifdef _WIN32
 const char* const kPathSeparator = "\\/";
+/* MAX_PATH is in characters, not bytes. Make sure we have enough headroom. */
+#define CWD_BUFSIZE (MAX_PATH * 4)
+#else
+#include <climits> // PATH_MAX on Solaris.
+const char* const kPathSeparator = "/";
+#define CWD_BUFSIZE (PATH_MAX)
 #endif
 
 std::unique_ptr<StringBuffer> ToProtocolString(Isolate* isolate,
@@ -180,6 +184,116 @@ void V8CoverageConnection::End() {
  DispatchMessage(end);
 }
 
+void V8CpuProfilerConnection::OnMessage(
+ const v8_inspector::StringView& message) {
+ Debug(env(),
+ DebugCategory::INSPECTOR_PROFILER,
+ "Receive cpu profiling message, ending = %s\n",
+ ending_ ? "true" : "false");
+ if (!ending_) {
+ return;
+ }
+ Isolate* isolate = env()->isolate();
+ HandleScope handle_scope(isolate);
+ Local<Context> context = env()->context();
+ Context::Scope context_scope(context);
+ Local<String> result;
+ if (!String::NewFromTwoByte(isolate,
+ message.characters16(),
+ NewStringType::kNormal,
+ message.length())
+ .ToLocal(&result)) {
+ fprintf(stderr, "Failed to convert profiling message\n");
+ }
+ WriteCpuProfile(result);
+}
+
+void V8CpuProfilerConnection::WriteCpuProfile(Local<String> message) {
+ const std::string& path = env()->cpu_profile_path();
+ CHECK(!path.empty());
+ std::string directory = path.substr(0, path.find_last_of(kPathSeparator));
+ if (directory != path) {
+ uv_fs_t req;
+ int ret = fs::MKDirpSync(nullptr, &req, directory, 0777, nullptr);
+ uv_fs_req_cleanup(&req);
+ if (ret < 0 && ret != UV_EEXIST) {
+ char err_buf[128];
+ uv_err_name_r(ret, err_buf, sizeof(err_buf));
+ fprintf(stderr,
+ "%s: Failed to create cpu profile directory %s\n",
+ err_buf,
+ directory.c_str());
+ return;
+ }
+ }
+ MaybeLocal<String> result = GetResult(message);
+ if (!result.IsEmpty()) {
+ WriteResult(path.c_str(), result.ToLocalChecked());
+ }
+}
+
+MaybeLocal<String> V8CpuProfilerConnection::GetResult(Local<String> message) {
+ Local<Context> context = env()->context();
+ Isolate* isolate = env()->isolate();
+ Local<Value> parsed;
+ if (!v8::JSON::Parse(context, message).ToLocal(&parsed) ||
+ !parsed->IsObject()) {
+ fprintf(stderr, "Failed to parse CPU profile result as JSON object\n");
+ return MaybeLocal<String>();
+ }
+
+ Local<Value> result_v;
+ if (!parsed.As<Object>()
+ ->Get(context, FIXED_ONE_BYTE_STRING(isolate, "result"))
+ .ToLocal(&result_v)) {
+ fprintf(stderr, "Failed to get result from CPU profile message\n");
+ return MaybeLocal<String>();
+ }
+
+ if (!result_v->IsObject()) {
+ fprintf(stderr, "'result' from CPU profile message is not an object\n");
+ return MaybeLocal<String>();
+ }
+
+ Local<Value> profile_v;
+ if (!result_v.As<Object>()
+ ->Get(context, FIXED_ONE_BYTE_STRING(isolate, "profile"))
+ .ToLocal(&profile_v)) {
+ fprintf(stderr, "'profile' from CPU profile result is undefined\n");
+ return MaybeLocal<String>();
+ }
+
+ Local<String> result_s;
+ if (!v8::JSON::Stringify(context, profile_v).ToLocal(&result_s)) {
+ fprintf(stderr, "Failed to stringify CPU profile result\n");
+ return MaybeLocal<String>();
+ }
+
+ return result_s;
+}
+
+void V8CpuProfilerConnection::Start() {
+ Debug(env(), DebugCategory::INSPECTOR_PROFILER, "Sending Profiler.start\n");
+ Isolate* isolate = env()->isolate();
+ Local<String> enable = FIXED_ONE_BYTE_STRING(
+ isolate, R"({"id": 1, "method": "Profiler.enable"})");
+ Local<String> start = FIXED_ONE_BYTE_STRING(
+ isolate, R"({"id": 2, "method": "Profiler.start"})");
+ DispatchMessage(enable);
+ DispatchMessage(start);
+}
+
+void V8CpuProfilerConnection::End() {
+ CHECK_EQ(ending_, false);
+ ending_ = true;
+ Debug(env(), DebugCategory::INSPECTOR_PROFILER, "Sending Profiler.stop\n");
+ Isolate* isolate = env()->isolate();
+ HandleScope scope(isolate);
+ Local<String> end =
+ FIXED_ONE_BYTE_STRING(isolate, R"({"id": 3, "method": "Profiler.stop"})");
+ DispatchMessage(end);
+}
+
 // For now, we only support coverage profiling, but we may add more
 // in the future.
 void EndStartedProfilers(Environment* env) {
@@ -190,6 +304,12 @@ void EndStartedProfilers(Environment* env) {
  env, DebugCategory::INSPECTOR_PROFILER, "Ending coverage collection\n");
  connection->End();
  }
+
+ connection = env->cpu_profiler_connection();
+ if (connection != nullptr && !connection->ending()) {
+ Debug(env, DebugCategory::INSPECTOR_PROFILER, "Ending cpu profiling\n");
+ connection->End();
+ }
 }
 
 void StartCoverageCollection(Environment* env) {
@@ -198,6 +318,26 @@ void StartCoverageCollection(Environment* env) {
  env->coverage_connection()->Start();
 }
 
+void StartCpuProfiling(Environment* env, const std::string& profile_path) {
+ std::string path;
+ if (profile_path.empty()) {
+ char cwd[CWD_BUFSIZE];
+ size_t size = CWD_BUFSIZE;
+ int err = uv_cwd(cwd, &size);
+ // TODO(joyeecheung): fallback to exec path / argv[0]
+ CHECK_EQ(err, 0);
+ CHECK_GT(size, 0);
+ DiagnosticFilename filename(env, "CPU", "cpuprofile");
+ path = cwd + std::string(kPathSeparator) + (*filename);
+ } else {
+ path = profile_path;
+ }
+ env->set_cpu_profile_path(std::move(path));
+ env->set_cpu_profiler_connection(
+ std::make_unique<V8CpuProfilerConnection>(env));
+ env->cpu_profiler_connection()->Start();
+}
+
 static void SetCoverageDirectory(const FunctionCallbackInfo<Value>& args) {
  CHECK(args[0]->IsString());
  Environment* env = Environment::GetCurrent(args);

src/inspector_profiler.h

@@ -68,6 +68,24 @@ class V8CoverageConnection : public V8ProfilerConnection {
  bool ending_ = false;
 };
 
+class V8CpuProfilerConnection : public V8ProfilerConnection {
+ public:
+ explicit V8CpuProfilerConnection(Environment* env)
+ : V8ProfilerConnection(env) {}
+
+ void Start() override;
+ void End() override;
+ void OnMessage(const v8_inspector::StringView& message) override;
+ bool ending() const override { return ending_; }
+
+ private:
+ void WriteCpuProfile(v8::Local<v8::String> message);
+ v8::MaybeLocal<v8::String> GetResult(v8::Local<v8::String> message);
+
+ std::unique_ptr<inspector::InspectorSession> session_;
+ bool ending_ = false;
+};
+
 } // namespace profiler
 } // namespace node
 

src/node.cc

@@ -252,6 +252,12 @@ MaybeLocal<Value> RunBootstrapping(Environment* env) {
 #endif // HAVE_INSPECTOR
  }
 
+#if HAVE_INSPECTOR
+ if (env->options()->cpu_prof) {
+ profiler::StartCpuProfiling(env, env->options()->cpu_prof_path);
+ }
+#endif // HAVE_INSPECTOR
+
  // Add a reference to the global object
  Local<Object> global = context->Global();
 

src/node_internals.h

@@ -312,6 +312,7 @@ void MarkBootstrapComplete(const v8::FunctionCallbackInfo<v8::Value>& args);
 #if HAVE_INSPECTOR
 namespace profiler {
 void StartCoverageCollection(Environment* env);
+void StartCpuProfiling(Environment* env, const std::string& profile_name);
 void EndStartedProfilers(Environment* env);
 }
 #endif // HAVE_INSPECTOR

src/node_options.cc

@@ -317,6 +317,18 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
  &EnvironmentOptions::prof_process);
  // Options after --prof-process are passed through to the prof processor.
  AddAlias("--prof-process", { "--prof-process", "--" });
+#if HAVE_INSPECTOR
+ AddOption("--cpu-prof",
+ "Start the V8 CPU profiler on start up, and write the CPU profile "
+ "to disk before exit. If --cpu-prof-path is not specified, write "
+ "the profile to the current working directory.",
+ &EnvironmentOptions::cpu_prof);
+ AddOption("--cpu-prof-path",
+ "Path the V8 CPU profile generated with --cpu-prof will be "
+ "written to.",
+ &EnvironmentOptions::cpu_prof_path);
+ Implies("--cpu-prof-path", "--cpu-prof");
+#endif // HAVE_INSPECTOR
  AddOption("--redirect-warnings",
  "write warnings to file instead of stderr",
  &EnvironmentOptions::redirect_warnings,

src/node_options.h

@@ -108,6 +108,10 @@ class EnvironmentOptions : public Options {
  bool preserve_symlinks = false;
  bool preserve_symlinks_main = false;
  bool prof_process = false;
+#if HAVE_INSPECTOR
+ std::string cpu_prof_path;
+ bool cpu_prof = false;
+#endif // HAVE_INSPECTOR
  std::string redirect_warnings;
  bool throw_deprecation = false;
  bool trace_deprecation = false;

test/fixtures/workload/fibonacci-exit.js

@@ -0,0 +1,7 @@
+'use strict';
+function fib(n) {
+ if (n === 0 || n === 1) return n;
+ return fib(n - 1) + fib(n - 2);
+}
+fib(parseInt(process.argv[2]) || 35);
+process.exit(55);

test/fixtures/workload/fibonacci-sigint.js

@@ -0,0 +1,7 @@
+'use strict';
+function fib(n) {
+ if (n === 0 || n === 1) return n;
+ return fib(n - 1) + fib(n - 2);
+}
+fib(parseInt(process.argv[2]) || 35);
+process.kill(process.pid, "SIGINT");

test/fixtures/workload/fibonacci-worker.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const{ Worker }=require('worker_threads');
+constpath=require('path');
+newWorker(path.join(__dirname,'fibonacci.js'),{
+execArgv: ['--cpu-prof']
+});

test/fixtures/workload/fibonacci.js

@@ -0,0 +1,8 @@
+'use strict';
+function fib(n) {
+ if (n === 0 || n === 1) return n;
+ return fib(n - 1) + fib(n - 2);
+}
+
+const n = parseInt(process.env.FIB) || 35;
+process.stdout.write(`${fib(n)}\n`);