// SPDX-License-Identifier: MPL-2.0 // (c) Hare authors use errors; use rt; // Converts a [[duration]] to an [[rt::timespec]]. This function is // non-portable. export fn duration_to_timespec(n: duration) rt::timespec = rt::timespec { tv_sec = n / SECOND, tv_nsec = n % SECOND, }; // Converts a [[rt::timespec]] to a [[duration]]. This function is non-portable. export fn timespec_to_duration(spec: rt::timespec) duration = { return (spec.tv_sec: i64 * SECOND) + spec.tv_nsec: i64; }; // Converts a [[duration]] to an [[rt::timeval]]. This function is // non-portable. export fn duration_to_timeval(d: duration) rt::timeval = rt::timeval { tv_sec = d / SECOND, tv_usec = d % SECOND / 1000, }; // Converts an [[instant]] to an [[rt::timespec]]. This function is // non-portable. export fn instant_to_timespec(t: instant) rt::timespec = rt::timespec { tv_sec = t.sec, tv_nsec = t.nsec, }; // Converts a [[rt::timespec]] to an [[instant]]. This function is // non-portable. export fn timespec_to_instant(ts: rt::timespec) instant = instant { sec = ts.tv_sec, nsec = ts.tv_nsec, }; // Yields the process to the kernel and returns after the requested duration. export fn sleep(d: duration) void = { let req = duration_to_timespec(d); for (true) { let res = rt::timespec { ... }; match (rt::nanosleep(&req, &res)) { case void => return; case let err: rt::errno => switch (err) { case rt::EINTR => req = res; case => abort("Unexpected error from nanosleep"); }; }; }; }; // An enumeration of clocks available on this system. Different clocks represent // times from different epochs, and have different characteristics with regards // to leap seconds, NTP adjustments, and so on. All systems provide the REALTIME // and MONOTONIC clocks at least; use of other clocks is not guaranteed to be // portable. export type clock = enum { // The current wall-clock time. This may jump forwards or backwards in // time to account for leap seconds, NTP adjustments, etc. REALTIME = rt::CLOCK_REALTIME, // The current monotonic time. This clock measures from some undefined // epoch and is not affected by leap seconds, NTP adjustments, and // changes to the system time: it always increases by one second per // second. MONOTONIC = rt::CLOCK_MONOTONIC, // TODO: Document these VIRTUAL = rt::CLOCK_VIRTUAL, PROF = rt::CLOCK_PROF, UPTIME = rt::CLOCK_UPTIME, UPTIME_PRECISE = rt::CLOCK_UPTIME_PRECISE, UPTIME_FAST = rt::CLOCK_UPTIME_FAST, REALTIME_PRECISE = rt::CLOCK_REALTIME_PRECISE, REALTIME_FAST = rt::CLOCK_REALTIME_FAST, MONOTONIC_PRECISE = rt::CLOCK_MONOTONIC_PRECISE, MONOTONIC_FAST = rt::CLOCK_MONOTONIC_FAST, SECOND = rt::CLOCK_SECOND, THREAD_CPUTIME_ID = rt::CLOCK_THREAD_CPUTIME_ID, PROCESS_CPUTIME_ID = rt::CLOCK_PROCESS_CPUTIME_ID, }; // Returns the current time for a given clock. export fn now(clock: clock) instant = { let tp = rt::timespec { ... }; match (rt::clock_gettime(clock, &tp)) { case void => return timespec_to_instant(tp); case let err: rt::errno => abort("Unexpected error from clock_gettime"); }; }; // Sets system clock to given time. export fn set(clock: clock, t: instant) (void | errors::noaccess) = { let tp = instant_to_timespec(t); let err = match (rt::clock_settime(clock, &tp)) { case void => return; case let err: rt::errno => yield err; }; if (err == rt::EPERM) { return errors::noaccess; }; abort("Unexpected error from clock_settime"); };