http: reduce per-request server overhead

Eliminate per-request work that is invariant or redundant on the server
response path:

- end(chunk) issued a second, empty socket.write whose only purpose was
  to carry the finish callback, paying a full Writable pass and an
  extra cork-queue entry per response. When the header block is already
  rendered and the framing is final (no chunked trailer, no strict
  content-length accounting), the finish callback rides the body write
  itself; writes complete in order, so the observable finish timing is
  unchanged.
- The response options bag and the pending-data callback only depend on
  the connection, not the request: allocate them once per socket and
  reuse them for every response on a keep-alive connection.
- The response close listener is a no-op unless a response is attached
  (socket._httpMessage guard), so it is installed once per socket
  instead of paying the add/removeListener pair per response.
- Status lines for default reason phrases are cached per status code,
  and the Keep-Alive header line is memoized per (timeout, max)
  configuration.

Measured with a CPU-per-request harness (fresh process per sample,
25x600k-request interleaved samples, Welch t-test) on a keep-alive
hello-world server: +7.34% requests per CPU-second (p=2.0e-14), and
about +6.4% requests/sec under autocannon. All test/parallel http and
https tests pass.

Assisted-by: Grok
Signed-off-by: Yagiz Nizipli <yagiz@nizipli.com>

Author: anonrig

lib/_http_outgoing.js

@@ -537,12 +537,19 @@ function _storeHeader(firstLine, headers) {
       const keepAliveTimeout = this._keepAliveTimeout;
       if (keepAliveTimeout && this._defaultKeepAlive) {
         const timeoutSeconds = MathFloor(keepAliveTimeout / 1000);
-        const maxRequestsPerSocket = this._maxRequestsPerSocket;
-        let max = '';
-        if (~~maxRequestsPerSocket > 0) {
-          max = `, max=${maxRequestsPerSocket}`;
+        const maxRequestsPerSocket = ~~this._maxRequestsPerSocket;
+        // The Keep-Alive line is invariant per server configuration, so
+        // memoize the last rendered (timeout, max) pair instead of
+        // re-building the string for every response.
+        if (timeoutSeconds !== keepAliveLine.timeout ||
+            maxRequestsPerSocket !== keepAliveLine.max) {
+          keepAliveLine.timeout = timeoutSeconds;
+          keepAliveLine.max = maxRequestsPerSocket;
+          keepAliveLine.value = maxRequestsPerSocket > 0 ?
+            `Keep-Alive: timeout=${timeoutSeconds}, max=${maxRequestsPerSocket}\r\n` :
+            `Keep-Alive: timeout=${timeoutSeconds}\r\n`;
         }
-        header += `Keep-Alive: timeout=${timeoutSeconds}${max}\r\n`;
+        header += keepAliveLine.value;
       }
     } else {
       this._last = true;
@@ -930,6 +937,10 @@ ObjectDefineProperty(OutgoingMessage.prototype, 'writableNeedDrain', {
 });
 
 const crlf_buf = Buffer.from('\r\n');
+
+// Memoized `Keep-Alive: timeout=N[, max=M]\r\n` line; servers use one
+// configuration, so this is effectively computed once per process.
+const keepAliveLine = { timeout: -1, max: -1, value: '' };
 OutgoingMessage.prototype.write = function write(chunk, encoding, callback) {
   if (typeof encoding === 'function') {
     callback = encoding;
@@ -1140,6 +1151,17 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
     encoding = null;
   }
 
+  // When the final body chunk is written with a known length (no chunked
+  // trailer to send), the finish notification can ride the body write's
+  // completion instead of issuing a second, empty socket.write whose only
+  // purpose is to carry the callback: writes complete in order, so the
+  // observable finish timing is unchanged while a full Writable pass per
+  // response disappears. Not applicable under strict content-length
+  // accounting, where the mismatch check must run after the write and
+  // before finish is scheduled.
+  let finish;
+  let finishAttached = false;
+
   if (chunk) {
     if (this.finished) {
       onError(this,
@@ -1152,7 +1174,20 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
       this[kSocket].cork();
     }
 
-    write_(this, chunk, encoding, null, true);
+    if (this._header !== null && this._hasBody && !this.chunkedEncoding &&
+        !this.destroyed && !strictContentLength(this)) {
+      // The header block is already rendered, so the framing decision is
+      // final: write_ deterministically reaches the single non-chunked
+      // _send and the callback is guaranteed to ride the body write.
+      // (Without a rendered header, write_'s _implicitHeader call may
+      // still switch the message to chunked encoding, which needs the
+      // trailing 0\r\n\r\n send below.)
+      finish = onFinish.bind(undefined, this);
+      write_(this, chunk, encoding, finish, true);
+      finishAttached = true;
+    } else {
+      write_(this, chunk, encoding, null, true);
+    }
   } else if (this.finished) {
     if (typeof callback === 'function') {
       if (!this.writableFinished) {
@@ -1178,14 +1213,16 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
     throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten], this._contentLength);
   }
 
-  const finish = onFinish.bind(undefined, this);
+  if (!finishAttached) {
+    finish ??= onFinish.bind(undefined, this);
 
-  if (this._hasBody && this.chunkedEncoding) {
-    this._send('0\r\n' + this._trailer + '\r\n', 'latin1', finish);
-  } else if (!this._headerSent || this.writableLength || chunk) {
-    this._send('', 'latin1', finish);
-  } else {
-    process.nextTick(finish);
+    if (this._hasBody && this.chunkedEncoding) {
+      this._send('0\r\n' + this._trailer + '\r\n', 'latin1', finish);
+    } else if (!this._headerSent || this.writableLength || chunk) {
+      this._send('', 'latin1', finish);
+    } else {
+      process.nextTick(finish);
+    }
   }
 
   if (this[kSocket]) {

lib/_http_server.js

@@ -110,6 +110,7 @@ const onResponseFinishChannel = dc.channel('http.server.response.finish');
 
 const kServerResponse = Symbol('ServerResponse');
 const kServerResponseStatistics = Symbol('ServerResponseStatistics');
+const kHasResponseCloseListener = Symbol('kHasResponseCloseListener');
 const kUpgradeStream = Symbol('UpgradeStream');
 
 const kOptimizeEmptyRequests = Symbol('OptimizeEmptyRequestsOption');
@@ -186,6 +187,10 @@ const STATUS_CODES = {
   511: 'Network Authentication Required', // RFC 6585 6
 };
 
+// Lazily filled per-status-code cache of `HTTP/1.1 <code> <default reason>\r\n`
+// status lines (bounded by the status codes actually used).
+const statusLineCache = { __proto__: null };
+
 const kOnExecute = HTTPParser.kOnExecute | 0;
 const kOnTimeout = HTTPParser.kOnTimeout | 0;
 
@@ -298,15 +303,21 @@ ServerResponse.prototype.assignSocket = function assignSocket(socket) {
     throw new ERR_HTTP_SOCKET_ASSIGNED();
   }
   socket._httpMessage = this;
-  socket.on('close', onServerResponseClose);
+  // The handler is a no-op unless a response is attached (see the
+  // _httpMessage guard above), so it is installed once per socket and
+  // left in place instead of paying the add/removeListener pair for
+  // every response on a keep-alive connection.
+  if (socket[kHasResponseCloseListener] !== true) {
+    socket[kHasResponseCloseListener] = true;
+    socket.on('close', onServerResponseClose);
+  }
   this.socket = socket;
   this.emit('socket', socket);
   this._flush();
 };
 
 ServerResponse.prototype.detachSocket = function detachSocket(socket) {
   assert(socket._httpMessage === this);
-  socket.removeListener('close', onServerResponseClose);
   socket._httpMessage = null;
   this.socket = null;
 };
@@ -467,10 +478,20 @@ function writeHead(statusCode, reason, obj) {
     headers = obj;
   }
 
-  if (checkInvalidHeaderChar(this.statusMessage))
+  const statusMessage = this.statusMessage;
+  if (checkInvalidHeaderChar(statusMessage))
     throw new ERR_INVALID_CHAR('statusMessage');
 
-  const statusLine = `HTTP/1.1 ${statusCode} ${this.statusMessage}\r\n`;
+  // The status line for a default reason phrase is invariant per status
+  // code: build it once per code instead of allocating the template
+  // result for every response.
+  let statusLine;
+  if (statusMessage === STATUS_CODES[statusCode]) {
+    statusLine = statusLineCache[statusCode] ??=
+      `HTTP/1.1 ${statusCode} ${statusMessage}\r\n`;
+  } else {
+    statusLine = `HTTP/1.1 ${statusCode} ${statusMessage}\r\n`;
+  }
 
   if (statusCode === 204 || statusCode === 304 ||
       (statusCode >= 100 && statusCode <= 199)) {
@@ -810,6 +831,10 @@ function connectionListenerInternal(server, socket) {
     outgoingData: 0,
     requestsCount: 0,
     keepAliveTimeoutSet: false,
+    // Per-connection caches for per-response invariants (see
+    // parserOnIncoming): initialized here for shape stability.
+    responseOptions: null,
+    updateOutgoingData: null,
   };
   state.onData = socketOnData.bind(undefined,
                                    server, socket, parser, state);
@@ -1280,15 +1305,20 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
     }
   }
 
-  const res = new server[kServerResponse](req,
-                                          {
-                                            highWaterMark: socket.writableHighWaterMark,
-                                            rejectNonStandardBodyWrites: server.rejectNonStandardBodyWrites,
-                                          });
+  // The response options and the pending-data callback only depend on
+  // the connection, not the request: allocate them once per socket and
+  // reuse for every response on a keep-alive connection. Neither object
+  // is retained by the response (the options are only read in the
+  // OutgoingMessage constructor).
+  state.responseOptions ??= {
+    highWaterMark: socket.writableHighWaterMark,
+    rejectNonStandardBodyWrites: server.rejectNonStandardBodyWrites,
+  };
+  const res = new server[kServerResponse](req, state.responseOptions);
   res._keepAliveTimeout = server.keepAliveTimeout;
   res._maxRequestsPerSocket = server.maxRequestsPerSocket;
-  res._onPendingData = updateOutgoingData.bind(undefined,
-                                               socket, state);
+  res._onPendingData = state.updateOutgoingData ??=
+    updateOutgoingData.bind(undefined, socket, state);
 
   res.shouldKeepAlive = keepAlive;
   res[kUniqueHeaders] = server[kUniqueHeaders];