1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
//- 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);
}
|