Upload Kmake

benchmark/process/bench-env.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const common = require('../common');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  operation: ['get', 'set', 'enumerate', 'query', 'delete'],
+});
+
+
+function main({ n, operation }) {
+  switch (operation) {
+    case 'get':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        process.env.PATH; // eslint-disable-line no-unused-expressions
+      }
+      bench.end(n);
+      break;
+    case 'set':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        process.env.DUMMY = 'hello, world';
+      }
+      bench.end(n);
+      break;
+    case 'enumerate':
+      // First, normalize process.env so that benchmark results are comparable.
+      for (const key of Object.keys(process.env))
+        delete process.env[key];
+      for (let i = 0; i < 64; i++)
+        process.env[Math.random()] = Math.random();
+
+      n /= 10;  // Enumeration is comparatively heavy.
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        // Access every item in object to process values.
+        Object.keys(process.env);
+      }
+      bench.end(n);
+      break;
+    case 'query':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        'PATH' in process.env; // eslint-disable-line no-unused-expressions
+      }
+      bench.end(n);
+      break;
+    case 'delete':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        delete process.env.DUMMY;
+      }
+      bench.end(n);
+      break;
+  }
+}

benchmark/process/bench-hrtime.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  type: ['raw', 'diff', 'bigint'],
+});
+
+function main({ n, type }) {
+  const hrtime = process.hrtime;
+  let noDead = type === 'bigint' ? hrtime.bigint() : hrtime();
+
+  switch (type) {
+    case 'raw':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        noDead = hrtime();
+      }
+      bench.end(n);
+      break;
+    case 'diff':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        noDead = hrtime(noDead);
+      }
+      bench.end(n);
+      break;
+    case 'bigint':
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        noDead = hrtime.bigint();
+      }
+      bench.end(n);
+      break;
+  }
+
+  assert.ok(Array.isArray(noDead) || typeof noDead === 'bigint');
+}

benchmark/process/coverage.js

@@ -0,0 +1,31 @@
+// This benchmark is meant to exercise a grab bag of code paths that would
+// be expected to run slower under coverage.
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [1e5],
+});
+const { rmSync } = require('fs');
+const { spawnSync } = require('child_process');
+const tmpdir = require('../../test/common/tmpdir');
+
+const coverageDir = tmpdir.resolve(`cov-${Date.now()}`);
+
+function main({ n }) {
+  bench.start();
+  const result = spawnSync(process.execPath, [
+    require.resolve('../fixtures/coverage-many-branches'),
+  ], {
+    env: {
+      NODE_V8_COVERAGE: coverageDir,
+      N: n,
+      ...process.env,
+    },
+  });
+  bench.end(n);
+  rmSync(coverageDir, { recursive: true, force: true });
+  if (result.status !== 0) {
+    throw new Error(result.stderr.toString('utf8'));
+  }
+}

benchmark/process/getActiveResourcesInfo.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const { createBenchmark } = require('../common.js');
+
+const { connect, createServer } = require('net');
+const { open } = require('fs');
+
+const bench = createBenchmark(main, {
+  handlesCount: [1e4],
+  requestsCount: [1e4],
+  timeoutsCount: [1e4],
+  immediatesCount: [1e4],
+  n: [1e5],
+});
+
+function main({ handlesCount, requestsCount, timeoutsCount, immediatesCount, n }) {
+  const server = createServer().listen();
+  const clients = [];
+  for (let i = 0; i < handlesCount; i++) {
+    clients.push(connect({ port: server.address().port }));
+  }
+
+  for (let i = 0; i < requestsCount; i++) {
+    open(__filename, 'r', () => {});
+  }
+
+  for (let i = 0; i < timeoutsCount; ++i) {
+    setTimeout(() => {}, 1);
+  }
+
+  for (let i = 0; i < immediatesCount; ++i) {
+    setImmediate(() => {});
+  }
+
+  bench.start();
+  for (let i = 0; i < n; ++i) {
+    process.getActiveResourcesInfo();
+  }
+  bench.end(n);
+
+  for (const client of clients) {
+    client.destroy();
+  }
+  server.close();
+}

benchmark/process/memoryUsage.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [1e5],
+});
+
+function main({ n }) {
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    process.memoryUsage();
+  }
+  bench.end(n);
+}

benchmark/process/next-tick-breadth-args.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [1e7],
+});
+
+function main({ n }) {
+  let j = 0;
+
+  function cb1(arg1) {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+
+  function cb2(arg1, arg2) {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+
+  function cb3(arg1, arg2, arg3) {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+
+  function cb4(arg1, arg2, arg3, arg4) {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    if (i % 4 === 0)
+      process.nextTick(cb4, 3.14, 1024, true, false);
+    else if (i % 3 === 0)
+      process.nextTick(cb3, 512, true, null);
+    else if (i % 2 === 0)
+      process.nextTick(cb2, false, 5.1);
+    else
+      process.nextTick(cb1, 0);
+  }
+}

benchmark/process/next-tick-breadth.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [1e7],
+});
+
+function main({ n }) {
+  let j = 0;
+
+  function cb() {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    process.nextTick(cb);
+  }
+}

benchmark/process/next-tick-depth-args.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [7e6],
+});
+
+function main({ n }) {
+  let counter = n;
+  function cb4(arg1, arg2, arg3, arg4) {
+    if (--counter) {
+      if (counter % 4 === 0)
+        process.nextTick(cb4, 3.14, 1024, true, false);
+      else if (counter % 3 === 0)
+        process.nextTick(cb3, 512, true, null);
+      else if (counter % 2 === 0)
+        process.nextTick(cb2, false, 5.1);
+      else
+        process.nextTick(cb1, 0);
+    } else
+      bench.end(n);
+  }
+
+  function cb3(arg1, arg2, arg3) {
+    if (--counter) {
+      if (counter % 4 === 0)
+        process.nextTick(cb4, 3.14, 1024, true, false);
+      else if (counter % 3 === 0)
+        process.nextTick(cb3, 512, true, null);
+      else if (counter % 2 === 0)
+        process.nextTick(cb2, false, 5.1);
+      else
+        process.nextTick(cb1, 0);
+    } else
+      bench.end(n);
+  }
+
+  function cb2(arg1, arg2) {
+    if (--counter) {
+      if (counter % 4 === 0)
+        process.nextTick(cb4, 3.14, 1024, true, false);
+      else if (counter % 3 === 0)
+        process.nextTick(cb3, 512, true, null);
+      else if (counter % 2 === 0)
+        process.nextTick(cb2, false, 5.1);
+      else
+        process.nextTick(cb1, 0);
+    } else
+      bench.end(n);
+  }
+
+  function cb1(arg1) {
+    if (--counter) {
+      if (counter % 4 === 0)
+        process.nextTick(cb4, 3.14, 1024, true, false);
+      else if (counter % 3 === 0)
+        process.nextTick(cb3, 512, true, null);
+      else if (counter % 2 === 0)
+        process.nextTick(cb2, false, 5.1);
+      else
+        process.nextTick(cb1, 0);
+    } else
+      bench.end(n);
+  }
+  bench.start();
+  process.nextTick(cb1, true);
+}

benchmark/process/next-tick-depth.js

@@ -0,0 +1,17 @@
+'use strict';
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [7e6],
+});
+
+function main({ n }) {
+  let counter = n;
+  bench.start();
+  process.nextTick(onNextTick);
+  function onNextTick() {
+    if (--counter)
+      process.nextTick(onNextTick);
+    else
+      bench.end(n);
+  }
+}

benchmark/process/next-tick-exec-args.js

@@ -0,0 +1,25 @@
+'use strict';
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [4e6],
+});
+
+function main({ n }) {
+  function onNextTick(i) {
+    if (i + 1 === n)
+      bench.end(n);
+  }
+
+  for (let i = 0; i < n; i++) {
+    if (i % 4 === 0)
+      process.nextTick(onNextTick, i, true, 10, 'test');
+    else if (i % 3 === 0)
+      process.nextTick(onNextTick, i, true, 10);
+    else if (i % 2 === 0)
+      process.nextTick(onNextTick, i, 20);
+    else
+      process.nextTick(onNextTick, i);
+  }
+
+  bench.start();
+}

benchmark/process/next-tick-exec.js

@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [4e6],
+});
+
+function main({ n }) {
+  function onNextTick(i) {
+    if (i + 1 === n)
+      bench.end(n);
+  }
+
+  for (let i = 0; i < n; i++) {
+    process.nextTick(onNextTick, i);
+  }
+
+  bench.start();
+}

benchmark/process/next-tick-loop-args.js

@@ -0,0 +1,37 @@
+'use strict';
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [1e4, 2e4, 4e4],
+  loop: [1e2, 2e2],
+});
+
+function main({ n, loop }) {
+  bench.start();
+  run();
+  function run() {
+    let j = 0;
+
+    function cb() {
+      j++;
+      if (j === n) {
+        loop--;
+        if (loop === 0) {
+          bench.end(n);
+        } else {
+          run();
+        }
+      }
+    }
+
+    for (let i = 0; i < n; i++) {
+      if (i % 4 === 0)
+        process.nextTick(cb, i, true, 10, 'test');
+      else if (i % 3 === 0)
+        process.nextTick(cb, i, true, 10);
+      else if (i % 2 === 0)
+        process.nextTick(cb, i, 20);
+      else
+        process.nextTick(cb, i);
+    }
+  }
+}

benchmark/process/next-tick-loop.js

@@ -0,0 +1,30 @@
+'use strict';
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [1e4, 2e4, 4e4],
+  loop: [1e2, 2e2],
+});
+
+function main({ n, loop }) {
+  bench.start();
+  run();
+  function run() {
+    let j = 0;
+
+    function cb() {
+      j++;
+      if (j === n) {
+        loop--;
+        if (loop === 0) {
+          bench.end(n);
+        } else {
+          run();
+        }
+      }
+    }
+
+    for (let i = 0; i < n; i++) {
+      process.nextTick(cb);
+    }
+  }
+}

benchmark/process/queue-microtask-breadth.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [4e5],
+});
+
+function main({ n }) {
+  let j = 0;
+
+  function cb() {
+    j++;
+    if (j === n)
+      bench.end(n);
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    queueMicrotask(cb);
+  }
+}

benchmark/process/queue-microtask-depth.js

@@ -0,0 +1,17 @@
+'use strict';
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [12e5],
+});
+
+function main({ n }) {
+  let counter = n;
+  bench.start();
+  queueMicrotask(onNextTick);
+  function onNextTick() {
+    if (--counter)
+      queueMicrotask(onNextTick);
+    else
+      bench.end(n);
+  }
+}

benchmark/process/resourceUsage.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const common = require('../common.js');
+const bench = common.createBenchmark(main, {
+  n: [1e5],
+});
+
+function main({ n }) {
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    process.resourceUsage();
+  }
+  bench.end(n);
+}