Putting @concurrent before actor methods has no effect

[rayx]

Description

While doing experiments, I find putting @concurrent before actor methods has no effect. For example, in the following code I expected runInGlobalExecutor() should run in different isolation than that of test(), but I couldn't observe the behavior I expected.

actor A {
    @concurrent func runInGlobalExecutor() async {
    }

    func test() {
        Task {
            await runInGlobalExecutor()
        }
    }
}

There wasn't an obvious way to confirm my suspicion. One approach I tried at first was to print thread id in test() and runInGlobalExecutor() separately and expected they should be different. But this approach didn't produce meaningful reasult, because in Swift concurrency an available thread is used dynamically to run code in different isolation. For example, in the following example @concurrent works correctly but printing thread id in test() and runInGlobalExecutor2() may still gives the same result (I observed it).

@concurrent func runInGlobalExecutor2() async {
}

actor A {
    func test() {
        Task {
            await runInGlobalExecutor2()
        }
    }
}

Fortunately I thought of an approach to prove runInGlobalExecutor() and runInGlobalExecutor2() have different behaviors. See this example:

class NS {}

@concurrent func runInGlobalExecutor2(_ x: NS) async {
}

actor A {
    @concurrent func runInGlobalExecutor(_ x: NS) async {
    }

    func test() async {
        let x = NS()
        Task {
            await runInGlobalExecutor(x) // Not OK
            await runInGlobalExecutor2(x) // OK
        }
    }
}

Since x is task isolated, it's expected that runInGlobalExecutor2(x) should compile. In my understanding runInGlobalExecutor(x) should work the same and compiles too, but it doesn't.

Reproduction

class NS {}

@concurrent func runInGlobalExecutor2(_ x: NS) async {
}

actor A {
    @concurrent func runInGlobalExecutor(_ x: NS) async {
    }

    func test() async {
        let x = NS()
        Task {
            await runInGlobalExecutor(x) // Not OK
            await runInGlobalExecutor2(x) // OK
        }
    }
}

Expected behavior

runInGlobalExecutor() should work the same as runInGlobalExecutor2()

Environment

x86-64 swiftc nightly on godbolt

Additional information

No response

[xedin]

Hm, maybe this is a concurrency runtime issue, @ktoso?

With main compiler the runInGlobalExecutor is nonisolated and hops to nil in its prolog just like runInGlobalExecutor2 does:

// A.runInGlobalExecutor(_:)
// Isolation: nonisolated
sil hidden [ossa] @$s4main1AC19runInGlobalExecutoryyAA2NSCYaF : $@convention(method) @async (@guaranteed NS, @guaranteed A) -> () {
// %0 "x"                                         // user: %2
// %1 "self"                                      // user: %3
bb0(%0 : @guaranteed $NS, %1 : @guaranteed $A):
  debug_value %0, let, name "x", argno 1          // id: %2
  debug_value %1, let, name "self", argno 2       // id: %3
  %4 = enum $Optional<any Actor>, #Optional.none!enumelt // user: %5
  hop_to_executor %4                              // id: %5
  %6 = tuple ()                                   // user: %7
  return %6                                       // id: %7
} // end sil function '$s4main1AC19runInGlobalExecutoryyAA2NSCYaF'

[jamieQ]

@rayx did you try adding isolation assertions? if i do that the @concurrent closure fails such assertions (https://swift.godbolt.org/z/b8zo9h9dq):

actor A {
    @concurrent
    func runInGlobalExecutor() async {
        self.assertIsolated("fail") // 💥
    }

    func runOnActorExecutor() async {
        self.assertIsolated("fail") // ✅
    }

    func test() {
        Task {
            await runOnActorExecutor()
            await runInGlobalExecutor()
        }
    }
}

let a = A()
await a.test()
try? await Task.sleep(for: .seconds(1))
print("done")

i think the RBI diagnostic behavior might be expected – if you comment out the runInGlobalExecutor call (which is what i assume you did to get it to build), then the Task is no longer isolated to the actor instance since self is not captured (it is implicitly captured by that call). if you explicitly capture self in the Task closure body, then both of the calls should be disallowed because from the perspective of the closure body, the non-sendable and actor have been merged into the same region (i think). e.g.

func test() async {
    let x = NS()
    Task {
        _ = self // if we capture self, then both calls error in the same way
        // await runInGlobalExecutor(x) // 🛑
        await runInGlobalExecutor2(x) // 🛑
    }
}