/* Threading for AtheOS.
  Based on thread_beos.h. */

#include <atheos/threads.h>
#include <atheos/semaphore.h>
#include <atheos/atomic.h>
#include <errno.h>
#include <string.h>

/* Missing decl from threads.h */
extern int exit_thread(int);


/* Undefine FASTLOCK to play with simple semaphores. */
#define FASTLOCK


#ifdef FASTLOCK

/* Use an atomic counter and a semaphore for maximum speed. */
typedef struct fastmutex {
       sem_id sem;
       atomic_t count;
} fastmutex_t;


static int fastmutex_create(const char *name, fastmutex_t * mutex);
static int fastmutex_destroy(fastmutex_t * mutex);
static int fastmutex_lock(fastmutex_t * mutex);
static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout);
static int fastmutex_unlock(fastmutex_t * mutex);


static int fastmutex_create(const char *name, fastmutex_t * mutex)
{
       mutex->count = 0;
       mutex->sem = create_semaphore(name, 0, 0);
       return (mutex->sem < 0) ? -1 : 0;
}


static int fastmutex_destroy(fastmutex_t * mutex)
{
       if (fastmutex_timedlock(mutex, 0) == 0 || errno == EWOULDBLOCK) {
               return delete_semaphore(mutex->sem);
       }
       return 0;
}


static int fastmutex_lock(fastmutex_t * mutex)
{
       atomic_t prev = atomic_add(&mutex->count, 1);
       if (prev > 0)
               return lock_semaphore(mutex->sem);
       return 0;
}


static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout)
{
       atomic_t prev = atomic_add(&mutex->count, 1);
       if (prev > 0)
               return lock_semaphore_x(mutex->sem, 1, 0, timeout);
       return 0;
}


static int fastmutex_unlock(fastmutex_t * mutex)
{
       atomic_t prev = atomic_add(&mutex->count, -1);
       if (prev > 1)
               return unlock_semaphore(mutex->sem);
       return 0;
}


#endif                          /* FASTLOCK */


/*
* Initialization.
*
*/
static void PyThread__init_thread(void)
{
       /* Do nothing. */
       return;
}


/*
* Thread support.
*
*/

static atomic_t thread_count = 0;

long PyThread_start_new_thread(void (*func) (void *), void *arg)
{
       status_t success = -1;
       thread_id tid;
       char name[OS_NAME_LENGTH];
       atomic_t this_thread;

       dprintf(("PyThread_start_new_thread called\n"));

       this_thread = atomic_add(&thread_count, 1);
       PyOS_snprintf(name, sizeof(name), "python thread (%d)", this_thread);

       tid = spawn_thread(name, func, NORMAL_PRIORITY, 0, arg);
       if (tid < 0) {
               dprintf(("PyThread_start_new_thread spawn_thread failed: %s\n", strerror(errno)));
       } else {
               success = resume_thread(tid);
               if (success < 0) {
                       dprintf(("PyThread_start_new_thread resume_thread failed: %s\n", strerror(errno)));
               }
       }

       return (success < 0 ? -1 : tid);
}


long PyThread_get_thread_ident(void)
{
       return get_thread_id(NULL);
}


static void do_PyThread_exit_thread(int no_cleanup)
{
       dprintf(("PyThread_exit_thread called\n"));

       /* Thread-safe way to read a variable without a mutex: */
       if (atomic_add(&thread_count, 0) == 0) {
               /* No threads around, so exit main(). */
               if (no_cleanup)
                       _exit(0);
               else
                       exit(0);
       } else {
               /* We're a thread */
               exit_thread(0);
       }
}


void PyThread_exit_thread(void)
{
       do_PyThread_exit_thread(0);
}


void PyThread__exit_thread(void)
{
       do_PyThread_exit_thread(1);
}


#ifndef NO_EXIT_PROG
static void do_PyThread_exit_prog(int status, int no_cleanup)
{
       dprintf(("PyThread_exit_prog(%d) called\n", status));

       /* No need to do anything, the threads get torn down if main()exits. */
       if (no_cleanup)
               _exit(status);
       else
               exit(status);
}


void PyThread_exit_prog(int status)
{
       do_PyThread_exit_prog(status, 0);
}


void PyThread__exit_prog(int status)
{
       do_PyThread_exit_prog(status, 1);
}
#endif                          /* NO_EXIT_PROG */


/*
* Lock support.
*
*/

static atomic_t lock_count = 0;

PyThread_type_lock PyThread_allocate_lock(void)
{
#ifdef FASTLOCK
       fastmutex_t *lock;
#else
       sem_id sema;
#endif
       char name[OS_NAME_LENGTH];
       atomic_t this_lock;

       dprintf(("PyThread_allocate_lock called\n"));

#ifdef FASTLOCK
       lock = (fastmutex_t *) malloc(sizeof(fastmutex_t));
       if (lock == NULL) {
               dprintf(("PyThread_allocate_lock failed: out of memory\n"));
               return (PyThread_type_lock) NULL;
       }
#endif
       this_lock = atomic_add(&lock_count, 1);
       PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);

#ifdef FASTLOCK
       if (fastmutex_create(name, lock) < 0) {
               dprintf(("PyThread_allocate_lock failed: %s\n",
                        strerror(errno)));
               free(lock);
               lock = NULL;
       }
       dprintf(("PyThread_allocate_lock()-> %p\n", lock));
       return (PyThread_type_lock) lock;
#else
       sema = create_semaphore(name, 1, 0);
       if (sema < 0) {
               dprintf(("PyThread_allocate_lock failed: %s\n",
                        strerror(errno)));
               sema = 0;
       }
       dprintf(("PyThread_allocate_lock()-> %p\n", sema));
       return (PyThread_type_lock) sema;
#endif
}


void PyThread_free_lock(PyThread_type_lock lock)
{
       dprintf(("PyThread_free_lock(%p) called\n", lock));

#ifdef FASTLOCK
       if (fastmutex_destroy((fastmutex_t *) lock) < 0) {
               dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
                        strerror(errno)));
       }
       free(lock);
#else
       if (delete_semaphore((sem_id) lock) < 0) {
               dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
                        strerror(errno)));
       }
#endif
}


int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
{
       int retval;

       dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock,
                waitflag));

#ifdef FASTLOCK
       if (waitflag)
               retval = fastmutex_lock((fastmutex_t *) lock);
       else
               retval = fastmutex_timedlock((fastmutex_t *) lock, 0);
#else
       if (waitflag)
               retval = lock_semaphore((sem_id) lock);
       else
               retval = lock_semaphore_x((sem_id) lock, 1, 0, 0);
#endif
       if (retval < 0) {
               dprintf(("PyThread_acquire_lock(%p, %d) failed: %s\n",
                        lock, waitflag, strerror(errno)));
       }
       dprintf(("PyThread_acquire_lock(%p, %d)-> %d\n", lock, waitflag,
                retval));
       return retval < 0 ? 0 : 1;
}


void PyThread_release_lock(PyThread_type_lock lock)
{
       dprintf(("PyThread_release_lock(%p) called\n", lock));

#ifdef FASTLOCK
       if (fastmutex_unlock((fastmutex_t *) lock) < 0) {
               dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
                        strerror(errno)));
       }
#else
       if (unlock_semaphore((sem_id) lock) < 0) {
               dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
                        strerror(errno)));
       }
#endif
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.