Missed optimization opportunity?

Development Standard Library
23

I'm not sure if I misunderstand something but here's what I see (using the program below, modified and compiled according to the diagram):

//                         |    within test func    |       top-level        |
//                         |                        |                        |
//                         | .nextDown : .magnitude | .nextDown : .magnitude |
// ------------------------+-----------+------------+-----------+------------+
// Xcode 9.4 def toolchain |     9     :   4e-08    |     9     :   4e-08    |
// ------------------------+-----------+------------+-----------+------------+
// Dev Snapshot 2018-05-30 |   4e-08   :   4e-08    |    0.08   :   4e-08    |
// ------------------------+-----------+------------+-----------+------------+
//
// My interpretation:
//
// 9 seconds means something needs fixing.
// 0.08 seconds means it has been *partly* fixed.
// 4e-08 seconds means it has been fixed.

import AppKit

//func test() {
    let a = Double(1)
    
    var checksum = UInt64(0)
    var minTime = Double.infinity
    for trial in 0 ..< 5 {
        print("#\(trial)")
        let start = CACurrentMediaTime()
        for _ in 0 ..< 1_000_000_000 {
            let v = a.nextDown // <-- Replace with `a.magnitude`, see time diff.
            checksum = checksum &+ v.bitPattern
        }
        let stop = CACurrentMediaTime()
        let time = stop - start
        print("  time:", time, "seconds (checksum: \(checksum)")
        minTime = min(time, minTime)
    }
    print("\nmin time:", minTime, "seconds")
//}
//test()

Note that:

  • 9 seconds is the time for the .nextDown case, using Xcode 9.4 def toolchain, no matter if top level or in func.
  • 0.08 seconds is about 100 times faster than that (9 / 0.08 == 112.5).
  • 4e-08 seconds is still millions of times faster than that (0.08 / 4e-08 == 2_000_000).

so 0.08 seconds (most recent snapshot, for the .nextDown case, code at top level) is still millions of times slower than what it should be if it was entirely fixed, ie the same as for the .magnitude case: 4e-08 seconds. (My guess is that: While the a.nextDown calculation is being hoisted out of the loop, the further optimization of turning all the &+ operations into a single multiplication isn't being performed, but it is in the .magnitude case.)

This is why I wrote:

And by "equally fast", I mean both should be like .magnitude, which is 4e-08 seconds, not 0.08 seconds

1 Like