http2: reduce per-request allocations

Cut several sources of per-stream/per-request overhead on the hot
path:
- Track 'priority'/'frameError' stream listeners by overriding the
EventEmitter methods on Http2Stream instead of subscribing to
'newListener'/'removeListener', which made every listener add and
remove on every stream emit an extra tracking event.
- Replace the per-call SafeSet and sensitive-header mapping in
buildNgHeaderString with a lazily allocated array and an
empty-array fast path, and skip the HTTP token regex and
connection-specific header checks for well-known single-value
header names.
- Replace per-call closures with shared named handlers in
onStreamClose, afterShutdown and Http2Stream._destroy.
- Skip the pendingStreams Set add/delete for streams that are
created with their native handle already available (all server
streams).
- Hoist the per-request onStreamTimeout closure factories in the
compat layer to module-level handlers, and avoid a once() wrapper
allocation per server stream.
h2load, 1 KiB response payload, -c 4 -m 100, mean of 6 alternating
runs: core API 60.2k -> 69.3k req/s (+15%), compat API 43.6k ->
46.2k req/s (+5.9%).
Signed-off-by: Matteo Collina <hello@matteocollina.com>
PR-URL: #64265
Backport-PR-URL: #64663
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Tim Perry <pimterry@gmail.com>
Reviewed-By: Ethan Arrowood <ethan@arrowood.dev>

Author: mcollina

lib/internal/http2/compat.js

@@ -300,11 +300,12 @@ function onStreamCloseRequest() {
 req.emit('close');
 }
 
-functiononStreamTimeout(kind){
-returnfunctiononStreamTimeout(){
-constobj=this[kind];
-obj.emit('timeout');
-};
+functiononStreamTimeoutRequest(){
+this[kRequest].emit('timeout');
+}
+
+functiononStreamTimeoutResponse(){
+this[kResponse].emit('timeout');
 }
 
 classHttp2ServerRequestextendsReadable{
@@ -332,7 +333,7 @@ class Http2ServerRequest extends Readable {
 stream.on('error',onStreamError);
 stream.on('aborted',onStreamAbortedRequest);
 stream.on('close',onStreamCloseRequest);
-stream.on('timeout',onStreamTimeout(kRequest));
+stream.on('timeout',onStreamTimeoutRequest);
 this.on('pause',onRequestPause);
 this.on('resume',onRequestResume);
 }
@@ -486,7 +487,7 @@ class Http2ServerResponse extends Stream {
 stream.on('aborted',onStreamAbortedResponse);
 stream.on('close',onStreamCloseResponse);
 stream.on('wantTrailers',onStreamTrailersReady);
-stream.on('timeout',onStreamTimeout(kResponse));
+stream.on('timeout',onStreamTimeoutResponse);
 }
 
 // User land modules such as finalhandler just check truthiness of this

lib/internal/http2/util.js

@@ -770,14 +770,16 @@ function buildNgHeaderString(arrayOrMap,
 letpseudoHeaders='';
 letcount=0;
 
-constsingles=newSafeSet();
+letsingles;
 constsensitiveHeaders=arrayOrMap[kSensitiveHeaders]||emptyArray;
-constneverIndex=sensitiveHeaders.map((v)=>v.toLowerCase());
+constneverIndex=sensitiveHeaders.length===0 ?
+emptyArray : sensitiveHeaders.map((v)=>v.toLowerCase());
 
 functionprocessHeader(key,value){
 key=key.toLowerCase();
+constisSingleValueField=kSingleValueFields.has(key);
 constisStrictSingleValueField=strictSingleValueFields&&
-kSingleValueFields.has(key);
+isSingleValueField;
 letisArray=ArrayIsArray(value);
 if(isArray){
 switch(value.length){
@@ -795,11 +797,15 @@ function buildNgHeaderString(arrayOrMap,
 value=String(value);
 }
 if(isStrictSingleValueField){
-if(singles.has(key))
+if(singles===undefined){
+singles=[key];
+}elseif(singles.includes(key)){
 thrownewERR_HTTP2_HEADER_SINGLE_VALUE(key);
-singles.add(key);
+}else{
+singles.push(key);
+}
 }
-constflags=neverIndex.includes(key) ?
+constflags=neverIndex.length!==0&&neverIndex.includes(key) ?
 kNeverIndexFlag :
 kNoHeaderFlags;
 if(key[0]===':'){
@@ -810,11 +816,15 @@ function buildNgHeaderString(arrayOrMap,
 count++;
 return;
 }
-if(!checkIsHttpToken(key)){
-thrownewERR_INVALID_HTTP_TOKEN('Header name',key);
-}
-if(isIllegalConnectionSpecificHeader(key,value)){
-thrownewERR_HTTP2_INVALID_CONNECTION_HEADERS(key);
+// Well-known single-value fields are all valid HTTP tokens and none of
+// them is a connection-specific header, so both checks can be skipped.
+if(!isSingleValueField){
+if(!checkIsHttpToken(key)){
+thrownewERR_INVALID_HTTP_TOKEN('Header name',key);
+}
+if(isIllegalConnectionSpecificHeader(key,value)){
+thrownewERR_HTTP2_INVALID_CONNECTION_HEADERS(key);
+}
 }
 if(isArray){
 for(letj=0;j<value.length;++j){