lighthouse 12.1.0-dev.20240629 → 12.1.0-dev.20240701

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

@@ -1,219 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../lantern.js';
-
-/**
- * @fileoverview
- *
- * This class encapsulates the type-related validation logic for moving timing information for nodes
- * through the different simulation phases. Methods here ensure that the invariants of simulation hold
- * as nodes are queued, partially simulated, and completed.
- */
-
-/** @typedef {import('../BaseNode.js').Node} Node */
-/** @typedef {import('../NetworkNode.js').NetworkNode} NetworkNode */
-/** @typedef {import('../CpuNode.js').CPUNode} CpuNode */
-
-/**
- * @typedef NodeTimingComplete
- * @property {number} startTime
- * @property {number} endTime
- * @property {number} queuedTime Helpful for debugging.
- * @property {number} estimatedTimeElapsed
- * @property {number} timeElapsed
- * @property {number} timeElapsedOvershoot
- * @property {number} bytesDownloaded
- */
-
-/** @typedef {Pick<NodeTimingComplete, 'queuedTime'>} NodeTimingQueued */
-
-/** @typedef {NodeTimingQueued & Pick<NodeTimingComplete, 'startTime'|'timeElapsed'>} CpuNodeTimingStarted */
-/** @typedef {CpuNodeTimingStarted & Pick<NodeTimingComplete, 'timeElapsedOvershoot'|'bytesDownloaded'>} NetworkNodeTimingStarted */
-
-/** @typedef {CpuNodeTimingStarted & Pick<NodeTimingComplete, 'estimatedTimeElapsed'>} CpuNodeTimingInProgress */
-/** @typedef {NetworkNodeTimingStarted & Pick<NodeTimingComplete, 'estimatedTimeElapsed'>} NetworkNodeTimingInProgress */
-
-/** @typedef {CpuNodeTimingInProgress & Pick<NodeTimingComplete, 'endTime'>} CpuNodeTimingComplete */
-/** @typedef {NetworkNodeTimingInProgress & Pick<NodeTimingComplete, 'endTime'> & {connectionTiming: ConnectionTiming}} NetworkNodeTimingComplete */
-
-/** @typedef {NodeTimingQueued | CpuNodeTimingStarted | NetworkNodeTimingStarted | CpuNodeTimingInProgress | NetworkNodeTimingInProgress | CpuNodeTimingComplete | NetworkNodeTimingComplete} NodeTimingData */
-
-/**
- * @typedef ConnectionTiming A breakdown of network connection timings.
- * @property {number} [dnsResolutionTime]
- * @property {number} [connectionTime]
- * @property {number} [sslTime]
- * @property {number} timeToFirstByte
- */
-
-class SimulatorTimingMap {
-  constructor() {
-    /** @type {Map<Node, NodeTimingData>} */
-    this._nodeTimings = new Map();
-  }
-
-  /** @return {Array<Node>} */
-  getNodes() {
-    return Array.from(this._nodeTimings.keys());
-  }
-
-  /**
-   * @param {Node} node
-   * @param {{queuedTime: number}} values
-   */
-  setReadyToStart(node, values) {
-    this._nodeTimings.set(node, values);
-  }
-
-  /**
-   * @param {Node} node
-   * @param {{startTime: number}} values
-   */
-  setInProgress(node, values) {
-    const nodeTiming = {
-      ...this.getQueued(node),
-      startTime: values.startTime,
-      timeElapsed: 0,
-    };
-
-    this._nodeTimings.set(
-      node,
-      node.type === Lantern.BaseNode.TYPES.NETWORK
-        ? {...nodeTiming, timeElapsedOvershoot: 0, bytesDownloaded: 0}
-        : nodeTiming
-    );
-  }
-
-  /**
-   * @param {Node} node
-   * @param {{endTime: number, connectionTiming?: ConnectionTiming}} values
-   */
-  setCompleted(node, values) {
-    const nodeTiming = {
-      ...this.getInProgress(node),
-      endTime: values.endTime,
-      connectionTiming: values.connectionTiming,
-    };
-
-    this._nodeTimings.set(node, nodeTiming);
-  }
-
-  /**
-   * @param {CpuNode} node
-   * @param {{timeElapsed: number}} values
-   */
-  setCpu(node, values) {
-    const nodeTiming = {
-      ...this.getCpuStarted(node),
-      timeElapsed: values.timeElapsed,
-    };
-
-    this._nodeTimings.set(node, nodeTiming);
-  }
-
-  /**
-   * @param {CpuNode} node
-   * @param {{estimatedTimeElapsed: number}} values
-   */
-  setCpuEstimated(node, values) {
-    const nodeTiming = {
-      ...this.getCpuStarted(node),
-      estimatedTimeElapsed: values.estimatedTimeElapsed,
-    };
-
-    this._nodeTimings.set(node, nodeTiming);
-  }
-
-  /**
-   * @param {NetworkNode} node
-   * @param {{timeElapsed: number, timeElapsedOvershoot: number, bytesDownloaded: number}} values
-   */
-  setNetwork(node, values) {
-    const nodeTiming = {
-      ...this.getNetworkStarted(node),
-      timeElapsed: values.timeElapsed,
-      timeElapsedOvershoot: values.timeElapsedOvershoot,
-      bytesDownloaded: values.bytesDownloaded,
-    };
-
-    this._nodeTimings.set(node, nodeTiming);
-  }
-
-  /**
-   * @param {NetworkNode} node
-   * @param {{estimatedTimeElapsed: number}} values
-   */
-  setNetworkEstimated(node, values) {
-    const nodeTiming = {
-      ...this.getNetworkStarted(node),
-      estimatedTimeElapsed: values.estimatedTimeElapsed,
-    };
-
-    this._nodeTimings.set(node, nodeTiming);
-  }
-
-  /**
-   * @param {Node} node
-   * @return {NodeTimingQueued}
-   */
-  getQueued(node) {
-    const timing = this._nodeTimings.get(node);
-    if (!timing) throw new Error(`Node ${node.id} not yet queued`);
-    return timing;
-  }
-
-  /**
-   * @param {CpuNode} node
-   * @return {CpuNodeTimingStarted}
-   */
-  getCpuStarted(node) {
-    const timing = this._nodeTimings.get(node);
-    if (!timing) throw new Error(`Node ${node.id} not yet queued`);
-    if (!('startTime' in timing)) throw new Error(`Node ${node.id} not yet started`);
-    if ('bytesDownloaded' in timing) throw new Error(`Node ${node.id} timing not valid`);
-    return timing;
-  }
-
-  /**
-   * @param {NetworkNode} node
-   * @return {NetworkNodeTimingStarted}
-   */
-  getNetworkStarted(node) {
-    const timing = this._nodeTimings.get(node);
-    if (!timing) throw new Error(`Node ${node.id} not yet queued`);
-    if (!('startTime' in timing)) throw new Error(`Node ${node.id} not yet started`);
-    if (!('bytesDownloaded' in timing)) throw new Error(`Node ${node.id} timing not valid`);
-    return timing;
-  }
-
-  /**
-   * @param {Node} node
-   * @return {CpuNodeTimingInProgress | NetworkNodeTimingInProgress}
-   */
-  getInProgress(node) {
-    const timing = this._nodeTimings.get(node);
-    if (!timing) throw new Error(`Node ${node.id} not yet queued`);
-    if (!('startTime' in timing)) throw new Error(`Node ${node.id} not yet started`);
-    if (!('estimatedTimeElapsed' in timing)) throw new Error(`Node ${node.id} not yet in progress`);
-    return timing;
-  }
-
-  /**
-   * @param {Node} node
-   * @return {CpuNodeTimingComplete | NetworkNodeTimingComplete}
-   */
-  getCompleted(node) {
-    const timing = this._nodeTimings.get(node);
-    if (!timing) throw new Error(`Node ${node.id} not yet queued`);
-    if (!('startTime' in timing)) throw new Error(`Node ${node.id} not yet started`);
-    if (!('estimatedTimeElapsed' in timing)) throw new Error(`Node ${node.id} not yet in progress`);
-    if (!('endTime' in timing)) throw new Error(`Node ${node.id} not yet completed`);
-    return timing;
-  }
-}
-
-export {SimulatorTimingMap};

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

@@ -1,157 +0,0 @@
-export type Node = import('../BaseNode.js').Node;
-export type NetworkNode = import('../NetworkNode.js').NetworkNode;
-export type CpuNode = import('../CpuNode.js').CPUNode;
-export type CompleteNodeTiming = import('./SimulationTimingMap.js').CpuNodeTimingComplete | import('./SimulationTimingMap.js').NetworkNodeTimingComplete;
-export type ConnectionTiming = import('./SimulationTimingMap.js').ConnectionTiming;
-/**
- * @template [T=any]
- */
-export class Simulator<T = any> {
-    /**
-     * @param {Lantern.Simulation.Settings} settings
-     */
-    static createSimulator(settings: Lantern.Simulation.Settings): Simulator<any>;
-    /** @return {Map<string, Map<Node, CompleteNodeTiming>>} */
-    static get ALL_NODE_TIMINGS(): Map<string, Map<Node, CompleteNodeTiming>>;
-    /**
-     * We attempt to start nodes by their observed start time using the request priority as a tie breaker.
-     * When simulating, just because a low priority image started 5ms before a high priority image doesn't mean
-     * it would have happened like that when the network was slower.
-     * @param {Node} node
-     */
-    static _computeNodeStartPosition(node: Node): number;
-    /**
-     * @param {Lantern.Simulation.Options} [options]
-     */
-    constructor(options?: import("../types/lantern.js").Simulation.Options | undefined);
-    /** @type {Required<Lantern.Simulation.Options>} */
-    _options: Required<Lantern.Simulation.Options>;
-    _rtt: number;
-    _throughput: number;
-    _maximumConcurrentRequests: number;
-    _cpuSlowdownMultiplier: number;
-    _layoutTaskMultiplier: number;
-    /** @type {Array<Node>} */
-    _cachedNodeListByStartPosition: Array<Node>;
-    _nodeTimings: Lantern.Simulation.SimulatorTimingMap;
-    /** @type {Map<string, number>} */
-    _numberInProgressByType: Map<string, number>;
-    /** @type {Record<number, Set<Node>>} */
-    _nodes: Record<number, Set<Node>>;
-    _dns: Lantern.Simulation.DNSCache;
-    /** @type {ConnectionPool} */
-    _connectionPool: ConnectionPool;
-    /** @return {number} */
-    get rtt(): number;
-    /**
-     * @param {Node} graph
-     */
-    _initializeConnectionPool(graph: Node): void;
-    /**
-     * Initializes the various state data structures such _nodeTimings and the _node Sets by state.
-     */
-    _initializeAuxiliaryData(): void;
-    /**
-     * @param {string} type
-     * @return {number}
-     */
-    _numberInProgress(type: string): number;
-    /**
-     * @param {Node} node
-     * @param {number} queuedTime
-     */
-    _markNodeAsReadyToStart(node: Node, queuedTime: number): void;
-    /**
-     * @param {Node} node
-     * @param {number} startTime
-     */
-    _markNodeAsInProgress(node: Node, startTime: number): void;
-    /**
-     * @param {Node} node
-     * @param {number} endTime
-     * @param {ConnectionTiming} [connectionTiming] Optional network connection information.
-     */
-    _markNodeAsComplete(node: Node, endTime: number, connectionTiming?: import("./SimulationTimingMap.js").ConnectionTiming | undefined): void;
-    /**
-     * @param {Lantern.NetworkRequest} request
-     * @return {?TcpConnection}
-     */
-    _acquireConnection(request: Lantern.NetworkRequest): TcpConnection | null;
-    /**
-     * @return {Node[]}
-     */
-    _getNodesSortedByStartPosition(): Node[];
-    /**
-     * @param {Node} node
-     * @param {number} totalElapsedTime
-     */
-    _startNodeIfPossible(node: Node, totalElapsedTime: number): void;
-    /**
-     * Updates each connection in use with the available throughput based on the number of network requests
-     * currently in flight.
-     */
-    _updateNetworkCapacity(): void;
-    /**
-     * Estimates the number of milliseconds remaining given current condidtions before the node is complete.
-     * @param {Node} node
-     * @return {number}
-     */
-    _estimateTimeRemaining(node: Node): number;
-    /**
-     * @param {CpuNode} cpuNode
-     * @return {number}
-     */
-    _estimateCPUTimeRemaining(cpuNode: CpuNode): number;
-    /**
-     * @param {NetworkNode} networkNode
-     * @return {number}
-     */
-    _estimateNetworkTimeRemaining(networkNode: NetworkNode): number;
-    /**
-     * Computes and returns the minimum estimated completion time of the nodes currently in progress.
-     * @return {number}
-     */
-    _findNextNodeCompletionTime(): number;
-    /**
-     * Given a time period, computes the progress toward completion that the node made durin that time.
-     * @param {Node} node
-     * @param {number} timePeriodLength
-     * @param {number} totalElapsedTime
-     */
-    _updateProgressMadeInTimePeriod(node: Node, timePeriodLength: number, totalElapsedTime: number): number | void;
-    /**
-     * @return {{nodeTimings: Map<Node, Lantern.Simulation.NodeTiming>, completeNodeTimings: Map<Node, CompleteNodeTiming>}}
-     */
-    _computeFinalNodeTimings(): {
-        nodeTimings: Map<Node, Lantern.Simulation.NodeTiming>;
-        completeNodeTimings: Map<Node, CompleteNodeTiming>;
-    };
-    /**
-     * @return {Required<Lantern.Simulation.Options>}
-     */
-    getOptions(): Required<Lantern.Simulation.Options>;
-    /**
-     * Estimates the time taken to process all of the graph's nodes, returns the overall time along with
-     * each node annotated by start/end times.
-     *
-     * Simulator/connection pool are allowed to deviate from what was
-     * observed in the trace/devtoolsLog and start requests as soon as they are queued (i.e. do not
-     * wait around for a warm connection to be available if the original request was fetched on a warm
-     * connection).
-     *
-     * @param {Node} graph
-     * @param {{label?: string}=} options
-     * @return {Lantern.Simulation.Result<T>}
-     */
-    simulate(graph: Node, options?: {
-        label?: string;
-    } | undefined): Lantern.Simulation.Result<T>;
-    /**
-     * @param {number} wastedBytes
-     */
-    computeWastedMsFromWastedBytes(wastedBytes: number): number;
-}
-import * as Lantern from '../lantern.js';
-import { ConnectionPool } from './ConnectionPool.js';
-import { TcpConnection } from './TcpConnection.js';
-//# sourceMappingURL=Simulator.d.ts.map