Merge pull request swiftlang#37007 from DougGregor/async-operation

[Concurrency] Add "async" operation for continuing work asynchronously.

Author: DougGregor

include/swift/Runtime/Concurrency.h

@@ -642,6 +642,10 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_reportUnexpectedExecutor(
     const unsigned char *file, uintptr_t fileLength, bool fileIsASCII,
     uintptr_t line, ExecutorRef executor);
+
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+JobPriority swift_task_getCurrentThreadPriority(void);
+
 }
 
 #pragma clang diagnostic pop

stdlib/public/Concurrency/Actor.cpp

@@ -27,6 +27,7 @@
 #include "swift/ABI/Actor.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "TaskPrivate.h"
+#include <dispatch/dispatch.h>
 
 #if defined(__APPLE__)
 #include <asl.h>
@@ -259,6 +260,17 @@ static bool isExecutingOnMainThread() {
 #endif
 }
 
+JobPriority swift::swift_task_getCurrentThreadPriority() {
+  if (isExecutingOnMainThread())
+    return JobPriority::UserInitiated;
+
+#if defined(__APPLE__)
+  return static_cast<JobPriority>(qos_class_self());
+#else
+  return JobPriority::Unspecified;
+#endif
+}
+
 SWIFT_CC(swift)
 static bool swift_task_isCurrentExecutorImpl(ExecutorRef executor) {
   if (auto currentTracking = ExecutorTrackingInfo::current()) {

stdlib/public/Concurrency/Task.swift

@@ -481,6 +481,55 @@ public func detach<T>(
   return Task.Handle<T, Error>(task)
 }
 
+/// Run given `operation` as asynchronously in its own top-level task.
+///
+/// The `async` function should be used when creating asynchronous work
+/// that operates on behalf of the synchronous function that calls it.
+/// Like `detach`, the async function creates a separate, top-level task.
+/// Unlike `detach`, the task creating by `async` inherits the priority and
+/// actor context of the caller, so the `operation` is treated more like an
+/// asynchronous extension to the synchronous operation. Additionally, `async`
+/// does not return a handle to refer to the task.
+///
+/// - Parameters:
+///   - priority: priority of the task. If unspecified, the priority will
+///               be inherited from the task that is currently executing
+///               or, if there is none, from the platform's understanding of
+///               which thread is executing.
+///   - operation: the operation to execute
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+public func async(
+  priority: Task.Priority = .unspecified,
+  @_inheritActorContext @_implicitSelfCapture operation: __owned @Sendable @escaping () async -> Void
+) {
+  // Determine the priority at which we should create this task
+  let actualPriority: Task.Priority
+  if priority == .unspecified {
+    actualPriority = withUnsafeCurrentTask { task in
+      // If we are running on behalf of a task,
+      if let task = task {
+        return task.priority
+      }
+
+      return Task.Priority(rawValue: _getCurrentThreadPriority()) ?? .unspecified
+    }
+  } else {
+    actualPriority = priority
+  }
+
+  // Set up the job flags for a new task.
+  var flags = Task.JobFlags()
+  flags.kind = .task
+  flags.priority = actualPriority
+  flags.isFuture = true
+
+  // Create the asynchronous task future.
+  let (task, _) = Builtin.createAsyncTaskFuture(flags.bits, operation)
+
+  // Enqueue the resulting job.
+  _enqueueJobGlobal(Builtin.convertTaskToJob(task))
+}
+
 // ==== Async Handler ----------------------------------------------------------
 
 // TODO: remove this?
@@ -746,6 +795,10 @@ func _reportUnexpectedExecutor(_ _filenameStart: Builtin.RawPointer,
                                _ _line: Builtin.Word,
                                _ _executor: Builtin.Executor)
 
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+@_silgen_name("swift_task_getCurrentThreadPriority")
+func _getCurrentThreadPriority() -> Int
+
 #if _runtime(_ObjC)
 
 /// Intrinsic used by SILGen to launch a task for bridging a Swift async method

test/Concurrency/Runtime/async.swift

@@ -0,0 +1,70 @@
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency %import-libdispatch)
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: libdispatch
+
+// rdar://76038845
+// UNSUPPORTED: use_os_stdlib
+
+import Dispatch
+import StdlibUnittest
+
+// for sleep
+#if canImport(Darwin)
+    import Darwin
+#elseif canImport(Glibc)
+    import Glibc
+#endif
+
+var asyncTests = TestSuite("Async")
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+actor MyActor {
+  func synchronous() { }
+
+  func doSomething(expectedPriority: Task.Priority) {
+    async {
+      synchronous() // okay to be synchronous
+      assert(Task.currentPriority == expectedPriority)
+    }
+  }
+}
+
+if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) {
+  let actor = MyActor()
+
+  asyncTests.test("Detach") {
+    detach(priority: .background) {
+      async {
+        assert(Task.currentPriority == .background)
+        await actor.doSomething(expectedPriority: .background)
+      }
+    }
+    sleep(1)
+  }
+
+  asyncTests.test("MainQueue") {
+    DispatchQueue.main.async {
+      async {
+        assert(Task.currentPriority == .userInitiated)
+      }
+    }
+    sleep(1)
+  }
+
+  asyncTests.test("GlobalDispatchQueue") {
+    DispatchQueue.global(qos: .utility).async {
+      async {
+#if (os(macOS) || os(iOS) || os(tvOS) || os(watchOS))
+        // Non-Darwin platforms currently lack qos_class_self().
+        assert(Task.currentPriority == .utility)
+#endif
+      }
+    }
+    sleep(1)
+  }
+}
+
+runAllTests()
+