Optimizing your Swift code

try! Swift 2023 Tokyo Meetup https://tryswift.jp/
https://youtu.be/ILWnstd-XOY?t=9036

Transcript

1. Yuta Saito (@kateinoigakukun) 2023/01/21 Optimizing your Swift code try! Swift 2023 Tokyo Meetup
2. • Yuta Saito / @kateinoigakukun • Waseda University B4 • Working at • Maintainer of SwiftWasm • Commiter to Swift / LLVM / CRuby About me
3. https://www.goodnotes.com/windows
4. Outline 1. Motivation: Why is performance important for us? 2. Background: Why is Swift “slow”? 3. Techniques: How to write compiler-friendly code 1. Pro fi le! Pro fi le!! Pro fi le!!! 2. Reduce dynamic dispatch 3. Reveal hidden CoW cost 4. Value operation cost
5. 1. Motivation:
 Why is performance important for us?
6. Motivation When/Where does performance matter? • Apps sensitive to frame dropping • Most apps don’t need to care • Game App, Camera App, etc… • 1 frame must be done within 16ms (60fps) or 8ms (120fps)
7. Motivation When/Where does performance matter? Non-optimized WebAssembly is still slow • V8 has two AOT compilers*1: • Baseline (Lifto ff ) • Optimizing (TurboFan) • Baseline is about 2x slower 😣 *1: https://v8.dev/docs/wasm-compilation-pipeline
8. Motivation GoodNotes’ Ink algorithm Compute Curve
9. 2. Background: Why is Swift “slow”?
10. Why is Swift “slow”? https://benchmarksgame-team.pages.debian.net/benchmarksgame/box-plot-summary-charts.html
11. Why is Swift “slow”? • Tend to be slower than C/C++ • High-level language features • ARC (Automatic Reference Counting) • CoW (Copy-on-Write) • Protocol • Short code can have large hidden cost
12. Why is Swift “slow”? Automatic Reference Counting class Animal { func bark() {} } class Cat: Animal { override func bark() { print("meow") } } let cat = Cat() let animal = cat as Animal animal.bark() Q. Where retain/release will be placed?
13. Why is Swift “slow”? Automatic Reference Counting class Animal { func bark() {} } class Cat: Animal { override func bark() { print("meow") } } let cat = Cat() // retain(cat) let animal = cat as Animal animal.bark() // release(animal) // release(cat) Q. Where retain/release will be placed? A. → Hidden cost!!
14. 3. Techniques:
 How to write compiler-friendly code
15. What do you mean “compiler-friendly”? • Easy for compilers to optimize • Compilers can optimize only a set of program patterns • Hand-annotated restriction would help compiler to optimize
16. Profile! Profile!! Profile!!! Performance is often bound by non-CPU work • GPU • Alpha blending • Event latency • Blocking IO • Disk IO • Network IO Do we really need to optimize CPU work?
17. Instruments.app • Go https://help.apple.com/instruments/mac/
18. Reduce dynamic dispatch Dynamic dispatch happens when: • Method called through class instances • Method called through protocol types
19. Reduce dynamic dispatch • Avoid open access modi fi er open class Animal { open func bark() {} } func useAnimal(_ x: Animal) { x.bark() // Animal.bark can be overridden outside the module } • Check if compiler can know the callee method at compile-time 🧐 • Use small type as much as possible (Cat < Animal < Any) Class instance methods
20. Reduce dynamic dispatch • Avoid existential container to be specialization-friendly func usePingable(_ x: Pingable) { x.ping() } // Better if possible 👍 func usePingable(_ x: some Pingable) { x.ping() } Protocol methods
21. Reduce dynamic dispatch Protocol methods Module A Module B public func usePingable(_ x: some Pingable) { x.ping() } import ModuleA Cannot remove dynamic dispatch 😣 struct PingableImpl: Pingable { ... } usePingable(PingableImpl())
22. Reduce dynamic dispatch Protocol methods Module A Module B import ModuleA public struct PingableImpl: Pingable { ... } usePingable(PingableImpl()) @_specialize(where X == PingableImpl) public func usePingable(_ x: some Pingable) { x.ping() } No dynamic dispatch! 💨
23. Reveal hidden CoW cost func computeCurve(newEvents: [Event]) -> Curve { var allPoints = self.points for event in newEvents { allPoints.append(event.point) } let tails = Array(allPoints.suffix(3)) return Curve(p0: tails[0], p1: tails[1], p2: tails[2]) } ⚠ Large copy ⚠ Temporary Array allocation
24. Reveal hidden CoW cost func computeCurve(newEvents: [Event]) -> Curve { let p0, p1, p2: Point switch newEvents.count { case 0: p0 = self.points[self.points.count - 3] p1 = self.points[self.points.count - 2] p2 = self.points[self.points.count - 1] case 1: p0 = self.points[self.points.count - 2] p1 = self.points[self.points.count - 1] p2 = newEvents[0].point case 2: p0 = self.points[self.points.count - 1] p1 = newEvents[0].point p2 = newEvents[1].point default: p0 = newEvents[newEvents.count - 3].point p1 = newEvents[newEvents.count - 2].point p2 = newEvents[newEvents.count - 1].point } return Curve(p0: p0, p1: p1, p2: p2) }
25. Reveal hidden CoW cost https://forums.swift.org/t/in-place-mutation-of-an-enum-associated-value/11747 enum JSON { case string(String) case array([JSON]) } func appendString(json: inout JSON) { switch json { case .array(var array): array.append(.string("extra string”)) json = .array(json) default: break } } ⚠ Sharing the same storage ⚠ CoW triggered!
26. Reveal hidden CoW cost https://forums.swift.org/t/in-place-mutation-of-an-enum-associated-value/11747 enum JSON { case string(String) // case array([JSON]) case array(Box<[JSON]>) } func appendString(json: inout JSON) { switch json { case .array(let array): array.value.append(.string(“extra string”)) default: break } } 🤔 Wrapped with Box to be uniquely referenced
27. Value operation cost • Struct copy is cheap only when the struct type is trivial • Trivial Types (POD: Plain Old Data): No extra copy, move, destruction semantics • Int, Bool, Double, … • A struct type that consists of trivial types • Many container types in stdlib (Array, Set, …) has fast-path for trivial types • Optimized to be a memcpy
28. Value operation cost class Owner { ... } struct Item { // non-trivial let id: Int // trivial let owner: Owner // non-trivial } var newItems = self.items // for item in newItems { // retain(item.owner) // } // memcpy(self.items, newItems) newItems.append(Item(...)) ⚠ Non-trivial copy operation struct Owner {} struct Item { // trivial let id: Int // trivial let owner: Owner // trivial } var newItems = self.items // memcpy(self.items, newItems) newItems.append(Item(...)) ✅ Relatively trivial copy operation
29. Value operation cost print(_isPOD(Int.self)) // true print(_isPOD(String.self)) // false print(_isPOD(Array<Int>.self)) // false struct Box<T> { let value: T } print(_isPOD(Box<Int>.self)) // true print(_isPOD(Box<String>.self)) // false Check a type is trivial or not by _isPOD
30. Summary • Swift has some hidden cost even in a short code • Understanding the underlying mechanism makes your code fast! • The GoodNotes’ Ink algorithm is now 7x faster! Before After 0 150 300 450 600 Benchmark Time (ms)
31. Resources • Low-level Swift optimization tips by Kelvin Ma
 https://swiftinit.org/articles/low-level-swift-optimization • Writing High-Performance Swift Code
 https://github.com/apple/swift/blob/main/docs/OptimizationTips.rst • Understanding Swift Performance - WWDC 2016
 https://developer.apple.com/videos/play/wwdc2016/416/