mirror of https://github.com/mgba-emu/mgba.git
147 lines
3.2 KiB
C
147 lines
3.2 KiB
C
/* Copyright (c) 2013-2015 Jeffrey Pfau
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
#ifndef SCE_THREADING_H
|
|
#define SCE_THREADING_H
|
|
|
|
#include <psp2/kernel/threadmgr.h>
|
|
|
|
typedef SceUID Thread;
|
|
typedef SceUID Mutex;
|
|
typedef struct {
|
|
Mutex mutex;
|
|
SceUID semaphore;
|
|
int waiting;
|
|
} Condition;
|
|
#define THREAD_ENTRY int
|
|
typedef THREAD_ENTRY (*ThreadEntry)(void*);
|
|
|
|
static inline int MutexInit(Mutex* mutex) {
|
|
Mutex id = sceKernelCreateMutex("mutex", 0, 0, 0);
|
|
if (id < 0) {
|
|
return id;
|
|
}
|
|
*mutex = id;
|
|
return 0;
|
|
}
|
|
|
|
static inline int MutexDeinit(Mutex* mutex) {
|
|
return sceKernelDeleteMutex(*mutex);
|
|
}
|
|
|
|
static inline int MutexLock(Mutex* mutex) {
|
|
return sceKernelLockMutex(*mutex, 1, 0);
|
|
}
|
|
|
|
static inline int MutexTryLock(Mutex* mutex) {
|
|
return sceKernelTryLockMutex(*mutex, 1);
|
|
}
|
|
|
|
static inline int MutexUnlock(Mutex* mutex) {
|
|
return sceKernelUnlockMutex(*mutex, 1);
|
|
}
|
|
|
|
static inline int ConditionInit(Condition* cond) {
|
|
int res = MutexInit(&cond->mutex);
|
|
if (res < 0) {
|
|
return res;
|
|
}
|
|
cond->semaphore = sceKernelCreateSema("SceCondSema", 0, 0, 1, 0);
|
|
if (cond->semaphore < 0) {
|
|
MutexDeinit(&cond->mutex);
|
|
res = cond->semaphore;
|
|
}
|
|
cond->waiting = 0;
|
|
return res;
|
|
}
|
|
|
|
static inline int ConditionDeinit(Condition* cond) {
|
|
MutexDeinit(&cond->mutex);
|
|
return sceKernelDeleteSema(cond->semaphore);
|
|
}
|
|
|
|
static inline int ConditionWait(Condition* cond, Mutex* mutex) {
|
|
int ret = MutexLock(&cond->mutex);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
++cond->waiting;
|
|
MutexUnlock(mutex);
|
|
MutexUnlock(&cond->mutex);
|
|
ret = sceKernelWaitSema(cond->semaphore, 1, 0);
|
|
if (ret < 0) {
|
|
printf("Premature wakeup: %08X", ret);
|
|
}
|
|
MutexLock(mutex);
|
|
return ret;
|
|
}
|
|
|
|
static inline int ConditionWaitTimed(Condition* cond, Mutex* mutex, int32_t timeoutMs) {
|
|
int ret = MutexLock(&cond->mutex);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
++cond->waiting;
|
|
MutexUnlock(mutex);
|
|
MutexUnlock(&cond->mutex);
|
|
SceUInt timeout = 0;
|
|
if (timeoutMs > 0) {
|
|
timeout = timeoutMs;
|
|
}
|
|
ret = sceKernelWaitSema(cond->semaphore, 1, &timeout);
|
|
if (ret < 0) {
|
|
printf("Premature wakeup: %08X", ret);
|
|
}
|
|
MutexLock(mutex);
|
|
return ret;
|
|
}
|
|
|
|
static inline int ConditionWake(Condition* cond) {
|
|
MutexLock(&cond->mutex);
|
|
if (cond->waiting) {
|
|
--cond->waiting;
|
|
sceKernelSignalSema(cond->semaphore, 1);
|
|
}
|
|
MutexUnlock(&cond->mutex);
|
|
return 0;
|
|
}
|
|
|
|
struct SceThreadEntryArgs {
|
|
void* context;
|
|
ThreadEntry entry;
|
|
};
|
|
|
|
static inline int _sceThreadEntry(SceSize args, void* argp) {
|
|
UNUSED(args);
|
|
struct SceThreadEntryArgs* arg = argp;
|
|
return arg->entry(arg->context);
|
|
}
|
|
|
|
static inline int ThreadCreate(Thread* thread, ThreadEntry entry, void* context) {
|
|
Thread id = sceKernelCreateThread("SceThread", _sceThreadEntry, 0x10000100, 0x10000, 0, 0, 0);
|
|
if (id < 0) {
|
|
*thread = 0;
|
|
return id;
|
|
}
|
|
*thread = id;
|
|
struct SceThreadEntryArgs args = { context, entry };
|
|
sceKernelStartThread(id, sizeof(args), &args);
|
|
return 0;
|
|
}
|
|
|
|
static inline int ThreadJoin(Thread thread) {
|
|
int res = sceKernelWaitThreadEnd(thread, 0, 0);
|
|
if (res < 0) {
|
|
return res;
|
|
}
|
|
return sceKernelDeleteThread(thread);
|
|
}
|
|
|
|
static inline int ThreadSetName(const char* name) {
|
|
UNUSED(name);
|
|
return -1;
|
|
}
|
|
#endif
|