Upload Kmake

benchmark/streams/compose.js

@@ -0,0 +1,42 @@
+'use strict';
+const common = require('../common.js');
+
+const {
+  PassThrough,
+  Readable,
+  Writable,
+  compose,
+} = require('node:stream');
+
+const bench = common.createBenchmark(main, {
+  n: [1e3],
+});
+
+function main({ n }) {
+  const cachedPassThroughs = [];
+  const cachedReadables = [];
+  const cachedWritables = [];
+
+  for (let i = 0; i < n; i++) {
+    const numberOfPassThroughs = 100;
+    const passThroughs = [];
+
+    for (let i = 0; i < numberOfPassThroughs; i++) {
+      passThroughs.push(new PassThrough());
+    }
+
+    const readable = Readable.from(['hello', 'world']);
+    const writable = new Writable({ objectMode: true, write: (chunk, encoding, cb) => cb() });
+
+    cachedPassThroughs.push(passThroughs);
+    cachedReadables.push(readable);
+    cachedWritables.push(writable);
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    const composed = compose(cachedReadables[i], ...cachedPassThroughs[i], cachedWritables[i]);
+    composed.end();
+  }
+  bench.end(n);
+}

benchmark/streams/creation.js

@@ -0,0 +1,56 @@
+'use strict';
+const common = require('../common.js');
+const {
+  Duplex,
+  Readable,
+  Transform,
+  Writable,
+} = require('stream');
+
+const bench = common.createBenchmark(main, {
+  n: [50e6],
+  kind: ['duplex', 'readable', 'transform', 'writable'],
+});
+
+function main({ n, kind }) {
+  switch (kind) {
+    case 'duplex':
+      new Duplex({});
+      new Duplex();
+
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        new Duplex();
+      bench.end(n);
+      break;
+    case 'readable':
+      new Readable({});
+      new Readable();
+
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        new Readable();
+      bench.end(n);
+      break;
+    case 'writable':
+      new Writable({});
+      new Writable();
+
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        new Writable();
+      bench.end(n);
+      break;
+    case 'transform':
+      new Transform({});
+      new Transform();
+
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        new Transform();
+      bench.end(n);
+      break;
+    default:
+      throw new Error('Invalid kind');
+  }
+}

benchmark/streams/destroy.js

@@ -0,0 +1,56 @@
+'use strict';
+const common = require('../common.js');
+const {
+  Duplex,
+  Readable,
+  Transform,
+  Writable,
+} = require('stream');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  kind: ['duplex', 'readable', 'transform', 'writable'],
+});
+
+function main({ n, kind }) {
+  switch (kind) {
+    case 'duplex':
+      new Duplex({});
+      new Duplex();
+
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        new Duplex().destroy();
+      bench.end(n);
+      break;
+    case 'readable':
+      new Readable({});
+      new Readable();
+
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        new Readable().destroy();
+      bench.end(n);
+      break;
+    case 'writable':
+      new Writable({});
+      new Writable();
+
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        new Writable().destroy();
+      bench.end(n);
+      break;
+    case 'transform':
+      new Transform({});
+      new Transform();
+
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        new Transform().destroy();
+      bench.end(n);
+      break;
+    default:
+      throw new Error('Invalid kind');
+  }
+}

benchmark/streams/pipe-object-mode.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const { Readable, Writable } = require('stream');
+
+const bench = common.createBenchmark(main, {
+  n: [5e6],
+});
+
+function main({ n }) {
+  const b = {};
+  const r = new Readable({ objectMode: true });
+  const w = new Writable({ objectMode: true });
+
+  let i = 0;
+
+  r._read = () => r.push(i++ === n ? null : b);
+  w._write = (data, enc, cb) => cb();
+
+  bench.start();
+
+  r.pipe(w);
+  w.on('finish', () => bench.end(n));
+}

benchmark/streams/pipe.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const { Readable, Writable } = require('stream');
+
+const bench = common.createBenchmark(main, {
+  n: [5e6],
+});
+
+function main({ n }) {
+  const b = Buffer.alloc(1024);
+  const r = new Readable();
+  const w = new Writable();
+
+  let i = 0;
+
+  r._read = () => r.push(i++ === n ? null : b);
+  w._write = (data, enc, cb) => cb();
+
+  bench.start();
+
+  r.pipe(w);
+  w.on('finish', () => bench.end(n));
+}

benchmark/streams/readable-async-iterator.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const common = require('../common');
+const Readable = require('stream').Readable;
+
+const bench = common.createBenchmark(main, {
+  n: [1e5],
+  sync: ['yes', 'no'],
+});
+
+async function main({ n, sync }) {
+  sync = sync === 'yes';
+
+  const s = new Readable({
+    objectMode: true,
+    read() {
+      if (sync) {
+        this.push(1);
+      } else {
+        process.nextTick(() => {
+          this.push(1);
+        });
+      }
+    },
+  });
+
+  bench.start();
+
+  let x = 0;
+  for await (const chunk of s) {
+    x += chunk;
+    if (x > n) {
+      break;
+    }
+  }
+
+  // Use x to ensure V8 does not optimize away the loop as a noop.
+  console.assert(x);
+
+  bench.end(n);
+}

benchmark/streams/readable-bigread.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const Readable = require('stream').Readable;
+
+const bench = common.createBenchmark(main, {
+  n: [1e3],
+});
+
+function main({ n }) {
+  const b = Buffer.alloc(32);
+  const s = new Readable();
+  function noop() {}
+  s._read = noop;
+
+  bench.start();
+  for (let k = 0; k < n; ++k) {
+    for (let i = 0; i < 1e3; ++i)
+      s.push(b);
+    while (s.read(128));
+  }
+  bench.end(n);
+}

benchmark/streams/readable-bigunevenread.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const Readable = require('stream').Readable;
+
+const bench = common.createBenchmark(main, {
+  n: [1e3],
+});
+
+function main({ n }) {
+  const b = Buffer.alloc(32);
+  const s = new Readable();
+  function noop() {}
+  s._read = noop;
+
+  bench.start();
+  for (let k = 0; k < n; ++k) {
+    for (let i = 0; i < 1e4; ++i)
+      s.push(b);
+    while (s.read(106));
+  }
+  bench.end(n);
+}

benchmark/streams/readable-boundaryread.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const common = require('../common');
+const Readable = require('stream').Readable;
+
+const bench = common.createBenchmark(main, {
+  n: [200e1],
+  type: ['string', 'buffer'],
+});
+
+function main({ n, type }) {
+  const s = new Readable();
+  let data = 'a'.repeat(32);
+  if (type === 'buffer')
+    data = Buffer.from(data);
+  s._read = function() {};
+
+  bench.start();
+  for (let k = 0; k < n; ++k) {
+    for (let i = 0; i < 1e4; ++i)
+      s.push(data);
+    while (s.read(32));
+  }
+  bench.end(n);
+}

benchmark/streams/readable-from.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const common = require('../common');
+const Readable = require('stream').Readable;
+
+const bench = common.createBenchmark(main, {
+  n: [1e7],
+  type: ['array', 'sync-generator-with-sync-values', 'sync-generator-with-async-values', 'async-generator'],
+});
+
+async function main({ n, type }) {
+  let fromArg;
+
+  switch (type) {
+    case 'array': {
+      fromArg = [];
+      for (let i = 0; i < n; i++) {
+        fromArg.push(`${i}`);
+      }
+
+      break;
+    }
+
+    case 'sync-generator-with-sync-values': {
+      fromArg = (function* () {
+        for (let i = 0; i < n; i++) {
+          yield `${i}`;
+        }
+      })();
+
+      break;
+    }
+
+    case 'sync-generator-with-async-values': {
+      fromArg = (function* () {
+        for (let i = 0; i < n; i++) {
+          yield Promise.resolve(`${i}`);
+        }
+      })();
+
+      break;
+    }
+
+    case 'async-generator': {
+      fromArg = (async function* () {
+        for (let i = 0; i < n; i++) {
+          yield `${i}`;
+        }
+      })();
+
+      break;
+    }
+
+    default: {
+      throw new Error(`Unknown type: ${type}`);
+    }
+  }
+
+  const s = new Readable.from(fromArg);
+
+  bench.start();
+  s.on('data', (data) => {
+    // eslint-disable-next-line no-unused-expressions
+    data;
+  });
+  s.on('close', () => {
+    bench.end(n);
+  });
+}

benchmark/streams/readable-readall.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const Readable = require('stream').Readable;
+
+const bench = common.createBenchmark(main, {
+  n: [50e2],
+});
+
+function main({ n }) {
+  const b = Buffer.alloc(32);
+  const s = new Readable();
+  function noop() {}
+  s._read = noop;
+
+  bench.start();
+  for (let k = 0; k < n; ++k) {
+    for (let i = 0; i < 1e3; ++i)
+      s.push(b);
+    while (s.read());
+  }
+  bench.end(n);
+}

benchmark/streams/readable-uint8array.js

@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common.js');
+const { Readable } = require('stream');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  kind: ['read', 'encoding'],
+});
+const ABC = new Uint8Array([0x41, 0x42, 0x43]);
+
+function main({ n, kind }) {
+  switch (kind) {
+    case 'read': {
+      bench.start();
+      const readable = new Readable({
+        read() {},
+      });
+      for (let i = 0; i < n; ++i) readable.push(ABC);
+      bench.end(n);
+      break;
+    }
+
+    case 'encoding': {
+      bench.start();
+      const readable = new Readable({
+        read() {},
+      });
+      readable.setEncoding('utf8');
+      for (let i = 0; i < n; ++i) readable.push(ABC);
+      bench.end(n);
+      break;
+    }
+    default:
+      throw new Error('Invalid kind');
+  }
+}

benchmark/streams/readable-unevenread.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const common = require('../common');
+const Readable = require('stream').Readable;
+
+const bench = common.createBenchmark(main, {
+  n: [1e3],
+});
+
+function main({ n }) {
+  const b = Buffer.alloc(32);
+  const s = new Readable();
+  function noop() {}
+  s._read = noop;
+
+  bench.start();
+  for (let k = 0; k < n; ++k) {
+    for (let i = 0; i < 1e4; ++i)
+      s.push(b);
+    while (s.read(12));
+  }
+  bench.end(n);
+}

benchmark/streams/writable-manywrites.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+const Writable = require('stream').Writable;
+
+const bench = common.createBenchmark(main, {
+  n: [1e5],
+  sync: ['yes', 'no'],
+  writev: ['yes', 'no'],
+  callback: ['yes', 'no'],
+  len: [1024, 32 * 1024],
+});
+
+function main({ n, sync, writev, callback, len }) {
+  const b = Buffer.allocUnsafe(len);
+  const s = new Writable({ highWaterMark: 16 * 1024 });
+  sync = sync === 'yes';
+
+  const writecb = (cb) => {
+    if (sync)
+      cb();
+    else
+      process.nextTick(cb);
+  };
+
+  if (writev === 'yes') {
+    s._writev = (chunks, cb) => writecb(cb);
+  } else {
+    s._write = (chunk, encoding, cb) => writecb(cb);
+  }
+
+  const cb = callback === 'yes' ? () => {} : null;
+
+  bench.start();
+
+  let k = 0;
+  function run() {
+    while (k++ < n && s.write(b, cb));
+    if (k >= n) {
+      bench.end(n);
+      s.removeListener('drain', run);
+    }
+  }
+  s.on('drain', run);
+  run();
+}

benchmark/streams/writable-uint8array.js

@@ -0,0 +1,51 @@
+'use strict';
+const common = require('../common.js');
+const { Writable } = require('stream');
+
+const bench = common.createBenchmark(main, {
+  n: [50e6],
+  kind: ['write', 'object-mode', 'writev'],
+});
+const ABC = new Uint8Array([0x41, 0x42, 0x43]);
+
+function main({ n, kind }) {
+  switch (kind) {
+    case 'write': {
+      bench.start();
+      const wr = new Writable({
+        write(chunk, encoding, cb) {
+          cb();
+        },
+      });
+      for (let i = 0; i < n; ++i) wr.write(ABC);
+      bench.end(n);
+      break;
+    }
+
+    case 'object-mode': {
+      bench.start();
+      const wr = new Writable({
+        objectMode: true,
+        write(chunk, encoding, cb) {
+          cb();
+        },
+      });
+      for (let i = 0; i < n; ++i) wr.write(ABC);
+      bench.end(n);
+      break;
+    }
+    case 'writev': {
+      bench.start();
+      const wr = new Writable({
+        writev(chunks, cb) {
+          cb();
+        },
+      });
+      for (let i = 0; i < n; ++i) wr.write(ABC);
+      bench.end(n);
+      break;
+    }
+    default:
+      throw new Error('Invalid kind');
+  }
+}