[RPP] Also use JS invocation trace events as async JS task schedulers

Before this CL, only profile calls were computed as async JS callers.
However, due to limitations with sampling, it's possible that no profile
call is built at all for an async call. In these cases we must fall back
to the corresponding FunctionCall trace event, which unlike profile
calls, is certain to happen for a given async call because these events
come from tracing instead of sampling.

Fixed: 384657567
Change-Id: I2a6364be37f64dabc3d7689015e6257410bc5ab6
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6097454
Commit-Queue: Andres Olivares <[email protected]>
Reviewed-by: Alina Varkki <[email protected]>

Author: and-oli

front_end/models/trace/handlers/AsyncJSCallsHandler.test.ts

@@ -40,8 +40,9 @@ describe('AsyncJSCallsHandler', function() {
       const allEvents = [...rendererEvents, ...flowEvents];
 
       const asyncCallStacksData = await buildAsyncJSCallsHandlerData(allEvents);
-      const testRunEntryPoint = asyncCallStacksData.schedulerToRunEntryPoints.get(jsTaskScheduler);
-      assert.strictEqual(testRunEntryPoint, jsTaskRunEntryPoint);
+      const testRunEntryPoints = asyncCallStacksData.schedulerToRunEntryPoints.get(jsTaskScheduler);
+      assert.strictEqual(testRunEntryPoints?.length, 1);
+      assert.strictEqual(testRunEntryPoints?.[0], jsTaskRunEntryPoint);
     });
 
     it('uses the nearest profile call ancestor of a debuggerTaskScheduled as JS task scheduler', async function() {
@@ -62,8 +63,9 @@ describe('AsyncJSCallsHandler', function() {
       const allEvents = [...rendererEvents, ...flowEvents];
 
       const asyncCallStacksData = await buildAsyncJSCallsHandlerData(allEvents);
-      const testRunEntryPoint = asyncCallStacksData.schedulerToRunEntryPoints.get(jsTaskScheduler);
-      assert.strictEqual(testRunEntryPoint, jsTaskRunEntryPoint);
+      const testRunEntryPoints = asyncCallStacksData.schedulerToRunEntryPoints.get(jsTaskScheduler);
+      assert.strictEqual(testRunEntryPoints?.length, 1);
+      assert.strictEqual(testRunEntryPoints?.[0], jsTaskRunEntryPoint);
     });
 
     it('uses the nearest JS entry point descendant of a debuggerTaskRun as async task run', async function() {
@@ -85,8 +87,75 @@ describe('AsyncJSCallsHandler', function() {
       const allEvents = [...rendererEvents, ...flowEvents];
 
       const asyncCallStacksData = await buildAsyncJSCallsHandlerData(allEvents);
-      const testRunEntryPoint = asyncCallStacksData.schedulerToRunEntryPoints.get(jsTaskScheduler);
-      assert.strictEqual(testRunEntryPoint, jsTaskRunEntryPoint);
+      const testRunEntryPoints = asyncCallStacksData.schedulerToRunEntryPoints.get(jsTaskScheduler);
+      assert.strictEqual(testRunEntryPoints?.length, 1);
+      assert.strictEqual(testRunEntryPoints?.[0], jsTaskRunEntryPoint);
+    });
+
+    it('falls back to a JS invocation as task scheduler if no profile call is found before in the debuggerTaskScheduled ancestors',
+       async function() {
+         const jsTaskScheduler = makeCompleteEvent(Trace.Types.Events.Name.FUNCTION_CALL, 0, 30, cat, tid, pid);
+         const asyncTaskScheduled =
+             makeCompleteEvent(Trace.Types.Events.Name.DEBUGGER_ASYNC_TASK_SCHEDULED, 0, 0, cat, pid, tid);
+
+         const asyncTaskRun =
+             makeCompleteEvent(Trace.Types.Events.Name.DEBUGGER_ASYNC_TASK_RUN, 60, 100, cat, tid, pid);
+
+         // Two JS entry points belonging to the same subtree are
+         // descendants to the debuggerTaskRun event. Test the one closest
+         // to the debuggerTaskRun in the global tree is picked.
+         const jsTaskRunEntryPoint = makeCompleteEvent(Trace.Types.Events.Name.FUNCTION_CALL, 70, 20, cat, tid, pid);
+         const secondFakeEntryPoint = makeCompleteEvent(Trace.Types.Events.Name.FUNCTION_CALL, 71, 10, cat, tid, pid);
+
+         const flowEvents = makeFlowEvents([asyncTaskScheduled, asyncTaskRun]);
+         const rendererEvents =
+             [jsTaskScheduler, asyncTaskScheduled, asyncTaskRun, jsTaskRunEntryPoint, secondFakeEntryPoint];
+         const allEvents = [...rendererEvents, ...flowEvents];
+
+         const asyncCallStacksData = await buildAsyncJSCallsHandlerData(allEvents);
+         const testRunEntryPoints = asyncCallStacksData.schedulerToRunEntryPoints.get(jsTaskScheduler);
+         assert.strictEqual(testRunEntryPoints?.length, 1);
+         assert.strictEqual(testRunEntryPoints?.[0], jsTaskRunEntryPoint);
+       });
+
+    it('returns multiple JS entry points when scheduled by the same function', async function() {
+      const jsTaskScheduler = makeCompleteEvent(Trace.Types.Events.Name.FUNCTION_CALL, 0, 30, cat, tid, pid);
+      // Two asyncTaskScheduled events right under the function call.
+      const asyncTaskScheduled1 =
+          makeCompleteEvent(Trace.Types.Events.Name.DEBUGGER_ASYNC_TASK_SCHEDULED, 0, 0, cat, pid, tid);
+
+      const asyncTaskScheduled2 =
+          makeCompleteEvent(Trace.Types.Events.Name.DEBUGGER_ASYNC_TASK_SCHEDULED, 10, 0, cat, pid, tid);
+
+      const asyncTaskRun1 = makeCompleteEvent(Trace.Types.Events.Name.DEBUGGER_ASYNC_TASK_RUN, 60, 100, cat, tid, pid);
+
+      const asyncTaskRun2 = makeCompleteEvent(Trace.Types.Events.Name.DEBUGGER_ASYNC_TASK_RUN, 200, 100, cat, tid, pid);
+
+      // Two JS entry points,
+      const firstJSTaskRunEntryPoint = makeCompleteEvent(Trace.Types.Events.Name.FUNCTION_CALL, 70, 20, cat, tid, pid);
+      const secondJSTaskRunEntryPoint =
+          makeCompleteEvent(Trace.Types.Events.Name.FUNCTION_CALL, 210, 10, cat, tid, pid);
+
+      const flow1Events = makeFlowEvents([asyncTaskScheduled1, asyncTaskRun1], 1);
+      const flow2Events = makeFlowEvents([asyncTaskScheduled2, asyncTaskRun2], 2);
+      const flowEvents = [...flow1Events, ...flow2Events].sort((a, b) => a.ts - b.ts);
+      const rendererEvents = [
+        jsTaskScheduler,
+        asyncTaskScheduled1,
+        asyncTaskRun1,
+        asyncTaskScheduled2,
+        firstJSTaskRunEntryPoint,
+        asyncTaskRun2,
+        secondJSTaskRunEntryPoint,
+      ];
+      const allEvents = [...rendererEvents, ...flowEvents];
+
+      const asyncCallStacksData = await buildAsyncJSCallsHandlerData(allEvents);
+
+      const testRunEntryPoints = asyncCallStacksData.schedulerToRunEntryPoints.get(jsTaskScheduler);
+      assert.strictEqual(testRunEntryPoints?.length, 2);
+      assert.strictEqual(testRunEntryPoints?.[0], firstJSTaskRunEntryPoint);
+      assert.strictEqual(testRunEntryPoints?.[1], secondJSTaskRunEntryPoint);
     });
   });
   describe('Resolving async JS tasks to schedulers', function() {

front_end/models/trace/handlers/AsyncJSCallsHandler.ts

@@ -1,16 +1,16 @@
 // Copyright 2024 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+import * as Platform from '../../../core/platform/platform.js';
 import type * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
 import {data as flowsHandlerData} from './FlowsHandler.js';
 import {data as rendererHandlerData} from './RendererHandler.js';
 
-const schedulerToRunEntryPoints: Map<Types.Events.SyntheticProfileCall, Types.Events.Event> = new Map();
-const asyncCallToScheduler:
-    Map<Types.Events.SyntheticProfileCall, {taskName: string, scheduler: Types.Events.SyntheticProfileCall}> =
-        new Map();
+const schedulerToRunEntryPoints: Map<Types.Events.Event, Types.Events.Event[]> = new Map();
+const asyncCallToScheduler: Map<Types.Events.SyntheticProfileCall, {taskName: string, scheduler: Types.Events.Event}> =
+    new Map();
 
 export function reset(): void {
   schedulerToRunEntryPoints.clear();
@@ -35,7 +35,7 @@ export async function finalize(): Promise<void> {
       // Unexpected flow shape, ignore.
       continue;
     }
-    const asyncCaller = findNearestProfileCallAncestor(asyncTaskScheduled, entryToNode);
+    const asyncCaller = findNearestJSAncestor(asyncTaskScheduled, entryToNode);
     if (!asyncCaller) {
       // Unexpected async call trace data shape, ignore.
       continue;
@@ -47,7 +47,8 @@ export async function finalize(): Promise<void> {
     }
     // Set scheduler -> schedulee mapping.
     // The schedulee being the JS entrypoint
-    schedulerToRunEntryPoints.set(asyncCaller, asyncEntryPoint);
+    const entryPoints = Platform.MapUtilities.getWithDefault(schedulerToRunEntryPoints, asyncCaller, () => []);
+    entryPoints.push(asyncEntryPoint);
 
     // Set schedulee -> scheduler mapping.
     // The schedulees being the JS calls (instead of the entrypoints as
@@ -60,15 +61,15 @@ export async function finalize(): Promise<void> {
 }
 /**
  * Given a DebuggerAsyncTaskScheduled event, returns its closest
- * ProfileCall ancestor, which represents the JS call that scheduled
- * the async task.
+ * ProfileCall or JS invocation ancestor, which represents the JS call
+ * that scheduled the async task.
  */
-function findNearestProfileCallAncestor(
+function findNearestJSAncestor(
     asyncTaskScheduled: Types.Events.DebuggerAsyncTaskScheduled,
-    entryToNode: Map<Types.Events.Event, Helpers.TreeHelpers.TraceEntryNode>): Types.Events.SyntheticProfileCall|null {
+    entryToNode: Map<Types.Events.Event, Helpers.TreeHelpers.TraceEntryNode>): Types.Events.Event|null {
   let node = entryToNode.get(asyncTaskScheduled)?.parent;
   while (node) {
-    if (Types.Events.isProfileCall(node.entry)) {
+    if (Types.Events.isProfileCall(node.entry) || acceptJSInvocationsPredicate(node.entry)) {
       return node.entry;
     }
     node = node.parent;
@@ -82,7 +83,7 @@ function findNearestProfileCallAncestor(
  * returns events that end up in the flame chart.
  */
 function acceptJSInvocationsPredicate(event: Types.Events.Event): event is Types.Events.Event {
-  const eventIsConsoleRunTask = event.name === Types.Events.Name.V8_CONSOLE_RUN_TASK;
+  const eventIsConsoleRunTask = Types.Events.isConsoleRunTask(event);
   const eventIsV8EntryPoint = event.name.startsWith('v8') || event.name.startsWith('V8');
   return Types.Events.isJSInvocationEvent(event) && (eventIsConsoleRunTask || !eventIsV8EntryPoint);
 }

front_end/models/trace/handlers/InitiatorsHandler.ts

@@ -189,9 +189,11 @@ function createRelationshipsFromFlows(): void {
 }
 
 function createRelationshipsFromAsyncJSCalls(): void {
-  const asyncCallPairs = AsyncJSCallsHandlerData().schedulerToRunEntryPoints.entries();
-  for (const [asyncCaller, asyncCallee] of asyncCallPairs) {
-    storeInitiator({event: asyncCallee, initiator: asyncCaller});
+  const asyncCallEntries = AsyncJSCallsHandlerData().schedulerToRunEntryPoints.entries();
+  for (const [asyncCaller, asyncCallees] of asyncCallEntries) {
+    for (const asyncCallee of asyncCallees) {
+      storeInitiator({event: asyncCallee, initiator: asyncCaller});
+    }
   }
 }