Concurrency Profiling — Instruments Workflows
Profile and optimize Swift async/await code using Instruments.
When to Use
✅ Use when:
UI stutters during async operations Suspecting actor contention Tasks queued but not executing Main thread blocked during async work Need to visualize task execution flow
❌ Don't use when:
Issue is pure CPU performance (use Time Profiler) Memory issues unrelated to concurrency (use Allocations) Haven't confirmed concurrency is the bottleneck Swift Concurrency Template What It Shows Track Information Swift Tasks Task lifetimes, parent-child relationships Swift Actors Actor access, contention visualization Thread States Blocked vs running vs suspended Statistics Running Tasks: Tasks currently executing Alive Tasks: Tasks present at a point in time Total Tasks: Cumulative count created Color Coding Blue: Task executing Red: Task waiting (contention) Gray: Task suspended (awaiting) Workflow 1: Diagnose Main Thread Blocking
Symptom: UI freezes, main thread timeline full
Profile with Swift Concurrency template Look at main thread → "Swift Tasks" lane Find long blue bars (task executing on main) Check if work could be offloaded
Solution patterns:
// ❌ Heavy work on MainActor @MainActor class ViewModel: ObservableObject { func process() { let result = heavyComputation() // Blocks UI self.data = result } }
// ✅ Offload heavy work @MainActor class ViewModel: ObservableObject { func process() async { let result = await Task.detached { heavyComputation() }.value self.data = result } }
Workflow 2: Find Actor Contention
Symptom: Tasks serializing unexpectedly, parallel work running sequentially
Enable "Swift Actors" instrument Look for serialized access patterns Red = waiting, Blue = executing High red:blue ratio = contention problem
Solution patterns:
// ❌ All work serialized through actor actor DataProcessor { func process(_ data: Data) -> Result { heavyProcessing(data) // All callers wait } }
// ✅ Mark heavy work as nonisolated actor DataProcessor { nonisolated func process(_ data: Data) -> Result { heavyProcessing(data) // Runs in parallel }
func storeResult(_ result: Result) {
// Only actor state access serialized
}
}
More fixes:
Split actor into multiple (domain separation) Use Mutex for hot paths (faster than actor hop) Reduce actor scope (fewer isolated properties) Workflow 3: Thread Pool Exhaustion
Symptom: Tasks queued but not executing, gaps in task execution
Cause: Blocking calls exhaust cooperative pool
Look for gaps in task execution across all threads Check for blocking primitives Replace with async equivalents
Common culprits:
// ❌ Blocks cooperative thread Task { semaphore.wait() // NEVER do this // ... semaphore.signal() }
// ❌ Synchronous file I/O in async context Task { let data = Data(contentsOf: fileURL) // Blocks }
// ✅ Use async APIs Task { let (data, _) = try await URLSession.shared.data(from: fileURL) }
Debug flag:
SWIFT_CONCURRENCY_COOPERATIVE_THREAD_BOUNDS=1
Detects unsafe blocking in async context.
Workflow 4: Priority Inversion
Symptom: High-priority task waits for low-priority
Inspect task priorities in Instruments Follow wait chains Ensure critical paths use appropriate priority // ✅ Explicit priority for critical work Task(priority: .userInitiated) { await criticalUIUpdate() }
Thread Pool Model
Swift uses a cooperative thread pool matching CPU core count:
Aspect GCD Swift Concurrency Threads Grows unbounded Fixed to core count Blocking Creates new threads Suspends, frees thread Dependencies Hidden Runtime-tracked Context switch Full kernel switch Lightweight continuation
Why blocking is catastrophic:
Each blocked thread holds memory + kernel structures Limited threads means blocked = no progress Pool exhaustion deadlocks the app Quick Checks (Before Profiling)
Run these checks first:
Is work actually async?
Look for suspension points (await) Sync code in async function still blocks
Holding locks across await?
// ❌ Deadlock risk mutex.withLock { await something() // Never! }
Tasks in tight loops?
// ❌ Overhead may exceed benefit for item in items { Task { process(item) } }
// ✅ Structured concurrency await withTaskGroup(of: Void.self) { group in for item in items { group.addTask { process(item) } } }
DispatchSemaphore in async context?
Always unsafe — use withCheckedContinuation instead Common Issues Summary Issue Symptom in Instruments Fix MainActor overload Long blue bars on main Task.detached, nonisolated Actor contention High red:blue ratio Split actors, use nonisolated Thread exhaustion Gaps in all threads Remove blocking calls Priority inversion High-pri waits for low-pri Check task priorities Too many tasks Task creation overhead Use task groups Safe vs Unsafe Primitives
Safe with cooperative pool:
await, actors, task groups os_unfair_lock, NSLock (short critical sections) Mutex (iOS 18+)
Unsafe (violate forward progress):
DispatchSemaphore.wait() pthread_cond_wait Sync file/network I/O Thread.sleep() in Task Resources
WWDC: 2022-110350, 2021-10254
Docs: /xcode/improving-app-responsiveness
Skills: axiom-swift-concurrency, axiom-performance-profiling, axiom-synchronization