codesanitize

I’m making an attempt to launch my iOS app on the simulator utilizing command-line instruments, possible for automated testing for Maestro. I can efficiently construct the app utilizing xcodebuild and set up it onto the goal simulator utilizing xcrun simctl set up. The set up seems profitable (the app icon reveals up on the simulator) and if I click on it it opens app efficiently.

Nevertheless, when I attempt to launch the app utilizing xcrun simctl launch "$SIMULATOR_TARGET" "$BUNDLE_ID" it fails instantly with the next error

Underlying error (area=FBSOpenApplicationServiceErrorDomain, code=4):

If I construct and run the very same scheme and configuration (Debug) instantly from Xcode, into the very same simulator occasion, the app launches and runs completely with none points.

That is my full construct and run bash script.
Which fails on the final command.

xcodebuild -project MyProject.xcodeproj 
                   -configuration Debug 
                   -scheme "MyAppScheme (Debug)" 
                   -destination 'platform=iOS Simulator,title=iPhone 16 Professional' 
                   -derivedDataPath construct
    
APP_PATH="construct/Construct/Merchandise/Debug-iphonesimulator/MyAppName.app" SIMULATOR_TARGET="..."
BUNDLE_ID="com.mycompany.myapp.debug"
xcrun simctl set up "$SIMULATOR_TARGET" "$APP_PATH"
xcrun simctl launch "$SIMULATOR_TARGET" "$BUNDLE_ID"

What I’ve Tried (and did not resolve the difficulty):

• Verified Bundle ID: Confirmed the $BUNDLE_ID utilized in simctl launch precisely matches the CFBundleIdentifier within the constructed Information.plist.

• Verified .app Path: Confirmed the $APP_PATH exists and factors to the proper .app bundle after the construct.

• Handbook Launch: Tapping the icon on the simulator after simctl set up additionally fails to launch the app correctly (seems to crash or just would not open).

• Simulator Logs: Checked logs by way of Console.app on the Mac, filtering for the simulator and the app’s bundle ID/title across the time of the failed launch. Discovered no apparent crash studies or particular errors explaining the launch failure. Additionally tried xcrun simctl spawn booted log stream –level debug with out pinpointing the trigger.

• Erase Simulator: Used “Machine -> Erase All Content material and Settings…” on the simulator and tried the set up/launch course of once more.

• Clear Construct: Used xcodebuild clear earlier than rebuilding.

• Checked Scheme Settings: Verified in Xcode (Edit Scheme -> Run -> Arguments) that “Surroundings Variables” and “Arguments Handed On Launch” are each fully empty for the Debug configuration.

• Checked Construct Settings: Confirmed SKIP_INSTALL = NO for the Debug configuration.

• Checked Construct Phases: Confirmed the scheme is accurately configured to construct the primary utility goal.

• Checked Information.plist Validity: Confirmed CFBundleVersion is a legitimate integer string (e.g. 1 or 123).

What might clarify this discrepancy the place the app runs completely from Xcode, however constantly fails to launch by way of xcrun simctl launch with FBSOpenApplicationServiceErrorDomain, given all of the troubleshooting steps already carried out?

Are there every other potential causes associated to the simctl launch atmosphere, particular system service interactions, or delicate construct variations that I is perhaps lacking? What additional diagnostic steps might assist the foundation reason for this command-line launch failure?

When you begin utilizing Swift Concurrency, actors will primarily turn into your normal selection for safeguarding mutable state. Nevertheless, introducing actors additionally tends to introduce extra concurrency than you meant which may result in extra advanced code, and a a lot more durable time transitioning to Swift 6 in the long term.

While you work together with state that’s protected by an actor, you need to to take action asynchronously. The result’s that you just’re writing asynchronous code in locations the place you would possibly by no means have meant to introduce concurrency in any respect.

One method to resolve that’s to annotate your for instance view mannequin with the @MainActor annotation. This makes certain that every one your code runs on the principle actor, which implies that it is thread-safe by default, and it additionally makes certain that you could safely work together together with your mutable state.

That mentioned, this may not be what you are searching for. You would possibly wish to have code that does not run on the principle actor, that is not remoted by world actors or any actor in any respect, however you simply wish to have an old school thread-safe property.

Traditionally, there are a number of methods by which we are able to synchronize entry to properties. We used to make use of Dispatch Queues, for instance, when GCD was the usual for concurrency on Apple Platforms.

Just lately, the Swift crew added one thing known as a Mutex to Swift. With mutexes, we now have an alternative choice to actors for safeguarding our mutable state. I say different, but it surely’s probably not true. Actors have a really particular function in that they shield our mutable state for a concurrent surroundings the place we would like code to be asynchronous. Mutexes, then again, are actually helpful after we don’t desire our code to be asynchronous and when the operation we’re synchronizing is fast (like assigning to a property).

On this submit, we’ll discover how you can use Mutex, when it is helpful, and the way you select between a Mutex or an actor.

Mutex utilization defined

A Mutex is used to guard state from concurrent entry. In most apps, there will likely be a handful of objects that may be accessed concurrently. For instance, a token supplier, an picture cache, and different networking-adjacent objects are sometimes accessed concurrently.

On this submit, I’ll use a quite simple Counter object to verify we don’t get misplaced in advanced particulars and specifics that don’t influence or change how we use a Mutex.

While you increment or decrement a counter, that’s a fast operation. And in a codebase the place. the counter is accessible in a number of duties on the similar time, we would like these increment and decrement operations to be secure and free from information races.

Wrapping your counter in an actor is sensible from a idea viewpoint as a result of we would like the counter to be shielded from concurrent accesses. Nevertheless, after we do that, we make each interplay with our actor asynchronous.

To considerably stop this, we may constrain the counter to the principle actor, however that implies that we’re at all times going to must be on the principle actor to work together with our counter. We would not at all times be on the identical actor after we work together with our counter, so we might nonetheless must await interactions in these conditions, and that is not superb.

So as to create a synchronous API that can also be thread-safe, we may fall again to GCD and have a serial DispatchQueue.

Alternatively, we are able to use a Mutex.

A Mutex is used to wrap a bit of state and it ensures that there is unique entry to that state. A Mutex makes use of a lock underneath the hood and it comes with handy strategies to be sure that we purchase and launch our lock rapidly and accurately.

After we attempt to work together with the Mutex‘ state, we now have to attend for the lock to turn into out there. That is just like how an actor would work with the important thing distinction being that ready for a Mutex is a blocking operation (which is why we must always solely use it for fast and environment friendly operations).

This is what interacting with a Mutex appears to be like like:

class Counter {
    personal let mutex = Mutex(0)

    func increment() {
        mutex.withLock { rely in
            rely += 1
        }
    }

    func decrement() {
        mutex.withLock { rely in
            rely -= 1
        }
    }
}

Our increment and decrement capabilities each purchase the Mutex, and mutate the rely that’s handed to withLock.

Our Mutex is outlined by calling the Mutex initializer and passing it our preliminary state. On this case, we cross it 0 as a result of that’s the beginning worth for our counter.

On this instance, I’ve outlined two capabilities that safely mutate the Mutex‘ state. Now let’s see how we are able to get the Mutex‘ worth:

var rely: Int {
    return mutex.withLock { rely in
        return rely
    }
}

Discover that studying the Mutex worth can also be performed withLock. The important thing distinction with increment and decrement right here is that as an alternative of mutating rely, I simply return it.

It’s completely important that we hold our operations inside withLock quick. We don’t wish to maintain the lock for any longer than we completely must as a result of any threads which can be ready for our lock or blocked whereas we maintain the lock.

We are able to increase our instance somewhat bit by including a get and set to our rely. This can permit customers of our Counter to work together with rely prefer it’s a standard property whereas we nonetheless have data-race safety underneath the hood:

var rely: Int {
    get {
        return mutex.withLock { rely in
            return rely
        }
    }

    set {
        mutex.withLock { rely in
            rely = newValue
        }
    }
}

We are able to now use our Counter as follows:

let counter = Counter()

counter.rely = 10
print(counter.rely)

That’s fairly handy, proper?

Whereas we now have a kind that is freed from data-races, utilizing it in a context the place there are a number of isolation contexts is a little bit of a problem after we opt-in to Swift 6 since our Counter doesn’t conform to the Sendable protocol.

The great factor about Mutex and sendability is that mutexes are outlined as being Sendable in Swift itself. Because of this we are able to replace our Counter to be Sendable fairly simply, and without having to make use of @unchecked Sendable!

closing class Counter: Sendable {
    personal let mutex = Mutex(0)

    // ....
}

At this level, we now have a fairly good setup; our Counter is Sendable, it’s freed from data-races, and it has a completely synchronous API!

After we attempt to use our Counter to drive a SwiftUI view by making it @Observable, this get somewhat difficult:

struct ContentView: View {
    @State personal var counter = Counter()

    var physique: some View {
        VStack {
            Textual content("(counter.rely)")

            Button("Increment") {
                counter.increment()
            }

            Button("Decrement") {
                counter.decrement()
            }
        }
        .padding()
    }
}

@Observable
closing class Counter: Sendable {
    personal let mutex = Mutex(0)

    var rely: Int {
        get {
            return mutex.withLock { rely in
                return rely
            }
        }

        set {
            mutex.withLock { rely in
                rely = newValue
            }
        }
    }
}

The code above will compile however the view gained’t ever replace. That’s as a result of our computed property rely is predicated on state that’s not explicitly altering. The Mutex will change the worth it protects however that doesn’t change the Mutex itself.

In different phrases, we’re not mutating any information in a method that @Observable can “see”.

To make our computed property work @Observable, we have to manually inform Observable after we’re accessing or mutating (on this case, the rely keypath). This is what that appears like:

var rely: Int {
    get {
        self.entry(keyPath: .rely)
        return mutex.withLock { rely in
            return rely
        }
    }

    set {
        self.withMutation(keyPath: .rely) {
            mutex.withLock { rely in
                rely = newValue
            }
        }
    }
}

By calling the entry and withMutation strategies that the @Observable macro provides to our Counter, we are able to inform the framework after we’re accessing and mutating state. This can tie into our Observable’s common state monitoring and it’ll permit our views to replace after we change our rely property.

Mutex or actor? How you can determine?

Selecting between a mutex and an actor isn’t at all times trivial or apparent. Actors are actually good in concurrent environments when you have already got a complete bunch of asynchronous code. When you do not wish to introduce async code, or while you’re solely defending one or two properties, you are in all probability within the territory the place a mutex makes extra sense as a result of the mutex won’t power you to write down asynchronous code wherever.

I may fake that it is a trivial determination and you need to at all times use mutexes for easy operations like our counter and actors solely make sense while you wish to have a complete bunch of stuff working asynchronously, however the determination normally is not that simple.

When it comes to efficiency, actors and mutexes do not fluctuate that a lot, so there’s not an enormous apparent efficiency profit that ought to make you lean in a single path or the opposite.

In the long run, your selection ought to be based mostly round comfort, consistency, and intent. When you’re discovering your self having to introduce a ton of async code simply to make use of an actor, you are in all probability higher off utilizing a Mutex.

Actors ought to be thought of an asynchronous software that ought to solely be utilized in locations the place you’re deliberately introducing and utilizing concurrency. They’re additionally extremely helpful while you’re attempting to wrap longer-running operations in a method that makes them thread-safe. Actors don’t block execution which implies that you’re utterly fantastic with having “slower” code on an actor.

When unsure, I wish to strive each for a bit after which I stick to the choice that’s most handy to work with (and infrequently that’s the Mutex…).

In Abstract

On this submit, you have realized about mutexes and the way you need to use them to guard mutable state. I confirmed you ways they’re used, once they’re helpful, and the way a Mutex compares to an actor.

You additionally realized somewhat bit about how one can select between an actor or a property that is protected by a mutex.

Making a selection between an actor or a Mutex is, for my part, not at all times simple however experimenting with each and seeing which model of your code comes out simpler to work with is an effective begin while you’re attempting to determine between a Mutex and an actor.