Add a new ConcurrentReadableHashMap type. Switch the protocol conformance cache

to use it.

ConcurrentReadableHashMap is lock-free for readers, with writers using a lock to
ensure mutual exclusion amongst each other. The intent is to eventually replace
all uses ConcurrentMap with ConcurrentReadableHashMap.

ConcurrentReadableHashMap provides for relatively quick lookups by using a hash
table. Rearders perform an atomic increment/decrement in order to inform writers
that there are active readers. The design attempts to minimize wasted memory by
storing the actual elements out-of-line, and having the table store indices into
a separate array of elements.

The protocol conformance cache now uses ConcurrentReadableHashMap, which
provides faster lookups and less memory use than the previous ConcurrentMap
implementation. The previous implementation caches
ProtocolConformanceDescriptors and extracts the WitnessTable after the cache
lookup. The new implementation directly caches the WitnessTable, removing an
extra step (potentially a quite slow one) from the fast path.

The previous implementation used a generational scheme to detect when negative
cache entries became obsolete due to new dynamic libraries being loaded, and
update them in place. The new implementation just clears the entire cache when
libraries are loaded, greatly simplifying the code and saving the memory needed
to track the current generation in each negative cache entry. This means we need
to re-cache all requested conformances after loading a dynamic library, but
loading libraries at runtime is rare and slow anyway.

rdar://problem/67268325

Author: mikeash

include/swift/Reflection/ReflectionContext.h

@@ -879,7 +879,8 @@ class ReflectionContext
     std::function<void(StoredPointer Type, StoredPointer Proto)> Call) {
     if (!NodePtr)
       return;
-    auto NodeBytes = getReader().readBytes(RemoteAddress(NodePtr), sizeof(Node));
+    auto NodeBytes = getReader().readBytes(RemoteAddress(NodePtr),
+                                           sizeof(ConformanceNode<Runtime>));
     auto NodeData =
       reinterpret_cast<const ConformanceNode<Runtime> *>(NodeBytes.get());
     if (!NodeData)
@@ -889,6 +890,33 @@ class ReflectionContext
     iterateConformanceTree(NodeData->Right, Call);
   }
 
+  void IterateConformanceTable(
+      RemoteAddress ConformancesPtr,
+      std::function<void(StoredPointer Type, StoredPointer Proto)> Call) {
+    auto MapBytes = getReader().readBytes(RemoteAddress(ConformancesPtr),
+                                          sizeof(ConcurrentHashMap<Runtime>));
+    auto MapData =
+        reinterpret_cast<const ConcurrentHashMap<Runtime> *>(MapBytes.get());
+    if (!MapData)
+      return;
+
+    auto Count = MapData->ElementCount;
+    auto Size = Count * sizeof(ConformanceCacheEntry<Runtime>);
+
+    auto ElementsBytes =
+        getReader().readBytes(RemoteAddress(MapData->Elements), Size);
+    auto ElementsData =
+        reinterpret_cast<const ConformanceCacheEntry<Runtime> *>(
+            ElementsBytes.get());
+    if (!ElementsData)
+      return;
+
+    for (StoredSize i = 0; i < Count; i++) {
+      auto &Element = ElementsData[i];
+      Call(Element.Type, Element.Proto);
+    }
+  }
+
   /// Iterate the protocol conformance cache in the target process, calling Call
   /// with the type and protocol of each conformance. Returns None on success,
   /// and a string describing the error on failure.
@@ -908,7 +936,26 @@ class ReflectionContext
 
     auto Root = getReader().readPointer(ConformancesAddr->getResolvedAddress(),
                                         sizeof(StoredPointer));
-    iterateConformanceTree(Root->getResolvedAddress().getAddressData(), Call);
+    auto ReaderCount = Root->getResolvedAddress().getAddressData();
+
+    // ReaderCount will be the root pointer if the conformance cache is a
+    // ConcurrentMap. It's very unlikely that there would ever be more readers
+    // than the least valid pointer value, so compare with that to distinguish.
+    // TODO: once the old conformance cache is gone for good, remove that code.
+    uint64_t LeastValidPointerValue;
+    if (!getReader().queryDataLayout(
+            DataLayoutQueryType::DLQ_GetLeastValidPointerValue, nullptr,
+            &LeastValidPointerValue)) {
+      return std::string("unable to query least valid pointer value");
+    }
+
+    if (ReaderCount < LeastValidPointerValue)
+      IterateConformanceTable(ConformancesAddr->getResolvedAddress(), Call);
+    else {
+      // The old code has the root address at this location.
+      auto RootAddr = ReaderCount;
+      iterateConformanceTree(RootAddr, Call);
+    }
     return llvm::None;
   }
 

include/swift/Reflection/RuntimeInternals.h

@@ -46,6 +46,20 @@ template <typename Runtime> struct MetadataCacheNode {
   typename Runtime::StoredPointer Right;
 };
 
+template <typename Runtime> struct ConcurrentHashMap {
+  typename Runtime::StoredSize ReaderCount;
+  typename Runtime::StoredSize ElementCount;
+  typename Runtime::StoredPointer Elements;
+  typename Runtime::StoredPointer Indices;
+  // We'll ignore the remaining fields for now....
+};
+
+template <typename Runtime> struct ConformanceCacheEntry {
+  typename Runtime::StoredPointer Type;
+  typename Runtime::StoredPointer Proto;
+  typename Runtime::StoredPointer Witness;
+};
+
 } // end namespace reflection
 } // end namespace swift