stream: keep webstreams nil requests in fast mode

The shared "no pending request" records in the writable stream were
`__proto__: null` literals, which V8 creates in dictionary mode. They
sit in inFlightWriteRequest, closeRequest and pendingAbortRequest
whenever nothing is pending, and their promise field is checked several
times per write, so those loads did a hash lookup on every write and
every pipe. They are now plain literals; every field is an own property,
so the prototype is never consulted.

The readable controllers also initialized their state slot with an
empty object that setup replaced immediately. That throwaway allocation
is gone, matching the writable and transform controllers.

Add a writable-write benchmark: nothing in benchmark/webstreams drove
WritableStreamDefaultWriter.write() directly.

Signed-off-by: Matteo Collina <hello@matteocollina.com>

Author: mcollina

benchmark/webstreams/writable-write.js

@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common.js');
+const assert = require('node:assert');
+const { WritableStream } = require('node:stream/web');
+
+const bench = common.createBenchmark(main, {
+  n: [1e5],
+  type: ['await', 'queued'],
+});
+
+async function main({ n, type }) {
+  let count = 0;
+  const ws = new WritableStream({
+    write() {
+      count++;
+    },
+  }, { highWaterMark: type === 'queued' ? n : 1 });
+  const writer = ws.getWriter();
+  bench.start();
+  if (type === 'await') {
+    for (let i = 0; i < n; i++)
+      await writer.write('a');
+  } else {
+    for (let i = 1; i < n; i++)
+      writer.write('a');
+    await writer.write('a');
+  }
+  bench.end(n);
+  await writer.close();
+  assert.strictEqual(count, n);
+}

lib/internal/webstreams/readablestream.js

@@ -1140,7 +1140,6 @@ ObjectDefineProperties(ReadableStreamBYOBReader.prototype, {
 
 class ReadableStreamDefaultController {
   [kType] = 'ReadableStreamDefaultController';
-  [kState] = {};
 
   constructor(skipThrowSymbol = undefined) {
     if (skipThrowSymbol !== kSkipThrow) {
@@ -1203,7 +1202,6 @@ ObjectDefineProperties(ReadableStreamDefaultController.prototype, {
 
 class ReadableByteStreamController {
   [kType] = 'ReadableByteStreamController';
-  [kState] = {};
 
   constructor(skipThrowSymbol = undefined) {
     if (skipThrowSymbol !== kSkipThrow) {

lib/internal/webstreams/writablestream.js

@@ -105,15 +105,16 @@ const kSkipThrow = Symbol('kSkipThrow');
 // Shared sentinels for the "no pending request" state records. These
 // records are only ever replaced wholesale and never mutated in place,
 // so single shared instances are safe and avoid an allocation on every
-// state reset (one per write on the hot path).
+// state reset (one per write on the hot path). They are plain literals:
+// a `__proto__: null` literal is created in dictionary mode, and these
+// fields are loaded several times per write. Every field is an own
+// property, so Object.prototype is never consulted.
 const kNilRequest = {
-  __proto__: null,
   promise: undefined,
   resolve: undefined,
   reject: undefined,
 };
 const kNilPendingAbortRequest = {
-  __proto__: null,
   abort: kNilRequest,
   reason: undefined,
   wasAlreadyErroring: false,