github
/
mpv
mirror of https://github.com/mpv-player/mpv
1
Fork 0
Code Releases Activity

win32/pthread: remove unused code

This commit is contained in:
Kacper Michajłow 2023-10-22 04:17:45 +02:00 committed by Dudemanguy
parent 71e888c2a0
commit e268dead30
3 changed files with 0 additions and 529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
osdep/win32/include/pthread.h
View File

@ -1,115 +0,0 @@
/* Copyright (C) 2017 the mpv developers
*
* 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.
*/
#ifndef MP_WRAP_PTHREAD_H_
#define MP_WRAP_PTHREAD_H_
// this is MinGW specific and sort of a hack but we really need to prevent
// system pthread headers from being included, which can happen through <time.h>
// and <unistd.h>:
#define WIN_PTHREADS_TIME_H
#define WIN_PTHREADS_UNISTD_H
#include <windows.h>
#include <sys/types.h>
#define _POSIX_TIMERS 200809L
// 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_trylock m_pthread_mutex_trylock
#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_exit m_pthread_exit
#define pthread_join m_pthread_join
#define pthread_detach m_pthread_detach
#define pthread_create m_pthread_create
#define pthread_set_name_np m_pthread_set_name_np
#define clock_gettime m_clock_gettime
#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 {
char use_cs;
union {
SRWLOCK srw;
CRITICAL_SECTION cs;
} lock;
} pthread_mutex_t;
// Assume SRWLOCK_INIT is {0} so we can easily remain C89-compatible.
#define PTHREAD_MUTEX_INITIALIZER {0}
#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) (*(attr) = (type))
#define PTHREAD_MUTEX_RECURSIVE 1
#define PTHREAD_MUTEX_ERRORCHECK 2 // unsupported
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_trylock(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)
#define clockid_t int
#define CLOCK_REALTIME 1
int clock_gettime(clockid_t clockid, struct timespec *tp);
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);
#define pthread_t DWORD
#define pthread_equal(a, b) ((a) == (b))
#define pthread_self() (GetCurrentThreadId())
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);
void pthread_set_name_np(pthread_t thread, const char *name);
#endif

44
osdep/win32/include/semaphore.h
View File

@ -1,44 +0,0 @@
/* Copyright (C) 2017 the mpv developers
*
* 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.
*/
#ifndef MP_WRAP_SEMAPHORE_H_
#define MP_WRAP_SEMAPHORE_H_
#include "osdep/threads.h"
// 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 {
mp_mutex lock;
mp_cond 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

370
osdep/win32/pthread.c
View File

@ -1,370 +0,0 @@
/* Copyright (C) 2017 the mpv developers
*
* 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 <pthread.h>
#include <semaphore.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <sys/time.h>
#include <assert.h>
#include <windows.h>
#include "osdep/timer.h" // mp_{start,end}_hires_timers
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)
{
if (mutex->use_cs)
DeleteCriticalSection(&mutex->lock.cs);
return 0;
}
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr)
{
mutex->use_cs = attr && (*attr & PTHREAD_MUTEX_RECURSIVE);
if (mutex->use_cs) {
InitializeCriticalSection(&mutex->lock.cs);
} else {
InitializeSRWLock(&mutex->lock.srw);
}
return 0;
}
int pthread_mutex_lock(pthread_mutex_t *mutex)
{
if (mutex->use_cs) {
EnterCriticalSection(&mutex->lock.cs);
} else {
AcquireSRWLockExclusive(&mutex->lock.srw);
}
return 0;
}
int pthread_mutex_trylock(pthread_mutex_t *mutex)
{
if (mutex->use_cs) {
return !TryEnterCriticalSection(&mutex->lock.cs);
} else {
return !TryAcquireSRWLockExclusive(&mutex->lock.srw);
}
}
int pthread_mutex_unlock(pthread_mutex_t *mutex)
{
if (mutex->use_cs) {
LeaveCriticalSection(&mutex->lock.cs);
} else {
ReleaseSRWLockExclusive(&mutex->lock.srw);
}
return 0;
}
int clock_gettime(clockid_t clockid, struct timespec *tp)
{
if (clockid != CLOCK_REALTIME) {
errno = EINVAL;
return -1;
}
union {
FILETIME ft;
ULARGE_INTEGER i;
} r;
GetSystemTimePreciseAsFileTime(&r.ft);
r.i.QuadPart -= UINT64_C(116444736000000000); // MS epoch -> Unix epoch
tp->tv_sec = r.i.QuadPart / UINT64_C(10000000);
tp->tv_nsec = (r.i.QuadPart % UINT64_C(10000000)) * 100;
return 0;
}
static int cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
DWORD ms)
{
BOOL res;
int hrt = mp_start_hires_timers(ms);
if (mutex->use_cs) {
res = SleepConditionVariableCS(cond, &mutex->lock.cs, ms);
} else {
res = SleepConditionVariableSRW(cond, &mutex->lock.srw, ms, 0);
}
mp_end_hires_timers(hrt);
return res ? 0 : ETIMEDOUT;
}
int pthread_cond_timedwait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime)
{
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
DWORD timeout_ms = 0;
if (abstime->tv_sec >= INT64_MAX / 1000) { // overflow
timeout_ms = INFINITE;
} else if (abstime->tv_sec >= ts.tv_sec) {
int64_t msec = (abstime->tv_sec - ts.tv_sec) * INT64_C(1000) +
(abstime->tv_nsec - ts.tv_nsec) / INT64_C(1000000);
if (msec > ULONG_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);
}
static pthread_mutex_t pthread_table_lock = PTHREAD_MUTEX_INITIALIZER;
static struct m_thread_info *pthread_table;
size_t pthread_table_num;
struct m_thread_info {
DWORD id;
HANDLE handle;
void *(*user_fn)(void *);
void *user_arg;
void *res;
};
static struct m_thread_info *find_thread_info(DWORD id)
{
for (int n = 0; n < pthread_table_num; n++) {
if (id == pthread_table[n].id)
return &pthread_table[n];
}
return NULL;
}
static void remove_thread_info(struct m_thread_info *info)
{
assert(pthread_table_num);
assert(info >= &pthread_table[0] && info < &pthread_table[pthread_table_num]);
pthread_table[info - pthread_table] = pthread_table[pthread_table_num - 1];
pthread_table_num -= 1;
// Avoid upsetting leak detectors.
if (pthread_table_num == 0) {
free(pthread_table);
pthread_table = NULL;
}
}
void pthread_exit(void *retval)
{
pthread_mutex_lock(&pthread_table_lock);
struct m_thread_info *info = find_thread_info(pthread_self());
assert(info); // not started with pthread_create, or pthread_join() race
info->res = retval;
if (!info->handle)
remove_thread_info(info); // detached case
pthread_mutex_unlock(&pthread_table_lock);
ExitThread(0);
}
int pthread_join(pthread_t thread, void **retval)
{
pthread_mutex_lock(&pthread_table_lock);
struct m_thread_info *info = find_thread_info(thread);
assert(info); // not started with pthread_create, or pthread_join() race
HANDLE h = info->handle;
assert(h); // thread was detached
pthread_mutex_unlock(&pthread_table_lock);
WaitForSingleObject(h, INFINITE);
pthread_mutex_lock(&pthread_table_lock);
info = find_thread_info(thread);
assert(info);
assert(info->handle == h);
CloseHandle(h);
if (retval)
*retval = info->res;
remove_thread_info(info);
pthread_mutex_unlock(&pthread_table_lock);
return 0;
}
int pthread_detach(pthread_t thread)
{
if (!pthread_equal(thread, pthread_self()))
abort(); // restriction of this wrapper
pthread_mutex_lock(&pthread_table_lock);
struct m_thread_info *info = find_thread_info(thread);
assert(info); // not started with pthread_create
assert(info->handle); // already detached
CloseHandle(info->handle);
info->handle = NULL;
pthread_mutex_unlock(&pthread_table_lock);
return 0;
}
static DWORD WINAPI run_thread(LPVOID lpParameter)
{
pthread_mutex_lock(&pthread_table_lock);
struct m_thread_info *pinfo = find_thread_info(pthread_self());
assert(pinfo);
struct m_thread_info info = *pinfo;
pthread_mutex_unlock(&pthread_table_lock);
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)
{
int res = 0;
pthread_mutex_lock(&pthread_table_lock);
void *nalloc =
realloc(pthread_table, (pthread_table_num + 1) * sizeof(pthread_table[0]));
if (!nalloc) {
res = EAGAIN;
goto done;
}
pthread_table = nalloc;
pthread_table_num += 1;
struct m_thread_info *info = &pthread_table[pthread_table_num - 1];
*info = (struct m_thread_info) {
.user_fn = start_routine,
.user_arg = arg,
};
info->handle = CreateThread(NULL, 0, run_thread, NULL, CREATE_SUSPENDED,
&info->id);
if (!info->handle) {
remove_thread_info(info);
res = EAGAIN;
goto done;
}
*thread = info->id;
ResumeThread(info->handle);
done:
pthread_mutex_unlock(&pthread_table_lock);
return res;
}
void pthread_set_name_np(pthread_t thread, const char *name)
{
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && defined(_PROCESSTHREADSAPI_H_)
HMODULE kernel32 = GetModuleHandleW(L"kernel32.dll");
if (!kernel32)
return;
HRESULT (WINAPI *pSetThreadDescription)(HANDLE, PCWSTR) =
(void*)GetProcAddress(kernel32, "SetThreadDescription");
if (!pSetThreadDescription)
return;
HANDLE th = OpenThread(THREAD_SET_LIMITED_INFORMATION, FALSE, thread);
if (!th)
return;
wchar_t wname[80];
int wc = MultiByteToWideChar(CP_UTF8, 0, name, -1, wname,
sizeof(wname) / sizeof(wchar_t) - 1);
if (wc > 0) {
wname[wc] = L'\0';
pSetThreadDescription(th, wname);
}
CloseHandle(th);
#endif
}
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;
}