X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=frontend%2F3ds%2Fpthread.h;h=76f1681c9a1c98489f6b75f3fcf91b2ee6d4200c;hb=2fb8465594a7ffb7ccbac39fdedf7c70085d7f63;hp=2c2bf6b1a3310a096951790eb9d45c0a84b4dc93;hpb=ce4cd3d539bbd593d543f2ead52e44fbf552dbc5;p=pcsx_rearmed.git diff --git a/frontend/3ds/pthread.h b/frontend/3ds/pthread.h index 2c2bf6b1..76f1681c 100644 --- a/frontend/3ds/pthread.h +++ b/frontend/3ds/pthread.h @@ -1,56 +1,321 @@ +/* Copyright (C) 2010-2020 The RetroArch team + * + * --------------------------------------------------------------------------------------- + * The following license statement only applies to this file (gx_pthread.h). + * --------------------------------------------------------------------------------------- + * + * Permission is hereby granted, free of charge, + * to any person obtaining a copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ -#ifndef _3DS_PTHREAD_WRAP__ -#define _3DS_PTHREAD_WRAP__ - -#include -#include -#include +#ifndef _CTR_PTHREAD_WRAP_CTR_ +#define _CTR_PTHREAD_WRAP_CTR_ #include "3ds_utils.h" -#define CTR_PTHREAD_STACK_SIZE 0x10000 +#include +#include + +#define STACKSIZE (4 * 1024) +#define FALSE 0 + +#ifndef PTHREAD_SCOPE_PROCESS +/* An earlier version of devkitARM does not define the pthread types. Can remove in r54+. */ + +typedef Thread pthread_t; +typedef LightLock pthread_mutex_t; +typedef void* pthread_mutexattr_t; +typedef int pthread_attr_t; +typedef LightEvent pthread_cond_t; +typedef int pthread_condattr_t; +#endif + +#ifndef USE_CTRULIB_2 +/* Backported CondVar API from libctru 2.0, and under its license: + https://github.com/devkitPro/libctru + Slightly modified for compatibility with older libctru. */ + +typedef s32 CondVar; + +static inline Result syncArbitrateAddress(s32* addr, ArbitrationType type, s32 value) +{ + return svcArbitrateAddress(__sync_get_arbiter(), (u32)addr, type, value, 0); +} + +static inline Result syncArbitrateAddressWithTimeout(s32* addr, ArbitrationType type, s32 value, s64 timeout_ns) +{ + return svcArbitrateAddress(__sync_get_arbiter(), (u32)addr, type, value, timeout_ns); +} + +static inline void __dmb(void) +{ + __asm__ __volatile__("mcr p15, 0, %[val], c7, c10, 5" :: [val] "r" (0) : "memory"); +} + +static inline void CondVar_BeginWait(CondVar* cv, LightLock* lock) +{ + s32 val; + do + val = __ldrex(cv) - 1; + while (__strex(cv, val)); + LightLock_Unlock(lock); +} + +static inline bool CondVar_EndWait(CondVar* cv, s32 num_threads) +{ + bool hasWaiters; + s32 val; + + do { + val = __ldrex(cv); + hasWaiters = val < 0; + if (hasWaiters) + { + if (num_threads < 0) + val = 0; + else if (val <= -num_threads) + val += num_threads; + else + val = 0; + } + } while (__strex(cv, val)); + + return hasWaiters; +} + +static inline void CondVar_Init(CondVar* cv) +{ + *cv = 0; +} + +static inline void CondVar_Wait(CondVar* cv, LightLock* lock) +{ + CondVar_BeginWait(cv, lock); + syncArbitrateAddress(cv, ARBITRATION_WAIT_IF_LESS_THAN, 0); + LightLock_Lock(lock); +} + +static inline int CondVar_WaitTimeout(CondVar* cv, LightLock* lock, s64 timeout_ns) +{ + CondVar_BeginWait(cv, lock); + + bool timedOut = false; + Result rc = syncArbitrateAddressWithTimeout(cv, ARBITRATION_WAIT_IF_LESS_THAN_TIMEOUT, 0, timeout_ns); + if (R_DESCRIPTION(rc) == RD_TIMEOUT) + { + timedOut = CondVar_EndWait(cv, 1); + __dmb(); + } + + LightLock_Lock(lock); + return timedOut; +} -typedef struct +static inline void CondVar_WakeUp(CondVar* cv, s32 num_threads) { - int32_t handle; - uint32_t* stack; -}pthread_t; -typedef int pthread_attr_t; + __dmb(); + if (CondVar_EndWait(cv, num_threads)) + syncArbitrateAddress(cv, ARBITRATION_SIGNAL, num_threads); + else + __dmb(); +} + +static inline void CondVar_Signal(CondVar* cv) +{ + CondVar_WakeUp(cv, 1); +} + +static inline void CondVar_Broadcast(CondVar* cv) +{ + CondVar_WakeUp(cv, ARBITRATION_SIGNAL_ALL); +} +/* End libctru 2.0 backport */ +#endif + +/* libctru threads return void but pthreads return void pointer */ +static bool mutex_inited = false; +static LightLock safe_double_thread_launch; +static void *(*start_routine_jump)(void*); + +static void ctr_thread_launcher(void* data) +{ + void *(*start_routine_jump_safe)(void*) = start_routine_jump; + LightLock_Unlock(&safe_double_thread_launch); + start_routine_jump_safe(data); +} static inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg) { + s32 prio = 0; + Thread new_ctr_thread; + int procnum = -2; // use default cpu + bool isNew3DS; + + APT_CheckNew3DS(&isNew3DS); + + if (isNew3DS) + procnum = 2; + + if (!mutex_inited) + { + LightLock_Init(&safe_double_thread_launch); + mutex_inited = true; + } - thread->stack = linearMemAlign(CTR_PTHREAD_STACK_SIZE, 8); + /*Must wait if attempting to launch 2 threads at once to prevent corruption of function pointer*/ + while (LightLock_TryLock(&safe_double_thread_launch) != 0); - svcCreateThread(&thread->handle, start_routine, arg, - (uint32_t*)((uint32_t)thread->stack + CTR_PTHREAD_STACK_SIZE), - 0x25, 1); + svcGetThreadPriority(&prio, CUR_THREAD_HANDLE); - return 1; + start_routine_jump = start_routine; + new_ctr_thread = threadCreate(ctr_thread_launcher, arg, STACKSIZE, prio - 1, procnum, FALSE); + + if (!new_ctr_thread) + { + LightLock_Unlock(&safe_double_thread_launch); + return EAGAIN; + } + + *thread = (pthread_t)new_ctr_thread; + return 0; } +static inline pthread_t pthread_self(void) +{ + return (pthread_t)threadGetCurrent(); +} -static inline int pthread_join(pthread_t thread, void **retval) +static inline int pthread_mutex_init(pthread_mutex_t *mutex, + const pthread_mutexattr_t *attr) { + LightLock_Init((LightLock *)mutex); + return 0; +} + +static inline int pthread_mutex_destroy(pthread_mutex_t *mutex) +{ + /*Nothing to destroy*/ + return 0; +} + +static inline int pthread_mutex_lock(pthread_mutex_t *mutex) +{ + LightLock_Lock((LightLock *)mutex); + return 0; +} + +static inline int pthread_mutex_unlock(pthread_mutex_t *mutex) +{ + LightLock_Unlock((LightLock *)mutex); + return 0; +} + +static inline void pthread_exit(void *retval) +{ + /*Yes the pointer to int cast is not ideal*/ + /*threadExit((int)retval);*/ (void)retval; - if(svcWaitSynchronization(thread.handle, INT64_MAX)) + threadExit(0); +} + +static inline int pthread_detach(pthread_t thread) +{ + threadDetach((Thread)thread); + return 0; +} + +static inline int pthread_join(pthread_t thread, void **retval) +{ + /*retval is ignored*/ + if(threadJoin((Thread)thread, INT64_MAX)) return -1; - linearFree(thread.stack); + threadFree((Thread)thread); return 0; } +static inline int pthread_mutex_trylock(pthread_mutex_t *mutex) +{ + return LightLock_TryLock((LightLock *)mutex); +} -static inline void pthread_exit(void *retval) -{ - (void)retval; +static inline int pthread_cond_wait(pthread_cond_t *cond, + pthread_mutex_t *mutex) +{ + CondVar_Wait((CondVar *)cond, (LightLock *)mutex); + return 0; +} + +static inline int pthread_cond_timedwait(pthread_cond_t *cond, + pthread_mutex_t *mutex, const struct timespec *abstime) +{ + struct timespec now = {0}; + /* Missing clock_gettime*/ + struct timeval tm; + int retval = 0; + + gettimeofday(&tm, NULL); + now.tv_sec = tm.tv_sec; + now.tv_nsec = tm.tv_usec * 1000; + s64 timeout = (abstime->tv_sec - now.tv_sec) * 1000000000 + (abstime->tv_nsec - now.tv_nsec); + + if (timeout < 0) + { + retval = ETIMEDOUT; + } + else if (CondVar_WaitTimeout((CondVar *)cond, (LightLock *)mutex, timeout)) + { + retval = ETIMEDOUT; + } + + return retval; +} + +static inline int pthread_cond_init(pthread_cond_t *cond, + const pthread_condattr_t *attr) +{ + CondVar_Init((CondVar *)cond); + return 0; +} - svcExitThread(); +static inline int pthread_cond_signal(pthread_cond_t *cond) +{ + CondVar_Signal((CondVar *)cond); + return 0; } +static inline int pthread_cond_broadcast(pthread_cond_t *cond) +{ + CondVar_Broadcast((CondVar *)cond); + return 0; +} -#endif //_3DS_PTHREAD_WRAP__ +static inline int pthread_cond_destroy(pthread_cond_t *cond) +{ + /*Nothing to destroy*/ + return 0; +} + +static inline int pthread_equal(pthread_t t1, pthread_t t2) +{ + if (threadGetHandle((Thread)t1) == threadGetHandle((Thread)t2)) + return 1; + return 0; +} +#endif