package core:time
Source

⌘K
Ctrl+K
or
/

    Index

    Variables (1)
    Procedures (67)

    Types

    Benchmark_Error ¶
    Source

    Benchmark_Error :: enum int {
	Okay             = 0, 
	Allocation_Error, 
}
     

    Errors returned by the benchmark() procedure.

    Related Procedures With Returns

    Benchmark_Options ¶
    Source

    Benchmark_Options :: struct {
	// The initialization procedure. `benchmark()` will call this before taking measurements.
	setup:                proc(options: ^Benchmark_Options, allocator: runtime.Allocator) -> (err: Benchmark_Error),
	// The procedure to benchmark.
	bench:                proc(options: ^Benchmark_Options, allocator: runtime.Allocator) -> (err: Benchmark_Error),
	// The deinitialization procedure.
	teardown:             proc(options: ^Benchmark_Options, allocator: runtime.Allocator) -> (err: Benchmark_Error),
	// Field to be used by `bench()` procedure for any purpose.
	rounds:               int,
	// Field to be used by `bench()` procedure for any purpose.
	bytes:                int,
	// Field to be used by `bench()` procedure for any purpose.
	input:                []u8,
	// `bench()` writes to specify the count of elements processed.
	count:                int,
	// `bench()` writes to specify the number of bytes processed.
	processed:            int,
	// `bench()` can write the output slice here.
	output:               []u8,
	// `bench()` can write the output hash here.
	hash:                 u128,
	// `benchmark()` procedure will output the duration of benchmark
	duration:             Duration,
	// `benchmark()` procedure will output the average count of elements
	// processed per second, using the `count` field of this struct.
	rounds_per_second:    f64,
	// `benchmark()` procedure will output the average number of megabytes
	// processed per second, using the `processed` field of this struct.
	megabytes_per_second: f64,
}
     

    Options for benchmarking.

    Related Procedures With Parameters

    Duration ¶
    Source

    Duration :: distinct i64
     

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

    Related Procedures With Parameters
    Related Procedures With Returns
    Related Constants

    Month ¶
    Source

    Month :: enum int {
	January   = 1, 
	February, 
	March, 
	April, 
	May, 
	June, 
	July, 
	August, 
	September, 
	October, 
	November, 
	December, 
}
     

    Type representing a month.

    Related Procedures With Returns

    Stopwatch ¶
    Source

    Stopwatch :: struct {
	running:       bool,
	_start_time:   Tick,
	_accumulation: Duration,
}
     

    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.

    Related Procedures With Parameters

    Tick ¶
    Source

    Tick :: struct {
	_nsec: i64,
}
     

    Type representing monotonic time, useful for measuring durations.

    Related Procedures With Parameters
    Related Procedures With Returns

    Time ¶
    Source

    Time :: struct {
	_nsec: i64,
}
     

    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

    Related Procedures With Parameters
    Related Procedures With Returns

    Weekday ¶
    Source

    Weekday :: enum int {
	Sunday    = 0, 
	Monday, 
	Tuesday, 
	Wednesday, 
	Thursday, 
	Friday, 
	Saturday, 
}
     

    Type representing a weekday.

    Related Procedures With Returns

    Constants

    ABSOLUTE_TO_INTERNAL ¶
    Source

    ABSOLUTE_TO_INTERNAL :: i64(-9223371966579724800)
     

    i64((ABSOLUTE_ZERO_YEAR - 1) 365.2425 SECONDS_PER_DAY);

    ABSOLUTE_TO_UNIX ¶
    Source

    ABSOLUTE_TO_UNIX: i64 : -UNIX_TO_ABSOLUTE

    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: int : 365 * 100 + 24
     

    Days in 100 years, with leap days.

    DAYS_PER_400_YEARS ¶
    Source

    DAYS_PER_400_YEARS: int : 365 * 400 + 97
     

    Days in 400 years, with leap days.

    DAYS_PER_4_YEARS ¶
    Source

    DAYS_PER_4_YEARS: int : 365 * 4 + 1
     

    Days in 4 years, with leap days.

    Hour ¶
    Source

    Hour: Duration : 60 * Minute
     

    The duration equal to one hour (3600 seconds).

    INTERNAL_TO_ABSOLUTE ¶
    Source

    INTERNAL_TO_ABSOLUTE: i64 : -ABSOLUTE_TO_INTERNAL

    INTERNAL_TO_UNIX ¶
    Source

    INTERNAL_TO_UNIX: i64 : -UNIX_TO_INTERNAL

    INTERNAL_TO_WALL ¶
    Source

    INTERNAL_TO_WALL: i64 : -WALL_TO_INTERNAL

    IS_SUPPORTED ¶
    Source

    IS_SUPPORTED: bool : _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.

    MIN_DURATION ¶
    Source

    MIN_DURATION :: Duration(-1 << 63)
     

    Minimum representable duration.

    MIN_HMS_12_LEN ¶
    Source

    MIN_HMS_12_LEN: int : 11

    MIN_HMS_LEN ¶
    Source

    MIN_HMS_LEN: int : 8

    MIN_YYYY_DATE_LEN ¶
    Source

    MIN_YYYY_DATE_LEN: int : 10

    MIN_YY_DATE_LEN ¶
    Source

    MIN_YY_DATE_LEN: int : 8

    Microsecond ¶
    Source

    Microsecond: Duration : 1000 * Nanosecond
     

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

    Millisecond ¶
    Source

    Millisecond: Duration : 1000 * Microsecond
     

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

    Minute ¶
    Source

    Minute: Duration : 60 * Second
     

    The duration equal to one minute (60 seconds).

    Nanosecond ¶
    Source

    Nanosecond :: Duration(1)
     

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

    SECONDS_PER_DAY ¶
    Source

    SECONDS_PER_DAY: int : 24 * SECONDS_PER_HOUR
     

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

    SECONDS_PER_HOUR ¶
    Source

    SECONDS_PER_HOUR: int : 60 * SECONDS_PER_MINUTE
     

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

    SECONDS_PER_MINUTE ¶
    Source

    SECONDS_PER_MINUTE: int : 60
     

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

    SECONDS_PER_WEEK ¶
    Source

    SECONDS_PER_WEEK: int : 7 * SECONDS_PER_DAY
     

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

    Second ¶
    Source

    Second: Duration : 1000 * Millisecond
     

    The duration equal to one second.

    UNIX_TO_ABSOLUTE ¶
    Source

    UNIX_TO_ABSOLUTE: i64 : 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)

    Variables

    days_before ¶
    Source

    @(rodata)
days_before: [13]i32 = …
     

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

    Procedures

    SCOPED_TICK_DURATION ¶
    Source

    SCOPED_TICK_DURATION :: proc "contextless" (d: ^Duration) -> Tick {…}
     

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

    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

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

    Obtain the time components from a duration.

    clock_from_seconds ¶
    Source

    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

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

    Obtain the time components from a stopwatch's total.

    clock_from_time ¶
    Source

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

    Obtain the time components from a time.

    components_to_time ¶
    Source

    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) {…}
     

    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

    compound_to_time :: proc "contextless" (datetime: 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

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

    Parse time into date components.

    day ¶
    Source

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

    Obtain the day of the date specified by time.

    diff ¶
    Source

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

    Calculate the duration elapsed between two times.

    duration_hours ¶
    Source

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

    Obtain the number of hours in a duration.

    duration_microseconds ¶
    Source

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

    Obtain the number of microseconds in a duration.

    duration_milliseconds ¶
    Source

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

    Obtain the number of milliseconds in a duration.

    duration_minutes ¶
    Source

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

    Obtain the number of minutes in a duration.

    duration_nanoseconds ¶
    Source

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

    Obtain the number of nanoseconds in a duration.

    duration_round ¶
    Source

    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

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

    Obtain the number of seconds in a duration.

    duration_to_string_hms ¶
    Source

    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

    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

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

    Obtain time from unix nanoseconds.

    has_invariant_tsc ¶
    Source

    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

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

    Check if a year is a leap year.

    iso8601_to_components ¶
    Source

    iso8601_to_components :: proc(iso_datetime: string) -> (res: datetime.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

    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

    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

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

    Obtain the month of the date specified by time.

    now ¶
    Source

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

    Obtain the current time.

    precise_clock_from_duration ¶
    Source

    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

    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

    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

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

    Read the timestamp counter of the CPU.

    rfc3339_to_components ¶
    Source

    rfc3339_to_components :: proc(rfc_datetime: string) -> (res: datetime.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

    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

    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.

    since ¶
    Source

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

    Calculate the duration elapsed since a specific time.

    sleep ¶
    Source

    sleep :: proc "contextless" (d: Duration) {…}
     

    Sleep for the specified duration.

    stopwatch_duration ¶
    Source

    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.

    stopwatch_reset ¶
    Source

    stopwatch_reset :: proc "contextless" (stopwatch: ^Stopwatch) {…}
     

    Reset the stopwatch.

    stopwatch_start ¶
    Source

    stopwatch_start :: proc "contextless" (stopwatch: ^Stopwatch) {…}
     

    Start the stopwatch.

    stopwatch_stop ¶
    Source

    stopwatch_stop :: proc "contextless" (stopwatch: ^Stopwatch) {…}
     

    Stop the stopwatch.

    tick_add ¶
    Source

    tick_add :: proc "contextless" (t: Tick, d: Duration) -> Tick {…}
     

    Add duration to a tick.

    tick_diff ¶
    Source

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

    Obtain the difference between ticks.

    tick_lap_time ¶
    Source

    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

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

    Obtain the current tick.

    tick_since ¶
    Source

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

    Obtain the duration since last tick.

    time_add ¶
    Source

    time_add :: proc "contextless" (t: Time, d: Duration) -> Time {…}
     

    Add duration to a time.

    time_to_compound ¶
    Source

    time_to_compound :: time_to_datetime
     

    Convert time into datetime.

    time_to_datetime ¶
    Source

    time_to_datetime :: proc "contextless" (t: Time) -> (datetime.DateTime, bool) {…}
     

    Convert time into datetime.

    time_to_rfc3339 ¶
    Source

    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

    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

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

    Obtain the Unix timestamp in seconds from a Time.

    time_to_unix_nano ¶
    Source

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

    Obtain the Unix timestamp in nanoseconds from a Time.

    to_string_dd_mm_yy ¶
    Source

    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

    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

    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

    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

    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

    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

    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

    to_unix_nanoseconds :: time_to_unix_nano
     

    Obtain the Unix timestamp in nanoseconds from a Time.

    to_unix_seconds ¶
    Source

    to_unix_seconds :: time_to_unix
     

    Obtain the Unix timestamp in seconds from a Time.

    tsc_frequency ¶
    Source

    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

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

    Obtain time from unix seconds and unix nanoseconds.

    weekday ¶
    Source

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

    Obtain the week day of the date specified by time.

    year ¶
    Source

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

    Obtain the year of the date specified by time.

    Procedure Groups

    clock ¶
    Source

     

    Obtain the time components from a time, a duration or a stopwatch's total.

    datetime_to_time ¶
    Source

    datetime_to_time :: proc{
	components_to_time,
	compound_to_time,
}
     

    Convert datetime components into time.

    precise_clock ¶
    Source

     

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

    to_string_hms ¶
    Source

    to_string_hms :: proc{
	time_to_string_hms,
	duration_to_string_hms,
}

    Source Files

    Generation Information

    Generated with odin version dev-2025-07 (vendor "odin") Windows_amd64 @ 2025-07-09 21:13:51.698563500 +0000 UTC