# Swift Performance Benchmarks: Structs vs Classes, Arrays, Strings, and Loops (Swift 6.4, -O) Source: https://devdocs10.com/articles/swift/swift-performance-benchmarks By Murat Bo · Published 2026-10-17 · DevDocs10 (https://devdocs10.com) How much faster are structs than classes, does `reserveCapacity` matter, is `forEach` slower than `for-in`, and when does a `Dictionary` beat a plain array search? This article answers with numbers measured on one machine on 2026-10-17 with `swiftc -O`, explains why each result comes out the way it does, and includes the complete benchmark source so you can reproduce it. > **Quick answer:** With `-O`, `for-in`, `forEach`, `reduce` and an index loop all summed an array at the same speed (0.21 ns per element); switching `+` to the wrapping `&+` made the sum 4.0× faster because it lets the compiler vectorize. Creating a million `final class` instances took about 8 ns each, roughly 16× the cost of structs in most runs (4–16× across all runs), copying an array of class references was 6.2× slower than copying structs, `reserveCapacity` made building many small arrays 2.1× faster, `+=` and `append` are the same operation, and a linear array search beat `Dictionary` up to about 16 `Int` keys but only up to about 8 `String` keys. > **Difficulty:** Intermediate to Advanced > > **You'll understand this better if you know:** [structs](/articles/swift/swift-structs) and classes, [value vs reference semantics](/articles/swift/swift-value-vs-reference-semantics), [copy-on-write](/articles/swift/swift-copy-on-write), and [ARC](/articles/swift/swift-arc). ## 1. Test Setup | Item | Value | | --- | --- | | Machine | Apple M6, 24 GB RAM (12 cores; `sysctl` reports 2 “Super”, 4 “Performance” and 6 “Efficiency” cores) | | Operating system | macOS 27.0.1 (build 26A434) | | Compiler | swift-driver version: 1.168.6 Apple Swift version 6.4 (swiftlang-6.4.0.34.1 clang-2100.3.34.1), target `arm64-apple-macosx27.0.0` (from `swift --version`) | | Build | `swiftc -O SwiftBench.swift` (single file, default Swift 5 language mode; the file also compiles with `-swift-version 6`). The same file was also built with `-Onone` for section 7. | | Timer | `ContinuousClock`. Readings advance in steps of about 41.7 ns. An empty timed repetition (two clock reads) measured 23 ns and 43 ns in the two full runs and between 15 and 69 ns in extra standalone runs; it varies from process to process. | | Date measured | 2026-10-17 | ### Methodology - **Every repetition is timed on its own.** The clock is read before and after each repetition. Because a clock read is an opaque call, the optimizer cannot hoist work out of a timed region or merge repetitions together. - **3 warm-up runs, then 10 measured runs per case.** A run is one or more repetitions; tables report the **median** time per element or operation (ns/op), the min–max range of the 10 runs, and speed relative to the fastest variant in the same table. - **No dead code.** Every result is folded into a global `checksum` that is printed at the end, and inputs are mixed with a value the compiler cannot know (`CommandLine.arguments.count`), so nothing can be constant-folded or deleted. Most functions under test are marked `@inline(never)`, so they are compiled as standalone functions rather than folded into the timing code. - **What is timed.** Results are freed after the clock stops, except in the “destroy” rows, which time exactly that. - **Repeated twice.** The full suite ran twice back to back; the *Re-run* column is the second run’s median and the *-Onone* column comes from the unoptimized build. The machine was idle apart from normal background desktop processes (1-minute load average 4.25 before the first suite, partly from the author’s own test runs just before, and 1.71 before the second). That timer overhead is included in every repetition. It is negligible except for the shortest repetitions (the 10,000-element sums with `&+`, about 0.5 µs), where it adds roughly 3–13%. Across all 101 cases, the median min–max spread within a run was 4% and the median difference between the two runs was 2%. ## 2. Structs vs Classes: Creating, Copying, Reading, Freeing The value type is `struct PointS { var x, y, z: Double }` and the reference type is a `final class PointC` with the same three stored properties. Each test works with 1,000,000 instances held in an array; ns/op is per instance. ### Creating 1,000,000 instances (appending to a reserved array) | Variant | Median (ns/op) | Min – max | Relative | Re-run | -Onone | | --- | --- | --- | --- | --- | --- | | `struct (array of PointS)` | 1.11 | 0.97 – 1.39 | 1.00× | 2.34 | 58.1 | | `final class (array of PointC)` | 8.28 | 7.97 – 8.63 | 7.44× | 8.61 | 65.2 | > **Note:** Struct creation was the one unstable measurement in the suite. It took 1.11 ms per repetition in the first full run and 2.34 ms in the second, but 7 of 8 additional standalone runs of just these two cases measured 504.88 µs–516.90 µs (the other measured 1.47 ms). Class creation stayed between 8.17 ms and 8.61 ms. A check with `getrusage` found no page faults after the first repetition, so the slow mode is not explained by faulting in fresh memory; its cause was not identified. ### Copying the array (assignment, then one mutation) | Variant | Median (ns/op) | Min – max | Relative | Re-run | -Onone | | --- | --- | --- | --- | --- | --- | | `struct PointS (values copied)` | 0.34 | 0.33 – 0.34 | 1.00× | 0.34 | 0.36 | | `class PointC (references copied + retained)` | 2.10 | 1.89 – 2.20 | 6.23× | 1.97 | 1.34 | | `struct Tagged {Int, String} (String retained)` | 2.07 | 1.92 – 2.19 | 6.16× | 2.11 | 1.65 | | `class PointC deep copy (new instances)` | 13.0 | 12.9 – 13.5 | 38.65× | 13.6 | 46.9 | ### Reading: summing `.x` over all elements | Variant | Median (ns/op) | Min – max | Relative | Re-run | -Onone | | --- | --- | --- | --- | --- | --- | | `struct PointS` | 0.51 | 0.50 – 0.52 | 1.00× | 0.52 | 34.4 | | `final class PointC` | 1.53 | 1.47 – 1.55 | 2.98× | 1.53 | 40.4 | ### Freeing the array | Variant | Median time to free 1,000,000 instances | Min – max | Re-run | -Onone | | --- | --- | --- | --- | --- | | `struct PointS` | 84 ns | 41 ns – 542 ns | 83 ns | 458 ns | | `final class PointC` | 8.41 ms | 8.03 ms – 8.76 ms | 8.80 ms | 9.30 ms | Why the gaps are this large: - **Allocation.** `MemoryLayout.stride` is 24 bytes, and the structs sit inline in one array buffer, so creating them is a sequence of stores. Every `PointC` is a separate heap allocation: `malloc_size` reported 48 bytes per instance (the object header with its metadata pointer and reference count, plus the 24 bytes of fields, rounded up by the allocator), and the array holds an 8-byte reference to each. That is why creating classes cost 8.28 ns per instance against 1.11 ns. - **Freeing is the mirror image.** Releasing the struct array is one deallocation (under 1 µs in total, at the limit of the timer’s resolution); releasing the class array has to release and free each object (8.41 ms). - **Copying.** Assigning an array is O(1); the copy happens at the first mutation ([copy-on-write](/articles/swift/swift-copy-on-write)). For `PointS` that copy is a plain memory copy. For `PointC` only references are copied, but every one must be retained, so the shallow copy cost 6.2× as much, and a real deep copy (new instances) cost 38.7× as much. - **Structs are not automatically cheap to copy.** `Tagged` holds a `String` longer than 15 bytes, which lives in heap storage, so copying an array of `Tagged` also retains every element (2.07 ns per element). Swift’s [optimization tips](https://github.com/swiftlang/swift/blob/main/docs/OptimizationTips.rst) make the same point: value types need reference counting only if they contain references. - **Reading.** Summing a field over the class array was 3.0× slower: each element is a reference that has to be followed to an object elsewhere in memory, and the data touched grows from 24 MB to about 56 MB. ## 3. Building Arrays: append With and Without reserveCapacity Each variant builds an `[Int]` of *n* elements. For n = 1,000, one repetition builds 1,000 arrays; ns/op is per element. ### n = 1,000 (many small arrays) | Variant | Median (ns/op) | Min – max | Relative | Re-run | -Onone | | --- | --- | --- | --- | --- | --- | | `append, no reserveCapacity` | 0.61 | 0.59 – 0.62 | 6.38× | 0.61 | 59.3 | | `append after reserveCapacity(n)` | 0.28 | 0.28 – 0.29 | 2.98× | 0.30 | 58.9 | | `Array(repeating:count:) + a[i] =` | 0.14 | 0.14 – 0.15 | 1.49× | 0.15 | 56.4 | | `(0.. **Note:** Never draw performance conclusions from a Debug build. Measure with the optimization level you ship, which for most apps is `-O` or `-Osize`. ## 8. What This Means for Your Code - **Write loops however reads best.** At `-O`, `for-in`, `forEach` and `reduce` compiled to the same speed. - **Prefer structs for plain data**, especially when you create, copy or free many values. The class costs here were per object, so they scale with how many objects you allocate. - **Remember what is inside your structs.** A struct holding strings longer than 15 bytes, arrays or class references needs reference counting when copied. - **Call `reserveCapacity` once when you know the final size**, especially when you build many small arrays. Do not call it repeatedly in a loop. - **Use `+=`, `append`, `joined()` or `reduce(into:)` to build strings**, and never `reduce("", +)` on a large input. - **Use wrapping operators only with a proof.** `&+` made a hot sum several times faster, but it turns an overflow trap into silently wrong results if your assumption is false. - **Do not replace small dictionaries by reflex.** A linear search wins only for a handful of keys, and the margin is a few nanoseconds; a `Dictionary` stays fast as the data grows. **When none of this matters:** most differences here are nanoseconds per element. Creating 1,000 class instances instead of structs costs about 7.17 µs extra, which is invisible next to a network request or a frame of UI layout. Measure first with Instruments or [performance tests](/articles/swift/swift-performance-testing), then optimize the code a profile points to. ## 9. Caveats - **One machine, one compiler version.** Optimizer behavior changes between Swift releases, and other CPUs have different caches, memory bandwidth and branch predictors. Re-measure on your target hardware. - **Single file, whole-module view.** The benchmark is one file, so the optimizer sees all code. Across module boundaries, non-`@inlinable` generic code cannot be specialized for your types. - **Micro-benchmarks run in isolation.** All cases share one process, so the allocator’s state carries over between cases, and in a real app other work competes for caches. - **Timer resolution and overhead.** Readings advance in steps of about 41.7 ns and two clock reads cost 15–69 ns, which matters only for the shortest repetitions (about 0.5 µs). - **Hashing is randomized.** Dictionary numbers can shift slightly from run to run. ## 10. Noise and Reproducibility The optimized build was very stable: the median min–max spread within a run was 4% and the median change between the two full runs was 2% (for `-Onone`: 2% and 2%). Cases with a within-run spread of 15% or more: `destroy (release the array) / struct PointS` (13.22×), `n = 4 / Array linear search (firstIndex(of:))` (1.54×), `create / struct (array of PointS)` (1.43×), `n = 2 / Dictionary subscript` (1.25×), `n = 64 / Dictionary subscript` (1.24×), `n = 1 / Array linear search (firstIndex(of:))` (1.22×). Cases whose median moved by 10% or more between runs: `Int keys/n = 8 / Dictionary subscript` (+142%), `1M instances/create / struct (array of PointS)` (+110%), `calibration / empty repetition (clock overhead)` (+85%), `short String keys ("key17", stored inline)/n = 8 / Dictionary subscript` (+50%), `short String keys ("key17", stored inline)/n = 4 / Dictionary subscript` (+39%), `Int keys/n = 4 / Dictionary subscript` (-23%), `Int keys/n = 128 / Dictionary subscript` (+16%), `Int keys/n = 64 / Dictionary subscript` (+16%). Most of that movement is in Dictionary lookups (random hash seeds, section 6), in struct creation (section 2), and in sub-microsecond measurements that sit at the timer’s resolution (freeing the struct array, the empty calibration repetition). ## 11. Run the Benchmarks Yourself Save the source below as `SwiftBench.swift`. It uses only the standard library (no Foundation) and needs Swift 5.10 or later for `nonisolated(unsafe)` ([SE-0412](https://github.com/swiftlang/swift-evolution/blob/main/proposals/0412-strict-concurrency-for-global-variables.md)) and macOS 13 or later for `ContinuousClock`. The optimized suite takes a few seconds; the `-Onone` build takes a few minutes. ```bash mkdir swift-bench && cd swift-bench # save the source below as SwiftBench.swift, then: swiftc -O SwiftBench.swift -o swift-bench ./swift-bench # every case, printed as tables plus raw RAW lines ./swift-bench dict-vs-array # only cases whose group/name contains the filter swiftc -Onone SwiftBench.swift -o swift-bench-onone && ./swift-bench-onone loop ``` ### Complete benchmark source (SwiftBench.swift) ```swift // SwiftBench.swift — Swift micro-benchmarks (structs/classes, arrays, strings, loops, lookups) // // swiftc -O SwiftBench.swift -o swift-bench // ./swift-bench run everything // ./swift-bench dict run only cases whose "group/name" contains "dict" // // Method: every repetition is timed on its own with ContinuousClock, so no work can be // moved out of, or merged across, timed regions. Each case does WARMUP_RUNS untimed runs, // then MEASURED_RUNS timed runs; a run is `reps` repetitions and reports ns per repetition. // Every result feeds `checksum`, which is printed at the end, so nothing is dead code. let WARMUP_RUNS = 3 let MEASURED_RUNS = 10 nonisolated(unsafe) var checksum = 0 let filter = CommandLine.arguments.count > 1 ? CommandLine.arguments[1] : "" // A value the compiler cannot know, mixed into inputs so nothing is constant-folded. let seed = CommandLine.arguments.count &+ 6 let clock = ContinuousClock() func nanoseconds(_ d: Duration) -> Double { let (s, atto) = d.components return Double(s) * 1e9 + Double(atto) * 1e-9 } // ---------- reporting ---------- func fmt(_ x: Double, _ digits: Int = 2) -> String { var scale = 1.0 for _ in 0.. String { if ns >= 1e6 { return fmt(ns / 1e6) + " ms" } if ns >= 1e3 { return fmt(ns / 1e3) + " µs" } return fmt(ns, 1) + " ns" } extension String { func padded(_ n: Int, left: Bool = false) -> String { let pad = String(repeating: " ", count: max(0, n - count)) return left ? pad + self : self + pad } } struct CaseResult { let name: String; let ops: Int; let runs: [Double] } nonisolated(unsafe) var currentGroup = "" nonisolated(unsafe) var groupResults: [CaseResult] = [] func median(_ xs: [Double]) -> Double { let s = xs.sorted() return s.count % 2 == 1 ? s[s.count / 2] : (s[s.count / 2 - 1] + s[s.count / 2]) / 2 } func flushGroup() { guard !groupResults.isEmpty else { return } let best = groupResults.map { median($0.runs) }.min()! for r in groupResults { let m = median(r.runs) print(" " + r.name.padded(44) + " median " + fmtTime(m).padded(10, left: true) + " min " + fmtTime(r.runs.min()!).padded(10, left: true) + " max " + fmtTime(r.runs.max()!).padded(10, left: true) + " " + fmt(m / Double(r.ops)).padded(9, left: true) + " ns/op " + fmt(m / best) + "x") } groupResults = [] } func record(_ group: String, _ name: String, ops: Int, runs: [Double]) { if group != currentGroup { flushGroup() currentGroup = group print("\n" + group) } groupResults.append(CaseResult(name: name, ops: ops, runs: runs)) // raw line: every measured run in ns per repetition rawLines.append("RAW\t\(group)\t\(name)\t\(ops)\t" + runs.map { fmt($0, 1) }.joined(separator: ",")) } nonisolated(unsafe) var rawLines: [String] = [] func selected(_ group: String, _ name: String) -> Bool { filter.isEmpty || (group + "/" + name).contains(filter) } // ---------- harness ---------- /// Times `body` (`reps` timed repetitions per run). `check` turns the result into an Int /// for the checksum; it runs after the clock stops, and the result is freed after that. @inline(never) func bench(_ group: String, _ name: String, ops: Int, reps: Int = 1, _ body: () -> T, check: (T) -> Int) { guard selected(group, name) else { return } func oneRun() -> Double { var total = 0.0 for _ in 0..(_ group: String, _ name: String, ops: Int, reps: Int = 1, prepare: () -> S, _ body: (S) -> T, check: (T) -> Int) { guard selected(group, name) else { return } func oneRun() -> Double { var total = 0.0 for _ in 0.. Int { state = state &* 6364136223846793005 &+ 1442695040888963407 return Int(truncatingIfNeeded: state >> 33) } } // Calibration: what an empty timed repetition costs (two clock reads) bench("calibration", "empty repetition (clock overhead)", ops: 1, reps: 1_000, { 0 }, check: { $0 }) // ===================================================================== // 1. Structs vs classes // ===================================================================== struct PointS { var x: Double; var y: Double; var z: Double } final class PointC { var x: Double; var y: Double; var z: Double init(x: Double, y: Double, z: Double) { self.x = x; self.y = y; self.z = z } } struct Tagged { var id: Int; var name: String } // a struct that holds a reference (String storage) final class Box { var value: T; init(_ v: T) { value = v } } @inline(never) func makeStructs(_ n: Int) -> [PointS] { var a: [PointS] = [] a.reserveCapacity(n) for i in 0.. [PointC] { var a: [PointC] = [] a.reserveCapacity(n) for i in 0.. [Int] { var a: [Int] = [] for i in 0.. [Int] { var a: [Int] = [] a.reserveCapacity(n) for i in 0.. [Int] { var a = [Int](repeating: 0, count: n) for i in 0.. [Int] { (0.. [Int] { [Int](unsafeUninitializedCapacity: n) { buf, count in for i in 0.. [Int])] = [ ("append, no reserveCapacity", buildAppend), ("append after reserveCapacity(n)", buildReserved), ("Array(repeating:count:) + a[i] =", buildRepeating), ("(0.. Int = { $0.utf8.count &+ Int($0.utf8.last!) } bench(g, "s += piece", ops: n, { var s = ""; for p in pieces { s += p }; return s }, check: check) bench(g, "s.append(piece)", ops: n, { var s = ""; for p in pieces { s.append(p) }; return s }, check: check) bench(g, "reserveCapacity + s.append(piece)", ops: n, { var s = ""; s.reserveCapacity(total); for p in pieces { s.append(p) }; return s }, check: check) bench(g, "pieces.joined()", ops: n, { pieces.joined() }, check: check) bench(g, "pieces.reduce(into: \"\") { $0 += $1 }", ops: n, { pieces.reduce(into: "") { $0 += $1 } }, check: check) let g2 = "string-build/100k pieces (built on the fly)" bench(g2, "s += \"item\\(i);\"", ops: n, { var s = ""; for i in 0.. Int { var s = 0; for x in a { s += x }; return s } @inline(never) func sumIndices(_ a: [Int]) -> Int { var s = 0; for i in 0.. Int { var s = 0; a.forEach { s += $0 }; return s } @inline(never) func sumReduce(_ a: [Int]) -> Int { a.reduce(0, +) } @inline(never) func sumForInWrapping(_ a: [Int]) -> Int { var s = 0; for x in a { s &+= x }; return s } @inline(never) func sumReduceWrapping(_ a: [Int]) -> Int { a.reduce(0, &+) } do { var rng = LCG(state: UInt64(seed)) for (label, n, reps) in [("10k Ints (fits in cache)", 10_000, 1_000), ("10M Ints (80 MB)", 10_000_000, 1)] { let a = (0.. Int)] = [ ("for x in a { s += x }", sumForIn), ("for i in 0..(_ keys: [K], _ values: [Int], _ probes: [K]) -> Int { var s = 0 for p in probes { s &+= values[keys.firstIndex(of: p)!] } return s } @inline(never) func lookupDict(_ dict: [K: Int], _ probes: [K]) -> Int { var s = 0 for p in probes { s &+= dict[p]! } return s } func crossover(_ label: String, _ makeKey: (Int) -> K) { let m = 200_000 // lookups per repetition, keys chosen at random from the n keys for n in [1, 2, 4, 8, 16, 32, 64, 128, 256] { let keys = (0..