lighthouse 12.1.0 → 12.2.0

package/core/lib/lantern/simulation/TCPConnection.test.js

@@ -1,374 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import assert from 'assert/strict';
-
-import * as Lantern from '../lantern.js';
-
-const {TcpConnection} = Lantern.Simulation;
-
-describe('DependencyGraph/Simulator/TcpConnection', () => {
-  describe('#constructor', () => {
-    it('should create the connection', () => {
-      const rtt = 150;
-      const throughput = 1600 * 1024;
-      const connection = new TcpConnection(rtt, throughput);
-      assert.ok(connection);
-      assert.equal(connection._rtt, rtt);
-    });
-  });
-
-  describe('#maximumSaturatedConnections', () => {
-    it('should compute number of supported simulated requests', () => {
-      const availableThroughput = 1460 * 8 * 10; // 10 TCP segments/second
-      assert.equal(TcpConnection.maximumSaturatedConnections(100, availableThroughput), 1);
-      assert.equal(TcpConnection.maximumSaturatedConnections(300, availableThroughput), 3);
-      assert.equal(TcpConnection.maximumSaturatedConnections(1000, availableThroughput), 10);
-    });
-  });
-
-  describe('.setWarmed', () => {
-    it('adjusts the time to download appropriately', () => {
-      const connection = new TcpConnection(100, Infinity);
-      assert.equal(connection.simulateDownloadUntil(0).timeElapsed, 300);
-      connection.setWarmed(true);
-      assert.equal(connection.simulateDownloadUntil(0).timeElapsed, 100);
-    });
-  });
-
-  describe('.setCongestionWindow', () => {
-    it('adjusts the time to download appropriately', () => {
-      const connection = new TcpConnection(100, Infinity);
-      assert.deepEqual(connection.simulateDownloadUntil(50000), {
-        bytesDownloaded: 50000,
-        extraBytesDownloaded: 0,
-        congestionWindow: 40,
-        roundTrips: 5,
-        timeElapsed: 500,
-        connectionTiming: {
-          connectionTime: 250,
-          dnsResolutionTime: 0,
-          sslTime: 100,
-          timeToFirstByte: 300,
-        },
-      });
-      connection.setCongestionWindow(40); // will download all in one round trip
-      assert.deepEqual(connection.simulateDownloadUntil(50000), {
-        bytesDownloaded: 50000,
-        extraBytesDownloaded: 0,
-        congestionWindow: 40,
-        roundTrips: 3,
-        timeElapsed: 300,
-        connectionTiming: {
-          connectionTime: 250,
-          dnsResolutionTime: 0,
-          sslTime: 100,
-          timeToFirstByte: 300,
-        },
-      });
-    });
-  });
-
-  describe('.setH2OverflowBytesDownloaded', () => {
-    it('adjusts the time to download appropriately for H2 connections', () => {
-      const connection = new TcpConnection(100, Infinity, 0, true, true);
-      connection.setWarmed(true);
-      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 200);
-      connection.setH2OverflowBytesDownloaded(20000);
-      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 100);
-      connection.setH2OverflowBytesDownloaded(50000);
-      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 0);
-    });
-
-    it('does not adjust the time to download for non-H2 connections', () => {
-      const connection = new TcpConnection(100, Infinity, 0, true, false);
-      connection.setWarmed(true);
-      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 200);
-      connection.setH2OverflowBytesDownloaded(20000);
-      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 200);
-      connection.setH2OverflowBytesDownloaded(50000);
-      assert.equal(connection.simulateDownloadUntil(30000).timeElapsed, 200);
-    });
-  });
-
-  describe('.simulateDownloadUntil', () => {
-    describe('when maximumTime is not set', () => {
-      it('should provide the correct values small payload non-SSL', () => {
-        const connection = new TcpConnection(100, Infinity, 0, false);
-        assert.deepEqual(connection.simulateDownloadUntil(7300), {
-          bytesDownloaded: 7300,
-          extraBytesDownloaded: 0,
-          congestionWindow: 10,
-          roundTrips: 2,
-          timeElapsed: 200,
-          connectionTiming: {
-            connectionTime: 150,
-            dnsResolutionTime: 0,
-            sslTime: undefined, // non-SSL
-            timeToFirstByte: 200,
-          },
-        });
-      });
-
-      it('should provide the correct values small payload SSL', () => {
-        const connection = new TcpConnection(100, Infinity, 0, true);
-        assert.deepEqual(connection.simulateDownloadUntil(7300), {
-          bytesDownloaded: 7300,
-          extraBytesDownloaded: 0,
-          congestionWindow: 10,
-          roundTrips: 3,
-          timeElapsed: 300,
-          connectionTiming: {
-            connectionTime: 250,
-            dnsResolutionTime: 0,
-            sslTime: 100,
-            timeToFirstByte: 300,
-          },
-        });
-      });
-
-      it('should provide the correct values small payload H2', () => {
-        const connection = new TcpConnection(100, Infinity, 0, true, true);
-        assert.deepEqual(connection.simulateDownloadUntil(7300), {
-          bytesDownloaded: 7300,
-          extraBytesDownloaded: 7300,
-          congestionWindow: 10,
-          roundTrips: 3,
-          timeElapsed: 300,
-          connectionTiming: {
-            connectionTime: 250,
-            dnsResolutionTime: 0,
-            sslTime: 100,
-            timeToFirstByte: 300,
-          },
-        });
-      });
-
-      it('should provide the correct values response time', () => {
-        const responseTime = 78;
-        const connection = new TcpConnection(100, Infinity, responseTime, true);
-        assert.deepEqual(connection.simulateDownloadUntil(7300), {
-          bytesDownloaded: 7300,
-          extraBytesDownloaded: 0,
-          congestionWindow: 10,
-          roundTrips: 3,
-          timeElapsed: 300 + responseTime,
-          connectionTiming: {
-            connectionTime: 250,
-            dnsResolutionTime: 0,
-            sslTime: 100,
-            timeToFirstByte: 378,
-          },
-        });
-      });
-
-      it('should provide the correct values large payload', () => {
-        const connection = new TcpConnection(100, 8 * 1000 * 1000);
-        const bytesToDownload = 10 * 1000 * 1000; // 10 mb
-        assert.deepEqual(connection.simulateDownloadUntil(bytesToDownload), {
-          bytesDownloaded: bytesToDownload,
-          extraBytesDownloaded: 0,
-          congestionWindow: 68,
-          roundTrips: 105,
-          timeElapsed: 10500,
-          connectionTiming: {
-            connectionTime: 250,
-            dnsResolutionTime: 0,
-            sslTime: 100,
-            timeToFirstByte: 300,
-          },
-        });
-      });
-
-      it('should provide the correct values resumed small payload', () => {
-        const connection = new TcpConnection(100, Infinity, 0, true);
-        assert.deepEqual(connection.simulateDownloadUntil(7300, {timeAlreadyElapsed: 250}), {
-          bytesDownloaded: 7300,
-          extraBytesDownloaded: 0,
-          congestionWindow: 10,
-          roundTrips: 3,
-          timeElapsed: 50,
-          connectionTiming: {
-            connectionTime: 250,
-            dnsResolutionTime: 0,
-            sslTime: 100,
-            timeToFirstByte: 300,
-          },
-        });
-      });
-
-      it('should provide the correct values resumed small payload H2', () => {
-        const connection = new TcpConnection(100, Infinity, 0, true, true);
-        connection.setWarmed(true);
-        connection.setH2OverflowBytesDownloaded(10000);
-        assert.deepEqual(connection.simulateDownloadUntil(7300), {
-          bytesDownloaded: 0,
-          extraBytesDownloaded: 2700, // 10000 - 7300
-          congestionWindow: 10,
-          roundTrips: 0,
-          timeElapsed: 0,
-          connectionTiming: {
-            timeToFirstByte: 0,
-          },
-        });
-      });
-
-      it('should provide the correct values resumed large payload', () => {
-        const connection = new TcpConnection(100, 8 * 1000 * 1000);
-        const bytesToDownload = 5 * 1000 * 1000; // 5 mb
-        connection.setCongestionWindow(68);
-        assert.deepEqual(
-          connection.simulateDownloadUntil(bytesToDownload, {timeAlreadyElapsed: 5234}),
-          {
-            bytesDownloaded: bytesToDownload,
-            extraBytesDownloaded: 0,
-            congestionWindow: 68,
-            roundTrips: 51, // 5 mb / (1460 * 68)
-            timeElapsed: 5100,
-            connectionTiming: {
-              connectionTime: 250,
-              dnsResolutionTime: 0,
-              sslTime: 100,
-              timeToFirstByte: 300,
-            },
-          }
-        );
-      });
-    });
-
-    describe('when maximumTime is set', () => {
-      it('should provide the correct values less than TTFB', () => {
-        const connection = new TcpConnection(100, Infinity, 0, false);
-        assert.deepEqual(
-          connection.simulateDownloadUntil(7300, {timeAlreadyElapsed: 0, maximumTimeToElapse: 68}),
-          {
-            bytesDownloaded: 7300,
-            extraBytesDownloaded: 0,
-            congestionWindow: 10,
-            roundTrips: 2,
-            timeElapsed: 200,
-            connectionTiming: {
-              connectionTime: 150,
-              dnsResolutionTime: 0,
-              sslTime: undefined, // non-SSL
-              timeToFirstByte: 200,
-            },
-          }
-        );
-      });
-
-      it('should provide the correct values just over TTFB', () => {
-        const connection = new TcpConnection(100, Infinity, 0, false);
-        assert.deepEqual(
-          connection.simulateDownloadUntil(7300, {timeAlreadyElapsed: 0, maximumTimeToElapse: 250}),
-          {
-            bytesDownloaded: 7300,
-            extraBytesDownloaded: 0,
-            congestionWindow: 10,
-            roundTrips: 2,
-            timeElapsed: 200,
-            connectionTiming: {
-              connectionTime: 150,
-              dnsResolutionTime: 0,
-              sslTime: undefined, // non-SSL
-              timeToFirstByte: 200,
-            },
-          }
-        );
-      });
-
-      it('should provide the correct values with already elapsed', () => {
-        const connection = new TcpConnection(100, Infinity, 0, false);
-        assert.deepEqual(
-          connection.simulateDownloadUntil(7300, {
-            timeAlreadyElapsed: 75,
-            maximumTimeToElapse: 250,
-          }),
-          {
-            bytesDownloaded: 7300,
-            extraBytesDownloaded: 0,
-            congestionWindow: 10,
-            roundTrips: 2,
-            timeElapsed: 125,
-            connectionTiming: {
-              connectionTime: 150,
-              dnsResolutionTime: 0,
-              sslTime: undefined, // non-SSL
-              timeToFirstByte: 200,
-            },
-          }
-        );
-      });
-
-      it('should provide the correct values large payloads', () => {
-        const connection = new TcpConnection(100, 8 * 1000 * 1000);
-        const bytesToDownload = 10 * 1000 * 1000; // 10 mb
-        assert.deepEqual(
-          connection.simulateDownloadUntil(bytesToDownload, {
-            timeAlreadyElapsed: 500,
-            maximumTimeToElapse: 740,
-          }),
-          {
-            bytesDownloaded: 683280, // should be less than 68 * 1460 * 8
-            extraBytesDownloaded: 0,
-            congestionWindow: 68,
-            roundTrips: 8,
-            timeElapsed: 800, // skips the handshake because time already elapsed
-            connectionTiming: {
-              connectionTime: 250,
-              dnsResolutionTime: 0,
-              sslTime: 100,
-              timeToFirstByte: 300,
-            },
-          }
-        );
-      });
-
-      it('should all add up', () => {
-        const connection = new TcpConnection(100, 8 * 1000 * 1000);
-        const bytesToDownload = 10 * 1000 * 1000; // 10 mb
-        const firstStoppingPoint = 5234;
-        const secondStoppingPoint = 315;
-        const thirdStoppingPoint = 10500 - firstStoppingPoint - secondStoppingPoint;
-
-        const firstSegment = connection.simulateDownloadUntil(bytesToDownload, {
-          timeAlreadyElapsed: 0,
-          maximumTimeToElapse: firstStoppingPoint,
-        });
-        const firstOvershoot = firstSegment.timeElapsed - firstStoppingPoint;
-
-        connection.setCongestionWindow(firstSegment.congestionWindow);
-        const secondSegment = connection.simulateDownloadUntil(
-          bytesToDownload - firstSegment.bytesDownloaded,
-          {
-            timeAlreadyElapsed: firstSegment.timeElapsed,
-            maximumTimeToElapse: secondStoppingPoint - firstOvershoot,
-          }
-        );
-        const secondOvershoot = firstOvershoot + secondSegment.timeElapsed - secondStoppingPoint;
-
-        connection.setCongestionWindow(secondSegment.congestionWindow);
-        const thirdSegment = connection.simulateDownloadUntil(
-          bytesToDownload - firstSegment.bytesDownloaded - secondSegment.bytesDownloaded,
-          {timeAlreadyElapsed: firstSegment.timeElapsed + secondSegment.timeElapsed}
-        );
-        const thirdOvershoot = secondOvershoot + thirdSegment.timeElapsed - thirdStoppingPoint;
-
-        assert.equal(thirdOvershoot, 0);
-        assert.equal(
-          firstSegment.bytesDownloaded +
-            secondSegment.bytesDownloaded +
-            thirdSegment.bytesDownloaded,
-          bytesToDownload
-        );
-        assert.equal(
-          firstSegment.timeElapsed + secondSegment.timeElapsed + thirdSegment.timeElapsed,
-          10500
-        );
-      });
-    });
-  });
-});

package/core/lib/lantern/simulation/TcpConnection.d.ts

@@ -1,89 +0,0 @@
-export type ConnectionTiming = import('./SimulationTimingMap.js').ConnectionTiming;
-export type DownloadOptions = {
-    dnsResolutionTime?: number | undefined;
-    timeAlreadyElapsed?: number | undefined;
-    maximumTimeToElapse?: number | undefined;
-};
-export type DownloadResults = {
-    roundTrips: number;
-    timeElapsed: number;
-    bytesDownloaded: number;
-    extraBytesDownloaded: number;
-    congestionWindow: number;
-    connectionTiming: ConnectionTiming;
-};
-export class TcpConnection {
-    /**
-     * @param {number} rtt
-     * @param {number} availableThroughput
-     * @return {number}
-     */
-    static maximumSaturatedConnections(rtt: number, availableThroughput: number): number;
-    /**
-     * @param {number} rtt
-     * @param {number} throughput
-     * @param {number=} serverLatency
-     * @param {boolean=} ssl
-     * @param {boolean=} h2
-     */
-    constructor(rtt: number, throughput: number, serverLatency?: number | undefined, ssl?: boolean | undefined, h2?: boolean | undefined);
-    _warmed: boolean;
-    _ssl: boolean;
-    _h2: boolean;
-    _rtt: number;
-    _throughput: number;
-    _serverLatency: number;
-    _congestionWindow: number;
-    _h2OverflowBytesDownloaded: number;
-    /**
-     * @return {number}
-     */
-    _computeMaximumCongestionWindowInSegments(): number;
-    /**
-     * @param {number} throughput
-     */
-    setThroughput(throughput: number): void;
-    /**
-     * @param {number} congestion
-     */
-    setCongestionWindow(congestion: number): void;
-    /**
-     * @param {boolean} warmed
-     */
-    setWarmed(warmed: boolean): void;
-    /**
-     * @return {boolean}
-     */
-    isWarm(): boolean;
-    /**
-     * @return {boolean}
-     */
-    isH2(): boolean;
-    /**
-     * @return {number}
-     */
-    get congestionWindow(): number;
-    /**
-     * Sets the number of excess bytes that are available to this connection on future downloads, only
-     * applies to H2 connections.
-     * @param {number} bytes
-     */
-    setH2OverflowBytesDownloaded(bytes: number): void;
-    /**
-     * @return {TcpConnection}
-     */
-    clone(): TcpConnection;
-    /**
-     * Simulates a network download of a particular number of bytes over an optional maximum amount of time
-     * and returns information about the ending state.
-     *
-     * See https://hpbn.co/building-blocks-of-tcp/#three-way-handshake and
-     *  https://hpbn.co/transport-layer-security-tls/#tls-handshake for details.
-     *
-     * @param {number} bytesToDownload
-     * @param {DownloadOptions} [options]
-     * @return {DownloadResults}
-     */
-    simulateDownloadUntil(bytesToDownload: number, options?: DownloadOptions | undefined): DownloadResults;
-}
-//# sourceMappingURL=TcpConnection.d.ts.map

package/core/lib/lantern/simulation/TcpConnection.js

@@ -1,230 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/** @typedef {import('./SimulationTimingMap.js').ConnectionTiming} ConnectionTiming */
-
-const INITIAL_CONGESTION_WINDOW = 10;
-const TCP_SEGMENT_SIZE = 1460;
-
-class TcpConnection {
-  /**
-   * @param {number} rtt
-   * @param {number} throughput
-   * @param {number=} serverLatency
-   * @param {boolean=} ssl
-   * @param {boolean=} h2
-   */
-  constructor(rtt, throughput, serverLatency = 0, ssl = true, h2 = false) {
-    this._warmed = false;
-    this._ssl = ssl;
-    this._h2 = h2;
-    this._rtt = rtt;
-    this._throughput = throughput;
-    this._serverLatency = serverLatency;
-    this._congestionWindow = INITIAL_CONGESTION_WINDOW;
-    this._h2OverflowBytesDownloaded = 0;
-  }
-
-  /**
-   * @param {number} rtt
-   * @param {number} availableThroughput
-   * @return {number}
-   */
-  static maximumSaturatedConnections(rtt, availableThroughput) {
-    const roundTripsPerSecond = 1000 / rtt;
-    const bytesPerRoundTrip = TCP_SEGMENT_SIZE;
-    const bytesPerSecond = roundTripsPerSecond * bytesPerRoundTrip;
-    const minimumThroughputRequiredPerRequest = bytesPerSecond * 8;
-    return Math.floor(availableThroughput / minimumThroughputRequiredPerRequest);
-  }
-
-  /**
-   * @return {number}
-   */
-  _computeMaximumCongestionWindowInSegments() {
-    const bytesPerSecond = this._throughput / 8;
-    const secondsPerRoundTrip = this._rtt / 1000;
-    const bytesPerRoundTrip = bytesPerSecond * secondsPerRoundTrip;
-    return Math.floor(bytesPerRoundTrip / TCP_SEGMENT_SIZE);
-  }
-
-  /**
-   * @param {number} throughput
-   */
-  setThroughput(throughput) {
-    this._throughput = throughput;
-  }
-
-  /**
-   * @param {number} congestion
-   */
-  setCongestionWindow(congestion) {
-    this._congestionWindow = congestion;
-  }
-
-  /**
-   * @param {boolean} warmed
-   */
-  setWarmed(warmed) {
-    this._warmed = warmed;
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isWarm() {
-    return this._warmed;
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isH2() {
-    return this._h2;
-  }
-
-  /**
-   * @return {number}
-   */
-  get congestionWindow() {
-    return this._congestionWindow;
-  }
-
-  /**
-   * Sets the number of excess bytes that are available to this connection on future downloads, only
-   * applies to H2 connections.
-   * @param {number} bytes
-   */
-  setH2OverflowBytesDownloaded(bytes) {
-    if (!this._h2) return;
-    this._h2OverflowBytesDownloaded = bytes;
-  }
-
-  /**
-   * @return {TcpConnection}
-   */
-  clone() {
-    return Object.assign(new TcpConnection(this._rtt, this._throughput), this);
-  }
-
-  /**
-   * Simulates a network download of a particular number of bytes over an optional maximum amount of time
-   * and returns information about the ending state.
-   *
-   * See https://hpbn.co/building-blocks-of-tcp/#three-way-handshake and
-   *  https://hpbn.co/transport-layer-security-tls/#tls-handshake for details.
-   *
-   * @param {number} bytesToDownload
-   * @param {DownloadOptions} [options]
-   * @return {DownloadResults}
-   */
-  simulateDownloadUntil(bytesToDownload, options) {
-    const {timeAlreadyElapsed = 0, maximumTimeToElapse = Infinity, dnsResolutionTime = 0} =
-      options || {};
-
-    if (this._warmed && this._h2) {
-      bytesToDownload -= this._h2OverflowBytesDownloaded;
-    }
-    const twoWayLatency = this._rtt;
-    const oneWayLatency = twoWayLatency / 2;
-    const maximumCongestionWindow = this._computeMaximumCongestionWindowInSegments();
-
-    let handshakeAndRequest = oneWayLatency;
-    if (!this._warmed) {
-      handshakeAndRequest =
-        // DNS lookup
-        dnsResolutionTime +
-        // SYN
-        oneWayLatency +
-        // SYN ACK
-        oneWayLatency +
-        // ACK + initial request
-        oneWayLatency +
-        // ClientHello/ServerHello assuming TLS False Start is enabled (https://istlsfastyet.com/#server-performance).
-        (this._ssl ? twoWayLatency : 0);
-    }
-
-    let roundTrips = Math.ceil(handshakeAndRequest / twoWayLatency);
-    let timeToFirstByte = handshakeAndRequest + this._serverLatency + oneWayLatency;
-    if (this._warmed && this._h2) timeToFirstByte = 0;
-
-    const timeElapsedForTTFB = Math.max(timeToFirstByte - timeAlreadyElapsed, 0);
-    const maximumDownloadTimeToElapse = maximumTimeToElapse - timeElapsedForTTFB;
-
-    let congestionWindow = Math.min(this._congestionWindow, maximumCongestionWindow);
-    let totalBytesDownloaded = 0;
-    if (timeElapsedForTTFB > 0) {
-      totalBytesDownloaded = congestionWindow * TCP_SEGMENT_SIZE;
-    } else {
-      roundTrips = 0;
-    }
-
-    let downloadTimeElapsed = 0;
-    let bytesRemaining = bytesToDownload - totalBytesDownloaded;
-    while (bytesRemaining > 0 && downloadTimeElapsed <= maximumDownloadTimeToElapse) {
-      roundTrips++;
-      downloadTimeElapsed += twoWayLatency;
-      congestionWindow = Math.max(Math.min(maximumCongestionWindow, congestionWindow * 2), 1);
-
-      const bytesDownloadedInWindow = congestionWindow * TCP_SEGMENT_SIZE;
-      totalBytesDownloaded += bytesDownloadedInWindow;
-      bytesRemaining -= bytesDownloadedInWindow;
-    }
-
-    const timeElapsed = timeElapsedForTTFB + downloadTimeElapsed;
-    const extraBytesDownloaded = this._h2 ? Math.max(totalBytesDownloaded - bytesToDownload, 0) : 0;
-    const bytesDownloaded = Math.max(Math.min(totalBytesDownloaded, bytesToDownload), 0);
-
-    /** @type {ConnectionTiming} */
-    let connectionTiming;
-    if (!this._warmed) {
-      connectionTiming = {
-        dnsResolutionTime,
-        connectionTime: handshakeAndRequest - dnsResolutionTime,
-        sslTime: this._ssl ? twoWayLatency : undefined,
-        timeToFirstByte,
-      };
-    } else if (this._h2) {
-      // TODO: timing information currently difficult to model for warm h2 connections.
-      connectionTiming = {
-        timeToFirstByte,
-      };
-    } else {
-      connectionTiming = {
-        connectionTime: handshakeAndRequest,
-        timeToFirstByte,
-      };
-    }
-
-    return {
-      roundTrips,
-      timeElapsed,
-      bytesDownloaded,
-      extraBytesDownloaded,
-      congestionWindow,
-      connectionTiming,
-    };
-  }
-}
-
-export {TcpConnection};
-
-/**
- * @typedef DownloadOptions
- * @property {number} [dnsResolutionTime]
- * @property {number} [timeAlreadyElapsed]
- * @property {number} [maximumTimeToElapse]
- */
-
-/**
- * @typedef DownloadResults
- * @property {number} roundTrips
- * @property {number} timeElapsed
- * @property {number} bytesDownloaded
- * @property {number} extraBytesDownloaded
- * @property {number} congestionWindow
- * @property {ConnectionTiming} connectionTiming
- */