aboutsummaryrefslogtreecommitdiff
path: root/gcc/objc/thr-mach.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/objc/thr-mach.c')
-rw-r--r--gcc/objc/thr-mach.c492
1 files changed, 170 insertions, 322 deletions
diff --git a/gcc/objc/thr-mach.c b/gcc/objc/thr-mach.c
index 1f43fc5..6f54ada 100644
--- a/gcc/objc/thr-mach.c
+++ b/gcc/objc/thr-mach.c
@@ -31,434 +31,282 @@ Boston, MA 02111-1307, USA. */
#include <objc/thr.h>
#include "runtime.h"
-/********
- * This structure represents a single mutual exclusion lock. Lock semantics
- * are detailed with the subsequent functions. We use whatever lock is
- * provided by the system. We augment it with depth and current owner id
- * fields to implement and re-entrant lock.
- */
-struct objc_mutex
+/*
+ Obtain the maximum thread priority that can set for t. Under the
+ mach threading model, it is possible for the developer to adjust the
+ maximum priority downward only-- cannot be raised without superuser
+ priviledges. Once lowered, it cannot be raised.
+ */
+static int __mach_get_max_thread_priority(cthread_t t, int *base)
{
- volatile objc_thread_t owner; /* Id of thread that owns. */
- volatile int depth; /* # of acquires. */
- struct mutex lock; /* cthread mutex */
-};
-
-struct objc_condition
-{
- struct condition condition; /* cthread condition */
-};
-
-/********
- * obtain the maximum thread priority that can set for t. Under the
- * mach threading model, it is possible for the developer to adjust the
- * maximum priority downward only-- cannot be raised without superuser
- * priviledges. Once lowered, it cannot be raised.
- */
-static int __mach_get_max_thread_priority(cthread_t t, int *base) {
- thread_t threadP;
- kern_return_t error;
- struct thread_sched_info info;
- unsigned int info_count=THREAD_SCHED_INFO_COUNT;
+ thread_t threadP;
+ kern_return_t error;
+ struct thread_sched_info info;
+ unsigned int info_count=THREAD_SCHED_INFO_COUNT;
- if (t == NULL)
- return -1;
+ if (t == NULL)
+ return -1;
- threadP = cthread_thread(t); /* get thread underlying */
+ threadP = cthread_thread(t); /* get thread underlying */
- error=thread_info(threadP, THREAD_SCHED_INFO,
- (thread_info_t)&info, &info_count);
+ error=thread_info(threadP, THREAD_SCHED_INFO,
+ (thread_info_t)&info, &info_count);
- if (error != KERN_SUCCESS)
- return -1;
+ if (error != KERN_SUCCESS)
+ return -1;
- if (base != NULL)
- *base = info.base_priority;
+ if (base != NULL)
+ *base = info.base_priority;
- return info.max_priority;
+ return info.max_priority;
}
-/********
- * Initialize the threads subsystem. Returns 0 if successful, or -1 if no
- * thread support is available.
- */
+/* Backend initialization functions */
+
+/* Initialize the threads subsystem. */
int
__objc_init_thread_system(void)
{
- DEBUG_PRINTF("__objc_init_thread_system\n");
- return 0; /* Succeeded. */
+ return 0;
}
-
+/* Close the threads subsystem. */
int
-__objc_fini_thread_system(void)
+__objc_close_thread_system(void)
{
return 0;
}
-/********
- * Create a new thread of execution and return its id. Return NULL if fails.
- * The new thread starts in "func" with the given argument.
- */
+/* Backend thread functions */
+
+/* Create a new thread of execution. */
objc_thread_t
-objc_thread_create(void (*func)(void *arg), void *arg)
+__objc_thread_detach(void (*func)(void *arg), void *arg)
{
- objc_thread_t thread_id = NULL; /* Detached thread id. */
- cthread_t new_thread_handle; /* cthread handle. */
+ objc_thread_t thread_id;
+ cthread_t new_thread_handle;
- objc_mutex_lock(__objc_runtime_mutex);
-
- /* create thread */
- new_thread_handle = cthread_fork((cthread_fn_t)func, arg);
+ /* create thread */
+ new_thread_handle = cthread_fork((cthread_fn_t)func, arg);
- if(new_thread_handle) {
+ if(new_thread_handle)
+ {
/* this is not terribly portable */
- thread_id = *(objc_thread_t *)&new_thread_handle;
- cthread_detach(new_thread_handle); /* fully detach thread */
- __objc_runtime_threads_alive++; /* increment thread count */
+ thread_id = *(objc_thread_t *)&new_thread_handle;
+ cthread_detach(new_thread_handle);
}
-
- objc_mutex_unlock(__objc_runtime_mutex);
- return thread_id;
+ else
+ thread_id = NULL;
+
+ return thread_id;
}
-/********
- * Set the current thread's priority.
- */
+/* Set the current thread's priority. */
int
-objc_thread_set_priority(int priority)
+__objc_thread_set_priority(int priority)
{
- objc_thread_t *t = objc_thread_id();
- cthread_t cT = (cthread_t) t;
- int maxPriority = __mach_get_max_thread_priority(cT, NULL);
- int sys_priority = 0;
+ objc_thread_t *t = objc_thread_id();
+ cthread_t cT = (cthread_t) t;
+ int maxPriority = __mach_get_max_thread_priority(cT, NULL);
+ int sys_priority = 0;
- if (maxPriority == -1)
- return -1;
+ if (maxPriority == -1)
+ return -1;
- switch (priority) {
+ switch (priority)
+ {
case OBJC_THREAD_INTERACTIVE_PRIORITY:
- sys_priority = maxPriority;
- break;
+ sys_priority = maxPriority;
+ break;
case OBJC_THREAD_BACKGROUND_PRIORITY:
- sys_priority = (maxPriority * 2) / 3;
- break;
+ sys_priority = (maxPriority * 2) / 3;
+ break;
case OBJC_THREAD_LOW_PRIORITY:
- sys_priority = maxPriority / 3;
- break;
+ sys_priority = maxPriority / 3;
+ break;
default:
- return -1;
+ return -1;
}
- if (sys_priority == 0)
- return -1;
-
- if (cthread_priority(cT, sys_priority, 0) == KERN_SUCCESS)
- return 0; /* Changed priority. End. */
-
- return -1; /* Failed. */
+ if (sys_priority == 0)
+ return -1;
+
+ /* Change the priority */
+ if (cthread_priority(cT, sys_priority, 0) == KERN_SUCCESS)
+ return 0;
+ else
+ return -1;
}
-/********
- * Return the current thread's priority [well, whatever it is closest to].
- */
+/* Return the current thread's priority. */
int
-objc_thread_get_priority(void)
+__objc_thread_get_priority(void)
{
- objc_thread_t *t = objc_thread_id();
- cthread_t cT = (cthread_t) t; /* see objc_thread_id() */
- int basePriority;
- int maxPriority;
- int sys_priority = 0;
-
- int interactiveT, backgroundT, lowT; /* threasholds */
-
- maxPriority = __mach_get_max_thread_priority(cT, &basePriority);
-
- if(maxPriority == -1)
- return -1;
-
- if (basePriority > ( (maxPriority * 2) / 3))
- return OBJC_THREAD_INTERACTIVE_PRIORITY; /* interactive priority
- */
- if (basePriority > ( maxPriority / 3))
- return OBJC_THREAD_BACKGROUND_PRIORITY; /* background priority
- */
- return OBJC_THREAD_LOW_PRIORITY; /* everything else is low */
+ objc_thread_t *t = objc_thread_id();
+ cthread_t cT = (cthread_t) t; /* see objc_thread_id() */
+ int basePriority;
+ int maxPriority;
+ int sys_priority = 0;
+
+ int interactiveT, backgroundT, lowT; /* threasholds */
+
+ maxPriority = __mach_get_max_thread_priority(cT, &basePriority);
+
+ if(maxPriority == -1)
+ return -1;
+
+ if (basePriority > ( (maxPriority * 2) / 3))
+ return OBJC_THREAD_INTERACTIVE_PRIORITY;
+
+ if (basePriority > ( maxPriority / 3))
+ return OBJC_THREAD_BACKGROUND_PRIORITY;
+
+ return OBJC_THREAD_LOW_PRIORITY;
}
-/********
- * Yield our process time to another thread. Any BUSY waiting that is done
- * by a thread should use this function to make sure that other threads can
- * make progress even on a lazy uniprocessor system.
- */
+/* Yield our process time to another thread. */
void
-objc_thread_yield(void)
+__objc_thread_yield(void)
{
- cthread_yield(); /* Yield to equal thread. */
+ cthread_yield();
}
-/********
- * Terminate the current tread. Doesn't return anything. Doesn't return.
- * Actually, if it failed returns -1.
- */
+/* Terminate the current thread. */
int
-objc_thread_exit(void)
+__objc_thread_exit(void)
{
- objc_mutex_lock(__objc_runtime_mutex);
- __objc_runtime_threads_alive--;
- objc_mutex_unlock(__objc_runtime_mutex);
-
- cthread_exit(&__objc_thread_exit_status); /* Terminate thread. */
+ /* exit the thread */
+ cthread_exit(&__objc_thread_exit_status);
+
+ /* Failed if we reached here */
return -1;
}
-/********
- * Returns an integer value which uniquely describes a thread. Must not be
- * NULL which is reserved as a marker for "no thread".
- */
+/* Returns an integer value which uniquely describes a thread. */
objc_thread_t
-objc_thread_id(void)
+__objc_thread_id(void)
{
cthread_t self = cthread_self();
- return (objc_thread_t)self;
-}
-/********
- * Sets the thread's local storage pointer. Returns 0 if successful or -1
- * if failed.
- */
+ return *(objc_thread_t *)&self;
+}
+/* Sets the thread's local storage pointer. */
int
-objc_thread_set_data(void *value)
+__objc_thread_set_data(void *value)
{
cthread_set_data(cthread_self(), (any_t) value);
return 0;
}
-/********
- * Returns the thread's local storage pointer. Returns NULL on failure.
- */
+/* Returns the thread's local storage pointer. */
void *
-objc_thread_get_data(void)
+__objc_thread_get_data(void)
{
return (void *) cthread_data(cthread_self());
}
-/********
- * Allocate a mutex. Return the mutex pointer if successful or NULL if the
- * allocation failed for any reason.
- */
-objc_mutex_t
-objc_mutex_allocate(void)
+/* Backend mutex functions */
+
+/* Allocate a mutex. */
+int
+__objc_mutex_allocate(objc_mutex_t mutex)
{
- objc_mutex_t mutex;
- int err = 0;
-
- if (!(mutex = (objc_mutex_t)objc_malloc(sizeof(struct objc_mutex))))
- return NULL; /* Abort if malloc failed. */
+ int err = 0;
+ mutex->backend = objc_malloc(sizeof(struct mutex));
- err = mutex_init(&(mutex->lock));
-
- if (err != 0) { /* System init failed? */
- objc_free(mutex); /* Yes, free local memory. */
- return NULL; /* Abort. */
+ err = mutex_init((mutex_t)(mutex->backend));
+
+ if (err != 0)
+ {
+ objc_free(mutex->backend);
+ return -1;
}
- mutex->owner = (objc_thread_t) -1; /* No owner. */
- mutex->depth = 0; /* No locks. */
- return mutex; /* Return mutex handle. */
+ else
+ return 0;
}
-/********
- * Deallocate a mutex. Note that this includes an implicit mutex_lock to
- * insure that no one else is using the lock. It is legal to deallocate
- * a lock if we have a lock on it, but illegal to deallocate a lock held
- * by anyone else.
- * Returns the number of locks on the thread. (1 for deallocate).
- */
+/* Deallocate a mutex. */
int
-objc_mutex_deallocate(objc_mutex_t mutex)
+__objc_mutex_deallocate(objc_mutex_t mutex)
{
- int depth; /* # of locks on mutex. */
+ mutex_clear((mutex_t)(mutex->backend));
- if (!mutex) /* Is argument bad? */
- return -1; /* Yes, abort. */
- depth = objc_mutex_lock(mutex); /* Must have lock. */
-
- mutex_unlock(&(mutex->lock)); /* Must unlock system mutex.*/
- mutex_clear(&(mutex->lock)); /* Free system mutex. */
-
- objc_free(mutex); /* Free memory. */
- return depth; /* Return last depth. */
+ objc_free(mutex->backend);
+ mutex->backend = NULL;
+ return 0;
}
-/********
- * Grab a lock on a mutex. If this thread already has a lock on this mutex
- * then we increment the lock count. If another thread has a lock on the
- * mutex we block and wait for the thread to release the lock.
- * Returns the lock count on the mutex held by this thread.
- */
+/* Grab a lock on a mutex. */
int
-objc_mutex_lock(objc_mutex_t mutex)
+__objc_mutex_lock(objc_mutex_t mutex)
{
- objc_thread_t thread_id; /* Cache our thread id. */
-
- if (!mutex) /* Is argument bad? */
- return -1; /* Yes, abort. */
- thread_id = objc_thread_id(); /* Get this thread's id. */
- if (mutex->owner == thread_id) /* Already own lock? */
- return ++mutex->depth; /* Yes, increment depth. */
-
- mutex_lock(&(mutex->lock)); /* Lock cthread mutex. */
-
- mutex->owner = thread_id; /* Mark thread as owner. */
- return mutex->depth = 1; /* Increment depth to end. */
+ mutex_lock((mutex_t)(mutex->backend));
+ return 0;
}
-/********
- * Try to grab a lock on a mutex. If this thread already has a lock on
- * this mutex then we increment the lock count and return it. If another
- * thread has a lock on the mutex returns -1.
- */
+/* Try to grab a lock on a mutex. */
int
-objc_mutex_trylock(objc_mutex_t mutex)
+__objc_mutex_trylock(objc_mutex_t mutex)
{
- objc_thread_t thread_id; /* Cache our thread id. */
-
- if (!mutex) /* Is argument bad? */
- return -1; /* Yes, abort. */
- thread_id = objc_thread_id(); /* Get this thread's id. */
- if (mutex->owner == thread_id) /* Already own lock? */
- return ++mutex->depth; /* Yes, increment depth. */
-
- if (mutex_try_lock(&(mutex->lock)) == 0) /* Lock cthread mutex. */
- return -1; /* Failed, abort. */
-
- mutex->owner = thread_id; /* Mark thread as owner. */
- return mutex->depth = 1; /* Increment depth to end. */
+ if (mutex_try_lock((mutex_t)(mutex->backend)) == 0)
+ return -1;
+ else
+ return 0;
}
-/********
- * Decrements the lock count on this mutex by one. If the lock count reaches
- * zero, release the lock on the mutex. Returns the lock count on the mutex.
- * It is an error to attempt to unlock a mutex which this thread doesn't hold
- * in which case return -1 and the mutex is unaffected.
- * Will also return -1 if the mutex free fails.
- */
+/* Unlock the mutex */
int
-objc_mutex_unlock(objc_mutex_t mutex)
+__objc_mutex_unlock(objc_mutex_t mutex)
{
- objc_thread_t thread_id; /* Cache our thread id. */
-
- if (!mutex) /* Is argument bad? */
- return -1; /* Yes, abort. */
- thread_id = objc_thread_id(); /* Get this thread's id. */
- if (mutex->owner != thread_id) /* Does some else own lock? */
- return -1; /* Yes, abort. */
- if (mutex->depth > 1) /* Released last lock? */
- return --mutex->depth; /* No, Decrement depth, end.*/
- mutex->depth = 0; /* Yes, reset depth to 0. */
- mutex->owner = (objc_thread_t) -1; /* Set owner to "no thread".*/
-
- mutex_unlock(&(mutex->lock)); /* unlock cthread mutex. */
-
- return 0; /* No, return success. */
+ mutex_unlock((mutex_t)(mutex->backend));
+ return 0;
}
-/********
- * Allocate a condition. Return the condition pointer if successful or NULL
- * if the allocation failed for any reason.
- */
-objc_condition_t
-objc_condition_allocate(void)
-{
- objc_condition_t condition;
-
- if (!(condition = (objc_condition_t)objc_malloc(
- sizeof(struct objc_condition))))
- return NULL; /* Abort if malloc failed. */
+/* Backend condition mutex functions */
- condition_init(&(condition->condition));
-
- return condition; /* Return mutex handle. */
+/* Allocate a condition. */
+int
+__objc_condition_allocate(objc_condition_t condition)
+{
+ condition->backend = objc_malloc(sizeof(struct condition));
+ condition_init((condition_t)(condition->backend));
+ return 0;
}
-/********
- * Deallocate a condition. Note that this includes an implicit
- * condition_broadcast to insure that waiting threads have the opportunity
- * to wake. It is legal to dealloc a condition only if no other
- * thread is/will be using it. Here we do NOT check for other threads
- * waiting but just wake them up.
- */
+/* Deallocate a condition. */
int
-objc_condition_deallocate(objc_condition_t condition)
+__objc_condition_deallocate(objc_condition_t condition)
{
- condition_broadcast(&(condition->condition));
- condition_clear(&(condition->condition));
- objc_free(condition);
- return 0;
+ condition_clear((condition_t)(condition->backend));
+ objc_free(condition->backend);
+ condition->backend = NULL;
+ return 0;
}
-/********
- * Wait on the condition unlocking the mutex until objc_condition_signal()
- * or objc_condition_broadcast() are called for the same condition. The
- * given mutex *must* have the depth set to 1 so that it can be unlocked
- * here, so that someone else can lock it and signal/broadcast the condition.
- * The mutex is used to lock access to the shared data that make up the
- * "condition" predicate.
- */
+/* Wait on the condition */
int
-objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex)
+__objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex)
{
- objc_thread_t thread_id; /* Cache our thread id. */
-
- if (!mutex || !condition) /* Is argument bad? */
- return -1; /* Yes, abort. */
-
- thread_id = objc_thread_id(); /* Get this thread's id. */
- if (mutex->owner != thread_id) /* Does some else own lock? */
- return -1; /* Yes, abort. */
- if (mutex->depth > 1) /* Locked more than once ? */
- return -1; /* YES, return error */
- /* mutex will be unlocked */
- mutex->depth = 0; /* Yes, reset depth to 0. */
- mutex->owner = (objc_thread_t) -1; /* Set owner to "no thread".*/
-
- condition_wait(&(condition->condition),
- &(mutex->lock)); /* unlock, wait ..., lock */
-
- mutex->owner = thread_id; /* Mark thread as owner. */
- mutex->depth = 1; /* Increment depth to end. */
- return 0; /* Return success. */
+ condition_wait((condition_t)(condition->backend),
+ (mutex_t)(mutex->backend));
+ return 0;
}
-/********
- * Wake up all threads waiting on this condition. It is recommended that
- * the called would lock the same mutex as the threads in objc_condition_wait
- * before changing the "condition predicate" and make this call and unlock it
- * right away after this call.
- */
+/* Wake up all threads waiting on this condition. */
int
-objc_condition_broadcast(objc_condition_t condition)
+__objc_condition_broadcast(objc_condition_t condition)
{
- if (!condition)
- return -1;
- condition_broadcast(&(condition->condition));
- return 0;
+ condition_broadcast((condition_t)(condition->backend));
+ return 0;
}
-/********
- * Wake up one thread waiting on this condition. It is recommended that
- * the called would lock the same mutex as the threads in objc_condition_wait
- * before changing the "condition predicate" and make this call and unlock it
- * right away after this call.
- */
+/* Wake up one thread waiting on this condition. */
int
-objc_condition_signal(objc_condition_t condition)
+__objc_condition_signal(objc_condition_t condition)
{
- if (!condition)
- return -1;
- condition_signal(&(condition->condition));
- return 0;
+ condition_signal((condition_t)(condition->backend));
+ return 0;
}
+/* End of File */
generated by cgit v1.1 at 2025-05-08 15:14:33 +0000