http2: reduce scheduled callbacks per request

Two per-request scheduling eliminations:

- The end-of-stream check that lets the final DATA frame carry the
  END_STREAM flag was scheduled with process.nextTick() on every
  write. When the write is dispatched from inside end() - the common
  case of end(chunk) - the check can instead run synchronously once
  end() returns and the writable state has settled. An end()
  override marks the stream while the base method runs, and
  [kWriteGeneric] hands the check back to it instead of scheduling
  a tick. Writes not tied to end() keep the nextTick behavior.

- Every stream destruction scheduled a setImmediate() to ask the
  session to clean itself up, but Http2Session[kMaybeDestroy] is a
  no-op unless the session is closed and has no remaining streams.
  Gate the setImmediate() on that condition: session.close() runs
  its own check, and the native side notifies again through
  ongracefulclosecomplete once pending data is flushed.

The wire format is unchanged (verified byte-identical h2load
traffic), and the END_STREAM merge is preserved.

h2load -c 4 -m 100, 1 KiB payload, alternating runs vs the previous
commit: consistently around +1% (within run-to-run noise on any
single set, positive across 42 paired samples).

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

Author: mcollina

lib/internal/http2/core.js

@@ -2208,6 +2208,8 @@ class Http2Stream extends Duplex {
       writeErr: null,
       endErr: null,
       writePending: 0,
+      endInProgress: false,
+      endCheckOwed: false,
       shutdownWritableCalled: false,
       fd: -1,
     };
@@ -2454,6 +2456,12 @@ class Http2Stream extends Duplex {
       // Trailers are pending, so the writable side cannot be shut down
       // early anyway; there is no point in scheduling the end check.
       state.writePending = 1;
+    } else if (state.endInProgress) {
+      // This write was dispatched from inside end(), which makes it the
+      // final chunk; end() runs the end-of-stream check synchronously once
+      // the stream machinery has settled, avoiding a nextTick per write.
+      state.writePending = 2;
+      state.endCheckOwed = true;
     } else {
       state.writePending = 2;
       // Shutdown write stream right after last chunk is sent
@@ -2494,6 +2502,25 @@ class Http2Stream extends Duplex {
     this[kWriteGeneric](true, data, '', cb);
   }
 
+  end(chunk, encoding, cb) {
+    const state = this[kState];
+    // Any write dispatched while end() runs is the final chunk. Marking
+    // that lets [kWriteGeneric] hand its end-of-stream check back to us to
+    // run synchronously below (once the writable state has settled)
+    // instead of scheduling a nextTick for it.
+    state.endInProgress = true;
+    try {
+      super.end(chunk, encoding, cb);
+    } finally {
+      state.endInProgress = false;
+      if (state.endCheckOwed) {
+        state.endCheckOwed = false;
+        endCheckNT(this);
+      }
+    }
+    return this;
+  }
+
   _final(cb) {
     if (this.pending) {
       this.once('ready', () => this._final(cb));
@@ -2656,8 +2683,16 @@ class Http2Stream extends Duplex {
     // gives the session the opportunity to clean itself up. The session
     // will destroy if it has been closed and there are no other open or
     // pending streams. Delay with setImmediate so we don't do it on the
-    // nghttp2 stack.
-    setImmediate(sessionMaybeDestroy, session);
+    // nghttp2 stack. When the session is not closed (or other streams are
+    // still around), [kMaybeDestroy] would be a no-op, so skip scheduling
+    // it altogether: session.close() runs its own check, and the native
+    // side notifies again through ongracefulclosecomplete once all pending
+    // data has been flushed.
+    if (session.closed &&
+        sessionState.streams.size === 0 &&
+        sessionState.pendingStreams.size === 0) {
+      setImmediate(sessionMaybeDestroy, session);
+    }
     if (err) {
       if (session[kType] === NGHTTP2_SESSION_CLIENT) {
         if (onClientStreamErrorChannel.hasSubscribers) {