Upload Kmake

benchmark/async_hooks/async-local-storage-getstore-nested-resources.js

@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common.js');
+const { AsyncLocalStorage, AsyncResource } = require('async_hooks');
+
+/**
+ * This benchmark verifies the performance of
+ * `AsyncLocalStorage.getStore()` on propagation through async
+ * resource scopes.
+ *
+ * - AsyncLocalStorage.run()
+ *  - AsyncResource.runInAsyncScope
+ *    - AsyncResource.runInAsyncScope
+ *      ...
+ *        - AsyncResource.runInAsyncScope
+ *          - AsyncLocalStorage.getStore()
+ */
+const bench = common.createBenchmark(main, {
+  resourceCount: [10, 100, 1000],
+  n: [5e5],
+});
+
+function runBenchmark(store, n) {
+  for (let i = 0; i < n; i++) {
+    store.getStore();
+  }
+}
+
+function runInAsyncScopes(resourceCount, cb, i = 0) {
+  if (i === resourceCount) {
+    cb();
+  } else {
+    const resource = new AsyncResource('noop');
+    resource.runInAsyncScope(() => {
+      runInAsyncScopes(resourceCount, cb, i + 1);
+    });
+  }
+}
+
+function main({ n, resourceCount }) {
+  const store = new AsyncLocalStorage();
+  store.run({}, () => {
+    runInAsyncScopes(resourceCount, () => {
+      bench.start();
+      runBenchmark(store, n);
+      bench.end(n);
+    });
+  });
+}

benchmark/async_hooks/async-local-storage-getstore-nested-run.js

@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common.js');
+const { AsyncLocalStorage } = require('async_hooks');
+
+/**
+ * This benchmark verifies the performance of
+ * `AsyncLocalStorage.getStore()` on multiple `AsyncLocalStorage` instances
+ * nested `AsyncLocalStorage.run()`s.
+ *
+ * - AsyncLocalStorage1.run()
+ *   - AsyncLocalStorage2.run()
+ *    ...
+ *      - AsyncLocalStorageN.run()
+ *        - AsyncLocalStorage1.getStore()
+ */
+const bench = common.createBenchmark(main, {
+  storageCount: [1, 10, 100],
+  n: [1e4],
+});
+
+function runBenchmark(store, n) {
+  for (let idx = 0; idx < n; idx++) {
+    store.getStore();
+  }
+}
+
+function runStores(stores, value, cb, idx = 0) {
+  if (idx === stores.length) {
+    cb();
+  } else {
+    stores[idx].run(value, () => {
+      runStores(stores, value, cb, idx + 1);
+    });
+  }
+}
+
+function main({ n, storageCount }) {
+  const stores = new Array(storageCount).fill(0).map(() => new AsyncLocalStorage());
+  const contextValue = {};
+
+  runStores(stores, contextValue, () => {
+    bench.start();
+    runBenchmark(stores[0], n);
+    bench.end(n);
+  });
+}

benchmark/async_hooks/async-local-storage-propagate-asyncresource.js

@@ -0,0 +1,46 @@
+'use strict';
+const common = require('../common.js');
+const { AsyncLocalStorage, AsyncResource } = require('async_hooks');
+
+/**
+ * This benchmark verifies the performance degradation of
+ * async resource propagation on the increasing number of
+ * active `AsyncLocalStorage`s.
+ *
+ * - AsyncLocalStorage.run() * storageCount
+ * - new AsyncResource()
+ * - new AsyncResource()
+ * ...
+ * - N new Asyncresource()
+ */
+const bench = common.createBenchmark(main, {
+  storageCount: [0, 1, 10, 100],
+  n: [1e3],
+});
+
+function runStores(stores, value, cb, idx = 0) {
+  if (idx === stores.length) {
+    cb();
+  } else {
+    stores[idx].run(value, () => {
+      runStores(stores, value, cb, idx + 1);
+    });
+  }
+}
+
+function runBenchmark(n) {
+  for (let i = 0; i < n; i++) {
+    new AsyncResource('noop');
+  }
+}
+
+function main({ n, storageCount }) {
+  const stores = new Array(storageCount).fill(0).map(() => new AsyncLocalStorage());
+  const contextValue = {};
+
+  runStores(stores, contextValue, () => {
+    bench.start();
+    runBenchmark(n);
+    bench.end(n);
+  });
+}

benchmark/async_hooks/async-local-storage-propagate-promise.js

@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common.js');
+const { AsyncLocalStorage } = require('async_hooks');
+
+/**
+ * This benchmark verifies the performance degradation of
+ * async resource propagation on the increasing number of
+ * active `AsyncLocalStorage`s.
+ *
+ * - AsyncLocalStorage.run()
+ *  - Promise
+ *    - Promise
+ *      ...
+ *        - Promise
+ */
+const bench = common.createBenchmark(main, {
+  storageCount: [0, 1, 10, 100],
+  n: [1e5],
+});
+
+function runStores(stores, value, cb, idx = 0) {
+  if (idx === stores.length) {
+    cb();
+  } else {
+    stores[idx].run(value, () => {
+      runStores(stores, value, cb, idx + 1);
+    });
+  }
+}
+
+async function runBenchmark(n) {
+  for (let i = 0; i < n; i++) {
+    // Avoid creating additional ticks.
+    await undefined;
+  }
+}
+
+function main({ n, storageCount }) {
+  const stores = new Array(storageCount).fill(0).map(() => new AsyncLocalStorage());
+  const contextValue = {};
+
+  runStores(stores, contextValue, () => {
+    bench.start();
+    runBenchmark(n).then(() => {
+      bench.end(n);
+    });
+  });
+}

benchmark/async_hooks/async-local-storage-run.js

@@ -0,0 +1,21 @@
+'use strict';
+const common = require('../common.js');
+const { AsyncLocalStorage } = require('async_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7],
+});
+
+async function run(store, n) {
+  for (let i = 0; i < n; i++) {
+    await new Promise((resolve) => store.run(i, resolve));
+  }
+}
+
+function main({ n }) {
+  const store = new AsyncLocalStorage();
+  bench.start();
+  run(store, n).then(() => {
+    bench.end(n);
+  });
+}

benchmark/async_hooks/async-resource-vs-destroy.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const { promisify } = require('util');
+const { readFile } = require('fs');
+const sleep = promisify(setTimeout);
+const read = promisify(readFile);
+const common = require('../common.js');
+const {
+  createHook,
+  executionAsyncResource,
+  executionAsyncId,
+  AsyncLocalStorage,
+} = require('async_hooks');
+const { createServer } = require('http');
+
+const bench = common.createBenchmark(main, {
+  type: ['async-resource', 'destroy', 'async-local-storage'],
+  asyncMethod: ['callbacks', 'async'],
+  path: '/',
+  connections: 500,
+  duration: 5,
+  n: [1e6],
+});
+
+function buildCurrentResource(getServe) {
+  const server = createServer(getServe(getCLS, setCLS));
+  const hook = createHook({ init });
+  const cls = Symbol('cls');
+  hook.enable();
+
+  return {
+    server,
+    close,
+  };
+
+  function getCLS() {
+    const resource = executionAsyncResource();
+    if (!resource[cls]) {
+      return null;
+    }
+    return resource[cls].state;
+  }
+
+  function setCLS(state) {
+    const resource = executionAsyncResource();
+    if (!resource[cls]) {
+      resource[cls] = { state };
+    } else {
+      resource[cls].state = state;
+    }
+  }
+
+  function init(asyncId, type, triggerAsyncId, resource) {
+    const cr = executionAsyncResource();
+    if (cr !== null) {
+      resource[cls] = cr[cls];
+    }
+  }
+
+  function close() {
+    hook.disable();
+    server.close();
+  }
+}
+
+function buildDestroy(getServe) {
+  const transactions = new Map();
+  const server = createServer(getServe(getCLS, setCLS));
+  const hook = createHook({ init, destroy });
+  hook.enable();
+
+  return {
+    server,
+    close,
+  };
+
+  function getCLS() {
+    const asyncId = executionAsyncId();
+    return transactions.has(asyncId) ? transactions.get(asyncId) : null;
+  }
+
+  function setCLS(value) {
+    const asyncId = executionAsyncId();
+    transactions.set(asyncId, value);
+  }
+
+  function init(asyncId, type, triggerAsyncId, resource) {
+    transactions.set(asyncId, getCLS());
+  }
+
+  function destroy(asyncId) {
+    transactions.delete(asyncId);
+  }
+
+  function close() {
+    hook.disable();
+    server.close();
+  }
+}
+
+function buildAsyncLocalStorage(getServe) {
+  const asyncLocalStorage = new AsyncLocalStorage();
+  const server = createServer((req, res) => {
+    asyncLocalStorage.run({}, () => {
+      getServe(getCLS, setCLS)(req, res);
+    });
+  });
+
+  return {
+    server,
+    close,
+  };
+
+  function getCLS() {
+    const store = asyncLocalStorage.getStore();
+    if (store === undefined) {
+      return null;
+    }
+    return store.state;
+  }
+
+  function setCLS(state) {
+    const store = asyncLocalStorage.getStore();
+    if (store === undefined) {
+      return;
+    }
+    store.state = state;
+  }
+
+  function close() {
+    asyncLocalStorage.disable();
+    server.close();
+  }
+}
+
+function getServeAwait(getCLS, setCLS) {
+  return async function serve(req, res) {
+    setCLS(Math.random());
+    await sleep(10);
+    await read(__filename);
+    if (res.destroyed) return;
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify({ cls: getCLS() }));
+  };
+}
+
+function getServeCallbacks(getCLS, setCLS) {
+  return function serve(req, res) {
+    setCLS(Math.random());
+    setTimeout(() => {
+      readFile(__filename, () => {
+        if (res.destroyed) return;
+        res.setHeader('content-type', 'application/json');
+        res.end(JSON.stringify({ cls: getCLS() }));
+      });
+    }, 10);
+  };
+}
+
+const types = {
+  'async-resource': buildCurrentResource,
+  'destroy': buildDestroy,
+  'async-local-storage': buildAsyncLocalStorage,
+};
+
+const asyncMethods = {
+  'callbacks': getServeCallbacks,
+  'async': getServeAwait,
+};
+
+function main({ type, asyncMethod, connections, duration, path }) {
+  const { server, close } = types[type](asyncMethods[asyncMethod]);
+
+  server
+    .listen(common.PORT)
+    .on('listening', () => {
+
+      bench.http({
+        path,
+        connections,
+        duration,
+      }, () => {
+        close();
+      });
+    });
+}

benchmark/async_hooks/gc-tracking.js

@@ -0,0 +1,52 @@
+'use strict';
+const common = require('../common.js');
+const { createHook, AsyncResource } = require('async_hooks');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  method: [
+    'trackingEnabled',
+    'trackingEnabledWithDestroyHook',
+    'trackingDisabled',
+  ],
+}, {
+  flags: ['--expose-gc'],
+});
+
+function endAfterGC(n) {
+  setImmediate(() => {
+    global.gc();
+    setImmediate(() => {
+      bench.end(n);
+    });
+  });
+}
+
+function main({ n, method }) {
+  switch (method) {
+    case 'trackingEnabled':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        new AsyncResource('foobar');
+      }
+      endAfterGC(n);
+      break;
+    case 'trackingEnabledWithDestroyHook':
+      createHook({ destroy: () => {} }).enable();
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        new AsyncResource('foobar');
+      }
+      endAfterGC(n);
+      break;
+    case 'trackingDisabled':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        new AsyncResource('foobar', { requireManualDestroy: true });
+      }
+      endAfterGC(n);
+      break;
+    default:
+      throw new Error(`Unsupported method "${method}"`);
+  }
+}

benchmark/async_hooks/http-server.js

@@ -0,0 +1,42 @@
+'use strict';
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  asyncHooks: ['init', 'before', 'after', 'all', 'disabled', 'none'],
+  connections: [50, 500],
+  duration: 5,
+});
+
+function main({ asyncHooks, connections, duration }) {
+  if (asyncHooks !== 'none') {
+    let hooks = {
+      init() {},
+      before() {},
+      after() {},
+      destroy() {},
+      promiseResolve() {},
+    };
+    if (asyncHooks !== 'all' || asyncHooks !== 'disabled') {
+      hooks = {
+        [asyncHooks]: () => {},
+      };
+    }
+    const hook = require('async_hooks').createHook(hooks);
+    if (asyncHooks !== 'disabled') {
+      hook.enable();
+    }
+  }
+  const server = require('../fixtures/simple-http-server.js')
+    .listen(common.PORT)
+    .on('listening', () => {
+      const path = '/buffer/4/4/normal/1';
+
+      bench.http({
+        connections,
+        path,
+        duration,
+      }, () => {
+        server.close();
+      });
+    });
+}

benchmark/async_hooks/promises.js

@@ -0,0 +1,56 @@
+'use strict';
+const common = require('../common.js');
+const { createHook } = require('async_hooks');
+
+let hook;
+const tests = {
+  disabled() {
+    hook = createHook({
+      promiseResolve() {},
+    });
+  },
+  enabled() {
+    hook = createHook({
+      promiseResolve() {},
+    }).enable();
+  },
+  enabledWithDestroy() {
+    hook = createHook({
+      promiseResolve() {},
+      destroy() {},
+    }).enable();
+  },
+  enabledWithInitOnly() {
+    hook = createHook({
+      init() {},
+    }).enable();
+  },
+};
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  asyncHooks: [
+    'enabled',
+    'enabledWithDestroy',
+    'enabledWithInitOnly',
+    'disabled',
+  ],
+});
+
+const err = new Error('foobar');
+async function run(n) {
+  for (let i = 0; i < n; i++) {
+    await new Promise((resolve) => resolve())
+      .then(() => { throw err; })
+      .catch((e) => e);
+  }
+}
+
+function main({ n, asyncHooks }) {
+  if (hook) hook.disable();
+  tests[asyncHooks]();
+  bench.start();
+  run(n).then(() => {
+    bench.end(n);
+  });
+}