libjava/posix-threads.cc

   1 // posix-threads.cc - interface between libjava and POSIX threads.
   2
   3 /* Copyright (C) 1998, 1999, 2000, 2001, 2004, 2006  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 // TO DO:
  12 // * Document signal handling limitations
  13
  14 #include <config.h>
  15
  16 #include "posix.h"
  17 #include "posix-threads.h"
  18
  19 // If we're using the Boehm GC, then we need to override some of the
  20 // thread primitives.  This is fairly gross.
  21 #ifdef HAVE_BOEHM_GC
  22 #include <gc.h>
  23 #endif /* HAVE_BOEHM_GC */
  24
  25 #include <stdlib.h>
  26 #include <time.h>
  27 #include <signal.h>
  28 #include <errno.h>
  29 #include <limits.h>
  30 #ifdef HAVE_UNISTD_H
  31 #include <unistd.h>     // To test for _POSIX_THREAD_PRIORITY_SCHEDULING
  32 #endif
  33
  34 #include <gcj/cni.h>
  35 #include <jvm.h>
  36 #include <java/lang/Thread.h>
  37 #include <java/lang/System.h>
  38 #include <java/lang/Long.h>
  39 #include <java/lang/OutOfMemoryError.h>
  40 #include <java/lang/InternalError.h>
  41
  42 // This is used to implement thread startup.
  43 struct starter
  44 {
  45   _Jv_ThreadStartFunc *method;
  46   _Jv_Thread_t *data;
  47 };
  48
  49 // This is the key used to map from the POSIX thread value back to the
  50 // Java object representing the thread.  The key is global to all
  51 // threads, so it is ok to make it a global here.
  52 pthread_key_t _Jv_ThreadKey;
  53
  54 // This is the key used to map from the POSIX thread value back to the
  55 // _Jv_Thread_t* representing the thread.
  56 pthread_key_t _Jv_ThreadDataKey;
  57
  58 // We keep a count of all non-daemon threads which are running.  When
  59 // this reaches zero, _Jv_ThreadWait returns.
  60 static pthread_mutex_t daemon_mutex;
  61 static pthread_cond_t daemon_cond;
  62 static int non_daemon_count;
  63
  64 // The signal to use when interrupting a thread.
  65 #if defined(LINUX_THREADS) || defined(FREEBSD_THREADS)
  66   // LinuxThreads (prior to glibc 2.1) usurps both SIGUSR1 and SIGUSR2.
  67   // GC on FreeBSD uses both SIGUSR1 and SIGUSR2.
  68 #  define INTR SIGHUP
  69 #else /* LINUX_THREADS */
  70 #  define INTR SIGUSR2
  71 #endif /* LINUX_THREADS */
  72
  73 //
  74 // These are the flags that can appear in _Jv_Thread_t.
  75 //
  76
  77 // Thread started.
  78 #define FLAG_START   0x01
  79 // Thread is daemon.
  80 #define FLAG_DAEMON  0x02
  81
  82 \f
  83
  84 int
  85 _Jv_MutexLock (_Jv_Mutex_t *mu)
  86 {
  87   pthread_t self = pthread_self ();
  88   if (mu->owner == self)
  89     {
  90       mu->count++;
  91     }
  92   else
  93     {
  94       JvSetThreadState holder (_Jv_ThreadCurrent(), JV_BLOCKED);
  95
  96 #     ifdef LOCK_DEBUG
  97         int result = pthread_mutex_lock (&mu->mutex);
  98         if (0 != result)
  99           {
 100             fprintf(stderr, "Pthread_mutex_lock returned %d\n", result);
 101             for (;;) {}
 102           }
 103 #     else
 104         pthread_mutex_lock (&mu->mutex);
 105 #     endif
 106       mu->count = 1;
 107       mu->owner = self;
 108     }
 109   return 0;
 110 }
 111
 112 // Wait for the condition variable "CV" to be notified.
 113 // Return values:
 114 // 0: the condition was notified, or the timeout expired.
 115 // _JV_NOT_OWNER: the thread does not own the mutex "MU".
 116 // _JV_INTERRUPTED: the thread was interrupted. Its interrupted flag is set.
 117 int
 118 _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
 119               jlong millis, jint nanos)
 120 {
 121   pthread_t self = pthread_self();
 122   if (mu->owner != self)
 123     return _JV_NOT_OWNER;
 124
 125   struct timespec ts;
 126
 127   JvThreadState new_state = JV_WAITING;
 128   if (millis > 0 || nanos > 0)
 129     {
 130       // Calculate the abstime corresponding to the timeout.
 131       unsigned long long seconds;
 132       unsigned long usec;
 133
 134       // For better accuracy, should use pthread_condattr_setclock
 135       // and clock_gettime.
 136 #ifdef HAVE_GETTIMEOFDAY
 137       timeval tv;
 138       gettimeofday (&tv, NULL);
 139       usec = tv.tv_usec;
 140       seconds = tv.tv_sec;
 141 #else
 142       unsigned long long startTime = java::lang::System::currentTimeMillis();
 143       seconds = startTime / 1000;
 144       /* Assume we're about half-way through this millisecond.  */
 145       usec = (startTime % 1000) * 1000 + 500;
 146 #endif
 147       /* These next two statements cannot overflow.  */
 148       usec += nanos / 1000;
 149       usec += (millis % 1000) * 1000;
 150       /* These two statements could overflow only if tv.tv_sec was
 151          insanely large.  */
 152       seconds += millis / 1000;
 153       seconds += usec / 1000000;
 154
 155       ts.tv_sec = seconds;
 156       if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
 157         {
 158           // We treat a timeout that won't fit into a struct timespec
 159           // as a wait forever.
 160           millis = nanos = 0;
 161         }
 162       else
 163         /* This next statement also cannot overflow.  */
 164         ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
 165     }
 166
 167   _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
 168   java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
 169
 170   pthread_mutex_lock (&current->wait_mutex);
 171
 172   // Now that we hold the wait mutex, check if this thread has been
 173   // interrupted already.
 174   if (current_obj->interrupt_flag)
 175     {
 176       pthread_mutex_unlock (&current->wait_mutex);
 177       return _JV_INTERRUPTED;
 178     }
 179
 180   // Set the thread's state.
 181   JvSetThreadState holder (current_obj, new_state);
 182
 183   // Add this thread to the cv's wait set.
 184   current->next = NULL;
 185
 186   if (cv->first == NULL)
 187     cv->first = current;
 188   else
 189     for (_Jv_Thread_t *t = cv->first;; t = t->next)
 190       {
 191         if (t->next == NULL)
 192           {
 193             t->next = current;
 194             break;
 195           }
 196       }
 197
 198   // Record the current lock depth, so it can be restored when we re-aquire it.
 199   int count = mu->count;
 200
 201   // Release the monitor mutex.
 202   mu->count = 0;
 203   mu->owner = 0;
 204   pthread_mutex_unlock (&mu->mutex);
 205
 206   int r = 0;
 207   bool done_sleeping = false;
 208
 209   while (! done_sleeping)
 210     {
 211       if (millis == 0 && nanos == 0)
 212         r = pthread_cond_wait (&current->wait_cond, &current->wait_mutex);
 213       else
 214         r = pthread_cond_timedwait (&current->wait_cond, &current->wait_mutex,
 215                                     &ts);
 216
 217       // In older glibc's (prior to 2.1.3), the cond_wait functions may
 218       // spuriously wake up on a signal. Catch that here.
 219       if (r != EINTR)
 220         done_sleeping = true;
 221     }
 222
 223   // Check for an interrupt *before* releasing the wait mutex.
 224   jboolean interrupted = current_obj->interrupt_flag;
 225
 226   pthread_mutex_unlock (&current->wait_mutex);
 227
 228   //  Reaquire the monitor mutex, and restore the lock count.
 229   pthread_mutex_lock (&mu->mutex);
 230   mu->owner = self;
 231   mu->count = count;
 232
 233   // If we were interrupted, or if a timeout occurred, remove ourself from
 234   // the cv wait list now. (If we were notified normally, notify() will have
 235   // already taken care of this)
 236   if (r == ETIMEDOUT || interrupted)
 237     {
 238       _Jv_Thread_t *prev = NULL;
 239       for (_Jv_Thread_t *t = cv->first; t != NULL; t = t->next)
 240         {
 241           if (t == current)
 242             {
 243               if (prev != NULL)
 244                 prev->next = t->next;
 245               else
 246                 cv->first = t->next;
 247               t->next = NULL;
 248               break;
 249             }
 250           prev = t;
 251         }
 252       if (interrupted)
 253         return _JV_INTERRUPTED;
 254     }
 255
 256   return 0;
 257 }
 258
 259 int
 260 _Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
 261 {
 262   if (_Jv_MutexCheckMonitor (mu))
 263     return _JV_NOT_OWNER;
 264
 265   _Jv_Thread_t *target;
 266   _Jv_Thread_t *prev = NULL;
 267
 268   for (target = cv->first; target != NULL; target = target->next)
 269     {
 270       pthread_mutex_lock (&target->wait_mutex);
 271
 272       if (target->thread_obj->interrupt_flag)
 273         {
 274           // Don't notify a thread that has already been interrupted.
 275           pthread_mutex_unlock (&target->wait_mutex);
 276           prev = target;
 277           continue;
 278         }
 279
 280       pthread_cond_signal (&target->wait_cond);
 281       pthread_mutex_unlock (&target->wait_mutex);
 282
 283       // Two concurrent notify() calls must not be delivered to the same
 284       // thread, so remove the target thread from the cv wait list now.
 285       if (prev == NULL)
 286         cv->first = target->next;
 287       else
 288         prev->next = target->next;
 289
 290       target->next = NULL;
 291
 292       break;
 293     }
 294
 295   return 0;
 296 }
 297
 298 int
 299 _Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
 300 {
 301   if (_Jv_MutexCheckMonitor (mu))
 302     return _JV_NOT_OWNER;
 303
 304   _Jv_Thread_t *target;
 305   _Jv_Thread_t *prev = NULL;
 306
 307   for (target = cv->first; target != NULL; target = target->next)
 308     {
 309       pthread_mutex_lock (&target->wait_mutex);
 310       pthread_cond_signal (&target->wait_cond);
 311       pthread_mutex_unlock (&target->wait_mutex);
 312
 313       if (prev != NULL)
 314         prev->next = NULL;
 315       prev = target;
 316     }
 317   if (prev != NULL)
 318     prev->next = NULL;
 319
 320   cv->first = NULL;
 321
 322   return 0;
 323 }
 324
 325 void
 326 _Jv_ThreadInterrupt (_Jv_Thread_t *data)
 327 {
 328   pthread_mutex_lock (&data->wait_mutex);
 329
 330   // Set the thread's interrupted flag *after* aquiring its wait_mutex. This
 331   // ensures that there are no races with the interrupt flag being set after
 332   // the waiting thread checks it and before pthread_cond_wait is entered.
 333   data->thread_obj->interrupt_flag = true;
 334
 335   // Interrupt blocking system calls using a signal.
 336   pthread_kill (data->thread, INTR);
 337
 338   pthread_cond_signal (&data->wait_cond);
 339
 340   pthread_mutex_unlock (&data->wait_mutex);
 341 }
 342
 343 /**
 344  * Releases the block on a thread created by _Jv_ThreadPark().  This
 345  * method can also be used to terminate a blockage caused by a prior
 346  * call to park.  This operation is unsafe, as the thread must be
 347  * guaranteed to be live.
 348  *
 349  * @param thread the thread to unblock.
 350  */
 351 void
 352 ParkHelper::unpark ()
 353 {
 354   using namespace ::java::lang;
 355   volatile obj_addr_t *ptr = &permit;
 356
 357   /* If this thread is in state RUNNING, give it a permit and return
 358      immediately.  */
 359   if (compare_and_swap
 360       (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PERMIT))
 361     return;
 362
 363   /* If this thread is parked, put it into state RUNNING and send it a
 364      signal.  */
 365   if (compare_and_swap
 366       (ptr, Thread::THREAD_PARK_PARKED, Thread::THREAD_PARK_RUNNING))
 367     {
 368       int result;
 369       pthread_mutex_lock (&mutex);
 370       result = pthread_cond_signal (&cond);
 371       pthread_mutex_unlock (&mutex);
 372       JvAssert (result == 0);
 373     }
 374 }
 375
 376 /**
 377  * Sets our state to dead.
 378  */
 379 void
 380 ParkHelper::deactivate ()
 381 {
 382   permit = ::java::lang::Thread::THREAD_PARK_DEAD;
 383 }
 384
 385 void
 386 ParkHelper::init ()
 387 {
 388   pthread_mutex_init (&mutex, NULL);
 389   pthread_cond_init (&cond, NULL);
 390   permit = ::java::lang::Thread::THREAD_PARK_RUNNING;
 391 }
 392
 393 /**
 394  * Blocks the thread until a matching _Jv_ThreadUnpark() occurs, the
 395  * thread is interrupted or the optional timeout expires.  If an
 396  * unpark call has already occurred, this also counts.  A timeout
 397  * value of zero is defined as no timeout.  When isAbsolute is true,
 398  * the timeout is in milliseconds relative to the epoch.  Otherwise,
 399  * the value is the number of nanoseconds which must occur before
 400  * timeout.  This call may also return spuriously (i.e.  for no
 401  * apparent reason).
 402  *
 403  * @param isAbsolute true if the timeout is specified in milliseconds from
 404  *                   the epoch.
 405  * @param time either the number of nanoseconds to wait, or a time in
 406  *             milliseconds from the epoch to wait for.
 407  */
 408 void
 409 ParkHelper::park (jboolean isAbsolute, jlong time)
 410 {
 411   using namespace ::java::lang;
 412   volatile obj_addr_t *ptr = &permit;
 413
 414   /* If we have a permit, return immediately.  */
 415   if (compare_and_swap
 416       (ptr, Thread::THREAD_PARK_PERMIT, Thread::THREAD_PARK_RUNNING))
 417     return;
 418
 419   struct timespec ts;
 420
 421   if (time)
 422     {
 423       unsigned long long seconds;
 424       unsigned long usec;
 425
 426       if (isAbsolute)
 427         {
 428           ts.tv_sec = time / 1000;
 429           ts.tv_nsec = (time % 1000) * 1000 * 1000;
 430         }
 431       else
 432         {
 433           // Calculate the abstime corresponding to the timeout.
 434           jlong nanos = time;
 435           jlong millis = 0;
 436
 437           // For better accuracy, should use pthread_condattr_setclock
 438           // and clock_gettime.
 439 #ifdef HAVE_GETTIMEOFDAY
 440           timeval tv;
 441           gettimeofday (&tv, NULL);
 442           usec = tv.tv_usec;
 443           seconds = tv.tv_sec;
 444 #else
 445           unsigned long long startTime
 446             = java::lang::System::currentTimeMillis();
 447           seconds = startTime / 1000;
 448           /* Assume we're about half-way through this millisecond.  */
 449           usec = (startTime % 1000) * 1000 + 500;
 450 #endif
 451           /* These next two statements cannot overflow.  */
 452           usec += nanos / 1000;
 453           usec += (millis % 1000) * 1000;
 454           /* These two statements could overflow only if tv.tv_sec was
 455              insanely large.  */
 456           seconds += millis / 1000;
 457           seconds += usec / 1000000;
 458
 459           ts.tv_sec = seconds;
 460           if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
 461             {
 462               // We treat a timeout that won't fit into a struct timespec
 463               // as a wait forever.
 464               millis = nanos = 0;
 465             }
 466           else
 467             /* This next statement also cannot overflow.  */
 468             ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
 469         }
 470     }
 471
 472   pthread_mutex_lock (&mutex);
 473   if (compare_and_swap
 474       (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED))
 475     {
 476       int result = 0;
 477
 478       if (! time)
 479         result = pthread_cond_wait (&cond, &mutex);
 480       else
 481         result = pthread_cond_timedwait (&cond, &mutex, &ts);
 482
 483       JvAssert (result == 0 || result == ETIMEDOUT);
 484
 485       /* If we were unparked by some other thread, this will already
 486          be in state THREAD_PARK_RUNNING.  If we timed out or were
 487          interrupted, we have to do it ourself.  */
 488       permit = Thread::THREAD_PARK_RUNNING;
 489     }
 490   pthread_mutex_unlock (&mutex);
 491 }
 492
 493 static void
 494 handle_intr (int)
 495 {
 496   // Do nothing.
 497 }
 498
 499 void
 500 _Jv_BlockSigchld()
 501 {
 502   sigset_t mask;
 503   sigemptyset (&mask);
 504   sigaddset (&mask, SIGCHLD);
 505   int c = pthread_sigmask (SIG_BLOCK, &mask, NULL);
 506   if (c != 0)
 507     JvFail (strerror (c));
 508 }
 509
 510 void
 511 _Jv_UnBlockSigchld()
 512 {
 513   sigset_t mask;
 514   sigemptyset (&mask);
 515   sigaddset (&mask, SIGCHLD);
 516   int c = pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
 517   if (c != 0)
 518     JvFail (strerror (c));
 519 }
 520
 521 void
 522 _Jv_InitThreads (void)
 523 {
 524   pthread_key_create (&_Jv_ThreadKey, NULL);
 525   pthread_key_create (&_Jv_ThreadDataKey, NULL);
 526   pthread_mutex_init (&daemon_mutex, NULL);
 527   pthread_cond_init (&daemon_cond, 0);
 528   non_daemon_count = 0;
 529
 530   // Arrange for the interrupt signal to interrupt system calls.
 531   struct sigaction act;
 532   act.sa_handler = handle_intr;
 533   sigemptyset (&act.sa_mask);
 534   act.sa_flags = 0;
 535   sigaction (INTR, &act, NULL);
 536
 537   // Block SIGCHLD here to ensure that any non-Java threads inherit the new
 538   // signal mask.
 539   _Jv_BlockSigchld();
 540
 541   // Check/set the thread stack size.
 542   size_t min_ss = 32 * 1024;
 543
 544   if (sizeof (void *) == 8)
 545     // Bigger default on 64-bit systems.
 546     min_ss *= 2;
 547
 548 #ifdef PTHREAD_STACK_MIN
 549   if (min_ss < PTHREAD_STACK_MIN)
 550     min_ss = PTHREAD_STACK_MIN;
 551 #endif
 552
 553   if (gcj::stack_size > 0 && gcj::stack_size < min_ss)
 554     gcj::stack_size = min_ss;
 555 }
 556
 557 _Jv_Thread_t *
 558 _Jv_ThreadInitData (java::lang::Thread *obj)
 559 {
 560   _Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_Jv_Thread_t));
 561   data->flags = 0;
 562   data->thread_obj = obj;
 563
 564   pthread_mutex_init (&data->wait_mutex, NULL);
 565   pthread_cond_init (&data->wait_cond, NULL);
 566
 567   return data;
 568 }
 569
 570 void
 571 _Jv_ThreadDestroyData (_Jv_Thread_t *data)
 572 {
 573   pthread_mutex_destroy (&data->wait_mutex);
 574   pthread_cond_destroy (&data->wait_cond);
 575   _Jv_Free ((void *)data);
 576 }
 577
 578 void
 579 _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
 580 {
 581 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
 582   if (data->flags & FLAG_START)
 583     {
 584       struct sched_param param;
 585
 586       param.sched_priority = prio;
 587       pthread_setschedparam (data->thread, SCHED_OTHER, &param);
 588     }
 589 #endif
 590 }
 591
 592 void
 593 _Jv_ThreadRegister (_Jv_Thread_t *data)
 594 {
 595   pthread_setspecific (_Jv_ThreadKey, data->thread_obj);
 596   pthread_setspecific (_Jv_ThreadDataKey, data);
 597
 598   // glibc 2.1.3 doesn't set the value of `thread' until after start_routine
 599   // is called. Since it may need to be accessed from the new thread, work
 600   // around the potential race here by explicitly setting it again.
 601   data->thread = pthread_self ();
 602
 603 # ifdef SLOW_PTHREAD_SELF
 604     // Clear all self cache slots that might be needed by this thread.
 605     int dummy;
 606     int low_index = SC_INDEX(&dummy) + SC_CLEAR_MIN;
 607     int high_index = SC_INDEX(&dummy) + SC_CLEAR_MAX;
 608     for (int i = low_index; i <= high_index; ++i)
 609       {
 610         int current_index = i;
 611         if (current_index < 0)
 612           current_index += SELF_CACHE_SIZE;
 613         if (current_index >= SELF_CACHE_SIZE)
 614           current_index -= SELF_CACHE_SIZE;
 615         _Jv_self_cache[current_index].high_sp_bits = BAD_HIGH_SP_VALUE;
 616       }
 617 # endif
 618   // Block SIGCHLD which is used in natPosixProcess.cc.
 619   _Jv_BlockSigchld();
 620 }
 621
 622 void
 623 _Jv_ThreadUnRegister ()
 624 {
 625   pthread_setspecific (_Jv_ThreadKey, NULL);
 626   pthread_setspecific (_Jv_ThreadDataKey, NULL);
 627 }
 628
 629 // This function is called when a thread is started.  We don't arrange
 630 // to call the `run' method directly, because this function must
 631 // return a value.
 632 static void *
 633 really_start (void *x)
 634 {
 635   struct starter *info = (struct starter *) x;
 636
 637   _Jv_ThreadRegister (info->data);
 638
 639   info->method (info->data->thread_obj);
 640
 641   if (! (info->data->flags & FLAG_DAEMON))
 642     {
 643       pthread_mutex_lock (&daemon_mutex);
 644       --non_daemon_count;
 645       if (! non_daemon_count)
 646         pthread_cond_signal (&daemon_cond);
 647       pthread_mutex_unlock (&daemon_mutex);
 648     }
 649
 650   return NULL;
 651 }
 652
 653 void
 654 _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
 655                  _Jv_ThreadStartFunc *meth)
 656 {
 657   struct sched_param param;
 658   pthread_attr_t attr;
 659   struct starter *info;
 660
 661   if (data->flags & FLAG_START)
 662     return;
 663   data->flags |= FLAG_START;
 664
 665   // Block SIGCHLD which is used in natPosixProcess.cc.
 666   // The current mask is inherited by the child thread.
 667   _Jv_BlockSigchld();
 668
 669   param.sched_priority = thread->getPriority();
 670
 671   pthread_attr_init (&attr);
 672   pthread_attr_setschedparam (&attr, &param);
 673   pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 674
 675   // Set stack size if -Xss option was given.
 676   if (gcj::stack_size > 0)
 677     {
 678       int e = pthread_attr_setstacksize (&attr, gcj::stack_size);
 679       if (e != 0)
 680         JvFail (strerror (e));
 681     }
 682
 683   info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
 684   info->method = meth;
 685   info->data = data;
 686
 687   if (! thread->isDaemon())
 688     {
 689       pthread_mutex_lock (&daemon_mutex);
 690       ++non_daemon_count;
 691       pthread_mutex_unlock (&daemon_mutex);
 692     }
 693   else
 694     data->flags |= FLAG_DAEMON;
 695   int r = pthread_create (&data->thread, &attr, really_start, (void *) info);
 696
 697   pthread_attr_destroy (&attr);
 698
 699   if (r)
 700     {
 701       const char* msg = "Cannot create additional threads";
 702       throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
 703     }
 704 }
 705
 706 void
 707 _Jv_ThreadWait (void)
 708 {
 709   pthread_mutex_lock (&daemon_mutex);
 710   if (non_daemon_count)
 711     pthread_cond_wait (&daemon_cond, &daemon_mutex);
 712   pthread_mutex_unlock (&daemon_mutex);
 713 }
 714
 715 #if defined(SLOW_PTHREAD_SELF)
 716
 717 #include "sysdep/locks.h"
 718
 719 // Support for pthread_self() lookup cache.
 720 volatile self_cache_entry _Jv_self_cache[SELF_CACHE_SIZE];
 721
 722 _Jv_ThreadId_t
 723 _Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce, size_t high_sp_bits)
 724 {
 725   pthread_t self = pthread_self();
 726   sce -> high_sp_bits = high_sp_bits;
 727   write_barrier();
 728   sce -> self = self;
 729   return self;
 730 }
 731
 732 #endif /* SLOW_PTHREAD_SELF */