summaryrefslogtreecommitdiffstats
path: root/Python/thread_beos.h
diff options
context:
space:
mode:
Diffstat (limited to 'Python/thread_beos.h')
-rw-r--r--Python/thread_beos.h287
1 files changed, 0 insertions, 287 deletions
diff --git a/Python/thread_beos.h b/Python/thread_beos.h
deleted file mode 100644
index 82f99de..0000000
--- a/Python/thread_beos.h
+++ /dev/null
@@ -1,287 +0,0 @@
-#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 );
-}
-
-static void do_PyThread_exit_thread( int no_cleanup )
-{
- 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(). */
- if( no_cleanup ) {
- _exit(0);
- } else {
- exit(0);
- }
- } else {
- /* Oh, we're a thread, let's try to exit gracefully... */
- exit_thread( B_NO_ERROR );
- }
-}
-
-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 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;
- }
-}
generated by cgit v0.12 at 2024-11-24 14:19:18 (GMT)