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       pthread_mutex_lock (&mutex);
 369       pthread_cond_signal (&cond);
 370       pthread_mutex_unlock (&mutex);
 371     }
 372 }
 373
 374 /**
 375  * Sets our state to dead.
 376  */
 377 void
 378 ParkHelper::deactivate ()
 379 {
 380   permit = ::java::lang::Thread::THREAD_PARK_DEAD;
 381 }
 382
 383 /**
 384  * Blocks the thread until a matching _Jv_ThreadUnpark() occurs, the
 385  * thread is interrupted or the optional timeout expires.  If an
 386  * unpark call has already occurred, this also counts.  A timeout
 387  * value of zero is defined as no timeout.  When isAbsolute is true,
 388  * the timeout is in milliseconds relative to the epoch.  Otherwise,
 389  * the value is the number of nanoseconds which must occur before
 390  * timeout.  This call may also return spuriously (i.e.  for no
 391  * apparent reason).
 392  *
 393  * @param isAbsolute true if the timeout is specified in milliseconds from
 394  *                   the epoch.
 395  * @param time either the number of nanoseconds to wait, or a time in
 396  *             milliseconds from the epoch to wait for.
 397  */
 398 void
 399 ParkHelper::park (jboolean isAbsolute, jlong time)
 400 {
 401   using namespace ::java::lang;
 402   volatile obj_addr_t *ptr = &permit;
 403
 404   /* If we have a permit, return immediately.  */
 405   if (compare_and_swap
 406       (ptr, Thread::THREAD_PARK_PERMIT, Thread::THREAD_PARK_RUNNING))
 407     return;
 408
 409   struct timespec ts;
 410   jlong millis = 0, nanos = 0;
 411
 412   if (time)
 413     {
 414       if (isAbsolute)
 415         {
 416           millis = time;
 417           nanos = 0;
 418         }
 419       else
 420         {
 421           millis = java::lang::System::currentTimeMillis();
 422           nanos = time;
 423         }
 424
 425       if (millis > 0 || nanos > 0)
 426         {
 427           // Calculate the abstime corresponding to the timeout.
 428           // Everything is in milliseconds.
 429           //
 430           // We use `unsigned long long' rather than jlong because our
 431           // caller may pass up to Long.MAX_VALUE millis.  This would
 432           // overflow the range of a timespec.
 433
 434           unsigned long long m = (unsigned long long)millis;
 435           unsigned long long seconds = m / 1000;
 436
 437           ts.tv_sec = seconds;
 438           if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
 439             {
 440               // We treat a timeout that won't fit into a struct timespec
 441               // as a wait forever.
 442               millis = nanos = 0;
 443             }
 444           else
 445             {
 446               m %= 1000;
 447               ts.tv_nsec = m * 1000000 + (unsigned long long)nanos;
 448             }
 449         }
 450     }
 451
 452   if (compare_and_swap
 453       (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED))
 454     {
 455       pthread_mutex_lock (&mutex);
 456       if (millis == 0 && nanos == 0)
 457         pthread_cond_wait (&cond, &mutex);
 458       else
 459         pthread_cond_timedwait (&cond, &mutex, &ts);
 460       pthread_mutex_unlock (&mutex);
 461
 462       /* If we were unparked by some other thread, this will already
 463          be in state THREAD_PARK_RUNNING.  If we timed out, we have to
 464          do it ourself.  */
 465       compare_and_swap
 466         (ptr, Thread::THREAD_PARK_PARKED, Thread::THREAD_PARK_RUNNING);
 467     }
 468 }
 469
 470 static void
 471 handle_intr (int)
 472 {
 473   // Do nothing.
 474 }
 475
 476 void
 477 _Jv_BlockSigchld()
 478 {
 479   sigset_t mask;
 480   sigemptyset (&mask);
 481   sigaddset (&mask, SIGCHLD);
 482   int c = pthread_sigmask (SIG_BLOCK, &mask, NULL);
 483   if (c != 0)
 484     JvFail (strerror (c));
 485 }
 486
 487 void
 488 _Jv_UnBlockSigchld()
 489 {
 490   sigset_t mask;
 491   sigemptyset (&mask);
 492   sigaddset (&mask, SIGCHLD);
 493   int c = pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
 494   if (c != 0)
 495     JvFail (strerror (c));
 496 }
 497
 498 void
 499 _Jv_InitThreads (void)
 500 {
 501   pthread_key_create (&_Jv_ThreadKey, NULL);
 502   pthread_key_create (&_Jv_ThreadDataKey, NULL);
 503   pthread_mutex_init (&daemon_mutex, NULL);
 504   pthread_cond_init (&daemon_cond, 0);
 505   non_daemon_count = 0;
 506
 507   // Arrange for the interrupt signal to interrupt system calls.
 508   struct sigaction act;
 509   act.sa_handler = handle_intr;
 510   sigemptyset (&act.sa_mask);
 511   act.sa_flags = 0;
 512   sigaction (INTR, &act, NULL);
 513
 514   // Block SIGCHLD here to ensure that any non-Java threads inherit the new
 515   // signal mask.
 516   _Jv_BlockSigchld();
 517
 518   // Check/set the thread stack size.
 519   size_t min_ss = 32 * 1024;
 520
 521   if (sizeof (void *) == 8)
 522     // Bigger default on 64-bit systems.
 523     min_ss *= 2;
 524
 525 #ifdef PTHREAD_STACK_MIN
 526   if (min_ss < PTHREAD_STACK_MIN)
 527     min_ss = PTHREAD_STACK_MIN;
 528 #endif
 529
 530   if (gcj::stack_size > 0 && gcj::stack_size < min_ss)
 531     gcj::stack_size = min_ss;
 532 }
 533
 534 _Jv_Thread_t *
 535 _Jv_ThreadInitData (java::lang::Thread *obj)
 536 {
 537   _Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_Jv_Thread_t));
 538   data->flags = 0;
 539   data->thread_obj = obj;
 540
 541   pthread_mutex_init (&data->wait_mutex, NULL);
 542   pthread_cond_init (&data->wait_cond, NULL);
 543
 544   return data;
 545 }
 546
 547 void
 548 _Jv_ThreadDestroyData (_Jv_Thread_t *data)
 549 {
 550   pthread_mutex_destroy (&data->wait_mutex);
 551   pthread_cond_destroy (&data->wait_cond);
 552   _Jv_Free ((void *)data);
 553 }
 554
 555 void
 556 _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
 557 {
 558 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
 559   if (data->flags & FLAG_START)
 560     {
 561       struct sched_param param;
 562
 563       param.sched_priority = prio;
 564       pthread_setschedparam (data->thread, SCHED_OTHER, &param);
 565     }
 566 #endif
 567 }
 568
 569 void
 570 _Jv_ThreadRegister (_Jv_Thread_t *data)
 571 {
 572   pthread_setspecific (_Jv_ThreadKey, data->thread_obj);
 573   pthread_setspecific (_Jv_ThreadDataKey, data);
 574
 575   // glibc 2.1.3 doesn't set the value of `thread' until after start_routine
 576   // is called. Since it may need to be accessed from the new thread, work
 577   // around the potential race here by explicitly setting it again.
 578   data->thread = pthread_self ();
 579
 580 # ifdef SLOW_PTHREAD_SELF
 581     // Clear all self cache slots that might be needed by this thread.
 582     int dummy;
 583     int low_index = SC_INDEX(&dummy) + SC_CLEAR_MIN;
 584     int high_index = SC_INDEX(&dummy) + SC_CLEAR_MAX;
 585     for (int i = low_index; i <= high_index; ++i)
 586       {
 587         int current_index = i;
 588         if (current_index < 0)
 589           current_index += SELF_CACHE_SIZE;
 590         if (current_index >= SELF_CACHE_SIZE)
 591           current_index -= SELF_CACHE_SIZE;
 592         _Jv_self_cache[current_index].high_sp_bits = BAD_HIGH_SP_VALUE;
 593       }
 594 # endif
 595   // Block SIGCHLD which is used in natPosixProcess.cc.
 596   _Jv_BlockSigchld();
 597 }
 598
 599 void
 600 _Jv_ThreadUnRegister ()
 601 {
 602   pthread_setspecific (_Jv_ThreadKey, NULL);
 603   pthread_setspecific (_Jv_ThreadDataKey, NULL);
 604 }
 605
 606 // This function is called when a thread is started.  We don't arrange
 607 // to call the `run' method directly, because this function must
 608 // return a value.
 609 static void *
 610 really_start (void *x)
 611 {
 612   struct starter *info = (struct starter *) x;
 613
 614   _Jv_ThreadRegister (info->data);
 615
 616   info->method (info->data->thread_obj);
 617
 618   if (! (info->data->flags & FLAG_DAEMON))
 619     {
 620       pthread_mutex_lock (&daemon_mutex);
 621       --non_daemon_count;
 622       if (! non_daemon_count)
 623         pthread_cond_signal (&daemon_cond);
 624       pthread_mutex_unlock (&daemon_mutex);
 625     }
 626
 627   return NULL;
 628 }
 629
 630 void
 631 _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
 632                  _Jv_ThreadStartFunc *meth)
 633 {
 634   struct sched_param param;
 635   pthread_attr_t attr;
 636   struct starter *info;
 637
 638   if (data->flags & FLAG_START)
 639     return;
 640   data->flags |= FLAG_START;
 641
 642   // Block SIGCHLD which is used in natPosixProcess.cc.
 643   // The current mask is inherited by the child thread.
 644   _Jv_BlockSigchld();
 645
 646   param.sched_priority = thread->getPriority();
 647
 648   pthread_attr_init (&attr);
 649   pthread_attr_setschedparam (&attr, &param);
 650   pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 651
 652   // Set stack size if -Xss option was given.
 653   if (gcj::stack_size > 0)
 654     {
 655       int e = pthread_attr_setstacksize (&attr, gcj::stack_size);
 656       if (e != 0)
 657         JvFail (strerror (e));
 658     }
 659
 660   info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
 661   info->method = meth;
 662   info->data = data;
 663
 664   if (! thread->isDaemon())
 665     {
 666       pthread_mutex_lock (&daemon_mutex);
 667       ++non_daemon_count;
 668       pthread_mutex_unlock (&daemon_mutex);
 669     }
 670   else
 671     data->flags |= FLAG_DAEMON;
 672   int r = pthread_create (&data->thread, &attr, really_start, (void *) info);
 673
 674   pthread_attr_destroy (&attr);
 675
 676   if (r)
 677     {
 678       const char* msg = "Cannot create additional threads";
 679       throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
 680     }
 681 }
 682
 683 void
 684 _Jv_ThreadWait (void)
 685 {
 686   pthread_mutex_lock (&daemon_mutex);
 687   if (non_daemon_count)
 688     pthread_cond_wait (&daemon_cond, &daemon_mutex);
 689   pthread_mutex_unlock (&daemon_mutex);
 690 }
 691
 692 #if defined(SLOW_PTHREAD_SELF)
 693
 694 #include "sysdep/locks.h"
 695
 696 // Support for pthread_self() lookup cache.
 697 volatile self_cache_entry _Jv_self_cache[SELF_CACHE_SIZE];
 698
 699 _Jv_ThreadId_t
 700 _Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce, size_t high_sp_bits)
 701 {
 702   pthread_t self = pthread_self();
 703   sce -> high_sp_bits = high_sp_bits;
 704   write_barrier();
 705   sce -> self = self;
 706   return self;
 707 }
 708
 709 #endif /* SLOW_PTHREAD_SELF */