aboutsummaryrefslogtreecommitdiff
path: root/std/os/time.zig
diff options
context:
space:
mode:
Diffstat (limited to 'std/os/time.zig')
-rw-r--r--std/os/time.zig262
1 files changed, 262 insertions, 0 deletions
diff --git a/std/os/time.zig b/std/os/time.zig
new file mode 100644
index 0000000000..f2e1307057
--- /dev/null
+++ b/std/os/time.zig
@@ -0,0 +1,262 @@
+const std = @import("../index.zig");
+const builtin = @import("builtin");
+const Os = builtin.Os;
+const debug = std.debug;
+
+const windows = std.os.windows;
+const darwin = std.os.darwin;
+const posix = std.os.posix;
+
+pub const epoch = @import("epoch.zig");
+
+/// Sleep for the specified duration
+pub fn sleep(seconds: usize, nanoseconds: usize) void {
+ switch(builtin.os) {
+ Os.linux, Os.macosx, Os.ios => {
+ posixSleep(u63(seconds), u63(nanoseconds));
+ },
+ Os.windows => {
+ const milliseconds = seconds * ms_per_s + nanoseconds / (ns_per_s / ms_per_s);
+ windows.Sleep(windows.DWORD(milliseconds));
+ },
+ else => @compileError("Unsupported OS"),
+ }
+}
+
+const u63 = @IntType(false, 63);
+pub fn posixSleep(seconds: u63, nanoseconds: u63) void {
+ var req = posix.timespec {
+ .tv_sec = seconds,
+ .tv_nsec = nanoseconds,
+ };
+ var rem: posix.timespec = undefined;
+ while (true) {
+ const ret_val = posix.nanosleep(&req, &rem);
+ const err = posix.getErrno(ret_val);
+ if (err == 0) return;
+ switch (err) {
+ posix.EFAULT => unreachable,
+ posix.EINVAL => {
+ // Sometimes Darwin returns EINVAL for no reason.
+ // We treat it as a spurious wakeup.
+ return;
+ },
+ posix.EINTR => {
+ req = rem;
+ continue;
+ },
+ else => return,
+ }
+ }
+}
+
+/// Get the posix timestamp, UTC, in seconds
+pub fn timestamp() u64 {
+ return @divFloor(miliTimestamp(), ms_per_s);
+}
+
+/// Get the posix timestamp, UTC, in nanoseconds
+pub const miliTimestamp = switch(builtin.os) {
+ Os.windows => miliTimestampWindows,
+ Os.linux => miliTimestampPosix,
+ Os.macosx, Os.ios => miliTimestampDarwin,
+ else => @compileError("Unsupported OS"),
+};
+
+fn miliTimestampWindows() u64 {
+ //FileTime has a granularity of 100 nanoseconds
+ // and uses the NTFS/Windows epoch
+ var ft: i64 = undefined;
+ windows.GetSystemTimeAsFileTime(&ft);
+ const hns_per_ms = (ns_per_s / 100) / ms_per_s;
+ const epoch_adj = epoch.windows * ms_per_s;
+ return u64(@divFloor(ft, hns_per_ms) + epoch_adj);
+}
+
+fn miliTimestampDarwin() u64 {
+ //Sources suggest MacOS 10.12 has support for
+ // posix clock_gettime.
+ var tv: darwin.timeval = undefined;
+ var err = darwin.gettimeofday(&tv, null);
+ debug.assert(err == 0);
+ return tv.tv_sec * ms_per_s + ts.tv_usec
+ * (us_per_s / ms_per_s);
+}
+
+fn miliTimestampPosix() u64 {
+ //From what I can tell there's no reason clock_gettime
+ // should ever fail for us with CLOCK_REALTIME
+ var ts: posix.timespec = undefined;
+ const err = posix.clock_gettime(posix.CLOCK_REALTIME, &ts);
+ debug.assert(err == 0);
+ const sec_ms = ts.tv_sec * ms_per_s;
+ const nsec_ms = @divFloor(ts.tv_nsec, ns_per_s / ms_per_s);
+ return u64(sec_ms) + u64(nsec_ms);
+}
+
+/// Divisions of a second
+pub const ns_per_s = 1000000000;
+pub const us_per_s = 1000000;
+pub const ms_per_s = 1000;
+pub const cs_per_s = 100;
+
+/// Common time divisions
+pub const s_per_min = 60;
+pub const s_per_hour = s_per_min * 60;
+pub const s_per_day = s_per_hour * 24;
+pub const s_per_week = s_per_day * 7;
+
+
+/// A monotonic high-performance timer.
+/// Timer.start() must be called to initialize the struct, which captures
+/// the counter frequency on windows and darwin, records the resolution,
+/// and gives the user an oportunity to check for the existnece of
+/// monotonic clocks without forcing them to check for error on each read.
+/// .resolution is in nanoseconds on all platforms but .start_time's meaning
+/// depends on the OS. On Windows and Darwin it is a hardware counter
+/// value that requires calculation to convert to a meaninful unit.
+pub const Timer = struct {
+
+ //if we used resolution's value when performing the
+ // performance counter calc on windows, it would be
+ // less precise
+ frequency: switch(builtin.os) {
+ Os.windows => u64,
+ Os.macosx, Os.ios => darwin.mach_timebase_info_data,
+ else => void,
+ },
+ resolution: u64,
+ start_time: u64,
+
+ //Initialize the timer structure.
+ //This gives us an oportunity to grab the counter frequency in windows.
+ //On Windows: QueryPerformanceCounter will succeed on anything > XP.
+ //On Posix: CLOCK_MONOTONIC will only fail if the monotonic counter is not
+ // supported, or if the timespec pointer is out of bounds, which should be
+ // impossible here barring cosmic rays or other such occurances of
+ // incredibly bad luck.
+ //On Darwin: This cannot fail, as far as I am able to tell.
+ pub fn start() !Timer {
+ var self: Timer = undefined;
+
+ switch(builtin.os) {
+ Os.windows => {
+ var freq: i64 = undefined;
+ var err = windows.QueryPerformanceFrequency(&freq);
+ if(err == 0) return error.TimerUnsupported;
+ self.frequency = u64(freq);
+ self.resolution = @divFloor(ns_per_s, self.frequency);
+ var start_time: i64 = undefined;
+ _ = windows.QueryPerformanceCounter(&start_time);
+ self.start_time = u64(start_time);
+ },
+ Os.linux => {
+ var ts: posix.timespec = undefined;
+ var result = posix.clock_getres(posix.CLOCK_MONOTONIC, &ts);
+ switch(posix.getErrno(result)) {
+ 0 => {},
+ posix.EINVAL => return error.TimerUnsupported,
+ else => unreachable,
+ }
+ self.resolution = u64(ts.tv_sec * ns_per_s + ts.tv_nsec);
+ _ = posix.clock_gettime(posix.CLOCK_MONOTONIC, &ts);
+ self.start_time = u64(ts.tv_sec * ns_per_s + ts.tv_nsec);
+ },
+ Os.macosx, Os.ios => {
+ darwin.c.mach_timebase_info(&self.frequency);
+ self.resolution = @divFloor(self.frequency.numer, self.denom);
+ self.start_time = darwin.c.mach_absolute_time();
+ },
+ else => @compileError("Unsupported OS"),
+ }
+ return self;
+ }
+
+ /// Reads the timer value since start or the last reset in nanoseconds
+ pub fn read(self: &Timer) u64 {
+ var clock = clockNative() - self.start_time;
+ return switch(builtin.os) {
+ Os.windows => @divFloor(clock * ns_per_s, self.frequency),
+ Os.linux => clock,
+ Os.macosx, Os.ios => @divFloor(clock * self.frequency.numer, self.frequency.denom),
+ else => @compileError("Unsupported OS"),
+ };
+ }
+
+ /// Resets the timer value to 0/now.
+ pub fn reset(self: &Timer) void
+ {
+ self.start_time = clockNative();
+ }
+
+ /// Returns the current value of the timer in nanoseconds, then resets it
+ pub fn lap(self: &Timer) u64 {
+ var now = clockNative();
+ var lap_time = self.read();
+ self.start_time = now;
+ return lap_time;
+ }
+
+
+ const clockNative = switch(builtin.os) {
+ Os.windows => clockWindows,
+ Os.linux => clockLinux,
+ Os.macosx, Os.ios => clockDarwin,
+ else => @compileError("Unsupported OS"),
+ };
+
+ fn clockWindows() u64 {
+ var result: i64 = undefined;
+ var err = windows.QueryPerformanceCounter(&result);
+ debug.assert(err != 0);
+ return u64(result);
+ }
+
+ fn clockDarwin() u64 {
+ var result: u64 = undefined;
+ darwin.c.mach_absolute_time(&result);
+ return result;
+ }
+
+ fn clockLinux() u64 {
+ var ts: posix.timespec = undefined;
+ var result = posix.clock_gettime(posix.CLOCK_MONOTONIC, &ts);
+ debug.assert(posix.getErrno(result) == 0);
+ return u64(ts.tv_sec * ns_per_s + ts.tv_nsec);
+ }
+};
+
+
+
+
+
+test "os.time.sleep" {
+ sleep(0, 1);
+}
+
+test "os.time.timestamp" {
+ const ns_per_ms = (ns_per_s / ms_per_s);
+ const margin = 50;
+
+ const time_0 = miliTimestamp();
+ sleep(0, ns_per_ms);
+ const time_1 = miliTimestamp();
+ const interval = time_1 - time_0;
+ debug.assert(interval > 0 and interval < margin);
+}
+
+test "os.time.Timer" {
+ const ns_per_ms = (ns_per_s / ms_per_s);
+ const margin = ns_per_ms * 50;
+
+ var timer = try Timer.start();
+ sleep(0, 10 * ns_per_ms);
+ const time_0 = timer.read();
+ debug.assert(time_0 > 0 and time_0 < margin);
+
+ const time_1 = timer.lap();
+ debug.assert(time_1 > time_0);
+
+ timer.reset();
+ debug.assert(timer.read() < time_1);
+} \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-28 05:41:47 +0000