Merge pull request #34769 from mikeash/concurrentmap-misc-to-concurrentreadablehashmap

[Runtime] Change ProtocolCache, NominalCache, and HashableConformances to ConcurrentReadableHashMap.

Author: mikeash

stdlib/public/runtime/AnyHashableSupport.cpp

@@ -29,6 +29,10 @@ struct HashableConformanceKey {
   /// The lookup key, the metadata of a type that is possibly derived
   /// from a type that conforms to `Hashable`.
   const Metadata *derivedType;
+
+  friend llvm::hash_code hash_value(const HashableConformanceKey &key) {
+    return llvm::hash_value(key.derivedType);
+  }
 };
 
 struct HashableConformanceEntry {
@@ -48,12 +52,12 @@ struct HashableConformanceEntry {
       : derivedType(key.derivedType),
         baseTypeThatConformsToHashable(baseTypeThatConformsToHashable) {}
 
-  int compareWithKey(const HashableConformanceKey &key) const {
-    if (key.derivedType != derivedType) {
-      return (uintptr_t(key.derivedType) < uintptr_t(derivedType) ? -1 : 1);
-    } else {
-      return 0;
-    }
+  bool matchesKey(const HashableConformanceKey &key) {
+    return derivedType == key.derivedType;
+  }
+
+  friend llvm::hash_code hash_value(const HashableConformanceEntry &value) {
+    return hash_value(HashableConformanceKey{value.derivedType});
   }
 
   static size_t
@@ -70,16 +74,18 @@ struct HashableConformanceEntry {
 
 // FIXME(performance): consider merging this cache into the regular
 // protocol conformance cache.
-static ConcurrentMap<HashableConformanceEntry, /*Destructor*/ false>
-  HashableConformances;
+static ConcurrentReadableHashMap<HashableConformanceEntry> HashableConformances;
 
 template <bool KnownToConformToHashable>
 SWIFT_ALWAYS_INLINE static const Metadata *
 findHashableBaseTypeImpl(const Metadata *type) {
   // Check the cache first.
-  if (HashableConformanceEntry *entry =
-          HashableConformances.find(HashableConformanceKey{type})) {
-    return entry->baseTypeThatConformsToHashable;
+  {
+    auto snapshot = HashableConformances.snapshot();
+    if (const HashableConformanceEntry *entry =
+            snapshot.find(HashableConformanceKey{type})) {
+      return entry->baseTypeThatConformsToHashable;
+    }
   }
 
   auto witnessTable =
@@ -93,8 +99,13 @@ findHashableBaseTypeImpl(const Metadata *type) {
   const auto *conformance = witnessTable->getDescription();
   const Metadata *baseTypeThatConformsToHashable =
     findConformingSuperclass(type, conformance);
-  HashableConformances.getOrInsert(HashableConformanceKey{type},
-                                   baseTypeThatConformsToHashable);
+  HashableConformanceKey key{type};
+  HashableConformances.getOrInsert(key, [&](HashableConformanceEntry *entry,
+                                            bool created) {
+    if (created)
+      new (entry) HashableConformanceEntry(key, baseTypeThatConformsToHashable);
+    return true; // Keep the new entry.
+  });
   return baseTypeThatConformsToHashable;
 }
 

stdlib/public/runtime/MetadataLookup.cpp

@@ -211,20 +211,29 @@ namespace {
 
   struct NominalTypeDescriptorCacheEntry {
   private:
-    std::string Name;
+    const char *Name;
+    size_t NameLength;
     const ContextDescriptor *Description;
 
   public:
     NominalTypeDescriptorCacheEntry(const llvm::StringRef name,
                                     const ContextDescriptor *description)
-      : Name(name.str()), Description(description) {}
+        : Description(description) {
+      char *nameCopy = reinterpret_cast<char *>(malloc(name.size()));
+      memcpy(nameCopy, name.data(), name.size());
+      Name = nameCopy;
+      NameLength = name.size();
+    }
+
+    const ContextDescriptor *getDescription() const { return Description; }
 
-    const ContextDescriptor *getDescription() {
-      return Description;
+    bool matchesKey(llvm::StringRef aName) {
+      return aName == llvm::StringRef{Name, NameLength};
     }
 
-    int compareWithKey(llvm::StringRef aName) const {
-      return aName.compare(Name);
+    friend llvm::hash_code
+    hash_value(const NominalTypeDescriptorCacheEntry &value) {
+      return hash_value(llvm::StringRef{value.Name, value.NameLength});
     }
 
     template <class... T>
@@ -235,7 +244,7 @@ namespace {
 } // end anonymous namespace
 
 struct TypeMetadataPrivateState {
-  ConcurrentMap<NominalTypeDescriptorCacheEntry> NominalCache;
+  ConcurrentReadableHashMap<NominalTypeDescriptorCacheEntry> NominalCache;
   ConcurrentReadableArray<TypeMetadataSection> SectionsToScan;
 
   TypeMetadataPrivateState() {
@@ -713,8 +722,11 @@ _findContextDescriptor(Demangle::NodePointer node,
 
   // Look for an existing entry.
   // Find the bucket for the metadata entry.
-  if (auto Value = T.NominalCache.find(mangledName))
-    return Value->getDescription();
+  {
+    auto snapshot = T.NominalCache.snapshot();
+    if (auto Value = snapshot.find(mangledName))
+      return Value->getDescription();
+  }
 
   // Check type metadata records		   
   // Scan any newly loaded images for context descriptors, then try the context
@@ -726,7 +738,13 @@ _findContextDescriptor(Demangle::NodePointer node,
     foundContext = _searchConformancesByMangledTypeName(node);
 
   if (foundContext)
-    T.NominalCache.getOrInsert(mangledName, foundContext);
+    T.NominalCache.getOrInsert(mangledName, [&](NominalTypeDescriptorCacheEntry
+                                                    *entry,
+                                                bool created) {
+      if (created)
+        new (entry) NominalTypeDescriptorCacheEntry{mangledName, foundContext};
+      return true;
+    });
 
   return foundContext;
 }
@@ -746,18 +764,29 @@ namespace {
 
   struct ProtocolDescriptorCacheEntry {
   private:
-    std::string Name;
+    const char *Name;
+    size_t NameLength;
     const ProtocolDescriptor *Description;
 
   public:
     ProtocolDescriptorCacheEntry(const llvm::StringRef name,
                                  const ProtocolDescriptor *description)
-        : Name(name.str()), Description(description) {}
+        : Description(description) {
+      char *nameCopy = reinterpret_cast<char *>(malloc(name.size()));
+      memcpy(nameCopy, name.data(), name.size());
+      Name = nameCopy;
+      NameLength = name.size();
+    }
 
-    const ProtocolDescriptor *getDescription() { return Description; }
+    const ProtocolDescriptor *getDescription() const { return Description; }
 
-    int compareWithKey(llvm::StringRef aName) const {
-      return aName.compare(Name);
+    bool matchesKey(llvm::StringRef aName) {
+      return aName == llvm::StringRef{Name, NameLength};
+    }
+
+    friend llvm::hash_code
+    hash_value(const ProtocolDescriptorCacheEntry &value) {
+      return hash_value(llvm::StringRef{value.Name, value.NameLength});
     }
 
     template <class... T>
@@ -767,7 +796,7 @@ namespace {
   };
 
   struct ProtocolMetadataPrivateState {
-    ConcurrentMap<ProtocolDescriptorCacheEntry> ProtocolCache;
+    ConcurrentReadableHashMap<ProtocolDescriptorCacheEntry> ProtocolCache;
     ConcurrentReadableArray<ProtocolSection> SectionsToScan;
 
     ProtocolMetadataPrivateState() {
@@ -849,14 +878,23 @@ _findProtocolDescriptor(NodePointer node,
 
   // Look for an existing entry.
   // Find the bucket for the metadata entry.
-  if (auto Value = T.ProtocolCache.find(mangledName))
-    return Value->getDescription();
+  {
+    auto snapshot = T.ProtocolCache.snapshot();
+    if (auto Value = snapshot.find(mangledName))
+      return Value->getDescription();
+  }
 
   // Check type metadata records
   foundProtocol = _searchProtocolRecords(T, node);
 
   if (foundProtocol) {
-    T.ProtocolCache.getOrInsert(mangledName, foundProtocol);
+    T.ProtocolCache.getOrInsert(mangledName, [&](ProtocolDescriptorCacheEntry
+                                                     *entry,
+                                                 bool created) {
+      if (created)
+        new (entry) ProtocolDescriptorCacheEntry{mangledName, foundProtocol};
+      return true;
+    });
   }
 
   return foundProtocol;