benchmark: include webstreams benchmark

benchmark/webstreams/creation.js

@@ -0,0 +1,49 @@
+'use strict';
+const common = require('../common.js');
+const {
+  ReadableStream,
+  TransformStream,
+  WritableStream,
+} = require('node:stream/web');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  n: [50e3],
+  kind: ['ReadableStream', 'TransformStream', 'WritableStream']
+});
+
+let rs, ws, ts;
+
+function main({ n, kind }) {
+  switch (kind) {
+    case 'ReadableStream':
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        rs = new ReadableStream();
+      bench.end(n);
+
+      // Avoid V8 deadcode (elimination)
+      assert.ok(rs);
+      break;
+    case 'WritableStream':
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        ws = new WritableStream();
+      bench.end(n);
+
+      // Avoid V8 deadcode (elimination)
+      assert.ok(ws);
+      break;
+    case 'TransformStream':
+      bench.start();
+      for (let i = 0; i < n; ++i)
+        ts = new TransformStream();
+      bench.end(n);
+
+      // Avoid V8 deadcode (elimination)
+      assert.ok(ts);
+      break;
+    default:
+      throw new Error('Invalid kind');
+  }
+}

benchmark/webstreams/pipe-to.js

@@ -0,0 +1,36 @@
+'use strict';
+const common = require('../common.js');
+const {
+  ReadableStream,
+  WritableStream,
+} = require('node:stream/web');
+
+const bench = common.createBenchmark(main, {
+  n: [5e6],
+  highWaterMarkR: [512, 1024, 2048, 4096],
+  highWaterMarkW: [512, 1024, 2048, 4096],
+});
+
+
+async function main({ n, highWaterMarkR, highWaterMarkW }) {
+  const b = Buffer.alloc(1024);
+  let i = 0;
+  const rs = new ReadableStream({
+    highWaterMark: highWaterMarkR,
+    pull: function(controller) {
+      if (i++ === n) {
+        controller.enqueue(b);
+      } else {
+        controller.close();
+      }
+    }
+  });
+  const ws = new WritableStream({
+    highWaterMark: highWaterMarkW,
+    write(chunk, controller) {},
+    close() { bench.end(n); },
+  });
+
+  bench.start();
+  rs.pipeTo(ws);
+}

benchmark/webstreams/readable-async-iterator.js

@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common.js');
+const {
+  ReadableStream,
+} = require('node:stream/web');
+
+const bench = common.createBenchmark(main, {
+  n: [1e5],
+});
+
+
+async function main({ n }) {
+  const rs = new ReadableStream({
+    pull: function(controller) {
+      controller.enqueue(1);
+    }
+  });
+
+  let x = 0;
+
+  bench.start();
+  for await (const chunk of rs) {
+    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);
+}

test/benchmark/test-benchmark-webstreams.js

@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('webstreams', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });