#include <kernel/OS.h> | |
#include <support/SupportDefs.h> | |
#include <errno.h> | |
/* ---------------------------------------------------------------------- | |
* Fast locking mechanism described by Benoit Schillings (benoit@be.com) | |
* in the Be Developer's Newsletter, Issue #26 (http://www.be.com/). | |
*/ | |
typedef struct benaphore { | |
sem_id _sem; | |
int32 _atom; | |
} benaphore_t; | |
static status_t benaphore_create( const char *name, benaphore_t *ben ); | |
static status_t benaphore_destroy( benaphore_t *ben ); | |
static status_t benaphore_lock( benaphore_t *ben ); | |
static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros ); | |
static status_t benaphore_unlock( benaphore_t *ben ); | |
static status_t benaphore_create( const char *name, benaphore_t *ben ) | |
{ | |
if( ben != NULL ) { | |
ben->_atom = 0; | |
ben->_sem = create_sem( 0, name ); | |
if( ben->_sem < B_NO_ERROR ) { | |
return B_BAD_SEM_ID; | |
} | |
} else { | |
return EFAULT; | |
} | |
return EOK; | |
} | |
static status_t benaphore_destroy( benaphore_t *ben ) | |
{ | |
if( ben->_sem >= B_NO_ERROR ) { | |
status_t retval = benaphore_timedlock( ben, 0 ); | |
if( retval == EOK || retval == EWOULDBLOCK ) { | |
status_t del_retval = delete_sem( ben->_sem ); | |
return del_retval; | |
} | |
} | |
return B_BAD_SEM_ID; | |
} | |
static status_t benaphore_lock( benaphore_t *ben ) | |
{ | |
int32 prev = atomic_add( &(ben->_atom), 1 ); | |
if( prev > 0 ) { | |
return acquire_sem( ben->_sem ); | |
} | |
return EOK; | |
} | |
static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros ) | |
{ | |
int32 prev = atomic_add( &(ben->_atom), 1 ); | |
if( prev > 0 ) { | |
status_t retval = acquire_sem_etc( ben->_sem, 1, B_TIMEOUT, micros ); | |
switch( retval ) { | |
case B_WOULD_BLOCK: /* Fall through... */ | |
case B_TIMED_OUT: | |
return EWOULDBLOCK; | |
break; | |
case B_OK: | |
return EOK; | |
break; | |
default: | |
return retval; | |
break; | |
} | |
} | |
return EOK; | |
} | |
static status_t benaphore_unlock( benaphore_t *ben ) | |
{ | |
int32 prev = atomic_add( &(ben->_atom), -1 ); | |
if( prev > 1 ) { | |
return release_sem( ben->_sem ); | |
} | |
return EOK; | |
} | |
/* ---------------------------------------------------------------------- | |
* Initialization. | |
*/ | |
static void PyThread__init_thread( void ) | |
{ | |
/* Do nothing. */ | |
return; | |
} | |
/* ---------------------------------------------------------------------- | |
* Thread support. | |
* | |
* Only ANSI C, renamed functions here; you can't use K&R on BeOS, | |
* and there's no legacy thread module to support. | |
*/ | |
static int32 thread_count = 0; | |
long PyThread_start_new_thread( void (*func)(void *), void *arg ) | |
{ | |
status_t success = 0; | |
thread_id tid; | |
char name[B_OS_NAME_LENGTH]; | |
int32 this_thread; | |
dprintf(("PyThread_start_new_thread called\n")); | |
/* We are so very thread-safe... */ | |
this_thread = atomic_add( &thread_count, 1 ); | |
PyOS_snprintf(name, sizeof(name), | |
"python thread (%d)", this_thread ); | |
tid = spawn_thread( (thread_func)func, name, | |
B_NORMAL_PRIORITY, arg ); | |
if( tid > B_NO_ERROR ) { | |
success = resume_thread( tid ); | |
} | |
return ( success == B_NO_ERROR ? tid : -1 ); | |
} | |
long PyThread_get_thread_ident( void ) | |
{ | |
/* Presumed to return the current thread's ID... */ | |
thread_id tid; | |
tid = find_thread( NULL ); | |
return ( tid != B_NAME_NOT_FOUND ? tid : -1 ); | |
} | |
void PyThread_exit_thread( void ) | |
{ | |
int32 threads; | |
dprintf(("PyThread_exit_thread called\n")); | |
/* Thread-safe way to read a variable without a mutex: */ | |
threads = atomic_add( &thread_count, 0 ); | |
if( threads == 0 ) { | |
/* No threads around, so exit main(). */ | |
exit(0); | |
} else { | |
/* Oh, we're a thread, let's try to exit gracefully... */ | |
exit_thread( B_NO_ERROR ); | |
} | |
} | |
/* ---------------------------------------------------------------------- | |
* Lock support. | |
*/ | |
static int32 lock_count = 0; | |
PyThread_type_lock PyThread_allocate_lock( void ) | |
{ | |
benaphore_t *lock; | |
status_t retval; | |
char name[B_OS_NAME_LENGTH]; | |
int32 this_lock; | |
dprintf(("PyThread_allocate_lock called\n")); | |
lock = (benaphore_t *)malloc( sizeof( benaphore_t ) ); | |
if( lock == NULL ) { | |
/* TODO: that's bad, raise MemoryError */ | |
return (PyThread_type_lock)NULL; | |
} | |
this_lock = atomic_add( &lock_count, 1 ); | |
PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock); | |
retval = benaphore_create( name, lock ); | |
if( retval != EOK ) { | |
/* TODO: that's bad, raise an exception */ | |
return (PyThread_type_lock)NULL; | |
} | |
dprintf(("PyThread_allocate_lock() -> %p\n", lock)); | |
return (PyThread_type_lock) lock; | |
} | |
void PyThread_free_lock( PyThread_type_lock lock ) | |
{ | |
status_t retval; | |
dprintf(("PyThread_free_lock(%p) called\n", lock)); | |
retval = benaphore_destroy( (benaphore_t *)lock ); | |
if( retval != EOK ) { | |
/* TODO: that's bad, raise an exception */ | |
return; | |
} | |
} | |
int PyThread_acquire_lock( PyThread_type_lock lock, int waitflag ) | |
{ | |
int success; | |
status_t retval; | |
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag)); | |
if( waitflag ) { | |
retval = benaphore_lock( (benaphore_t *)lock ); | |
} else { | |
retval = benaphore_timedlock( (benaphore_t *)lock, 0 ); | |
} | |
if( retval == EOK ) { | |
success = 1; | |
} else { | |
success = 0; | |
/* TODO: that's bad, raise an exception */ | |
} | |
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success)); | |
return success; | |
} | |
void PyThread_release_lock( PyThread_type_lock lock ) | |
{ | |
status_t retval; | |
dprintf(("PyThread_release_lock(%p) called\n", lock)); | |
retval = benaphore_unlock( (benaphore_t *)lock ); | |
if( retval != EOK ) { | |
/* TODO: that's bad, raise an exception */ | |
return; | |
} | |
} |