Zmierz upływający czas w Swift

Jak możemy zmierzyć czas, który upłynął do uruchomienia funkcji w języku Swift? Próbuję wyświetlić upływający czas w następujący sposób: „Upłynęło 0,05 sekundy”. Widziałem, że w Javie możemy użyć System.nanoTime (), czy w języku Swift są dostępne równoważne metody, aby to osiągnąć?

Proszę spojrzeć na przykładowy program:

func isPrime(var number:Int) ->Bool {
    var i = 0;
    for i=2; i<number; i++ {
        if(number % i == 0 && i != 0) {
            return false;
        }
    }
    return true;
}

var number = 5915587277;

if(isPrime(number)) {
    println("Prime number");
} else {
    println("NOT a prime number");
}

Oto funkcja języka Swift, którą napisałem, aby zmierzyć problemy projektu Euler w języku Swift

Od wersji Swift 3 dostępna jest teraz wersja Grand Central Dispatch, która jest „szybka”. Zatem prawidłowa odpowiedź to prawdopodobnie użycie interfejsu API DispatchTime .

Moja funkcja wyglądałaby tak:

// Swift 3
func evaluateProblem(problemNumber: Int, problemBlock: () -> Int) -> Answer
{
    print("Evaluating problem \(problemNumber)")

    let start = DispatchTime.now() // <<<<<<<<<< Start time
    let myGuess = problemBlock()
    let end = DispatchTime.now()   // <<<<<<<<<<   end time

    let theAnswer = self.checkAnswer(answerNum: "\(problemNumber)", guess: myGuess)

    let nanoTime = end.uptimeNanoseconds - start.uptimeNanoseconds // <<<<< Difference in nano seconds (UInt64)
    let timeInterval = Double(nanoTime) / 1_000_000_000 // Technically could overflow for long running tests

    print("Time to evaluate problem \(problemNumber): \(timeInterval) seconds")
    return theAnswer
}

Stara odpowiedź

W przypadku Swift 1 i 2 moja funkcja używa NSDate:

// Swift 1
func evaluateProblem(problemNumber: Int, problemBlock: () -> Int) -> Answer
{
    println("Evaluating problem \(problemNumber)")

    let start = NSDate() // <<<<<<<<<< Start time
    let myGuess = problemBlock()
    let end = NSDate()   // <<<<<<<<<<   end time

    let theAnswer = self.checkAnswer(answerNum: "\(problemNumber)", guess: myGuess)

    let timeInterval: Double = end.timeIntervalSinceDate(start) // <<<<< Difference in seconds (double)

    println("Time to evaluate problem \(problemNumber): \(timeInterval) seconds")
    return theAnswer
}

_{Należy zwrócić uwagę, że używanie NSdate do funkcji czasowych jest odradzane: „ Czas systemowy może ulec skróceniu z powodu synchronizacji z zewnętrznymi odniesieniami czasu lub z powodu jawnej zmiany zegara przez użytkownika. ”.}

To jest przydatna klasa timera oparta na CoreFoundations CFAbsoluteTime:

import CoreFoundation

class ParkBenchTimer {

    let startTime:CFAbsoluteTime
    var endTime:CFAbsoluteTime?

    init() {
        startTime = CFAbsoluteTimeGetCurrent()
    }

    func stop() -> CFAbsoluteTime {
        endTime = CFAbsoluteTimeGetCurrent()

        return duration!
    }

    var duration:CFAbsoluteTime? {
        if let endTime = endTime {
            return endTime - startTime
        } else {
            return nil
        }
    }
}

Możesz go używać w ten sposób:

let timer = ParkBenchTimer()

// ... a long runnig task ...

println("The task took \(timer.stop()) seconds.")

Użyj clock, ProcessInfo.systemUptimelub DispatchTimedla prostego czasu uruchamiania.

O ile wiem, istnieje co najmniej dziesięć sposobów mierzenia upływającego czasu:

Na podstawie zegara monotonicznego:

1. ProcessInfo.systemUptime.
2. mach_absolute_timez mach_timebase_infojak wspomniano w tej odpowiedzi .
3. clock()w standardzie POSIX .
4. times()w standardzie POSIX . (Zbyt skomplikowane, ponieważ musimy rozważyć czas użytkownika w porównaniu z czasem systemowym, a procesy potomne są zaangażowane).
5. DispatchTime (wrapper wokół Mach time API), jak wspomniał JeremyP w zaakceptowanej odpowiedzi.
6. CACurrentMediaTime().

Na podstawie zegara ściennego:

(nigdy nie używaj ich do pomiarów: zobacz poniżej, dlaczego)

7. NSDate/ Datejak wspominali inni.
8. CFAbsoluteTime jak wspominali inni.
9. DispatchWallTime.
10. gettimeofday()w standardzie POSIX .

Opcje 1, 2 i 3 omówiono poniżej.

Opcja 1: Process Info API w Foundation

do {
    let info = ProcessInfo.processInfo
    let begin = info.systemUptime
    // do something
    let diff = (info.systemUptime - begin)
}

gdzie diff:NSTimeIntervaljest upływający czas w sekundach.

Opcja 2: Mach C API

do {
    var info = mach_timebase_info(numer: 0, denom: 0)
    mach_timebase_info(&info)
    let begin = mach_absolute_time()
    // do something
    let diff = Double(mach_absolute_time() - begin) * Double(info.numer) / Double(info.denom)
}

gdzie diff:Doublejest upływający czas o nano-sekundy.

Opcja 3: API zegara POSIX

do {
    let begin = clock()
    // do something
    let diff = Double(clock() - begin) / Double(CLOCKS_PER_SEC)
}

gdzie diff:Doublejest upływający czas w sekundach.

Dlaczego nie czas na zegarze ściennym dla upływającego czasu?

W dokumentacji CFAbsoluteTimeGetCurrent:

Wielokrotne wywołania tej funkcji nie gwarantują monotonnie rosnących wyników.

Powód jest podobny do currentTimeMillisvs nanoTimew Javie :

Nie możesz użyć tego w innym celu. Powodem jest to, że żaden zegar komputera nie jest doskonały; zawsze dryfuje i od czasu do czasu wymaga korekty. Ta korekta może nastąpić ręcznie lub w przypadku większości komputerów działa proces, który nieustannie wprowadza niewielkie poprawki do zegara systemowego („zegar ścienny”). To zdarza się często. Kolejna taka korekta ma miejsce, gdy pojawia się sekunda przestępna.

Tutaj CFAbsoluteTimepodaje czas zegara ściennego zamiast czasu uruchomienia. NSDateto również zegar ścienny.

Szybka 4 najkrótsza odpowiedź:

let startingPoint = Date()
//  ... intensive task
print("\(startingPoint.timeIntervalSinceNow * -1) seconds elapsed")

Wydrukuje ci około 1.02107906341553 sekund, które upłynęły (czas oczywiście będzie się różnił w zależności od zadania, pokazuję to tylko, aby zobaczyć poziom dokładności dziesiętnej dla tego pomiaru).

Mam nadzieję, że od teraz pomoże to komuś w Swift 4!

Aktualizacja

Jeśli chcesz mieć ogólny sposób testowania fragmentów kodu, proponuję następny fragment:

func measureTime(for closure: @autoclosure () -> Any) {
    let start = CFAbsoluteTimeGetCurrent()
    closure()
    let diff = CFAbsoluteTimeGetCurrent() - start
    print("Took \(diff) seconds")
}

*Usage*

measureTime(for: <insert method signature here>)

**Console log**
Took xx.xxxxx seconds

let start = NSDate()

for index in 1...10000 {
    // do nothing
}

let elapsed = start.timeIntervalSinceNow

// elapsed is a negative value.

Po prostu skopiuj i wklej tę funkcję. Napisane w szybkim 5. Kopiowanie JeremyP tutaj.

func calculateTime(block : (() -> Void)) {
        let start = DispatchTime.now()
        block()
        let end = DispatchTime.now()
        let nanoTime = end.uptimeNanoseconds - start.uptimeNanoseconds
        let timeInterval = Double(nanoTime) / 1_000_000_000
        print("Time: \(timeInterval) seconds")
    }

Użyj tego jak

calculateTime {
     exampleFunc()// function whose execution time to be calculated
}

Możesz stworzyć timefunkcję do mierzenia połączeń. Inspiruje mnie odpowiedź Klaasa .

func time <A> (f: @autoclosure () -> A) -> (result:A, duration: String) {
    let startTime = CFAbsoluteTimeGetCurrent()
    let result = f()
    let endTime = CFAbsoluteTimeGetCurrent()
    return (result, "Elapsed time is \(endTime - startTime) seconds.")
}

Ta funkcja pozwoli ci wywołać to w ten sposób, time (isPrime(7))co zwróci krotkę zawierającą wynik i opis ciągu, który upłynął.

Jeśli chcesz tylko upływającego czasu, możesz to zrobić time (isPrime(7)).duration

Prosta funkcja pomocnicza do pomiaru czasu wykonania z zamknięciem.

func printExecutionTime(withTag tag: String, of closure: () -> ()) {
    let start = CACurrentMediaTime()
    closure()
    print("#\(tag) - execution took \(CACurrentMediaTime() - start) seconds")
}

Stosowanie:

printExecutionTime(withTag: "Init") {
    // Do your work here
}

Wynik: #Init - execution took 1.00104497105349 seconds

możesz mierzyć nanosekundy w ten sposób:

let startDate: NSDate = NSDate()

// your long procedure

let endDate: NSDate = NSDate()
let dateComponents: NSDateComponents = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian).components(NSCalendarUnit.CalendarUnitNanosecond, fromDate: startDate, toDate: endDate, options: NSCalendarOptions(0))
println("runtime is nanosecs : \(dateComponents.nanosecond)")

Używam tego:

public class Stopwatch {
    public init() { }
    private var start_: NSTimeInterval = 0.0;
    private var end_: NSTimeInterval = 0.0;

    public func start() {
        start_ = NSDate().timeIntervalSince1970;
    }

    public func stop() {
        end_ = NSDate().timeIntervalSince1970;
    }

    public func durationSeconds() -> NSTimeInterval {
        return end_ - start_;
    }
}

Nie wiem, czy jest bardziej czy mniej dokładny niż poprzednio opublikowany. Ale sekundy mają dużo miejsc po przecinku i wydają się wychwytywać niewielkie zmiany w kodzie w algorytmach, takich jak QuickSort przy użyciu funkcji swap (), w porównaniu z implementacją samego swapu itp.

Pamiętaj, aby zwiększyć optymalizację kompilacji podczas testowania wydajności:

Oto moja próba najprostszej odpowiedzi:

let startTime = Date().timeIntervalSince1970  // 1512538946.5705 seconds

// time passes (about 10 seconds)

let endTime = Date().timeIntervalSince1970    // 1512538956.57195 seconds
let elapsedTime = endTime - startTime         // 10.0014500617981 seconds

Uwagi

• startTimei endTimesą typu TimeInterval, który jest po prostu typealiasfor Double, więc łatwo jest przekształcić go w Intlub cokolwiek. Czas jest mierzony w sekundach z dokładnością do milisekund.
• Zobacz też DateInterval, który zawiera rzeczywisty czas rozpoczęcia i zakończenia.
• Używanie czasu od 1970 roku jest podobne do znaczników czasu w Javie .

Zapożyczyłem pomysł od Klaasa, aby stworzyć lekką strukturę do pomiaru czasu biegu i interwałów:

Wykorzystanie kodu:

var timer = RunningTimer.init()
// Code to be timed
print("Running: \(timer) ") // Gives time interval
// Second code to be timed
print("Running: \(timer) ") // Gives final time

Funkcja stop nie musi być wywoływana, ponieważ funkcja drukowania poda upływ czasu. Może być wywoływane wielokrotnie, aby uzyskać upływ czasu. Ale aby zatrzymać licznik czasu w określonym punkcie kodu timer.stop(), można go również użyć do zwrócenia czasu w sekundach: let seconds = timer.stop() Po zatrzymaniu licznika czasu interwał nie będzie, więc print("Running: \(timer) ")poda prawidłowy czas nawet po kilku wierszach kodu.

Poniżej znajduje się kod RunningTimer. Jest testowany dla Swift 2.1:

import CoreFoundation
// Usage:    var timer = RunningTimer.init()
// Start:    timer.start() to restart the timer
// Stop:     timer.stop() returns the time and stops the timer
// Duration: timer.duration returns the time
// May also be used with print(" \(timer) ")

struct RunningTimer: CustomStringConvertible {
    var begin:CFAbsoluteTime
    var end:CFAbsoluteTime

    init() {
        begin = CFAbsoluteTimeGetCurrent()
        end = 0
    }
    mutating func start() {
        begin = CFAbsoluteTimeGetCurrent()
        end = 0
    }
    mutating func stop() -> Double {
        if (end == 0) { end = CFAbsoluteTimeGetCurrent() }
        return Double(end - begin)
    }
    var duration:CFAbsoluteTime {
        get {
            if (end == 0) { return CFAbsoluteTimeGetCurrent() - begin } 
            else { return end - begin }
        }
    }
    var description:String {
    let time = duration
    if (time > 100) {return " \(time/60) min"}
    else if (time < 1e-6) {return " \(time*1e9) ns"}
    else if (time < 1e-3) {return " \(time*1e6) µs"}
    else if (time < 1) {return " \(time*1000) ms"}
    else {return " \(time) s"}
    }
}

Zapakuj go w blok uzupełniający, aby był łatwy w użyciu.

public class func secElapsed(completion: () -> Void) {
    let startDate: NSDate = NSDate()
    completion()
    let endDate: NSDate = NSDate()
    let timeInterval: Double = endDate.timeIntervalSinceDate(startDate)
    println("seconds: \(timeInterval)")
}

To jest fragment, który wymyśliłem i wydaje się, że działa dla mnie na moim Macbooku ze Swift 4.

Nigdy nie testowałem na innych systemach, ale pomyślałem, że i tak warto się nim podzielić.

typealias MonotonicTS = UInt64
let monotonic_now: () -> MonotonicTS = mach_absolute_time

let time_numer: UInt64
let time_denom: UInt64
do {
    var time_info = mach_timebase_info(numer: 0, denom: 0)
    mach_timebase_info(&time_info)
    time_numer = UInt64(time_info.numer)
    time_denom = UInt64(time_info.denom)
}

// returns time interval in seconds
func monotonic_diff(from: MonotonicTS, to: MonotonicTS) -> TimeInterval {
    let diff = (to - from)
    let nanos = Double(diff * time_numer / time_denom)
    return nanos / 1_000_000_000
}

func seconds_elapsed(since: MonotonicTS) -> TimeInterval {
    return monotonic_diff(from: since, to:monotonic_now())
}

Oto przykład, jak go używać:

let t1 = monotonic_now()
// .. some code to run ..
let elapsed = seconds_elapsed(since: t1)
print("Time elapsed: \(elapsed*1000)ms")

Innym sposobem jest zrobienie tego bardziej szczegółowo:

let t1 = monotonic_now()
// .. some code to run ..
let t2 = monotonic_now()
let elapsed = monotonic_diff(from: t1, to: t2)
print("Time elapsed: \(elapsed*1000)ms")

Tak to napisałem.

 func measure<T>(task: () -> T) -> Double {
        let startTime = CFAbsoluteTimeGetCurrent()
        task()
        let endTime = CFAbsoluteTimeGetCurrent()
        let result = endTime - startTime
        return result
    }

Aby zmierzyć algorytm, użyj go w ten sposób.

let time = measure {
    var array = [2,4,5,2,5,7,3,123,213,12]
    array.sorted()
}

print("Block is running \(time) seconds.")

Statyczna klasa Swift3 dla podstawowego taktowania funkcji. Będzie śledzić każdy timer według nazwy. Nazwij to w ten sposób w miejscu, w którym chcesz rozpocząć pomiar:

Stopwatch.start(name: "PhotoCapture")

Wywołaj to, aby uchwycić i wydrukować czas, który upłynął:

Stopwatch.timeElapsed(name: "PhotoCapture")

Oto wynik: *** PhotoCapture upłynął ms: 1402.415125 Istnieje parametr „useNanos”, jeśli chcesz używać nanos. W razie potrzeby możesz je zmienić.

   class Stopwatch: NSObject {

  private static var watches = [String:TimeInterval]()

  private static func intervalFromMachTime(time: TimeInterval, useNanos: Bool) -> TimeInterval {
     var info = mach_timebase_info()
     guard mach_timebase_info(&info) == KERN_SUCCESS else { return -1 }
     let currentTime = mach_absolute_time()
     let nanos = currentTime * UInt64(info.numer) / UInt64(info.denom)
     if useNanos {
        return (TimeInterval(nanos) - time)
     }
     else {
        return (TimeInterval(nanos) - time) / TimeInterval(NSEC_PER_MSEC)
     }
  }

  static func start(name: String) {
     var info = mach_timebase_info()
     guard mach_timebase_info(&info) == KERN_SUCCESS else { return }
     let currentTime = mach_absolute_time()
     let nanos = currentTime * UInt64(info.numer) / UInt64(info.denom)
     watches[name] = TimeInterval(nanos)
  }

  static func timeElapsed(name: String) {
     return timeElapsed(name: name, useNanos: false)
  }

  static func timeElapsed(name: String, useNanos: Bool) {
     if let start = watches[name] {
        let unit = useNanos ? "nanos" : "ms"
        print("*** \(name) elapsed \(unit): \(intervalFromMachTime(time: start, useNanos: useNanos))")
     }
  }

}

Na podstawie odpowiedzi Franklina Yu i Cœura komentarzy

Detale

• Xcode 10.1 (10B61)
• Swift 4.2

Rozwiązanie 1

pomiar(_:)

Rozwiązanie 2

import Foundation

class Measurer<T: Numeric> {

    private let startClosure: ()->(T)
    private let endClosure: (_ beginningTime: T)->(T)

    init (startClosure: @escaping ()->(T), endClosure: @escaping (_ beginningTime: T)->(T)) {
        self.startClosure = startClosure
        self.endClosure = endClosure
    }

    init (getCurrentTimeClosure: @escaping ()->(T)) {
        startClosure = getCurrentTimeClosure
        endClosure = { beginningTime in
            return getCurrentTimeClosure() - beginningTime
        }
    }

    func measure(closure: ()->()) -> T {
        let value = startClosure()
        closure()
        return endClosure(value)
    }
}

Zastosowanie rozwiązania 2

// Sample with ProcessInfo class

m = Measurer { ProcessInfo.processInfo.systemUptime }
time = m.measure {
    _ = (1...1000).map{_ in Int(arc4random()%100)}
}
print("ProcessInfo: \(time)")

// Sample with Posix clock API

m = Measurer(startClosure: {Double(clock())}) { (Double(clock()) - $0 ) / Double(CLOCKS_PER_SEC) }
time = m.measure {
    _ = (1...1000).map{_ in Int(arc4random()%100)}
}
print("POSIX: \(time)")