`Time`-related procedures and types, including `sleep`, `now`, and string formatting of moments.

Collection Info

View Source
Collection
core
Path
time
Entries
109
Constants 29
Jump to Constants
ABSOLUTE_TO_INTERNAL ABSOLUTE_TO_UNIX ABSOLUTE_ZERO_YEAR DAYS_PER_100_YEARS DAYS_PER_4_YEARS DAYS_PER_400_YEARS Hour INTERNAL_TO_ABSOLUTE INTERNAL_TO_UNIX INTERNAL_TO_WALL IS_SUPPORTED MAX_DURATION Microsecond Millisecond MIN_DURATION MIN_HMS_12_LEN +13 more
Types 8
Jump to Types
Benchmark_Error Benchmark_Options Duration Month Stopwatch Tick Time Weekday
Procedures 67
Jump to Procedures
accurate_sleep benchmark clock_from_duration clock_from_seconds clock_from_stopwatch clock_from_time components_to_time compound_to_time date day diff duration_hours duration_microseconds duration_milliseconds duration_minutes duration_nanoseconds +51 more
Procedure Groups 4
Jump to Procedure Groups
clock datetime_to_time precise_clock to_string_hms
Variables 1
Jump to Variables
days_before

Source Files

Constants

29

ABSOLUTE_TO_INTERNAL #

Source 
ABSOLUTE_TO_INTERNAL :: i64(-9223371966579724800)

i64((ABSOLUTE_ZERO_YEAR - 1) * 365.2425 * SECONDS_PER_DAY);

ABSOLUTE_ZERO_YEAR #

Source 
ABSOLUTE_ZERO_YEAR :: i64(-292277022399)

Day is chosen so that 2001-01-01 is Monday in the calculations

DAYS_PER_100_YEARS #

Source 
DAYS_PER_100_YEARS :: 365 * 100 + 24

Days in 100 years, with leap days.

DAYS_PER_4_YEARS #

Source 
DAYS_PER_4_YEARS :: 365 * 4 + 1

Days in 4 years, with leap days.

DAYS_PER_400_YEARS #

Source 
DAYS_PER_400_YEARS :: 365 * 400 + 97

Days in 400 years, with leap days.

Hour #

Source 
Hour :: 60 * Minute

The duration equal to one hour (3600 seconds).

INTERNAL_TO_ABSOLUTE #

Source 
INTERNAL_TO_ABSOLUTE :: -ABSOLUTE_TO_INTERNAL

IS_SUPPORTED #

Source 
IS_SUPPORTED :: _IS_SUPPORTED

Value specifying whether the time procedures are supported by the current platform.

MAX_DURATION #

Source 
MAX_DURATION :: Duration(1 << 63 - 1)

Maximum representable duration.

Microsecond #

Source 
Microsecond :: 1000 * Nanosecond

The duration equal to one microsecond (1e-6 seconds).

Millisecond #

Source 
Millisecond :: 1000 * Microsecond

The duration equal to one millisecond (1e-3 seconds).

MIN_DURATION #

Source 
MIN_DURATION :: Duration(-1 << 63)

Minimum representable duration.

Minute #

Source 
Minute :: 60 * Second

The duration equal to one minute (60 seconds).

Nanosecond #

Source 
Nanosecond :: Duration(1)

The duration equal to one nanosecond (1e-9 seconds).

Second #

Source 
Second :: 1000 * Millisecond

The duration equal to one second.

SECONDS_PER_DAY #

Source 
SECONDS_PER_DAY :: 24 * SECONDS_PER_HOUR

Number of seconds in a day (without leap seconds).

SECONDS_PER_HOUR #

Source 
SECONDS_PER_HOUR :: 60 * SECONDS_PER_MINUTE

Number of seconds in an hour (without leap seconds).

SECONDS_PER_MINUTE #

Source 
SECONDS_PER_MINUTE :: 60

Number of seconds in a minute (without leap seconds).

SECONDS_PER_WEEK #

Source 
SECONDS_PER_WEEK :: 7 * SECONDS_PER_DAY

Number of seconds in a week (without leap seconds).

UNIX_TO_ABSOLUTE #

Source 
UNIX_TO_ABSOLUTE :: UNIX_TO_INTERNAL + INTERNAL_TO_ABSOLUTE

UNIX_TO_INTERNAL #

Source 
UNIX_TO_INTERNAL :: i64((1969 * 365 + 1969 / 4 - 1969 / 100 + 1969 / 400) * SECONDS_PER_DAY)

WALL_TO_INTERNAL #

Source 
WALL_TO_INTERNAL :: i64((1884 * 365 + 1884 / 4 - 1884 / 100 + 1884 / 400) * SECONDS_PER_DAY)

Types

8

Duration #

Source 
Duration :: distinct Duration

Type representing duration, with nanosecond precision. This is the regular Unix timestamp, scaled to nanosecond precision.

Stopwatch #

Source 
Stopwatch :: Stopwatch

Type representing a stopwatch. The stopwatch is used for measuring the total time in multiple "runs". When the stopwatch is started, it starts counting time. When the stopwatch is stopped, the difference in time between the last start and the stop is added to the total. When the stopwatch resets, the total is reset.

Tick #

Source 
Tick :: Tick

Type representing monotonic time, useful for measuring durations.

Time #

Source 
Time :: Time

Specifies time since the UNIX epoch, with nanosecond precision. Capable of representing any time within the following range: - `min: 1677-09-21 00:12:44.145224192 +0000 UTC` - `max: 2262-04-11 23:47:16.854775807 +0000 UTC`

Procedures

67

accurate_sleep #

Source 
accurate_sleep :: proc "contextless" (d: Duration) {…}

Accurate sleep This procedure sleeps for the duration specified by `d`, very accurately. **Note**: Implementation borrowed from: [this source](https://blat-blatnik.github.io/computerBear/making-accurate-sleep-function/) **Note(linux)**: The accuracy is within around 4µs (microseconds), in the worst case. **Note(windows)**: The accuracy depends but is comparable with regular sleep in the worst case. To get the same kind of accuracy as on Linux, have your program call `windows.timeBeginPeriod(1)` to tell Windows to use a more accurate timer for your process. Additionally your program should call `windows.timeEndPeriod(1)` once you're done with `accurate_sleep`.

benchmark #

Source 
benchmark :: proc(options: ^Benchmark_Options, allocator := context.allocator) -> (err: Benchmark_Error) {…}

Benchmark a procedure. This procedure produces a benchmark. The procedure specified in the `bench` field of the `options` parameter will be benchmarked. The following metrics can be obtained: - Run time of the procedure - Number of elements per second processed on average - Number of bytes per second this processed on average In order to obtain these metrics, the `bench()` procedure writes to `options` struct the number of elements or bytes it has processed.

clock_from_duration #

Source 
@(require_results)
clock_from_duration :: proc "contextless" (d: Duration) -> (hour, min, sec: int) {…}

Obtain the time components from a duration.

clock_from_seconds #

Source 
@(require_results)
clock_from_seconds :: proc "contextless" (in_sec: u64) -> (hour, min, sec: int) {…}

Obtain the time components from the number of seconds.

clock_from_stopwatch #

Source 
@(require_results)
clock_from_stopwatch :: proc "contextless" (s: Stopwatch) -> (hour, min, sec: int) {…}

Obtain the time components from a stopwatch's total.

clock_from_time #

Source 
@(require_results)
clock_from_time :: proc "contextless" (t: Time) -> (hour, min, sec: int) {…}

Obtain the time components from a time.

components_to_time #

Source 
@(require_results)
components_to_time :: proc "contextless" (
	#any_int year, #any_int month, #any_int day, #any_int hour, #any_int minute, #any_int second: i64, 
	#any_int nsec:                                   i64 = i64(0), 
) -> (t: Time, ok: bool) #optional_ok {…}

Convert datetime components into time. This procedure calculates the time from datetime components supplied in the arguments to this procedure. If the datetime components don't represent a valid datetime, the function returns `false` in the second argument.

compound_to_time #

Source 
@(require_results)
compound_to_time :: proc "contextless" (datetime: DateTime) -> (t: Time, ok: bool) {…}

Convert datetime into time. If the datetime represents a time outside of a valid range, `false` is returned as the second return value. See `Time` for the representable range.

date #

Source 
@(require_results)
date :: proc "contextless" (t: Time) -> (year: int, month: Month, day: int) {…}

Parse time into date components.

day #

Source 
@(require_results)
day :: proc "contextless" (t: Time) -> (day: int) {…}

Obtain the day of the date specified by time.

diff #

Source 
@(require_results)
diff :: proc "contextless" (start, end: Time) -> Duration {…}

Calculate the duration elapsed between two times.

duration_hours #

Source 
@(require_results)
duration_hours :: proc "contextless" (d: Duration) -> f64 {…}

Obtain the number of hours in a duration.

duration_microseconds #

Source 
@(require_results)
duration_microseconds :: proc "contextless" (d: Duration) -> f64 {…}

Obtain the number of microseconds in a duration.

duration_milliseconds #

Source 
@(require_results)
duration_milliseconds :: proc "contextless" (d: Duration) -> f64 {…}

Obtain the number of milliseconds in a duration.

duration_minutes #

Source 
@(require_results)
duration_minutes :: proc "contextless" (d: Duration) -> f64 {…}

Obtain the number of minutes in a duration.

duration_nanoseconds #

Source 
@(require_results)
duration_nanoseconds :: proc "contextless" (d: Duration) -> i64 {…}

Obtain the number of nanoseconds in a duration.

duration_round #

Source 
@(require_results)
duration_round :: proc "contextless" (d, m: Duration) -> Duration {…}

Round a duration to a specific unit This procedure rounds the duration to a specific unit **Note**: Any duration can be supplied as a unit. Inputs: - d: The duration to round - m: The unit to round to Returns: - The duration `d`, rounded to the unit specified by `m` Example: time.duration_round(my_duration, time.Second)

duration_seconds #

Source 
@(require_results)
duration_seconds :: proc "contextless" (d: Duration) -> f64 {…}

Obtain the number of seconds in a duration.

duration_to_string_hms #

Source 
@(require_results)
duration_to_string_hms :: proc(d: Duration, buf: []u8) -> (res: string) {…}

Formats a `Duration` as a 24-hour `hh:mm:ss` string. **Does not allocate** Inputs: - d: The Duration to format. - buf: The backing buffer to use. Returns: - res: The formatted string, backed by buf Example: buf: [MIN_HMS_LEN]u8 d := time.since(earlier) fmt.println(time.to_string_hms(now, buf[:]))

duration_truncate #

Source 
@(require_results)
duration_truncate :: proc "contextless" (d, m: Duration) -> Duration {…}

Truncate the duration to the specified unit. This procedure truncates the duration `d` to the unit specified by `m`. **Note**: Any duration can be supplied as a unit. Inputs: - d: The duration to truncate. - m: The unit to truncate to. Returns: - The duration `d`, truncated to the unit specified by `m`. Example: time.duration_round(my_duration, time.Second)

from_nanoseconds #

Source 
@(require_results)
from_nanoseconds :: proc "contextless" (nsec: i64) -> Time {…}

Obtain time from unix nanoseconds.

has_invariant_tsc #

Source 
@(require_results)
has_invariant_tsc :: proc "contextless" () -> bool {…}

Check if the CPU has invariant TSC. This procedure checks if the CPU contains an invariant TSC (Time stamp counter). Invariant TSC is a feature of modern processors that allows them to run their TSC at a fixed frequency, independent of ACPI state, and CPU frequency.

is_leap_year #

Source 
@(require_results)
is_leap_year :: proc "contextless" (year: int) -> (leap: bool) {…}

Check if a year is a leap year.

iso8601_to_components #

Source 
@(require_results)
iso8601_to_components :: proc(iso_datetime: string) -> (res: DateTime, utc_offset: int, is_leap: bool, consumed: int) {…}

Parse an ISO 8601 string into a datetime and a UTC offset in minutes. This procedure parses an ISO 8601 string of roughly the following format: ```text YYYY-MM-DD[Tt]HH:mm:ss[.nn][Zz][+-]HH:mm ``` And returns datetime, in UTC represented by that string, and the UTC offset, in minutes. **Inputs**: - `iso_datetime`: The string to be parsed **Returns**: - `res`: The parsed datetime, in UTC. - `utc_offset`: The UTC offset, in minutes. - `is_leap`: Specifies whether the moment was a leap second. - `consumed`: The number of bytes consumed by parsing the string. **Notes**: - This procedure performs no validation on whether components are valid, e.g. it'll return hour = 25 if that's what it's given in the specified string.

iso8601_to_time_and_offset #

Source 
@(require_results)
iso8601_to_time_and_offset :: proc(iso_datetime: string, is_leap: ^bool = nil) -> (res: Time, utc_offset: int, consumed: int) {…}

Parse an ISO 8601 string into a time and a UTC offset in minutes. This procedure parses an ISO 8601 string of roughly the following format: ```text YYYY-MM-DD[Tt]HH:mm:ss[.nn][Zz][+-]HH:mm ``` And returns time, in UTC represented by that string, and the UTC offset, in minutes. **Inputs**: - `iso_datetime`: The string to be parsed. - `is_leap`: Optional output parameter, specifying if the moment was a leap second. **Returns**: - `res`: The time in UTC. - `utc_offset`: The UTC offset of the time, in minutes. - `consumed`: Number of bytes consumed by parsing the string. **Notes**: - Only 4-digit years are accepted. - Leap seconds are smeared into 23:59:59.

iso8601_to_time_utc #

Source 
@(require_results)
iso8601_to_time_utc :: proc(iso_datetime: string, is_leap: ^bool = nil) -> (res: Time, consumed: int) {…}

Parse an ISO 8601 string into a time with UTC offset applied to it. This procedure parses an ISO 8601 string of roughly the following format: ```text YYYY-MM-DD[Tt]HH:mm:ss[.nn][Zz][+-]HH:mm ``` And returns time, in UTC represented by that string. In case the timezone offset is specified in the string, that timezone is applied to time. **Inputs**: - `iso_datetime`: The string to be parsed. - `is_leap`: Optional output parameter, specifying if the moment was a leap second. **Returns**: - `res`: The time represented by `iso_datetime`, with UTC offset applied. - `consumed`: Number of bytes consumed by parsing the string. **Notes**: - Only 4-digit years are accepted. - Leap seconds are smeared into 23:59:59.

month #

Source 
@(require_results)
month :: proc "contextless" (t: Time) -> (month: Month) {…}

Obtain the month of the date specified by time.

now #

Source 
@(require_results)
now :: proc "contextless" () -> Time {…}

Obtain the current time.

precise_clock_from_duration #

Source 
@(require_results)
precise_clock_from_duration :: proc "contextless" (d: Duration) -> (hour, min, sec, nanos: int) {…}

Obtain the time components from a duration, including nanoseconds.

precise_clock_from_stopwatch #

Source 
@(require_results)
precise_clock_from_stopwatch :: proc "contextless" (s: Stopwatch) -> (hour, min, sec, nanos: int) {…}

Obtain the time components from a stopwatch's total, including nanoseconds

precise_clock_from_time #

Source 
@(require_results)
precise_clock_from_time :: proc "contextless" (t: Time) -> (hour, min, sec, nanos: int) {…}

Obtain the time components from a time, including nanoseconds.

read_cycle_counter #

Source 
@(require_results)
read_cycle_counter :: proc "contextless" () -> u64 {…}

Read the timestamp counter of the CPU.

rfc3339_to_components #

Source 
@(require_results)
rfc3339_to_components :: proc(rfc_datetime: string) -> (res: DateTime, utc_offset: int, is_leap: bool, consumed: int) {…}

Parse an RFC 3339 string into a datetime and a UTC offset in minutes. This procedure parses the specified RFC 3339 strings of roughly the following format: ```text YYYY-MM-DD[Tt]HH:mm:ss[.nn][Zz][+-]HH:mm ``` And returns the datetime, in UTC and the UTC offset, in minutes, that were represented by the RFC 3339 string. **Inputs**: - `rfc_datetime`: The RFC 3339 string to parse. **Returns**: - `res`: The datetime, in UTC, that was parsed from the RFC 3339 string. - `utc_offset`: The UTC offset, in minutes, that was parsed from the RFC 3339 string. - `is_leap`: Specifies whether the moment was a leap second. - `consumed`: Number of bytes consumed by parsing the string. Performs no validation on whether components are valid, e.g. it'll return hour = 25 if that's what it's given

rfc3339_to_time_and_offset #

Source 
@(require_results)
rfc3339_to_time_and_offset :: proc(rfc_datetime: string, is_leap: ^bool = nil) -> (res: Time, utc_offset: int, consumed: int) {…}

Parse an RFC 3339 string into a time and a UTC offset in minutes. This procedure parses the specified RFC 3339 strings of roughly the following format: ```text YYYY-MM-DD[Tt]HH:mm:ss[.nn][Zz][+-]HH:mm ``` And returns the time, in UTC and a UTC offset, in minutes, that were represented by the RFC 3339 string. **Inputs**: - `rfc_datetime`: The RFC 3339 string to be parsed. - `is_leap`: Optional output parameter specifying whether the moment was a leap second. **Returns**: - `res`: The time, in UTC, that was parsed from the RFC 3339 string. - `utc_offset`: The UTC offset, in minutes, that was parsed from the RFC 3339 string. - `consumed`: The number of bytes consumed by parsing the string. **Notes**: - Only 4-digit years are accepted. - Leap seconds are smeared into 23:59:59.

rfc3339_to_time_utc #

Source 
@(require_results)
rfc3339_to_time_utc :: proc(rfc_datetime: string, is_leap: ^bool = nil) -> (res: Time, consumed: int) {…}

Parse an RFC 3339 string into time with a UTC offset applied to it. This procedure parses the specified RFC 3339 strings of roughly the following format: ```text YYYY-MM-DD[Tt]HH:mm:ss[.nn][Zz][+-]HH:mm ``` And returns the time that was represented by the RFC 3339 string, with the UTC offset applied to it. **Inputs**: - `rfc_datetime`: An RFC 3339 string to parse. - `is_leap`: Optional output parameter specifying whether the moment was a leap second. **Returns**: - `res`: The time, with UTC offset applied, that was parsed from the RFC 3339 string. - `consumed`: The number of bytes consumed by parsing the RFC 3339 string. **Notes**: - Only 4-digit years are accepted. - Leap seconds are smeared into 23:59:59.

SCOPED_TICK_DURATION #

Source 
@(deferred_in_out=_tick_duration_end)
SCOPED_TICK_DURATION :: proc "contextless" (d: ^Duration) -> Tick {…}

Capture the duration the code in the current scope takes to execute.

since #

Source 
@(require_results)
since :: proc "contextless" (start: Time) -> Duration {…}

Calculate the duration elapsed since a specific time.

stopwatch_duration #

Source 
@(require_results)
stopwatch_duration :: proc "contextless" (stopwatch: Stopwatch) -> Duration {…}

Obtain the total time, counted by the stopwatch. This procedure obtains the total time, counted by the stopwatch. If the stopwatch isn't stopped at the time of calling this procedure, the time between the last start and the current time is also accounted for.

tick_diff #

Source 
@(require_results)
tick_diff :: proc "contextless" (start, end: Tick) -> Duration {…}

Obtain the difference between ticks.

tick_lap_time #

Source 
@(require_results)
tick_lap_time :: proc "contextless" (prev: ^Tick) -> Duration {…}

Incrementally obtain durations since last tick. This procedure returns the duration between the current tick and the tick stored in `prev` pointer, and then stores the current tick in location, specified by `prev`. If the prev pointer contains an zero-initialized tick, then the returned duration is 0. This procedure is meant to be used in a loop, or in other scenarios, where one might want to obtain time between multiple ticks at specific points.

tick_now #

Source 
@(require_results)
tick_now :: proc "contextless" () -> Tick {…}

Obtain the current tick.

tick_since #

Source 
@(require_results)
tick_since :: proc "contextless" (start: Tick) -> Duration {…}

Obtain the duration since last tick.

time_to_rfc3339 #

Source 
@(require_results)
time_to_rfc3339 :: proc(time: Time, utc_offset: int = 0, include_nanos: bool = true, allocator := context.allocator) -> (res: string, ok: bool) {…}

Serialize the timestamp as a RFC 3339 string. The boolean `ok` is false if the `time` is not a valid datetime, or if allocating the result string fails. **Inputs**: - `utc_offset`: offset in minutes wrt UTC (ie. the timezone) - `include_nanos`: whether to include nanoseconds in the result.

time_to_string_hms #

Source 
@(require_results)
time_to_string_hms :: proc(t: Time, buf: []u8) -> (res: string) {…}

Formats a `Time` as a 24-hour `hh:mm:ss` string. **Does not allocate** Inputs: - t: The Time to format. - buf: The backing buffer to use. Returns: - res: The formatted string, backed by buf Example: buf: [MIN_HMS_LEN]u8 now := time.now() fmt.println(time.to_string_hms(now, buf[:]))

time_to_unix #

Source 
@(require_results)
time_to_unix :: proc "contextless" (t: Time) -> i64 {…}

Obtain the Unix timestamp in seconds from a Time.

time_to_unix_nano #

Source 
@(require_results)
time_to_unix_nano :: proc "contextless" (t: Time) -> i64 {…}

Obtain the Unix timestamp in nanoseconds from a Time.

to_string_dd_mm_yy #

Source 
@(require_results)
to_string_dd_mm_yy :: proc(t: Time, buf: []u8) -> (res: string) {…}

Formats a Time as a dd-mm-yy date string. Inputs: - t: The Time to format. - buf: The backing buffer to use. Returns: - res: The formatted string, backed by `buf`. Example: buf: [MIN_YY_DATE_LEN]u8 now := time.now() fmt.println(time.to_string_dd_mm_yy(now, buf[:]))

to_string_dd_mm_yyyy #

Source 
@(require_results)
to_string_dd_mm_yyyy :: proc(t: Time, buf: []u8) -> (res: string) {…}

Formats a Time as a dd-mm-yyyy date string. Inputs: - t: The Time to format. - buf: The backing buffer to use. Returns: - res: The formatted string, backed by `buf`. Example: buf: [MIN_YYYY_DATE_LEN]u8 now := time.now() fmt.println(time.to_string_dd_mm_yyyy(now, buf[:]))

to_string_hms_12 #

Source 
@(require_results)
to_string_hms_12 :: proc(t: Time, buf: []u8, ampm: [2]string = {" am", " pm"}) -> (res: string) {…}

Formats a `Time` as a 12-hour `hh:mm:ss pm` string **Does not allocate** Inputs: - t: The Time to format - buf: The backing buffer to use - ampm: An optional pair of am/pm strings to use in place of the default Returns: - res: The formatted string, backed by buf Example: buf: [64]u8 now := time.now() fmt.println(time.to_string_hms_12(now, buf[:])) fmt.println(time.to_string_hms_12(now, buf[:], {"㏂", "㏘"}))

to_string_mm_dd_yy #

Source 
@(require_results)
to_string_mm_dd_yy :: proc(t: Time, buf: []u8) -> (res: string) {…}

Formats a Time as a mm-dd-yy date string. Inputs: - t: The Time to format. - buf: The backing buffer to use. Returns: - res: The formatted string, backed by `buf`. Example: buf: [MIN_YY_DATE_LEN]u8 now := time.now() fmt.println(time.to_string_mm_dd_yy(now, buf[:]))

to_string_mm_dd_yyyy #

Source 
@(require_results)
to_string_mm_dd_yyyy :: proc(t: Time, buf: []u8) -> (res: string) {…}

Formats a Time as a mm-dd-yyyy date string. Inputs: - t: The Time to format. - buf: The backing buffer to use. Returns: - res: The formatted string, backed by `buf`. Example: buf: [MIN_YYYY_DATE_LEN]u8 now := time.now() fmt.println(time.to_string_mm_dd_yyyy(now, buf[:]))

to_string_yy_mm_dd #

Source 
@(require_results)
to_string_yy_mm_dd :: proc(t: Time, buf: []u8) -> (res: string) {…}

Formats a Time as a yy-mm-dd date string. Inputs: - t: The Time to format. - buf: The backing buffer to use. Returns: - res: The formatted string, backed by `buf`. Example: buf: [MIN_YY_DATE_LEN]u8 now := time.now() fmt.println(time.to_string_yy_mm_dd(now, buf[:]))

to_string_yyyy_mm_dd #

Source 
@(require_results)
to_string_yyyy_mm_dd :: proc(t: Time, buf: []u8) -> (res: string) {…}

Formats a Time as a yyyy-mm-dd date string. Inputs: - t: The Time to format. - buf: The backing buffer to use. Returns: - res: The formatted string, backed by `buf`. Example: buf: [MIN_YYYY_DATE_LEN]u8 now := time.now() fmt.println(time.to_string_yyyy_mm_dd(now, buf[:]))

to_unix_nanoseconds #

Source 
@(require_results)
to_unix_nanoseconds :: proc "contextless" (t: Time) -> i64 {…}

Obtain the Unix timestamp in nanoseconds from a Time.

to_unix_seconds #

Source 
@(require_results)
to_unix_seconds :: proc "contextless" (t: Time) -> i64 {…}

Obtain the Unix timestamp in seconds from a Time.

tsc_frequency #

Source 
@(require_results)
tsc_frequency :: proc "contextless" (fallback_sleep: Duration = 2 * Second) -> (u64, bool) {…}

Obtain the CPU's TSC frequency, in hertz. This procedure tries to obtain the CPU's TSC frequency in hertz. If the CPU doesn't have an invariant TSC, this procedure returns with an error. Otherwise an attempt is made to fetch the TSC frequency from the OS. If this fails, the frequency is obtained by sleeping for the specified amount of time and dividing the readings from TSC by the duration of the sleep. The duration of sleep can be controlled by `fallback_sleep` parameter.

unix #

Source 
@(require_results)
unix :: proc "contextless" (sec: i64, nsec: i64) -> Time {…}

Obtain time from unix seconds and unix nanoseconds.

weekday #

Source 
@(require_results)
weekday :: proc "contextless" (t: Time) -> (weekday: Weekday) {…}

Obtain the week day of the date specified by time.

year #

Source 
@(require_results)
year :: proc "contextless" (t: Time) -> (year: int) {…}

Obtain the year of the date specified by time.

Procedure Groups

4

Variables

1

days_before #

Source 
@(rodata)
days_before: [13]i32 = [?]i32{0, 31, 31 + 28, 31 + 28 + 31, 31 + 28 + 31 + 30, 31 + 28 + 31 + 30 + 31, 31 + 28 + 31 + 30 + 31 + 30, 31 + 28 + 31 + 30 + 31 + 30 + 31, 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31, 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30, 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31, 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30, 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31}

Days before each month in a year, not counting the leap day on february 29th.