Optimize the common header name handling

While the common header names and indices are defined in
the capnp header, they are unlikely to change often (if at
all). To avoid the overhead of building the hash map at
runtime and performing the hash lookups, we can hardcode
the common header names in an array and use direct indexing
to retrieve them. Should at least save a handful of CPU
cycles.

Author: jasnell

src/workerd/api/headers.c++

@@ -98,6 +98,87 @@ void requireValidHeaderValue(kj::StringPtr value) {
     JSG_REQUIRE(c != '\0' && c != '\r' && c != '\n', TypeError, "Invalid header value.");
   }
 }
+
+// If any more headers are added to the CommonHeaderName enum later, we should be careful about
+// introducing them into serialization. We need to roll out a change that recognizes the new IDs
+// before rolling out a change that sends them. MAX_COMMON_HEADER_ID is the max value we're willing
+// to send.
+static constexpr size_t MAX_COMMON_HEADER_ID =
+    static_cast<size_t>(capnp::CommonHeaderName::WWW_AUTHENTICATE);
+
+// Constexpr array of lowercase common header names (must match CommonHeaderName enum order
+// and must be kept in sync with the ordinal values defined in http-over-capnp.capnp). Since
+// it is extremely unlikely that those will change often, we hardcode them here for runtime
+// efficiency.
+static constexpr const char* COMMON_HEADER_NAMES[] = {
+  nullptr,                        // 0: invalid
+  "accept-charset",               // 1
+  "accept-encoding",              // 2
+  "accept-language",              // 3
+  "accept-ranges",                // 4
+  "accept",                       // 5
+  "access-control-allow-origin",  // 6
+  "age",                          // 7
+  "allow",                        // 8
+  "authorization",                // 9
+  "cache-control",                // 10
+  "content-disposition",          // 11
+  "content-encoding",             // 12
+  "content-language",             // 13
+  "content-length",               // 14
+  "content-location",             // 15
+  "content-range",                // 16
+  "content-type",                 // 17
+  "cookie",                       // 18
+  "date",                         // 19
+  "etag",                         // 20
+  "expect",                       // 21
+  "expires",                      // 22
+  "from",                         // 23
+  "host",                         // 24
+  "if-match",                     // 25
+  "if-modified-since",            // 26
+  "if-none-match",                // 27
+  "if-range",                     // 28
+  "if-unmodified-since",          // 29
+  "last-modified",                // 30
+  "link",                         // 31
+  "location",                     // 32
+  "max-forwards",                 // 33
+  "proxy-authenticate",           // 34
+  "proxy-authorization",          // 35
+  "range",                        // 36
+  "referer",                      // 37
+  "refresh",                      // 38
+  "retry-after",                  // 39
+  "server",                       // 40
+  "set-cookie",                   // 41
+  "strict-transport-security",    // 42
+  "transfer-encoding",            // 43
+  "user-agent",                   // 44
+  "vary",                         // 45
+  "via",                          // 46
+  "www-authenticate",             // 47
+};
+
+kj::String getCommonHeaderName(uint id) {
+  KJ_ASSERT(id > 0 && id <= MAX_COMMON_HEADER_ID, "Invalid common header ID");
+  auto name = COMMON_HEADER_NAMES[id];
+  KJ_DASSERT(name != nullptr);
+  return kj::str(name);
+}
+
+kj::Maybe<uint> getCommonHeaderId(kj::StringPtr name) {
+  // It really shouldn't be possible for a name to be empty but just in case...
+  if (name.size() == 0) return kj::none;
+  for (uint i = 1; i <= MAX_COMMON_HEADER_ID; ++i) {
+    KJ_DASSERT(COMMON_HEADER_NAMES[i] != nullptr);
+    if (name == COMMON_HEADER_NAMES[i]) return i;
+  }
+  return kj::none;
+}
+
+static_assert(std::size(COMMON_HEADER_NAMES) == (MAX_COMMON_HEADER_ID + 1));
 }  // namespace
 
 Headers::Headers(jsg::Lock& js, jsg::Dict<jsg::ByteString, jsg::ByteString> dict)
@@ -416,78 +497,6 @@ bool Headers::inspectImmutable() {
 // capitalization). So, it's certainly not worth it to try to keep the original capitalization
 // across serialization.
 
-// If any more headers are added to the CommonHeaderName enum later, we should be careful about
-// introducing them into serialization. We need to roll out a change that recognizes the new IDs
-// before rolling out a change that sends them. MAX_COMMON_HEADER_ID is the max value we're willing
-// to send.
-static constexpr uint MAX_COMMON_HEADER_ID =
-    static_cast<uint>(capnp::CommonHeaderName::WWW_AUTHENTICATE);
-
-// ID for the `$commonText` annotation declared in http-over-capnp.capnp.
-// TODO(cleanup): Cap'n Proto should really codegen constants for annotation IDs so we don't have
-//   to copy them.
-static constexpr uint64_t COMMON_TEXT_ANNOTATION_ID = 0x857745131db6fc83;
-
-static kj::Array<kj::StringPtr> makeCommonHeaderList() {
-  auto enums = capnp::Schema::from<capnp::CommonHeaderName>().getEnumerants();
-  auto builder = kj::heapArrayBuilder<kj::StringPtr>(enums.size());
-  bool first = true;
-  for (auto e: enums) {
-    if (first) {
-      // Value zero is invalid, skip it.
-      static_assert(static_cast<uint>(capnp::CommonHeaderName::INVALID) == 0);
-
-      // Add `nullptr` to the array so that our array indexes aren't off-by-one from the enum
-      // values. We could in theory skip this and use +1 and -1 in a bunch of places but that seems
-      // error-prone.
-      builder.add(nullptr);
-
-      first = false;
-      continue;
-    }
-
-    kj::Maybe<kj::StringPtr> name;
-
-    // Look for $commonText annotation.
-    for (auto ann: e.getProto().getAnnotations()) {
-      if (ann.getId() == COMMON_TEXT_ANNOTATION_ID) {
-        name = ann.getValue().getText();
-        break;
-      }
-    }
-
-    builder.add(KJ_ASSERT_NONNULL(name));
-  }
-
-  return builder.finish();
-}
-
-static kj::ArrayPtr<const kj::StringPtr> getCommonHeaderList() {
-  static const kj::Array<kj::StringPtr> LIST = makeCommonHeaderList();
-  return LIST;
-}
-
-static kj::HashMap<kj::String, uint> makeCommonHeaderMap() {
-  kj::HashMap<kj::String, uint> result;
-  auto list = getCommonHeaderList();
-  KJ_ASSERT(MAX_COMMON_HEADER_ID < list.size());
-  for (auto i: kj::range(1, MAX_COMMON_HEADER_ID + 1)) {
-    auto key = kj::str(list[i]);
-    for (auto& c: key) {
-      if ('A' <= c && c <= 'Z') {
-        c = c - 'A' + 'a';
-      }
-    }
-    result.insert(kj::mv(key), i);
-  }
-  return result;
-}
-
-static const kj::HashMap<kj::String, uint>& getCommonHeaderMap() {
-  static const kj::HashMap<kj::String, uint> MAP = makeCommonHeaderMap();
-  return MAP;
-}
-
 void Headers::serialize(jsg::Lock& js, jsg::Serializer& serializer) {
   // We serialize as a series of key-value pairs. Each value is a length-delimited string. Each key
   // is a common header ID, or the value zero to indicate an uncommon header, which is then
@@ -503,10 +512,9 @@ void Headers::serialize(jsg::Lock& js, jsg::Serializer& serializer) {
   serializer.writeRawUint32(count);
 
   // Now write key/values.
-  auto& commonHeaders = getCommonHeaderMap();
   for (auto& entry: headers) {
     auto& header = entry.second;
-    auto commonId = commonHeaders.find(header.key);
+    auto commonId = getCommonHeaderId(header.key);
     for (auto& value: header.values) {
       KJ_IF_SOME(c, commonId) {
         serializer.writeRawUint32(c);
@@ -527,15 +535,14 @@ jsg::Ref<Headers> Headers::deserialize(
 
   uint count = deserializer.readRawUint32();
 
-  auto commonHeaders = getCommonHeaderList();
   for (auto i KJ_UNUSED: kj::zeroTo(count)) {
     uint commonId = deserializer.readRawUint32();
     kj::String name;
     if (commonId == 0) {
       name = deserializer.readLengthDelimitedString();
     } else {
-      KJ_ASSERT(commonId < commonHeaders.size());
-      name = kj::str(commonHeaders[commonId]);
+      KJ_ASSERT(commonId <= MAX_COMMON_HEADER_ID);
+      name = getCommonHeaderName(commonId);
     }
 
     auto value = deserializer.readLengthDelimitedString();