[Isolated conformances] Cache resolved global actor for conformances

In the prior implementation of runtime resolution of isolated conformances,
the runtime had to look in both the protocol conformance descriptor and
in all conditional conformance requirements (recursively) to find any
isolated conformances. If it found one, it had to demangle the global
actor type to metadata. Since swift_conformsToProtocol is a hot path through
the runtime, we can't afford this non-constant-time work in the common
case.

Instead, cache the resolved global actor and witness table as part of the
conformance cache, so that we have access to this information every time
we look up a witness table for a conformance. Propagate this up through
various callers (e.g., generic requirement checking) to the point where
we either stash it in the cache or check it at runtime. This gets us down
to a very quick check (basically, NULL-or-not) for nonisolated conformances,
and just one check for isolated conformances.

Author: DougGregor

include/swift/ABI/Metadata.h

@@ -2884,8 +2884,16 @@ struct TargetProtocolConformanceDescriptor final
   /// Get the witness table for the specified type, realizing it if
   /// necessary, or return null if the conformance does not apply to the
   /// type.
+  ///
+  /// The globalActorIsolationType will be populated with the type of the global
+  /// actor to which this conformance is isolated, or NULL if this is a
+  /// nonisolated conformances. When it is isolated,
+  /// globalActorIsolationConformance is the conformance of
+  /// globalActorIsolationType to the GlobalActor protocol.
   const swift::TargetWitnessTable<Runtime> *
-  getWitnessTable(const TargetMetadata<Runtime> *type) const;
+  getWitnessTable(const TargetMetadata<Runtime> *type,
+                  const Metadata *&globalActorIsolationType,
+                  const WitnessTable *&globalActorIsolationConformance) const;
 
   /// Retrieve the resilient witnesses.
   llvm::ArrayRef<ResilientWitness> getResilientWitnesses() const {

include/swift/Runtime/Casting.h

@@ -260,6 +260,18 @@ const WitnessTable *
 swift_conformsToProtocolCommon(const Metadata *type,
                                const ProtocolDescriptor *protocol);
 
+/// Check whether a type conforms to a given native Swift protocol. This
+/// is similar to swift_conformsToProtocolCommon, but allows the caller to
+/// capture the global actor isolation of the conformance rather than
+/// checking that the code is currently executing on that global actor.
+SWIFT_RUNTIME_EXPORT
+const WitnessTable *
+swift_conformsToProtocolCommonIsolated(
+    const Metadata *type,
+    const ProtocolDescriptor *protocol,
+    const Metadata **globalActorIsolationType,
+    const WitnessTable **globalActorIsolationWitnessTable);
+
 } // end namespace swift
 
 #endif // SWIFT_RUNTIME_CASTING_H

stdlib/public/CompatibilityOverride/CompatibilityOverrideRuntime.def

@@ -193,6 +193,16 @@ OVERRIDE_PROTOCOLCONFORMANCE(conformsToProtocolCommon, const WitnessTable *, , ,
                               const ProtocolDescriptor *protocol),
                              (type, protocol))
 
+OVERRIDE_PROTOCOLCONFORMANCE(conformsToProtocolCommonIsolated,
+                             const WitnessTable *, , , swift::,
+                             (const Metadata * const type,
+                              const ProtocolDescriptor *protocol,
+                              const Metadata **globalActorIsolationType,
+                              const WitnessTable **
+                                  globalActorIsolationWitnessTable),
+                             (type, protocol, globalActorIsolationType,
+                              globalActorIsolationWitnessTable))
+
 OVERRIDE_KEYPATH(getKeyPath, const HeapObject *, , , swift::,
                  (const void *pattern, const void *arguments),
                  (pattern, arguments))

stdlib/public/runtime/Casting.cpp

@@ -529,13 +529,18 @@ static bool _unknownClassConformsToObjCProtocol(const OpaqueValue *value,
 }
 #endif
 
-bool swift::_conformsToProtocol(const OpaqueValue *value,
-                                const Metadata *type,
-                                ProtocolDescriptorRef protocol,
-                                const WitnessTable **conformance) {
+bool swift::_conformsToProtocol(
+    const OpaqueValue *value,
+    const Metadata *type,
+    ProtocolDescriptorRef protocol,
+    const WitnessTable **conformance,
+    const Metadata **globalActorIsolationType,
+    const WitnessTable **globalActorIsolationWitnessTable) {
   // Look up the witness table for protocols that need them.
   if (protocol.needsWitnessTable()) {
-    auto witness = swift_conformsToProtocolCommon(type, protocol.getSwiftProtocol());
+    auto witness = swift_conformsToProtocolCommonIsolated(
+        type, protocol.getSwiftProtocol(), globalActorIsolationType,
+        globalActorIsolationWitnessTable);
     if (!witness)
       return false;
     if (conformance)
@@ -624,7 +629,8 @@ static bool _conformsToProtocols(const OpaqueValue *value,
   }
 
   for (auto protocol : existentialType->getProtocols()) {
-    if (!_conformsToProtocol(value, type, protocol, conformances))
+    if (!_conformsToProtocol(
+            value, type, protocol, conformances, nullptr, nullptr))
       return false;
     if (conformances != nullptr && protocol.needsWitnessTable()) {
       assert(*conformances != nullptr);

stdlib/public/runtime/DynamicCast.cpp

@@ -1384,7 +1384,8 @@ static bool _conformsToProtocols(const OpaqueValue *value,
   }
 
   for (auto protocol : existentialType->getProtocols()) {
-    if (!swift::_conformsToProtocol(value, type, protocol, conformances))
+    if (!swift::_conformsToProtocol(value, type, protocol, conformances,
+                                    nullptr, nullptr))
       return false;
     if (conformances != nullptr && protocol.needsWitnessTable()) {
       assert(*conformances != nullptr);
@@ -1879,7 +1880,8 @@ static DynamicCastResult tryCastToExtendedExistential(
         },
         [](const Metadata *type, unsigned index) -> const WitnessTable * {
           swift_unreachable("Resolution of witness tables is not supported");
-        });
+        },
+        nullptr, nullptr);
     if (error)
       return DynamicCastResult::Failure;
   }

stdlib/public/runtime/MetadataLookup.cpp

@@ -1602,7 +1602,8 @@ _gatherGenericParameters(const ContextDescriptor *context,
         },
         [&substitutions](const Metadata *type, unsigned index) {
           return substitutions.getWitnessTable(type, index);
-        });
+        },
+        nullptr, nullptr);
     if (error)
       return *error;
 
@@ -2043,7 +2044,8 @@ class DecodedMetadataBuilder {
         },
         [](const Metadata *type, unsigned index) -> const WitnessTable * {
           swift_unreachable("never called");
-        });
+        },
+        nullptr, nullptr);
     if (error)
       return *error;
 
@@ -3056,7 +3058,8 @@ swift_distributed_getWitnessTables(GenericEnvironmentDescriptor *genericEnv,
       },
       [&substFn](const Metadata *type, unsigned index) {
         return substFn.getWitnessTable(type, index);
-      });
+      },
+      nullptr, nullptr);
 
   if (error) {
     return {/*ptr=*/nullptr, -1};

stdlib/public/runtime/Private.h

@@ -567,14 +567,20 @@ class TypeInfo {
   /// generic requirements (e.g., those that need to be
   /// passed to an instantiation function) will be added to this vector.
   ///
+  /// \param globalActorIsolationType When non-NULL, the global actor isolation
+  /// of these requirements will be reported through this OUT parameter.
+  /// When NULL, any global actor isolation will be checked dynamically.
+  /// 
   /// \returns the error if an error occurred, None otherwise.
   std::optional<TypeLookupError> _checkGenericRequirements(
       llvm::ArrayRef<GenericParamDescriptor> genericParams,
       llvm::ArrayRef<GenericRequirementDescriptor> requirements,
       llvm::SmallVectorImpl<const void *> &extraArguments,
       SubstGenericParameterFn substGenericParam,
       SubstGenericParameterOrdinalFn substGenericParamOrdinal,
-      SubstDependentWitnessTableFn substWitnessTable);
+      SubstDependentWitnessTableFn substWitnessTable,
+      const Metadata **globalActorIsolationType,
+      const WitnessTable **globalActorIsolationWitnessTable);
 
   /// A helper function which avoids performing a store if the destination
   /// address already contains the source value.  This is useful when
@@ -686,10 +692,19 @@ class TypeInfo {
   /// \param conformance - if non-null, and the protocol requires a
   ///   witness table, and the type implements the protocol, the witness
   ///   table will be placed here
-  bool _conformsToProtocol(const OpaqueValue *value,
-                           const Metadata *type,
-                           ProtocolDescriptorRef protocol,
-                           const WitnessTable **conformance);
+  /// \param globalActorIsolationType - when non-NULL and the conformance is
+  /// global-actor-isolated, capture the global actor isolation type in this
+  /// out variable rather than checking when we are executing on that global
+  /// actor.
+  /// \param globalActorIsolationWitnessTable - receives the witness table for
+  /// *globalActorIsolationType's conformance to GlobalActor.
+  bool _conformsToProtocol(
+      const OpaqueValue *value,
+      const Metadata *type,
+      ProtocolDescriptorRef protocol,
+      const WitnessTable **conformance,
+      const Metadata **globalActorIsolationType,
+      const WitnessTable **globalActorIsolationWitnessTable);
 
   /// Construct type metadata for the given protocol.
   const Metadata *