Runtime: Remove linear order on metadata cache keys

Author: slavapestov

include/swift/Runtime/Concurrent.h

@@ -33,20 +33,6 @@
 
 namespace swift {
 
-/// A utility function for ordering two integers, which is useful
-/// for implementing compareWithKey.
-template <class T>
-static inline int compareIntegers(T left, T right) {
-  return (left == right ? 0 : left < right ? -1 : 1);
-}
-
-/// A utility function for ordering two pointers, which is useful
-/// for implementing compareWithKey.
-template <class T>
-static inline int comparePointers(const T *left, const T *right) {
-  return (left == right ? 0 : std::less<const T *>()(left, right) ? -1 : 1);
-}
-
 /// A simple linked list representing pointers that need to be freed. This is
 /// not a concurrent data structure, just a bit of support used in the types
 /// below.

stdlib/public/runtime/Metadata.cpp

@@ -6372,7 +6372,7 @@ bool swift::swift_compareProtocolConformanceDescriptors(
   rhs = swift_auth_data_non_address(
       rhs, SpecialPointerAuthDiscriminators::ProtocolConformanceDescriptor);
 
-  return MetadataCacheKey::compareProtocolConformanceDescriptors(lhs, rhs) == 0;
+  return MetadataCacheKey::areConformanceDescriptorsEqual(lhs, rhs);
 }
 
 /***************************************************************************/

stdlib/public/runtime/MetadataCache.h

@@ -492,36 +492,6 @@ struct GenericSignatureLayout {
                          const GenericSignatureLayout<Runtime> &rhs) {
     return !(lhs == rhs);
   }
-
-  int compare(const GenericSignatureLayout<Runtime> &rhs) const {
-    if (auto result = compareIntegers(NumKeyParameters, rhs.NumKeyParameters))
-      return result;
-
-    if (auto result = compareIntegers(NumWitnessTables, rhs.NumWitnessTables))
-      return result;
-
-    if (auto result = compareIntegers(NumShapeClasses, rhs.NumShapeClasses))
-      return result;
-
-    if (auto result = compareIntegers(NumPacks, rhs.NumPacks))
-      return result;
-
-    for (unsigned i = 0; i < NumPacks; ++i) {
-      const auto &lhsElt = PackShapeDescriptors[i];
-      const auto &rhsElt = rhs.PackShapeDescriptors[i];
-
-      if (auto result = compareIntegers(lhsElt.Kind, rhsElt.Kind))
-        return result;
-
-      if (auto result = compareIntegers(lhsElt.Index, rhsElt.Index))
-        return result;
-
-      if (auto result = compareIntegers(lhsElt.ShapeClass, rhsElt.ShapeClass))
-        return result;
-    }
-
-    return 0;
-  }
 };
 
 /// A key value as provided to the concurrent map.
@@ -532,10 +502,10 @@ class MetadataCacheKey {
 
   /// Compare two witness tables, which may involving checking the
   /// contents of their conformance descriptors.
-  static int compareWitnessTables(const WitnessTable *awt,
-                                  const WitnessTable *bwt) {
+  static bool areWitnessTablesEqual(const WitnessTable *awt,
+                                    const WitnessTable *bwt) {
     if (awt == bwt)
-      return 0;
+      return true;
 #if SWIFT_STDLIB_USE_RELATIVE_PROTOCOL_WITNESS_TABLES
     auto *aDescription = lookThroughOptionalConditionalWitnessTable(
       reinterpret_cast<const RelativeWitnessTable*>(awt))->getDescription();
@@ -545,37 +515,34 @@ class MetadataCacheKey {
     auto *aDescription = awt->getDescription();
     auto *bDescription = bwt->getDescription();
 #endif
-    return compareProtocolConformanceDescriptors(aDescription, bDescription);
+    return areConformanceDescriptorsEqual(aDescription, bDescription);
   }
 
 public:
   /// Compare two conformance descriptors, checking their contents if necessary.
-  static int compareProtocolConformanceDescriptors(
+  static bool areConformanceDescriptorsEqual(
       const ProtocolConformanceDescriptor *aDescription,
       const ProtocolConformanceDescriptor *bDescription) {
     if (aDescription == bDescription)
-      return 0;
+      return true;
 
     if (!aDescription->isSynthesizedNonUnique() ||
         !bDescription->isSynthesizedNonUnique())
-      return comparePointers(aDescription, bDescription);
+      return aDescription == bDescription;
 
     auto aType = aDescription->getCanonicalTypeMetadata();
     auto bType = bDescription->getCanonicalTypeMetadata();
     if (!aType || !bType)
-      return comparePointers(aDescription, bDescription);
+      return aDescription == bDescription;
 
-    if (int result = comparePointers(aType, bType))
-      return result;
-
-    return comparePointers(aDescription->getProtocol(),
-                           bDescription->getProtocol());
+    return (aType == bType &&
+            aDescription->getProtocol() == bDescription->getProtocol());
   }
 
 private:
-  static int compareMetadataPacks(const void *lhsPtr,
-                                  const void *rhsPtr,
-                                  uintptr_t count) {
+  static bool areMetadataPacksEqual(const void *lhsPtr,
+                                    const void *rhsPtr,
+                                    uintptr_t count) {
     MetadataPackPointer lhs(lhsPtr);
     MetadataPackPointer rhs(rhsPtr);
 
@@ -586,16 +553,16 @@ class MetadataCacheKey {
     auto *rhsElt = rhs.getElements();
 
     for (uintptr_t i = 0; i < count; ++i) {
-      if (auto result = comparePointers(lhsElt[i], rhsElt[i]))
-        return result;
+      if (lhsElt[i] != rhsElt[i])
+        return false;
     }
 
-    return 0;
+    return true;
   }
 
-  static int compareWitnessTablePacks(const void *lhsPtr,
-                                      const void *rhsPtr,
-                                      uintptr_t count) {
+  static bool areWitnessTablePacksEqual(const void *lhsPtr,
+                                        const void *rhsPtr,
+                                        uintptr_t count) {
     WitnessTablePackPointer lhs(lhsPtr);
     WitnessTablePackPointer rhs(rhsPtr);
 
@@ -606,107 +573,88 @@ class MetadataCacheKey {
     auto *rhsElt = rhs.getElements();
 
     for (uintptr_t i = 0; i < count; ++i) {
-      if (auto result = compareWitnessTables(lhsElt[i], rhsElt[i]))
-        return result;
+      if (!areWitnessTablesEqual(lhsElt[i], rhsElt[i]))
+        return false;
     }
 
-    return 0;
+    return true;
   }
 
-  /// Compare the content from two keys.
-  static int compareContent(const void *const *adata, const void *const *bdata,
-                            const GenericSignatureLayout<InProcess> &layout) {
+public:
+  MetadataCacheKey(const GenericSignatureLayout<InProcess> &layout,
+                   const void *const *data)
+      : Data(data), Layout(layout), Hash(computeHash()) {}
+
+  MetadataCacheKey(const GenericSignatureLayout<InProcess> &layout,
+                   const void *const *data, uint32_t hash)
+      : Data(data), Layout(layout), Hash(hash) {}
+
+  bool operator==(MetadataCacheKey rhs) const {
+    // Compare the hashes.
+    if (hash() != rhs.hash()) return false;
+
+    // Compare the layouts.
+    if (Layout != rhs.Layout) return false;
+
+    // Compare the content.
+    auto *adata = begin();
+    auto *bdata = rhs.begin();
     const uintptr_t *packCounts = reinterpret_cast<const uintptr_t *>(adata);
 
     // Compare pack lengths for shape classes.
-    for (unsigned i = 0; i != layout.NumShapeClasses; ++i) {
-      if (auto result = compareIntegers(reinterpret_cast<uintptr_t>(*adata++),
-                                        reinterpret_cast<uintptr_t>(*bdata++)))
-        return result;
+    for (unsigned i = 0; i != Layout.NumShapeClasses; ++i) {
+      if (*adata++ != *bdata++)
+        return false;
     }
 
-    auto *nextPack = layout.PackShapeDescriptors;
+    auto *nextPack = Layout.PackShapeDescriptors;
     unsigned numPacks = 0;
 
     // Compare generic arguments for key parameters.
-    for (unsigned i = 0; i != layout.NumKeyParameters; ++i) {
+    for (unsigned i = 0; i != Layout.NumKeyParameters; ++i) {
       // Is this entry a metadata pack?
-      if (numPacks < layout.NumPacks &&
+      if (numPacks < Layout.NumPacks &&
           nextPack->Kind == GenericPackKind::Metadata &&
           i == nextPack->Index) {
-        assert(nextPack->ShapeClass < layout.NumShapeClasses);
+        assert(nextPack->ShapeClass < Layout.NumShapeClasses);
         uintptr_t count = packCounts[nextPack->ShapeClass];
         ++numPacks;
         ++nextPack;
 
-        if (auto result = compareMetadataPacks(*adata++, *bdata++, count))
-          return result;
+        if (!areMetadataPacksEqual(*adata++, *bdata++, count))
+          return false;
 
         continue;
       }
 
-      if (auto result = comparePointers(*adata++, *bdata++))
-        return result;
+      if (*adata++ != *bdata++)
+        return false;
     }
 
     // Compare witness tables.
-    for (unsigned i = 0; i != layout.NumWitnessTables; ++i) {
+    for (unsigned i = 0; i != Layout.NumWitnessTables; ++i) {
       // Is this entry a witness table pack?
-      if (numPacks < layout.NumPacks &&
+      if (numPacks < Layout.NumPacks &&
           nextPack->Kind == GenericPackKind::WitnessTable &&
           i == nextPack->Index) {
-        assert(nextPack->ShapeClass < layout.NumShapeClasses);
+        assert(nextPack->ShapeClass < Layout.NumShapeClasses);
         uintptr_t count = packCounts[nextPack->ShapeClass];
         ++numPacks;
         ++nextPack;
 
-        if (auto result = compareWitnessTablePacks(*adata++, *bdata++, count))
-          return result;
+        if (!areWitnessTablePacksEqual(*adata++, *bdata++, count))
+          return false;
 
         continue;
       }
 
-      if (auto result =
-              compareWitnessTables((const WitnessTable *)*adata++,
-                                   (const WitnessTable *)*bdata++))
-        return result;
+      if (!areWitnessTablesEqual((const WitnessTable *)*adata++,
+                                 (const WitnessTable *)*bdata++))
+        return false;
     }
 
-    assert(numPacks == layout.NumPacks && "Missed a pack");
-    return 0;
-  }
-
-public:
-  MetadataCacheKey(const GenericSignatureLayout<InProcess> &layout,
-                   const void *const *data)
-      : Data(data), Layout(layout), Hash(computeHash()) {}
-
-  MetadataCacheKey(const GenericSignatureLayout<InProcess> &layout,
-                   const void *const *data, uint32_t hash)
-      : Data(data), Layout(layout), Hash(hash) {}
-
-  bool operator==(MetadataCacheKey rhs) const {
-    // Compare the hashes.
-    if (hash() != rhs.hash()) return false;
-
-    // Compare the layouts.
-    if (Layout != rhs.Layout) return false;
-
-    // Compare the content.
-    return compareContent(begin(), rhs.begin(), Layout) == 0;
-  }
-
-  int compare(const MetadataCacheKey &rhs) const {
-    // Compare the hashes.
-    if (auto result = compareIntegers(Hash, rhs.Hash))
-      return result;
-
-    // Compare the layouts.
-    if (auto result = Layout.compare(rhs.Layout))
-      return result;
-
-    // Compare the content.
-    return compareContent(begin(), rhs.begin(), Layout);
+    assert(numPacks == Layout.NumPacks && "Missed a pack");
+    return true;
   }
 
   uint32_t hash() const {