[Concurrency] Simple Task.yield implementation

Author: ktoso

stdlib/public/Concurrency/Task.swift

@@ -503,6 +503,37 @@ extension Task {
   }
 }
 
+// ==== Voluntary Suspension -----------------------------------------------------
+extension Task {
+
+  /// Explicitly suspend the current task, potentially giving up execution actor
+  /// of current actor/task, allowing other tasks to execute.
+  ///
+  /// This is not a perfect cure for starvation;
+  /// if the task is the highest-priority task in the system, it might go
+  /// immediately back to executing.
+  public static func yield() async {
+    // Prepare the job flags
+    var flags = JobFlags()
+    flags.kind = .task
+    flags.priority = .default
+    flags.isFuture = true
+
+    // Create the asynchronous task future, it will do nothing, but simply serves
+    // as a way for us to yield our execution until the executor gets to it and
+    // resumes us.
+    // FIXME: This should be an empty closure instead. Returning `0` here is
+    //        a workaround for rdar://74957357
+    // TODO: consider if it would be useful for this task to be a child task
+    let (task, _) = Builtin.createAsyncTaskFuture(flags.bits, nil, { return 0 })
+
+    // Enqueue the resulting job.
+    _enqueueJobGlobal(Builtin.convertTaskToJob(task))
+
+    let _ = await Handle<Int, Never>(task).get()
+  }
+}
+
 // ==== UnsafeCurrentTask ------------------------------------------------------
 
 /// Calls the given closure with the with the "current" task in which this

test/Concurrency/Runtime/async_task_yield.swift

@@ -0,0 +1,42 @@
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency %import-libdispatch -parse-as-library) | %FileCheck %s
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+
+protocol Go: Actor {
+  func go(times: Int) async -> Int
+}
+extension Go {
+  func go(times: Int) async -> Int {
+    for i in 0...times {
+      print("\(Self.self) @ \(i)")
+      await Task.yield()
+    }
+    return times
+  }
+}
+
+actor One: Go {}
+actor Two: Go {}
+
+func yielding() async {
+  let one = One()
+  let two = Two()
+  try! await Task.withGroup(resultType: Int.self) { group in
+    await group.add {
+      await one.go(times: 100)
+    }
+    await group.add {
+      await two.go(times: 100)
+    }
+  }
+}
+
+@main struct Main {
+  static func main() async {
+    await yielding()
+    // TODO: No idea for a good test for this... Open to ideas?
+    // CHECK:      One
+    // CHECK-NEXT: Two
+  }
+}