core(lantern): cleanup Simulator construction

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

@@ -7,8 +7,7 @@
 
 const Audit = require('../audit');
 const ConsistentlyInteractive = require('../../gather/computed/metrics/lantern-consistently-interactive'); // eslint-disable-line max-len
-const NetworkAnalysis = require('../../gather/computed/network-analysis');
-const LoadSimulator = require('../../lib/dependency-graph/simulator/simulator.js');
+const Simulator = require('../../lib/dependency-graph/simulator/simulator'); // eslint-disable-line no-unused-vars
 
 const KB_IN_BYTES = 1024;
 
@@ -69,33 +68,43 @@ class UnusedBytes extends Audit {
   }
 
   /**
-   * @param {!Artifacts} artifacts
-   * @return {!Promise<!AuditResult>}
+   * @param {Artifacts} artifacts
+   * @param {LH.Audit.Context=} context
+   * @return {Promise<AuditResult>}
    */
-  static audit(artifacts) {
+  static audit(artifacts, context) {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const settings = context && context.settings || {};
+    const simulatorOptions = {
+      devtoolsLog,
+      throttlingMethod: settings.throttlingMethod,
+      throttling: settings.throttling,
+    };
+
     return artifacts
       .requestNetworkRecords(devtoolsLog)
       .then(networkRecords =>
         Promise.all([
           this.audit_(artifacts, networkRecords),
           artifacts.requestPageDependencyGraph({trace, devtoolsLog}),
+          artifacts.requestLoadSimulator(simulatorOptions),
         ])
       )
-      .then(([result, graph]) => this.createAuditResult(result, graph));
+      .then(([result, graph, simulator]) => this.createAuditResult(result, graph, simulator));
   }
 
   /**
    * Computes the estimated effect of all the byte savings on the last long task
    * in the provided graph.
    *
-   * @param {!Array<{url: string, wastedBytes: number}>} results The array of byte savings results per resource
-   * @param {!Node} graph
+   * @param {Array<{url: string, wastedBytes: number}>} results The array of byte savings results per resource
+   * @param {Node} graph
+   * @param {Simulator} simulator
    * @return {number}
    */
   static computeWasteWithTTIGraph(results, graph, simulator) {
-    const simulationBeforeChanges = simulator.simulate();
+    const simulationBeforeChanges = simulator.simulate(graph);
     const resultsByUrl = new Map();
     for (const result of results) {
       resultsByUrl.set(result.url, result);
@@ -112,7 +121,7 @@ class UnusedBytes extends Audit {
       node.record._transferSize = Math.max(original - wastedBytes, 0);
     });
 
-    const simulationAfterChanges = simulator.simulate();
+    const simulationAfterChanges = simulator.simulate(graph);
     // Restore the original transfer size after we've done our simulation
     graph.traverse(node => {
       if (node.type !== 'network') return;
@@ -131,20 +140,12 @@ class UnusedBytes extends Audit {
   }
 
   /**
-   * @param {!Audit.HeadingsResult} result
-   * @param {!Node} graph
-   * @return {!AuditResult}
+   * @param {Audit.HeadingsResult} result
+   * @param {Node} graph
+   * @param {Simulator} simulator
+   * @return {AuditResult}
    */
-  static createAuditResult(result, graph) {
-    const records = [];
-    graph.traverse(node => node.record && records.push(node.record));
-    const simulatorOptions = NetworkAnalysis.computeRTTAndServerResponseTime(records);
-    // TODO: use rtt/throughput from config.settings instead of defaults
-    delete simulatorOptions.rtt;
-    // TODO: calibrate multipliers, see https://github.com/GoogleChrome/lighthouse/issues/820
-    Object.assign(simulatorOptions, {cpuSlowdownMultiplier: 1, layoutTaskMultiplier: 1});
-    const simulator = new LoadSimulator(graph, simulatorOptions);
-
+  static createAuditResult(result, graph, simulator) {
     const debugString = result.debugString;
     const results = result.results.sort((itemA, itemB) => itemB.wastedBytes - itemA.wastedBytes);
 

lighthouse-core/config/constants.js

@@ -14,6 +14,8 @@ const DEVTOOLS_RTT_ADJUSTMENT_FACTOR = 3.75;
 const DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR = 0.9;
 
 const throttling = {
+  DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
+  DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
   mobile3G: {
     rttMs: 150,
     throughputKbps: 1.6 * 1024,

lighthouse-core/gather/computed/load-simulator.js

@@ -0,0 +1,66 @@
+/**
+ * @license Copyright 2018 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+'use strict';
+
+const ComputedArtifact = require('./computed-artifact');
+const constants = require('../../config/constants');
+const Simulator = require('../../lib/dependency-graph/simulator/simulator');
+
+class LoadSimulatorArtifact extends ComputedArtifact {
+  get name() {
+    return 'LoadSimulator';
+  }
+
+  /**
+   * @param {{devtoolsLog: Array, settings: LH.ConfigSettings|undefined}} data
+   * @param {!Artifacts} artifacts
+   * @return {!Promise}
+   */
+  async compute_(data, artifacts) {
+    const {throttlingMethod, throttling} = data.settings || {};
+    const networkAnalysis = await artifacts.requestNetworkAnalysis(data.devtoolsLog);
+
+    const options = {
+      additionalRttByOrigin: networkAnalysis.additionalRttByOrigin,
+      serverResponseTimeByOrigin: networkAnalysis.serverResponseTimeByOrigin,
+    };
+
+    switch (throttlingMethod) {
+      case 'provided':
+        options.rtt = networkAnalysis.rtt;
+        options.throughput = networkAnalysis.throughput;
+        options.cpuSlowdownMultiplier = 1;
+        options.layoutTaskMultiplier = 1;
+        break;
+      case 'devtools':
+        if (throttling) {
+          options.rtt =
+            throttling.requestLatencyMs / constants.throttling.DEVTOOLS_RTT_ADJUSTMENT_FACTOR;
+          options.throughput =
+            throttling.downloadThroughputKbps * 1024 /
+            constants.throttling.DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR;
+        }
+
+        options.cpuSlowdownMultiplier = 1;
+        options.layoutTaskMultiplier = 1;
+        break;
+      case 'simulate':
+        if (throttling) {
+          options.rtt = throttling.rttMs;
+          options.throughput = throttling.throughputKbps * 1024;
+          options.cpuSlowdownMultiplier = throttling.cpuSlowdownMultiplier;
+        }
+        break;
+      default:
+        // intentionally fallback to simulator defaults
+        break;
+    }
+
+    return new Simulator(options);
+  }
+}
+
+module.exports = LoadSimulatorArtifact;

lighthouse-core/gather/computed/metrics/lantern-metric.js

@@ -8,7 +8,7 @@
 const ComputedArtifact = require('../computed-artifact');
 const Node = require('../../../lib/dependency-graph/node');
 const NetworkNode = require('../../../lib/dependency-graph/network-node'); // eslint-disable-line no-unused-vars
-const Simulator = require('../../../lib/dependency-graph/simulator/simulator');
+const Simulator = require('../../../lib/dependency-graph/simulator/simulator'); // eslint-disable-line no-unused-vars
 const WebInspector = require('../../../lib/web-inspector');
 
 class LanternMetricArtifact extends ComputedArtifact {
@@ -75,19 +75,15 @@ class LanternMetricArtifact extends ComputedArtifact {
     const {trace, devtoolsLog} = data;
     const graph = await artifacts.requestPageDependencyGraph({trace, devtoolsLog});
     const traceOfTab = await artifacts.requestTraceOfTab(trace);
-    const networkAnalysis = await artifacts.requestNetworkAnalysis(devtoolsLog);
+    // TODO(phulce): passthrough settings once all metrics are converted to computed artifacts
+    /** @type {Simulator} */
+    const simulator = await artifacts.requestLoadSimulator({devtoolsLog});
 
     const optimisticGraph = this.getOptimisticGraph(graph, traceOfTab);
     const pessimisticGraph = this.getPessimisticGraph(graph, traceOfTab);
 
-    // TODO(phulce): use rtt and throughput from config.settings instead of defaults
-    const options = {
-      additionalRttByOrigin: networkAnalysis.additionalRttByOrigin,
-      serverResponseTimeByOrigin: networkAnalysis.serverResponseTimeByOrigin,
-    };
-
-    const optimisticSimulation = new Simulator(optimisticGraph, options).simulate();
-    const pessimisticSimulation = new Simulator(pessimisticGraph, options).simulate();
+    const optimisticSimulation = simulator.simulate(optimisticGraph);
+    const pessimisticSimulation = simulator.simulate(pessimisticGraph);
 
     const optimisticEstimate = this.getEstimateFromSimulation(
       optimisticSimulation,

lighthouse-core/gather/computed/network-analysis.js

@@ -50,7 +50,7 @@ class NetworkAnalysis extends ComputedArtifact {
     const records = await artifacts.requestNetworkRecords(devtoolsLog);
     const throughput = await artifacts.requestNetworkThroughput(devtoolsLog);
     const rttAndServerResponseTime = NetworkAnalysis.computeRTTAndServerResponseTime(records);
-    rttAndServerResponseTime.throughput = throughput;
+    rttAndServerResponseTime.throughput = throughput * 8; // convert from KBps to Kbps
     return rttAndServerResponseTime;
   }
 }

lighthouse-core/gather/computed/network-throughput.js

@@ -65,6 +65,7 @@ class NetworkThroughput extends ComputedArtifact {
    * @return {!Promise<!Object>}
    */
   compute_(devtoolsLog, artifacts) {
+    // TODO(phulce): migrate this to network-analysis computed artifact
     return artifacts.requestNetworkRecords(devtoolsLog)
       .then(NetworkThroughput.getThroughput);
   }

lighthouse-core/gather/gather-runner.js

@@ -444,8 +444,8 @@ class GatherRunner {
       .then(_ => GatherRunner.disposeDriver(driver))
       .then(_ => GatherRunner.collectArtifacts(gathererResults))
       .then(artifacts => {
-        // Add tracing data to the artifacts object.
-        return Object.assign(artifacts, tracingData);
+        // Add tracing data and settings used to the artifacts object.
+        return Object.assign(artifacts, tracingData, {settings: options.settings});
       })
       // cleanup on error
       .catch(err => {

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

@@ -28,11 +28,9 @@ const NodeState = {
 
 class Simulator {
   /**
-   * @param {Node} graph
    * @param {LH.Gatherer.Simulation.Options} [options]
    */
-  constructor(graph, options) {
-    this._graph = graph;
+  constructor(options) {
     this._options = Object.assign(
       {
         rtt: mobile3G.rttMs,
@@ -46,13 +44,14 @@ class Simulator {
 
     this._rtt = this._options.rtt;
     this._throughput = this._options.throughput;
-    this._maximumConcurrentRequests = Math.min(
+    this._maximumConcurrentRequests = Math.max(Math.min(
       TcpConnection.maximumSaturatedConnections(this._rtt, this._throughput),
       this._options.maximumConcurrentRequests
-    );
+    ), 1);
     this._cpuSlowdownMultiplier = this._options.cpuSlowdownMultiplier;
     this._layoutTaskMultiplier = this._cpuSlowdownMultiplier * this._options.layoutTaskMultiplier;
 
+    // Properties reset on every `.simulate` call but duplicated here for type checking
     this._nodeTiming = new Map();
     this._numberInProgressByType = new Map();
     this._nodes = {};
@@ -61,12 +60,12 @@ class Simulator {
   }
 
   /**
-   *
+   * @param {Node} graph
    */
-  _initializeConnectionPool() {
+  _initializeConnectionPool(graph) {
     /** @type {LH.WebInspector.NetworkRequest[]} */
     const records = [];
-    this._graph.getRootNode().traverse(node => {
+    graph.getRootNode().traverse(node => {
       if (node.type === Node.TYPES.NETWORK) {
         records.push(/** @type {NetworkNode} */ (node).record);
       }
@@ -281,18 +280,19 @@ class Simulator {
 
   /**
    * Estimates the time taken to process all of the graph's nodes.
+   * @param {Node} graph
    * @return {LH.Gatherer.Simulation.Result}
    */
-  simulate() {
+  simulate(graph) {
     // initialize the necessary data containers
-    this._initializeConnectionPool();
+    this._initializeConnectionPool(graph);
     this._initializeAuxiliaryData();
 
     const nodesNotReadyToStart = this._nodes[NodeState.NotReadyToStart];
     const nodesReadyToStart = this._nodes[NodeState.ReadyToStart];
     const nodesInProgress = this._nodes[NodeState.InProgress];
 
-    const rootNode = this._graph.getRootNode();
+    const rootNode = graph.getRootNode();
     rootNode.traverse(node => nodesNotReadyToStart.add(node));
 
     let totalElapsedTime = 0;

lighthouse-core/runner.js

@@ -6,6 +6,7 @@
 // @ts-nocheck
 'use strict';
 
+const isDeepEqual = require('lodash.isequal');
 const Driver = require('./gather/driver.js');
 const GatherRunner = require('./gather/gather-runner');
 const ReportScoring = require('./scoring');
@@ -177,12 +178,23 @@ class Runner {
     artifacts = Object.assign(Runner.instantiateComputedArtifacts(),
         artifacts || opts.config.artifacts);
 
+    if (artifacts.settings) {
+      const overrides = {gatherMode: undefined, auditMode: undefined};
+      const normalizedGatherSettings = Object.assign({}, artifacts.settings, overrides);
+      const normalizedAuditSettings = Object.assign({}, opts.settings, overrides);
+
+      // TODO(phulce): allow change of throttling method to `simulate`
+      if (!isDeepEqual(normalizedGatherSettings, normalizedAuditSettings)) {
+        throw new Error('Cannot change settings between gathering and auditing');
+      }
+    }
+
     // Run each audit sequentially
     const auditResults = [];
     let promise = Promise.resolve();
     for (const auditDefn of opts.config.audits) {
       promise = promise.then(_ => {
-        return Runner._runAudit(auditDefn, artifacts).then(ret => auditResults.push(ret));
+        return Runner._runAudit(auditDefn, artifacts, opts).then(ret => auditResults.push(ret));
       });
     }
     return promise.then(_ => {
@@ -204,10 +216,11 @@ class Runner {
    * Otherwise returns error audit result.
    * @param {!Audit} audit
    * @param {!Artifacts} artifacts
+   * @param {{settings: LH.ConfigSettings}} opts
    * @return {!Promise<!AuditResult>}
    * @private
    */
-  static _runAudit(auditDefn, artifacts) {
+  static _runAudit(auditDefn, artifacts, opts) {
     const audit = auditDefn.implementation;
     const status = `Evaluating: ${audit.meta.description}`;
 
@@ -248,7 +261,7 @@ class Runner {
         }
       }
       // all required artifacts are in good shape, so we proceed
-      return audit.audit(artifacts, {options: auditDefn.options || {}});
+      return audit.audit(artifacts, {options: auditDefn.options || {}, settings: opts.settings});
     // Fill remaining audit result fields.
     }).then(auditResult => Audit.generateAuditResult(audit, auditResult))
     .catch(err => {