package core:time

Types

Benchmark_Error ¶

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

Benchmark_Options ¶

Benchmark_Options :: struct {
	setup:                proc "odin" (options: ^Benchmark_Options, allocator := context.allocator) -> (err: Benchmark_Error),
	bench:                proc "odin" (options: ^Benchmark_Options, allocator := context.allocator) -> (err: Benchmark_Error),
	teardown:             proc "odin" (options: ^Benchmark_Options, allocator := context.allocator) -> (err: Benchmark_Error),
	rounds:               int,
	bytes:                int,
	input:                []u8,
	count:                int,
	processed:            int,
	output:               []u8,
	// Unused for hash benchmarks
	hash:                 u128,
	// 		Performance
	duration:             Duration,
	rounds_per_second:    f64,
	megabytes_per_second: f64,
}

Duration ¶

Duration :: distinct i64

Month ¶

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

Stopwatch ¶

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

Tick ¶

Tick :: struct {
	_nsec: i64,
}

Time ¶

Time :: struct {
	_nsec: i64,
}

Weekday ¶

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

Constants

ABSOLUTE_TO_INTERNAL ¶

ABSOLUTE_TO_INTERNAL :: i64(-9223371966579724800)

ABSOLUTE_TO_UNIX ¶

ABSOLUTE_TO_UNIX: i64 : -UNIX_TO_ABSOLUTE

ABSOLUTE_ZERO_YEAR ¶

ABSOLUTE_ZERO_YEAR :: i64(-292277022399)

DAYS_PER_100_YEARS ¶

DAYS_PER_100_YEARS :: 365 * 100 + 24

DAYS_PER_400_YEARS ¶

DAYS_PER_400_YEARS :: 365 * 400 + 97

DAYS_PER_4_YEARS ¶

DAYS_PER_4_YEARS :: 365 * 4 + 1

Hour ¶

Hour: Duration : 60 * Minute

INTERNAL_TO_ABSOLUTE ¶

INTERNAL_TO_ABSOLUTE: i64 : -ABSOLUTE_TO_INTERNAL

INTERNAL_TO_UNIX ¶

INTERNAL_TO_UNIX: i64 : -UNIX_TO_INTERNAL

INTERNAL_TO_WALL ¶

INTERNAL_TO_WALL: i64 : -WALL_TO_INTERNAL

IS_SUPPORTED ¶

IS_SUPPORTED :: _IS_SUPPORTED

MAX_DURATION ¶

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

MIN_DURATION ¶

MIN_DURATION :: Duration(-1 << 63)

Microsecond ¶

Microsecond: Duration : 1000 * Nanosecond

Millisecond ¶

Millisecond: Duration : 1000 * Microsecond

Minute ¶

Minute: Duration : 60 * Second

Nanosecond ¶

Nanosecond :: Duration(1)

SECONDS_PER_DAY ¶

SECONDS_PER_DAY :: 24 * SECONDS_PER_HOUR

SECONDS_PER_HOUR ¶

SECONDS_PER_HOUR :: 60 * SECONDS_PER_MINUTE

SECONDS_PER_MINUTE ¶

SECONDS_PER_MINUTE :: 60

SECONDS_PER_WEEK ¶

SECONDS_PER_WEEK :: 7 * SECONDS_PER_DAY

Second ¶

Second: Duration : 1000 * Millisecond

UNIX_TO_ABSOLUTE ¶

UNIX_TO_ABSOLUTE: i64 : UNIX_TO_INTERNAL + INTERNAL_TO_ABSOLUTE

UNIX_TO_INTERNAL ¶

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

WALL_TO_INTERNAL ¶

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

Variables

days_before ¶

days_before: [13]i32 = …

Procedures

SCOPED_TICK_DURATION ¶

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

accurate_sleep ¶

accurate_sleep :: proc "odin" (d: Duration) {…}
 

Accurate sleep borrowed from: https://blat-blatnik.github.io/computerBear/making-accurate-sleep-function/

Accuracy seems to be pretty good out of the box on Linux, to within around 4µs worst case. On Windows it 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 win32.time_begin_period(1) to tell Windows to use a more accurate timer for your process.

benchmark ¶

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

clock_from_duration ¶

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

clock_from_seconds ¶

clock_from_seconds :: proc "odin" (nsec: u64) -> (hour, min, sec: int) {…}

clock_from_stopwatch ¶

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

clock_from_time ¶

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

date ¶

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

datetime_to_time ¶

datetime_to_time :: proc "odin" (
	year, month, day, hour, minute, second: int, 
) -> (t: Time, ok: bool) {…}

day ¶

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

diff ¶

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

duration_hours ¶

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

duration_microseconds ¶

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

duration_milliseconds ¶

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

duration_minutes ¶

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

duration_nanoseconds ¶

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

duration_round ¶

duration_round :: proc "odin" (d, m: Duration) -> Duration {…}

duration_seconds ¶

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

duration_truncate ¶

duration_truncate :: proc "odin" (d, m: Duration) -> Duration {…}

month ¶

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

now ¶

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

read_cycle_counter ¶

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

since ¶

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

sleep ¶

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

stopwatch_duration ¶

stopwatch_duration :: proc "odin" (using stopwatch: Stopwatch) -> Duration {…}

stopwatch_reset ¶

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

stopwatch_start ¶

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

stopwatch_stop ¶

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

tick_diff ¶

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

tick_lap_time ¶

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

tick_now ¶

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

tick_since ¶

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

time_add ¶

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

time_to_unix ¶

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

time_to_unix_nano ¶

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

unix ¶

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

year ¶

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

Procedure Groups

Source Files

Generation Information

Generated with odin version dev-2022-10 (vendor "odin") Windows_amd64 @ 2022-10-05 21:11:47.539297700 +0000 UTC