---
source: ~/DuckDuckGo/apple-browsers.git/main/.cursor/rules/performance-optimization.mdc
confidence: 0.9
namespace: work
last_synced: 2026-04-28
alwaysApply: false
---

# Performance Optimization Guidelines

## Memory Management

### Avoid Retain Cycles
```swift
// Use weak/unowned references appropriately
class ViewController: UIViewController {
    private var timer: Timer?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Bad - Creates retain cycle
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
            self.updateUI()
        }
        
        // Good - Weak reference prevents retain cycle
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            self?.updateUI()
        }
    }
    
    deinit {
        timer?.invalidate()
    }
}
```

### Lazy Loading
```swift
class DataManager {
    // Load expensive resources only when needed
    private lazy var database: Database = {
        return Database()
    }()
    
    // Use computed properties for lightweight calculations
    var itemCount: Int {
        return items.count
    }
    
    // Cache expensive computations
    private var _processedData: [ProcessedItem]?
    var processedData: [ProcessedItem] {
        if let cached = _processedData {
            return cached
        }
        let processed = items.map { ProcessedItem($0) }
        _processedData = processed
        return processed
    }
}
```

### Memory-Efficient Collections
```swift
// Use appropriate collection types
struct LargeDataSet {
    // Bad - Loads all data into memory
    var allItems: [Item] {
        return database.fetchAll()
    }
    
    // Good - Use lazy sequences
    var items: LazySequence<[Item]> {
        return database.fetchAll().lazy
    }
    
    // Better - Use pagination
    func items(page: Int, pageSize: Int = 50) -> [Item] {
        return database.fetch(offset: page * pageSize, limit: pageSize)
    }
}
```

## UI Performance

### Main Thread Protection
```swift
class ImageLoader {
    func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {
        Task {
            // Perform heavy work on background queue
            let data = try? await URLSession.shared.data(from: url).0
            let image = data.flatMap { UIImage(data: $0) }
            
            // Always update UI on main thread
            await MainActor.run {
                completion(image)
            }
        }
    }
}
```

### Efficient Table/Collection Views
```swift
class OptimizedTableViewController: UITableViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Register reusable cells
        tableView.register(CustomCell.self, forCellReuseIdentifier: "Cell")
        
        // Set estimated heights for better scrolling
        tableView.estimatedRowHeight = 44.0
        tableView.rowHeight = UITableView.automaticDimension
        
        // Enable prefetching
        tableView.prefetchDataSource = self
    }
    
    // Reuse cells efficiently
    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) as! CustomCell
        
        // Configure cell with minimal work
        cell.configure(with: items[indexPath.row])
        
        // Cancel any ongoing async work
        cell.prepareForReuse()
        
        return cell
    }
}

extension OptimizedTableViewController: UITableViewDataSourcePrefetching {
    func tableView(_ tableView: UITableView, prefetchRowsAt indexPaths: [IndexPath]) {
        // Preload data for upcoming cells
        let urls = indexPaths.compactMap { items[$0.row].imageURL }
        ImageCache.shared.preload(urls: urls)
    }
}
```

### Image Optimization
```swift
extension UIImage {
    // Resize images to appropriate size
    func resized(to targetSize: CGSize) -> UIImage? {
        let renderer = UIGraphicsImageRenderer(size: targetSize)
        return renderer.image { _ in
            self.draw(in: CGRect(origin: .zero, size: targetSize))
        }
    }
    
    // Decode images on background queue
    func decodedImage() -> UIImage? {
        guard let cgImage = cgImage else { return nil }
        
        let colorSpace = CGColorSpaceCreateDeviceRGB()
        let context = CGContext(
            data: nil,
            width: cgImage.width,
            height: cgImage.height,
            bitsPerComponent: 8,
            bytesPerRow: cgImage.width * 4,
            space: colorSpace,
            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
        )
        
        context?.draw(cgImage, in: CGRect(x: 0, y: 0, width: cgImage.width, height: cgImage.height))
        
        guard let decodedImage = context?.makeImage() else { return nil }
        return UIImage(cgImage: decodedImage)
    }
}
```

## Network Performance

### Efficient API Calls
```swift
class APIClient {
    private let session: URLSession
    private let cache = URLCache(
        memoryCapacity: 10 * 1024 * 1024,  // 10 MB
        diskCapacity: 50 * 1024 * 1024,     // 50 MB
        diskPath: nil
    )
    
    init() {
        let configuration = URLSessionConfiguration.default
        configuration.urlCache = cache
        configuration.requestCachePolicy = .returnCacheDataElseLoad
        configuration.timeoutIntervalForRequest = 30
        configuration.httpMaximumConnectionsPerHost = 5
        
        self.session = URLSession(configuration: configuration)
    }
    
    // Batch requests when possible
    func fetchMultipleItems(ids: [String]) async throws -> [Item] {
        // Bad - Multiple individual requests
        // let items = try await ids.asyncMap { try await fetchItem(id: $0) }
        
        // Good - Single batch request
        let request = BatchRequest(ids: ids)
        return try await fetch(request)
    }
    
    // Use compression
    func createRequest(url: URL) -> URLRequest {
        var request = URLRequest(url: url)
        request.addValue("gzip, deflate", forHTTPHeaderField: "Accept-Encoding")
        return request
    }
}
```

### Download Optimization
```swift
class DownloadManager {
    // Use background sessions for large downloads
    private lazy var backgroundSession: URLSession = {
        let configuration = URLSessionConfiguration.background(withIdentifier: "com.duckduckgo.downloads")
        configuration.isDiscretionary = true
        configuration.sessionSendsLaunchEvents = true
        return URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
    }()
    
    // Resume interrupted downloads
    func resumeDownload(from resumeData: Data) {
        let task = backgroundSession.downloadTask(withResumeData: resumeData)
        task.resume()
    }
    
    // Limit concurrent downloads
    private let downloadQueue = OperationQueue()
    
    init() {
        downloadQueue.maxConcurrentOperationCount = 3
    }
}
```

## Database Performance

### Efficient Queries
```swift
import GRDB

class DatabaseManager {
    // Use indexes for frequently queried columns
    func createIndexes(_ db: Database) throws {
        try db.create(index: "idx_bookmarks_url", on: "bookmarks", columns: ["url"])
        try db.create(index: "idx_history_date", on: "history", columns: ["visitDate"])
    }
    
    // Batch operations
    func insertMultipleItems(_ items: [Item]) throws {
        try dbQueue.write { db in
            // Use transactions for bulk operations
            try items.forEach { item in
                try item.insert(db)
            }
        }
    }
    
    // Use appropriate fetch limits
    func fetchRecentHistory(limit: Int = 100) throws -> [HistoryItem] {
        try dbQueue.read { db in
            try HistoryItem
                .order(Column("visitDate").desc)
                .limit(limit)
                .fetchAll(db)
        }
    }
    
    // Optimize complex queries
    func searchBookmarks(query: String) throws -> [Bookmark] {
        try dbQueue.read { db in
            // Use FTS (Full Text Search) for text searching
            let pattern = "%\(query)%"
            return try Bookmark
                .filter(Column("title").like(pattern) || Column("url").like(pattern))
                .limit(50)
                .fetchAll(db)
        }
    }
}
```

## Algorithm Optimization

### Use Efficient Data Structures
```swift
// Choose appropriate data structures
class URLMatcher {
    // Bad - O(n) lookup
    private var blockedURLs: [String] = []
    
    func isBlocked(_ url: String) -> Bool {
        return blockedURLs.contains(url)
    }
    
    // Good - O(1) lookup
    private var blockedURLSet: Set<String> = []
    
    func isBlockedOptimized(_ url: String) -> Bool {
        return blockedURLSet.contains(url)
    }
}
```

### Avoid Expensive Operations
```swift
extension Array {
    // Bad - Creates multiple intermediate arrays
    func processItems() -> [ProcessedItem] {
        return self
            .compactMap { $0 as? Item }
            .filter { $0.isValid }
            .map { ProcessedItem($0) }
            .sorted { $0.priority > $1.priority }
    }
    
    // Good - Use lazy evaluation
    func processItemsOptimized() -> [ProcessedItem] {
        return self.lazy
            .compactMap { $0 as? Item }
            .filter { $0.isValid }
            .map { ProcessedItem($0) }
            .sorted { $0.priority > $1.priority }
    }
}
```

## Monitoring and Profiling

### Performance Metrics
```swift
class PerformanceMonitor {
    static func measure<T>(
        _ title: String,
        operation: () throws -> T
    ) rethrows -> T {
        let startTime = CFAbsoluteTimeGetCurrent()
        defer {
            let timeElapsed = CFAbsoluteTimeGetCurrent() - startTime
            print("⏱ \(title): \(timeElapsed)s")
            
            // Log slow operations
            if timeElapsed > 1.0 {
                Pixel.fire(.performanceWarning(operation: title, duration: timeElapsed))
            }
        }
        return try operation()
    }
}

// Usage
let results = PerformanceMonitor.measure("Database Query") {
    try database.fetchAllBookmarks()
}
```

### Memory Monitoring
```swift
class MemoryMonitor {
    static var currentMemoryUsage: Double {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size) / 4
        
        let result = withUnsafeMutablePointer(to: &info) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(mach_task_self_,
                         task_flavor_t(MACH_TASK_BASIC_INFO),
                         $0,
                         &count)
            }
        }
        
        return result == KERN_SUCCESS ? Double(info.resident_size) / 1024.0 / 1024.0 : 0
    }
    
    static func logMemoryUsage(_ context: String) {
        let usage = currentMemoryUsage
        print("💾 Memory usage (\(context)): \(usage) MB")
        
        if usage > 200 { // 200 MB threshold
            Pixel.fire(.highMemoryUsage(context: context, usage: usage))
        }
    }
}
```

## Best Practices Summary

1. **Profile First**: Use Instruments to identify actual bottlenecks
2. **Measure Impact**: Quantify performance improvements
3. **Cache Wisely**: Cache expensive computations but watch memory usage
4. **Async Everything**: Keep UI responsive with background processing
5. **Batch Operations**: Combine multiple operations when possible
6. **Lazy Loading**: Load data only when needed
7. **Resource Management**: Release resources promptly
8. **Monitor Production**: Track performance metrics in production