aboutsummaryrefslogtreecommitdiffstats
path: root/source/core/core_sync.cpp
blob: c295f8a30ecc04df380e5085e048a57fbc34e095 (plain) (blame)
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);
}