Actors 101

[ibex10]

More Interesting Topics

Measuring Actor performance

Post

Summary

@nkbelov

@isaac-weisberg

The code does a lot of stuff that's not directly related to what I have written.

Can somebody help me, maybe I need to somehow setup my project so that the performance is comparable?

This is expected to an extent: actors are much higher-level than simple locks and rely on Swift Concurrency runtime to work, which includes some scheduling logic on top of OS threads. In that, they are more comparable to GCD queues.

You should not really expect actors to demonstrate comparable performance in tasks such as simply incrementing an integer from a different isolation domain, as the runtime will have to constantly switch contexts, which is way more expensive than the operation itself.

Part of the problem is that testStateHolderActor() runs on the so-called generic executor, while the actor has its own executor, and the runtime has to switch in each iteration. You can modify your logic to only hop off the actor once:

func testStateHolderActor() async {
    let e = measureSH()
    let actor = StateHolderActor()

    var sum = 0
    actor.onNewValueReceived = { val in
        sum += val
    }

    func run(actor: isolated StateHolderActor) async {
         for i in 0 ..< iterations {
            actor.handleValueRecieved(1)
        }
    }

    await run(actor: actor)

    e()
}

You will find much more success with actors for tasks where you have to isolate larger stateful systems, where it becomes increasingly more cumbersome to set up locking properly and there's a need to support async operations by design, such as network I/O.

Try This

import Foundation

@main
enum Test {
    static func main () async  {
        testStateHolderLocked()
        await testStateHolderActor()
        await testStateHolderActor2()
    }
}

// [https://forums.swift.org/t/i-was-playing-with-measuring-actor-performance/75005]

final class StateHolderLock {
    var lock = os_unfair_lock_s()

    init() {}

    var sum = 0

    var onNewValueReceived: ((Int) -> Void)!

    func handleValueRecieved(_ val: Int) {
        os_unfair_lock_lock(&lock)
        sum += val
        os_unfair_lock_unlock(&lock)
        onNewValueReceived(val)
    }
}

final actor StateHolderActor {
    init() {}

    var sum = 0

    nonisolated(unsafe) var onNewValueReceived: ((Int) -> Void)!

    func handleValueRecieved(_ val: Int) {
        sum += val
        onNewValueReceived(val)
    }
}

let iterations = 1000000
func testStateHolderActor() async {
    await measure ("Actor:") {
        let actor = StateHolderActor()
        
        var sum = 0
        actor.onNewValueReceived = { val in
            sum += val
        }
        
        for _ in 0 ..< iterations {
            await actor.handleValueRecieved(1)
        }
        
    }
}

func testStateHolderLocked() {
    measure ("Locked:") {
        let actor = StateHolderLock()
        
        var sum = 0
        actor.onNewValueReceived = { val in
            sum += val
        }
        
        for _ in 0 ..< iterations {
            actor.handleValueRecieved(1)
        }
        
    }
}

// [https://forums.swift.org/t/i-was-playing-with-measuring-actor-performance/75005/2]

func testStateHolderActor2 () async {
    await measure ("Actor2 :") {
        let actor = StateHolderActor()
        
        var sum = 0
        actor.onNewValueReceived = { val in
            sum += val
        }
        
        func run (actor: isolated StateHolderActor) async {
            for _ in 0 ..< iterations {
                actor.handleValueRecieved(1)
            }
        }
        
        await run (actor: actor)
    }
}

func measure (_ prefix: String, _ f: () -> Void) {
    let d = ContinuousClock ().measure {
        f ()
    }
    print (prefix, d)
}

func measure (_ prefix: String, _ f: () async -> Void) async {
    let d = await ContinuousClock ().measure {
        await f ()
    }
    print (prefix, d)
}

Guaranteeing an actor executes off the main thread

Post

Summary

@nkbelov

Every actor which is not the main actor executes on a background thread; this is actually a public guarantee and is stated in the documentation: Actor | Apple Developer Documentation. More specifically, if an actor doesn't specify a custom executor, it's given a default executor instance, which simply delegates to that background thread pool.

I think you're assuming that an actor becomes "bound" to whatever place it has been created in, but this is not true; an actor is always its own isolation domain regardless of whether its initializer got called by something running on the main actor or not, and because it already is concurrency-safe, it can execute concurrently with its creator — through using the global threadpool.

@George

Is there consensus on what is the correct approach?

The good news is that you don't have to do anything Looks like you want precisely the default behaviour.

Also, priority is a property of a task, not an actor. That is, if you call the same actor method twice from tasks with different priorities, like so:

func foo() async {
    let myActor = MyActor()
    
    Task(priority: .high) {
        await myActor.synchronousFunction(1)
    }
    
    Task(priority: .low) {
        await myActor.synchronousFunction(2)
    }
}

it only affects the scheduling order of the calls, but never "infects" the actor for the rest of its lifetime.

How to share isolation between two actors

Post

How to “fire and forget” work on an actor?

Post

Try This

@main
enum Actors {
    static func main () async throws {
        let u = FooActor ()
        await print (u.x)
        u.incrementEventually()
        u.incrementEventually()
        u.incrementEventually()
        for _ in 0..<5 {
            await print (u.x)
            await hibernate (seconds: 3)
        }
    }
}

func hibernate (seconds v: Int) async {
    try! await Task.sleep(until: .now + .seconds(v))
}

// [https://forums.swift.org/t/how-to-fire-and-forget-work-on-an-actor/75157]


actor FooActor {
    var x = 0

    func incrementX () {
        self.x += 1
    }
    
    nonisolated func incrementEventually() {
        Task {
            await hibernate (seconds: 3)
            await self.incrementX()
        }
    }
}