How much slower is a Debug (-Onone) build than Release (-O), why, and what does that mean for profiling and for what you ship?

Predict first

Build one workload with -Onone and -O (the program invokes swiftc itself) and compare.

import Foundation

let workload = """
import Foundation
struct P { var x: Double; var y: Double }
func total<C: Collection>(_ c: C) -> Double where C.Element == P { c.reduce(0) { $0 + $1.x * $1.y } }
let pts = (0..<1000).map { P(x: Double($0), y: 1.5) }
var acc = 0.0
let t = DispatchTime.now()
for _ in 0..<2000 { acc += total(pts.lazy.filter { $0.x > 10 }.map { P(x: $0.x, y: $0.y + 1) }) }
print(Double(DispatchTime.now().uptimeNanoseconds - t.uptimeNanoseconds) / 1e6, acc > 0)
"""
let dir = NSTemporaryDirectory() + "optcmp-\(getpid())"
try? FileManager.default.createDirectory(atPath: dir, withIntermediateDirectories: true)
try! workload.write(toFile: dir + "/w.swift", atomically: true, encoding: .utf8)

func run(_ exe: String, _ args: [String]) -> String {
    let p = Process(), out = Pipe()
    p.executableURL = URL(fileURLWithPath: exe); p.arguments = args; p.standardOutput = out
    try! p.run(); p.waitUntilExit()
    return String(decoding: out.fileHandleForReading.readDataToEndOfFile(), as: UTF8.self)
}
var times: [String: Double] = [:]
for flag in ["-Onone", "-O"] {
    _ = run("/usr/bin/swiftc", [flag, dir + "/w.swift", "-o", dir + "/w\(flag)"])
    times[flag] = (0..<3).map { _ in Double(run(dir + "/w\(flag)", []).split(separator: " ")[0])! }.min()!
}
print("the same source built with -Onone is more than 5x slower than -O:", times["-Onone"]! > 5 * times["-O"]!)
try? FileManager.default.removeItem(atPath: dir)

• the same source built with -Onone is more than 5x slower than -O: true
• The two builds run at the same speed
• -Onone is faster because it skips optimisation work