simple nanosecond timer using mach_absolute_time

Timer.swift

/*
    var t = Timer()
    
    t.start()
    // do something
    t.stop()

    print("took \(t.seconds)")
*/

import Darwin

struct Timer {
    var startTime: UInt64 = 0
    var stopTime: UInt64 = 0
    let numer: UInt64
    let denom: UInt64

    init() {
        var info = mach_timebase_info(numer: 0, denom: 0)
        mach_timebase_info(&info)
        numer = UInt64(info.numer)
        denom = UInt64(info.denom)
    }

    mutating func start() {
        startTime = mach_absolute_time()
    }

    mutating func stop() {
        stopTime = mach_absolute_time()
    }

    var nanoseconds: UInt64 {
        return ((stopTime - startTime) * numer) / denom
    }

    var milliseconds: Double {
        return Double(nanoseconds) / 1_000_000
    }

    var seconds: Double {
        return Double(nanoseconds) / 1_000_000_000
    }
}

Don't want to tread on anyone's toes here, but I've made my own implementation of the timer with a few advantages here: https://gist.github.com/LK-Simon/d1f5979c54a064871e4eea7ff2e4abf8

It provides the ability to take point-in-time readings from an "Active" timer... oh, and it includes the concept of "State" (Running and NotRunning) which are used to determine whether the code needs the point-in-time reading, or a "final" reading (when the timer is stopped).

Additionally, mine returns a struct containing the nanosecond value and property-decorated functions to return it in milliseconds and seconds. This means you can take multiple readings, retain them in the struct, use them as you wish, then dispose them as necessary (garbage collection will do this when they are dereferenced)

Finally, my implementation enables your code to feed in the mach time when calling start, stop, and result... so that you can take the reference time immediately at a point of execution, rather than whatever delay may occur when passing along a call stack.