Merge pull request swiftlang#34816 from rjmccall/actor-runtime

Implement a basic actor runtime, including queuing and switching

Author: rjmccall

cmake/modules/AddSwift.cmake

@@ -248,6 +248,18 @@ function(_add_host_variant_c_compile_flags target)
     endif()
   endif()
 
+  # The concurrency library uses double-word atomics.  MSVC's std::atomic
+  # uses a spin lock for this, so to get reasonable behavior we have to
+  # implement it ourselves using _InterlockedCompareExchange128.
+  # clang-cl requires us to enable the `cx16` feature to use this intrinsic.
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
+    if(SWIFT_HOST_VARIANT_ARCH STREQUAL x86_64)
+      if(CMAKE_C_COMPILER_ID MATCHES Clang)
+        target_compile_options(${target} PRIVATE -mcx16)
+      endif()
+    endif()
+  endif()
+
   if(LLVM_ENABLE_ASSERTIONS)
     target_compile_options(${target} PRIVATE -UNDEBUG)
   else()

include/swift/ABI/Actor.h

@@ -0,0 +1,44 @@
+//===--- 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.  This is the layout of both
+/// the DefaultActor and NSDefaultActor classes.
+class alignas(Alignment_DefaultActor) 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/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/MetadataValues.h

@@ -42,6 +42,10 @@ enum {
 
   /// The number of words in a yield-many coroutine buffer.
   NumWords_YieldManyBuffer = 8,
+
+  /// The number of words (in addition to the heap-object header)
+  /// in a default actor.
+  NumWords_DefaultActor = 10,
 };
 
 struct InProcess;
@@ -114,6 +118,9 @@ enum class NominalTypeKind : uint32_t {
 /// The maximum supported type alignment.
 const size_t MaximumAlignment = 16;
 
+/// The alignment of a DefaultActor.
+const size_t Alignment_DefaultActor = MaximumAlignment;
+
 /// Flags stored in the value-witness table.
 template <typename int_type>
 class TargetValueWitnessFlags {
@@ -1885,7 +1892,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.
@@ -1920,6 +1931,10 @@ class JobFlags : public FlagSet<size_t> {
 
   explicit JobFlags(size_t bits) : FlagSet(bits) {}
   JobFlags(JobKind kind) { setKind(kind); }
+  JobFlags(JobKind kind, JobPriority priority) {
+    setKind(kind);
+    setPriority(priority);
+  }
   constexpr JobFlags() {}
 
   FLAGSET_DEFINE_FIELD_ACCESSORS(Kind, Kind_width, JobKind,

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:
@@ -436,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/AST/ASTContext.h

@@ -580,7 +580,7 @@ class ASTContext final {
 
   // Retrieve the declaration of Swift._stdlib_isOSVersionAtLeast.
   FuncDecl *getIsOSVersionAtLeastDecl() const;
-  
+
   /// Look for the declaration with the given name within the
   /// Swift module.
   void lookupInSwiftModule(StringRef name,

include/swift/AST/Decl.h

@@ -3459,6 +3459,10 @@ enum class AncestryFlags : uint8_t {
 
   /// The class or one of its superclasses requires stored property initializers.
   RequiresStoredPropertyInits = (1<<6),
+
+  /// The class uses the ObjC object model (reference counting,
+  /// isa encoding, etc.).
+  ObjCObjectModel = (1<<7),
 };
 
 /// Return type of ClassDecl::checkAncestry(). Describes a set of interesting
@@ -3625,6 +3629,30 @@ class ClassDecl final : public NominalTypeDecl {
   /// Whether the class is an actor.
   bool isActor() const;
 
+  /// Whether the class is (known to be) a default actor.
+  bool isDefaultActor() const;
+
+  /// Whether the class is known to be a *root* default actor,
+  /// i.e. the first class in its hierarchy that is a default actor.
+  bool isRootDefaultActor() const;
+
+  /// Does this class explicitly declare any of the methods that
+  /// would prevent it from being a default actor?
+  bool hasExplicitCustomActorMethods() const;
+
+  /// Is this the NSObject class type?
+  bool isNSObject() const;
+
+  /// Whether the class directly inherits from NSObject but should use
+  /// Swift's native object model.
+  bool isNativeNSObjectSubclass() const;
+
+  /// Whether the class uses the ObjC object model (reference counting,
+  /// allocation, etc.) instead of the Swift model.
+  bool usesObjCObjectModel() const {
+    return checkAncestry(AncestryFlags::ObjCObjectModel);
+  }
+
   /// Returns true if the class has designated initializers that are not listed
   /// in its members.
   ///

include/swift/AST/DiagnosticsCommon.def

@@ -103,6 +103,10 @@ ERROR(generic_signature_not_equal,none,
       "generic signature %0 is not equal to new signature %1",
       (StringRef, StringRef))
 
+// Used in diagnostics that are split across requests implemented in several places.
+ERROR(concurrency_default_actor_not_found,none,
+      "broken standard library: cannot find default actor type '%0'", (StringRef))
+
 // FIXME: Used by swift-api-digester. Don't want to set up a separate diagnostics
 // file just for a few errors.
 ERROR(sdk_node_unrecognized_key,none,