Task Executors: Prepare for new TaskExecutor protocol & builtins

Author: ktoso

include/swift/ABI/Executor.h

@@ -28,8 +28,9 @@ class AsyncTask;
 class DefaultActor;
 class Job;
 class SerialExecutorWitnessTable;
+class TaskExecutorWitnessTable;
 
-/// An unmanaged reference to an executor.
+/// An unmanaged reference to an serial (!) executor.
 ///
 /// This type corresponds to the type Optional<Builtin.Executor> in
 /// Swift.  The representation of nil in Optional<Builtin.Executor>
@@ -182,6 +183,94 @@ class ExecutorRef {
   }
 };
 
+class TaskExecutorRef {
+  HeapObject *Identity; // Not necessarily Swift reference-countable
+  uintptr_t Implementation;
+
+  // We future-proof the ABI here by masking the low bits off the
+  // implementation pointer before using it as a witness table.
+  //
+  // We have 3 bits for future use remaining here.
+  enum: uintptr_t {
+    WitnessTableMask = ~uintptr_t(alignof(void*) - 1)
+  };
+
+  /// The kind is stored in the free bits in the `Implementation` witness table reference.
+  enum class TaskExecutorKind : uintptr_t {
+    /// Ordinary executor.
+    Ordinary = 0b00,
+  };
+
+  static_assert(static_cast<uintptr_t>(TaskExecutorKind::Ordinary) == 0);
+
+  constexpr TaskExecutorRef(HeapObject *identity, uintptr_t implementation)
+    : Identity(identity), Implementation(implementation) {}
+
+public:
+
+  constexpr static TaskExecutorRef undefined() {
+    return TaskExecutorRef(nullptr, 0);
+  }
+
+  /// Given a pointer to a serial executor and its TaskExecutor
+  /// conformance, return an executor reference for it.
+  static TaskExecutorRef forOrdinary(HeapObject *identity,
+                           const SerialExecutorWitnessTable *witnessTable) {
+    assert(identity);
+    assert(witnessTable);
+    auto wtable = reinterpret_cast<uintptr_t>(witnessTable) |
+        static_cast<uintptr_t>(TaskExecutorKind::Ordinary);
+    return TaskExecutorRef(identity, wtable);
+  }
+
+  HeapObject *getIdentity() const {
+    return Identity;
+  }
+
+  /// Is this the generic executor reference?
+  bool isUndefined() const {
+    return Identity == 0;
+  }
+
+  TaskExecutorKind getExecutorKind() const {
+    return static_cast<TaskExecutorKind>(Implementation & ~WitnessTableMask);
+  }
+
+  /// Is this an ordinary executor reference?
+  /// These executor references are the default kind, and have no special treatment elsewhere in the system.
+  bool isOrdinary() const {
+    return getExecutorKind() == TaskExecutorKind::Ordinary;
+  }
+
+  const SerialExecutorWitnessTable *getTaskExecutorWitnessTable() const {
+    assert(!isUndefined());
+    auto table = Implementation & WitnessTableMask;
+    return reinterpret_cast<const SerialExecutorWitnessTable*>(table);
+  }
+
+//  /// Do we have to do any work to start running as the requested
+//  /// executor?
+//  bool mustSwitchToRun(ExecutorRef newExecutor) const {
+//    return Identity != newExecutor.Identity;
+//  }
+
+  /// Get the raw value of the Implementation field, for tracing.
+  uintptr_t getRawImplementation() const {
+    return Implementation & WitnessTableMask;
+  }
+
+  bool operator==(TaskExecutorRef other) const {
+    return Identity == other.Identity;
+  }
+  bool operator!=(TaskExecutorRef other) const {
+    return !(*this == other);
+  }
+};
+
+// Historically the 'ExecutorRef' was introduced initially, however it always has meant specifically
+// a SERIAL executor. This typedef fixes up this confusion and especially since now there is also a TaskExecutor.
+typedef ExecutorRef SerialExecutorRef;
+
 using JobInvokeFunction =
   SWIFT_CC(swiftasync)
   void (Job *);

include/swift/AST/ASTSynthesis.h

@@ -50,6 +50,7 @@ enum SingletonTypeSynthesizer {
   _void,
   _word,
   _serialExecutor,
+  _taskExecutor,
 };
 inline Type synthesizeType(SynthesisContext &SC,
                            SingletonTypeSynthesizer kind) {
@@ -69,6 +70,9 @@ inline Type synthesizeType(SynthesisContext &SC,
   case _serialExecutor:
     return SC.Context.getProtocol(KnownProtocolKind::SerialExecutor)
       ->getDeclaredInterfaceType();
+  case _taskExecutor:
+    return SC.Context.getProtocol(KnownProtocolKind::TaskExecutor)
+      ->getDeclaredInterfaceType();
   }
 }
 

include/swift/AST/Builtins.def

@@ -1004,6 +1004,11 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(AutoDiffAllocateSubcontextWithType, "autoDiff
 BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildOrdinarySerialExecutorRef,
                                    "buildOrdinarySerialExecutorRef", "n", Special)
 
+/// Build a Builtin.Executor value from an "ordinary" task executor
+/// reference.
+BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildOrdinaryTaskExecutorRef,
+                                   "buildOrdinaryTaskExecutorRef", "n", Special)
+
 /// Build a Builtin.Executor value from an "complex equality" serial executor
 /// reference.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(BuildComplexEqualitySerialExecutorRef,

include/swift/AST/KnownProtocols.def

@@ -86,6 +86,7 @@ PROTOCOL(FixedWidthInteger)
 PROTOCOL(RangeReplaceableCollection)
 PROTOCOL(Executor)
 PROTOCOL(SerialExecutor)
+PROTOCOL(TaskExecutor)
 PROTOCOL(GlobalActor)
 
 PROTOCOL_(BridgedNSError)

include/swift/AST/KnownSDKTypes.def

@@ -44,6 +44,7 @@ KNOWN_SDK_TYPE_DECL(Concurrency, Job, StructDecl, 0) // TODO: remove in favor of
 KNOWN_SDK_TYPE_DECL(Concurrency, ExecutorJob, StructDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, UnownedJob, StructDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, Executor, NominalTypeDecl, 0)
+KNOWN_SDK_TYPE_DECL(Concurrency, TaskExecutor, NominalTypeDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, SerialExecutor, NominalTypeDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, UnownedSerialExecutor, NominalTypeDecl, 0)
 

include/swift/Basic/Features.def

@@ -83,6 +83,7 @@ LANGUAGE_FEATURE(BuiltinTaskGroupWithArgument, 0, "TaskGroup builtins", true)
 LANGUAGE_FEATURE(InheritActorContext, 0, "@_inheritActorContext attribute", true)
 LANGUAGE_FEATURE(ImplicitSelfCapture, 0, "@_implicitSelfCapture attribute", true)
 LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins", true)
+LANGUAGE_FEATURE(BuiltinBuildTaskExecutor, 0, "TaskExecutor-building builtins", true)
 LANGUAGE_FEATURE(BuiltinBuildComplexEqualityExecutor, 0, "Executor-building for 'complexEquality executor' builtins", true)
 LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building builtin", true)
 LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "MainActor executor building builtin", true)

include/swift/Demangling/StandardTypesMangling.def

@@ -88,6 +88,7 @@ STANDARD_TYPE_CONCURRENCY(Protocol, F, Executor)
 STANDARD_TYPE_CONCURRENCY(Protocol, f, SerialExecutor)
 STANDARD_TYPE_CONCURRENCY(Structure, G, TaskGroup)
 STANDARD_TYPE_CONCURRENCY(Structure, g, ThrowingTaskGroup)
+STANDARD_TYPE_CONCURRENCY(Protocol, h, TaskExecutor)
 STANDARD_TYPE_CONCURRENCY(Protocol, I, AsyncIteratorProtocol)
 STANDARD_TYPE_CONCURRENCY(Protocol, i, AsyncSequence)
 STANDARD_TYPE_CONCURRENCY(Structure, J, UnownedJob)

lib/AST/ASTContext.cpp

@@ -1140,6 +1140,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::AsyncSequence:
   case KnownProtocolKind::AsyncIteratorProtocol:
   case KnownProtocolKind::Executor:
+  case KnownProtocolKind::TaskExecutor:
   case KnownProtocolKind::SerialExecutor:
     M = getLoadedModule(Id_Concurrency);
     break;

lib/AST/ASTPrinter.cpp

@@ -3086,6 +3086,10 @@ static bool usesFeatureBuiltinExecutor(Decl *decl) {
   return usesBuiltinType(decl, BuiltinTypeKind::BuiltinExecutor);
 }
 
+static bool usesFeatureBuiltinBuildTaskExecutor(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureBuiltinBuildExecutor(Decl *decl) {
   return false;
 }

lib/AST/Builtins.cpp

@@ -1610,6 +1610,16 @@ static ValueDecl *getTargetOSVersionAtLeast(ASTContext &Context,
   return getBuiltinFunction(Id, {int32Type, int32Type, int32Type}, int32Type);
 }
 
+static ValueDecl *getBuildOrdinaryTaskExecutorRef(ASTContext &ctx,
+                                                  Identifier id) {
+  return getBuiltinFunction(ctx, id, _thin,
+                            _generics(_unrestricted,
+                                      _conformsTo(_typeparam(0), _taskExecutor)),
+                            _parameters(_typeparam(0)),
+                            _executor);
+}
+
+
 static ValueDecl *getBuildOrdinarySerialExecutorRef(ASTContext &ctx,
                                                     Identifier id) {
   return getBuiltinFunction(ctx, id, _thin,
@@ -2919,6 +2929,9 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::BuildComplexEqualitySerialExecutorRef:
     return getBuildComplexEqualitySerialExecutorRef(Context, Id);
 
+  case BuiltinValueKind::BuildOrdinaryTaskExecutorRef:
+    return getBuildOrdinaryTaskExecutorRef(Context, Id);
+
   case BuiltinValueKind::PoundAssert:
     return getPoundAssert(Context, Id);
 

lib/IRGen/GenBuiltin.cpp

@@ -426,6 +426,13 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     emitBuildOrdinarySerialExecutorRef(IGF, actor, type, conf, out);
     return;
   }
+  if (Builtin.ID == BuiltinValueKind::BuildOrdinaryTaskExecutorRef) {
+    auto actor = args.claimNext();
+    auto type = substitutions.getReplacementTypes()[0]->getCanonicalType();
+    auto conf = substitutions.getConformances()[0];
+    emitBuildOrdinaryTaskExecutorRef(IGF, actor, type, conf, out);
+    return;
+  }
   if (Builtin.ID == BuiltinValueKind::BuildComplexEqualitySerialExecutorRef) {
     auto actor = args.claimNext();
     auto type = substitutions.getReplacementTypes()[0]->getCanonicalType();

lib/IRGen/GenConcurrency.cpp

@@ -174,6 +174,23 @@ void irgen::emitBuildOrdinarySerialExecutorRef(IRGenFunction &IGF,
   out.add(impl);
 }
 
+void irgen::emitBuildOrdinaryTaskExecutorRef(IRGenFunction &IGF,
+                                             llvm::Value *executor,
+                                             CanType executorType,
+                                             ProtocolConformanceRef executorConf,
+                                             Explosion &out) {
+  // The implementation word of an "ordinary" task executor is
+  // just the witness table pointer with no flags set.
+  llvm::Value *identity =
+    IGF.Builder.CreatePtrToInt(executor, IGF.IGM.ExecutorFirstTy);
+  llvm::Value *impl =
+    emitWitnessTableRef(IGF, executorType, executorConf);
+  impl = IGF.Builder.CreatePtrToInt(impl, IGF.IGM.ExecutorSecondTy);
+
+  out.add(identity);
+  out.add(impl);
+}
+
 void irgen::emitBuildComplexEqualitySerialExecutorRef(IRGenFunction &IGF,
                                                llvm::Value *executor,
                                                CanType executorType,

lib/IRGen/GenConcurrency.h

@@ -54,6 +54,13 @@ void emitBuildOrdinarySerialExecutorRef(IRGenFunction &IGF,
                                         ProtocolConformanceRef executorConformance,
                                         Explosion &out);
 
+/// Emit the buildOrdinaryTaskExecutorRef builtin.
+void emitBuildOrdinaryTaskExecutorRef(IRGenFunction &IGF,
+                                      llvm::Value *executor,
+                                      CanType executorType,
+                                      ProtocolConformanceRef executorConformance,
+                                      Explosion &out);
+
 /// Emit the buildComplexEqualitySerialExecutorRef builtin.
 void emitBuildComplexEqualitySerialExecutorRef(IRGenFunction &IGF,
                                         llvm::Value *executor,

lib/IRGen/GenMeta.cpp

@@ -6561,6 +6561,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::UnsafeCxxMutableRandomAccessIterator:
   case KnownProtocolKind::Executor:
   case KnownProtocolKind::SerialExecutor:
+  case KnownProtocolKind::TaskExecutor:
   case KnownProtocolKind::Sendable:
   case KnownProtocolKind::UnsafeSendable:
   case KnownProtocolKind::RangeReplaceableCollection:

lib/SIL/IR/OperandOwnership.cpp

@@ -959,6 +959,7 @@ BUILTIN_OPERAND_OWNERSHIP(PointerEscape, AutoDiffProjectTopLevelSubcontext)
 // ownership should be 'TrivialUse'.
 BUILTIN_OPERAND_OWNERSHIP(ForwardingConsume, ConvertTaskToJob)
 
+BUILTIN_OPERAND_OWNERSHIP(BitwiseEscape, BuildOrdinaryTaskExecutorRef)
 BUILTIN_OPERAND_OWNERSHIP(BitwiseEscape, BuildOrdinarySerialExecutorRef)
 BUILTIN_OPERAND_OWNERSHIP(BitwiseEscape, BuildComplexEqualitySerialExecutorRef)
 BUILTIN_OPERAND_OWNERSHIP(BitwiseEscape, BuildDefaultActorExecutorRef)

lib/SIL/IR/ValueOwnership.cpp

@@ -581,6 +581,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, GetCurrentExecutor)
 CONSTANT_OWNERSHIP_BUILTIN(None, ResumeNonThrowingContinuationReturning)
 CONSTANT_OWNERSHIP_BUILTIN(None, ResumeThrowingContinuationReturning)
 CONSTANT_OWNERSHIP_BUILTIN(None, ResumeThrowingContinuationThrowing)
+CONSTANT_OWNERSHIP_BUILTIN(None, BuildOrdinaryTaskExecutorRef)
 CONSTANT_OWNERSHIP_BUILTIN(None, BuildOrdinarySerialExecutorRef)
 CONSTANT_OWNERSHIP_BUILTIN(None, BuildComplexEqualitySerialExecutorRef)
 CONSTANT_OWNERSHIP_BUILTIN(None, BuildDefaultActorExecutorRef)

lib/SIL/Utils/InstructionUtils.cpp

@@ -988,6 +988,7 @@ RuntimeEffect swift::getRuntimeEffect(SILInstruction *inst, SILType &impactType)
       return RuntimeEffect::RefCounting | RuntimeEffect::Deallocating;
     case BuiltinValueKind::Swift3ImplicitObjCEntrypoint:
       return RuntimeEffect::ObjectiveC | RuntimeEffect::Allocating;
+    case BuiltinValueKind::BuildOrdinaryTaskExecutorRef:
     case BuiltinValueKind::BuildOrdinarySerialExecutorRef:
     case BuiltinValueKind::BuildComplexEqualitySerialExecutorRef:
     case BuiltinValueKind::BuildDefaultActorExecutorRef:

lib/SIL/Verifier/SILVerifier.cpp

@@ -2112,6 +2112,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
 
     if (builtinKind == BuiltinValueKind::BuildOrdinarySerialExecutorRef ||
+        builtinKind == BuiltinValueKind::BuildOrdinaryTaskExecutorRef ||
         builtinKind == BuiltinValueKind::BuildComplexEqualitySerialExecutorRef ||
         builtinKind == BuiltinValueKind::BuildDefaultActorExecutorRef) {
       require(arguments.size() == 1,

lib/SILGen/SILGenBuiltin.cpp

@@ -1780,6 +1780,12 @@ static ManagedValue emitBuildExecutorRef(SILGenFunction &SGF, SILLocation loc,
       subs, argValues);
   return ManagedValue::forObjectRValueWithoutOwnership(builtinApply);
 }
+static ManagedValue emitBuiltinBuildOrdinaryTaskExecutorRef(
+    SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
+    ArrayRef<ManagedValue> args, SGFContext C) {
+  return emitBuildExecutorRef(SGF, loc, subs, args,
+                            BuiltinValueKind::BuildOrdinaryTaskExecutorRef);
+}
 static ManagedValue emitBuiltinBuildOrdinarySerialExecutorRef(
     SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
     ArrayRef<ManagedValue> args, SGFContext C) {

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -191,6 +191,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::DestroyDefaultActor:
     case BuiltinValueKind::InitializeDistributedRemoteActor:
     case BuiltinValueKind::InitializeNonDefaultDistributedActor:
+    case BuiltinValueKind::BuildOrdinaryTaskExecutorRef:
     case BuiltinValueKind::BuildOrdinarySerialExecutorRef:
     case BuiltinValueKind::BuildComplexEqualitySerialExecutorRef:
     case BuiltinValueKind::BuildDefaultActorExecutorRef:

lib/Sema/TypeCheckConcurrency.cpp

@@ -1338,7 +1338,8 @@ void swift::tryDiagnoseExecutorConformance(ASTContext &C,
                                            const NominalTypeDecl *nominal,
                                            ProtocolDecl *proto) {
   assert(proto->isSpecificProtocol(KnownProtocolKind::Executor) ||
-         proto->isSpecificProtocol(KnownProtocolKind::SerialExecutor));
+         proto->isSpecificProtocol(KnownProtocolKind::SerialExecutor) ||
+         proto->isSpecificProtocol(KnownProtocolKind::TaskExecutor));
 
   auto &diags = C.Diags;
   auto module = nominal->getParentModule();