123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838 |
- #if defined(GB_SYSTEM_LINUX)
- #include <signal.h>
- #if __has_include(<valgrind/helgrind.h>)
- #include <valgrind/helgrind.h>
- #define HAS_VALGRIND
- #endif
- #endif
- #if defined(GB_SYSTEM_WINDOWS)
- #pragma warning(push)
- #pragma warning(disable: 4505)
- #endif
- #if defined(HAS_VALGRIND)
- #define ANNOTATE_LOCK_PRE(m, t) VALGRIND_HG_MUTEX_LOCK_PRE(m, t)
- #define ANNOTATE_LOCK_POST(m) VALGRIND_HG_MUTEX_LOCK_POST(m)
- #define ANNOTATE_UNLOCK_PRE(m) VALGRIND_HG_MUTEX_UNLOCK_PRE(m)
- #define ANNOTATE_UNLOCK_POST(m) VALGRIND_HG_MUTEX_UNLOCK_POST(m)
- #define ANNOTATE_SEM_WAIT_POST(s) VALGRIND_HG_SEM_WAIT_POST(s)
- #define ANNOTATE_SEM_POST_PRE(s) VALGRIND_HG_SEM_POST_PRE(s)
- #else
- #define ANNOTATE_LOCK_PRE(m, t)
- #define ANNOTATE_LOCK_POST(m)
- #define ANNOTATE_UNLOCK_PRE(m)
- #define ANNOTATE_UNLOCK_POST(m)
- #define ANNOTATE_SEM_WAIT_POST(s)
- #define ANNOTATE_SEM_POST_PRE(s)
- #endif
- struct BlockingMutex;
- struct RecursiveMutex;
- struct RwMutex;
- struct Semaphore;
- struct Condition;
- struct Thread;
- struct ThreadPool;
- struct Parker;
- #define THREAD_PROC(name) isize name(struct Thread *thread)
- gb_internal THREAD_PROC(thread_pool_thread_proc);
- #define WORKER_TASK_PROC(name) isize name(void *data)
- typedef WORKER_TASK_PROC(WorkerTaskProc);
- typedef struct WorkerTask {
- WorkerTaskProc *do_work;
- void *data;
- } WorkerTask;
- struct Thread {
- #if defined(GB_SYSTEM_WINDOWS)
- void *win32_handle;
- #else
- pthread_t posix_handle;
- #endif
- isize idx;
- WorkerTask *queue;
- size_t capacity;
- std::atomic<uint64_t> head_and_tail;
- isize stack_size;
- struct ThreadPool *pool;
- };
- typedef std::atomic<i32> Futex;
- typedef volatile i32 Footex;
- gb_internal void futex_wait(Futex *addr, Footex val);
- gb_internal void futex_signal(Futex *addr);
- gb_internal void futex_broadcast(Futex *addr);
- gb_internal void mutex_lock (BlockingMutex *m);
- gb_internal bool mutex_try_lock(BlockingMutex *m);
- gb_internal void mutex_unlock (BlockingMutex *m);
- gb_internal void mutex_lock (RecursiveMutex *m);
- gb_internal bool mutex_try_lock(RecursiveMutex *m);
- gb_internal void mutex_unlock (RecursiveMutex *m);
- gb_internal void rw_mutex_lock (RwMutex *m);
- gb_internal bool rw_mutex_try_lock (RwMutex *m);
- gb_internal void rw_mutex_unlock (RwMutex *m);
- gb_internal void rw_mutex_shared_lock (RwMutex *m);
- gb_internal bool rw_mutex_try_shared_lock(RwMutex *m);
- gb_internal void rw_mutex_shared_unlock (RwMutex *m);
- gb_internal void semaphore_post(Semaphore *s, i32 count);
- gb_internal void semaphore_wait(Semaphore *s);
- gb_internal void condition_broadcast(Condition *c);
- gb_internal void condition_signal(Condition *c);
- gb_internal void condition_wait(Condition *c, BlockingMutex *m);
- gb_internal void park(Parker *p);
- gb_internal void unpark_one(Parker *p);
- gb_internal void unpark_all(Parker *p);
- gb_internal u32 thread_current_id(void);
- gb_internal void thread_init (ThreadPool *pool, Thread *t, isize idx);
- gb_internal void thread_init_and_start (ThreadPool *pool, Thread *t, isize idx);
- gb_internal void thread_join_and_destroy(Thread *t);
- gb_internal void thread_set_name (Thread *t, char const *name);
- gb_internal void yield_thread(void);
- gb_internal void yield_process(void);
- struct Wait_Signal {
- Futex futex;
- };
- gb_internal void wait_signal_until_available(Wait_Signal *ws) {
- if (ws->futex.load() == 0) {
- futex_wait(&ws->futex, 1);
- }
- }
- gb_internal void wait_signal_set(Wait_Signal *ws) {
- ws->futex.store(1);
- futex_broadcast(&ws->futex);
- }
- struct MutexGuard {
- MutexGuard() = delete;
- MutexGuard(MutexGuard const &) = delete;
- MutexGuard(MutexGuard &&) = delete;
- explicit MutexGuard(BlockingMutex *bm) noexcept : bm{bm} {
- mutex_lock(this->bm);
- }
- explicit MutexGuard(RecursiveMutex *rm) noexcept : rm{rm} {
- mutex_lock(this->rm);
- }
- explicit MutexGuard(RwMutex *rwm) noexcept : rwm{rwm} {
- rw_mutex_lock(this->rwm);
- }
- explicit MutexGuard(BlockingMutex &bm) noexcept : bm{&bm} {
- mutex_lock(this->bm);
- }
- explicit MutexGuard(RecursiveMutex &rm) noexcept : rm{&rm} {
- mutex_lock(this->rm);
- }
- explicit MutexGuard(RwMutex &rwm) noexcept : rwm{&rwm} {
- rw_mutex_lock(this->rwm);
- }
- ~MutexGuard() noexcept {
- if (this->bm) {
- mutex_unlock(this->bm);
- } else if (this->rm) {
- mutex_unlock(this->rm);
- } else if (this->rwm) {
- rw_mutex_unlock(this->rwm);
- }
- }
- operator bool() const noexcept { return true; }
- BlockingMutex *bm;
- RecursiveMutex *rm;
- RwMutex *rwm;
- };
- #define MUTEX_GUARD_BLOCK(m) if (MutexGuard GB_DEFER_3(_mutex_guard_){m})
- #define MUTEX_GUARD(m) mutex_lock(m); defer (mutex_unlock(m))
- #define RW_MUTEX_GUARD(m) rw_mutex_lock(m); defer (rw_mutex_unlock(m))
- struct RecursiveMutex {
- Futex owner;
- i32 recursion;
- };
- gb_internal void mutex_lock(RecursiveMutex *m) {
- Futex tid;
- tid.store(cast(i32)thread_current_id());
- for (;;) {
- i32 prev_owner = 0;
- m->owner.compare_exchange_strong(prev_owner, tid, std::memory_order_acquire, std::memory_order_acquire);
- if (prev_owner == 0 || prev_owner == tid) {
- m->recursion++;
- // inside the lock
- return;
- }
- futex_wait(&m->owner, prev_owner);
- }
- }
- gb_internal bool mutex_try_lock(RecursiveMutex *m) {
- Futex tid;
- tid.store(cast(i32)thread_current_id());
- i32 prev_owner = 0;
- m->owner.compare_exchange_strong(prev_owner, tid, std::memory_order_acquire, std::memory_order_acquire);
- if (prev_owner == 0 || prev_owner == tid) {
- m->recursion++;
- // inside the lock
- return true;
- }
- return false;
- }
- gb_internal void mutex_unlock(RecursiveMutex *m) {
- m->recursion--;
- if (m->recursion != 0) {
- return;
- }
- m->owner.exchange(0, std::memory_order_release);
- futex_signal(&m->owner);
- // outside the lock
- }
- struct Semaphore {
- Footex count_;
- Futex &count() noexcept {
- return *(Futex *)&this->count_;
- }
- Futex const &count() const noexcept {
- return *(Futex *)&this->count_;
- }
- };
- gb_internal void semaphore_post(Semaphore *s, i32 count) {
- s->count().fetch_add(count, std::memory_order_release);
- if (s->count().load() == 1) {
- futex_signal(&s->count());
- } else {
- futex_broadcast(&s->count());
- }
- }
- gb_internal void semaphore_wait(Semaphore *s) {
- for (;;) {
- i32 original_count = s->count().load(std::memory_order_relaxed);
- while (original_count == 0) {
- futex_wait(&s->count(), original_count);
- original_count = s->count().load(std::memory_order_relaxed);
- }
- if (s->count().compare_exchange_strong(original_count, original_count-1, std::memory_order_acquire, std::memory_order_acquire)) {
- return;
- }
- }
- }
- #if defined(GB_SYSTEM_WINDOWS)
- struct BlockingMutex {
- SRWLOCK srwlock;
- };
- gb_internal void mutex_lock(BlockingMutex *m) {
- AcquireSRWLockExclusive(&m->srwlock);
- }
- gb_internal bool mutex_try_lock(BlockingMutex *m) {
- return !!TryAcquireSRWLockExclusive(&m->srwlock);
- }
- gb_internal void mutex_unlock(BlockingMutex *m) {
- ReleaseSRWLockExclusive(&m->srwlock);
- }
- struct Condition {
- CONDITION_VARIABLE cond;
- };
- gb_internal void condition_broadcast(Condition *c) {
- WakeAllConditionVariable(&c->cond);
- }
- gb_internal void condition_signal(Condition *c) {
- WakeConditionVariable(&c->cond);
- }
- gb_internal void condition_wait(Condition *c, BlockingMutex *m) {
- SleepConditionVariableSRW(&c->cond, &m->srwlock, INFINITE, 0);
- }
- struct RwMutex {
- SRWLOCK srwlock;
- };
- gb_internal void rw_mutex_lock(RwMutex *m) {
- AcquireSRWLockExclusive(&m->srwlock);
- }
- gb_internal bool rw_mutex_try_lock(RwMutex *m) {
- return !!TryAcquireSRWLockExclusive(&m->srwlock);
- }
- gb_internal void rw_mutex_unlock(RwMutex *m) {
- ReleaseSRWLockExclusive(&m->srwlock);
- }
- gb_internal void rw_mutex_shared_lock(RwMutex *m) {
- AcquireSRWLockShared(&m->srwlock);
- }
- gb_internal bool rw_mutex_try_shared_lock(RwMutex *m) {
- return !!TryAcquireSRWLockShared(&m->srwlock);
- }
- gb_internal void rw_mutex_shared_unlock(RwMutex *m) {
- ReleaseSRWLockShared(&m->srwlock);
- }
- #else
- enum Internal_Mutex_State : i32 {
- Internal_Mutex_State_Unlocked = 0,
- Internal_Mutex_State_Locked = 1,
- Internal_Mutex_State_Waiting = 2,
- };
- struct BlockingMutex {
- #if defined(HAS_VALGRIND)
- // BlockingMutex() {
- // VALGRIND_HG_MUTEX_INIT_POST(this, 0);
- // }
- // ~BlockingMutex() {
- // VALGRIND_HG_MUTEX_DESTROY_PRE(this);
- // }
- #endif
- i32 state_;
- Futex &state() {
- return *(Futex *)&this->state_;
- }
- Futex const &state() const {
- return *(Futex const *)&this->state_;
- }
- };
- gb_no_inline gb_internal void mutex_lock_slow(BlockingMutex *m, i32 curr_state) {
- i32 new_state = curr_state;
- for (i32 spin = 0; spin < 100; spin++) {
- i32 state = Internal_Mutex_State_Unlocked;
- bool ok = m->state().compare_exchange_weak(state, new_state, std::memory_order_acquire, std::memory_order_consume);
- if (ok) {
- return;
- }
- if (state == Internal_Mutex_State_Waiting) {
- break;
- }
- for (i32 i = gb_min(spin+1, 32); i > 0; i--) {
- yield_thread();
- }
- }
- // Set just in case 100 iterations did not do it
- new_state = Internal_Mutex_State_Waiting;
- for (;;) {
- if (m->state().exchange(Internal_Mutex_State_Waiting, std::memory_order_acquire) == Internal_Mutex_State_Unlocked) {
- return;
- }
- futex_wait(&m->state(), new_state);
- yield_thread();
- }
- }
- gb_internal void mutex_lock(BlockingMutex *m) {
- ANNOTATE_LOCK_PRE(m, 0);
- i32 v = m->state().exchange(Internal_Mutex_State_Locked, std::memory_order_acquire);
- if (v != Internal_Mutex_State_Unlocked) {
- mutex_lock_slow(m, v);
- }
- ANNOTATE_LOCK_POST(m);
- }
- gb_internal bool mutex_try_lock(BlockingMutex *m) {
- ANNOTATE_LOCK_PRE(m, 1);
- i32 v = m->state().exchange(Internal_Mutex_State_Locked, std::memory_order_acquire);
- if (v == Internal_Mutex_State_Unlocked) {
- ANNOTATE_LOCK_POST(m);
- return true;
- }
- return false;
- }
- gb_no_inline gb_internal void mutex_unlock_slow(BlockingMutex *m) {
- futex_signal(&m->state());
- }
- gb_internal void mutex_unlock(BlockingMutex *m) {
- ANNOTATE_UNLOCK_PRE(m);
- i32 v = m->state().exchange(Internal_Mutex_State_Unlocked, std::memory_order_release);
- switch (v) {
- case Internal_Mutex_State_Unlocked:
- GB_PANIC("Unreachable");
- break;
- case Internal_Mutex_State_Locked:
- // Okay
- break;
- case Internal_Mutex_State_Waiting:
- mutex_unlock_slow(m);
- break;
- }
- ANNOTATE_UNLOCK_POST(m);
- }
- struct Condition {
- i32 state_;
- Futex &state() {
- return *(Futex *)&this->state_;
- }
- Futex const &state() const {
- return *(Futex const *)&this->state_;
- }
- };
- gb_internal void condition_broadcast(Condition *c) {
- c->state().fetch_add(1, std::memory_order_release);
- futex_broadcast(&c->state());
- }
- gb_internal void condition_signal(Condition *c) {
- c->state().fetch_add(1, std::memory_order_release);
- futex_signal(&c->state());
- }
- gb_internal void condition_wait(Condition *c, BlockingMutex *m) {
- i32 state = c->state().load(std::memory_order_relaxed);
- mutex_unlock(m);
- futex_wait(&c->state(), state);
- mutex_lock(m);
- }
- struct RwMutex {
- // TODO(bill): make this a proper RW mutex
- BlockingMutex mutex;
- };
- gb_internal void rw_mutex_lock(RwMutex *m) {
- mutex_lock(&m->mutex);
- }
- gb_internal bool rw_mutex_try_lock(RwMutex *m) {
- return mutex_try_lock(&m->mutex);
- }
- gb_internal void rw_mutex_unlock(RwMutex *m) {
- mutex_unlock(&m->mutex);
- }
- gb_internal void rw_mutex_shared_lock(RwMutex *m) {
- mutex_lock(&m->mutex);
- }
- gb_internal bool rw_mutex_try_shared_lock(RwMutex *m) {
- return mutex_try_lock(&m->mutex);
- }
- gb_internal void rw_mutex_shared_unlock(RwMutex *m) {
- mutex_unlock(&m->mutex);
- }
- #endif
- struct Parker {
- Futex state;
- };
- enum ParkerState : u32 {
- ParkerState_Empty = 0,
- ParkerState_Notified = 1,
- ParkerState_Parked = UINT32_MAX,
- };
- gb_internal void park(Parker *p) {
- if (p->state.fetch_sub(1, std::memory_order_acquire) == ParkerState_Notified) {
- return;
- }
- for (;;) {
- futex_wait(&p->state, ParkerState_Parked);
- i32 notified = ParkerState_Empty;
- if (p->state.compare_exchange_strong(notified, ParkerState_Empty, std::memory_order_acquire, std::memory_order_acquire)) {
- return;
- }
- }
- }
- gb_internal void unpark_one(Parker *p) {
- if (p->state.exchange(ParkerState_Notified, std::memory_order_release) == ParkerState_Parked) {
- futex_signal(&p->state);
- }
- }
- gb_internal void unpark_all(Parker *p) {
- if (p->state.exchange(ParkerState_Notified, std::memory_order_release) == ParkerState_Parked) {
- futex_broadcast(&p->state);
- }
- }
- gb_internal u32 thread_current_id(void) {
- u32 thread_id;
- #if defined(GB_SYSTEM_WINDOWS)
- #if defined(GB_ARCH_32_BIT) && defined(GB_CPU_X86)
- thread_id = (cast(u32 *)__readfsdword(24))[9];
- #elif defined(GB_ARCH_64_BIT) && defined(GB_CPU_X86)
- thread_id = (cast(u32 *)__readgsqword(48))[18];
- #else
- thread_id = GetCurrentThreadId();
- #endif
- #elif defined(GB_SYSTEM_OSX) && defined(GB_ARCH_64_BIT)
- thread_id = pthread_mach_thread_np(pthread_self());
- #elif defined(GB_ARCH_32_BIT) && defined(GB_CPU_X86)
- __asm__("mov %%gs:0x08,%0" : "=r"(thread_id));
- #elif defined(GB_ARCH_64_BIT) && defined(GB_CPU_X86)
- __asm__("mov %%fs:0x10,%0" : "=r"(thread_id));
- #elif defined(GB_SYSTEM_LINUX)
- thread_id = gettid();
- #else
- #error Unsupported architecture for thread_current_id()
- #endif
- return thread_id;
- }
- gb_internal gb_inline void yield_thread(void) {
- #if defined(GB_SYSTEM_WINDOWS)
- _mm_pause();
- #elif defined(GB_SYSTEM_OSX)
- #if defined(GB_CPU_X86)
- __asm__ volatile ("" : : : "memory");
- #elif defined(GB_CPU_ARM)
- __asm__ volatile ("yield" : : : "memory");
- #endif
- #elif defined(GB_CPU_X86)
- _mm_pause();
- #elif defined(GB_CPU_ARM)
- __asm__ volatile ("yield" : : : "memory");
- #else
- #error Unknown architecture
- #endif
- }
- gb_internal gb_inline void yield(void) {
- #if defined(GB_SYSTEM_WINDOWS)
- YieldProcessor();
- #else
- sched_yield();
- #endif
- }
- #if defined(GB_SYSTEM_WINDOWS)
- gb_internal DWORD __stdcall internal_thread_proc(void *arg) {
- Thread *t = cast(Thread *)arg;
- thread_pool_thread_proc(t);
- return 0;
- }
- #else
- gb_internal void *internal_thread_proc(void *arg) {
- #if (GB_SYSTEM_LINUX)
- // NOTE: Don't permit any signal delivery to threads on Linux.
- sigset_t mask = {};
- sigfillset(&mask);
- GB_ASSERT_MSG(pthread_sigmask(SIG_BLOCK, &mask, nullptr) == 0, "failed to block signals");
- #endif
- Thread *t = cast(Thread *)arg;
- thread_pool_thread_proc(t);
- return NULL;
- }
- #endif
- gb_internal void thread_init(ThreadPool *pool, Thread *t, isize idx) {
- gb_zero_item(t);
- #if defined(GB_SYSTEM_WINDOWS)
- t->win32_handle = INVALID_HANDLE_VALUE;
- #else
- t->posix_handle = 0;
- #endif
- t->capacity = 1 << 14; // must be a power of 2
- t->queue = gb_alloc_array(heap_allocator(), WorkerTask, t->capacity);
- t->head_and_tail = 0;
- t->pool = pool;
- t->idx = idx;
- }
- gb_internal void thread_init_and_start(ThreadPool *pool, Thread *t, isize idx) {
- thread_init(pool, t, idx);
- isize stack_size = 0;
- #if defined(GB_SYSTEM_WINDOWS)
- t->win32_handle = CreateThread(NULL, stack_size, internal_thread_proc, t, 0, NULL);
- GB_ASSERT_MSG(t->win32_handle != NULL, "CreateThread: GetLastError");
- #else
- {
- pthread_attr_t attr;
- pthread_attr_init(&attr);
- defer (pthread_attr_destroy(&attr));
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
- if (stack_size != 0) {
- pthread_attr_setstacksize(&attr, stack_size);
- }
- pthread_create(&t->posix_handle, &attr, internal_thread_proc, t);
- }
- #endif
- }
- gb_internal void thread_join_and_destroy(Thread *t) {
- #if defined(GB_SYSTEM_WINDOWS)
- WaitForSingleObject(t->win32_handle, INFINITE);
- CloseHandle(t->win32_handle);
- t->win32_handle = INVALID_HANDLE_VALUE;
- #else
- pthread_join(t->posix_handle, NULL);
- t->posix_handle = 0;
- #endif
- gb_free(heap_allocator(), t->queue);
- }
- gb_internal void thread_set_name(Thread *t, char const *name) {
- #if defined(GB_COMPILER_MSVC)
- #pragma pack(push, 8)
- typedef struct {
- DWORD type;
- char const *name;
- DWORD id;
- DWORD flags;
- } gbprivThreadName;
- #pragma pack(pop)
- gbprivThreadName tn;
- tn.type = 0x1000;
- tn.name = name;
- tn.id = GetThreadId(cast(HANDLE)t->win32_handle);
- tn.flags = 0;
- __try {
- RaiseException(0x406d1388, 0, gb_size_of(tn)/4, cast(ULONG_PTR *)&tn);
- } __except(1 /*EXCEPTION_EXECUTE_HANDLER*/) {
- }
- #elif defined(GB_SYSTEM_WINDOWS) && !defined(GB_COMPILER_MSVC)
- // IMPORTANT TODO(bill): Set thread name for GCC/Clang on windows
- return;
- #elif defined(GB_SYSTEM_OSX)
- // TODO(bill): Test if this works
- pthread_setname_np(name);
- #elif defined(GB_SYSTEM_FREEBSD) || defined(GB_SYSTEM_OPENBSD)
- pthread_set_name_np(t->posix_handle, name);
- #else
- // TODO(bill): Test if this works
- pthread_setname_np(t->posix_handle, name);
- #endif
- }
- #if defined(GB_SYSTEM_LINUX)
- #include <linux/futex.h>
- #include <sys/syscall.h>
- gb_internal void futex_signal(Futex *addr) {
- int ret = syscall(SYS_futex, addr, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1, NULL, NULL, 0);
- if (ret == -1) {
- perror("Futex wake");
- GB_PANIC("Failed in futex wake!\n");
- }
- }
- gb_internal void futex_broadcast(Futex *addr) {
- int ret = syscall(SYS_futex, addr, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, INT32_MAX, NULL, NULL, 0);
- if (ret == -1) {
- perror("Futex wake");
- GB_PANIC("Failed in futex wake!\n");
- }
- }
- gb_internal void futex_wait(Futex *addr, Footex val) {
- for (;;) {
- int ret = syscall(SYS_futex, addr, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, NULL, NULL, 0);
- if (ret == -1) {
- if (errno != EAGAIN && errno != EINTR) {
- perror("Futex wait");
- GB_PANIC("Failed in futex wait!\n");
- } else {
- return;
- }
- } else if (ret == 0) {
- if (*addr != val) {
- return;
- }
- }
- }
- }
- #elif defined(GB_SYSTEM_FREEBSD)
- #include <sys/types.h>
- #include <sys/umtx.h>
- gb_internal void futex_signal(Futex *addr) {
- _umtx_op(addr, UMTX_OP_WAKE, 1, 0, 0);
- }
- gb_internal void futex_broadcast(Futex *addr) {
- _umtx_op(addr, UMTX_OP_WAKE, INT32_MAX, 0, 0);
- }
- gb_internal void futex_wait(Futex *addr, Footex val) {
- for (;;) {
- int ret = _umtx_op(addr, UMTX_OP_WAIT_UINT, val, 0, NULL);
- if (ret == -1) {
- if (errno == ETIMEDOUT || errno == EINTR) {
- continue;
- }
- perror("Futex wait");
- GB_PANIC("Failed in futex wait!\n");
- } else if (ret == 0) {
- if (*addr != val) {
- return;
- }
- }
- }
- }
- #elif defined(GB_SYSTEM_OPENBSD)
- #include <sys/futex.h>
- gb_internal void futex_signal(Futex *f) {
- for (;;) {
- int ret = futex((volatile uint32_t *)f, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1, NULL, NULL);
- if (ret == -1) {
- if (errno == ETIMEDOUT || errno == EINTR) {
- continue;
- }
- perror("Futex wake");
- GB_PANIC("futex wake fail");
- } else if (ret == 1) {
- return;
- }
- }
- }
- gb_internal void futex_broadcast(Futex *f) {
- for (;;) {
- int ret = futex((volatile uint32_t *)f, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, INT32_MAX, NULL, NULL);
- if (ret == -1) {
- if (errno == ETIMEDOUT || errno == EINTR) {
- continue;
- }
- perror("Futex wake");
- GB_PANIC("futex wake fail");
- } else if (ret == 1) {
- return;
- }
- }
- }
- gb_internal void futex_wait(Futex *f, Footex val) {
- for (;;) {
- int ret = futex((volatile uint32_t *)f, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, NULL, NULL);
- if (ret == -1) {
- if (*f != val) {
- return;
- }
- if (errno == ETIMEDOUT || errno == EINTR) {
- continue;
- }
- perror("Futex wait");
- GB_PANIC("Failed in futex wait!\n");
- }
- }
- }
- #elif defined(GB_SYSTEM_OSX)
- #define UL_COMPARE_AND_WAIT 0x00000001
- #define ULF_NO_ERRNO 0x01000000
- extern "C" int __ulock_wait(uint32_t operation, void *addr, uint64_t value, uint32_t timeout); /* timeout is specified in microseconds */
- extern "C" int __ulock_wake(uint32_t operation, void *addr, uint64_t wake_value);
- gb_internal void futex_signal(Futex *f) {
- for (;;) {
- int ret = __ulock_wake(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO, f, 0);
- if (ret >= 0) {
- return;
- }
- if (ret == -EINTR || ret == -EFAULT) {
- continue;
- }
- if (ret == -ENOENT) {
- return;
- }
- GB_PANIC("Failed in futex wake!\n");
- }
- }
- gb_internal void futex_broadcast(Futex *f) {
- for (;;) {
- enum { ULF_WAKE_ALL = 0x00000100 };
- int ret = __ulock_wake(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO | ULF_WAKE_ALL, f, 0);
- if (ret == 0) {
- return;
- }
- if (ret == -EINTR || ret == -EFAULT) {
- continue;
- }
- if (ret == -ENOENT) {
- return;
- }
- GB_PANIC("Failed in futex wake!\n");
- }
- }
- gb_internal void futex_wait(Futex *f, Footex val) {
- for (;;) {
- int ret = __ulock_wait(UL_COMPARE_AND_WAIT | ULF_NO_ERRNO, f, val, 0);
- if (ret >= 0) {
- if (*f != val) {
- return;
- }
- continue;
- }
- if (ret == -EINTR || ret == -EFAULT) {continue;
- ret = -ret;
- }
- if (ret == -ENOENT) {
- return;
- }
- GB_PANIC("Failed in futex wait!\n");
- }
- }
- #elif defined(GB_SYSTEM_WINDOWS)
- gb_internal void futex_signal(Futex *f) {
- WakeByAddressSingle(f);
- }
- gb_internal void futex_broadcast(Futex *f) {
- WakeByAddressAll(f);
- }
- gb_internal void futex_wait(Futex *f, Footex val) {
- do {
- WaitOnAddress(f, (void *)&val, sizeof(val), INFINITE);
- } while (f->load() == val);
- }
- #endif
- #if defined(GB_SYSTEM_WINDOWS)
- #pragma warning(pop)
- #endif
|