tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

browser_metrics_pool.js (3419B)

      1 /* Any copyright is dedicated to the Public Domain.
      2 * http://creativecommons.org/publicdomain/zero/1.0/ */
      3 
      4 "use strict";
      5 
      6 const {
      7  DevToolsServer,
      8 } = require("resource://devtools/server/devtools-server.js");
      9 const { Pool } = require("resource://devtools/shared/protocol.js");
     10 
     11 // Test parameters
     12 const ROOT_POOLS = 100;
     13 const POOL_DEPTH = 10;
     14 const POOLS_BY_LEVEL = 100;
     15 // Number of Pools that will be added once the environment is set up.
     16 const ADDITIONAL_POOLS = 5000;
     17 
     18 add_task(async function () {
     19  DevToolsServer.init();
     20  DevToolsServer.registerAllActors();
     21  const conn = DevToolsServer.connectPipe()._serverConnection;
     22 
     23  info("Add multiple Pools to the connection");
     24  const pools = setupTestEnvironment(conn);
     25 
     26  let sumResult = 0;
     27 
     28  info("Test how long it takes to manage new Pools");
     29  let start = performance.now();
     30  let parentPool = pools[pools.length - 1];
     31  const newPools = [];
     32  for (let i = 0; i < ADDITIONAL_POOLS; i++) {
     33    const pool = new Pool(conn, `${parentPool.label}-${i}`);
     34    newPools.push(pool);
     35    parentPool.manage(pool);
     36  }
     37  const manageResult = performance.now() - start;
     38  sumResult += manageResult;
     39 
     40  info("Test how long it takes to manage Pools that were already managed");
     41  start = performance.now();
     42  parentPool = pools[pools.length - 2];
     43  for (const pool of newPools) {
     44    parentPool.manage(pool);
     45  }
     46  const manageAlreadyManagedResult = performance.now() - start;
     47  sumResult += manageAlreadyManagedResult;
     48 
     49  info("Test how long it takes to unmanage Pools");
     50  start = performance.now();
     51  for (const pool of newPools) {
     52    parentPool.unmanage(pool);
     53  }
     54  const unmanageResult = performance.now() - start;
     55  sumResult += unmanageResult;
     56 
     57  info("Test how long it takes to destroy all the Pools");
     58  start = performance.now();
     59  conn.onTransportClosed();
     60  const destroyResult = performance.now() - start;
     61  sumResult += destroyResult;
     62 
     63  const PERFHERDER_DATA = {
     64    framework: {
     65      name: "devtools",
     66    },
     67    suites: [
     68      {
     69        name: "server.pool",
     70        value: sumResult,
     71        subtests: [
     72          {
     73            name: "server.pool.manage",
     74            value: manageResult,
     75          },
     76          {
     77            name: "server.pool.manage-already-managed",
     78            value: manageAlreadyManagedResult,
     79          },
     80          {
     81            name: "server.pool.unmanage",
     82            value: unmanageResult,
     83          },
     84          {
     85            name: "server.pool.destroy",
     86            value: destroyResult,
     87          },
     88        ],
     89      },
     90    ],
     91  };
     92  info("PERFHERDER_DATA: " + JSON.stringify(PERFHERDER_DATA));
     93 });
     94 
     95 // Some Pool operations might be impacted by the number of existing pools in a connection,
     96 // so it's important to have a sizeable number of Pools in order to assert Pool performances.
     97 function setupTestEnvironment(conn) {
     98  const pools = [];
     99  for (let i = 0; i < ROOT_POOLS; i++) {
    100    const rootPool = new Pool(conn, "root-pool-" + i);
    101    pools.push(rootPool);
    102    let parent = rootPool;
    103    for (let j = 0; j < POOL_DEPTH; j++) {
    104      const intermediatePool = new Pool(conn, `pool-${i}-${j}`);
    105      pools.push(intermediatePool);
    106      parent.manage(intermediatePool);
    107 
    108      for (let k = 0; k < POOLS_BY_LEVEL; k++) {
    109        const pool = new Pool(conn, `pool-${i}-${j}-${k}`);
    110        pools.push(pool);
    111        intermediatePool.manage(pool);
    112      }
    113 
    114      parent = intermediatePool;
    115    }
    116  }
    117  return pools;
    118 }