hmn
/
orca
5
Fork 2
Code Issues 21 Pull Requests 1 Packages Projects Releases Wiki Activity

platform thread naming pass

This commit is contained in:
Reuben Dunnington 2023-07-30 19:18:00 -07:00
parent 442d86386e
commit baab4036c4
Signed by: rdunnington
GPG Key ID: 4EC5290E704FD482
2 changed files with 69 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
src/platform/platform_thread.h
View File

@ -25,61 +25,65 @@ extern "C" {
// Platform Thread API
//---------------------------------------------------------------
typedef struct platform_thread platform_thread;
enum
{
MP_THREAD_NAME_MAX_SIZE = 64, // including null terminator
};
typedef void* (*ThreadStartFunction)(void* userPointer);
typedef struct mp_thread mp_thread;
platform_thread* ThreadCreate(ThreadStartFunction start, void* userPointer);
platform_thread* ThreadCreateWithName(ThreadStartFunction start, void* userPointer, const char* name);
typedef void* (*mp_thread_start_function)(void* userPointer);
const char* ThreadGetName(platform_thread* thread);
mp_thread* mp_thread_create(mp_thread_start_function start, void* userPointer);
mp_thread* mp_thread_create_with_name(mp_thread_start_function start, void* userPointer, const char* name);
u64 ThreadSelfID();
u64 ThreadUniqueID(platform_thread* thread);
const char* mp_thread_get_name(mp_thread* thread);
int ThreadSignal(platform_thread* thread, int sig);
void ThreadCancel(platform_thread* thread);
int ThreadJoin(platform_thread* thread, void** ret);
int ThreadDetach(platform_thread* thread);
u64 mp_thread_unique_id(mp_thread* thread);
u64 mp_thread_self_id();
int mp_thread_signal(mp_thread* thread, int sig);
int mp_thread_join(mp_thread* thread, void** ret);
int mp_thread_detach(mp_thread* thread);
//---------------------------------------------------------------
// Platform Mutex API
//---------------------------------------------------------------
typedef struct platform_mutex platform_mutex;
typedef struct mp_mutex mp_mutex;
platform_mutex* MutexCreate();
int MutexDestroy(platform_mutex* mutex);
int MutexLock(platform_mutex* mutex);
int MutexUnlock(platform_mutex* mutex);
mp_mutex* mp_mutex_create();
int mp_mutex_destroy(mp_mutex* mutex);
int mp_mutex_lock(mp_mutex* mutex);
int mp_mutex_unlock(mp_mutex* mutex);
//---------------------------------------------------------------
// Lightweight ticket mutex API
//---------------------------------------------------------------
typedef struct ticket_spin_mutex
typedef struct mp_ticket_spin_mutex
{
volatile _Atomic(u64) nextTicket;
volatile _Atomic(u64) serving;
} ticket_spin_mutex;
} mp_ticket_spin_mutex;
void TicketSpinMutexInit(ticket_spin_mutex* mutex);
void TicketSpinMutexLock(ticket_spin_mutex* mutex);
void TicketSpinMutexUnlock(ticket_spin_mutex* mutex);
void mp_ticket_spin_mutex_init(mp_ticket_spin_mutex* mutex);
void mp_ticket_spin_mutex_lock(mp_ticket_spin_mutex* mutex);
void mp_ticket_spin_mutex_unlock(mp_ticket_spin_mutex* mutex);
//---------------------------------------------------------------
// Platform condition variable API
//---------------------------------------------------------------
typedef struct platform_condition platform_condition;
typedef struct mp_condition mp_condition;
platform_condition* ConditionCreate();
int ConditionDestroy(platform_condition* cond);
int ConditionWait(platform_condition* cond, platform_mutex* mutex);
int ConditionTimedWait(platform_condition* cond, platform_mutex* mutex, f64 seconds);
int ConditionSignal(platform_condition* cond);
int ConditionBroadcast(platform_condition* cond);
mp_condition* mp_condition_create();
int mp_condition_destroy(mp_condition* cond);
int mp_condition_wait(mp_condition* cond, mp_mutex* mutex);
int mp_condition_timedwait(mp_condition* cond, mp_mutex* mutex, f64 seconds);
int mp_condition_signal(mp_condition* cond);
int mp_condition_broadcast(mp_condition* cond);
#ifdef __cplusplus
} // extern "C"

78
src/platform/posix_thread.c
View File

@ -14,20 +14,18 @@
#include"platform_thread.h"
const u32 PLATFORM_THREAD_NAME_MAX_SIZE = 64; // including null terminator
struct platform_thread
struct mp_thread
{
bool valid;
pthread_t pthread;
ThreadStartFunction start;
mp_thread_start_function start;
void* userPointer;
char name[PLATFORM_THREAD_NAME_MAX_SIZE];
char name[MP_THREAD_NAME_MAX_SIZE];
};
void* platform_thread_bootstrap(void* data)
void* mp_thread_bootstrap(void* data)
{
platform_thread* thread = (platform_thread*)data;
mp_thread* thread = (mp_thread*)data;
if(strlen(thread->name))
{
pthread_setname_np(thread->name);
@ -35,9 +33,9 @@ void* platform_thread_bootstrap(void* data)
return(thread->start(thread->userPointer));
}
platform_thread* ThreadCreateWithName(ThreadStartFunction start, void* userPointer, const char* name)
mp_thread* mp_thread_create_with_name(mp_thread_start_function start, void* userPointer, const char* name)
{
platform_thread* thread = (platform_thread*)malloc(sizeof(platform_thread));
mp_thread* thread = (mp_thread*)malloc(sizeof(mp_thread));
if(!thread)
{
return(0);
@ -45,7 +43,7 @@ platform_thread* ThreadCreateWithName(ThreadStartFunction start, void* userPoint
if(name)
{
char* end = stpncpy(thread->name, name, PLATFORM_THREAD_NAME_MAX_SIZE-1);
char* end = stpncpy(thread->name, name, MP_THREAD_NAME_MAX_SIZE-1);
*end = '\0';
}
else
@ -67,30 +65,24 @@ platform_thread* ThreadCreateWithName(ThreadStartFunction start, void* userPoint
}
}
platform_thread* ThreadCreate(ThreadStartFunction start, void* userPointer)
mp_thread* mp_thread_create(mp_thread_start_function start, void* userPointer)
{
return(ThreadCreateWithName(start, userPointer, 0));
return(mp_thread_create_with_name(start, userPointer, 0));
}
void ThreadCancel(platform_thread* thread)
{
pthread_cancel(thread->pthread);
}
const char* ThreadGetName(platform_thread* thread)
const char* mp_thread_get_name(mp_thread* thread)
{
return(thread->name);
}
u64 ThreadUniqueID(platform_thread* thread)
u64 mp_thread_unique_id(mp_thread* thread)
{
u64 id;
pthread_threadid_np(thread->pthread, &id);
return(id);
}
u64 ThreadSelfID()
u64 mp_thread_self_id()
{
pthread_t thread = pthread_self();
u64 id;
@ -98,12 +90,12 @@ u64 ThreadSelfID()
return(id);
}
int ThreadSignal(platform_thread* thread, int sig)
int mp_thread_signal(mp_thread* thread, int sig)
{
return(pthread_kill(thread->pthread, sig));
}
int ThreadJoin(platform_thread* thread, void** ret)
int mp_thread_join(mp_thread* thread, void** ret)
{
if(pthread_join(thread->pthread, ret))
{
@ -113,7 +105,7 @@ int ThreadJoin(platform_thread* thread, void** ret)
return(0);
}
int ThreadDetach(platform_thread* thread)
int mp_thread_detach(mp_thread* thread)
{
if(pthread_detach(thread->pthread))
{
@ -124,14 +116,14 @@ int ThreadDetach(platform_thread* thread)
}
struct platform_mutex
struct mp_mutex
{
pthread_mutex_t pmutex;
};
platform_mutex* MutexCreate()
mp_mutex* mp_mutex_create()
{
platform_mutex* mutex = (platform_mutex*)malloc(sizeof(platform_mutex));
mp_mutex* mutex = (mp_mutex*)malloc(sizeof(mp_mutex));
if(!mutex)
{
return(0);
@ -143,7 +135,8 @@ platform_mutex* MutexCreate()
}
return(mutex);
}
int MutexDestroy(platform_mutex* mutex)
int mp_mutex_destroy(mp_mutex* mutex)
{
if(pthread_mutex_destroy(&mutex->pmutex) != 0)
{
@ -153,41 +146,42 @@ int MutexDestroy(platform_mutex* mutex)
return(0);
}
int MutexLock(platform_mutex* mutex)
int mp_mutex_lock(mp_mutex* mutex)
{
return(pthread_mutex_lock(&mutex->pmutex));
}
int MutexUnlock(platform_mutex* mutex)
int mp_mutex_unlock(mp_mutex* mutex)
{
return(pthread_mutex_unlock(&mutex->pmutex));
}
void TicketSpinMutexInit(ticket_spin_mutex* mutex)
void mp_ticket_spin_mutex_init(mp_ticket_spin_mutex* mutex)
{
mutex->nextTicket = 0;
mutex->serving = 0;
}
void TicketSpinMutexLock(ticket_spin_mutex* mutex)
void mp_ticket_spin_mutex_lock(mp_ticket_spin_mutex* mutex)
{
u64 ticket = atomic_fetch_add(&mutex->nextTicket, 1ULL);
while(ticket != mutex->serving); //spin
}
void TicketSpinMutexUnlock(ticket_spin_mutex* mutex)
void mp_ticket_spin_mutex_unlock(mp_ticket_spin_mutex* mutex)
{
atomic_fetch_add(&mutex->serving, 1ULL);
}
struct platform_condition
struct mp_condition
{
pthread_cond_t pcond;
};
platform_condition* ConditionCreate()
mp_condition* mp_condition_create()
{
platform_condition* cond = (platform_condition*)malloc(sizeof(platform_condition));
mp_condition* cond = (mp_condition*)malloc(sizeof(mp_condition));
if(!cond)
{
return(0);
@ -199,7 +193,8 @@ platform_condition* ConditionCreate()
}
return(cond);
}
int ConditionDestroy(platform_condition* cond)
int mp_condition_destroy(mp_condition* cond)
{
if(pthread_cond_destroy(&cond->pcond) != 0)
{
@ -208,12 +203,13 @@ int ConditionDestroy(platform_condition* cond)
free(cond);
return(0);
}
int ConditionWait(platform_condition* cond, platform_mutex* mutex)
int mp_condition_wait(mp_condition* cond, mp_mutex* mutex)
{
return(pthread_cond_wait(&cond->pcond, &mutex->pmutex));
}
int ConditionTimedWait(platform_condition* cond, platform_mutex* mutex, f64 seconds)
int mp_condition_timedwait(mp_condition* cond, mp_mutex* mutex, f64 seconds)
{
struct timeval tv;
gettimeofday(&tv, 0);
@ -230,12 +226,12 @@ int ConditionTimedWait(platform_condition* cond, platform_mutex* mutex, f64 seco
return(pthread_cond_timedwait(&cond->pcond, &mutex->pmutex, &ts));
}
int ConditionSignal(platform_condition* cond)
int mp_condition_signal(mp_condition* cond)
{
return(pthread_cond_signal(&cond->pcond));
}
int ConditionBroadcast(platform_condition* cond)
int mp_condition_broadcast(mp_condition* cond)
{
return(pthread_cond_broadcast(&cond->pcond));
}