Clock/Instant/Duration

include/swift/Runtime/Concurrency.h

@@ -665,6 +665,10 @@ using JobDelay = unsigned long long;
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueGlobalWithDelay(JobDelay delay, Job *job);
 
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_enqueueGlobalWithDeadline(long long sec, long long nsec,
+    long long tsec, long long tnsec, int clock, Job *job);
+
 /// Enqueue the given job on the main executor.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueMainExecutor(Job *job);
@@ -691,6 +695,21 @@ SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDelay_hook)(
     unsigned long long delay, Job *job,
     swift_task_enqueueGlobalWithDelay_original original);
 
+typedef SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDeadline_original)(
+    long long sec,
+    long long nsec,
+    long long tsec,
+    long long tnsec,
+    int clock, Job *job);
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift) void (*swift_task_enqueueGlobalWithDeadline_hook)(
+    long long sec,
+    long long nsec,
+    long long tsec,
+    long long tnsec,
+    int clock, Job *job,
+    swift_task_enqueueGlobalWithDeadline_original original);
+
 /// A hook to take over main executor enqueueing.
 typedef SWIFT_CC(swift) void (*swift_task_enqueueMainExecutor_original)(
     Job *job);
@@ -825,6 +844,21 @@ void swift_task_donateThreadToGlobalExecutorUntil(bool (*condition)(void*),
 
 #endif
 
+enum swift_clock_id : int {
+  swift_clock_id_continuous = 1,
+  swift_clock_id_suspending = 2
+};
+
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_get_time(long long *seconds,
+                    long long *nanoseconds,
+                    swift_clock_id clock_id);
+
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_get_clock_res(long long *seconds,
+                         long long *nanoseconds,
+                         swift_clock_id clock_id);
+
 #ifdef __APPLE__
 /// A magic symbol whose address is the mask to apply to a frame pointer to
 /// signal that it is an async frame. Do not try to read the actual value of

stdlib/public/Concurrency/CMakeLists.txt

@@ -113,6 +113,10 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   AsyncThrowingStream.swift
   AsyncStream.cpp
   Deque.swift
+  Clock.cpp
+  Clock.swift
+  ContinuousClock.swift
+  SuspendingClock.swift
   ${swift_concurrency_extra_sources}
   linker-support/magic-symbols-for-install-name.c
 

stdlib/public/Concurrency/Clock.cpp

@@ -0,0 +1,140 @@
+//===--- Clock.cpp - Time and clock resolution ----------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Runtime/Concurrency.h"
+
+#if __has_include(<time.h>)
+#define HAS_TIME 1
+#include <time.h>
+#endif
+#if defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <Windows.h>
+#endif
+
+using namespace swift;
+
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift)
+void swift_get_time(
+  long long *seconds,
+  long long *nanoseconds,
+  swift_clock_id clock_id) {
+  switch (clock_id) {
+    case swift_clock_id_continuous: {
+#if defined(__linux__) && HAS_TIME
+      struct timespec continuous;
+      clock_gettime(CLOCK_BOOTTIME, &continuous);
+      *seconds = continuous.tv_sec;
+      *nanoseconds = continuous.tv_nsec;
+#elif defined(__APPLE__) && HAS_TIME
+      struct timespec continuous;
+      clock_gettime(CLOCK_MONOTONIC, &continuous);
+      *seconds = continuous.tv_sec;
+      *nanoseconds = continuous.tv_nsec;
+#elif defined(_WIN32)
+      LARGE_INTEGER freq;
+      QueryPerformanceFrequency(&freq);
+      LARGE_INTEGER count;
+      QueryPerformanceCounter(&count);
+      *seconds = count.QuadPart / freq.QuadPart;
+      if (freq.QuadPart < 1000000000) {
+        *nanoseconds = 
+            ((count.QuadPart % freq.QuadPart) * 1000000000) / freq.QuadPart;
+      } else {
+        *nanoseconds = 
+            (count.QuadPart % freq.QuadPart) * (1000000000.0 / freq.QuadPart);
+      }
+#else
+#error Missing platform continuous time definition
+#endif
+      break;
+    }
+    case swift_clock_id_suspending: {
+#if defined(__linux__) && HAS_TIME
+      struct timespec suspending;
+      clock_gettime(CLOCK_MONOTONIC_RAW, &suspending);
+      *seconds = suspending.tv_sec;
+      *nanoseconds = suspending.tv_nsec;
+#elif defined(__APPLE__) && HAS_TIME
+      struct timespec suspending;
+      clock_gettime(CLOCK_UPTIME_RAW, &suspending);
+      *seconds = suspending.tv_sec;
+      *nanoseconds = suspending.tv_nsec;
+#elif defined(_WIN32)
+      LARGE_INTEGER freq;
+      QueryPerformanceFrequency(&freq);
+      LARGE_INTEGER count;
+      QueryPerformanceCounter(&count);
+      *seconds = count.QuadPart / freq.QuadPart;
+      if (freq.QuadPart < 1000000000) {
+        *nanoseconds = 
+            ((count.QuadPart % freq.QuadPart) * 1000000000) / freq.QuadPart;
+      } else {
+        *nanoseconds = 
+            (count.QuadPart % freq.QuadPart) * (1000000000.0 / freq.QuadPart);
+      }
+#else
+#error Missing platform suspending time definition
+#endif
+      break;
+    }
+  }
+}
+
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift)
+void swift_get_clock_res(
+  long long *seconds,
+  long long *nanoseconds,
+  swift_clock_id clock_id) {
+switch (clock_id) {
+    case swift_clock_id_continuous: {
+#if defined(__linux__) && HAS_TIME
+      struct timespec continuous;
+      clock_getres(CLOCK_BOOTTIME, &continuous);
+      *seconds = continuous.tv_sec;
+      *nanoseconds = continuous.tv_nsec;
+#elif defined(__APPLE__) && HAS_TIME
+      struct timespec continuous;
+      clock_getres(CLOCK_MONOTONIC, &continuous);
+      *seconds = continuous.tv_sec;
+      *nanoseconds = continuous.tv_nsec;
+#elif defined(_WIN32)
+      *seconds = 0;
+      *nanoseconds = 1000;
+#else
+#error Missing platform continuous time definition
+#endif
+      break;
+    }
+    case swift_clock_id_suspending: {
+      struct timespec suspending;
+#if defined(__linux__) && HAS_TIME
+      clock_getres(CLOCK_MONOTONIC_RAW, &suspending);
+      *seconds = suspending.tv_sec;
+      *nanoseconds = suspending.tv_nsec;
+#elif defined(__APPLE__) && HAS_TIME
+      clock_gettime(CLOCK_UPTIME_RAW, &suspending);
+      *seconds = suspending.tv_sec;
+      *nanoseconds = suspending.tv_nsec;
+#elif defined(_WIN32)
+      *seconds = 0;
+      *nanoseconds = 1000;
+#else
+#error Missing platform suspending time definition
+#endif
+      break;
+    }
+  }
+}

stdlib/public/Concurrency/Clock.swift

@@ -0,0 +1,98 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+import Swift
+
+/// A mechanism in which to measure time, and delay work until a given point 
+/// in time.
+///
+/// Types that conform to the `Clock` protocol define a concept of "now" which 
+/// is the specific instant in time that property is accessed. Any pair of calls
+/// to the `now` property may have a minimum duration between them - this
+/// minimum resolution is exposed by the `minimumResolution` property to inform
+/// any user of the type the expected granularity of accuracy. 
+///
+/// One of the primary uses for clocks is to schedule task sleeping. This method
+/// resumes the calling task after a given deadline has been met or passed with
+/// a given tolerance value. The tolerance is expected as a leeway around the 
+/// deadline. The clock may reschedule tasks within the tolerance to ensure 
+/// efficient execution of resumptions by reducing potential operating system
+/// wake-ups. If no tolerance is specified (i.e. nil is passed in) the sleep
+/// function is expected to schedule with a default tolerance strategy. 
+///
+/// For more information about specific clocks see `ContinuousClock` and 
+/// `SuspendingClock`.
+@available(SwiftStdlib 5.7, *)
+public protocol Clock: Sendable {
+  associatedtype Instant: InstantProtocol
+
+  var now: Instant { get }
+  var minimumResolution: Instant.Duration { get }
+
+  func sleep(until deadline: Instant, tolerance: Instant.Duration?) async throws
+}
+
+
+@available(SwiftStdlib 5.7, *)
+extension Clock {
+  /// Measure the elapsed time to execute a closure.
+  ///
+  ///       let clock = ContinuousClock()
+  ///       let elapsed = clock.measure {
+  ///          someWork()
+  ///       }
+  @available(SwiftStdlib 5.7, *)
+  public func measure(_ work: () throws -> Void) rethrows -> Instant.Duration {
+    let start = now
+    try work()
+    let end = now
+    return start.duration(to: end)
+  }
+
+  /// Measure the elapsed time to execute an asynchronous closure.
+  ///
+  ///       let clock = ContinuousClock()
+  ///       let elapsed = await clock.measure {
+  ///          await someWork()
+  ///       }
+  @available(SwiftStdlib 5.7, *)
+  public func measure(
+    _ work: () async throws -> Void
+  ) async rethrows -> Instant.Duration {
+    let start = now
+    try await work()
+    let end = now
+    return start.duration(to: end)
+  }
+}
+
+@available(SwiftStdlib 5.7, *)
+@usableFromInline
+enum _ClockID: Int32 {
+  case continuous = 1
+  case suspending = 2
+}
+
+@available(SwiftStdlib 5.7, *)
+@_silgen_name("swift_get_time")
+@usableFromInline
+internal func _getTime(
+  seconds: UnsafeMutablePointer<Int64>,
+  nanoseconds: UnsafeMutablePointer<Int64>,
+  clock: _ClockID)
+
+@available(SwiftStdlib 5.7, *)
+@_silgen_name("swift_get_clock_res")
+@usableFromInline
+internal func _getClockRes(
+  seconds: UnsafeMutablePointer<Int64>,
+  nanoseconds: UnsafeMutablePointer<Int64>,
+  clock: _ClockID)