DrJones/Perf: Ensure selected event is always within its own tree

Bug:377672675
Change-Id: Ie514815ed09c586eee1ac827774d6dc5161ce159
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6002096
Reviewed-by: Alex Rudenko <[email protected]>
Auto-Submit: Paul Irish <[email protected]>
Commit-Queue: Alex Rudenko <[email protected]>

Author: paulirish

front_end/models/trace/extras/TraceTree.ts

@@ -103,7 +103,7 @@ export class TopDownNode extends Node {
     }
     const startTime = root.startTime;
     const endTime = root.endTime;
-    const instantEventCallback = root.doNotAggregate ? onInstantEvent : undefined;
+    const instantEventCallback = (root.doNotAggregate || root.includeInstantEvents) ? onInstantEvent : undefined;
     const eventIdCallback = root.doNotAggregate ? undefined : generateEventID;
     const eventGroupIdCallback = root.getEventGroupIdCallback();
     let depth = 0;
@@ -238,18 +238,21 @@ export class TopDownNode extends Node {
 
 export class TopDownRootNode extends TopDownNode {
   readonly filter: (e: Types.Events.Event) => boolean;
+  /** This is all events passed in to create the tree, and it's very likely that it included events outside of the passed startTime/endTime as that filtering is done in `Helpers.Trace.forEachEvent` */
   readonly events: Types.Events.Event[];
   readonly startTime: Types.Timing.MilliSeconds;
   readonly endTime: Types.Timing.MilliSeconds;
   eventGroupIdCallback: ((arg0: Types.Events.Event) => string)|null|undefined;
+  /** Default behavior is to aggregate similar trace events into one Node based on generateEventID(), eventGroupIdCallback(), etc. Set true to keep nodes 1:1 with events. */
   readonly doNotAggregate: boolean|undefined;
+  readonly includeInstantEvents?: boolean;
   override totalTime: number;
   override selfTime: number;
 
   constructor(
       events: Types.Events.Event[], filters: TraceFilter[], startTime: Types.Timing.MilliSeconds,
       endTime: Types.Timing.MilliSeconds, doNotAggregate?: boolean,
-      eventGroupIdCallback?: ((arg0: Types.Events.Event) => string)|null) {
+      eventGroupIdCallback?: ((arg0: Types.Events.Event) => string)|null, includeInstantEvents?: boolean) {
     super('', null, null);
     this.root = this;
     this.events = events;
@@ -258,6 +261,8 @@ export class TopDownRootNode extends TopDownNode {
     this.endTime = endTime;
     this.eventGroupIdCallback = eventGroupIdCallback;
     this.doNotAggregate = doNotAggregate;
+    this.includeInstantEvents = includeInstantEvents;
+
     this.totalTime = endTime - startTime;
     this.selfTime = this.totalTime;
   }

front_end/panels/timeline/utils/AICallTree.test.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Trace from '../../../models/trace/trace.js';
 import {describeWithEnvironment} from '../../../testing/EnvironmentHelpers.js';
 import {TraceLoader} from '../../../testing/TraceLoader.js';
 
@@ -77,4 +78,108 @@ self: 0.2
     const fibCallCount = lines.filter(line => line.includes('fibonacci')).length;
     assert.isTrue(fibCallCount > 10);
   });
+
+  it('AITreeFilter includes the right items in the tree', async function() {
+    const {parsedTrace} = await TraceLoader.traceEngine(this, 'two-workers.json.gz');
+    const mainEvents = parsedTrace.Renderer.allTraceEntries;
+
+    // A very small 'get storage' event. It's 6µs long
+    const tinyEvent = mainEvents.find(event => event.ts === 107350149168);
+    if (!tinyEvent) {
+      throw new Error('Could not find expected event.');
+    }
+    const tinyStr = Utils.AICallTree.AICallTree.from(tinyEvent, mainEvents, parsedTrace).serialize();
+    assert.strictEqual(tinyStr.split('\n').filter(l => l.startsWith('Node:')).join('\n'), `
+Node: 1 – Task
+Node: 2 – Parse HTML
+Node: 3 – Evaluate script
+Node: 4 – (anonymous)
+Node: 5 – get storage`.trim());
+    assert.include(tinyStr, 'get storage');
+
+    // An evaluateScript that has 3 'Compile code' children
+    const evaluateEvent = mainEvents.find(event => event.ts === 107350147808);
+    if (!evaluateEvent) {
+      throw new Error('Could not find expected event.');
+    }
+    const treeStr = Utils.AICallTree.AICallTree.from(evaluateEvent, mainEvents, parsedTrace).serialize();
+    assert.strictEqual(treeStr.split('\n').filter(l => l.startsWith('Node:')).join('\n'), `
+Node: 1 – Task
+Node: 2 – Parse HTML
+Node: 3 – Evaluate script
+Node: 4 – Compile script
+Node: 5 – (anonymous)
+Node: 6 – H.la`.trim());
+    assert.notInclude(treeStr, 'Compile code');
+
+    // An Compile code event within the evaluateEvent call tree
+    const compileEvent = mainEvents.find(event => event.ts === 107350148218);
+    if (!compileEvent) {
+      throw new Error('Could not find expected event.');
+    }
+    const compileStr = Utils.AICallTree.AICallTree.from(compileEvent, mainEvents, parsedTrace).serialize();
+    assert.strictEqual(compileStr.split('\n').filter(l => l.startsWith('Node:')).join('\n'), `
+Node: 1 – Task
+Node: 2 – Parse HTML
+Node: 3 – Evaluate script
+Node: 4 – (anonymous)
+Node: 5 – Compile code`.trim());
+    assert.include(compileStr, 'Compile code');
+  });
+});
+
+describe('AITreeFilter', () => {
+  const makeEvent = (
+                        name: string,
+                        ts: number,
+                        dur: number,
+                        ): Trace.Types.Events.Event => ({
+    name,
+    cat: 'disabled-by-default-devtools.timeline',
+    ph: Trace.Types.Events.Phase.COMPLETE,
+    ts: Trace.Types.Timing.MicroSeconds(ts),
+    dur: Trace.Types.Timing.MicroSeconds(dur),
+    pid: Trace.Types.Events.ProcessID(1),
+    tid: Trace.Types.Events.ThreadID(4),
+    args: {},
+  });
+
+  it('always includes the selected event', () => {
+    const selectedEvent = makeEvent('selected', 0, 100);
+    const filter = new Utils.AICallTree.AITreeFilter(selectedEvent);
+    assert.strictEqual(filter.accept(selectedEvent), true);
+  });
+
+  it('includes events that are long enough', () => {
+    const selectedEvent = makeEvent('selected', 0, 100);
+    const filter = new Utils.AICallTree.AITreeFilter(selectedEvent);
+
+    assert.strictEqual(filter.accept(makeEvent('short', 0, 1)), true);
+    assert.strictEqual(filter.accept(makeEvent('short', 0, 0.6)), true);
+    assert.strictEqual(filter.accept(makeEvent('long', 0, 101)), true);
+    assert.strictEqual(filter.accept(makeEvent('long', 0, 200)), true);
+    assert.strictEqual(filter.accept(makeEvent('long', 0, 1000)), true);
+  });
+
+  it('excludes events that are too short', () => {
+    const selectedEvent = makeEvent('selected', 0, 100);
+    const filter = new Utils.AICallTree.AITreeFilter(selectedEvent);
+
+    assert.strictEqual(filter.accept(makeEvent('short', 0, 0)), false);
+    assert.strictEqual(filter.accept(makeEvent('short', 0, 0.1)), false);
+    assert.strictEqual(filter.accept(makeEvent('short', 0, 0.4)), false);
+  });
+
+  it('excludes COMPILE_CODE nodes if non-selected', () => {
+    const selectedEvent = makeEvent('selected', 0, 100);
+    const compileCodeEvent = makeEvent(Trace.Types.Events.Name.COMPILE_CODE, 0, 100);
+    const filter = new Utils.AICallTree.AITreeFilter(selectedEvent);
+    assert.strictEqual(filter.accept(compileCodeEvent), false);
+  });
+
+  it('includes COMPILE_CODE nodes if selected', () => {
+    const selectedEvent = makeEvent(Trace.Types.Events.Name.COMPILE_CODE, 0, 100);
+    const filter = new Utils.AICallTree.AITreeFilter(selectedEvent);
+    assert.strictEqual(filter.accept(selectedEvent), true);
+  });
 });

front_end/panels/timeline/utils/AICallTree.ts

@@ -31,22 +31,22 @@ export class AICallTree {
   static from(
       selectedEvent: Trace.Types.Events.Event, events: Trace.Types.Events.Event[],
       parsedTrace: Trace.Handlers.Types.ParsedTrace): AICallTree {
-    const timings = Trace.Helpers.Timing.eventTimingsMilliSeconds(selectedEvent);
-    const selectedEventBounds = Trace.Helpers.Timing.traceWindowFromMicroSeconds(
-        Trace.Helpers.Timing.millisecondsToMicroseconds(timings.startTime),
-        Trace.Helpers.Timing.millisecondsToMicroseconds(timings.endTime));
+    const {startTime, endTime} = Trace.Helpers.Timing.eventTimingsMilliSeconds(selectedEvent);
 
+    const selectedEventBounds = Trace.Helpers.Timing.traceWindowFromMicroSeconds(
+        Trace.Helpers.Timing.millisecondsToMicroseconds(startTime),
+        Trace.Helpers.Timing.millisecondsToMicroseconds(endTime));
     const threadEvents = parsedTrace.Renderer.processes.get(selectedEvent.pid)?.threads.get(selectedEvent.tid)?.entries;
     if (!threadEvents) {
       throw new Error('Cannot locate thread');
     }
     const overlappingEvents = threadEvents.filter(e => Trace.Helpers.Timing.eventIsInBounds(e, selectedEventBounds));
 
     const visibleEventsFilter = new Trace.Extras.TraceFilter.VisibleEventsFilter(visibleTypes());
-    const customFilter = new AITreeFilter(timings.duration);
+    const customFilter = new AITreeFilter(selectedEvent);
     // Build a tree bounded by the selected event's timestamps, and our other filters applied
     const rootNode = new Trace.Extras.TraceTree.TopDownRootNode(
-        overlappingEvents, [visibleEventsFilter, customFilter], timings.startTime, timings.endTime, false, null);
+        overlappingEvents, [visibleEventsFilter, customFilter], startTime, endTime, false, null, true);
 
     // Walk the tree to find selectedNode
     let selectedNode: Trace.Extras.TraceTree.Node|null = null;
@@ -147,14 +147,17 @@ export class AICallTree {
 
 export class AITreeFilter extends Trace.Extras.TraceFilter.TraceFilter {
   #minDuration: Trace.Types.Timing.MicroSeconds;
-  constructor(eventDuration: Trace.Types.Timing.MilliSeconds) {
+  #selectedEvent: Trace.Types.Events.Event;
+  constructor(selectedEvent: Trace.Types.Events.Event) {
     super();
     // The larger the selected event is, the less small ones matter. We'll exclude items under ½% of the selected event's size
-    // We'll always exclude items under 0.15ms of total time.
-    const minDurationMs = Math.max(Trace.Types.Timing.MilliSeconds(0.15), eventDuration * 0.005);
-    this.#minDuration = Trace.Helpers.Timing.millisecondsToMicroseconds(Trace.Types.Timing.MilliSeconds(minDurationMs));
+    this.#minDuration = Trace.Types.Timing.MicroSeconds((selectedEvent.dur ?? 1) * 0.005);
+    this.#selectedEvent = selectedEvent;
   }
   accept(event: Trace.Types.Events.Event): boolean {
+    if (event === this.#selectedEvent) {
+      return true;
+    }
     if (event.name === Trace.Types.Events.Name.COMPILE_CODE) {
       return false;
     }