Swift ile geçen zamanı ölçün

Swift'de bir işlevi çalıştırmak için geçen süreyi nasıl ölçebiliriz? Geçen süreyi şu şekilde görüntülemeye çalışıyorum: "Geçen süre .05 saniye". Java'da System.nanoTime () kullanabileceğimizi gördüm , bunu başarmak için Swift'de eşdeğer yöntemler var mı?

Lütfen örnek programa bir göz atın:

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

İşte Swift'deki Project Euler sorunlarını ölçmek için yazdığım bir Swift işlevi

Swift 3'ten itibaren artık Grand Central Dispatch'in "hızlı" bir sürümü var. Dolayısıyla doğru cevap muhtemelen DispatchTime API'sini kullanmaktır .

İşlevim şuna benzer:

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

Eski cevap

Swift 1 ve 2 için işlevim NSDate'i kullanıyor:

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

_{Zamanlama işlevleri için NSdate'i kullanmanın tavsiye edilmediğini unutmayın: " Sistem zamanı, harici zaman referanslarıyla senkronizasyon nedeniyle veya saatin açık bir kullanıcı değişikliği nedeniyle azalabilir. "}

Bu dayanan kullanışlı bir zamanlayıcı sınıftır 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
        }
    }
}

Bunu şu şekilde kullanabilirsiniz:

let timer = ParkBenchTimer()

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

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

Kullanım clock, ProcessInfo.systemUptimeya DispatchTimebasit başlangıç kez.

Bildiğim kadarıyla geçen zamanı ölçmenin en az on yolu var:

Monotonik Saat tabanlı:

1. ProcessInfo.systemUptime.
2. mach_absolute_timeile mach_timebase_infobelirtildiği gibi bu cevap .
3. clock()içinde POSIX standardı .
4. times()içinde POSIX standardı . (Kullanıcı zamanı ile sistem zamanını dikkate almamız gerektiğinden çok karmaşık ve alt süreçler de dahil.)
5. DispatchTime (Mach zamanı API'si etrafında bir sarmalayıcı) JeremyP tarafından kabul edilen yanıtta belirtildiği gibi.
6. CACurrentMediaTime().

Duvar Saati tabanlı:

(bunları asla ölçümler için kullanmayın: aşağıya bakın)

7. NSDate/ Datebaşkaları tarafından belirtildiği gibi.
8. CFAbsoluteTime diğerleri tarafından belirtildiği gibi.
9. DispatchWallTime.
10. gettimeofday()içinde POSIX standardı .

Seçenek 1, 2 ve 3 aşağıda detaylandırılmıştır.

Seçenek 1: Foundation'da Process Info API'si

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

diff:NSTimeIntervalsaniye cinsinden geçen zaman nerede .

Seçenek 2: Mach C API'si

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

diff:Doublenano saniyelik geçen zaman nerede .

Seçenek 3: POSIX saat API'si

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

diff:Doublesaniye cinsinden geçen zaman nerede .

Geçen Zaman İçin Neden Duvar Saati Zamanı Değil?

Belgelerde CFAbsoluteTimeGetCurrent:

Bu işleve tekrarlanan çağrılar, tekdüze olarak artan sonuçları garanti etmez.

Nedeni benzer currentTimeMillisvs nanoTimeJava :

Birini diğer amaç için kullanamazsınız. Bunun nedeni, hiçbir bilgisayarın saatinin mükemmel olmamasıdır; her zaman sürüklenir ve bazen düzeltilmesi gerekir. Bu düzeltme manuel olarak gerçekleşebilir veya çoğu makinede, sistem saatinde sürekli olarak küçük düzeltmeler yapan ("duvar saati") bir süreç vardır. Bunlar sıklıkla olma eğilimindedir. Böyle bir başka düzeltme, artık bir saniye olduğunda gerçekleşir.

Burada CFAbsoluteTime, başlangıç ​​zamanı yerine duvar saati süresi sağlar. NSDateaynı zamanda duvar saati zamanıdır.

Swift 4 en kısa cevap:

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

Size geçen 1.02107906341553 saniye gibi bir şey basacaktır (süre, göreve göre değişecektir, bu ölçüm için ondalık hassasiyet seviyesini görmeniz için size bunu gösteriyorum).

Umarım bundan sonra Swift 4'teki birine yardımcı olur!

Güncelleme

Kod bölümlerini test etmenin genel bir yoluna sahip olmak istiyorsanız, sonraki parçacığı öneririm:

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.

Sadece bu işlevi Kopyala ve Yapıştır. Hızlı bir şekilde yazıldı. 5. JeremyP burada kopyalanıyor.

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

Gibi kullan

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

timeÇağrılarınızı ölçmek için bir işlev oluşturabilirsiniz . Klaas'ın cevabından ilham aldım .

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

Bu işlev time (isPrime(7)), sonucu içeren bir tuple ve geçen zamanın bir dize tanımını döndürecek şekilde onu bu şekilde çağırmanıza izin verir .

Sadece geçen zamanı diliyorsan bunu yapabilirsin time (isPrime(7)).duration

Kapanma ile yürütme süresini ölçmek için basit yardımcı fonksiyon.

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

Kullanımı:

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

Sonuç: #Init - execution took 1.00104497105349 seconds

nanosaniyeleri şu şekilde ölçebilirsiniz :

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

Bunu kullanıyorum:

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

Daha önce gönderilenden daha fazla veya daha az doğru olup olmadığını bilmiyorum. Ancak saniyeler çok sayıda ondalık sayıya sahiptir ve swap () kullanarak QuickSort gibi algoritmalarda küçük kod değişikliklerini yakalıyor gibi görünmektedir.

Performansı test ederken derleme optimizasyonlarınızı artırmayı unutmayın:

İşte en basit cevap için denemem:

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

notlar

• startTimeve endTimetiptedir TimeIntervaladil olduğunu typealiasiçin Doublebir dönüştürmek kolaydır böylece, Intya da her neyse. Zaman, milisaniyenin altında bir hassasiyetle saniye cinsinden ölçülür.
• Ayrıca DateInterval, gerçek bir başlangıç ​​ve bitiş saati içeren bkz .
• 1970'ten beri kullanılan zamanı kullanmak Java zaman damgalarına benzer .

Koşu ve aralık süresini ölçmek için hafif bir yapı oluşturma fikrini Klaas'tan ödünç aldım:

Kod Kullanımı:

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

Yazdırma işlevi geçen süreyi vereceğinden, durdurma işlevinin çağrılmasına gerek yoktur. Geçen süreyi almak için tekrar tekrar çağrılabilir. Ancak, zamanlayıcıyı kodun belirli bir noktasında durdurmak için timer.stop(), zamanı saniye cinsinden döndürmek için de kullanılabilir: let seconds = timer.stop() Zamanlayıcı durdurulduktan sonra aralık zamanlayıcı durmaz , bu nedenle print("Running: \(timer) ")birkaç satır koddan sonra bile doğru zamanı verecektir.

Aşağıda, RunningTimer kodu verilmiştir. Swift 2.1 için test edilmiştir:

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

Kolay kullanım için bir tamamlama bloğuna sarın.

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

Bu benim bulduğum pasaj ve Swift 4 ile Macbook'umda benim için çalışıyor gibi görünüyor.

Başka sistemlerde hiç test edilmemişti ama yine de paylaşmaya değer olduğunu düşündüm.

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

İşte nasıl kullanılacağına dair bir örnek:

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

Başka bir yol da bunu daha açık bir şekilde yapmaktır:

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

Ben böyle yazdım.

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

Bir algoritmayı ölçmek için onu böyle kullanın .

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

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

Temel işlev zamanlaması için statik Swift3 sınıfı. Her zamanlayıcıyı isme göre takip edecektir. Ölçmeye başlamak istediğiniz noktada bunu şöyle adlandırın:

Stopwatch.start(name: "PhotoCapture")

Geçen süreyi yakalamak ve yazdırmak için bunu arayın:

Stopwatch.timeElapsed(name: "PhotoCapture")

Bu çıktı: *** PhotoCapture geçen ms: 1402.415125 Nano kullanmak istiyorsanız bir "useNanos" parametresi vardır. Lütfen gerektiği gibi değiştirmekten çekinmeyin.

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

}

Dayanarak Franklin Yu cevap ve Coeur yorumlarla

ayrıntılar

• Xcode 10.1 (10B61)
• Swift 4.2

1.Çözüm

_ (Ölçmek :)

2.Çözüm

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

Çözüm 2'nin kullanımı

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