Understanding Swift Performance: Allocation, Reference Counting, and Dispatch

Introduction

Swift, introduced by Apple at WWDC 2014, has become the backbone of iOS development. It offers high‑level features such as protocols, closures, and generics, and uses Swift Intermediate Language (SIL) for compiler optimizations, making Swift faster than Objective‑C.

Understanding Swift Performance

Performance can be examined from two perspectives: the compiler (compile‑time and run‑time optimizations) and the developer (choosing appropriate data structures and keywords).

Allocation

Memory allocation is divided into stack and heap. Simple value types (e.g., struct) are allocated on the stack, which is fast and contiguous. Classes allocate their instances on the heap, requiring reference counting and possible locking, which adds overhead.

// Example 1
// Allocation
// Struct
struct Point { var x, y: Double
    func draw() { … }
}
let point1 = Point(x: 0, y: 0) // stack allocation
var point2 = point1               // copy creates new stack memory
point2.x = 5

When a struct is copied, the compiler creates an independent instance on the stack. In contrast, a class instance shares a heap allocation:

// Allocation
// Class
class Point { var x, y: Double
    func draw() { … }
}
let point1 = Point(x: 0, y: 0) // heap allocation, stack holds a pointer
let point2 = point1            // both variables reference the same heap object
point2.x = 5                    // modifies the same instance

Reference Counting

Swift uses Automatic Reference Counting (ARC) to manage heap objects. When the reference count drops to zero, the memory is released. Structs without heap references have no ARC overhead, while structs containing reference‑type fields incur ARC costs.

// Reference Counting
struct Label { var text: String
    var font: UIFont
    func draw() { … }
}
let label1 = Label(text: "Hi", font: font) // stack holds a pointer to heap objects
let label2 = label1                         // both share the same heap references

Method Dispatch

Static dispatch resolves the method at compile time and enables inlining, while dynamic dispatch resolves it at run time via a method table, which is slower.

Swift can use final classes or private methods to force static dispatch, and whole‑module optimization can replace dynamic dispatch with static dispatch when the concrete type is known.

Protocol Types

Protocol‑oriented programming implements polymorphism without inheritance. A protocol type is stored in an Existential Container that holds a value buffer, a value‑witness table, and a protocol‑witness table.

protocol Drawable { func draw() }
struct Point: Drawable { var x, y: Double
    func draw() { … }
}
struct Line: Drawable { var x1, y1, x2, y2: Double
    func draw() { … }
}
var drawables: [Drawable] = [Point(), Line()]
for d in drawables { d.draw() }

The container allows different concrete types to be stored uniformly, while the witness tables provide the correct method implementations.

Generics

Generics provide static polymorphism. The compiler creates a specialized version of a generic function for each concrete type, enabling inlining and eliminating witness‑table indirection.

func min<T: Comparable>(x: T, y: T) -> T {
    return y < x ? y : x
}
// After specialization for Int
func minInt(x: Int, y: Int) -> Int { return y < x ? y : x }

When generic code is used with a fixed type, whole‑module optimization can inline the specialized implementation, reducing call overhead.

Whole‑Module Optimization

Enabling -whole-module-optimization (or -wmo) lets the Swift compiler see all source files together, allowing cross‑file inlining, generic specialization, and dead‑code elimination. This dramatically improves both runtime performance and compile‑time efficiency for large projects.

Summary

Performance in Swift is affected by three main factors: allocation strategy, reference counting, and method dispatch. Choosing struct over class where appropriate, using final or private to enable static dispatch, and leveraging whole‑module optimization are key techniques for writing high‑performance Swift code.