From c0ee2bd42e6cd5bb9e53314f0ae9116913c75536 Mon Sep 17 00:00:00 2001
From: Kim Topley <ktopley@apple.com>
Date: Wed, 12 Apr 2017 13:32:24 -0700
Subject: [PATCH] Port changes from swift repository.

(Radar 31585625)
---
 src/swift/Time.swift | 40 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 35 insertions(+), 5 deletions(-)

diff --git a/src/swift/Time.swift b/src/swift/Time.swift
index 0b07742e6..8178ffd6c 100644
--- a/src/swift/Time.swift
+++ b/src/swift/Time.swift
@@ -17,6 +17,14 @@
 import CDispatch
 
 public struct DispatchTime : Comparable {
+#if HAVE_MACH
+	private static let timebaseInfo: mach_timebase_info_data_t = {
+		var info = mach_timebase_info_data_t(numer: 1, denom: 1)
+		mach_timebase_info(&info)
+		return info
+	}()
+#endif
+ 
 	public let rawValue: dispatch_time_t
 
 	public static func now() -> DispatchTime {
@@ -39,16 +47,34 @@ public struct DispatchTime : Comparable {
 	/// - Returns: A new `DispatchTime`
 	/// - Discussion: This clock is the same as the value returned by
 	///               `mach_absolute_time` when converted into nanoseconds.
+	///               On some platforms, the nanosecond value is rounded up to a
+	///               multiple of the Mach timebase, using the conversion factors
+	///               returned by `mach_timebase_info()`. The nanosecond equivalent
+	///               of the rounded result can be obtained by reading the
+	///               `uptimeNanoseconds` property.
 	///               Note that `DispatchTime(uptimeNanoseconds: 0)` is
 	///               equivalent to `DispatchTime.now()`, that is, its value
 	///               represents the number of nanoseconds since boot (excluding
 	///               system sleep time), not zero nanoseconds since boot.
 	public init(uptimeNanoseconds: UInt64) {
-		self.rawValue = dispatch_time_t(uptimeNanoseconds)
+		var rawValue = uptimeNanoseconds
+#if HAVE_MACH
+		if (DispatchTime.timebaseInfo.numer != DispatchTime.timebaseInfo.denom) {
+			rawValue = (rawValue * UInt64(DispatchTime.timebaseInfo.denom) 
+				+ UInt64(DispatchTime.timebaseInfo.numer - 1)) / UInt64(DispatchTime.timebaseInfo.numer)
+		}
+#endif
+		self.rawValue = dispatch_time_t(rawValue)
 	}
 
 	public var uptimeNanoseconds: UInt64 {
-		return UInt64(self.rawValue)
+		var result = self.rawValue
+#if HAVE_MACH
+		if (DispatchTime.timebaseInfo.numer != DispatchTime.timebaseInfo.denom) {
+			result = result * UInt64(DispatchTime.timebaseInfo.numer) / UInt64(DispatchTime.timebaseInfo.denom)
+		}
+#endif
+		return result
 	}
 }
 
@@ -81,8 +107,12 @@ public struct DispatchWallTime : Comparable {
 }
 
 public func <(a: DispatchWallTime, b: DispatchWallTime) -> Bool {
-	if a.rawValue == ~0 || b.rawValue == ~0 { return false }
-	return -Int64(a.rawValue) < -Int64(b.rawValue)
+	if b.rawValue == ~0 {
+		return a.rawValue != ~0
+	} else if a.rawValue == ~0 {
+		return false
+	}
+	return -Int64(bitPattern: a.rawValue) < -Int64(bitPattern: b.rawValue)
 }
 
 public func ==(a: DispatchWallTime, b: DispatchWallTime) -> Bool {
@@ -147,7 +177,7 @@ public func +(time: DispatchWallTime, seconds: Double) -> DispatchWallTime {
 }
 
 public func -(time: DispatchWallTime, seconds: Double) -> DispatchWallTime {
-	let interval = seconds * Double(NSEC_PER_SEC)
+	let interval = -seconds * Double(NSEC_PER_SEC)
 	let t = CDispatch.dispatch_time(time.rawValue,
 		interval.isInfinite || interval.isNaN ? Int64.min : Int64(interval))
 	return DispatchWallTime(rawValue: t)