Add a basic default-actor implementation with support for

eagerly adopting and abandoning threads.

Author: rjmccall

include/swift/ABI/Actor.h

@@ -0,0 +1,43 @@
+//===--- Actor.h - ABI structures for actors --------------------*- 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 actors.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_ABI_ACTOR_H
+#define SWIFT_ABI_ACTOR_H
+
+#include "swift/ABI/HeapObject.h"
+#include "swift/ABI/MetadataValues.h"
+
+namespace swift {
+
+/// The default actor implementation.
+class alignas(MaximumAlignment) DefaultActor : public HeapObject {
+public:
+  // These constructors do not initialize the actor instance, and the
+  // destructor does not destroy the actor instance; you must call
+  // swift_defaultActor_{initialize,destroy} yourself.
+  constexpr DefaultActor(const HeapMetadata *metadata)
+    : HeapObject(metadata), PrivateData{} {}
+
+  constexpr DefaultActor(const HeapMetadata *metadata,
+                         InlineRefCounts::Immortal_t immortal)
+    : HeapObject(metadata, immortal), PrivateData{} {}
+
+  void *PrivateData[NumWords_DefaultActor];
+};
+
+} // end namespace swift
+
+#endif

include/swift/ABI/MetadataValues.h

@@ -1889,7 +1889,11 @@ enum class JobKind : size_t {
   Task = 0,
 
   /// Job kinds >= 192 are private to the implementation.
-  First_Reserved = 192
+  First_Reserved = 192,
+
+  DefaultActorInline = First_Reserved,
+  DefaultActorSeparate,
+  DefaultActorOverride
 };
 
 /// The priority of a job.  Higher priorities are larger values.

include/swift/ABI/Task.h

@@ -382,6 +382,16 @@ class alignas(MaximumAlignment) AsyncContext {
 
   AsyncContext(const AsyncContext &) = delete;
   AsyncContext &operator=(const AsyncContext &) = delete;
+
+  /// Perform a return from this context.
+  ///
+  /// Generally this should be tail-called.
+  SWIFT_CC(swiftasync)
+  void resumeParent(AsyncTask *task, ExecutorRef executor) {
+    // TODO: destroy context before returning?
+    // FIXME: force tail call
+    return ResumeParent(task, executor, Parent);
+  }
 };
 
 /// An async context that supports yielding.

include/swift/Runtime/Concurrency.h

@@ -20,6 +20,7 @@
 #include "swift/ABI/TaskStatus.h"
 
 namespace swift {
+class DefaultActor;
 
 struct AsyncTaskAndContext {
   AsyncTask *Task;
@@ -206,6 +207,70 @@ swift_task_getNearestDeadline(AsyncTask *task);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_run(AsyncTask *taskToRun);
 
+/// Switch the current task to a new executor if we aren't already
+/// running on a compatible executor.
+///
+/// The resumption function pointer and continuation should be set
+/// appropriately in the task.
+///
+/// Generally the compiler should inline a fast-path compatible-executor
+/// check to avoid doing the suspension work.  This function should
+/// generally be tail-called, as it may continue executing the task
+/// synchronously if possible.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
+void swift_task_switch(AsyncTask *task,
+                       ExecutorRef currentExecutor,
+                       ExecutorRef newExecutor);
+
+/// Enqueue the given job to run asynchronously on the given executor.
+///
+/// The resumption function pointer and continuation should be set
+/// appropriately in the task.
+///
+/// Generally you should call swift_task_switch to switch execution
+/// synchronously when possible.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_enqueue(Job *job, ExecutorRef executor);
+
+/// Enqueue the given job to run asynchronously on the global
+/// execution pool.
+///
+/// The resumption function pointer and continuation should be set
+/// appropriately in the task.
+///
+/// Generally you should call swift_task_switch to switch execution
+/// synchronously when possible.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_enqueueGlobal(Job *job);
+
+/// A hook to take over global enqueuing.
+/// TODO: figure out a better abstraction plan than this.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void (*swift_task_enqueueGlobal_hook)(Job *job);
+
+/// Initialize the runtime storage for a default actor.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_defaultActor_initialize(DefaultActor *actor);
+
+/// Destroy the runtime storage for a default actor.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_defaultActor_destroy(DefaultActor *actor);
+
+/// Enqueue a job on the default actor implementation.
+///
+/// The job must be ready to run.  Notably, if it's a task, that
+/// means that the resumption function and context should have been
+/// set appropriately.
+///
+/// Jobs are assumed to be "self-consuming": once it starts running,
+/// the job memory is invalidated and the executor should not access it
+/// again.
+///
+/// Jobs are generally expected to keep the actor alive during their
+/// execution.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_defaultActor_enqueue(Job *job, DefaultActor *actor);
+
 }
 
 #endif