http: reduce per-request allocations in the server · nodejs/node@357ba2f · GitHub
Skip to content

Commit 357ba2f

Browse files
mcollinamcollina
authored
http: reduce per-request allocations in the server
Remove allocations and repeated work performed for every request: - reuse a per-connection updateOutgoingData closure and a shared 'finish' listener instead of binding two functions per request, reaching resOnFinish through the connection state stored on the response - cache the ServerResponse options object per server (custom response classes keep receiving a fresh object) - check for Host, Expect, Content-Length and Transfer-Encoding by scanning rawHeaders instead of materializing req.headers, which was built (with per-name toLowerCase calls) for every request even when the application never reads it - cache the rendered status line per status code when the reason phrase is the default, skipping its character validation - cache the complete 'Date: ...' header line in the utcDate cache and the keep-alive header pair for the current server settings - compute the lenient-validation option chain once per message Signed-off-by: Matteo Collina <hello@matteocollina.com> PR-URL: #65802 Reviewed-By: Robert Nagy <ronagy@icloud.com> Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Tim Perry <pimterry@gmail.com> Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>
1 parent e98208b commit 357ba2f

4 files changed

Lines changed: 128 additions & 33 deletions

File tree

‎lib/_http_incoming.js‎

Lines changed: 1 addition & 0 deletions

‎lib/_http_outgoing.js‎

Lines changed: 35 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ const { getDefaultHighWaterMark } = require('internal/streams/state');
3838
const assert = require('internal/assert');
3939
const EE = require('events');
4040
const Stream = require('stream');
41-
const { kOutHeaders, utcDate, kNeedDrain } = require('internal/http');
41+
const { kOutHeaders, utcDateHeader, kNeedDrain } = require('internal/http');
4242
const { Buffer } = require('buffer');
4343
const {
4444
_checkIsHttpToken: checkIsHttpToken,
@@ -89,6 +89,11 @@ const kChunkedLength = Symbol('kChunkedLength');
8989
const kUniqueHeaders = Symbol('kUniqueHeaders');
9090
const kBytesWritten = Symbol('kBytesWritten');
9191
const kErrored = Symbol('errored');
92+
const kLenientCache = Symbol('kLenientCache');
93+
94+
let keepAliveTimeoutCache = -1;
95+
let keepAliveMaxCache = -1;
96+
let keepAliveHeaderCache = '';
9297
const kWritableFinished = Symbol('kWritableFinished');
9398
const kEndCallbacks = Symbol('kEndCallbacks');
9499
const kFlushError = Symbol('kFlushError');
@@ -169,6 +174,7 @@ function OutgoingMessage(options) {
169174
this[kFlushError] = null;
170175
this[kHighWaterMark] = options?.highWaterMark ?? getDefaultHighWaterMark();
171176
this[kRejectNonStandardBodyWrites] = options?.rejectNonStandardBodyWrites ?? false;
177+
this[kLenientCache] = null;
172178
}
173179
ObjectSetPrototypeOf(OutgoingMessage.prototype, Stream.prototype);
174180
ObjectSetPrototypeOf(OutgoingMessage, Stream);
@@ -178,27 +184,34 @@ ObjectSetPrototypeOf(OutgoingMessage, Stream);
178184
// For ServerResponse: checks the server's httpValidation or insecureHTTPParser
179185
// Falls back to global --insecure-http-parser flag.
180186
OutgoingMessage.prototype._isLenientHeaderValidation = function() {
187+
// The underlying options cannot change during the lifetime of a message:
188+
// compute the lookup chain only once per message.
189+
this[kLenientCache] ??= isLenientHeaderValidation(this);
190+
return this[kLenientCache];
191+
};
192+
193+
function isLenientHeaderValidation(msg) {
181194
// New httpValidation option takes priority (ClientRequest case)
182-
if (this.httpValidation !== undefined) {
183-
return this.httpValidation !== 'strict';
195+
if (msg.httpValidation !== undefined) {
196+
return msg.httpValidation !== 'strict';
184197
}
185198
// ServerResponse: check server's httpValidation option
186-
const serverHttpValidation = this.req?.socket?.server?.httpValidation;
199+
const serverHttpValidation = msg.req?.socket?.server?.httpValidation;
187200
if (serverHttpValidation !== undefined) {
188201
return serverHttpValidation !== 'strict';
189202
}
190203
// Legacy insecureHTTPParser - ClientRequest has it directly
191-
if (typeof this.insecureHTTPParser === 'boolean') {
192-
return this.insecureHTTPParser;
204+
if (typeof msg.insecureHTTPParser === 'boolean') {
205+
return msg.insecureHTTPParser;
193206
}
194207
// ServerResponse can access via req.socket.server
195-
const serverOption = this.req?.socket?.server?.insecureHTTPParser;
208+
const serverOption = msg.req?.socket?.server?.insecureHTTPParser;
196209
if (typeof serverOption === 'boolean') {
197210
return serverOption;
198211
}
199212
// Fall back to global option
200213
return isLenient();
201-
};
214+
}
202215

203216
ObjectDefineProperty(OutgoingMessage.prototype, 'errored', {
204217
__proto__: null,
@@ -508,7 +521,7 @@ function _storeHeader(firstLine, headers) {
508521

509522
// Date header
510523
if (this.sendDate && !state.date) {
511-
header += 'Date: ' + utcDate() + '\r\n';
524+
header += utcDateHeader();
512525
}
513526

514527
// Force the connection to close when the response is a 204 No Content or
@@ -541,14 +554,21 @@ function _storeHeader(firstLine, headers) {
541554
if (shouldSendKeepAlive && this.maxRequestsOnConnectionReached) {
542555
header += 'Connection: close\r\n';
543556
} else if (shouldSendKeepAlive) {
544-
header += 'Connection: keep-alive\r\n';
545557
if (this._keepAliveTimeout && this._defaultKeepAlive) {
546-
const timeoutSeconds = MathFloor(this._keepAliveTimeout / 1000);
547-
let max = '';
548-
if (~~this._maxRequestsPerSocket > 0) {
549-
max = `, max=${this._maxRequestsPerSocket}`;
558+
// The keep-alive header lines are identical for every response of a
559+
// given server: cache the last rendered value.
560+
const timeout = this._keepAliveTimeout;
561+
const max = ~~this._maxRequestsPerSocket;
562+
if (timeout !== keepAliveTimeoutCache || max !== keepAliveMaxCache) {
563+
keepAliveTimeoutCache = timeout;
564+
keepAliveMaxCache = max;
565+
keepAliveHeaderCache = 'Connection: keep-alive\r\n' +
566+
`Keep-Alive: timeout=${MathFloor(timeout / 1000)}` +
567+
(max > 0 ? `, max=${max}` : '') + '\r\n';
550568
}
551-
header += `Keep-Alive: timeout=${timeoutSeconds}${max}\r\n`;
569+
header += keepAliveHeaderCache;
570+
} else {
571+
header += 'Connection: keep-alive\r\n';
552572
}
553573
} else {
554574
this._last = true;

‎lib/_http_server.js‎

Lines changed: 82 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,7 @@ const {
7373
const {
7474
IncomingMessage,
7575
kDetachAbortSignal,
76+
kHeadersCount,
7677
} = require('_http_incoming');
7778
const {
7879
ConnResetException,
@@ -117,6 +118,10 @@ const kServerResponseStatistics = Symbol('ServerResponseStatistics');
117118
const kUpgradeStream = Symbol('UpgradeStream');
118119

119120
const kOptimizeEmptyRequests = Symbol('OptimizeEmptyRequestsOption');
121+
const kConnectionState = Symbol('ConnectionState');
122+
const kResponseOptions = Symbol('ResponseOptions');
123+
124+
const statusLineCache = [];
120125

121126
const {
122127
hasObserver,
@@ -475,10 +480,18 @@ function writeHead(statusCode, reason, obj) {
475480
headers = obj;
476481
}
477482

478-
if (checkInvalidHeaderChar(this.statusMessage))
479-
throw new ERR_INVALID_CHAR('statusMessage');
483+
let statusLine;
484+
if (this.statusMessage === STATUS_CODES[statusCode]) {
485+
// Default reason phrases contain no invalid characters and are shared
486+
// across responses: cache the whole status line.
487+
statusLine = statusLineCache[statusCode] ??=
488+
`HTTP/1.1 ${statusCode} ${this.statusMessage}\r\n`;
489+
} else {
490+
if (checkInvalidHeaderChar(this.statusMessage))
491+
throw new ERR_INVALID_CHAR('statusMessage');
480492

481-
const statusLine = `HTTP/1.1 ${statusCode} ${this.statusMessage}\r\n`;
493+
statusLine = `HTTP/1.1 ${statusCode} ${this.statusMessage}\r\n`;
494+
}
482495

483496
if (statusCode === 204 || statusCode === 304 ||
484497
(statusCode >= 100 && statusCode <= 199)) {
@@ -827,7 +840,11 @@ function connectionListenerInternal(server, socket) {
827840
outgoingData: 0,
828841
requestsCount: 0,
829842
keepAliveTimeoutSet: false,
843+
onPendingData: null,
844+
server,
845+
socket,
830846
};
847+
state.onPendingData = updateOutgoingData.bind(undefined, socket, state);
831848
state.onData = socketOnData.bind(undefined,
832849
server, socket, parser, state);
833850
state.onEnd = socketOnEnd.bind(undefined,
@@ -1264,8 +1281,61 @@ function emitCloseNT(self) {
12641281
}
12651282
}
12661283

1267-
function hasBodyHeaders(headers) {
1268-
return ('content-length' in headers) || ('transfer-encoding' in headers);
1284+
// Check for the presence of a request header by scanning rawHeaders instead
1285+
// of materializing the req.headers object. Only the first req[kHeadersCount]
1286+
// entries are considered, matching what the req.headers getter exposes.
1287+
function hasRequestHeader(req, length, lowerName) {
1288+
const rawHeaders = req.rawHeaders;
1289+
const count = req[kHeadersCount];
1290+
for (let i = 0; i < count; i += 2) {
1291+
const key = rawHeaders[i];
1292+
if (key.length === length &&
1293+
(key === lowerName || key.toLowerCase() === lowerName)) {
1294+
return true;
1295+
}
1296+
}
1297+
return false;
1298+
}
1299+
1300+
function hasBodyHeaders(req) {
1301+
const rawHeaders = req.rawHeaders;
1302+
const count = req[kHeadersCount];
1303+
for (let i = 0; i < count; i += 2) {
1304+
const length = rawHeaders[i].length;
1305+
if (length === 14 || length === 17) {
1306+
const key = rawHeaders[i].toLowerCase();
1307+
if (key === 'content-length' || key === 'transfer-encoding') {
1308+
return true;
1309+
}
1310+
}
1311+
}
1312+
return false;
1313+
}
1314+
1315+
// The options object passed to the ServerResponse constructor is identical
1316+
// for every request of a given server: cache it. Custom response classes get
1317+
// a fresh object since they may retain or mutate it.
1318+
function getResponseOptions(server, socket) {
1319+
const highWaterMark = socket.writableHighWaterMark;
1320+
const rejectNonStandardBodyWrites = server.rejectNonStandardBodyWrites;
1321+
if (server[kServerResponse] !== ServerResponse) {
1322+
return { highWaterMark, rejectNonStandardBodyWrites };
1323+
}
1324+
let options = server[kResponseOptions];
1325+
if (options === undefined ||
1326+
options.highWaterMark !== highWaterMark ||
1327+
options.rejectNonStandardBodyWrites !== rejectNonStandardBodyWrites) {
1328+
options = server[kResponseOptions] =
1329+
{ highWaterMark, rejectNonStandardBodyWrites };
1330+
}
1331+
return options;
1332+
}
1333+
1334+
// Shared 'finish' listener: everything resOnFinish needs is reachable from
1335+
// the response, avoiding a bound function per request.
1336+
function onResponseFinish() {
1337+
const state = this[kConnectionState];
1338+
resOnFinish(this.req, this, state.socket, state, state.server);
12691339
}
12701340

12711341
// The following callback is issued after the headers have been read on a
@@ -1298,15 +1368,11 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
12981368
}
12991369
}
13001370

1301-
const res = new server[kServerResponse](req,
1302-
{
1303-
highWaterMark: socket.writableHighWaterMark,
1304-
rejectNonStandardBodyWrites: server.rejectNonStandardBodyWrites,
1305-
});
1371+
const res = new server[kServerResponse](req, getResponseOptions(server, socket));
13061372
res._keepAliveTimeout = server.keepAliveTimeout;
13071373
res._maxRequestsPerSocket = server.maxRequestsPerSocket;
1308-
res._onPendingData = updateOutgoingData.bind(undefined,
1309-
socket, state);
1374+
res._onPendingData = state.onPendingData;
1375+
res[kConnectionState] = state;
13101376

13111377
res.shouldKeepAlive = keepAlive;
13121378
res[kUniqueHeaders] = server[kUniqueHeaders];
@@ -1321,7 +1387,7 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
13211387
}
13221388

13231389
// Check if we should optimize empty requests (those without Content-Length or Transfer-Encoding headers)
1324-
const shouldOptimize = server[kOptimizeEmptyRequests] === true && !hasBodyHeaders(req.headers);
1390+
const shouldOptimize = server[kOptimizeEmptyRequests] === true && !hasBodyHeaders(req);
13251391

13261392
if (shouldOptimize) {
13271393
// Fast processing where emitting 'data', 'end' and 'close' events is
@@ -1342,9 +1408,7 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
13421408

13431409
// When we're finished writing the response, check if this is the last
13441410
// response, if so destroy the socket.
1345-
res.on('finish',
1346-
resOnFinish.bind(undefined,
1347-
req, res, socket, state, server));
1411+
res.on('finish', onResponseFinish);
13481412

13491413
let handled = false;
13501414

@@ -1354,7 +1418,7 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
13541418
// From RFC 7230 5.4 https://datatracker.ietf.org/doc/html/rfc7230#section-5.4
13551419
// A server MUST respond with a 400 (Bad Request) status code to any
13561420
// HTTP/1.1 request message that lacks a Host header field
1357-
if (server.requireHostHeader && req.headers.host === undefined) {
1421+
if (server.requireHostHeader && !hasRequestHeader(req, 4, 'host')) {
13581422
res.writeHead(400, ['Connection', 'close']);
13591423
res.end();
13601424
return 0;
@@ -1377,7 +1441,7 @@ function parserOnIncoming(server, socket, state, req, keepAlive) {
13771441
server.emit('dropRequest', req, socket);
13781442
res.writeHead(503);
13791443
res.end();
1380-
} else if (req.headers.expect !== undefined) {
1444+
} else if (hasRequestHeader(req, 6, 'expect')) {
13811445
handled = true;
13821446

13831447
if (continueExpression.test(req.headers.expect)) {

‎lib/internal/http.js‎

Lines changed: 10 additions & 0 deletions

0 commit comments

Comments
 (0)