80486DX2-66/86Box-fork
1
0
Fork 0
Code Issues Pull Requests Activity

Remove Win32 code from the pthread implementation

Browse Source
This commit is contained in:
David Hrdlička
2021-09-23 22:52:13 +02:00
parent b44d5884f4
commit c51f899d0f
1 changed files with 35 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
src/thread.c
View File

@@ -1,169 +1,10 @@
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h>
#include <time.h> #include <time.h>
#ifdef __APPLE__ #include <pthread.h>
#include <sys/time.h> #include <inttypes.h>
#endif
#include <86box/86box.h> #include <86box/86box.h>
#include <86box/plat.h> #include <86box/plat.h>
#if (defined WIN32) || (defined _WIN32) || (defined _WIN32)
#include <windows.h>
#include <process.h>
typedef struct {
HANDLE handle;
} win_event_t;
thread_t *
thread_create(void (*func)(void *param), void *param)
{
uintptr_t bt = _beginthread(func, 0, param);
return((thread_t *)bt);
}
int
thread_wait(thread_t *arg, int timeout)
{
if (arg == NULL) return(0);
if (timeout == -1)
timeout = INFINITE;
if (WaitForSingleObject(arg, timeout)) return(1);
return(0);
}
event_t *
thread_create_event(void)
{
win_event_t *ev = malloc(sizeof(win_event_t));
ev->handle = CreateEvent(NULL, FALSE, FALSE, NULL);
return((event_t *)ev);
}
void
thread_set_event(event_t *arg)
{
win_event_t *ev = (win_event_t *)arg;
if (arg == NULL) return;
SetEvent(ev->handle);
}
void
thread_reset_event(event_t *arg)
{
win_event_t *ev = (win_event_t *)arg;
if (arg == NULL) return;
ResetEvent(ev->handle);
}
int
thread_wait_event(event_t *arg, int timeout)
{
win_event_t *ev = (win_event_t *)arg;
if (arg == NULL) return(0);
if (ev->handle == NULL) return(0);
if (timeout == -1)
timeout = INFINITE;
if (WaitForSingleObject(ev->handle, timeout)) return(1);
return(0);
}
void
thread_destroy_event(event_t *arg)
{
win_event_t *ev = (win_event_t *)arg;
if (arg == NULL) return;
CloseHandle(ev->handle);
free(ev);
}
mutex_t *
thread_create_mutex(void)
{
mutex_t *mutex = malloc(sizeof(CRITICAL_SECTION));
InitializeCriticalSection(mutex);
return mutex;
}
mutex_t *
thread_create_mutex_with_spin_count(unsigned int spin_count)
{
mutex_t *mutex = malloc(sizeof(CRITICAL_SECTION));
InitializeCriticalSectionAndSpinCount(mutex, spin_count);
return mutex;
}
int
thread_wait_mutex(mutex_t *mutex)
{
if (mutex == NULL) return(0);
LPCRITICAL_SECTION critsec = (LPCRITICAL_SECTION)mutex;
EnterCriticalSection(critsec);
return 1;
}
int
thread_release_mutex(mutex_t *mutex)
{
if (mutex == NULL) return(0);
LPCRITICAL_SECTION critsec = (LPCRITICAL_SECTION)mutex;
LeaveCriticalSection(critsec);
return 1;
}
void
thread_close_mutex(mutex_t *mutex)
{
if (mutex == NULL) return;
LPCRITICAL_SECTION critsec = (LPCRITICAL_SECTION)mutex;
DeleteCriticalSection(critsec);
free(critsec);
}
#else
#include <pthread.h>
#include <unistd.h>
typedef struct event_pthread_t typedef struct event_pthread_t
@@ -174,18 +15,38 @@ typedef struct event_pthread_t
} event_pthread_t; } event_pthread_t;
typedef struct thread_param
{
void (*thread_rout)(void*);
void * param;
} thread_param;
typedef struct pt_mutex_t typedef struct pt_mutex_t
{ {
pthread_mutex_t mutex; pthread_mutex_t mutex;
} pt_mutex_t; } pt_mutex_t;
void *
thread_run_wrapper(thread_param* arg)
{
thread_param localparam = *arg;
free(arg);
localparam.thread_rout(localparam.param);
return NULL;
}
thread_t * thread_t *
thread_create(void (*thread_rout)(void *param), void *param) thread_create(void (*thread_rout)(void *param), void *param)
{ {
pthread_t *thread = malloc(sizeof(pthread_t)); pthread_t *thread = malloc(sizeof(pthread_t));
thread_param *thrparam = malloc(sizeof(thread_param));
thrparam->thread_rout = thread_rout;
thrparam->param = param;
pthread_create(thread, NULL, (void*)thread_rout, param); pthread_create(thread, NULL, (void* (*)(void*))thread_run_wrapper, thrparam);
return thread; return thread;
} }
@@ -240,13 +101,10 @@ thread_wait_event(event_t *handle, int timeout)
event_pthread_t *event = (event_pthread_t *)handle; event_pthread_t *event = (event_pthread_t *)handle;
struct timespec abstime; struct timespec abstime;
#ifdef __linux__ #ifdef HAS_TIMESPEC_GET
clock_gettime(CLOCK_REALTIME, &abstime); timespec_get(&abstime, TIME_UTC);
#else #else
struct timeval now; clock_gettime(CLOCK_REALTIME, &abstime);
gettimeofday(&now, 0);
abstime.tv_sec = now.tv_sec;
abstime.tv_nsec = now.tv_usec*1000UL;
#endif #endif
abstime.tv_nsec += (timeout % 1000) * 1000000; abstime.tv_nsec += (timeout % 1000) * 1000000;
abstime.tv_sec += (timeout / 1000); abstime.tv_sec += (timeout / 1000);
@@ -301,22 +159,23 @@ thread_create_mutex_with_spin_count(unsigned int spin_count)
int int
thread_wait_mutex(mutex_t *_mutex) thread_wait_mutex(mutex_t *_mutex)
{ {
if (_mutex == NULL)
return(0);
pt_mutex_t *mutex = (pt_mutex_t *)_mutex; pt_mutex_t *mutex = (pt_mutex_t *)_mutex;
pthread_mutex_lock(&mutex->mutex); return
pthread_mutex_lock(&mutex->mutex) != 0;
return 1;
} }
int int
thread_release_mutex(mutex_t *_mutex) thread_release_mutex(mutex_t *_mutex)
{ {
if (_mutex == NULL)
return(0);
pt_mutex_t *mutex = (pt_mutex_t *)_mutex; pt_mutex_t *mutex = (pt_mutex_t *)_mutex;
pthread_mutex_unlock(&mutex->mutex); return pthread_mutex_unlock(&mutex->mutex) != 0;
return 1;
} }
@@ -329,4 +188,3 @@ thread_close_mutex(mutex_t *_mutex)
free(mutex); free(mutex);
} }
#endif