Extract executor stuff out into a separate header and

start introducing the idea of a swiftasync CC.

Author: rjmccall

include/swift/ABI/Executor.h

@@ -0,0 +1,119 @@
+//===--- Executor.h - ABI structures for executors --------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Swift ABI describing executors.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_ABI_EXECUTOR_H
+#define SWIFT_ABI_EXECUTOR_H
+
+#include <inttypes.h>
+
+namespace swift {
+class AsyncContext;
+class AsyncTask;
+class DefaultActor;
+class Job;
+
+/// An ExecutorRef isn't necessarily just a pointer to an executor
+/// object; it may have other bits set.
+class ExecutorRef {
+  static constexpr uintptr_t IsDefaultActor = 1;
+  static constexpr uintptr_t PointerMask = 7;
+
+  uintptr_t Value;
+
+  constexpr ExecutorRef(uintptr_t value) : Value(value) {}
+
+public:
+  /// A generic execution environment.  When running in a generic
+  /// environment, it's presumed to be okay to switch synchronously
+  /// to an actor.  As an executor request, this represents a request
+  /// to drop whatever the current actor is.
+  constexpr static ExecutorRef generic() {
+    return ExecutorRef(0);
+  }
+
+  /// Given a pointer to a default actor, return an executor reference
+  /// for it.
+  static ExecutorRef forDefaultActor(DefaultActor *actor) {
+    assert(actor);
+    return ExecutorRef(reinterpret_cast<uintptr_t>(actor) | IsDefaultActor);
+  }
+
+  /// Is this the generic executor reference?
+  bool isGeneric() const {
+    return Value == 0;
+  }
+
+  /// Is this a default-actor executor reference?
+  bool isDefaultActor() const {
+    return Value & IsDefaultActor;
+  }
+  DefaultActor *getDefaultActor() const {
+    assert(isDefaultActor());
+    return reinterpret_cast<DefaultActor*>(Value & ~PointerMask);
+  }
+
+  /// Do we have to do any work to start running as the requested
+  /// executor?
+  bool mustSwitchToRun(ExecutorRef newExecutor) const {
+    return *this != newExecutor;
+  }
+
+  bool operator==(ExecutorRef other) const {
+    return Value == other.Value;
+  }
+  bool operator!=(ExecutorRef other) const {
+    return Value != other.Value;
+  }
+};
+
+using JobInvokeFunction =
+  SWIFT_CC(swiftasync)
+  void (Job *, ExecutorRef);
+
+using TaskContinuationFunction =
+  SWIFT_CC(swiftasync)
+  void (AsyncTask *, ExecutorRef, AsyncContext *);
+
+template <class Fn>
+struct AsyncFunctionTypeImpl;
+template <class Result, class... Params>
+struct AsyncFunctionTypeImpl<Result(Params...)> {
+  // TODO: expand and include the arguments in the parameters.
+  using type = TaskContinuationFunction;
+};
+
+template <class Fn>
+using AsyncFunctionType = typename AsyncFunctionTypeImpl<Fn>::type;
+
+/// A "function pointer" for an async function.
+///
+/// Eventually, this will always be signed with the data key
+/// using a type-specific discriminator.
+template <class FnType>
+class AsyncFunctionPointer {
+public:
+  /// The function to run.
+  RelativeDirectPointer<AsyncFunctionType<FnType>,
+                        /*nullable*/ false,
+                        int32_t> Function;
+
+  /// The expected size of the context.
+  uint32_t ExpectedContextSize;
+};
+
+}
+
+#endif

include/swift/ABI/Task.h

@@ -18,75 +18,21 @@
 #define SWIFT_ABI_TASK_H
 
 #include "swift/Basic/RelativePointer.h"
+#include "swift/ABI/Executor.h"
 #include "swift/ABI/HeapObject.h"
 #include "swift/ABI/Metadata.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/Runtime/Config.h"
 #include "swift/Basic/STLExtras.h"
 
 namespace swift {
-
 class AsyncTask;
 class AsyncContext;
-class Executor;
 class Job;
 struct OpaqueValue;
 struct SwiftError;
 class TaskStatusRecord;
 
-/// An ExecutorRef isn't necessarily just a pointer to an executor
-/// object; it may have other bits set.
-struct ExecutorRef {
-  Executor *Pointer;
-
-  /// Get an executor ref that represents a lack of preference about
-  /// where execution resumes.  This is only valid in continuations,
-  /// return contexts, and so on; it is not generally passed to
-  /// executing functions.
-  static ExecutorRef noPreference() {
-    return { nullptr };
-  }
-
-  bool operator==(ExecutorRef other) const {
-    return Pointer == other.Pointer;
-  }
-};
-
-using JobInvokeFunction =
-  SWIFT_CC(swift)
-  void (Job *, ExecutorRef);
-
-using TaskContinuationFunction =
-  SWIFT_CC(swift)
-  void (AsyncTask *, ExecutorRef, AsyncContext *);
-
-template <class Fn>
-struct AsyncFunctionTypeImpl;
-template <class Result, class... Params>
-struct AsyncFunctionTypeImpl<Result(Params...)> {
-  // TODO: expand and include the arguments in the parameters.
-  using type = TaskContinuationFunction;
-};
-
-template <class Fn>
-using AsyncFunctionType = typename AsyncFunctionTypeImpl<Fn>::type;
-
-/// A "function pointer" for an async function.
-///
-/// Eventually, this will always be signed with the data key
-/// using a type-specific discriminator.
-template <class FnType>
-class AsyncFunctionPointer {
-public:
-  /// The function to run.
-  RelativeDirectPointer<AsyncFunctionType<FnType>,
-                        /*nullable*/ false,
-                        int32_t> Function;
-
-  /// The expected size of the context.
-  uint32_t ExpectedContextSize;
-};
-
 /// A schedulable job.
 class alignas(2 * alignof(void*)) Job {
 protected:

include/swift/Runtime/Config.h

@@ -176,6 +176,14 @@ extern uintptr_t __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTL
 #define SWIFT_INDIRECT_RESULT
 #endif
 
+// SWIFT_CC(swiftasync) is the Swift async calling convention.
+// We assume that it supports mandatory tail call elimination.
+#if __has_attribute(swiftasynccall)
+#define SWIFT_CC_swiftasync __attribute__((swiftasynccall))
+#else
+#define SWIFT_CC_swiftasync SWIFT_CC_swift
+#endif
+
 // SWIFT_CC(PreserveMost) is used in the runtime implementation to prevent
 // register spills on the hot path.
 // It is not safe to use for external calls; the loader's lazy function

stdlib/public/Concurrency/Task.cpp

@@ -303,7 +303,7 @@ AsyncTaskAndContext swift::swift_task_create_future_f(
   // be is the final hop.  Store a signed null instead.
   initialContext->Parent = nullptr;
   initialContext->ResumeParent = &completeTask;
-  initialContext->ResumeParentExecutor = ExecutorRef::noPreference();
+  initialContext->ResumeParentExecutor = ExecutorRef::generic();
   initialContext->Flags = AsyncContextKind::Ordinary;
   initialContext->Flags.setShouldNotDeallocateInCallee(true);
 
@@ -349,7 +349,7 @@ void swift::swift_task_future_wait(
 
 // TODO: Remove this hack.
 void swift::swift_task_run(AsyncTask *taskToRun) {
-  taskToRun->run(ExecutorRef::noPreference());
+  taskToRun->run(ExecutorRef::generic());
 }
 
 JobFlags swift::swift_task_getJobFlags(AsyncTask *task) {

unittests/runtime/TaskStatus.cpp

@@ -80,7 +80,7 @@ static void withSimpleTask(T &&value,
 }
 
 static ExecutorRef createFakeExecutor(uintptr_t value) {
-  return {reinterpret_cast<Executor*>(value)};
+  return ExecutorRef::forDefaultActor(reinterpret_cast<DefaultActor*>(value));
 }
 
 } // end anonymous namespace