libobjc/thr.c

   1 /* GNU Objective C Runtime Thread Interface
   2    Copyright (C) 1996, 1997, 2009, 2010 Free Software Foundation, Inc.
   3    Contributed by Galen C. Hunt (gchunt@cs.rochester.edu)
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under the
   8 terms of the GNU General Public License as published by the Free Software
   9 Foundation; either version 3, or (at your option) any later version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14 details.
  15
  16 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 #define _LIBOBJC
  26 /* The line below is needed for declarations of functions such as
  27    pthread_mutexattr_settype, without which gthr-posix.h may fail to
  28    compile within libobjc.  Unfortunately, this breaks compilation on
  29    Tru64 UNIX V4.0F, so disable it there.  */
  30 #ifndef __osf__
  31 #define _XOPEN_SOURCE 500
  32 #endif
  33 #include "config.h"
  34 #include "tconfig.h"
  35 #include "coretypes.h"
  36 #include "tm.h"
  37 #include "defaults.h"
  38 #include "objc/thr.h"
  39 #include "objc/runtime.h"
  40 #include <gthr.h>
  41
  42 #include <stdlib.h>
  43
  44 /* Global exit status. */
  45 int __objc_thread_exit_status = 0;
  46
  47 /* Flag which lets us know if we ever became multi threaded */
  48 int __objc_is_multi_threaded = 0;
  49
  50 /* The hook function called when the runtime becomes multi threaded */
  51 objc_thread_callback _objc_became_multi_threaded = NULL;
  52
  53 /*
  54   Use this to set the hook function that will be called when the
  55   runtime initially becomes multi threaded.
  56   The hook function is only called once, meaning only when the
  57   2nd thread is spawned, not for each and every thread.
  58
  59   It returns the previous hook function or NULL if there is none.
  60
  61   A program outside of the runtime could set this to some function so
  62   it can be informed; for example, the GNUstep Base Library sets it
  63   so it can implement the NSBecomingMultiThreaded notification.
  64   */
  65 objc_thread_callback objc_set_thread_callback (objc_thread_callback func)
  66 {
  67   objc_thread_callback temp = _objc_became_multi_threaded;
  68   _objc_became_multi_threaded = func;
  69   return temp;
  70 }
  71
  72 /*
  73   Private functions
  74
  75   These functions are utilized by the frontend, but they are not
  76   considered part of the public interface.
  77   */
  78
  79 /* Initialize the threads subsystem. */
  80 int
  81 __objc_init_thread_system(void)
  82 {
  83   return __gthread_objc_init_thread_system ();
  84 }
  85
  86 /*
  87   First function called in a thread, starts everything else.
  88
  89   This function is passed to the backend by objc_thread_detach
  90   as the starting function for a new thread.
  91  */
  92 struct __objc_thread_start_state
  93 {
  94   SEL selector;
  95   id object;
  96   id argument;
  97 };
  98
  99 static void __attribute__((noreturn))
 100 __objc_thread_detach_function (struct __objc_thread_start_state *istate)
 101 {
 102   /* Valid state? */
 103   if (istate) {
 104     id (*imp) (id, SEL, id);
 105     SEL selector = istate->selector;
 106     id object   = istate->object;
 107     id argument = istate->argument;
 108
 109     /* Don't need anymore so free it */
 110     objc_free (istate);
 111
 112     /* Clear out the thread local storage */
 113     objc_thread_set_data (NULL);
 114
 115     /* Check to see if we just became multi threaded */
 116     if (! __objc_is_multi_threaded)
 117       {
 118         __objc_is_multi_threaded = 1;
 119
 120         /* Call the hook function */
 121         if (_objc_became_multi_threaded != NULL)
 122           (*_objc_became_multi_threaded) ();
 123       }
 124
 125     /* Call the method */
 126     if ((imp = (id (*) (id, SEL, id))objc_msg_lookup (object, selector)))
 127         (*imp) (object, selector, argument);
 128     else
 129       objc_error (object, OBJC_ERR_UNIMPLEMENTED,
 130                   "objc_thread_detach called with bad selector.\n");
 131   }
 132   else
 133     objc_error (nil, OBJC_ERR_BAD_STATE,
 134                 "objc_thread_detach called with NULL state.\n");
 135
 136   /* Exit the thread */
 137   objc_thread_exit ();
 138
 139   /* Make sure compiler detects no return.  */
 140   __builtin_trap ();
 141 }
 142
 143 /*
 144   Frontend functions
 145
 146   These functions constitute the public interface to the Objective-C thread
 147   and mutex functionality.
 148   */
 149
 150 /* Frontend thread functions */
 151
 152 /*
 153   Detach a new thread of execution and return its id.  Returns NULL if fails.
 154   Thread is started by sending message with selector to object.  Message
 155   takes a single argument.
 156   */
 157 objc_thread_t
 158 objc_thread_detach (SEL selector, id object, id argument)
 159 {
 160   struct __objc_thread_start_state *istate;
 161   objc_thread_t        thread_id = NULL;
 162
 163   /* Allocate the state structure */
 164   if (! (istate = (struct __objc_thread_start_state *)
 165          objc_malloc (sizeof (*istate))))
 166     return NULL;
 167
 168   /* Initialize the state structure */
 169   istate->selector = selector;
 170   istate->object = object;
 171   istate->argument = argument;
 172
 173   /* lock access */
 174   objc_mutex_lock (__objc_runtime_mutex);
 175
 176   /* Call the backend to spawn the thread */
 177   if ((thread_id = __gthread_objc_thread_detach ((void *)__objc_thread_detach_function,
 178                                                  istate)) == NULL)
 179     {
 180       /* failed! */
 181       objc_mutex_unlock (__objc_runtime_mutex);
 182       objc_free (istate);
 183       return NULL;
 184     }
 185
 186   /* Increment our thread counter */
 187   __objc_runtime_threads_alive++;
 188   objc_mutex_unlock (__objc_runtime_mutex);
 189
 190   return thread_id;
 191 }
 192
 193 /* Set the current thread's priority. */
 194 int
 195 objc_thread_set_priority (int priority)
 196 {
 197   /* Call the backend */
 198   return __gthread_objc_thread_set_priority (priority);
 199 }
 200
 201 /* Return the current thread's priority. */
 202 int
 203 objc_thread_get_priority (void)
 204 {
 205   /* Call the backend */
 206   return __gthread_objc_thread_get_priority ();
 207 }
 208
 209 /*
 210   Yield our process time to another thread.  Any BUSY waiting that is done
 211   by a thread should use this function to make sure that other threads can
 212   make progress even on a lazy uniprocessor system.
 213   */
 214 void
 215 objc_thread_yield (void)
 216 {
 217   /* Call the backend */
 218   __gthread_objc_thread_yield ();
 219 }
 220
 221 /*
 222   Terminate the current tread.  Doesn't return.
 223   Actually, if it failed returns -1.
 224   */
 225 int
 226 objc_thread_exit (void)
 227 {
 228   /* Decrement our counter of the number of threads alive */
 229   objc_mutex_lock (__objc_runtime_mutex);
 230   __objc_runtime_threads_alive--;
 231   objc_mutex_unlock (__objc_runtime_mutex);
 232
 233   /* Call the backend to terminate the thread */
 234   return __gthread_objc_thread_exit ();
 235 }
 236
 237 /*
 238   Returns an integer value which uniquely describes a thread.  Must not be
 239   NULL which is reserved as a marker for "no thread".
 240   */
 241 objc_thread_t
 242 objc_thread_id (void)
 243 {
 244   /* Call the backend */
 245   return __gthread_objc_thread_id ();
 246 }
 247
 248 /*
 249   Sets the thread's local storage pointer.
 250   Returns 0 if successful or -1 if failed.
 251   */
 252 int
 253 objc_thread_set_data (void *value)
 254 {
 255   /* Call the backend */
 256   return __gthread_objc_thread_set_data (value);
 257 }
 258
 259 /*
 260   Returns the thread's local storage pointer.  Returns NULL on failure.
 261   */
 262 void *
 263 objc_thread_get_data (void)
 264 {
 265   /* Call the backend */
 266   return __gthread_objc_thread_get_data ();
 267 }
 268
 269 /* Frontend mutex functions */
 270
 271 /*
 272   Allocate a mutex.  Return the mutex pointer if successful or NULL if the
 273   allocation failed for any reason.
 274   */
 275 objc_mutex_t
 276 objc_mutex_allocate (void)
 277 {
 278   objc_mutex_t mutex;
 279
 280   /* Allocate the mutex structure */
 281   if (! (mutex = (objc_mutex_t)objc_malloc (sizeof (struct objc_mutex))))
 282     return NULL;
 283
 284   /* Call backend to create the mutex */
 285   if (__gthread_objc_mutex_allocate (mutex))
 286     {
 287       /* failed! */
 288       objc_free (mutex);
 289       return NULL;
 290     }
 291
 292   /* Initialize mutex */
 293   mutex->owner = NULL;
 294   mutex->depth = 0;
 295   return mutex;
 296 }
 297
 298 /*
 299   Deallocate a mutex.  Note that this includes an implicit mutex_lock to
 300   insure that no one else is using the lock.  It is legal to deallocate
 301   a lock if we have a lock on it, but illegal to deallocate a lock held
 302   by anyone else.
 303   Returns the number of locks on the thread.  (1 for deallocate).
 304   */
 305 int
 306 objc_mutex_deallocate (objc_mutex_t mutex)
 307 {
 308   int depth;
 309
 310   /* Valid mutex? */
 311   if (! mutex)
 312     return -1;
 313
 314   /* Acquire lock on mutex */
 315   depth = objc_mutex_lock (mutex);
 316
 317   /* Call backend to destroy mutex */
 318   if (__gthread_objc_mutex_deallocate (mutex))
 319     return -1;
 320
 321   /* Free the mutex structure */
 322   objc_free (mutex);
 323
 324   /* Return last depth */
 325   return depth;
 326 }
 327
 328 /*
 329   Grab a lock on a mutex.  If this thread already has a lock on this mutex
 330   then we increment the lock count.  If another thread has a lock on the
 331   mutex we block and wait for the thread to release the lock.
 332   Returns the lock count on the mutex held by this thread.
 333   */
 334 int
 335 objc_mutex_lock (objc_mutex_t mutex)
 336 {
 337   objc_thread_t thread_id;
 338   int status;
 339
 340   /* Valid mutex? */
 341   if (! mutex)
 342     return -1;
 343
 344   /* If we already own the lock then increment depth */
 345   thread_id = __gthread_objc_thread_id ();
 346   if (mutex->owner == thread_id)
 347     return ++mutex->depth;
 348
 349   /* Call the backend to lock the mutex */
 350   status = __gthread_objc_mutex_lock (mutex);
 351
 352   /* Failed? */
 353   if (status)
 354     return status;
 355
 356   /* Successfully locked the thread */
 357   mutex->owner = thread_id;
 358   return mutex->depth = 1;
 359 }
 360
 361 /*
 362   Try to grab a lock on a mutex.  If this thread already has a lock on
 363   this mutex then we increment the lock count and return it.  If another
 364   thread has a lock on the mutex returns -1.
 365   */
 366 int
 367 objc_mutex_trylock (objc_mutex_t mutex)
 368 {
 369   objc_thread_t thread_id;
 370   int status;
 371
 372   /* Valid mutex? */
 373   if (! mutex)
 374     return -1;
 375
 376   /* If we already own the lock then increment depth */
 377   thread_id = __gthread_objc_thread_id ();
 378   if (mutex->owner == thread_id)
 379     return ++mutex->depth;
 380
 381   /* Call the backend to try to lock the mutex */
 382   status = __gthread_objc_mutex_trylock (mutex);
 383
 384   /* Failed? */
 385   if (status)
 386     return status;
 387
 388   /* Successfully locked the thread */
 389   mutex->owner = thread_id;
 390   return mutex->depth = 1;
 391 }
 392
 393 /*
 394   Unlocks the mutex by one level.
 395   Decrements the lock count on this mutex by one.
 396   If the lock count reaches zero, release the lock on the mutex.
 397   Returns the lock count on the mutex.
 398   It is an error to attempt to unlock a mutex which this thread
 399   doesn't hold in which case return -1 and the mutex is unaffected.
 400   */
 401 int
 402 objc_mutex_unlock (objc_mutex_t mutex)
 403 {
 404   objc_thread_t thread_id;
 405   int status;
 406
 407   /* Valid mutex? */
 408   if (! mutex)
 409     return -1;
 410
 411   /* If another thread owns the lock then abort */
 412   thread_id = __gthread_objc_thread_id ();
 413   if (mutex->owner != thread_id)
 414     return -1;
 415
 416   /* Decrement depth and return */
 417   if (mutex->depth > 1)
 418     return --mutex->depth;
 419
 420   /* Depth down to zero so we are no longer the owner */
 421   mutex->depth = 0;
 422   mutex->owner = NULL;
 423
 424   /* Have the backend unlock the mutex */
 425   status = __gthread_objc_mutex_unlock (mutex);
 426
 427   /* Failed? */
 428   if (status)
 429     return status;
 430
 431   return 0;
 432 }
 433
 434 /* Frontend condition mutex functions */
 435
 436 /*
 437   Allocate a condition.  Return the condition pointer if successful or NULL
 438   if the allocation failed for any reason.
 439   */
 440 objc_condition_t
 441 objc_condition_allocate (void)
 442 {
 443   objc_condition_t condition;
 444
 445   /* Allocate the condition mutex structure */
 446   if (! (condition =
 447          (objc_condition_t) objc_malloc (sizeof (struct objc_condition))))
 448     return NULL;
 449
 450   /* Call the backend to create the condition mutex */
 451   if (__gthread_objc_condition_allocate (condition))
 452     {
 453       /* failed! */
 454       objc_free (condition);
 455       return NULL;
 456     }
 457
 458   /* Success! */
 459   return condition;
 460 }
 461
 462 /*
 463   Deallocate a condition. Note that this includes an implicit
 464   condition_broadcast to insure that waiting threads have the opportunity
 465   to wake.  It is legal to dealloc a condition only if no other
 466   thread is/will be using it. Here we do NOT check for other threads
 467   waiting but just wake them up.
 468   */
 469 int
 470 objc_condition_deallocate (objc_condition_t condition)
 471 {
 472   /* Broadcast the condition */
 473   if (objc_condition_broadcast (condition))
 474     return -1;
 475
 476   /* Call the backend to destroy */
 477   if (__gthread_objc_condition_deallocate (condition))
 478     return -1;
 479
 480   /* Free the condition mutex structure */
 481   objc_free (condition);
 482
 483   return 0;
 484 }
 485
 486 /*
 487   Wait on the condition unlocking the mutex until objc_condition_signal ()
 488   or objc_condition_broadcast () are called for the same condition. The
 489   given mutex *must* have the depth set to 1 so that it can be unlocked
 490   here, so that someone else can lock it and signal/broadcast the condition.
 491   The mutex is used to lock access to the shared data that make up the
 492   "condition" predicate.
 493   */
 494 int
 495 objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
 496 {
 497   objc_thread_t thread_id;
 498
 499   /* Valid arguments? */
 500   if (! mutex || ! condition)
 501     return -1;
 502
 503   /* Make sure we are owner of mutex */
 504   thread_id = __gthread_objc_thread_id ();
 505   if (mutex->owner != thread_id)
 506     return -1;
 507
 508   /* Cannot be locked more than once */
 509   if (mutex->depth > 1)
 510     return -1;
 511
 512   /* Virtually unlock the mutex */
 513   mutex->depth = 0;
 514   mutex->owner = (objc_thread_t)NULL;
 515
 516   /* Call the backend to wait */
 517   __gthread_objc_condition_wait (condition, mutex);
 518
 519   /* Make ourselves owner of the mutex */
 520   mutex->owner = thread_id;
 521   mutex->depth = 1;
 522
 523   return 0;
 524 }
 525
 526 /*
 527   Wake up all threads waiting on this condition. It is recommended that
 528   the called would lock the same mutex as the threads in objc_condition_wait
 529   before changing the "condition predicate" and make this call and unlock it
 530   right away after this call.
 531   */
 532 int
 533 objc_condition_broadcast (objc_condition_t condition)
 534 {
 535   /* Valid condition mutex? */
 536   if (! condition)
 537     return -1;
 538
 539   return __gthread_objc_condition_broadcast (condition);
 540 }
 541
 542 /*
 543   Wake up one thread waiting on this condition. It is recommended that
 544   the called would lock the same mutex as the threads in objc_condition_wait
 545   before changing the "condition predicate" and make this call and unlock it
 546   right away after this call.
 547   */
 548 int
 549 objc_condition_signal (objc_condition_t condition)
 550 {
 551   /* Valid condition mutex? */
 552   if (! condition)
 553     return -1;
 554
 555   return __gthread_objc_condition_signal (condition);
 556 }
 557
 558 /* Make the objc thread system aware that a thread which is managed
 559    (started, stopped) by external code could access objc facilities
 560    from now on.  This is used when you are interfacing with some
 561    external non-objc-based environment/system - you must call
 562    objc_thread_add () before an alien thread makes any calls to
 563    Objective-C.  Do not cause the _objc_became_multi_threaded hook to
 564    be executed. */
 565 void
 566 objc_thread_add (void)
 567 {
 568   objc_mutex_lock (__objc_runtime_mutex);
 569   __objc_is_multi_threaded = 1;
 570   __objc_runtime_threads_alive++;
 571   objc_mutex_unlock (__objc_runtime_mutex);
 572 }
 573
 574 /* Make the objc thread system aware that a thread managed (started,
 575    stopped) by some external code will no longer access objc and thus
 576    can be forgotten by the objc thread system.  Call
 577    objc_thread_remove () when your alien thread is done with making
 578    calls to Objective-C. */
 579 void
 580 objc_thread_remove (void)
 581 {
 582   objc_mutex_lock (__objc_runtime_mutex);
 583   __objc_runtime_threads_alive--;
 584   objc_mutex_unlock (__objc_runtime_mutex);
 585 }
 586
 587 /* End of File */