Performance Profiling

// Batch multiple IDs into single request
func fetchUsers(ids: [String]) {
    let batchedIDs = ids.joined(separator: ",")
    api.get("/users?ids=\(batchedIDs)")
}

// Implement cursor-based pagination
func fetchFeed(cursor: String? = nil, limit: Int = 20) {
    var params = ["limit": limit]
    if let cursor = cursor {
        params["cursor"] = cursor
    }
    api.get("/feed", parameters: params)
}

// Cache with expiration
class APICache {
    private var cache: [String: CachedResponse] = [:]

    func get(url: String) -> Data? {
        guard let cached = cache[url],
              !cached.isExpired else { return nil }
        return cached.data
    }

    func set(url: String, data: Data, ttl: TimeInterval = 300) {
        cache[url] = CachedResponse(data: data, expiry: Date() + ttl)
    }
}

// Prevent duplicate in-flight requests
class RequestCoalescer {
    private var inFlightRequests: [String: Task<Data, Error>] = [:]

    func request(url: String) async throws -> Data {
        if let existing = inFlightRequests[url] {
            return try await existing.value
        }

        let task = Task {
            let data = try await performRequest(url)
            inFlightRequests[url] = nil
            return data
        }

        inFlightRequests[url] = task
        return try await task.value
    }
}

Total Time | Self Time | Symbol
-----------|-----------|--------
  1000ms   |   10ms    | -[UITableView reloadData]
   800ms   |   50ms    |  └─ -[MyCell configure]
   700ms   |  700ms    |     └─ -[ImageProcessor processImage]

[                    main                    ] ← 100% of time
[       viewDidLoad       ][    updateUI    ] ← 50% each
[loadData][parseJSON]      [layout][render] ← Breakdown

ViewController → (strong) Closure → (strong) ViewController

// Before (leak)
viewModel.onUpdate = {
    self.updateUI()
}

// After (no leak)
viewModel.onUpdate = { [weak self] in
    self?.updateUI()
}

func testLaunchPerformance() throws {
    measure(metrics: [XCTApplicationLaunchMetric()]) {
        XCUIApplication().launch()
    }
}

func testScrollPerformance() throws {
    let app = XCUIApplication()
    app.launch()

    measure(metrics: [XCTOSSignpostMetric.scrollDecelerationMetric]) {
        app.tables.firstMatch.swipeUp()
    }
}

{
  "launch_time_ms": 350,
  "memory_mb": 120,
  "scroll_fps": 59,
  "thresholds": {
    "launch_time_ms": 450,
    "memory_mb": 150,
    "scroll_fps": 55
  }
}

// Problem: Heavy work on main thread
DispatchQueue.main.async {
    let result = expensiveCalculation() // Blocks UI
    updateUI(with: result)
}

// Solution: Move work off main thread
DispatchQueue.global(qos: .userInitiated).async {
    let result = expensiveCalculation()
    DispatchQueue.main.async {
        updateUI(with: result)
    }
}

// Problem: Constant polling
Timer.scheduledTimer(withTimeInterval: 0.01, repeats: true) { _ in
    checkForUpdates() // Called 100 times per second!
}

// Solution: Reasonable interval or event-driven
Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
    checkForUpdates() // Called once per second
}

// Problem: O(n²) complexity
for item in items {
    for other in items {
        compare(item, other) // n² comparisons
    }
}

// Solution: O(n log n) or O(n)
let sorted = items.sorted()
for (item, other) in zip(sorted, sorted.dropFirst()) {
    compare(item, other) // n comparisons
}

// Problem: Cache grows indefinitely
class ImageCache {
    private var cache: [URL: UIImage] = [:] // Never clears!
}

// Solution: Use NSCache (auto-eviction)
class ImageCache {
    private let cache = NSCache<NSURL, UIImage>()

    init() {
        cache.countLimit = 100 // Max 100 images
    }
}

// Problem: Listeners never removed
override func viewWillAppear(_ animated: Bool) {
    NotificationCenter.default.addObserver(/* ... */) // Added every time!
}

// Solution: Remove in viewWillDisappear
override func viewWillDisappear(_ animated: Bool) {
    NotificationCenter.default.removeObserver(self)
}

// Problem: Keeping large objects in memory
class ViewController: UIViewController {
    var cachedImage: UIImage? // Large image retained
}

// Solution: Cache only when needed, clear when done
class ViewController: UIViewController {
    private var cachedImage: UIImage?

    override func didReceiveMemoryWarning() {
        cachedImage = nil // Release when memory pressure
    }
}

// Problem: Sequential dependent requests
func loadProfile() async {
    let user = await fetchUser() // Wait...
    let posts = await fetchPosts(for: user) // Wait...
    let comments = await fetchComments(for: posts) // Wait...
}

// Solution: Parallel independent requests
func loadProfile() async {
    async let user = fetchUser()
    async let followers = fetchFollowers()
    async let settings = fetchSettings()

    let (u, f, s) = await (user, followers, settings)
}

// Problem: Same request made multiple times
func loadData() {
    fetchUsers() // Request 1
    fetchUsers() // Request 2 (redundant!)
}

// Solution: Deduplicate requests
class APIClient {
    private var pendingRequests: [String: Task<Data, Error>] = [:]

    func fetch(url: String) async throws -> Data {
        if let pending = pendingRequests[url] {
            return try await pending.value // Reuse
        }

        let task = Task { try await URLSession.shared.data(from: URL(string: url)!) }
        pendingRequests[url] = task
        defer { pendingRequests[url] = nil }
        return try await task.value
    }
}

// Problem: Sending/receiving uncompressed data
URLSession.shared.dataTask(with: url) // Default: no compression

// Solution: Enable compression
var request = URLRequest(url: url)
request.setValue("gzip, deflate", forHTTPHeaderField: "Accept-Encoding")
URLSession.shared.dataTask(with: request)

// Problem: Constant background work
func applicationDidEnterBackground(_ application: UIApplication) {
    Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
        syncData() // Drains battery in background
    }
}

// Solution: Use background tasks properly
func applicationDidEnterBackground(_ application: UIApplication) {
    let taskID = application.beginBackgroundTask {
        // Task expired, clean up
    }

    syncData {
        application.endBackgroundTask(taskID)
    }
}

// Problem: Always requesting location
locationManager.startUpdatingLocation() // Continuous GPS drain

// Solution: Use appropriate accuracy
locationManager.desiredAccuracy = kCLLocationAccuracyHundredMeters
locationManager.distanceFilter = 100 // Update every 100m
locationManager.startMonitoringSignificantLocationChanges() // Low power mode

// Problem: Animating hidden views
override func viewDidDisappear(_ animated: Bool) {
    // Animations keep running! Wastes CPU/battery
}

// Solution: Pause animations when offscreen
override func viewDidDisappear(_ animated: Bool) {
    animationView.layer.pauseAnimations()
}

extension CALayer {
    func pauseAnimations() {
        let pausedTime = convertTime(CACurrentMediaTime(), from: nil)
        speed = 0.0
        timeOffset = pausedTime
    }
}

# .github/workflows/performance.yml
name: Performance Tests

on: [pull_request]

jobs:
  performance:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v2

      - name: Run performance tests
        run: xcodebuild test -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 15'

      - name: Check for regressions
        run: ./scripts/check_performance_baseline.sh

class PerformanceTests: XCTestCase {
    func testLaunchPerformance() {
        measure(metrics: [XCTApplicationLaunchMetric()]) {
            XCUIApplication().launch()
        }
    }

    func testMemoryUsage() {
        let app = XCUIApplication()
        app.launch()

        measure(metrics: [XCTMemoryMetric()]) {
            // Perform memory-intensive operations
            for _ in 0..<100 {
                app.buttons["Load"].tap()
            }
        }
    }
}

// PerformanceBudgets.swift
enum PerformanceBudget {
    static let launchTime: TimeInterval = 0.4 // 400ms
    static let memoryFootprint: Int = 150 * 1024 * 1024 // 150MB
    static let scrollFrameTime: TimeInterval = 0.0167 // 16.67ms (60 FPS)
    static let networkRequestTimeout: TimeInterval = 5.0 // 5s
}

// Enforce in tests
func testLaunchBudget() {
    let launchTime = measureLaunchTime()
    XCTAssertLessThan(launchTime, PerformanceBudget.launchTime,
                      "Launch time exceeded budget: \(launchTime)s > \(PerformanceBudget.launchTime)s")
}

{
  "operation": "build",
  "scheme": "MyApp",
  "configuration": "Release",
  "destination": "platform=iOS,id=<device-udid>",
  "options": {
    "clean_before_build": true
  }
}

xcodebuild archive \
  -scheme MyApp \
  -configuration Release \
  -archivePath ./build/MyApp.xcarchive

xcodebuild -exportArchive \
  -archivePath ./build/MyApp.xcarchive \
  -exportPath ./build \
  -exportOptionsPlist ExportOptions.plist