[Concurrency] More work on the custom executor implementation.

Added an `-executor-factory` argument to the compiler to let you safely
specify the executors you wish to use (by naming a type that returns
them).

Also added some tests of the new functionality.

rdar://141348916

Author: al45tair

include/swift/AST/DiagnosticsSIL.def

@@ -1133,6 +1133,14 @@ NOTE(rbi_add_generic_parameter_sendable_conformance,none,
      "consider making generic parameter %0 conform to the 'Sendable' protocol",
      (Type))
 
+// Concurrency related diagnostics
+ERROR(cannot_find_executor_factory_type, none,
+      "the specified executor factory '%0' could not be found", (StringRef))
+ERROR(executor_factory_must_conform, none,
+      "the executor factory '%0' does not conform to 'ExecutorFactory'", (Type))
+ERROR(executor_factory_not_supported, none,
+      "deployment target too low for executor factory specification", ())
+
 //===----------------------------------------------------------------------===//
 //                           MARK: Misc Diagnostics
 //===----------------------------------------------------------------------===//

include/swift/AST/FeatureAvailability.def

@@ -80,6 +80,7 @@ FEATURE(IsolatedDeinit,                                 (6, 1))
 
 FEATURE(ValueGenericType,                               (6, 2))
 FEATURE(InitRawStructMetadata2,                         (6, 2))
+FEATURE(CustomExecutors,                                (6, 2))
 
 FEATURE(TaskExecutor,                                   FUTURE)
 FEATURE(Differentiation,                                FUTURE)

include/swift/AST/KnownProtocols.def

@@ -97,6 +97,7 @@ PROTOCOL(Executor)
 PROTOCOL(SerialExecutor)
 PROTOCOL(TaskExecutor)
 PROTOCOL(GlobalActor)
+PROTOCOL(ExecutorFactory)
 
 PROTOCOL_(BridgedNSError)
 PROTOCOL_(BridgedStoredNSError)

include/swift/Basic/LangOptions.h

@@ -397,6 +397,10 @@ namespace swift {
     /// Specifies how strict concurrency checking will be.
     StrictConcurrency StrictConcurrencyLevel = StrictConcurrency::Minimal;
 
+    /// Specifies the name of the executor factory to use to create the
+    /// default executors for Swift Concurrency.
+    std::optional<std::string> ExecutorFactory;
+
     /// Enable experimental concurrency model.
     bool EnableExperimentalConcurrency = false;
 

include/swift/Option/Options.td

@@ -985,6 +985,16 @@ def strict_concurrency : Joined<["-"], "strict-concurrency=">,
            "concurrency model, or 'complete' ('Sendable' and other checking is "
            "enabled for all code in the module)">;
 
+def executor_factory : JoinedOrSeparate<["-"], "executor-factory">,
+  Flags<[FrontendOption]>,
+  HelpText<"Specify the factory to use to create the default executors for "
+           "Swift Concurrency.  This must be a type conforming to the "
+           "'ExecutorFactory' protocol.">,
+  MetaVarName<"<factory-type>">;
+def executor_factory_EQ : Joined<["-"], "executor-factory=">,
+  Flags<[FrontendOption]>,
+  Alias<executor_factory>;
+
 def enable_experimental_feature :
   Separate<["-"], "enable-experimental-feature">,
   Flags<[FrontendOption, ModuleInterfaceOption]>,

lib/AST/ASTContext.cpp

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

lib/ClangImporter/SortedCFDatabase.def.gyb

@@ -39,7 +39,7 @@ with codecs.open(CFDatabaseFile, encoding='utf-8', errors='strict') as f:
       continue
 
     # Otherwise, check for lines like FOO(BAR)
-    m = re.match('^\w+\((\w+)\)', line)
+    m = re.match(r'^\w+\((\w+)\)', line)
     if m:
       lineForName[m.group(1)] = line
 }%

lib/Driver/ToolChains.cpp

@@ -377,6 +377,10 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
     arguments.push_back(inputArgs.MakeArgString(globalRemapping));
   }
 
+  if (inputArgs.hasArg(options::OPT_executor_factory)) {
+    inputArgs.AddLastArg(arguments, options::OPT_executor_factory);
+  }
+
   // Pass through the values passed to -Xfrontend.
   inputArgs.AddAllArgValues(arguments, options::OPT_Xfrontend);
 

lib/Frontend/CompilerInvocation.cpp

@@ -1275,6 +1275,12 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Opts.enableFeature(Feature::RegionBasedIsolation);
   }
 
+  // Get the executor factory name
+  if (const Arg *A = Args.getLastArg(OPT_executor_factory)) {
+    printf("Got executor-factory option\n");
+    Opts.ExecutorFactory = A->getValue();
+  }
+
   Opts.WarnImplicitOverrides =
     Args.hasArg(OPT_warn_implicit_overrides);
 

lib/IRGen/GenMeta.cpp

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

lib/SILGen/SILGen.cpp

@@ -458,6 +458,10 @@ FuncDecl *SILGenModule::getDeinitOnExecutor() {
   return lookupConcurrencyIntrinsic(getASTContext(), "_deinitOnExecutor");
 }
 
+FuncDecl *SILGenModule::getCreateExecutors() {
+  return lookupConcurrencyIntrinsic(getASTContext(), "_createExecutors");
+}
+
 FuncDecl *SILGenModule::getExit() {
   ASTContext &C = getASTContext();
 
@@ -507,6 +511,46 @@ FuncDecl *SILGenModule::getExit() {
   return exitFunction;
 }
 
+Type SILGenModule::getExecutorFactory() {
+  auto &ctx = getASTContext();
+
+  ModuleDecl *module;
+
+  // Parse the executor factory name
+  StringRef qualifiedName = *ctx.LangOpts.ExecutorFactory;
+  StringRef typeName;
+
+  auto parts = qualifiedName.split('.');
+
+  if (parts.second.empty()) {
+    // This was an unqualified name; assume it's relative to the main module
+    module = ctx.MainModule;
+    typeName = qualifiedName;
+  } else {
+    Identifier moduleName = ctx.getIdentifier(parts.first);
+    module = ctx.getModuleByIdentifier(moduleName);
+    typeName = parts.second;
+  }
+
+  return ctx.getNamedSwiftType(module, typeName);
+}
+
+Type SILGenModule::getDefaultExecutorFactory() {
+  auto &ctx = getASTContext();
+
+  ModuleDecl *module = ctx.getModuleByIdentifier(ctx.Id_Concurrency);
+  if (!module)
+    return Type();
+
+  return ctx.getNamedSwiftType(module, "DefaultExecutorFactory");
+}
+
+ProtocolDecl *SILGenModule::getExecutorFactoryProtocol() {
+  auto &ctx = getASTContext();
+
+  return ctx.getProtocol(KnownProtocolKind::ExecutorFactory);
+}
+
 ProtocolConformance *SILGenModule::getNSErrorConformanceToError() {
   if (NSErrorConformanceToError)
     return *NSErrorConformanceToError;

lib/SILGen/SILGen.h

@@ -563,6 +563,18 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   // Retrieve the _SwiftConcurrencyShims.exit intrinsic.
   FuncDecl *getExit();
 
+  /// Get the ExecutorFactory type.
+  Type getExecutorFactory();
+
+  /// Get the DefaultExecutorFactory type.
+  Type getDefaultExecutorFactory();
+
+  /// Get the ExecutorFactory protocol.
+  ProtocolDecl *getExecutorFactoryProtocol();
+
+  /// Get the swift_createExecutors function.
+  FuncDecl *getCreateExecutors();
+
   SILFunction *getKeyPathProjectionCoroutine(bool isReadAccess,
                                              KeyPathTypeKind typeKind);
 

lib/SILGen/SILGenFunction.cpp

@@ -486,7 +486,7 @@ SILGenFunction::getOrCreateScope(const ast_scope::ASTScopeImpl *ASTScope,
   // Collapse BraceStmtScopes whose parent is a .*BodyScope.
   if (auto Parent = ASTScope->getParent().getPtrOrNull())
     if (Parent->getSourceRangeOfThisASTNode() ==
-        ASTScope->getSourceRangeOfThisASTNode())
+       ASTScope->getSourceRangeOfThisASTNode())
       return cache(getOrCreateScope(Parent, FnScope, InlinedAt));
 
   // The calls to defer closures have cleanup source locations pointing to the
@@ -1431,6 +1431,28 @@ void SILGenFunction::emitArtificialTopLevel(Decl *mainDecl) {
   }
 }
 
+static bool isCreateExecutorsFunctionAvailable(SILGenModule &SGM) {
+  FuncDecl *createExecutorsFuncDecl = SGM.getCreateExecutors();
+  if (!createExecutorsFuncDecl)
+    return false;
+
+  auto &ctx = createExecutorsFuncDecl->getASTContext();
+
+  if (ctx.LangOpts.hasFeature(Feature::Embedded))
+    return true;
+
+  if (!ctx.LangOpts.DisableAvailabilityChecking) {
+    auto deploymentAvailability = AvailabilityRange::forDeploymentTarget(ctx);
+    auto runtimeAvailability = AvailabilityRange::forRuntimeTarget(ctx);
+    auto declAvailability = ctx.getCustomExecutorsAvailability();
+    auto declRtAvailability = ctx.getCustomExecutorsRuntimeAvailability();
+    return deploymentAvailability.isContainedIn(declAvailability)
+      && runtimeAvailability.isContainedIn(declRtAvailability);
+  }
+
+  return true;
+}
+
 void SILGenFunction::emitAsyncMainThreadStart(SILDeclRef entryPoint) {
   auto moduleLoc = entryPoint.getAsRegularLocation();
   auto *entryBlock = B.getInsertionBB();
@@ -1446,6 +1468,53 @@ void SILGenFunction::emitAsyncMainThreadStart(SILDeclRef entryPoint) {
 
   B.setInsertionPoint(entryBlock);
 
+  // If we're using a new enough deployment target, call swift_createExecutors()
+  if (ctx.LangOpts.ExecutorFactory) {
+    printf("Executor factory is %s\n", ctx.LangOpts.ExecutorFactory->c_str());
+
+    if (!isCreateExecutorsFunctionAvailable(SGM)) {
+      ctx.Diags.diagnose(SourceLoc(), diag::executor_factory_not_supported);
+    } else {
+      CanType factoryTy = SGM.getExecutorFactory()->getCanonicalType();
+
+      if (!factoryTy) {
+        ctx.Diags.diagnose(SourceLoc(), diag::cannot_find_executor_factory_type,
+                           *ctx.LangOpts.ExecutorFactory);
+      }
+
+      ProtocolDecl *executorFactoryProtocol = SGM.getExecutorFactoryProtocol();
+      auto conformance = lookupConformance(factoryTy, executorFactoryProtocol);
+
+      if (conformance.isInvalid()) {
+        // If this type doesn't conform, ignore it and use the default factory
+        SourceLoc loc = extractNearestSourceLoc(factoryTy);
+
+        ctx.Diags.diagnose(loc, diag::executor_factory_must_conform, factoryTy);
+
+        factoryTy = SGM.getDefaultExecutorFactory()->getCanonicalType();
+        conformance = lookupConformance(factoryTy, executorFactoryProtocol);
+
+        assert(!conformance.isInvalid());
+      }
+
+      FuncDecl *createExecutorsFuncDecl = SGM.getCreateExecutors();
+      assert(createExecutorsFuncDecl
+             && "Failed to find swift_createExecutors function decl");
+      SILFunction *createExecutorsSILFunc =
+        SGM.getFunction(SILDeclRef(createExecutorsFuncDecl, SILDeclRef::Kind::Func),
+                        NotForDefinition);
+      SILValue createExecutorsFunc =
+        B.createFunctionRefFor(moduleLoc, createExecutorsSILFunc);
+      MetatypeType *factoryThickMetaTy
+        = MetatypeType::get(factoryTy, MetatypeRepresentation::Thick);
+      SILValue factorySILMetaTy
+        = B.createMetatype(moduleLoc, getLoweredType(factoryThickMetaTy));
+      auto ceSubs = SubstitutionMap::getProtocolSubstitutions(
+        conformance.getRequirement(), factoryTy, conformance);
+      B.createApply(moduleLoc, createExecutorsFunc, ceSubs, { factorySILMetaTy });
+    }
+  }
+
   auto wrapCallArgs = [this, &moduleLoc](SILValue originalValue, FuncDecl *fd,
                             uint32_t paramIndex) -> SILValue {
     Type parameterType = fd->getParameters()->get(paramIndex)->getTypeInContext();

stdlib/public/Concurrency/DispatchExecutor.swift

@@ -27,6 +27,8 @@ import Swift
 public class DispatchMainExecutor: RunLoopExecutor, @unchecked Sendable {
   var threaded = false
 
+  public init() {}
+
   public func run() throws {
     if threaded {
       fatalError("DispatchMainExecutor does not support recursion")
@@ -43,6 +45,7 @@ public class DispatchMainExecutor: RunLoopExecutor, @unchecked Sendable {
 
 @available(SwiftStdlib 6.2, *)
 extension DispatchMainExecutor: SerialExecutor {
+
   public func enqueue(_ job: consuming ExecutorJob) {
     _dispatchEnqueueMain(UnownedJob(job))
   }
@@ -112,6 +115,9 @@ extension DispatchMainExecutor: MainExecutor {}
 
 @available(SwiftStdlib 6.2, *)
 public class DispatchTaskExecutor: TaskExecutor, @unchecked Sendable {
+
+  public init() {}
+
   public func enqueue(_ job: consuming ExecutorJob) {
     _dispatchEnqueueGlobal(UnownedJob(job))
   }

stdlib/public/Concurrency/DispatchGlobalExecutor.cpp

@@ -241,32 +241,6 @@ void swift_dispatchEnqueueGlobal(SwiftJob *job) {
 }
 
 
-SWIFT_CC(swift)
-void swift_task_enqueueGlobalWithDelayImpl(SwiftJobDelay delay,
-                                           SwiftJob *job) {
-  assert(job && "no job provided");
-
-  dispatch_function_t dispatchFunction = &__swift_run_job;
-  void *dispatchContext = job;
-
-  SwiftJobPriority priority = swift_job_getPriority(job);
-
-  auto queue = getTimerQueue(priority);
-
-  job->schedulerPrivate[SwiftJobDispatchQueueIndex] =
-      DISPATCH_QUEUE_GLOBAL_EXECUTOR;
-
-  // dispatch_time takes a signed int64_t. SwiftJobDelay is unsigned, so
-  // extremely large values get interpreted as negative numbers, which results
-  // in zero delay. Clamp the value to INT64_MAX. That's about 292 years, so
-  // there should be no noticeable difference.
-  if (delay > (SwiftJobDelay)INT64_MAX)
-    delay = INT64_MAX;
-
-  dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, delay);
-  dispatch_after_f(when, queue, dispatchContext, dispatchFunction);
-}
-
 #define DISPATCH_UP_OR_MONOTONIC_TIME_MASK  (1ULL << 63)
 #define DISPATCH_WALLTIME_MASK  (1ULL << 62)
 #define DISPATCH_TIME_MAX_VALUE (DISPATCH_WALLTIME_MASK - 1)
@@ -359,11 +333,20 @@ void swift_dispatchEnqueueWithDeadline(bool global,
     job->schedulerPrivate[SwiftJobDispatchQueueIndex] = queue;
   }
 
-  uint64_t deadline = sec * NSEC_PER_SEC + nsec;
+  uint64_t deadline;
+  if (__builtin_mul_overflow(sec, NSEC_PER_SEC, &deadline)
+      || __builtin_add_overflow(nsec, deadline, &deadline)) {
+    deadline = UINT64_MAX;
+  }
+
   dispatch_time_t when = clock_and_value_to_time(clock, deadline);
 
   if (tnsec != -1) {
-    uint64_t leeway = tsec * NSEC_PER_SEC + tnsec;
+    uint64_t leeway;
+    if (__builtin_mul_overflow(tsec, NSEC_PER_SEC, &leeway)
+        || __builtin_add_overflow(tnsec, deadline, &leeway)) {
+      leeway = UINT64_MAX;
+    }
 
     dispatch_source_t source = 
       dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);