ax-swift-perf

Swift Performance

Quick Patterns

Reserve Capacity

// BAD: ~14 reallocations for 10000 appends
var array: [Int] = []
for i in 0..<10000 { array.append(i) }

// GOOD: Single allocation
var array: [Int] = []
array.reserveCapacity(10000)
for i in 0..<10000 { array.append(i) }

ContiguousArray (15% faster)

// For pure Swift (no ObjC bridging)
var array: ContiguousArray<Int> = []
array.reserveCapacity(count)

Avoid Defensive Copies

class DataStore { var items: [Item] = [] }

// BAD: Swift may defensively copy store.items each iteration
func process(_ store: DataStore) {
    for item in store.items { handle(item) }
}

// GOOD: One explicit copy
func process(_ store: DataStore) {
    let items = store.items
    for item in items { handle(item) }
}

Unowned vs Weak (2x faster)

// Use unowned when child lifetime < parent lifetime
class Child {
    unowned let parent: Parent  // No atomic overhead
}

Generic over Existential (10x faster)

// BAD: Existential container + dynamic dispatch
func drawAll(shapes: [any Drawable]) { for s in shapes { s.draw() } }

// GOOD: Specializable, static dispatch
func drawAll<T: Drawable>(shapes: [T]) { for s in shapes { s.draw() } }

Batch Actor Calls

// BAD: 10000 actor hops
for _ in 0..<10000 { await counter.increment() }

// GOOD: Single actor hop
await counter.incrementBatch(10000)

Lazy Evaluation

// BAD: Processes entire array
let result = array.map { expensive($0) }.filter { $0 > 0 }.first

// GOOD: Stops at first match
let result = array.lazy.map { expensive($0) }.filter { $0 > 0 }.first

---

Decision Tree

Performance issue identified?
|
|-- Profiler shows excessive copying?
|   |-- Large types copied repeatedly -> Noncopyable Types
|   +-- COW triggers in loop -> Copy-on-Write optimization
|
|-- Retain/release overhead in Time Profiler?
|   +-- ARC Optimization (unowned, capture only what's needed)
|
|-- Generic code in hot path?
|   |-- Using `any Protocol`? -> Switch to `some` or generic <T>
|   +-- Cross-module? -> @inlinable, @_specialize
|
|-- Collection operations slow?
|   |-- Many reallocations? -> reserveCapacity
|   |-- Pure Swift? -> ContiguousArray
|   |-- Fixed size? -> InlineArray
|   +-- Short-circuit needed? -> .lazy
|
|-- Async/await overhead visible?
|   |-- Many actor hops? -> Batch operations
|   |-- Task per item? -> TaskGroup instead
|   +-- Sync func marked async? -> Remove async
|
|-- Struct vs class decision?
|   |-- <= 64 bytes, no identity -> Struct
|   |-- > 64 bytes or shared -> Class
|   +-- Large + value semantics -> COW wrapper
|
+-- Memory layout concerns?
    |-- Struct padding -> Reorder fields (largest first)
    |-- Cache misses -> ContiguousArray (not linked list)
    +-- Runtime exclusivity checks -> Move to struct