Cache additional TypeRefBuilder operations

Speed up Remote Mirror significantly by caching two additional
calculations in TypeRefBuilder.

Resolves rdar://111248508

Author: bentroller

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -424,6 +424,15 @@ class TypeRefBuilder {
   /// Cache for field info lookups.
   std::unordered_map<std::string, RemoteRef<FieldDescriptor>> FieldTypeInfoCache;
 
+  /// Cache for normalized reflection name lookups.
+  std::unordered_map<uint64_t /* remote address */, llvm::Optional<std::string>>
+      NormalizedReflectionNameCache;
+
+  /// Cache for built-in type descriptor lookups.
+  std::unordered_map<std::string /* normalized name */,
+                     RemoteRef<BuiltinTypeDescriptor>>
+      BuiltInTypeDescriptorCache;
+
   std::vector<std::unique_ptr<const GenericSignatureRef>> SignatureRefPool;
 
   TypeConverter TC;
@@ -1043,6 +1052,30 @@ class TypeRefBuilder {
     ReflectionInfos.push_back(I);
     auto InfoID = ReflectionInfos.size() - 1;
     assert(InfoID <= UINT32_MAX && "ReflectionInfo ID overflow");
+
+    for (auto BuiltinTypeDescriptor : I.Builtin) {
+      if (BuiltinTypeDescriptor->Stride <= 0)
+        continue;
+      if (!BuiltinTypeDescriptor->hasMangledTypeName())
+        continue;
+
+      auto Alignment = BuiltinTypeDescriptor->getAlignment();
+      if (Alignment <= 0)
+        continue;
+      // Reject any alignment that's not a power of two.
+      if (Alignment & (Alignment - 1))
+        continue;
+
+      const auto CandidateMangledName =
+          readTypeRef(BuiltinTypeDescriptor, BuiltinTypeDescriptor->TypeName);
+      const auto CandidateNormalizedName =
+          normalizeReflectionName(CandidateMangledName);
+      if (CandidateNormalizedName) {
+        BuiltInTypeDescriptorCache.insert(
+            std::make_pair(*CandidateNormalizedName, BuiltinTypeDescriptor));
+      }
+    }
+
     return InfoID;
   }
 

stdlib/public/RemoteInspection/TypeRefBuilder.cpp

@@ -93,6 +93,14 @@ RemoteRef<char> TypeRefBuilder::readTypeRef(uint64_t remoteAddr) {
 /// Load and normalize a mangled name so it can be matched with string equality.
 llvm::Optional<std::string>
 TypeRefBuilder::normalizeReflectionName(RemoteRef<char> reflectionName) {
+  const auto reflectionNameRemoteAddress = reflectionName.getAddressData();
+
+  if (const auto found =
+          NormalizedReflectionNameCache.find(reflectionNameRemoteAddress);
+      found != NormalizedReflectionNameCache.end()) {
+    return found->second;
+  }
+
   ScopedNodeFactoryCheckpoint checkpoint(this);
   // Remangle the reflection name to resolve symbolic references.
   if (auto node = demangleTypeRef(reflectionName,
@@ -102,18 +110,27 @@ TypeRefBuilder::normalizeReflectionName(RemoteRef<char> reflectionName) {
     case Node::Kind::ProtocolSymbolicReference:
     case Node::Kind::OpaqueTypeDescriptorSymbolicReference:
       // Symbolic references cannot be mangled, return a failure.
+      NormalizedReflectionNameCache.insert(std::make_pair(
+          reflectionNameRemoteAddress, (llvm::Optional<std::string>){}));
       return {};
     default:
       auto mangling = mangleNode(node);
       if (!mangling.isSuccess()) {
+        NormalizedReflectionNameCache.insert(std::make_pair(
+            reflectionNameRemoteAddress, (llvm::Optional<std::string>){}));
         return {};
       }
+      NormalizedReflectionNameCache.insert(
+          std::make_pair(reflectionNameRemoteAddress, mangling.result()));
       return std::move(mangling.result());
     }
   }
 
   // Fall back to the raw string.
-  return getTypeRefString(reflectionName).str();
+  const auto manglingResult = getTypeRefString(reflectionName).str();
+  NormalizedReflectionNameCache.insert(
+      std::make_pair(reflectionNameRemoteAddress, manglingResult));
+  return std::move(manglingResult);
 }
 
 /// Determine whether the given reflection protocol name matches.
@@ -398,26 +415,9 @@ TypeRefBuilder::getBuiltinTypeInfo(const TypeRef *TR) {
   else
     return nullptr;
 
-  for (auto Info : ReflectionInfos) {
-    for (auto BuiltinTypeDescriptor : Info.Builtin) {
-      if (BuiltinTypeDescriptor->Stride <= 0)
-        continue;
-      if (!BuiltinTypeDescriptor->hasMangledTypeName())
-        continue;
-
-      auto Alignment = BuiltinTypeDescriptor->getAlignment();
-      if (Alignment <= 0)
-        continue;
-      // Reject any alignment that's not a power of two.
-      if (Alignment & (Alignment - 1))
-        continue;
-
-      auto CandidateMangledName =
-        readTypeRef(BuiltinTypeDescriptor, BuiltinTypeDescriptor->TypeName);
-      if (!reflectionNameMatches(CandidateMangledName, MangledName))
-        continue;
-      return BuiltinTypeDescriptor;
-    }
+  if (const auto found = BuiltInTypeDescriptorCache.find(MangledName);
+      found != BuiltInTypeDescriptorCache.end()) {
+    return found->second;
   }
 
   return nullptr;