Merge pull request #3776 from apple/stdlib-AnyHashable-caching

Author: swift-ci

benchmark/CMakeLists.txt

@@ -21,6 +21,7 @@ set(SWIFT_BENCH_MODULES
     single-source/unit-tests/StackPromo
     single-source/Ackermann
     single-source/AngryPhonebook
+    single-source/AnyHashableWithAClass
     single-source/Array2D
     single-source/ArrayAppend
     single-source/ArrayInClass

benchmark/single-source/AnyHashableWithAClass.swift

@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// This benchmark tests AnyHashable's initializer that needs to dynamically
+// upcast the instance to the type that introduces the Hashable
+// conformance.
+
+class TestHashableBase : Hashable {
+  var value: Int
+  init(_ value: Int) {
+    self.value = value
+  }
+  var hashValue: Int {
+    return value
+  }
+  static func == (
+    lhs: TestHashableBase,
+    rhs: TestHashableBase
+  ) -> Bool {
+    return lhs.value == rhs.value
+  }
+}
+
+class TestHashableDerived1 : TestHashableBase {}
+class TestHashableDerived2 : TestHashableDerived1 {}
+class TestHashableDerived3 : TestHashableDerived2 {}
+class TestHashableDerived4 : TestHashableDerived3 {}
+class TestHashableDerived5 : TestHashableDerived4 {}
+
+@inline(never)
+public func run_AnyHashableWithAClass(_ N: Int) {
+  let c = TestHashableDerived5(10)
+  for _ in 0...(N*500000) {
+    _ = AnyHashable(c)
+  }
+}
+

benchmark/utils/main.swift

@@ -22,6 +22,7 @@ import TestsUtils
 import DriverUtils
 import Ackermann
 import AngryPhonebook
+import AnyHashableWithAClass
 import Array2D
 import ArrayAppend
 import ArrayInClass
@@ -100,6 +101,7 @@ import XorLoop
 
 precommitTests = [
   "AngryPhonebook": run_AngryPhonebook,
+  "AnyHashableWithAClass": run_AnyHashableWithAClass,
   "Array2D": run_Array2D,
   "ArrayAppend": run_ArrayAppend,
   "ArrayAppendReserved": run_ArrayAppendReserved,

stdlib/public/stubs/AnyHashableSupport.cpp

@@ -11,14 +11,79 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Runtime/Config.h"
+#include "swift/Basic/Lazy.h"
+#include "swift/Runtime/Concurrent.h"
 #include "swift/Runtime/Debug.h"
 #include "swift/Runtime/Metadata.h"
 #include "../runtime/Private.h"
 
 using namespace swift;
 
+/// The name demangles to "protocol descriptor for Swift.Hashable".
 extern "C" const ProtocolDescriptor _TMps8Hashable;
 
+namespace {
+struct HashableConformanceKey {
+  /// The lookup key, the metadata of a type that is possibly derived
+  /// from a type that conforms to `Hashable`.
+  const Metadata *derivedType;
+};
+
+struct HashableConformanceEntry {
+  /// The lookup key, the metadata of a type that is possibly derived
+  /// from a type that conforms to `Hashable`.
+  const Metadata *derivedType;
+
+  /// The highest (closest to the root) type in the superclass chain
+  /// that conforms to `Hashable`.
+  const Metadata *baseTypeThatConformsToHashable;
+
+  HashableConformanceEntry(HashableConformanceKey key,
+                           const Metadata *baseTypeThatConformsToHashable)
+      : 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;
+    }
+  }
+
+  static size_t
+  getExtraAllocationSize(HashableConformanceKey key,
+                         const Metadata *baseTypeThatConformsToHashable) {
+    return 0;
+  }
+};
+} // end unnamed namesapce
+
+static Lazy<ConcurrentMap<HashableConformanceEntry>> HashableConformances;
+
+/// Find the base type that introduces the `Hashable` conformance.
+///
+/// - Precondition: `type` conforms to `Hashable` (not checked).
+static const Metadata *findHashableBaseType(const Metadata *type) {
+  if (HashableConformanceEntry *entry =
+          HashableConformances->find(HashableConformanceKey{type})) {
+    return entry->baseTypeThatConformsToHashable;
+  }
+  const Metadata *baseTypeThatConformsToHashable = type;
+  while (true) {
+    const Metadata *superclass =
+        _swift_class_getSuperclass(baseTypeThatConformsToHashable);
+    if (!superclass)
+      break;
+    if (!swift_conformsToProtocol(superclass, &_TMps8Hashable))
+      break;
+    baseTypeThatConformsToHashable = superclass;
+  }
+  HashableConformances->getOrInsert(HashableConformanceKey{type},
+                                    baseTypeThatConformsToHashable);
+  return baseTypeThatConformsToHashable;
+}
+
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERFACE
 extern "C" void _swift_stdlib_makeAnyHashableUsingDefaultRepresentation(
   const OpaqueValue *value,
@@ -34,22 +99,14 @@ extern "C" void _swift_stdlib_makeAnyHashableUpcastingToHashableBaseType(
   const Metadata *type,
   const WitnessTable *hashableWT
 ) {
-  // FIXME(id-as-any)(performance): cache the result of the lookup.
   switch (type->getKind()) {
   case MetadataKind::Class:
   case MetadataKind::ObjCClassWrapper:
   case MetadataKind::ForeignClass: {
     // FIXME(id-as-any): handle ForeignClass.
-    while (true) {
-      const Metadata *superclass = _swift_class_getSuperclass(type);
-      if (!superclass)
-        break;
-      if (!swift_conformsToProtocol(superclass, &_TMps8Hashable))
-        break;
-      type = superclass;
-    }
     _swift_stdlib_makeAnyHashableUsingDefaultRepresentation(
-        value, anyHashableResultPointer, type, hashableWT);
+        value, anyHashableResultPointer, findHashableBaseType(type),
+        hashableWT);
     return;
   }