[question] How do the static members of Task work?

[ibex10]

I am curious about how the static members of Task work.

For example, here are two static members:

struct Task {
   ...
   static var isCancelled: Bool { get }
   // A Boolean value that indicates whether the task should stop executing.

   static func checkCancellation() throws
   // Throws an error if the task was canceled.
   ...
}

And a function foo that creates two Task instances and then cancels them.

func foo () {
     let t1 = Task <Void, Never> {
          ....
          if Task.isCancelled {
              return
          }
          ...
     }

     let t2 = Task <Void, Error> {
          ....
          Task.checkCancellation ()
          ...
          }
     }
     ...
     t1.cancel ()
     t2.cancel ()

How does Task.isCancelled determine that t1 has been cancelled but not t2? Similarly, how does Task.checkCancellation determine that t2 has been cancelled but not t1?

Both members are static, and therefore they have no direct access to instances t1 and t2. They must have some indirect access.

How does this work? How does Task.isCancelled find the instance t1?

Can anyone shed some light on this?

Thank you

[vns]

Via withUnsafeCurrentTask, you can check it in source code: swift/stdlib/public/Concurrency/TaskCancellation.swift at 638950c0411ca201aca626ab92d85cd35bb5d59b · swiftlang/swift · GitHub

[Diggory]

Cancellation section of SE0304

It is possible to query for cancellation from within a synchronous task, e.g. while iterating over a loop and wanting to check if we should abort its execution by using the static Task.isCancelled property:

 extension Task where Success == Never, Failure == Never { 
   /// Returns `true` if the task is cancelled, and should stop executing.
   ///
   /// Always returns `false` when called from code not currently running inside of a `Task`.
   static var isCancelled: Bool { get }
 }

This works the same as its instance counterpart, except that if invoked from a context that has no Task available, e.g. if invoked from outside of Swift's concurrency model (e.g. directly from a pthread) a default value is returned. The static isCancelled property is implemented as:

 extension Task where Success == Never, Failure == Never {
   static var isCancelled: Bool { 
     withUnsafeCurrentTask { task in 
       task?.isCancelled ?? false  
     }
   }
 }

[ktoso (Konrad 'ktoso' Malawski 🐟🏴‍☠️)]

As folks already explained: the task, just like a thread, is the “current execution context” and therefore you can “get the current one” (like you can with threads).

Since it can be unsafe to escape that and we generally don’t need to access it explicitly while running “on it”, the only api to get “the current one” is as shown above. Now that we have non escaping types that’d be actually quite possible to make a “get current” api that would not be unsafe, if we can prevent you from escaping it, because then it’ll always be valid since you can only get it while executing on it

Either way, these methods are static because they get the current task, and we did not want you to each for the unsafe api but these single accesses are always safe.

The same goes for task locals — they also access the current task after all :-)

[ibex10]

@vns

Via withUnsafeCurrentTask, you can check it in source code: swift/stdlib/public/Concurrency/TaskCancellation.swift at 638950c0411ca201aca626ab92d85cd35bb5d59b · swiftlang/swift · GitHub

@Diggory

 extension Task where Success == Never, Failure == Never {
   static var isCancelled: Bool { 
     withUnsafeCurrentTask { task in 
       task?.isCancelled ?? false  
     }
   }
 }

Thank you, @vns, @Diggory

That got me excited, but my quest ended at _getCurrentAsyncTask; I couldn't dive any deeper.

// Task.swift
...
// ==== Internal ---------------------------------------------------------------
@available(SwiftStdlib 5.1, *)
@_silgen_name("swift_task_getCurrent")
public func _getCurrentAsyncTask() -> Builtin.NativeObject?

However, as @ktoso pointed out, the current execution context is the key to understanding how the static members of Task do their jobs.