Python/thread_beos.h

   1 /***********************************************************
   2 Copyright (c) 2000, BeOpen.com.
   3 Copyright (c) 1995-2000, Corporation for National Research Initiatives.
   4 Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
   5 All rights reserved.
   6
   7 See the file "Misc/COPYRIGHT" for information on usage and
   8 redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
   9 BeOS thread support by Chris Herborth (chrish@qnx.com)
  10 ******************************************************************/
  11
  12 #include <kernel/OS.h>
  13 #include <support/SupportDefs.h>
  14 #include <errno.h>
  15
  16 /* ----------------------------------------------------------------------
  17  * Fast locking mechanism described by Benoit Schillings (benoit@be.com)
  18  * in the Be Developer's Newsletter, Issue #26 (http://www.be.com/).
  19  */
  20 typedef struct benaphore {
  21         sem_id _sem;
  22         int32  _atom;
  23 } benaphore_t;
  24
  25 static status_t benaphore_create( const char *name, benaphore_t *ben );
  26 static status_t benaphore_destroy( benaphore_t *ben );
  27 static status_t benaphore_lock( benaphore_t *ben );
  28 static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros );
  29 static status_t benaphore_unlock( benaphore_t *ben );
  30
  31 static status_t benaphore_create( const char *name, benaphore_t *ben )
  32 {
  33         if( ben != NULL ) {
  34                 ben->_atom = 0;
  35                 ben->_sem = create_sem( 0, name );
  36
  37                 if( ben->_sem < B_NO_ERROR ) {
  38                         return B_BAD_SEM_ID;
  39                 }
  40         } else {
  41                 return EFAULT;
  42         }
  43
  44         return EOK;
  45 }
  46
  47 static status_t benaphore_destroy( benaphore_t *ben )
  48 {
  49         if( ben->_sem >= B_NO_ERROR ) {
  50                 status_t retval = benaphore_timedlock( ben, 0 );
  51
  52                 if( retval == EOK || retval == EWOULDBLOCK ) {
  53                         status_t del_retval = delete_sem( ben->_sem );
  54
  55                         return del_retval;
  56                 }
  57         }
  58
  59         return B_BAD_SEM_ID;
  60 }
  61
  62 static status_t benaphore_lock( benaphore_t *ben )
  63 {
  64         int32 prev = atomic_add( &(ben->_atom), 1 );
  65
  66         if( prev > 0 ) {
  67                 return acquire_sem( ben->_sem );
  68         }
  69
  70         return EOK;
  71 }
  72
  73 static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros )
  74 {
  75         int32 prev = atomic_add( &(ben->_atom), 1 );
  76
  77         if( prev > 0 ) {
  78                 status_t retval = acquire_sem_etc( ben->_sem, 1, B_TIMEOUT, micros );
  79
  80                 switch( retval ) {
  81                 case B_WOULD_BLOCK:     /* Fall through... */
  82                 case B_TIMED_OUT:
  83                         return EWOULDBLOCK;
  84                         break;
  85                 case B_OK:
  86                         return EOK;
  87                         break;
  88                 default:
  89                         return retval;
  90                         break;
  91                 }
  92         }
  93
  94         return EOK;
  95 }
  96
  97 static status_t benaphore_unlock( benaphore_t *ben )
  98 {
  99         int32 prev = atomic_add( &(ben->_atom), -1 );
 100
 101         if( prev > 1 ) {
 102                 return release_sem( ben->_sem );
 103         }
 104
 105         return EOK;
 106 }
 107
 108 /* ----------------------------------------------------------------------
 109  * Initialization.
 110  */
 111 static void PyThread__init_thread( void )
 112 {
 113         /* Do nothing. */
 114         return;
 115 }
 116
 117 /* ----------------------------------------------------------------------
 118  * Thread support.
 119  *
 120  * Only ANSI C, renamed functions here; you can't use K&R on BeOS,
 121  * and there's no legacy thread module to support.
 122  */
 123
 124 static int32 thread_count = 0;
 125
 126 int PyThread_start_new_thread( void (*func)(void *), void *arg )
 127 {
 128         status_t success = 0;
 129         thread_id tid;
 130         char name[B_OS_NAME_LENGTH];
 131         int32 this_thread;
 132
 133         dprintf(("PyThread_start_new_thread called\n"));
 134
 135         /* We are so very thread-safe... */
 136         this_thread = atomic_add( &thread_count, 1 );
 137         sprintf( name, "python thread (%d)", this_thread );
 138
 139         tid = spawn_thread( (thread_func)func, name,
 140                             B_NORMAL_PRIORITY, arg );
 141         if( tid > B_NO_ERROR ) {
 142                 success = resume_thread( tid );
 143         }
 144
 145         return ( success == B_NO_ERROR ? 1 : 0 );
 146 }
 147
 148 long PyThread_get_thread_ident( void )
 149 {
 150         /* Presumed to return the current thread's ID... */
 151         thread_id tid;
 152         tid = find_thread( NULL );
 153
 154         return ( tid != B_NAME_NOT_FOUND ? tid : -1 );
 155 }
 156
 157 static void do_PyThread_exit_thread( int no_cleanup )
 158 {
 159         int32 threads;
 160
 161         dprintf(("PyThread_exit_thread called\n"));
 162
 163         /* Thread-safe way to read a variable without a mutex: */
 164         threads = atomic_add( &thread_count, 0 );
 165
 166         if( threads == 0 ) {
 167                 /* No threads around, so exit main(). */
 168                 if( no_cleanup ) {
 169                         _exit(0);
 170                 } else {
 171                         exit(0);
 172                 }
 173         } else {
 174                 /* Oh, we're a thread, let's try to exit gracefully... */
 175                 exit_thread( B_NO_ERROR );
 176         }
 177 }
 178
 179 void PyThread_exit_thread( void )
 180 {
 181         do_PyThread_exit_thread(0);
 182 }
 183
 184 void PyThread__exit_thread( void )
 185 {
 186         do_PyThread_exit_thread(1);
 187 }
 188
 189 #ifndef NO_EXIT_PROG
 190 static void do_PyThread_exit_prog( int status, int no_cleanup )
 191 {
 192         dprintf(("PyThread_exit_prog(%d) called\n", status));
 193
 194         /* No need to do anything, the threads get torn down if main() exits. */
 195
 196         if (no_cleanup) {
 197                 _exit(status);
 198         } else {
 199                 exit(status);
 200         }
 201 }
 202
 203 void PyThread_exit_prog( int status )
 204 {
 205         do_PyThread_exit_prog(status, 0);
 206 }
 207
 208 void PyThread__exit_prog( int status )
 209 {
 210         do_PyThread_exit_prog(status, 1);
 211 }
 212 #endif /* NO_EXIT_PROG */
 213
 214 /* ----------------------------------------------------------------------
 215  * Lock support.
 216  */
 217
 218 static int32 lock_count = 0;
 219
 220 PyThread_type_lock PyThread_allocate_lock( void )
 221 {
 222         benaphore_t *lock;
 223         status_t retval;
 224         char name[B_OS_NAME_LENGTH];
 225         int32 this_lock;
 226
 227         dprintf(("PyThread_allocate_lock called\n"));
 228
 229         lock = (benaphore_t *)malloc( sizeof( benaphore_t ) );
 230         if( lock == NULL ) {
 231                 /* TODO: that's bad, raise MemoryError */
 232                 return (PyThread_type_lock)NULL;
 233         }
 234
 235         this_lock = atomic_add( &lock_count, 1 );
 236         sprintf( name, "python lock (%d)", this_lock );
 237
 238         retval = benaphore_create( name, lock );
 239         if( retval != EOK ) {
 240                 /* TODO: that's bad, raise an exception */
 241                 return (PyThread_type_lock)NULL;
 242         }
 243
 244         dprintf(("PyThread_allocate_lock() -> %p\n", lock));
 245         return (PyThread_type_lock) lock;
 246 }
 247
 248 void PyThread_free_lock( PyThread_type_lock lock )
 249 {
 250         status_t retval;
 251
 252         dprintf(("PyThread_free_lock(%p) called\n", lock));
 253
 254         retval = benaphore_destroy( (benaphore_t *)lock );
 255         if( retval != EOK ) {
 256                 /* TODO: that's bad, raise an exception */
 257                 return;
 258         }
 259 }
 260
 261 int PyThread_acquire_lock( PyThread_type_lock lock, int waitflag )
 262 {
 263         int success;
 264         status_t retval;
 265
 266         dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
 267
 268         if( waitflag ) {
 269                 retval = benaphore_lock( (benaphore_t *)lock );
 270         } else {
 271                 retval = benaphore_timedlock( (benaphore_t *)lock, 0 );
 272         }
 273
 274         if( retval == EOK ) {
 275                 success = 1;
 276         } else {
 277                 success = 0;
 278
 279                 /* TODO: that's bad, raise an exception */
 280         }
 281
 282         dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
 283         return success;
 284 }
 285
 286 void PyThread_release_lock( PyThread_type_lock lock )
 287 {
 288         status_t retval;
 289
 290         dprintf(("PyThread_release_lock(%p) called\n", lock));
 291
 292         retval = benaphore_unlock( (benaphore_t *)lock );
 293         if( retval != EOK ) {
 294                 /* TODO: that's bad, raise an exception */
 295                 return;
 296         }
 297 }
 298
 299 /* ----------------------------------------------------------------------
 300  * Semaphore support.
 301  *
 302  * Guido says not to implement this because it's not used anywhere;
 303  * I'll do it anyway, you never know when it might be handy, and it's
 304  * easy...
 305  */
 306 PyThread_type_sema PyThread_allocate_sema( int value )
 307 {
 308         sem_id sema;
 309
 310         dprintf(("PyThread_allocate_sema called\n"));
 311
 312         sema = create_sem( value, "python semaphore" );
 313         if( sema < B_NO_ERROR ) {
 314                 /* TODO: that's bad, raise an exception */
 315                 return 0;
 316         }
 317
 318         dprintf(("PyThread_allocate_sema() -> %p\n", sema));
 319         return (PyThread_type_sema) sema;
 320 }
 321
 322 void PyThread_free_sema( PyThread_type_sema sema )
 323 {
 324         status_t retval;
 325
 326         dprintf(("PyThread_free_sema(%p) called\n", sema));
 327
 328         retval = delete_sem( (sem_id)sema );
 329         if( retval != B_NO_ERROR ) {
 330                 /* TODO: that's bad, raise an exception */
 331                 return;
 332         }
 333 }
 334
 335 int PyThread_down_sema( PyThread_type_sema sema, int waitflag )
 336 {
 337         status_t retval;
 338
 339         dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
 340
 341         if( waitflag ) {
 342                 retval = acquire_sem( (sem_id)sema );
 343         } else {
 344                 retval = acquire_sem_etc( (sem_id)sema, 1, B_TIMEOUT, 0 );
 345         }
 346
 347         if( retval != B_NO_ERROR ) {
 348                 /* TODO: that's bad, raise an exception */
 349                 return 0;
 350         }
 351
 352         dprintf(("PyThread_down_sema(%p) return\n", sema));
 353         return -1;
 354 }
 355
 356 void PyThread_up_sema( PyThread_type_sema sema )
 357 {
 358         status_t retval;
 359
 360         dprintf(("PyThread_up_sema(%p)\n", sema));
 361
 362         retval = release_sem( (sem_id)sema );
 363         if( retval != B_NO_ERROR ) {
 364                 /* TODO: that's bad, raise an exception */
 365                 return;
 366         }
 367 }