Merge pull request swiftlang#34842 from DougGregor/worlds-slowest-fibonacci

Author: swift-ci

include/swift/Runtime/Concurrency.h

@@ -174,8 +174,8 @@ bool swift_task_removeStatusRecord(AsyncTask *task,
                                    TaskStatusRecord *record);
 
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-JobPriority
-swift_task_getPriority(AsyncTask* task);
+JobFlags
+swift_task_getJobFlags(AsyncTask* task);
 
 /// This should have the same representation as an enum like this:
 ///    enum NearestTaskDeadline {

lib/IRGen/IRGenFunction.cpp

@@ -495,8 +495,6 @@ Address IRGenFunction::emitTaskAlloc(llvm::Value *size, Alignment alignment) {
   auto *call = Builder.CreateCall(IGM.getTaskAllocFn(), {getAsyncTask(), size});
   call->setDoesNotThrow();
   call->setCallingConv(IGM.SwiftCC);
-  call->addAttribute(llvm::AttributeList::FunctionIndex,
-                     llvm::Attribute::ReadNone);
   auto address = Address(call, alignment);
   return address;
 }

lib/SIL/IR/ValueOwnership.cpp

@@ -541,7 +541,7 @@ CONSTANT_OWNERSHIP_BUILTIN(None, PoundAssert)
 CONSTANT_OWNERSHIP_BUILTIN(None, TypePtrAuthDiscriminator)
 CONSTANT_OWNERSHIP_BUILTIN(None, IntInstrprofIncrement)
 CONSTANT_OWNERSHIP_BUILTIN(None, GlobalStringTablePointer)
-CONSTANT_OWNERSHIP_BUILTIN(Owned, GetCurrentAsyncTask)
+CONSTANT_OWNERSHIP_BUILTIN(None, GetCurrentAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(None, CancelAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTask)
 CONSTANT_OWNERSHIP_BUILTIN(Owned, CreateAsyncTaskFuture)

stdlib/public/Concurrency/Task.cpp

@@ -352,6 +352,6 @@ void swift::swift_task_run(AsyncTask *taskToRun) {
   taskToRun->run(ExecutorRef::noPreference());
 }
 
-JobPriority swift::swift_task_getPriority(AsyncTask *task) {
-  return task->getPriority();
+JobFlags swift::swift_task_getJobFlags(AsyncTask *task) {
+  return task->Flags;
 }

stdlib/public/Concurrency/Task.swift

@@ -44,8 +44,8 @@ extension Task {
   /// This function returns instantly and will never suspend.
   /* @instantaneous */
   public static func currentPriority() async -> Priority {
-    let task = Builtin.getCurrentAsyncTask()
-    return getPriority(task)
+    let flags = getJobFlags(Builtin.getCurrentAsyncTask())
+    return flags.priority
   }
 
   /// Task priority may inform decisions an `Executor` makes about how and when
@@ -416,8 +416,8 @@ extension Task {
 @_silgen_name("swift_task_run")
 public func runTask(_ task: __owned Builtin.NativeObject)
 
-@_silgen_name("swift_task_getPriority")
-public func getPriority(_ task: __owned Builtin.NativeObject) -> Task.Priority
+@_silgen_name("swift_task_getJobFlags")
+func getJobFlags(_ task: Builtin.NativeObject) -> Task.JobFlags
 
 public func runAsync(_ asyncFun: @escaping () async -> ()) {
   let childTask = Builtin.createAsyncTask(0, nil, asyncFun)

test/Concurrency/Runtime/async_task_priority_basic.swift

@@ -25,9 +25,9 @@ extension DispatchQueue {
 func test_getPriority() {
   _ = DispatchQueue.main.async { () async in
     let p = await Task.currentPriority()
-    // CHECK: priority: userInteractive
+    // CHECK: priority: default
     print("priority: \(p)")
-    assert(p == Task.Priority.userInteractive)
+    assert(p == Task.Priority.default)
     exit(0)
   }
 }

test/Concurrency/Runtime/basic_future.swift

@@ -3,6 +3,7 @@
 // REQUIRES: executable_test
 // REQUIRES: concurrency
 // REQUIRES: OS=macosx
+// XFAIL: CPU=arm64e
 
 import Dispatch
 

test/Concurrency/Runtime/future_fibonacci.swift

@@ -0,0 +1,87 @@
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency)
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: OS=macosx
+// XFAIL: CPU=arm64e
+
+import Dispatch
+
+extension DispatchQueue {
+  func async<R>(execute: @escaping () async throws -> R) -> Task.Handle<R> {
+    let handle = Task.runDetached(operation: execute)
+
+    // Run the task
+    _ = { self.async { handle.run() } }()
+
+    return handle
+  }
+
+  func async<R>(in group: DispatchGroup,
+    execute: @escaping () async throws -> R) -> Task.Handle<R> {
+    let handle = Task.runDetached(operation: execute)
+
+    // Run the task
+    group.enter()
+    _ = {
+      self.async {
+        handle.run()
+        group.leave()
+      }
+    }()
+
+    return handle
+  }
+}
+
+func fib(_ n: Int) -> Int {
+    var first = 0
+    var second = 1
+    for _ in 0..<n {
+        let temp = first
+        first = second
+        second = temp + first
+    }
+    return first
+}
+
+func asyncFib(_ n: Int, group: DispatchGroup, queue: DispatchQueue) async -> Int {
+  if n == 0 || n == 1 {
+    return n
+  }
+
+  let first = queue.async(in: group) {
+    await asyncFib(n - 2, group: group, queue: queue)
+  }
+
+  let second = queue.async(in: group) {
+    await asyncFib(n - 1, group: group, queue: queue)
+  }
+
+  // Sleep a random amount of time waiting on the result producing a result.
+  usleep(UInt32.random(in: 0..<100) * 1000)
+
+  let result = await try! first.get() + second.get()
+
+  // Sleep a random amount of time before producing a result.
+  usleep(UInt32.random(in: 0..<100) * 1000)
+
+  return result
+}
+
+func runFibonacci(_ n: Int) {
+  let queue = DispatchQueue(label: "concurrent", attributes: .concurrent)
+  let group = DispatchGroup()
+
+  var result = 0
+  _ = queue.async(in: group) {
+    result = await asyncFib(n, group: group, queue: queue)
+  }
+  group.wait()
+
+  print()
+  print("Async fib = \(result), sequential fib = \(fib(n))")
+  assert(result == fib(n))
+}
+
+runFibonacci(15)