//- futex internal void futex_wait(u32 *address, u32 expected, s64 timeout_ns) { struct timespec timeout = {}; struct timespec *timeout_ptr = NULL; if(timeout_ns >= 0) { timeout.tv_sec = timeout_ns / 1000000000ll; timeout.tv_nsec = timeout_ns % 1000000000ll; timeout_ptr = &timeout; } // NOTE: EAGAIN (value already changed), EINTR and ETIMEDOUT are all fine, the caller re-checks syscall(SYS_futex, address, FUTEX_WAIT_PRIVATE, expected, timeout_ptr, NULL, 0); } internal void futex_wake_all(u32 *address) { syscall(SYS_futex, address, FUTEX_WAKE_PRIVATE, INT32_MAX, NULL, NULL, 0); } internal u32 signal_snapshot(Signal *signal) { return AtomicLoad(&signal->sequence); } internal void signal_notify(Signal *signal) { AtomicAdd(&signal->sequence, 1); futex_wake_all(&signal->sequence); } internal void signal_wait(Signal *signal, u32 snapshot, s64 timeout_ns) { futex_wait(&signal->sequence, snapshot, timeout_ns); } //- spin lock internal void spin_lock(SpinLock *lock) { for(;;) { if(!AtomicExchange(&lock->locked, 1)) { return; } // NOTE: spin on a plain load so we don't hammer the line with exclusive requests while(AtomicLoadRelaxed(&lock->locked)) { CpuRelax(); } } } internal void spin_unlock(SpinLock *lock) { AtomicStore(&lock->locked, 0u); } //- main thread wakeup global_variable int global_wake_fd = -1; internal void wake_main_init(void) { global_wake_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); AssertLog(global_wake_fd != -1, "failed to create eventfd"); } internal void wake_main(void) { u64 one = 1; ssize_t written = write(global_wake_fd, &one, sizeof(one)); Unused(written); } internal b32 wake_main_drain(void) { u64 value = 0; ssize_t got = read(global_wake_fd, &value, sizeof(value)); return got == (ssize_t)sizeof(value) && value > 0; } internal int wake_main_fd(void) { return global_wake_fd; } //- time internal u64 time_now_ns(void) { struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now); return (u64)now.tv_sec * 1000000000ull + (u64)now.tv_nsec; } internal void sleep_ns(u64 ns) { struct timespec duration = {(time_t)(ns / 1000000000ull), (long)(ns % 1000000000ull)}; nanosleep(&duration, NULL); } //- aligned arena pushes // NOTE: arena_alloc only guarantees 16 byte alignment, hot simd arrays want a full cache line internal void *push_cache_aligned_raw(Arena *arena, u64 size) { u8 *raw = (u8 *)arena_alloc(arena, size + CACHE_LINE_SIZE, 0); return (void *)Align(raw, CACHE_LINE_SIZE); } internal void *push_cache_aligned(Arena *arena, u64 size) { u8 *raw = (u8 *)arena_alloc(arena, size + CACHE_LINE_SIZE, 1); return (void *)Align(raw, CACHE_LINE_SIZE); }