Use current public Dispatch API to schedule global work.

We expect to iterate on this quite a bit, both publicly
and internally, but this is a fine starting-point.

I've renamed runAsync to runAsyncAndBlock to underline
very clearly what it does and why it's not long for this
world.  I've also had to give it a radically different
implementation in an effort to make it continue to work
given an actor implementation that is no longer just
running all work synchronously.

The major remaining bit of actor-scheduling work is to
make swift_task_enqueue actually do something sensible
based on the executor it's been given; currently it's
expecting a flag that IRGen simply doesn't know to set.

Author: rjmccall

CMakeLists.txt

@@ -435,10 +435,18 @@ option(SWIFT_BUILD_ONLY_SYNTAXPARSERLIB "Only build the Swift Syntax Parser libr
 option(SWIFT_BUILD_SOURCEKIT "Build SourceKit" TRUE)
 option(SWIFT_ENABLE_SOURCEKIT_TESTS "Enable running SourceKit tests" ${SWIFT_BUILD_SOURCEKIT})
 
-if(SWIFT_BUILD_SYNTAXPARSERLIB OR SWIFT_BUILD_SOURCEKIT)
+# Use dispatch as the system scheduler by default.
+# For convenience, we set this to false when concurrency is disabled.
+# TODO: don't do this when building a single-threaded runtime
+set(SWIFT_CONCURRENCY_USES_DISPATCH FALSE)
+if(SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY)
+  set(SWIFT_CONCURRENCY_USES_DISPATCH TRUE)
+endif()
+
+if(SWIFT_BUILD_SYNTAXPARSERLIB OR SWIFT_BUILD_SOURCEKIT OR SWIFT_CONCURRENCY_USES_DISPATCH)
   if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
     if(NOT EXISTS "${SWIFT_PATH_TO_LIBDISPATCH_SOURCE}")
-      message(SEND_ERROR "SyntaxParserLib and SourceKit require libdispatch on non-Darwin hosts.  Please specify SWIFT_PATH_TO_LIBDISPATCH_SOURCE")
+      message(SEND_ERROR "SyntaxParserLib, SourceKit, and concurrency require libdispatch on non-Darwin hosts.  Please specify SWIFT_PATH_TO_LIBDISPATCH_SOURCE")
     endif()
   endif()
 endif()
@@ -941,7 +949,7 @@ if (LLVM_ENABLE_DOXYGEN)
   message(STATUS "Doxygen: enabled")
 endif()
 
-if(SWIFT_BUILD_SYNTAXPARSERLIB OR SWIFT_BUILD_SOURCEKIT)
+if(SWIFT_BUILD_SYNTAXPARSERLIB OR SWIFT_BUILD_SOURCEKIT OR SWIFT_CONCURRENCY_USES_DISPATCH)
   if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
     if(CMAKE_C_COMPILER_ID STREQUAL Clang AND
        CMAKE_C_COMPILER_VERSION VERSION_GREATER 3.8

include/swift/ABI/Executor.h

@@ -18,6 +18,7 @@
 #define SWIFT_ABI_EXECUTOR_H
 
 #include <inttypes.h>
+#include "swift/ABI/HeapObject.h"
 
 namespace swift {
 class AsyncContext;
@@ -65,6 +66,10 @@ class ExecutorRef {
     return reinterpret_cast<DefaultActor*>(Value & ~PointerMask);
   }
 
+  uintptr_t getRawValue() const {
+    return Value;
+  }
+
   /// Do we have to do any work to start running as the requested
   /// executor?
   bool mustSwitchToRun(ExecutorRef newExecutor) const {
@@ -87,10 +92,53 @@ using TaskContinuationFunction =
   SWIFT_CC(swiftasync)
   void (AsyncTask *, ExecutorRef, AsyncContext *);
 
-template <class Fn>
+template <class AsyncSignature>
+class AsyncFunctionPointer;
+template <class AsyncSignature>
 struct AsyncFunctionTypeImpl;
-template <class Result, class... Params>
-struct AsyncFunctionTypeImpl<Result(Params...)> {
+
+/// The abstract signature for an asynchronous function.
+template <class Sig, bool HasErrorResult>
+struct AsyncSignature;
+
+template <class DirectResultTy, class... ArgTys, bool HasErrorResult>
+struct AsyncSignature<DirectResultTy(ArgTys...), HasErrorResult> {
+  bool hasDirectResult = !std::is_same<DirectResultTy, void>::value;
+  using DirectResultType = DirectResultTy;
+
+  bool hasErrorResult = HasErrorResult;
+
+  using FunctionPointer = AsyncFunctionPointer<AsyncSignature>;
+  using FunctionType = typename AsyncFunctionTypeImpl<AsyncSignature>::type;
+};
+
+/// A signature for a thin async function that takes no arguments
+/// and returns no results.
+using ThinNullaryAsyncSignature =
+  AsyncSignature<void(), false>;
+
+/// A signature for a thick async function that takes no formal
+/// arguments and returns no results.
+using ThickNullaryAsyncSignature =
+  AsyncSignature<void(HeapObject*), false>;
+
+/// A class which can be used to statically query whether a type
+/// is a specialization of AsyncSignature.
+template <class T>
+struct IsAsyncSignature {
+  static const bool value = false;
+};
+template <class DirectResultTy, class... ArgTys, bool HasErrorResult>
+struct IsAsyncSignature<AsyncSignature<DirectResultTy(ArgTys...),
+                                       HasErrorResult>> {
+  static const bool value = true;
+};
+
+template <class Signature>
+struct AsyncFunctionTypeImpl {
+  static_assert(IsAsyncSignature<Signature>::value,
+                "template argument is not an AsyncSignature");
+
   // TODO: expand and include the arguments in the parameters.
   using type = TaskContinuationFunction;
 };
@@ -102,11 +150,11 @@ using AsyncFunctionType = typename AsyncFunctionTypeImpl<Fn>::type;
 ///
 /// Eventually, this will always be signed with the data key
 /// using a type-specific discriminator.
-template <class FnType>
+template <class AsyncSignature>
 class AsyncFunctionPointer {
 public:
   /// The function to run.
-  RelativeDirectPointer<AsyncFunctionType<FnType>,
+  RelativeDirectPointer<AsyncFunctionType<AsyncSignature>,
                         /*nullable*/ false,
                         int32_t> Function;
 

include/swift/AST/Builtins.def

@@ -723,6 +723,12 @@ BUILTIN_MISC_OPERATION(TypePtrAuthDiscriminator, "typePtrAuthDiscriminator", "n"
 //  int_instrprof_increment has type (Builtin.RawPointer, Builtin.Int64, Builtin.Int32, Builtin.Int32) -> ().
 BUILTIN_MISC_OPERATION(IntInstrprofIncrement, "int_instrprof_increment", "", Special)
 
+/// Initialize the default-actor instance in a default actor object.
+BUILTIN_MISC_OPERATION(InitializeDefaultActor, "initializeDefaultActor", "", Special)
+
+/// Destroy the default-actor instance in a default actor object.
+BUILTIN_MISC_OPERATION(DestroyDefaultActor, "destroyDefaultActor", "", Special)
+
 // BUILTIN_MISC_OPERATION_WITH_SILGEN - Miscellaneous operations that are
 // specially emitted during SIL generation.
 //

include/swift/Runtime/Concurrency.h

@@ -42,16 +42,21 @@ struct AsyncTaskAndContext {
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create(JobFlags flags,
                                       AsyncTask *parent,
-                                const AsyncFunctionPointer<void()> *function);
+                const ThinNullaryAsyncSignature::FunctionPointer *function);
 
 /// Create a task object with no future which will run the given
 /// function.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_f(JobFlags flags,
                                         AsyncTask *parent,
-                                        AsyncFunctionType<void()> *function,
+                             ThinNullaryAsyncSignature::FunctionType *function,
                                         size_t initialContextSize);
 
+/// Caution: not all future-initializing functions actually throw, so
+/// this signature may be incorrect.
+using FutureAsyncSignature =
+  AsyncSignature<void(void*), /*throws*/ true>;
+
 /// Create a task object with a future which will run the given
 /// function.
 ///
@@ -68,14 +73,15 @@ AsyncTaskAndContext swift_task_create_f(JobFlags flags,
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_future(
     JobFlags flags, AsyncTask *parent, const Metadata *futureResultType,
-    const AsyncFunctionPointer<void()> *function);
+    const FutureAsyncSignature::FunctionPointer *function);
 
 /// Create a task object with a future which will run the given
 /// function.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 AsyncTaskAndContext swift_task_create_future_f(
     JobFlags flags, AsyncTask *parent, const Metadata *futureResultType,
-    AsyncFunctionType<void()> *function, size_t initialContextSize);
+    FutureAsyncSignature::FunctionType *function,
+    size_t initialContextSize);
 
 /// Allocate memory in a task.
 ///
@@ -127,6 +133,9 @@ struct TaskFutureWaitResult {
   OpaqueValue *storage;
 };
 
+using TaskFutureWaitSignature =
+  AsyncSignature<TaskFutureWaitResult(AsyncTask *), /*throws*/ false>;
+
 /// Wait for a future task to complete.
 ///
 /// This can be called from any thread. Its Swift signature is
@@ -135,8 +144,8 @@ struct TaskFutureWaitResult {
 /// func swift_task_future_wait(on task: Builtin.NativeObject) async
 ///     -> TaskFutureWaitResult
 /// \endcode
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-AsyncFunctionType<TaskFutureWaitResult(AsyncTask *task)>
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
+TaskFutureWaitSignature::FunctionType
 swift_task_future_wait;
 
 /// Add a status record to a task.  The record should not be
@@ -204,9 +213,18 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 NearestTaskDeadline
 swift_task_getNearestDeadline(AsyncTask *task);
 
-// TODO: Remove this hack.
+/// Run the given async function and block the current thread until
+/// it returns.  This is a hack added for testing purposes; eventually
+/// top-level code will be an async context, and the need for this in
+/// tests should go away.  We *definitely* do not want this to be part
+/// of the standard feature set.
+///
+/// The argument is a `() async -> ()` function, whose ABI is currently
+/// quite complex.  Eventually this should use a different convention;
+/// that's rdar://72105841.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_task_run(AsyncTask *taskToRun);
+void swift_task_runAndBlockThread(const void *function,
+                                  HeapObject *functionContext);
 
 /// Switch the current task to a new executor if we aren't already
 /// running on a compatible executor.

lib/AST/Builtins.cpp

@@ -1439,6 +1439,13 @@ static ValueDecl *getConvertTaskToJob(ASTContext &ctx, Identifier id) {
                             _job);
 }
 
+static ValueDecl *getDefaultActorInitDestroy(ASTContext &ctx,
+                                             Identifier id) {
+  return getBuiltinFunction(ctx, id, _thin,
+                            _parameters(_nativeObject),
+                            _void);
+}
+
 static ValueDecl *getAutoDiffCreateLinearMapContext(ASTContext &ctx,
                                                     Identifier id) {
   return getBuiltinFunction(
@@ -2651,6 +2658,10 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::TriggerFallbackDiagnostic:
     return getTriggerFallbackDiagnosticOperation(Context, Id);
 
+  case BuiltinValueKind::InitializeDefaultActor:
+  case BuiltinValueKind::DestroyDefaultActor:
+    return getDefaultActorInitDestroy(Context, Id);
+
   case BuiltinValueKind::WithUnsafeContinuation:
     return getWithUnsafeContinuation(Context, Id, /*throws=*/false);
 

stdlib/public/Concurrency/Actor.cpp

@@ -10,7 +10,8 @@
 ///
 ///===----------------------------------------------------------------------===///
 ///
-/// The standard actor implementation for Swift actors.
+/// The default actor implementation for Swift actors, plus related
+/// routines such as generic executor enqueuing and switching.
 ///
 ///===----------------------------------------------------------------------===///
 
@@ -1357,21 +1358,9 @@ void swift::swift_task_enqueue(Job *job, ExecutorRef executor) {
   if (executor.isDefaultActor())
     return asImpl(executor.getDefaultActor())->enqueue(job);
 
+  // Just assume it's actually a default actor that we haven't tagged
+  // properly.
   // FIXME: call the general method.
-  job->run(executor);
+  return asImpl(reinterpret_cast<DefaultActor*>(executor.getRawValue()))
+    ->enqueue(job);
 }
-
-SWIFT_CC(swift)
-void (*swift::swift_task_enqueueGlobal_hook)(Job *job) = nullptr;
-
-void swift::swift_task_enqueueGlobal(Job *job) {
-  assert(job && "no job provided");
-
-  // If the hook is defined, use it.
-  if (swift_task_enqueueGlobal_hook)
-    return swift_task_enqueueGlobal_hook(job);
-
-  // FIXME: implement this properly
-  job->run(ExecutorRef::generic());
-}
-