Messen Sie die verstrichene Zeit in Swift

Wie können wir die Zeit messen, die zum Ausführen einer Funktion in Swift vergangen ist? Ich versuche, die verstrichene Zeit folgendermaßen anzuzeigen: "Die verstrichene Zeit beträgt 0,05 Sekunden". Saw , dass in Java , können wir System.nanoTime () verwenden, ist es gleichwertige Verfahren in Swift verfügbar sind , dies zu erreichen?

Bitte schauen Sie sich das Beispielprogramm an:

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

Hier ist eine Swift-Funktion, die ich geschrieben habe, um Project Euler- Probleme in Swift zu messen

Ab Swift 3 gibt es jetzt eine Version von Grand Central Dispatch, die "schnell" ist. Die richtige Antwort ist also wahrscheinlich die Verwendung der DispatchTime-API .

Meine Funktion würde ungefähr so ​​aussehen:

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

Alte Antwort

Für Swift 1 und 2 verwendet meine Funktion 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
}

_{Beachten Sie, dass von der Verwendung von NSdate für Zeitsteuerungsfunktionen abgeraten wird: " Die Systemzeit kann sich aufgrund der Synchronisation mit externen Zeitreferenzen oder aufgrund einer expliziten Änderung der Uhr durch den Benutzer verringern. "}

Dies ist eine praktische Timer-Klasse, die auf CoreFoundations basiert 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
        }
    }
}

Sie können es so verwenden:

let timer = ParkBenchTimer()

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

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

Verwenden Sie clock, ProcessInfo.systemUptimeoder DispatchTimefür eine einfache Startzeit.

Soweit ich weiß, gibt es mindestens zehn Möglichkeiten, die verstrichene Zeit zu messen:

Monotone Uhr basiert:

1. ProcessInfo.systemUptime.
2. mach_absolute_timemit mach_timebase_infowie in dieser Antwort erwähnt .
3. clock()im POSIX-Standard .
4. times()im POSIX-Standard . (Zu kompliziert, da wir Benutzerzeit und Systemzeit berücksichtigen müssen und untergeordnete Prozesse beteiligt sind.)
5. DispatchTime (ein Wrapper um die Mach-Zeit-API), wie von JeremyP in der akzeptierten Antwort erwähnt.
6. CACurrentMediaTime().

Wanduhr basiert:

(Verwenden Sie diese niemals für Metriken: siehe unten, warum)

7. NSDate/ Datewie von anderen erwähnt.
8. CFAbsoluteTime wie von anderen erwähnt.
9. DispatchWallTime.
10. gettimeofday()im POSIX-Standard .

Option 1, 2 und 3 werden nachstehend erläutert.

Option 1: Verarbeiten der Info-API in Foundation

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

Wo diff:NSTimeIntervalist die verstrichene Zeit in Sekunden.

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

Wo diff:Doubleist die verstrichene Zeit in Nanosekunden?

Option 3: POSIX Clock API

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

Wo diff:Doubleist die verstrichene Zeit in Sekunden.

Warum nicht die Wanduhrzeit für die verstrichene Zeit?

In der Dokumentation von CFAbsoluteTimeGetCurrent:

Wiederholte Aufrufe dieser Funktion garantieren keine monoton steigenden Ergebnisse.

Grund ist ähnlich wie currentTimeMillisvs nanoTimein Java :

Sie können das eine nicht für den anderen Zweck verwenden. Der Grund ist, dass keine Computeruhr perfekt ist; es driftet immer und muss gelegentlich korrigiert werden. Diese Korrektur kann entweder manuell erfolgen, oder bei den meisten Maschinen wird ein Prozess ausgeführt, der kontinuierlich kleine Korrekturen an der Systemuhr ("Wanduhr") vornimmt. Diese treten häufig auf. Eine weitere solche Korrektur erfolgt immer dann, wenn eine Schaltsekunde vorliegt.

Hier wird CFAbsoluteTimedie Wanduhrzeit anstelle der Startzeit angegeben. NSDateist auch Wanduhrzeit.

Swift 4 kürzeste Antwort:

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

Es druckt Ihnen ungefähr 1.02107906341553 Sekunden (die Zeit variiert natürlich je nach Aufgabe, ich zeige dies nur, damit Sie die Dezimalgenauigkeit für diese Messung sehen können).

Hoffe, es hilft jemandem in Swift 4 von nun an!

Aktualisieren

Wenn Sie eine generische Methode zum Testen von Codeteilen haben möchten, würde ich das nächste Snippet vorschlagen:

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.

Kopieren Sie diese Funktion einfach und fügen Sie sie ein. Geschrieben in Swift 5. Kopieren Sie JeremyP hier.

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

Verwenden Sie es wie

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

Sie können eine timeFunktion zum Messen Ihrer Anrufe erstellen . Ich bin inspiriert von Klaas ' Antwort.

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

Mit dieser Funktion können Sie es so aufrufen, dass time (isPrime(7))ein Tupel mit dem Ergebnis und einer Zeichenfolgenbeschreibung der verstrichenen Zeit zurückgegeben wird.

Wenn Sie nur die verstrichene Zeit wünschen, können Sie dies tun time (isPrime(7)).duration

Einfache Hilfsfunktion zur Messung der Ausführungszeit mit Verschluss.

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

Verwendung:

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

Ergebnis: #Init - execution took 1.00104497105349 seconds

Sie können die Nanosekunden wie folgt messen :

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

Ich benutze das:

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

Ich weiß nicht, ob es mehr oder weniger genau ist als zuvor veröffentlicht. Aber die Sekunden haben viele Dezimalstellen und scheinen kleine Codeänderungen in Algorithmen wie QuickSort mit swap () oder der Implementierung von swap urself usw. zu erfassen.

Denken Sie daran, Ihre Build-Optimierungen zu verbessern, wenn Sie die Leistung testen:

Hier ist mein Versuch für die einfachste Antwort:

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

Anmerkungen

• startTimeund endTimesind von der Art TimeInterval, die nur ein typealiasfür ist Double, so ist es einfach, es in eine Intoder was auch immer umzuwandeln . Die Zeit wird in Sekunden mit einer Genauigkeit von weniger als einer Millisekunde gemessen.
• Siehe auch DateInterval, einschließlich einer tatsächlichen Start- und Endzeit.
• Die Verwendung der Zeit seit 1970 ähnelt Java-Zeitstempeln .

Ich habe mir die Idee von Klaas geliehen, eine leichte Struktur zum Messen der Laufzeit und der Intervallzeit zu erstellen:

Code-Verwendung:

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

Die Stoppfunktion muss nicht aufgerufen werden, da die Druckfunktion die verstrichene Zeit angibt. Es kann wiederholt aufgerufen werden, um die abgelaufene Zeit zu erhalten. Um den Timer an einem bestimmten Punkt in der Code-Verwendung anzuhalten timer.stop(), kann er auch verwendet werden, um die Zeit in Sekunden zurückzugeben: let seconds = timer.stop() Nach dem Anhalten des Timers wird der Intervall-Timer nicht mehr angezeigt , sodass print("Running: \(timer) ")auch nach einigen Codezeilen die richtige Zeit angezeigt wird .

Es folgt der Code für RunningTimer. Es ist für Swift 2.1 getestet:

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

Wickeln Sie es zur einfachen Verwendung in einen Fertigstellungsblock.

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

Dies ist der Ausschnitt, den ich mir ausgedacht habe und der auf meinem Macbook mit Swift 4 zu funktionieren scheint.

Nie auf anderen Systemen getestet, aber ich dachte, es lohnt sich trotzdem zu teilen.

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

Hier ist ein Beispiel für die Verwendung:

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

Eine andere Möglichkeit besteht darin, dies expliziter zu tun:

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

So habe ich es geschrieben.

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

Um einen Algorithmus zu messen, verwenden Sie ihn so.

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

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

Statische Swift3-Klasse für das Timing grundlegender Funktionen. Jeder Timer wird anhand seines Namens verfolgt. Nennen Sie es an dem Punkt, an dem Sie mit der Messung beginnen möchten, so:

Stopwatch.start(name: "PhotoCapture")

Rufen Sie dies auf, um die verstrichene Zeit zu erfassen und auszudrucken:

Stopwatch.timeElapsed(name: "PhotoCapture")

Dies ist die Ausgabe: *** PhotoCapture abgelaufen ms: 1402.415125 Es gibt einen "useNanos" -Parameter, wenn Sie Nanos verwenden möchten. Bitte zögern Sie nicht, nach Bedarf zu ändern.

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

}}

Basierend auf Franklin Yu Antwort und Cœur Kommentaren

Einzelheiten

• Xcode 10.1 (10B61)
• Swift 4.2

Lösung 1

messen(_:)

Lösung 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)
    }
}

Verwendung der Lösung 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)")