libretro/beetle-lynx-libretro
1
0
Fork 0
mirror of https://github.com/libretro/beetle-lynx-libretro.git synced 2024-11-27 10:22:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge thread stub functions into stubs.cpp

Browse Source
This commit is contained in:
twinaphex 2012-11-20 17:11:38 +01:00
parent 2847ec254c
commit 7ffaa8cf30
4 changed files with 326 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile
View File

@ -185,7 +185,6 @@ IS_X86 = 1
endif
ifeq ($(NEED_THREADING), 1)
THREAD_STUBS += thread.cpp stubs_thread.cpp
FLAGS += -DWANT_THREADING
endif

326
stubs.cpp
View File

@ -137,3 +137,329 @@ uint32 MDFND_GetTime()
return ms - start_ms;
}
#ifdef WANT_THREADING
#include "thread.h"
#include <stdlib.h>
#if defined(_WIN32) && !defined(_XBOX)
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#elif defined(_XBOX)
#include <xtl.h>
#elif defined(GEKKO)
#include "thread/gx_pthread.h"
#else
#include <pthread.h>
#include <time.h>
#endif
#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>
#endif
struct thread_data
{
void (*func)(void*);
void *userdata;
};
#ifdef _WIN32
struct sthread
{
HANDLE thread;
};
static DWORD CALLBACK thread_wrap(void *data_)
{
struct thread_data *data = (struct thread_data*)data_;
data->func(data->userdata);
free(data);
return 0;
}
sthread_t *sthread_create(void (*thread_func)(void*), void *userdata)
{
sthread_t *thread = (sthread_t*)calloc(1, sizeof(*thread));
if (!thread)
return NULL;
struct thread_data *data = (struct thread_data*)calloc(1, sizeof(*data));
if (!data)
{
free(thread);
return NULL;
}
data->func = thread_func;
data->userdata = userdata;
thread->thread = CreateThread(NULL, 0, thread_wrap, data, 0, NULL);
if (!thread->thread)
{
free(data);
free(thread);
return NULL;
}
return thread;
}
void sthread_join(sthread_t *thread)
{
WaitForSingleObject(thread->thread, INFINITE);
CloseHandle(thread->thread);
free(thread);
}
struct slock
{
CRITICAL_SECTION lock;
};
slock_t *slock_new(void)
{
slock_t *lock = (slock_t*)calloc(1, sizeof(*lock));
if (!lock)
return NULL;
InitializeCriticalSection(&lock->lock);
return lock;
}
void slock_free(slock_t *lock)
{
DeleteCriticalSection(&lock->lock);
free(lock);
}
void slock_lock(slock_t *lock)
{
EnterCriticalSection(&lock->lock);
}
void slock_unlock(slock_t *lock)
{
LeaveCriticalSection(&lock->lock);
}
struct scond
{
HANDLE event;
};
scond_t *scond_new(void)
{
scond_t *cond = (scond_t*)calloc(1, sizeof(*cond));
if (!cond)
return NULL;
cond->event = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!cond->event)
{
free(cond);
return NULL;
}
return cond;
}
void scond_wait(scond_t *cond, slock_t *lock)
{
WaitForSingleObject(cond->event, 0);
slock_unlock(lock);
WaitForSingleObject(cond->event, INFINITE);
slock_lock(lock);
}
int scond_wait_timeout(scond_t *cond, slock_t *lock, unsigned timeout_ms)
{
WaitForSingleObject(cond->event, 0);
slock_unlock(lock);
DWORD res = WaitForSingleObject(cond->event, timeout_ms);
slock_lock(lock);
return res == WAIT_OBJECT_0;
}
void scond_signal(scond_t *cond)
{
SetEvent(cond->event);
}
void scond_free(scond_t *cond)
{
CloseHandle(cond->event);
free(cond);
}
#else
struct sthread
{
pthread_t id;
};
static void *thread_wrap(void *data_)
{
struct thread_data *data = (struct thread_data*)data_;
data->func(data->userdata);
free(data);
return NULL;
}
sthread_t *sthread_create(void (*thread_func)(void*), void *userdata)
{
sthread_t *thr = (sthread_t*)calloc(1, sizeof(*thr));
if (!thr)
return NULL;
struct thread_data *data = (struct thread_data*)calloc(1, sizeof(*data));
if (!data)
{
free(thr);
return NULL;
}
data->func = thread_func;
data->userdata = userdata;
if (pthread_create(&thr->id, NULL, thread_wrap, data) < 0)
{
free(data);
free(thr);
return NULL;
}
return thr;
}
void sthread_join(sthread_t *thread)
{
pthread_join(thread->id, NULL);
free(thread);
}
struct slock
{
pthread_mutex_t lock;
};
slock_t *slock_new(void)
{
slock_t *lock = (slock_t*)calloc(1, sizeof(*lock));
if (!lock)
return NULL;
if (pthread_mutex_init(&lock->lock, NULL) < 0)
{
free(lock);
return NULL;
}
return lock;
}
void slock_free(slock_t *lock)
{
pthread_mutex_destroy(&lock->lock);
free(lock);
}
void slock_lock(slock_t *lock)
{
pthread_mutex_lock(&lock->lock);
}
void slock_unlock(slock_t *lock)
{
pthread_mutex_unlock(&lock->lock);
}
struct scond
{
pthread_cond_t cond;
};
scond_t *scond_new(void)
{
scond_t *cond = (scond_t*)calloc(1, sizeof(*cond));
if (!cond)
return NULL;
if (pthread_cond_init(&cond->cond, NULL) < 0)
{
free(cond);
return NULL;
}
return cond;
}
void scond_free(scond_t *cond)
{
pthread_cond_destroy(&cond->cond);
free(cond);
}
void scond_wait(scond_t *cond, slock_t *lock)
{
pthread_cond_wait(&cond->cond, &lock->lock);
}
void scond_signal(scond_t *cond)
{
pthread_cond_signal(&cond->cond);
}
#endif
MDFN_Thread *MDFND_CreateThread(int (*fn)(void *), void *data)
{
return (MDFN_Thread*)sthread_create((void (*)(void*))fn, data);
}
void MDFND_WaitThread(MDFN_Thread *thr, int *val)
{
sthread_join((sthread_t*)thr);
if (val)
{
*val = 0;
fprintf(stderr, "WaitThread relies on return value.\n");
}
}
void MDFND_KillThread(MDFN_Thread *)
{
fprintf(stderr, "Killing a thread is a BAD IDEA!\n");
}
MDFN_Mutex *MDFND_CreateMutex()
{
return (MDFN_Mutex*)slock_new();
}
void MDFND_DestroyMutex(MDFN_Mutex *lock)
{
slock_free((slock_t*)lock);
}
int MDFND_LockMutex(MDFN_Mutex *lock)
{
slock_lock((slock_t*)lock);
return 0;
}
int MDFND_UnlockMutex(MDFN_Mutex *lock)
{
slock_unlock((slock_t*)lock);
return 0;
}
#endif

50
stubs_thread.cpp
View File

@ -1,50 +0,0 @@
#include "mednafen/mednafen-types.h"
#include "mednafen/mednafen.h"
#include "mednafen/md5.h"
#include "mednafen/git.h"
#include "mednafen/general.h"
#include "mednafen/mednafen-driver.h"
#include "thread.h"
MDFN_Thread *MDFND_CreateThread(int (*fn)(void *), void *data)
{
return (MDFN_Thread*)sthread_create((void (*)(void*))fn, data);
}
void MDFND_WaitThread(MDFN_Thread *thr, int *val)
{
sthread_join((sthread_t*)thr);
if (val)
{
*val = 0;
fprintf(stderr, "WaitThread relies on return value.\n");
}
}
void MDFND_KillThread(MDFN_Thread *)
{
fprintf(stderr, "Killing a thread is a BAD IDEA!\n");
}
MDFN_Mutex *MDFND_CreateMutex()
{
return (MDFN_Mutex*)slock_new();
}
void MDFND_DestroyMutex(MDFN_Mutex *lock)
{
slock_free((slock_t*)lock);
}
int MDFND_LockMutex(MDFN_Mutex *lock)
{
slock_lock((slock_t*)lock);
return 0;
}
int MDFND_UnlockMutex(MDFN_Mutex *lock)
{
slock_unlock((slock_t*)lock);
return 0;
}

295
thread.cpp
View File

@ -1,295 +0,0 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2012 - Hans-Kristian Arntzen
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include "thread.h"
#include <stdlib.h>
#if defined(_WIN32) && !defined(_XBOX)
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#elif defined(_XBOX)
#include <xtl.h>
#elif defined(GEKKO)
#include "thread/gx_pthread.h"
#else
#include <pthread.h>
#include <time.h>
#endif
#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>
#endif
struct thread_data
{
void (*func)(void*);
void *userdata;
};
#ifdef _WIN32
struct sthread
{
HANDLE thread;
};
static DWORD CALLBACK thread_wrap(void *data_)
{
struct thread_data *data = (struct thread_data*)data_;
data->func(data->userdata);
free(data);
return 0;
}
sthread_t *sthread_create(void (*thread_func)(void*), void *userdata)
{
sthread_t *thread = (sthread_t*)calloc(1, sizeof(*thread));
if (!thread)
return NULL;
struct thread_data *data = (struct thread_data*)calloc(1, sizeof(*data));
if (!data)
{
free(thread);
return NULL;
}
data->func = thread_func;
data->userdata = userdata;
thread->thread = CreateThread(NULL, 0, thread_wrap, data, 0, NULL);
if (!thread->thread)
{
free(data);
free(thread);
return NULL;
}
return thread;
}
void sthread_join(sthread_t *thread)
{
WaitForSingleObject(thread->thread, INFINITE);
CloseHandle(thread->thread);
free(thread);
}
struct slock
{
CRITICAL_SECTION lock;
};
slock_t *slock_new(void)
{
slock_t *lock = (slock_t*)calloc(1, sizeof(*lock));
if (!lock)
return NULL;
InitializeCriticalSection(&lock->lock);
return lock;
}
void slock_free(slock_t *lock)
{
DeleteCriticalSection(&lock->lock);
free(lock);
}
void slock_lock(slock_t *lock)
{
EnterCriticalSection(&lock->lock);
}
void slock_unlock(slock_t *lock)
{
LeaveCriticalSection(&lock->lock);
}
struct scond
{
HANDLE event;
};
scond_t *scond_new(void)
{
scond_t *cond = (scond_t*)calloc(1, sizeof(*cond));
if (!cond)
return NULL;
cond->event = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!cond->event)
{
free(cond);
return NULL;
}
return cond;
}
void scond_wait(scond_t *cond, slock_t *lock)
{
WaitForSingleObject(cond->event, 0);
slock_unlock(lock);
WaitForSingleObject(cond->event, INFINITE);
slock_lock(lock);
}
int scond_wait_timeout(scond_t *cond, slock_t *lock, unsigned timeout_ms)
{
WaitForSingleObject(cond->event, 0);
slock_unlock(lock);
DWORD res = WaitForSingleObject(cond->event, timeout_ms);
slock_lock(lock);
return res == WAIT_OBJECT_0;
}
void scond_signal(scond_t *cond)
{
SetEvent(cond->event);
}
void scond_free(scond_t *cond)
{
CloseHandle(cond->event);
free(cond);
}
#else
struct sthread
{
pthread_t id;
};
static void *thread_wrap(void *data_)
{
struct thread_data *data = (struct thread_data*)data_;
data->func(data->userdata);
free(data);
return NULL;
}
sthread_t *sthread_create(void (*thread_func)(void*), void *userdata)
{
sthread_t *thr = (sthread_t*)calloc(1, sizeof(*thr));
if (!thr)
return NULL;
struct thread_data *data = (struct thread_data*)calloc(1, sizeof(*data));
if (!data)
{
free(thr);
return NULL;
}
data->func = thread_func;
data->userdata = userdata;
if (pthread_create(&thr->id, NULL, thread_wrap, data) < 0)
{
free(data);
free(thr);
return NULL;
}
return thr;
}
void sthread_join(sthread_t *thread)
{
pthread_join(thread->id, NULL);
free(thread);
}
struct slock
{
pthread_mutex_t lock;
};
slock_t *slock_new(void)
{
slock_t *lock = (slock_t*)calloc(1, sizeof(*lock));
if (!lock)
return NULL;
if (pthread_mutex_init(&lock->lock, NULL) < 0)
{
free(lock);
return NULL;
}
return lock;
}
void slock_free(slock_t *lock)
{
pthread_mutex_destroy(&lock->lock);
free(lock);
}
void slock_lock(slock_t *lock)
{
pthread_mutex_lock(&lock->lock);
}
void slock_unlock(slock_t *lock)
{
pthread_mutex_unlock(&lock->lock);
}
struct scond
{
pthread_cond_t cond;
};
scond_t *scond_new(void)
{
scond_t *cond = (scond_t*)calloc(1, sizeof(*cond));
if (!cond)
return NULL;
if (pthread_cond_init(&cond->cond, NULL) < 0)
{
free(cond);
return NULL;
}
return cond;
}
void scond_free(scond_t *cond)
{
pthread_cond_destroy(&cond->cond);
free(cond);
}
void scond_wait(scond_t *cond, slock_t *lock)
{
pthread_cond_wait(&cond->cond, &lock->lock);
}
void scond_signal(scond_t *cond)
{
pthread_cond_signal(&cond->cond);
}
#endif