Conditionally enable native perf events

Author: rbuckton

src/compiler/performance.ts

@@ -115,13 +115,19 @@ namespace ts.performance {
     }
 
     /** Enables (and resets) performance measurements for the compiler. */
-    export function enable() {
+    export function enable(system: System = sys) {
         if (!enabled) {
             enabled = true;
             perfHooks ||= tryGetNativePerformanceHooks();
             if (perfHooks) {
-                performanceImpl = perfHooks.performance;
-                timeorigin = performanceImpl.timeOrigin;
+                timeorigin = perfHooks.performance.timeOrigin;
+                // NodeJS's Web Performance API is currently slower than expected, but we'd still like
+                // to be able to leverage native trace events when node is run with either `--cpu-prof`
+                // or `--prof`, if we're running with our own `--generateCpuProfile` flag, or when
+                // running in debug mode (since its possible to generate a cpu profile while debugging).
+                if (perfHooks.shouldWriteNativeEvents || system?.cpuProfilingEnabled?.() || system?.debugMode) {
+                    performanceImpl = perfHooks.performance;
+                }
             }
         }
         return true;

src/compiler/performanceCore.ts

@@ -4,6 +4,8 @@ namespace ts {
     // between browsers and NodeJS:
 
     export interface PerformanceHooks {
+        /** Indicates whether we should write native performance events */
+        shouldWriteNativeEvents: boolean;
         performance: Performance;
         PerformanceObserver: PerformanceObserverConstructor;
     }
@@ -37,6 +39,7 @@ namespace ts {
     export type PerformanceEntryList = PerformanceEntry[];
 
     // Browser globals for the Web Performance User Timings API
+    declare const process: any;
     declare const performance: Performance | undefined;
     declare const PerformanceObserver: PerformanceObserverConstructor | undefined;
 
@@ -55,44 +58,49 @@ namespace ts {
             typeof PerformanceObserver === "function" &&
             hasRequiredAPI(performance, PerformanceObserver)) {
             return {
+                // For now we always write native performance events when running in the browser. We may
+                // make this conditional in the future if we find that native web performance hooks
+                // in the browser also slow down compilation.
+                shouldWriteNativeEvents: true,
                 performance,
                 PerformanceObserver
             };
         }
     }
 
     function tryGetNodePerformanceHooks(): PerformanceHooks | undefined {
-        if (typeof module === "object" && typeof require === "function") {
+        if (typeof process !== "undefined" && process.nextTick && !process.browser && typeof module === "object" && typeof require === "function") {
             try {
-                const { performance, PerformanceObserver } = require("perf_hooks") as typeof import("perf_hooks");
-                if (hasRequiredAPI(performance, PerformanceObserver)) {
+                let performance: Performance;
+                const { performance: nodePerformance, PerformanceObserver } = require("perf_hooks") as typeof import("perf_hooks");
+                if (hasRequiredAPI(nodePerformance, PerformanceObserver)) {
+                    performance = nodePerformance;
                     // There is a bug in Node's performance.measure prior to 12.16.3/13.13.0 that does not
                     // match the Web Performance API specification. Node's implementation did not allow
                     // optional `start` and `end` arguments for `performance.measure`.
                     // See https://github.com/nodejs/node/pull/32651 for more information.
                     const version = new Version(process.versions.node);
                     const range = new VersionRange("<12.16.3 || 13 <13.13");
                     if (range.test(version)) {
-                        return {
-                            performance: {
-                                get timeOrigin() { return performance.timeOrigin; },
-                                now() { return performance.now(); },
-                                mark(name) { return performance.mark(name); },
-                                measure(name, start = "nodeStart", end?) {
-                                    if (end === undefined) {
-                                        end = "__performance.measure-fix__";
-                                        performance.mark(end);
-                                    }
-                                    performance.measure(name, start, end);
-                                    if (end === "__performance.measure-fix__") {
-                                        performance.clearMarks("__performance.measure-fix__");
-                                    }
+                        performance = {
+                            get timeOrigin() { return nodePerformance.timeOrigin; },
+                            now() { return nodePerformance.now(); },
+                            mark(name) { return nodePerformance.mark(name); },
+                            measure(name, start = "nodeStart", end?) {
+                                if (end === undefined) {
+                                    end = "__performance.measure-fix__";
+                                    nodePerformance.mark(end);
                                 }
-                            },
-                            PerformanceObserver
+                                nodePerformance.measure(name, start, end);
+                                if (end === "__performance.measure-fix__") {
+                                    nodePerformance.clearMarks("__performance.measure-fix__");
+                                }
+                            }
                         };
                     }
                     return {
+                        // By default, only write native events when generating a cpu profile or using the v8 profiler.
+                        shouldWriteNativeEvents: false,
                         performance,
                         PerformanceObserver
                     };

src/compiler/sys.ts

@@ -1116,6 +1116,7 @@ namespace ts {
         exit(exitCode?: number): void;
         /*@internal*/ enableCPUProfiler?(path: string, continuation: () => void): boolean;
         /*@internal*/ disableCPUProfiler?(continuation: () => void): boolean;
+        /*@internal*/ cpuProfilingEnabled?(): boolean;
         realpath?(path: string): string;
         /*@internal*/ getEnvironmentVariable(name: string): string;
         /*@internal*/ tryEnableSourceMapsForHost?(): void;
@@ -1286,6 +1287,7 @@ namespace ts {
                 },
                 enableCPUProfiler,
                 disableCPUProfiler,
+                cpuProfilingEnabled: () => !!activeSession || contains(process.execArgv, "--cpu-prof") || contains(process.execArgv, "--prof"),
                 realpath,
                 debugMode: !!process.env.NODE_INSPECTOR_IPC || !!process.env.VSCODE_INSPECTOR_OPTIONS || some(<string[]>process.execArgv, arg => /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg)),
                 tryEnableSourceMapsForHost() {

src/executeCommandLine/executeCommandLine.ts

@@ -662,7 +662,7 @@ namespace ts {
 
     function enableStatisticsAndTracing(system: System, compilerOptions: CompilerOptions, isBuildMode: boolean) {
         if (canReportDiagnostics(system, compilerOptions)) {
-            performance.enable();
+            performance.enable(system);
         }
 
         if (canTrace(system, compilerOptions)) {