http: cache parser callbacks, intern header names

Two low-level reductions in the HTTP parser's per-request work:

- Cache the kOnHeadersComplete, kOnBody and kOnMessageComplete
  callback lookups per parser instead of doing an object property Get
  on every message. These callbacks are assigned once when the parser
  object is created and never change; the cache is cleared in Init()
  so re-initialized parsers (direct binding users) stay correct.

- Intern header field-name strings when building the header array.
  Field names repeat heavily across requests on a connection, so
  interning lets V8's string table return the same string object for
  each 'Host', 'User-Agent', etc. instead of allocating a new one per
  request. Header values are unique and stay non-interned.

No observable behavior change: header names keep their original case
in rawHeaders and all header/parser tests pass. On a keep-alive server
this is a small but consistent CPU reduction (~2%), measured on both
1-header and 8-header requests.

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

Author: mcollina

src/node_http_parser.cc

@@ -233,6 +233,20 @@ struct StringPtr {
       return String::Empty(env->isolate());
   }
 
+  // Like ToString(), but interns the result in V8's string table. Used for
+  // HTTP header field names, which repeat heavily across requests on a
+  // connection: interning lets V8 hand back the same string object instead
+  // of allocating a fresh one for every "Host", "User-Agent", etc.
+  Local<String> ToInternalizedString(Environment* env) const {
+    if (size_ != 0)
+      return OneByteString(env->isolate(),
+                           str_,
+                           static_cast<int>(size_),
+                           v8::NewStringType::kInternalized);
+    else
+      return String::Empty(env->isolate());
+  }
+
   // Strip trailing OWS (SPC or HTAB) from string.
   Local<String> ToTrimmedString(Environment* env) {
     while (size_ > 0 && IsOWS(str_[size_ - 1])) {
@@ -441,9 +455,8 @@ class Parser : public AsyncWrap, public StreamListener {
     };
 
     Local<Value> argv[A_MAX];
-    Local<Object> obj = object();
-    Local<Value> cb = obj->Get(env()->context(),
-                               kOnHeadersComplete).ToLocalChecked();
+    Local<Value> cb =
+        CachedCallback(kOnHeadersComplete, &on_headers_complete_cb_);
 
     if (!cb->IsFunction())
       return 0;
@@ -521,7 +534,7 @@ class Parser : public AsyncWrap, public StreamListener {
     Environment* env = this->env();
     HandleScope handle_scope(env->isolate());
 
-    Local<Value> cb = object()->Get(env->context(), kOnBody).ToLocalChecked();
+    Local<Value> cb = CachedCallback(kOnBody, &on_body_cb_);
 
     if (!cb->IsFunction())
       return 0;
@@ -554,9 +567,8 @@ class Parser : public AsyncWrap, public StreamListener {
 
     header_pairs_ = 0;
 
-    Local<Object> obj = object();
-    Local<Value> cb = obj->Get(env()->context(),
-                               kOnMessageComplete).ToLocalChecked();
+    Local<Value> cb =
+        CachedCallback(kOnMessageComplete, &on_message_complete_cb_);
 
     if (!cb->IsFunction())
       return 0;
@@ -940,7 +952,7 @@ class Parser : public AsyncWrap, public StreamListener {
     Local<Value> headers_v[kMaxHeaderFieldsCount * 2];
 
     for (size_t i = 0; i < num_values_; ++i) {
-      headers_v[i * 2] = fields_[i].ToString(env());
+      headers_v[i * 2] = fields_[i].ToInternalizedString(env());
       headers_v[i * 2 + 1] = values_[i].ToTrimmedString(env());
     }
 
@@ -975,10 +987,33 @@ class Parser : public AsyncWrap, public StreamListener {
   }
 
 
+  // Fetches a JS callback property from the parser object, caching it so the
+  // per-message object()->Get() lookup is only paid once. The message
+  // callbacks (kOnHeadersComplete, kOnBody, kOnMessageComplete) are assigned
+  // once when the parser object is created and never change afterwards. The
+  // cache is cleared in Init() so it stays correct if the same parser object
+  // is re-initialized with different callbacks (direct users of the binding).
+  Local<Value> CachedCallback(uint32_t index, v8::Global<v8::Value>* cache) {
+    Isolate* isolate = env()->isolate();
+    if (!cache->IsEmpty()) {
+      return cache->Get(isolate);
+    }
+    Local<Value> cb =
+        object()->Get(env()->context(), index).ToLocalChecked();
+    if (cb->IsFunction()) {
+      cache->Reset(isolate, cb);
+    }
+    return cb;
+  }
+
   void Init(llhttp_type_t type, uint64_t max_http_header_size,
             uint32_t lenient_flags) {
     llhttp_init(&parser_, type, &settings);
 
+    on_headers_complete_cb_.Reset();
+    on_body_cb_.Reset();
+    on_message_complete_cb_.Reset();
+
     if (lenient_flags & kLenientHeaders) {
       llhttp_set_lenient_headers(&parser_, 1);
     }
@@ -1102,6 +1137,11 @@ class Parser : public AsyncWrap, public StreamListener {
   size_t header_pairs_ = 0;
   double max_header_pairs_ = -1;
   bool pending_pause_ = false;
+
+  // Lazily-cached JS message callbacks; see CachedCallback().
+  v8::Global<v8::Value> on_headers_complete_cb_;
+  v8::Global<v8::Value> on_body_cb_;
+  v8::Global<v8::Value> on_message_complete_cb_;
   bool received_data_ = false;
   uint64_t header_nread_ = 0;
   uint64_t chunk_extensions_nread_ = 0;