aboutsummaryrefslogtreecommitdiffstats
path: root/include
diff options
context:
space:
mode:
Diffstat (limited to 'include')
-rw-r--r--include/align.h21
-rw-r--r--include/atomic.h141
-rw-r--r--include/threads.h217
3 files changed, 379 insertions, 0 deletions
diff --git a/include/align.h b/include/align.h
new file mode 100644
index 00000000..babd4106
--- /dev/null
+++ b/include/align.h
@@ -0,0 +1,21 @@
+#ifndef AL_ALIGN_H
+#define AL_ALIGN_H
+
+#ifdef HAVE_STDALIGN_H
+#include <stdalign.h>
+#endif
+
+#ifndef alignas
+#ifdef HAVE_C11_ALIGNAS
+#define alignas _Alignas
+#elif defined(IN_IDE_PARSER)
+/* KDevelop has problems with our align macro, so just use nothing for parsing. */
+#define alignas(x)
+#else
+/* NOTE: Our custom ALIGN macro can't take a type name like alignas can. For
+ * maximum compatibility, only provide constant integer values to alignas. */
+#define alignas(_x) ALIGN(_x)
+#endif
+#endif
+
+#endif /* AL_ALIGN_H */
diff --git a/include/atomic.h b/include/atomic.h
new file mode 100644
index 00000000..3b5ec24d
--- /dev/null
+++ b/include/atomic.h
@@ -0,0 +1,141 @@
+#ifndef AL_ATOMIC_H
+#define AL_ATOMIC_H
+
+
+typedef void *volatile XchgPtr;
+
+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && !defined(__QNXNTO__)
+typedef unsigned int RefCount;
+inline RefCount IncrementRef(volatile RefCount *ptr)
+{ return __sync_add_and_fetch(ptr, 1); }
+inline RefCount DecrementRef(volatile RefCount *ptr)
+{ return __sync_sub_and_fetch(ptr, 1); }
+
+inline int ExchangeInt(volatile int *ptr, int newval)
+{
+ return __sync_lock_test_and_set(ptr, newval);
+}
+inline void *ExchangePtr(XchgPtr *ptr, void *newval)
+{
+ return __sync_lock_test_and_set(ptr, newval);
+}
+inline int CompExchangeInt(volatile int *ptr, int oldval, int newval)
+{
+ return __sync_val_compare_and_swap(ptr, oldval, newval);
+}
+inline void *CompExchangePtr(XchgPtr *ptr, void *oldval, void *newval)
+{
+ return __sync_val_compare_and_swap(ptr, oldval, newval);
+}
+
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+
+inline unsigned int xaddl(volatile unsigned int *dest, int incr)
+{
+ unsigned int ret;
+ __asm__ __volatile__("lock; xaddl %0,(%1)"
+ : "=r" (ret)
+ : "r" (dest), "0" (incr)
+ : "memory");
+ return ret;
+}
+
+typedef unsigned int RefCount;
+inline RefCount IncrementRef(volatile RefCount *ptr)
+{ return xaddl(ptr, 1)+1; }
+inline RefCount DecrementRef(volatile RefCount *ptr)
+{ return xaddl(ptr, -1)-1; }
+
+inline int ExchangeInt(volatile int *dest, int newval)
+{
+ int ret;
+ __asm__ __volatile__("lock; xchgl %0,(%1)"
+ : "=r" (ret)
+ : "r" (dest), "0" (newval)
+ : "memory");
+ return ret;
+}
+inline void *ExchangePtr(XchgPtr *dest, void *newval)
+{
+ void *ret;
+ __asm__ __volatile__(
+#ifdef __i386__
+ "lock; xchgl %0,(%1)"
+#else
+ "lock; xchgq %0,(%1)"
+#endif
+ : "=r" (ret)
+ : "r" (dest), "0" (newval)
+ : "memory"
+ );
+ return ret;
+}
+inline int CompExchangeInt(volatile int *dest, int oldval, int newval)
+{
+ int ret;
+ __asm__ __volatile__("lock; cmpxchgl %2,(%1)"
+ : "=a" (ret)
+ : "r" (dest), "r" (newval), "0" (oldval)
+ : "memory");
+ return ret;
+}
+inline void *CompExchangePtr(XchgPtr *dest, void *oldval, void *newval)
+{
+ void *ret;
+ __asm__ __volatile__(
+#ifdef __i386__
+ "lock; cmpxchgl %2,(%1)"
+#else
+ "lock; cmpxchgq %2,(%1)"
+#endif
+ : "=a" (ret)
+ : "r" (dest), "r" (newval), "0" (oldval)
+ : "memory"
+ );
+ return ret;
+}
+
+#elif defined(_WIN32)
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+typedef LONG RefCount;
+inline RefCount IncrementRef(volatile RefCount *ptr)
+{ return InterlockedIncrement(ptr); }
+inline RefCount DecrementRef(volatile RefCount *ptr)
+{ return InterlockedDecrement(ptr); }
+
+static_assert(sizeof(LONG)==sizeof(int), "sizeof LONG does not match sizeof int");
+
+inline int ExchangeInt(volatile int *ptr, int newval)
+{
+ union {
+ volatile int *i;
+ volatile LONG *l;
+ } u = { ptr };
+ return InterlockedExchange(u.l, newval);
+}
+inline void *ExchangePtr(XchgPtr *ptr, void *newval)
+{
+ return InterlockedExchangePointer(ptr, newval);
+}
+inline int CompExchangeInt(volatile int *ptr, int oldval, int newval)
+{
+ union {
+ volatile int *i;
+ volatile LONG *l;
+ } u = { ptr };
+ return InterlockedCompareExchange(u.l, newval, oldval);
+}
+inline void *CompExchangePtr(XchgPtr *ptr, void *oldval, void *newval)
+{
+ return InterlockedCompareExchangePointer(ptr, newval, oldval);
+}
+
+#else
+#error "No atomic functions available on this platform!"
+typedef unsigned int RefCount;
+#endif
+
+#endif /* AL_ATOMIC_H */
diff --git a/include/threads.h b/include/threads.h
new file mode 100644
index 00000000..40f523fa
--- /dev/null
+++ b/include/threads.h
@@ -0,0 +1,217 @@
+#ifndef AL_THREADS_H
+#define AL_THREADS_H
+
+#include <time.h>
+
+
+enum {
+ althrd_success = 0,
+ althrd_error,
+ althrd_nomem,
+ althrd_timedout,
+ althrd_busy
+};
+
+enum {
+ almtx_plain = 0,
+ almtx_recursive = 1,
+ almtx_timed = 2
+};
+
+typedef int (*althrd_start_t)(void*);
+typedef void (*altss_dtor_t)(void*);
+
+
+#define AL_TIME_UTC 1
+
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+
+#ifndef __MINGW32__
+struct timespec {
+ time_t tv_sec;
+ long tv_nsec;
+};
+#endif
+
+typedef DWORD althrd_t;
+typedef CRITICAL_SECTION almtx_t;
+typedef DWORD altss_t;
+typedef LONG alonce_flag;
+
+#define AL_ONCE_FLAG_INIT 0
+
+int althrd_sleep(const struct timespec *ts, struct timespec *rem);
+void alcall_once(alonce_flag *once, void (*callback)(void));
+
+
+inline althrd_t althrd_current(void)
+{
+ return GetCurrentThreadId();
+}
+
+inline int althrd_equal(althrd_t thr0, althrd_t thr1)
+{
+ return thr0 == thr1;
+}
+
+inline void althrd_exit(int res)
+{
+ ExitThread(res);
+}
+
+inline void althrd_yield(void)
+{
+ SwitchToThread();
+}
+
+
+inline int almtx_lock(almtx_t *mtx)
+{
+ if(!mtx) return althrd_error;
+ EnterCriticalSection(mtx);
+ return althrd_success;
+}
+
+inline int almtx_unlock(almtx_t *mtx)
+{
+ if(!mtx) return althrd_error;
+ LeaveCriticalSection(mtx);
+ return althrd_success;
+}
+
+inline int almtx_trylock(almtx_t *mtx)
+{
+ if(!mtx) return althrd_error;
+ if(!TryEnterCriticalSection(mtx))
+ return althrd_busy;
+ return althrd_success;
+}
+
+
+inline void *altss_get(altss_t tss_id)
+{
+ return TlsGetValue(tss_id);
+}
+
+inline int altss_set(altss_t tss_id, void *val)
+{
+ if(TlsSetValue(tss_id, val) == 0)
+ return althrd_error;
+ return althrd_success;
+}
+
+#else
+
+#include <stdint.h>
+#include <errno.h>
+#include <pthread.h>
+
+
+typedef pthread_t althrd_t;
+typedef pthread_mutex_t almtx_t;
+typedef pthread_key_t altss_t;
+typedef pthread_once_t alonce_flag;
+
+#define AL_ONCE_FLAG_INIT PTHREAD_ONCE_INIT
+
+
+inline althrd_t althrd_current(void)
+{
+ return pthread_self();
+}
+
+inline int althrd_equal(althrd_t thr0, althrd_t thr1)
+{
+ return pthread_equal(thr0, thr1);
+}
+
+inline void althrd_exit(int res)
+{
+ pthread_exit((void*)(intptr_t)res);
+}
+
+inline void althrd_yield(void)
+{
+ sched_yield();
+}
+
+inline int althrd_sleep(const struct timespec *ts, struct timespec *rem)
+{
+ int ret = nanosleep(ts, rem);
+ if(ret != 0)
+ {
+ ret = ((errno==EINTR) ? -1 : -2);
+ errno = 0;
+ }
+ return ret;
+}
+
+
+inline int almtx_lock(almtx_t *mtx)
+{
+ if(pthread_mutex_lock(mtx) != 0)
+ return althrd_error;
+ return althrd_success;
+}
+
+inline int almtx_unlock(almtx_t *mtx)
+{
+ if(pthread_mutex_unlock(mtx) != 0)
+ return althrd_error;
+ return althrd_success;
+}
+
+inline int almtx_trylock(almtx_t *mtx)
+{
+ int ret = pthread_mutex_trylock(mtx);
+ switch(ret)
+ {
+ case 0: return althrd_success;
+ case EBUSY: return althrd_busy;
+ }
+ return althrd_error;
+}
+
+
+inline void *altss_get(altss_t tss_id)
+{
+ return pthread_getspecific(tss_id);
+}
+
+inline int altss_set(altss_t tss_id, void *val)
+{
+ if(pthread_setspecific(tss_id, val) != 0)
+ return althrd_error;
+ return althrd_success;
+}
+
+
+inline void alcall_once(alonce_flag *once, void (*callback)(void))
+{
+ pthread_once(once, callback);
+}
+
+#endif
+
+
+int althrd_create(althrd_t *thr, althrd_start_t func, void *arg);
+int althrd_detach(althrd_t thr);
+int althrd_join(althrd_t thr, int *res);
+void althrd_setname(althrd_t thr, const char *name);
+
+int almtx_init(almtx_t *mtx, int type);
+void almtx_destroy(almtx_t *mtx);
+int almtx_timedlock(almtx_t *mtx, const struct timespec *ts);
+
+int altss_create(altss_t *tss_id, altss_dtor_t callback);
+void altss_delete(altss_t tss_id);
+
+int altimespec_get(struct timespec *ts, int base);
+
+void al_nssleep(time_t sec, long nsec);
+
+#endif /* AL_THREADS_H */
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-14 01:57:54 +0000