tor-browser

sequencer.js (7616B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// A Sequencer handles transitioning between different mutators. Typically, it
// will base the decision to transition on things like elapsed time, number of
// GCs observed, or similar. However, they might also implement a search for
// some result value by running for some time while measuring, tweaking
// parameters, and re-running until an in-range result is found.

var Sequencer = class {
 // Return the current mutator (of class AllocationLoad).
 get current() {
   throw new Error("unimplemented");
 }

 start(now = gHost.now()) {
   this.started = now;
 }

 // Called by user to handle advancing time. Subclasses will normally override
 // do_tick() instead. Returns the results of a trial if complete (the mutator
 // reached its allotted time or otherwise determined that its timing data
 // should be valid), and falsy otherwise.
 tick(now = gHost.now()) {
   if (this.done()) {
     throw new Error("tick() called on completed sequencer");
   }

   return this.do_tick(now);
 }

 // Implement in subclass to handle time advancing. Must return trial's result
 // if complete. Called by tick(), above.
 do_tick(now = gHost.now()) {
   throw new Error("unimplemented");
 }

 // Returns whether this sequencer is done running trials.
 done() {
   throw new Error("unimplemented");
 }

 restart(now = gHost.now()) {
   this.reset();
   this.start(now);
 }

 // Returns how long the current load has been running.
 currentLoadElapsed(now = gHost.now()) {
   return now - this.started;
 }
};

// Run a single trial of a mutator and be done.
var SingleMutatorSequencer = class extends Sequencer {
 constructor(mutator, perf, duration_sec) {
   super();
   this.mutator = mutator;
   this.perf = perf;
   if (!(duration_sec > 0)) {
     throw new Error(`invalid duration '${duration_sec}'`);
   }
   this.duration = duration_sec * 1000;
   this.state = 'init'; // init -> running -> done
   this.lastResult = undefined;
 }

 get current() {
   return this.state === 'done' ? undefined : this.mutator;
 }

 reset() {
   this.state = 'init';
 }

 start(now = gHost.now()) {
   if (this.state !== 'init') {
     throw new Error("cannot restart a single-mutator sequencer");
   }
   super.start(now);
   this.state = 'running';
   this.perf.on_load_start(this.current, now);
 }

 do_tick(now) {
   if (this.currentLoadElapsed(now) < this.duration) {
     return false;
   }

   const load = this.current;
   this.state = 'done';
   return this.perf.on_load_end(load, now);
 }

 done() {
   return this.state === 'done';
 }
};

// For each of series of sequencers, run until done.
var ChainSequencer = class extends Sequencer {
 constructor(sequencers) {
   super();
   this.sequencers = sequencers;
   this.idx = -1;
   this.state = sequencers.length ? 'init' : 'done'; // init -> running -> done
 }

 get current() {
   return this.idx >= 0 ? this.sequencers[this.idx].current : undefined;
 }

 reset() {
   this.state = 'init';
   this.idx = -1;
 }

 start(now = gHost.now()) {
   super.start(now);
   if (this.sequencers.length === 0) {
     this.state = 'done';
     return;
   }

   this.idx = 0;
   this.sequencers[0].start(now);
   this.state = 'running';
 }

 do_tick(now) {
   const sequencer = this.sequencers[this.idx];
   const trial_result = sequencer.do_tick(now);
   if (!trial_result) {
     return false; // Trial is still going.
   }

   if (!sequencer.done()) {
     // A single trial has completed, but the sequencer is not yet done.
     return trial_result;
   }

   this.idx++;
   if (this.idx < this.sequencers.length) {
     this.sequencers[this.idx].start();
   } else {
     this.idx = -1;
     this.state = 'done';
   }

   return trial_result;
 }

 done() {
   return this.state === 'done';
 }
};

var RunUntilSequencer = class extends Sequencer {
 constructor(sequencer, loadMgr) {
   super();
   this.loadMgr = loadMgr;
   this.sequencer = sequencer;

   // init -> running -> done
   this.state = sequencer.done() ? 'done' : 'init';
 }

 get current() {
   return this.sequencer?.current;
 }

 reset() {
   this.sequencer.reset();
   this.state = 'init';
 }

 start(now) {
   super.start(now);
   this.sequencer.start(now);
   this.initSearch(now);
   this.state = 'running';
 }

 initSearch(now) {}

 done() {
   return this.state === 'done';
 }

 do_tick(now) {
   const trial_result = this.sequencer.do_tick(now);
   if (trial_result) {
     if (this.searchComplete(trial_result)) {
       this.state = 'done';
     } else {
       this.sequencer.restart(now);
     }
   }
   return trial_result;
 }

 // Take the result of the last mutator run into account (only notified after
 // a mutator is complete, so cannot be used to decide when to end the
 // mutator.)
 searchComplete(result) {
   throw new Error("must implement in subclass");
 }
};

// Run trials, adjusting garbagePerFrame, until 50% of the frames are dropped.
var Find50Sequencer = class extends RunUntilSequencer {
 constructor(sequencer, loadMgr, goal=0.5, low_range=0.45, high_range=0.55) {
   super(sequencer, loadMgr);

   // Run trials with varying garbagePerFrame, looking for a setting that
   // drops 50% of the frames, until we have been searching in the range for
   // `persistence` times.
   this.low_range = low_range;
   this.goal = goal;
   this.high_range = high_range;
   this.persistence = 3;

   this.clear();
 }

 reset() {
   super.reset();
   this.clear();
 }

 clear() {
   this.garbagePerFrame = undefined;

   this.good = undefined;
   this.goodAt = undefined;
   this.bad = undefined;
   this.badAt = undefined;

   this.numInRange = 0;
 }

 start(now) {
   super.start(now);
   if (!this.done()) {
     this.garbagePerFrame = this.sequencer.current.garbagePerFrame;
   }
 }

 searchComplete(result) {
   print(
     `Saw ${percent(result.dropped_60fps_fraction)} with garbagePerFrame=${this.garbagePerFrame}`
   );

   // This is brittle with respect to noise. It might be better to do a linear
   // regression and stop at an error threshold.
   if (result.dropped_60fps_fraction < this.goal) {
     if (this.goodAt === undefined || this.goodAt < this.garbagePerFrame) {
       this.goodAt = this.garbagePerFrame;
       this.good = result.dropped_60fps_fraction;
     }
     if (this.badAt !== undefined) {
       this.garbagePerFrame = Math.trunc(
         (this.garbagePerFrame + this.badAt) / 2
       );
     } else {
       this.garbagePerFrame *= 2;
     }
   } else {
     if (this.badAt === undefined || this.badAt > this.garbagePerFrame) {
       this.badAt = this.garbagePerFrame;
       this.bad = result.dropped_60fps_fraction;
     }
     if (this.goodAt !== undefined) {
       this.garbagePerFrame = Math.trunc(
         (this.garbagePerFrame + this.goodAt) / 2
       );
     } else {
       this.garbagePerFrame = Math.trunc(this.garbagePerFrame / 2);
     }
   }

   if (
     this.low_range < result.dropped_60fps_fraction &&
     result.dropped_60fps_fraction < this.high_range
   ) {
     this.numInRange++;
     if (this.numInRange >= this.persistence) {
       return true;
     }
   }

   print(`next run with ${this.garbagePerFrame}`);
   this.loadMgr.change_garbagePerFrame(this.garbagePerFrame);

   return false;
 }
};