From bafb9b22715313ef0049630228a744d7f2c9363b Mon Sep 17 00:00:00 2001 From: wm4 Date: Thu, 1 Jan 2015 15:10:42 +0100 Subject: win32: add native wrappers for pthread functions Off by default, use --enable-win32-internal-pthreads . This probably still needs a lot more testing. It also won't work on Windows XP. --- osdep/win32/include/pthread.h | 82 ++++++++++++ osdep/win32/include/semaphore.h | 29 +++++ osdep/win32/pthread.c | 269 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 380 insertions(+) create mode 100644 osdep/win32/include/pthread.h create mode 100644 osdep/win32/include/semaphore.h create mode 100644 osdep/win32/pthread.c (limited to 'osdep') diff --git a/osdep/win32/include/pthread.h b/osdep/win32/include/pthread.h new file mode 100644 index 0000000000..2e9436d80b --- /dev/null +++ b/osdep/win32/include/pthread.h @@ -0,0 +1,82 @@ +#ifndef MP_WRAP_PTHREAD_H_ +#define MP_WRAP_PTHREAD_H_ + +#include + +#include + +// Note: all pthread functions are mangled to make static linking easier. +#define pthread_once m_pthread_once +#define pthread_mutex_destroy m_pthread_mutex_destroy +#define pthread_mutex_init m_pthread_mutex_init +#define pthread_mutex_lock m_pthread_mutex_lock +#define pthread_mutex_unlock m_pthread_mutex_unlock +#define pthread_cond_timedwait m_pthread_cond_timedwait +#define pthread_cond_wait m_pthread_cond_wait +#define pthread_self m_pthread_self +#define pthread_exit m_pthread_exit +#define pthread_join m_pthread_join +#define pthread_detach m_pthread_detach +#define pthread_create m_pthread_create + +#define pthread_once_t INIT_ONCE +#define PTHREAD_ONCE_INIT INIT_ONCE_STATIC_INIT + +int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)); + +typedef struct { + volatile LONG requires_init; + CRITICAL_SECTION cs; +} pthread_mutex_t; + +#define PTHREAD_MUTEX_INITIALIZER {1} + +#define pthread_mutexattr_t int +#define pthread_mutexattr_destroy(attr) (void)0 +#define pthread_mutexattr_init(attr) (*(attr) = 0) +#define pthread_mutexattr_settype(attr, type) (void)0 +// CRITICAL_SECTION is always recursive +#define PTHREAD_MUTEX_RECURSIVE 0 + +int pthread_mutex_destroy(pthread_mutex_t *mutex); +int pthread_mutex_init(pthread_mutex_t *restrict mutex, + const pthread_mutexattr_t *restrict attr); + +int pthread_mutex_lock(pthread_mutex_t *mutex); +int pthread_mutex_unlock(pthread_mutex_t *mutex); + +#define pthread_cond_t CONDITION_VARIABLE +#define pthread_condattr_t int + +#define PTHREAD_COND_INITIALIZER CONDITION_VARIABLE_INIT + +#define pthread_cond_init(cond, attr) InitializeConditionVariable(cond) +#define pthread_cond_destroy(c) (void)0 +#define pthread_cond_broadcast(cond) WakeAllConditionVariable(cond) +#define pthread_cond_signal(cond) WakeConditionVariable(cond) + +int pthread_cond_timedwait(pthread_cond_t *restrict cond, + pthread_mutex_t *restrict mutex, + const struct timespec *restrict abstime); +int pthread_cond_wait(pthread_cond_t *restrict cond, + pthread_mutex_t *restrict mutex); + +// Unusual, but allowed by POSIX. +typedef struct { + DWORD id; + struct m_thread_info *info; +} pthread_t; + +#define pthread_equal(a, b) ((a).id == (b).id) + +pthread_t pthread_self(void); +void pthread_exit(void *retval); +int pthread_join(pthread_t thread, void **retval); +int pthread_detach(pthread_t thread); + +#define pthread_attr_t int + +int pthread_create(pthread_t *thread, const pthread_attr_t *attr, + void *(*start_routine) (void *), void *arg); + +#endif diff --git a/osdep/win32/include/semaphore.h b/osdep/win32/include/semaphore.h new file mode 100644 index 0000000000..49670fc7a5 --- /dev/null +++ b/osdep/win32/include/semaphore.h @@ -0,0 +1,29 @@ +#ifndef MP_WRAP_SEMAPHORE_H_ +#define MP_WRAP_SEMAPHORE_H_ + +#include + +// See pthread.h for rationale. +#define sem_init m_sem_init +#define sem_destroy m_sem_destroy +#define sem_wait m_sem_wait +#define sem_trywait m_sem_trywait +#define sem_timedwait m_sem_timedwait +#define sem_post m_sem_post + +#define SEM_VALUE_MAX 100 + +typedef struct { + pthread_mutex_t lock; + pthread_cond_t wakeup; + unsigned int value; +} sem_t; + +int sem_init(sem_t *sem, int pshared, unsigned int value); +int sem_destroy(sem_t *sem); +int sem_wait(sem_t *sem); +int sem_trywait(sem_t *sem); +int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout); +int sem_post(sem_t *sem); + +#endif diff --git a/osdep/win32/pthread.c b/osdep/win32/pthread.c new file mode 100644 index 0000000000..ee4b5a158d --- /dev/null +++ b/osdep/win32/pthread.c @@ -0,0 +1,269 @@ +/* Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +#include +#include + +#include +#include +#include +#include + +// We keep this around to avoid active waiting while handling static +// initializers. +static pthread_once_t init_cs_once = PTHREAD_ONCE_INIT; +static CRITICAL_SECTION init_cs; + +static void init_init_cs(void) +{ + InitializeCriticalSection(&init_cs); +} + +static void init_lock(void) +{ + pthread_once(&init_cs_once, init_init_cs); + EnterCriticalSection(&init_cs); +} + +static void init_unlock(void) +{ + LeaveCriticalSection(&init_cs); +} + +int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) +{ + BOOL pending; + if (!InitOnceBeginInitialize(once_control, 0, &pending, NULL)) + abort(); + if (pending) { + init_routine(); + InitOnceComplete(once_control, 0, NULL); + } + return 0; +} + +int pthread_mutex_destroy(pthread_mutex_t *mutex) +{ + DeleteCriticalSection(&mutex->cs); + return 0; +} + +int pthread_mutex_init(pthread_mutex_t *restrict mutex, + const pthread_mutexattr_t *restrict attr) +{ + InitializeCriticalSection(&mutex->cs); + return 0; +} + +int pthread_mutex_lock(pthread_mutex_t *mutex) +{ + if (mutex->requires_init) { + init_lock(); + if (mutex->requires_init) + InitializeCriticalSection(&mutex->cs); + _InterlockedAnd(&mutex->requires_init, 0); + init_unlock(); + } + EnterCriticalSection(&mutex->cs); + return 0; +} + +int pthread_mutex_unlock(pthread_mutex_t *mutex) +{ + LeaveCriticalSection(&mutex->cs); + return 0; +} + +static int cond_wait(pthread_cond_t *restrict cond, + pthread_mutex_t *restrict mutex, + DWORD ms) +{ + return SleepConditionVariableCS(cond, &mutex->cs, ms) ? 0 : ETIMEDOUT; +} + +int pthread_cond_timedwait(pthread_cond_t *restrict cond, + pthread_mutex_t *restrict mutex, + const struct timespec *restrict abstime) +{ + // mpv uses mingw's gettimeofday() as time source too. + struct timeval tv; + gettimeofday(&tv, NULL); + DWORD timeout_ms = 0; + if (abstime->tv_sec >= INT64_MAX / 10000) { + timeout_ms = INFINITE; + } else if (abstime->tv_sec >= tv.tv_sec) { + long long msec = (abstime->tv_sec - tv.tv_sec) * 1000LL + + abstime->tv_nsec / 1000LL / 1000LL - tv.tv_usec / 1000LL; + if (msec > INT_MAX) { + timeout_ms = INFINITE; + } else if (msec > 0) { + timeout_ms = msec; + } + } + return cond_wait(cond, mutex, timeout_ms); +} + +int pthread_cond_wait(pthread_cond_t *restrict cond, + pthread_mutex_t *restrict mutex) +{ + return cond_wait(cond, mutex, INFINITE); +} + +struct m_thread_info { + HANDLE handle; + void *(*user_fn)(void *); + void *user_arg; + void *res; +}; + +// Assuming __thread maps to __declspec(thread) +static __thread struct m_thread_info *self; + +pthread_t pthread_self(void) +{ + return (pthread_t){GetCurrentThreadId(), self}; +} + +void pthread_exit(void *retval) +{ + if (!self) + abort(); // not started with pthread_create + self->res = retval; + if (!self->handle) { + // detached case + free(self); + self = NULL; + } + ExitThread(0); +} + +int pthread_join(pthread_t thread, void **retval) +{ + if (!thread.info) + abort(); // not started with pthread_create + HANDLE h = thread.info->handle; + if (!h) + abort(); // thread was detached + WaitForSingleObject(h, INFINITE); + CloseHandle(h); + if (retval) + *retval = thread.info->res; + free(thread.info); + return 0; +} + +int pthread_detach(pthread_t thread) +{ + if (!pthread_equal(thread, pthread_self())) + abort(); // restriction of this wrapper + if (!thread.info) + abort(); // not started with pthread_create + if (!thread.info->handle) + abort(); // already deatched + CloseHandle(thread.info->handle); + thread.info->handle = NULL; + return 0; +} + +static DWORD WINAPI run_thread(LPVOID lpParameter) +{ + struct m_thread_info *info = lpParameter; + self = info; + pthread_exit(info->user_fn(info->user_arg)); + abort(); // not reached +} + +int pthread_create(pthread_t *thread, const pthread_attr_t *attr, + void *(*start_routine) (void *), void *arg) +{ + struct m_thread_info *info = calloc(1, sizeof(*info)); + if (!info) + return EAGAIN; + info->user_fn = start_routine; + info->user_arg = arg; + HANDLE h = CreateThread(NULL, 0, run_thread, info, CREATE_SUSPENDED, NULL); + if (!h) { + free(info); + return EAGAIN; + } + info->handle = h; + *thread = (pthread_t){GetThreadId(h), info}; + ResumeThread(h); + return 0; +} + +int sem_init(sem_t *sem, int pshared, unsigned int value) +{ + if (pshared) + abort(); // unsupported + pthread_mutex_init(&sem->lock, NULL); + pthread_cond_init(&sem->wakeup, NULL); + sem->value = value; + return 0; +} + +int sem_destroy(sem_t *sem) +{ + pthread_mutex_destroy(&sem->lock); + pthread_cond_destroy(&sem->wakeup); + return 0; +} + +int sem_wait(sem_t *sem) +{ + pthread_mutex_lock(&sem->lock); + while (!sem->value) + pthread_cond_wait(&sem->wakeup, &sem->lock); + sem->value -= 1; + pthread_mutex_unlock(&sem->lock); + return 0; +} + +int sem_trywait(sem_t *sem) +{ + pthread_mutex_lock(&sem->lock); + int r; + if (sem->value > 0) { + sem->value -= 1; + r = 0; + } else { + errno = EAGAIN; + r = -1; + } + pthread_mutex_unlock(&sem->lock); + return r; +} + +int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout) +{ + pthread_mutex_lock(&sem->lock); + while (!sem->value) { + int err = pthread_cond_timedwait(&sem->wakeup, &sem->lock, abs_timeout); + if (err) { + pthread_mutex_unlock(&sem->lock); + errno = err; + return -1; + } + } + sem->value -= 1; + pthread_mutex_unlock(&sem->lock); + return 0; +} + +int sem_post(sem_t *sem) +{ + pthread_mutex_lock(&sem->lock); + sem->value += 1; + pthread_cond_broadcast(&sem->wakeup); + pthread_mutex_unlock(&sem->lock); + return 0; +} -- cgit v1.2.3