Question

我读到基于范围的循环在某些编程语言上具有更好的性能。是Swift的情况吗？例如在Playgroud：

func timeDebug(desc: String, function: ()->() )
{
    let start : UInt64 = mach_absolute_time()
    function()
    let duration : UInt64 = mach_absolute_time() - start

    var info : mach_timebase_info = mach_timebase_info(numer: 0, denom: 0)
    mach_timebase_info(&info)

    let total = (duration * UInt64(info.numer) / UInt64(info.denom)) / 1_000
    println("\(desc): \(total) µs.")
}

func loopOne(){
    for i in 0..<4000 {
        println(i);
    }
}

func loopTwo(){
    for var i = 0; i < 4000; i++ {
        println(i);
    }
}

基于范围的循环

timeDebug("Loop One time"){
    loopOne(); // Loop One time: 2075159 µs.
}

循环正常

timeDebug("Loop Two time"){
    loopTwo(); // Loop Two time: 1905956 µs.
}

如何在swift中正确进行基准测试？

//在设备上更新

首次运行

循环两次：54μs。

循环一次：482μs。

第二

循环两次：44μs。

循环一次：382μs。

第三

循环两次：43μs。

循环一次：419μs。

四

循环两次：44μs。

循环一次：399μs。

//更新2

    func printTimeElapsedWhenRunningCode(title:String, operation:()->()) {
        let startTime = CFAbsoluteTimeGetCurrent()
        operation()
        let timeElapsed = CFAbsoluteTimeGetCurrent() - startTime
        println("Time elapsed for \(title): \(timeElapsed) s")
    }


    printTimeElapsedWhenRunningCode("Loop Two time") {
        loopTwo(); // Time elapsed for Loop Two time: 4.10079956054688e-05 s
    }

    printTimeElapsedWhenRunningCode("Loop One time") {
        loopOne(); // Time elapsed for Loop One time: 0.000500023365020752 s.
    }

Answer 1

你不应该在游乐场做真正的基准，因为它们没有被优化。除非您对调试时需要多长时间感兴趣，否则您应该只对优化的构建进行基准测试（swiftc -O）。

要理解为什么基于范围的循环可以更快，您可以查看为这两个选项生成的程序集：

<强>基于范围

% echo "for i in 0..<4_000 { println(i) }" | swiftc -O -emit-assembly -
; snip opening boiler plate...
LBB0_1:
    movq    %rbx, -32(%rbp)
; increment i
    incq    %rbx
    movq    %r14, %rdi
    movq    %r15, %rsi
; print (pre-incremented) i
    callq   __TFSs7printlnU__FQ_T_
; compare i to 4_000
    cmpq    $4000, %rbx
; loop if not equal
    jne LBB0_1
    xorl    %eax, %eax
    addq    $8, %rsp
    popq    %rbx
    popq    %r14
    popq    %r15
    popq    %rbp
    retq
    .cfi_endproc

C风格for循环

% echo "for var i = 0;i < 4_000;++i { println(i) }" | swiftc -O -emit-assembly -
; snip opening boiler plate...
LBB0_1:
    movq    %rbx, -32(%rbp)
    movq    %r14, %rdi
    movq    %r15, %rsi
; print i
    callq   __TFSs7printlnU__FQ_T_
; increment i
    incq    %rbx
; jump if overflow
    jo  LBB0_4
; compare i to 4_000
    cmpq    $4000, %rbx
; loop if less than
    jl  LBB0_1
    xorl    %eax, %eax
    addq    $8, %rsp
    popq    %rbx
    popq    %r14
    popq    %r15
    popq    %rbp
    retq
LBB0_4:
; raise illegal instruction due to overflow
    ud2
    .cfi_endproc

因此C风格循环较慢的原因是因为它正在执行额外的操作 - 检查溢出。编写Range以避免溢出检查（或预先执行此操作），或者优化程序更能够使用Range版本将其消除。

如果切换到使用免检加法运算符，则可以取消此检查。这会产生与基于范围的版本几乎相同的代码（唯一的区别是代码的一些非物质排序）：

% echo "for var i = 0;i < 4_000;i = i &+ 1 { println(i) }" | swiftc -O -emit-assembly -
; snip
LBB0_1:
    movq    %rbx, -32(%rbp)
    movq    %r14, %rdi
    movq    %r15, %rsi
    callq   __TFSs7printlnU__FQ_T_
    incq    %rbx
    cmpq    $4000, %rbx
    jne LBB0_1
    xorl    %eax, %eax
    addq    $8, %rsp
    popq    %rbx
    popq    %r14
    popq    %r15
    popq    %rbp
    retq
    .cfi_endproc

从未对未经优化的构建进行基准测试

如果您想了解原因，请尝试查看基于Range的上述版本的输出，但不进行优化：echo "for var i = 0;i < 4_000;++i { println(i) }" | swiftc -Onone -emit-assembly -。您将看到它输出 lot 更多代码。这是因为通过Range使用的for…in是一个抽象，一个用于返回生成器的自定义运算符和函数的结构，并且做了很多安全检查和其他有用的事情。这使得 lot 更容易编写/读取代码。但是当你打开优化器时，所有这一切都会消失，你会得到非常高效的代码。

基准

关于基准测试的方法，这是我倾向于使用的代码，只需替换数组：

import CoreFoundation.CFDate

func timeRun<T>(name: String, f: ()->T) -> String {
    let start = CFAbsoluteTimeGetCurrent()
    let result = f()
    let end = CFAbsoluteTimeGetCurrent()
    let timeStr = toString(Int((end - start) * 1_000_000))
    return "\(name)\t\(timeStr)µs, produced \(result)"
}

let n = 4_000

let runs: [(String,()->Void)] = [
    ("for in range", {
        for i in 0..<n { println(i) }    
    }),
    ("plain ol for", {
        for var i = 0;i < n;++i { println(i) }    
    }),
    ("w/o overflow", {
        for var i = 0;i < n;i = i &+ 1 { println(i) }    
    }),
]

println("\n".join(map(runs, timeRun)))

但结果可能毫无意义，因为println期间的抖动可能会模糊实际测量。要真正进行基准测试（假设您不仅仅相信汇编分析:)，您需要将其替换为非常轻量级的东西。

循环和范围操作符的基准

1 个答案:

从未对未经优化的构建进行基准测试

基准