Misura il tempo trascorso in Swift

Come possiamo misurare il tempo trascorso per eseguire una funzione in Swift? Sto cercando di visualizzare il tempo trascorso in questo modo: "Il tempo trascorso è di 0,05 secondi". Visto che in Java , possiamo usare System.nanoTime (), ci sono metodi equivalenti disponibili in Swift per ottenere questo risultato?

Dai un'occhiata al programma di esempio:

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");
}

Ecco una funzione Swift che ho scritto per misurare i problemi di Project Euler in Swift

A partire da Swift 3, ora esiste una versione di Grand Central Dispatch che è "modificata". Quindi la risposta corretta è probabilmente usare l' API DispatchTime .

La mia funzione sarebbe simile a:

// 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
}

Vecchia risposta

Per Swift 1 e 2, la mia funzione utilizza 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
}

_{Si noti che l'utilizzo di NSdate per le funzioni di temporizzazione è sconsigliato: " L'ora del sistema può diminuire a causa della sincronizzazione con riferimenti temporali esterni o a causa di un esplicito cambio dell'orologio da parte dell'utente ".}

Questa è una comoda classe di timer basata su 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
        }
    }
}

Puoi usarlo in questo modo:

let timer = ParkBenchTimer()

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

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

Utilizzare clock, ProcessInfo.systemUptimeo DispatchTimeper un semplice tempo di avvio.

Per quanto ne so, esistono almeno dieci modi per misurare il tempo trascorso:

Basato su orologio monotonico:

1. ProcessInfo.systemUptime.
2. mach_absolute_timecon mach_timebase_infocome menzionato in questa risposta .
3. clock()nello standard POSIX .
4. times()nello standard POSIX . (Troppo complicato poiché dobbiamo considerare il tempo dell'utente rispetto al tempo di sistema e sono coinvolti i processi figlio.)
5. DispatchTime (un wrapper attorno all'API di Mach Time) come indicato da JeremyP nella risposta accettata.
6. CACurrentMediaTime().

Basato su orologio da parete:

(non usare mai quelli per le metriche: vedi sotto perché)

7. NSDate/ Datecome menzionato da altri.
8. CFAbsoluteTime come menzionato da altri.
9. DispatchWallTime.
10. gettimeofday()nello standard POSIX .

Le opzioni 1, 2 e 3 sono elaborate di seguito.

Opzione 1: API delle informazioni di processo in Foundation

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

dove diff:NSTimeIntervalè il tempo trascorso in secondi.

Opzione 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)
}

dove diff:Doubleè il tempo trascorso di nano-secondi.

Opzione 3: API dell'orologio POSIX

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

dove diff:Doubleè il tempo trascorso in secondi.

Perché non l'ora dell'orologio da parete per il tempo trascorso?

Nella documentazione di CFAbsoluteTimeGetCurrent:

Le chiamate ripetute a questa funzione non garantiscono risultati monotonicamente crescenti.

Il motivo è simile a currentTimeMillisvs nanoTimein Java :

Non puoi usare l'uno per l'altro scopo. Il motivo è che nessun orologio da computer è perfetto; va sempre alla deriva e occasionalmente deve essere corretto. Questa correzione può avvenire manualmente o, nel caso della maggior parte delle macchine, esiste un processo che viene eseguito e genera continuamente piccole correzioni all'orologio di sistema ("orologio da parete"). Questi tendono ad accadere spesso. Un'altra correzione di questo tipo si verifica ogni volta che c'è un secondo di salto.

Qui CFAbsoluteTimefornisce l'ora dell'orologio da parete anziché l'ora di avvio. NSDateè anche l'ora dell'orologio da parete.

Swift 4 risposta più breve:

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

Ti stamperà qualcosa come 1.02107906341553 secondi trascorsi (il tempo ovviamente varierà a seconda del compito, lo sto solo mostrando a voi ragazzi per vedere il livello di precisione decimale per questa misura).

Spero che d'aiuto qualcuno in Swift 4 d'ora in poi!

Aggiornare

Se vuoi avere un modo generico di testare porzioni di codice, suggerirei il frammento seguente:

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.

Basta copiare e incollare questa funzione. Scritto in rapido 5. Copia qui JeremyP.

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")
    }

Usalo come

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

È possibile creare una timefunzione per misurare le chiamate. Sono ispirato dalla risposta di Klaas .

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.")
}

Questa funzione ti permetterebbe di chiamarla così time (isPrime(7))che restituirebbe una tupla contenente il risultato e una descrizione della stringa del tempo trascorso.

Se desideri solo il tempo trascorso, puoi farlo time (isPrime(7)).duration

Semplice funzione di supporto per misurare i tempi di esecuzione con chiusura.

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

Uso:

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

Risultato: #Init - execution took 1.00104497105349 seconds

puoi misurare i nanosecondi come ad esempio questo:

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)")

Io lo uso questo:

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_;
    }
}

Non so se sia più o meno preciso di quanto precedentemente pubblicato. Ma i secondi hanno molti decimali e sembrano catturare piccole modifiche al codice in algoritmi come QuickSort usando swap () rispetto all'implementazione di swap noi stessi ecc.

Ricorda di aumentare le ottimizzazioni di build durante il test delle prestazioni:

Ecco il mio tentativo per la risposta più semplice:

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

Appunti

• startTimee endTimesono del tipo TimeInterval, che è solo un typealiasa Double, quindi è facile convertirlo in uno Into qualunque cosa. Il tempo viene misurato in secondi con precisione inferiore al millisecondo.
• Vedi anche DateInterval, che include l'ora di inizio e di fine effettiva.
• L'uso del tempo dal 1970 è simile ai timestamp Java .

Ho preso in prestito l'idea di Klaas per creare una struttura leggera per misurare il tempo di corsa e di intervallo:

Utilizzo del codice:

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

Non è necessario chiamare la funzione di arresto, poiché la funzione di stampa indica il tempo trascorso. Può essere chiamato ripetutamente per far scadere il tempo. Ma per fermare il timer ad un certo punto nell'uso del codice timer.stop(), può anche essere usato per restituire il tempo in secondi: let seconds = timer.stop() Dopo che il timer è stato arrestato, l'intervallo non lo farà, quindi print("Running: \(timer) ")fornirà l'ora corretta anche dopo alcune righe di codice.

Di seguito è riportato il codice per RunningTimer. È testato per 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"}
    }
}

Avvolgilo in un blocco di completamento per un facile utilizzo.

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

Questo è lo snippet che mi è venuto in mente e sembra funzionare per me sul mio Macbook con Swift 4.

Non ho mai provato su altri sistemi, ma ho pensato che valesse comunque la pena condividerli.

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())
}

Ecco un esempio di come usarlo:

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

Un altro modo è farlo in modo più esplicito:

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")

È così che l'ho scritto.

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

Per misurare un algoritmo usalo in quel modo.

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

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

Classe Swift3 statica per i tempi delle funzioni di base. Terrà traccia di ciascun timer per nome. Chiamalo così nel punto in cui vuoi iniziare a misurare:

Stopwatch.start(name: "PhotoCapture")

Chiamalo per catturare e stampare il tempo trascorso:

Stopwatch.timeElapsed(name: "PhotoCapture")

Questo è l'output: *** PhotoCapture trascorso ms: 1402.415125 Esiste un parametro "useNanos" se si desidera utilizzare nanos. Sentiti libero di cambiare se necessario.

   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))")
     }
  }

}

Basato sulla risposta di Franklin Yu e sui commenti del Cœur

Dettagli

• Xcode 10.1 (10B61)
• Rapido 4.2

Soluzione 1

misurare(_:)

Soluzione 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)
    }
}

Utilizzo della soluzione 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)")