Protocol conformance cache for generic types

This change adds a new type of cache (cache by type descriptor) to the protocol conformance lookup system. This optimization is beneficial for generic types, where the
same conformance can be reused across different instantiations of the generic type.

Key changes:
- Add a `GetOrInsertManyScope` class to `ConcurrentReadableHashMap` for performing
  multiple insertions under a single lock
- Add type descriptor-based caching for protocol conformances
- Add environment variables for controlling and debugging the conformance cache
- Add tests to verify the behavior of the conformance cache
- Fix for #82889

The implementation is controlled by the `SWIFT_DEBUG_ENABLE_CACHE_PROTOCOL_CONFORMANCES_BY_TYPE_DESCRIPTOR`
environment variable, which is enabled by default.

This reapplies #82818 after it's been reverted in #83770.

Author: DmT021

include/swift/Runtime/Concurrent.h

@@ -593,6 +593,51 @@ struct ConcurrentReadableHashMap {
     }
   }
 
+  // Common implementation for `getOrInsert` and `GetOrInsertManyScope`
+  template <class KeyTy, typename Call>
+  void getOrInsertExternallyLocked(KeyTy key, const Call &call) {
+    auto indices = IndexStorage{Indices.load(std::memory_order_relaxed)};
+    auto indicesCapacityLog2 = indices.getCapacityLog2();
+    auto elementCount = ElementCount.load(std::memory_order_relaxed);
+    auto *elements = Elements.load(std::memory_order_relaxed);
+    auto *elementsPtr = elements ? elements->data() : nullptr;
+
+    
+    auto found = this->find(key, indices, elementCount, elementsPtr);
+    if (found.first) {
+      call(found.first, false);
+      return;
+    }
+
+    auto indicesCapacity = 1UL << indicesCapacityLog2;
+
+    // The number of slots in use is elementCount + 1, since the capacity also
+    // takes a slot.
+    auto emptyCount = indicesCapacity - (elementCount + 1);
+    auto proportion = indicesCapacity / emptyCount;
+    if (proportion >= ResizeProportion) {
+      indices = resize(indices, indicesCapacityLog2, elementsPtr);
+      found = find(key, indices, elementCount, elementsPtr);
+      assert(!found.first && "Shouldn't suddenly find the key after rehashing");
+    }
+
+    if (!elements || elementCount >= elements->Capacity) {
+      elements = resize(elements, elementCount);
+    }
+    auto *element = &elements->data()[elementCount];
+
+    // Order matters: fill out the element, then update the count,
+    // then update the index.
+    bool keep = call(element, true);
+    if (keep) {
+      assert(hash_value(key) == hash_value(*element) &&
+            "Element must have the same hash code as its key.");
+      ElementCount.store(elementCount + 1, std::memory_order_release);
+      indices.storeIndexAt(&Indices, elementCount + 1, found.second,
+                          std::memory_order_release);
+    }
+  }
+
 public:
   // Implicitly trivial constructor/destructor.
   ConcurrentReadableHashMap() = default;
@@ -684,6 +729,48 @@ struct ConcurrentReadableHashMap {
     return Snapshot(this, indices, elementsPtr, elementCount);
   }
 
+  /// A wrapper that allows performing several `getOrInsert` operations under
+  /// the same lock.
+  class GetOrInsertManyScope {
+    GetOrInsertManyScope() = delete;
+    GetOrInsertManyScope(const GetOrInsertManyScope &) = delete;
+    GetOrInsertManyScope &operator=(const GetOrInsertManyScope &) = delete;
+    GetOrInsertManyScope(GetOrInsertManyScope &&) = delete;
+    GetOrInsertManyScope &operator=(GetOrInsertManyScope &&) = delete;
+
+    ConcurrentReadableHashMap &Map;
+
+  public:
+    GetOrInsertManyScope(ConcurrentReadableHashMap &map) : Map(map) {
+      Map.WriterLock.lock();
+    }
+
+    ~GetOrInsertManyScope() {
+      Map.deallocateFreeListIfSafe();
+      Map.WriterLock.unlock();
+    }
+
+    /// Get an element by key, or insert a new element for that key if one is
+    /// not already present. Invoke `call` with the pointer to the element.
+    ///
+    /// `call` is passed the following parameters:
+    ///   - `element`: the pointer to the element corresponding to `key`
+    ///   - `created`: true if the element is newly created, false if it already
+    ///                exists
+    /// `call` returns a `bool`. When `created` is `true`, the return values
+    /// mean:
+    ///   - `true` the new entry is to be kept
+    ///   - `false` indicates that the new entry is discarded
+    /// If the new entry is kept, then the new element MUST be initialized, and
+    /// have a hash value that matches the hash value of `key`.
+    ///
+    /// The return value is ignored when `created` is `false`.
+    template <class KeyTy, typename Call>
+    void getOrInsert(KeyTy key, const Call &call) {
+      Map.getOrInsertExternallyLocked(key, call);
+    }
+  };
+
   /// Get an element by key, or insert a new element for that key if one is not
   /// already present. Invoke `call` with the pointer to the element. BEWARE:
   /// `call` is invoked with the internal writer lock held, keep work to a
@@ -703,48 +790,7 @@ struct ConcurrentReadableHashMap {
   template <class KeyTy, typename Call>
   void getOrInsert(KeyTy key, const Call &call) {
     typename MutexTy::ScopedLock guard(WriterLock);
-
-    auto indices = IndexStorage{Indices.load(std::memory_order_relaxed)};
-    auto indicesCapacityLog2 = indices.getCapacityLog2();
-    auto elementCount = ElementCount.load(std::memory_order_relaxed);
-    auto *elements = Elements.load(std::memory_order_relaxed);
-    auto *elementsPtr = elements ? elements->data() : nullptr;
-
-    auto found = this->find(key, indices, elementCount, elementsPtr);
-    if (found.first) {
-      call(found.first, false);
-      deallocateFreeListIfSafe();
-      return;
-    }
-
-    auto indicesCapacity = 1UL << indicesCapacityLog2;
-
-    // The number of slots in use is elementCount + 1, since the capacity also
-    // takes a slot.
-    auto emptyCount = indicesCapacity - (elementCount + 1);
-    auto proportion = indicesCapacity / emptyCount;
-    if (proportion >= ResizeProportion) {
-      indices = resize(indices, indicesCapacityLog2, elementsPtr);
-      found = find(key, indices, elementCount, elementsPtr);
-      assert(!found.first && "Shouldn't suddenly find the key after rehashing");
-    }
-
-    if (!elements || elementCount >= elements->Capacity) {
-      elements = resize(elements, elementCount);
-    }
-    auto *element = &elements->data()[elementCount];
-
-    // Order matters: fill out the element, then update the count,
-    // then update the index.
-    bool keep = call(element, true);
-    if (keep) {
-      assert(hash_value(key) == hash_value(*element) &&
-             "Element must have the same hash code as its key.");
-      ElementCount.store(elementCount + 1, std::memory_order_release);
-      indices.storeIndexAt(&Indices, elementCount + 1, found.second,
-                           std::memory_order_release);
-    }
-
+    getOrInsertExternallyLocked(key, call);
     deallocateFreeListIfSafe();
   }
 

stdlib/public/runtime/EnvironmentVariables.def

@@ -62,6 +62,11 @@ VARIABLE(SWIFT_DEBUG_ENABLE_SHARED_CACHE_PROTOCOL_CONFORMANCES, bool, true,
 
 #endif
 
+VARIABLE(SWIFT_DEBUG_ENABLE_CACHE_PROTOCOL_CONFORMANCES_BY_TYPE_DESCRIPTOR,
+         bool, true,
+         "Enable caching protocol conformances by type descriptor in addition "
+         "to the cache by metadata.")
+
 VARIABLE(SWIFT_DEBUG_CONCURRENCY_ENABLE_COOPERATIVE_QUEUES, bool, true,
          "Enable dispatch cooperative queues in the global executor.")
 
@@ -70,6 +75,10 @@ VARIABLE(SWIFT_DEBUG_CONCURRENCY_ENABLE_COOPERATIVE_QUEUES, bool, true,
 VARIABLE(SWIFT_DEBUG_RUNTIME_EXCLUSIVITY_LOGGING, bool, false,
          "Enable the an asserts runtime to emit logging as it works.")
 
+VARIABLE(SWIFT_DEBUG_ENABLE_PROTOCOL_CONFORMANCES_LOOKUP_LOG,
+         bool, false,
+         "Enable logs for the conformance lookup routine.")
+
 #endif
 
 VARIABLE(SWIFT_BINARY_COMPATIBILITY_VERSION, uint32_t, 0,