วัดเวลาที่ผ่านไปใน Swift

เราจะวัดเวลาที่ผ่านไปสำหรับการเรียกใช้ฟังก์ชันใน Swift ได้อย่างไร? ฉันพยายามแสดงเวลาที่ผ่านไปดังนี้: "เวลาที่ผ่านไปคือ. 05 วินาที" เห็นว่าใน Javaเราสามารถใช้ System.nanoTime () ได้มีวิธีการที่เทียบเท่าใน Swift เพื่อทำสิ่งนี้ให้สำเร็จหรือไม่?

โปรดดูโปรแกรมตัวอย่าง:

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

นี่คือฟังก์ชั่น Swift ที่ฉันเขียนเพื่อวัดปัญหาProject Eulerใน Swift

สำหรับ Swift 3 ตอนนี้มีเวอร์ชันของ Grand Central Dispatch ที่ "รวดเร็ว" ดังนั้นคำตอบที่ถูกต้องคืออาจจะใช้DispatchTime API

ฟังก์ชันของฉันจะมีลักษณะดังนี้:

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

คำตอบเก่า

สำหรับ Swift 1 และ 2 ฟังก์ชันของฉันใช้ 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
}

_{โปรดทราบว่าการใช้ NSdate สำหรับฟังก์ชันจับเวลาเป็นสิ่งที่ไม่ควรทำ: " เวลาของระบบอาจลดลงเนื่องจากการซิงโครไนซ์กับการอ้างอิงเวลาภายนอกหรือเนื่องจากการเปลี่ยนนาฬิกาของผู้ใช้อย่างชัดเจน "}

นี่คือคลาสจับเวลาที่สะดวกโดยอิงจาก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
        }
    }
}

คุณสามารถใช้งานได้ดังนี้:

let timer = ParkBenchTimer()

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

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

การใช้งานclock, ProcessInfo.systemUptimeหรือDispatchTimeเวลาเริ่มต้นขึ้นง่าย

เท่าที่ฉันรู้มีอย่างน้อยสิบวิธีในการวัดเวลาที่ผ่านไป:

Monotonic Clock ตาม:

1. ProcessInfo.systemUptime.
2. mach_absolute_timeกับmach_timebase_infoที่กล่าวไว้ในคำตอบนี้
3. clock()ในมาตรฐาน POSIX
4. times()ในมาตรฐาน POSIX (ซับซ้อนเกินไปเนื่องจากเราต้องพิจารณาเวลาของผู้ใช้เทียบกับเวลาของระบบและกระบวนการย่อยมีส่วนเกี่ยวข้อง)
5. DispatchTime (เครื่องห่อรอบ Mach time API) ตามที่ JeremyP กล่าวไว้ในคำตอบที่ยอมรับ
6. CACurrentMediaTime().

นาฬิกาแขวนตาม:

(อย่าใช้สิ่งเหล่านี้สำหรับเมตริก: ดูเหตุผลด้านล่าง)

7. NSDate/ Dateตามที่ผู้อื่นกล่าวถึง
8. CFAbsoluteTime ตามที่ผู้อื่นกล่าวถึง
9. DispatchWallTime.
10. gettimeofday()ในมาตรฐาน POSIX

ตัวเลือกที่ 1, 2 และ 3 มีรายละเอียดด้านล่าง

ตัวเลือกที่ 1: Process Info API ใน Foundation

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

ซึ่งdiff:NSTimeIntervalเป็นเวลาที่ผ่านไปโดยวินาที

ตัวเลือกที่ 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)
}

ซึ่งdiff:Doubleเป็นเวลาที่ผ่านไปโดยนาโนวินาที

ตัวเลือกที่ 3: POSIX clock API

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

ซึ่งdiff:Doubleเป็นเวลาที่ผ่านไปโดยวินาที

ทำไมไม่ใช้นาฬิกาแขวนเป็นเวลาที่ผ่านไป?

ในเอกสารของCFAbsoluteTimeGetCurrent:

การเรียกใช้ฟังก์ชันนี้ซ้ำ ๆ ไม่ได้รับประกันผลลัพธ์ที่เพิ่มขึ้นอย่างจำเจ

เหตุผลคล้ายcurrentTimeMillisกับnanoTimeใน Java :

คุณไม่สามารถใช้เพื่อวัตถุประสงค์อื่นได้ เหตุผลก็คือไม่มีนาฬิกาของคอมพิวเตอร์ที่สมบูรณ์แบบ มันลอยอยู่เสมอและบางครั้งต้องได้รับการแก้ไข การแก้ไขนี้อาจเกิดขึ้นด้วยตนเองหรือในกรณีของเครื่องส่วนใหญ่มีกระบวนการที่ทำงานและออกการแก้ไขเล็กน้อยอย่างต่อเนื่องกับนาฬิการะบบ ("นาฬิกาแขวน") สิ่งเหล่านี้มักจะเกิดขึ้นบ่อยครั้ง การแก้ไขเช่นนี้เกิดขึ้นเมื่อใดก็ตามที่มีวินาทีอธิกสุรทิน

ที่นี่CFAbsoluteTimeให้เวลานาฬิกาแขวนแทนเวลาเริ่มต้น NSDateเป็นเวลานาฬิกาแขวนเช่นกัน

คำตอบที่สั้นที่สุดของ Swift 4:

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

มันจะพิมพ์ให้คุณบางอย่างเช่นเวลาผ่านไป 1.02107906341553 วินาที (เวลาแน่นอนจะแตกต่างกันไปขึ้นอยู่กับงานฉันแค่แสดงสิ่งนี้ให้พวกคุณเห็นระดับความแม่นยำทศนิยมสำหรับการวัดนี้)

หวังว่ามันจะช่วยใครบางคนใน Swift 4 ต่อจากนี้!

ปรับปรุง

หากคุณต้องการทดสอบโค้ดส่วนต่างๆโดยทั่วไปเราขอแนะนำตัวอย่างถัดไป:

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.

เพียงแค่คัดลอกและวางฟังก์ชันนี้ เขียนด้วยความรวดเร็ว 5. คัดลอก 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")
    }

ใช้แล้วชอบ

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

คุณสามารถสร้างtimeฟังก์ชันสำหรับวัดการโทรของคุณ ฉันได้รับแรงบันดาลใจจากคำตอบของ 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.")
}

ฟังก์ชันนี้จะช่วยให้คุณสามารถเรียกมันแบบนี้time (isPrime(7))ซึ่งจะส่งคืนทูเพิลที่มีผลลัพธ์และคำอธิบายสตริงของเวลาที่ผ่านไป

หากคุณต้องการเพียงเวลาที่ผ่านไปคุณสามารถทำได้ time (isPrime(7)).duration

ฟังก์ชันตัวช่วยที่เรียบง่ายสำหรับการวัดเวลาดำเนินการด้วยการปิด

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

การใช้งาน:

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

ผลลัพธ์: #Init - execution took 1.00104497105349 seconds

คุณสามารถวัดนาโนวินาทีเช่นนี้:

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

ฉันใช้สิ่งนี้:

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

ฉันไม่รู้ว่ามันแม่นยำมากหรือน้อยกว่าที่เคยโพสต์ไว้ แต่วินาทีนั้นมีทศนิยมจำนวนมากและดูเหมือนว่าจะตรวจจับการเปลี่ยนแปลงโค้ดเล็กน้อยในอัลกอริทึมเช่น QuickSort โดยใช้ swap () เทียบกับการใช้ swap urself เป็นต้น

อย่าลืมเพิ่มประสิทธิภาพการสร้างของคุณเมื่อทดสอบประสิทธิภาพ:

นี่คือความพยายามของฉันสำหรับคำตอบที่ง่ายที่สุด:

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

หมายเหตุ

• startTimeและendTimeเป็นประเภทTimeIntervalซึ่งเป็นเพียงtypealiasสำหรับDoubleดังนั้นจึงเป็นเรื่องง่ายที่จะแปลงเป็น an Intหรืออะไรก็ได้ เวลาถูกวัดเป็นวินาทีโดยมีความแม่นยำย่อยมิลลิวินาที
• ดูเพิ่มเติมDateIntervalซึ่งรวมถึงเวลาเริ่มต้นและเวลาสิ้นสุดจริง
• ใช้เวลาตั้งแต่ปี 1970 มีความคล้ายคลึงกับการประทับเวลา Java

ฉันได้ยืมแนวคิดจาก Klaas เพื่อสร้างโครงสร้างที่มีน้ำหนักเบาเพื่อวัดการวิ่งและช่วงเวลา:

การใช้รหัส:

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

ไม่จำเป็นต้องเรียกใช้ฟังก์ชันหยุดเนื่องจากฟังก์ชันการพิมพ์จะทำให้เวลาหมดไป อาจเรียกซ้ำ ๆ กันเพื่อให้เวลาล่วงเลยไป แต่หากต้องการหยุดตัวจับเวลา ณ จุดหนึ่งในรหัสให้ใช้timer.stop()มันอาจใช้เพื่อคืนเวลาเป็นวินาทีด้วยเช่นกัน: let seconds = timer.stop() หลังจากหยุดจับเวลาแล้วตัวจับเวลาช่วงจะไม่ทำงานดังนั้นprint("Running: \(timer) ")จะให้เวลาที่ถูกต้องแม้จะใส่รหัสไปไม่กี่บรรทัด

ต่อไปนี้เป็นรหัสสำหรับ RunningTimer ได้รับการทดสอบสำหรับ 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"}
    }
}

ห่อไว้ในบล็อกที่สมบูรณ์เพื่อให้ใช้งานได้ง่าย

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

นี่คือตัวอย่างข้อมูลที่ฉันคิดขึ้นมาและดูเหมือนว่าจะใช้ได้กับฉันใน Macbook ที่มี Swift 4

ไม่เคยทดสอบกับระบบอื่น แต่ฉันคิดว่ามันคุ้มค่าที่จะแบ่งปัน

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

นี่คือตัวอย่างวิธีการใช้งาน:

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

อีกวิธีหนึ่งคือทำอย่างชัดเจนมากขึ้น:

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

นี่คือวิธีที่ฉันเขียนมัน

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

ในการวัดอัลกอริทึมให้ใช้เช่นนั้น

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

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

คลาส Swift3 แบบคงที่สำหรับการจับเวลาฟังก์ชันพื้นฐาน มันจะติดตามตัวจับเวลาแต่ละครั้งตามชื่อ เรียกเช่นนี้ในจุดที่คุณต้องการเริ่มวัด:

Stopwatch.start(name: "PhotoCapture")

เรียกสิ่งนี้เพื่อจับภาพและพิมพ์เวลาที่ผ่านไป:

Stopwatch.timeElapsed(name: "PhotoCapture")

นี่คือผลลัพธ์: *** PhotoCapture ที่ผ่านไป ms: 1402.415125 มีพารามิเตอร์ "useNanos" หากคุณต้องการใช้นาโน โปรดอย่าลังเลที่จะเปลี่ยนแปลงตามความจำเป็น

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

}

จากคำตอบของFranklin Yuและความคิดเห็นของCœur

รายละเอียด

• Xcode 10.1 (10B61)
• Swift 4.2

โซลูชันที่ 1

วัด(_:)

โซลูชันที่ 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)
    }
}

การใช้โซลูชัน 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)")