#include <objc/thr.h>
#include "runtime.h"
#include <pthread.h>
static pthread_key_t _objc_thread_storage;
static pthread_attr_t _objc_thread_attribs;
int
__objc_init_thread_system(void)
{
if (pthread_key_create(&_objc_thread_storage, NULL) == 0)
{
if (pthread_attr_init(&_objc_thread_attribs) == 0)
{
if (pthread_attr_setdetachstate(&_objc_thread_attribs,
PTHREAD_CREATE_DETACHED) == 0)
return 0;
}
}
return -1;
}
int
__objc_close_thread_system(void)
{
if (pthread_key_delete(_objc_thread_storage) == 0)
{
if (pthread_attr_destroy(&_objc_thread_attribs) == 0)
return 0;
}
return -1;
}
objc_thread_t
__objc_thread_detach(void (*func)(void *arg), void *arg)
{
objc_thread_t thread_id;
pthread_t new_thread_handle;
if (!(pthread_create(&new_thread_handle, &_objc_thread_attribs,
(void *)func, arg)))
thread_id = *(objc_thread_t *)&new_thread_handle;
else
thread_id = NULL;
return thread_id;
}
int
__objc_thread_set_priority(int priority)
{
pthread_t thread_id = pthread_self();
int policy;
struct sched_param params;
int priority_min, priority_max;
if (pthread_getschedparam(thread_id, &policy, ¶ms) == 0)
{
if ((priority_max = sched_get_priority_max(policy)) != 0)
return -1;
if ((priority_min = sched_get_priority_min(policy)) != 0)
return -1;
if (priority > priority_max)
priority = priority_max;
else if (priority < priority_min)
priority = priority_min;
params.sched_priority = priority;
if (pthread_setschedparam(thread_id, policy, ¶ms) == 0)
return 0;
}
return -1;
}
int
__objc_thread_get_priority(void)
{
int policy;
struct sched_param params;
if (pthread_getschedparam(pthread_self(), &policy, ¶ms) == 0)
return params.sched_priority;
else
return -1;
}
void
__objc_thread_yield(void)
{
sched_yield();
}
int
__objc_thread_exit(void)
{
pthread_exit(&__objc_thread_exit_status);
return -1;
}
objc_thread_t
__objc_thread_id(void)
{
pthread_t self = pthread_self();
return *(objc_thread_t *)&self;
}
int
__objc_thread_set_data(void *value)
{
if (pthread_setspecific(_objc_thread_storage, value) == 0)
return 0;
else
return -1;
}
void *
__objc_thread_get_data(void)
{
return pthread_getspecific(_objc_thread_storage);
}
int
__objc_mutex_allocate(objc_mutex_t mutex)
{
mutex->backend = objc_malloc(sizeof(pthread_mutex_t));
if (pthread_mutex_init((pthread_mutex_t *)mutex->backend, NULL))
{
objc_free(mutex->backend);
mutex->backend = NULL;
return -1;
}
return 0;
}
int
__objc_mutex_deallocate(objc_mutex_t mutex)
{
int count = 1;
while (count)
{
if ((count = pthread_mutex_unlock((pthread_mutex_t*)mutex->backend)) < 0)
return -1;
}
if (pthread_mutex_destroy((pthread_mutex_t *)mutex->backend))
return -1;
objc_free(mutex->backend);
mutex->backend = NULL;
return 0;
}
int
__objc_mutex_lock(objc_mutex_t mutex)
{
if (pthread_mutex_lock((pthread_mutex_t *)mutex->backend) == 0)
return 0;
else
return -1;
}
int
__objc_mutex_trylock(objc_mutex_t mutex)
{
if (pthread_mutex_trylock((pthread_mutex_t *)mutex->backend) == 0)
return 0;
else
return -1;
}
int
__objc_mutex_unlock(objc_mutex_t mutex)
{
if (pthread_mutex_unlock((pthread_mutex_t *)mutex->backend) == 0)
return 0;
else
return -1;
}
int
__objc_condition_allocate(objc_condition_t condition)
{
condition->backend = objc_malloc(sizeof(pthread_cond_t));
if (pthread_cond_init((pthread_cond_t *)condition->backend, NULL))
{
objc_free(condition->backend);
condition->backend = NULL;
return -1;
}
return 0;
}
int
__objc_condition_deallocate(objc_condition_t condition)
{
if (pthread_cond_destroy((pthread_cond_t *)condition->backend))
return -1;
objc_free(condition->backend);
condition->backend = NULL;
return 0;
}
int
__objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex)
{
if (pthread_cond_wait((pthread_cond_t *)condition->backend,
(pthread_mutex_t *)mutex->backend) == 0)
return 0;
else
return -1;
}
int
__objc_condition_broadcast(objc_condition_t condition)
{
if (pthread_cond_broadcast((pthread_cond_t *)condition->backend) == 0)
return 0;
else
return -1;
}
int
__objc_condition_signal(objc_condition_t condition)
{
if (pthread_cond_signal((pthread_cond_t *)condition->backend) == 0)
return 0;
else
return -1;
}