RPP: disable throttling during trace collection

We have had reports of the performance panel freezing for users when
CPU throttling is active; particularly with the new 20x throttling
option. We think this is because after tracing is completed the act of
collecting + emitting all the events from the renderer (which is what
gets throttled) is very slow. This is less prevalent on big powerful M3
MacBooks but more prevalent on less powerful devices, and also more
prevalent on heavier websites which generate more trace events.

This CL updates the code so that after we stop tracing we immediately
reset the CPU throttling to 1 (e.g. no throttling). Then, after all the
events are gathered and collected, we set it back to whatever it was.

This maintains the existing behaviour of the throttling being persistent
in Devtools, but means we do not throttle during a potentially expensive
stage of the process.

Testing (unscientifically) on my M1 MacBook Pro on cnn.com with 20x
throttling, I got:

- Between 9.5-11 seconds of processing time with NO change
- Between 5-5.5 seconds of processing time with this CL

And I am fairly confident these numbers will be larger on less powerful
devices.

As a drive-by, I also updated the throttling manager to make sure that
if you set the CPU throttling to what it is already, it does nothing
rather than fire off a bunch of listeners despite the value not actually
changing.

Fixed: 376836355
Change-Id: Ie7bf7fdfca1039b549b16ae94c486189a7b3abd0
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/5979761
Reviewed-by: Connor Clark <[email protected]>
Commit-Queue: Paul Irish <[email protected]>
Reviewed-by: Paul Irish <[email protected]>

Author: jackfranklin

front_end/core/sdk/CPUThrottlingManager.ts

@@ -35,6 +35,10 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
   }
 
   setCPUThrottlingRate(rate: number): void {
+    if (rate === this.#cpuThrottlingRateInternal) {
+      return;
+    }
+
     this.#cpuThrottlingRateInternal = rate;
     for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
       void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingRateInternal);

front_end/panels/timeline/TimelineController.ts

@@ -144,11 +144,23 @@ export class TimelineController implements Trace.TracingManager.TracingManagerCl
     if (this.tracingManager) {
       this.tracingManager.stop();
     }
+    // When throttling is applied to the main renderer, it can slow down the
+    // collection of trace events once tracing has completed. Therefore we
+    // temporarily disable throttling whilst the final trace event collection
+    // takes place. Once it is done, we re-enable it (this is the existing
+    // behaviour within DevTools; the throttling settling is sticky + global).
+    const throttlingManager = SDK.CPUThrottlingManager.CPUThrottlingManager.instance();
+    const rateDuringRecording = throttlingManager.cpuThrottlingRate();
+    // 1 = no throttling (CPU is 1x'd)
+    throttlingManager.setCPUThrottlingRate(1);
 
     this.client.loadingStarted();
     await this.waitForTracingToStop();
     await this.allSourcesFinished();
 
+    // Now we re-enable throttling again to maintain the setting being persistent.
+    throttlingManager.setCPUThrottlingRate(rateDuringRecording);
+
     await LiveMetrics.LiveMetrics.instance().enable();
   }