core(config): switch to throttling settings object

lighthouse-core/audits/byte-efficiency/byte-efficiency-audit.js

@@ -137,7 +137,7 @@ class UnusedBytes extends Audit {
   static createAuditResult(result, graph) {
     const simulatorOptions = PredictivePerf.computeRTTAndServerResponseTime(graph);
     // TODO: calibrate multipliers, see https://github.com/GoogleChrome/lighthouse/issues/820
-    Object.assign(simulatorOptions, {cpuTaskMultiplier: 1, layoutTaskMultiplier: 1});
+    Object.assign(simulatorOptions, {cpuSlowdownMultiplier: 1, layoutTaskMultiplier: 1});
     const simulator = new LoadSimulator(graph, simulatorOptions);
 
     const debugString = result.debugString;

lighthouse-core/config/default.js

@@ -6,12 +6,20 @@
 'use strict';
 
 const Driver = require('../gather/driver');
+const emulation = require('../lib/emulation').settings;
 
 /* eslint-disable max-len */
 
 module.exports = {
   settings: {
     maxWaitForLoad: Driver.MAX_WAIT_FOR_FULLY_LOADED,
+    throttlingMethod: 'devtools',
+    throttling: {
+      requestLatency: emulation.TYPICAL_MOBILE_THROTTLING_METRICS.latency,
+      downloadThroughput: emulation.TYPICAL_MOBILE_THROTTLING_METRICS.downloadThroughput * 8,
+      uploadThroughput: emulation.TYPICAL_MOBILE_THROTTLING_METRICS.uploadThroughput * 8,
+      cpuSlowdownMultiplier: emulation.CPU_THROTTLE_METRICS.rate,
+    },
   },
   passes: [{
     passName: 'defaultPass',

lighthouse-core/gather/driver.js

@@ -1033,13 +1033,15 @@ class Driver {
    * @return {Promise<void>}
    */
   async setThrottling(settings, passConfig) {
-    const throttleCpu = passConfig.useThrottling && !settings.disableCpuThrottling;
-    const throttleNetwork = passConfig.useThrottling && !settings.disableNetworkThrottling;
-    const cpuPromise = throttleCpu ?
-        emulation.enableCPUThrottling(this) :
+    if (settings.throttlingMethod !== 'devtools') {
+      return;
+    }
+
+    const cpuPromise = passConfig.useThrottling ?
+        emulation.enableCPUThrottling(this, settings.throttling) :
         emulation.disableCPUThrottling(this);
-    const networkPromise = throttleNetwork ?
-        emulation.enableNetworkThrottling(this) :
+    const networkPromise = passConfig.useThrottling ?
+        emulation.enableNetworkThrottling(this, settings.throttling) :
         emulation.disableNetworkThrottling(this);
 
     await Promise.all([cpuPromise, networkPromise]);
@@ -1056,8 +1058,7 @@ class Driver {
   }
 
   /**
-   * Enable internet connection, using emulated mobile settings if
-   * `options.settings.disableNetworkThrottling` is false.
+   * Enable internet connection, using emulated mobile settings if applicable.
    * @param {{settings: LH.ConfigSettings, passConfig: LH.ConfigPass}} options
    * @return {Promise<void>}
    */

lighthouse-core/lib/dependency-graph/simulator/simulator.js

@@ -22,7 +22,7 @@ const DEFAULT_THROUGHPUT = emulation.TYPICAL_MOBILE_THROTTLING_METRICS.targetDow
 // same multiplier as Lighthouse uses for CPU emulation
 const DEFAULT_CPU_TASK_MULTIPLIER = emulation.CPU_THROTTLE_METRICS.rate;
 // layout tasks tend to be less CPU-bound and do not experience the same increase in duration
-const DEFAULT_LAYOUT_TASK_MULTIPLIER = DEFAULT_CPU_TASK_MULTIPLIER / 2;
+const DEFAULT_LAYOUT_TASK_MULTIPLIER = .5;
 // if a task takes more than 10 seconds it's usually a sign it isn't actually CPU bound and we're overestimating
 const DEFAULT_MAXIMUM_CPU_TASK_DURATION = 10000;
 
@@ -45,7 +45,7 @@ class Simulator {
         rtt: DEFAULT_RTT,
         throughput: DEFAULT_THROUGHPUT,
         maximumConcurrentRequests: DEFAULT_MAXIMUM_CONCURRENT_REQUESTS,
-        cpuTaskMultiplier: DEFAULT_CPU_TASK_MULTIPLIER,
+        cpuSlowdownMultiplier: DEFAULT_CPU_TASK_MULTIPLIER,
         layoutTaskMultiplier: DEFAULT_LAYOUT_TASK_MULTIPLIER,
       },
       options
@@ -57,8 +57,8 @@ class Simulator {
       TcpConnection.maximumSaturatedConnections(this._rtt, this._throughput),
       this._options.maximumConcurrentRequests
     );
-    this._cpuTaskMultiplier = this._options.cpuTaskMultiplier;
-    this._layoutTaskMultiplier = this._options.layoutTaskMultiplier;
+    this._cpuSlowdownMultiplier = this._options.cpuSlowdownMultiplier;
+    this._layoutTaskMultiplier = this._cpuSlowdownMultiplier * this._options.layoutTaskMultiplier;
 
     this._nodeTiming = new Map();
     this._numberInProgressByType = new Map();
@@ -206,7 +206,7 @@ class Simulator {
       const timingData = this._nodeTiming.get(node);
       const multiplier = (/** @type {CpuNode} */ (node)).didPerformLayout()
         ? this._layoutTaskMultiplier
-        : this._cpuTaskMultiplier;
+        : this._cpuSlowdownMultiplier;
       const totalDuration = Math.min(
         Math.round((/** @type {CpuNode} */ (node)).event.dur / 1000 * multiplier),
         DEFAULT_MAXIMUM_CPU_TASK_DURATION
@@ -360,7 +360,7 @@ module.exports = Simulator;
  * @property {number} [throughput]
  * @property {number} [fallbackTTFB]
  * @property {number} [maximumConcurrentRequests]
- * @property {number} [cpuTaskMultiplier]
+ * @property {number} [cpuSlowdownMultiplier]
  * @property {number} [layoutTaskMultiplier]
  */
 

lighthouse-core/lib/emulation.js

@@ -6,6 +6,8 @@
 // @ts-nocheck
 'use strict';
 
+const NBSP = '\xa0';
+
 /**
  * Nexus 5X metrics adapted from emulated_devices/module.json
  */
@@ -118,8 +120,23 @@ function enableNexus5X(driver) {
   ]);
 }
 
-function enableNetworkThrottling(driver) {
-  return driver.sendCommand('Network.emulateNetworkConditions', TYPICAL_MOBILE_THROTTLING_METRICS);
+/**
+ * @param {Driver} driver
+ * @param {LH.ThrottlingSettings|undefined} throttlingSettings
+ * @return {Promise<void>}
+ */
+function enableNetworkThrottling(driver, throttlingSettings) {
+  let conditions = TYPICAL_MOBILE_THROTTLING_METRICS;
+  if (throttlingSettings) {
+    conditions = {
+      offline: false,
+      latency: throttlingSettings.requestLatency,
+      downloadThroughput: throttlingSettings.downloadThroughput / 8,
+      uploadThroughput: throttlingSettings.uploadThroughput / 8,
+    };
+  }
+
+  return driver.sendCommand('Network.emulateNetworkConditions', conditions);
 }
 
 function disableNetworkThrottling(driver) {
@@ -130,22 +147,60 @@ function goOffline(driver) {
   return driver.sendCommand('Network.emulateNetworkConditions', OFFLINE_METRICS);
 }
 
-function enableCPUThrottling(driver) {
-  return driver.sendCommand('Emulation.setCPUThrottlingRate', CPU_THROTTLE_METRICS);
+/**
+ * @param {Driver} driver
+ * @param {LH.ThrottlingSettings|undefined} throttlingSettings
+ * @return {Promise<void>}
+ */
+function enableCPUThrottling(driver, throttlingSettings) {
+  const rate = throttlingSettings
+    ? throttlingSettings.cpuSlowdownMultiplier
+    : CPU_THROTTLE_METRICS.rate;
+  return driver.sendCommand('Emulation.setCPUThrottlingRate', {rate});
 }
 
 function disableCPUThrottling(driver) {
   return driver.sendCommand('Emulation.setCPUThrottlingRate', NO_CPU_THROTTLE_METRICS);
 }
 
-function getEmulationDesc() {
-  const {latency, downloadThroughput, uploadThroughput} = TYPICAL_MOBILE_THROTTLING_METRICS;
-  const byteToMbit = bytes => (bytes / 1024 / 1024 * 8).toFixed(1);
+/**
+ * @param {LH.ConfigSettings} settings
+ * @return {deviceEmulation: string, cpuThrottling: string, networkThrottling: string}
+ */
+function getEmulationDesc(settings) {
+  let cpuThrottling;
+  let networkThrottling;
+  const byteToKbit = bytes => (bytes / 1024 * 8).toFixed();
+
+  switch (settings.throttlingMethod) {
+    case 'provided':
+      cpuThrottling = 'Provided by environment';
+      networkThrottling = 'Provided by environment';
+      break;
+    case 'devtools': {
+      const {cpuSlowdownMultiplier, requestLatency} = settings.throttling;
+      const down = byteToKbit(settings.throttling.downloadThroughput);
+      const up = byteToKbit(settings.throttling.uploadThroughput);
+
+      cpuThrottling = `${cpuSlowdownMultiplier}x slowdown (DevTools)`;
+      networkThrottling = `${requestLatency}${NBSP}ms HTTP RTT, ` +
+        `${down}${NBSP}Kbps down, ${up}${NBSP}Kbps up (DevTools)`;
+      break;
+    }
+    case 'simulate': {
+      const {cpuSlowdownMultiplier, rtt} = settings.throttling;
+      const throughput = byteToKbit(settings.throttling.throughput);
+      cpuThrottling = `${cpuSlowdownMultiplier}x slowdown (Simulated)`;
+      networkThrottling = `${rtt}${NBSP}ms TCP RTT, ` +
+        `${throughput}${NBSP}Kbps throughput (Simulated)`;
+      break;
+    }
+  }
+
   return {
-    'deviceEmulation': 'Nexus 5X',
-    'cpuThrottling': `${CPU_THROTTLE_METRICS.rate}x slowdown`,
-    'networkThrottling': `${latency}ms RTT, ${byteToMbit(downloadThroughput)}Mbps down, ` +
-        `${byteToMbit(uploadThroughput)}Mbps up`,
+    deviceEmulation: settings.disableDeviceEmulation ? 'Disabled' : 'Nexus 5X',
+    cpuThrottling,
+    networkThrottling,
   };
 }
 

lighthouse-core/lib/sentry.js

@@ -82,12 +82,11 @@ sentryDelegate.init = function init(opts) {
     );
   }
 
-  const context = {
+  const context = Object.assign({
     url: opts.url,
     deviceEmulation: !opts.flags.disableDeviceEmulation,
-    networkThrottling: !opts.flags.disableNetworkThrottling,
-    cpuThrottling: !opts.flags.disableCpuThrottling,
-  };
+    throttlingMethod: opts.flags.throttlingMethod,
+  }, opts.flags.throttling);
 
   sentryDelegate.mergeContext({extra: Object.assign({}, environmentData.extra, context)});
   return context;

lighthouse-core/report/v2/renderer/report-renderer.js

@@ -69,8 +69,6 @@ class ReportRenderer {
       const item = this._dom.cloneTemplate('#tmpl-lh-env__items', env);
       this._dom.find('.lh-env__name', item).textContent = runtime.name;
       this._dom.find('.lh-env__description', item).textContent = runtime.description;
-      this._dom.find('.lh-env__enabled', item).textContent =
-          runtime.enabled ? 'Enabled' : 'Disabled';
       env.appendChild(item);
     });
 

lighthouse-core/report/v2/templates.html

@@ -338,9 +338,8 @@ <h1 class="leftnav__header__title">Lighthouse</h1>
               </li>
               <template id="tmpl-lh-env__items">
                 <li class="lh-env__item">
-                  <span class="lh-env__name"><!-- fill me --></span>
-                  <span class="lh-env__description"><!-- fill me --></span>:
-                  <b class="lh-env__enabled"><!-- fill me --></b>
+                  <span class="lh-env__name"><!-- fill me --></span>:
+                  <span class="lh-env__description"><!-- fill me --></span>
                 </li>
               </template>
             </ul>

lighthouse-core/runner.js

@@ -389,21 +389,18 @@ class Runner {
    * @return {!Object} runtime config
    */
   static getRuntimeConfig(settings) {
-    const emulationDesc = emulation.getEmulationDesc();
+    const emulationDesc = emulation.getEmulationDesc(settings);
     const environment = [
       {
         name: 'Device Emulation',
-        enabled: !settings.disableDeviceEmulation,
         description: emulationDesc['deviceEmulation'],
       },
       {
         name: 'Network Throttling',
-        enabled: !settings.disableNetworkThrottling,
         description: emulationDesc['networkThrottling'],
       },
       {
         name: 'CPU Throttling',
-        enabled: !settings.disableCpuThrottling,
         description: emulationDesc['cpuThrottling'],
       },
     ];

lighthouse-core/test/gather/gather-runner-test.js

@@ -148,9 +148,9 @@ describe('GatherRunner', function() {
     return GatherRunner.setupDriver(driver, {}, {
       settings: {},
     }).then(_ => {
-      assert.equal(tests.calledDeviceEmulation, true);
-      assert.equal(tests.calledNetworkEmulation, true);
-      assert.equal(tests.calledCpuEmulation, true);
+      assert.ok(tests.calledDeviceEmulation, 'did not call device emulation');
+      assert.ok(!tests.calledNetworkEmulation, 'called network emulation');
+      assert.ok(!tests.calledCpuEmulation, 'called cpu emulation');
     });
   });
 
@@ -173,6 +173,8 @@ describe('GatherRunner', function() {
     return GatherRunner.setupDriver(driver, {}, {
       settings: {
         disableDeviceEmulation: true,
+        throttlingMethod: 'devtools',
+        throttling: {},
       },
     }).then(_ => {
       assert.equal(tests.calledDeviceEmulation, false);
@@ -181,7 +183,7 @@ describe('GatherRunner', function() {
     });
   });
 
-  it('stops network throttling when disableNetworkThrottling flag is true', () => {
+  it('stops throttling when not devtools', () => {
     const tests = {
       calledDeviceEmulation: false,
       calledNetworkEmulation: false,
@@ -199,18 +201,16 @@ describe('GatherRunner', function() {
 
     return GatherRunner.setupDriver(driver, {}, {
       settings: {
-        disableNetworkThrottling: true,
+        throttlingMethod: 'provided',
       },
     }).then(_ => {
-      assert.ok(tests.calledDeviceEmulation, 'called device emulation');
-      assert.deepEqual(tests.calledNetworkEmulation, [{
-        latency: 0, downloadThroughput: 0, uploadThroughput: 0, offline: false,
-      }]);
-      assert.ok(tests.calledCpuEmulation, 'called CPU emulation');
+      assert.ok(tests.calledDeviceEmulation, 'did not call device emulation');
+      assert.ok(!tests.calledNetworkEmulation, 'called network emulation');
+      assert.ok(!tests.calledCpuEmulation, 'called CPU emulation');
     });
   });
 
-  it('stops cpu throttling when disableCpuThrottling flag is true', () => {
+  it('sets throttling according to settings', () => {
     const tests = {
       calledDeviceEmulation: false,
       calledNetworkEmulation: false,
@@ -228,11 +228,19 @@ describe('GatherRunner', function() {
 
     return GatherRunner.setupDriver(driver, {}, {
       settings: {
-        disableCpuThrottling: true,
+        throttlingMethod: 'devtools',
+        throttling: {
+          requestLatency: 100,
+          downloadThroughput: 800,
+          uploadThroughput: 800,
+          cpuSlowdownMultiplier: 1,
+        },
       },
     }).then(_ => {
-      assert.ok(tests.calledDeviceEmulation, 'called device emulation');
-      assert.ok(tests.calledNetworkEmulation, 'called network emulation');
+      assert.ok(tests.calledDeviceEmulation, 'did not call device emulation');
+      assert.deepEqual(tests.calledNetworkEmulation, [{
+        latency: 100, downloadThroughput: 100, uploadThroughput: 100, offline: false,
+      }]);
       assert.deepEqual(tests.calledCpuEmulation, [{rate: 1}]);
     });
   });

lighthouse-core/test/lib/dependency-graph/simulator/simulator-test.js

@@ -61,7 +61,10 @@ describe('DependencyGraph/Simulator', () => {
       const cpuNode = new CpuNode(cpuTask({duration: 200}));
       cpuNode.addDependency(rootNode);
 
-      const simulator = new Simulator(rootNode, {serverResponseTimeByOrigin, cpuTaskMultiplier: 5});
+      const simulator = new Simulator(rootNode, {
+        serverResponseTimeByOrigin,
+        cpuSlowdownMultiplier: 5,
+      });
       const result = simulator.simulate();
       // should be 2 RTTs and 500ms for the server response time + 200 CPU
       assert.equal(result.timeInMs, 300 + 500 + 200);
@@ -99,7 +102,10 @@ describe('DependencyGraph/Simulator', () => {
       nodeA.addDependent(nodeC);
       nodeA.addDependent(nodeD);
 
-      const simulator = new Simulator(nodeA, {serverResponseTimeByOrigin, cpuTaskMultiplier: 5});
+      const simulator = new Simulator(nodeA, {
+        serverResponseTimeByOrigin,
+        cpuSlowdownMultiplier: 5,
+      });
       const result = simulator.simulate();
       // should be 800ms A, then 1000 ms total for B, C, D in serial
       assert.equal(result.timeInMs, 1800);
@@ -123,7 +129,10 @@ describe('DependencyGraph/Simulator', () => {
       nodeC.addDependent(nodeD);
       nodeC.addDependent(nodeF); // finishes 400 ms after D
 
-      const simulator = new Simulator(nodeA, {serverResponseTimeByOrigin, cpuTaskMultiplier: 5});
+      const simulator = new Simulator(nodeA, {
+        serverResponseTimeByOrigin,
+        cpuSlowdownMultiplier: 5,
+      });
       const result = simulator.simulate();
       // should be 800ms each for A, B, C, D, with F finishing 400 ms after D
       assert.equal(result.timeInMs, 3600);

lighthouse-core/test/report/v2/renderer/report-renderer-test.js

@@ -105,11 +105,9 @@ describe('ReportRenderer V2', () => {
       assert.equal(userAgent.textContent, sampleResults.userAgent, 'user agent populated');
 
       // Check runtime settings were populated.
-      const enables = header.querySelectorAll('.lh-env__enabled');
       const names = Array.from(header.querySelectorAll('.lh-env__name')).slice(1);
       const descriptions = header.querySelectorAll('.lh-env__description');
       sampleResults.runtimeConfig.environment.forEach((env, i) => {
-        assert.equal(enables[i].textContent, env.enabled ? 'Enabled' : 'Disabled');
         assert.equal(names[i].textContent, env.name);
         assert.equal(descriptions[i].textContent, env.description);
       });