boehm-gc/irix_threads.c

   1 /*
   2  * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
   3  * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
   4  *
   5  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
   6  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
   7  *
   8  * Permission is hereby granted to use or copy this program
   9  * for any purpose,  provided the above notices are retained on all copies.
  10  * Permission to modify the code and to distribute modified code is granted,
  11  * provided the above notices are retained, and a notice that the code was
  12  * modified is included with the above copyright notice.
  13  */
  14 /*
  15  * Support code for Irix (>=6.2) Pthreads.  This relies on properties
  16  * not guaranteed by the Pthread standard.  It may or may not be portable
  17  * to other implementations.
  18  *
  19  * Note that there is a lot of code duplication between linux_threads.c
  20  * and irix_threads.c; any changes made here may need to be reflected
  21  * there too.
  22  */
  23
  24 # if defined(IRIX_THREADS)
  25
  26 # include "gc_priv.h"
  27 # include <pthread.h>
  28 # include <semaphore.h>
  29 # include <time.h>
  30 # include <errno.h>
  31 # include <unistd.h>
  32 # include <sys/mman.h>
  33 # include <sys/time.h>
  34
  35 #undef pthread_create
  36 #undef pthread_sigmask
  37 #undef pthread_join
  38
  39 void GC_thr_init();
  40
  41 #if 0
  42 void GC_print_sig_mask()
  43 {
  44     sigset_t blocked;
  45     int i;
  46
  47     if (pthread_sigmask(SIG_BLOCK, NULL, &blocked) != 0)
  48         ABORT("pthread_sigmask");
  49     GC_printf0("Blocked: ");
  50     for (i = 1; i <= MAXSIG; i++) {
  51         if (sigismember(&blocked, i)) { GC_printf1("%ld ",(long) i); }
  52     }
  53     GC_printf0("\n");
  54 }
  55 #endif
  56
  57 /* We use the allocation lock to protect thread-related data structures. */
  58
  59 /* The set of all known threads.  We intercept thread creation and      */
  60 /* joins.  We never actually create detached threads.  We allocate all  */
  61 /* new thread stacks ourselves.  These allow us to maintain this        */
  62 /* data structure.                                                      */
  63 /* Protected by GC_thr_lock.                                            */
  64 /* Some of this should be declared volatile, but that's incosnsistent   */
  65 /* with some library routine declarations.                              */
  66 typedef struct GC_Thread_Rep {
  67     struct GC_Thread_Rep * next;  /* More recently allocated threads    */
  68                                   /* with a given pthread id come       */
  69                                   /* first.  (All but the first are     */
  70                                   /* guaranteed to be dead, but we may  */
  71                                   /* not yet have registered the join.) */
  72     pthread_t id;
  73     word stop;
  74 #       define NOT_STOPPED 0
  75 #       define PLEASE_STOP 1
  76 #       define STOPPED 2
  77     word flags;
  78 #       define FINISHED 1       /* Thread has exited.   */
  79 #       define DETACHED 2       /* Thread is intended to be detached.   */
  80 #       define CLIENT_OWNS_STACK        4
  81                                 /* Stack was supplied by client.        */
  82     ptr_t stack;
  83     ptr_t stack_ptr;            /* Valid only when stopped. */
  84                                 /* But must be within stack region at   */
  85                                 /* all times.                           */
  86     size_t stack_size;          /* 0 for original thread.       */
  87     void * status;              /* Used only to avoid premature         */
  88                                 /* reclamation of any data it might     */
  89                                 /* reference.                           */
  90 } * GC_thread;
  91
  92 GC_thread GC_lookup_thread(pthread_t id);
  93
  94 /*
  95  * The only way to suspend threads given the pthread interface is to send
  96  * signals.  Unfortunately, this means we have to reserve
  97  * a signal, and intercept client calls to change the signal mask.
  98  */
  99 # define SIG_SUSPEND (SIGRTMIN + 6)
 100
 101 pthread_mutex_t GC_suspend_lock = PTHREAD_MUTEX_INITIALIZER;
 102                                 /* Number of threads stopped so far     */
 103 pthread_cond_t GC_suspend_ack_cv = PTHREAD_COND_INITIALIZER;
 104 pthread_cond_t GC_continue_cv = PTHREAD_COND_INITIALIZER;
 105
 106 void GC_suspend_handler(int sig)
 107 {
 108     int dummy;
 109     GC_thread me;
 110     sigset_t all_sigs;
 111     sigset_t old_sigs;
 112     int i;
 113
 114     if (sig != SIG_SUSPEND) ABORT("Bad signal in suspend_handler");
 115     me = GC_lookup_thread(pthread_self());
 116     /* The lookup here is safe, since I'm doing this on behalf  */
 117     /* of a thread which holds the allocation lock in order     */
 118     /* to stop the world.  Thus concurrent modification of the  */
 119     /* data structure is impossible.                            */
 120     if (PLEASE_STOP != me -> stop) {
 121         /* Misdirected signal.  */
 122         pthread_mutex_unlock(&GC_suspend_lock);
 123         return;
 124     }
 125     pthread_mutex_lock(&GC_suspend_lock);
 126     me -> stack_ptr = (ptr_t)(&dummy);
 127     me -> stop = STOPPED;
 128     pthread_cond_signal(&GC_suspend_ack_cv);
 129     pthread_cond_wait(&GC_continue_cv, &GC_suspend_lock);
 130     pthread_mutex_unlock(&GC_suspend_lock);
 131     /* GC_printf1("Continuing 0x%x\n", pthread_self()); */
 132 }
 133
 134
 135 GC_bool GC_thr_initialized = FALSE;
 136
 137 size_t GC_min_stack_sz;
 138
 139 size_t GC_page_sz;
 140
 141 # define N_FREE_LISTS 25
 142 ptr_t GC_stack_free_lists[N_FREE_LISTS] = { 0 };
 143                 /* GC_stack_free_lists[i] is free list for stacks of    */
 144                 /* size GC_min_stack_sz*2**i.                           */
 145                 /* Free lists are linked through first word.            */
 146
 147 /* Return a stack of size at least *stack_size.  *stack_size is */
 148 /* replaced by the actual stack size.                           */
 149 /* Caller holds allocation lock.                                */
 150 ptr_t GC_stack_alloc(size_t * stack_size)
 151 {
 152     register size_t requested_sz = *stack_size;
 153     register size_t search_sz = GC_min_stack_sz;
 154     register int index = 0;     /* = log2(search_sz/GC_min_stack_sz) */
 155     register ptr_t result;
 156
 157     while (search_sz < requested_sz) {
 158         search_sz *= 2;
 159         index++;
 160     }
 161     if ((result = GC_stack_free_lists[index]) == 0
 162         && (result = GC_stack_free_lists[index+1]) != 0) {
 163         /* Try next size up. */
 164         search_sz *= 2; index++;
 165     }
 166     if (result != 0) {
 167         GC_stack_free_lists[index] = *(ptr_t *)result;
 168     } else {
 169         result = (ptr_t) GC_scratch_alloc(search_sz + 2*GC_page_sz);
 170         result = (ptr_t)(((word)result + GC_page_sz) & ~(GC_page_sz - 1));
 171         /* Protect hottest page to detect overflow. */
 172         /* mprotect(result, GC_page_sz, PROT_NONE); */
 173         result += GC_page_sz;
 174     }
 175     *stack_size = search_sz;
 176     return(result);
 177 }
 178
 179 /* Caller holds allocation lock.                                        */
 180 void GC_stack_free(ptr_t stack, size_t size)
 181 {
 182     register int index = 0;
 183     register size_t search_sz = GC_min_stack_sz;
 184
 185     while (search_sz < size) {
 186         search_sz *= 2;
 187         index++;
 188     }
 189     if (search_sz != size) ABORT("Bad stack size");
 190     *(ptr_t *)stack = GC_stack_free_lists[index];
 191     GC_stack_free_lists[index] = stack;
 192 }
 193
 194
 195
 196 # define THREAD_TABLE_SZ 128    /* Must be power of 2   */
 197 volatile GC_thread GC_threads[THREAD_TABLE_SZ];
 198
 199 /* Add a thread to GC_threads.  We assume it wasn't already there.      */
 200 /* Caller holds allocation lock.                                        */
 201 GC_thread GC_new_thread(pthread_t id)
 202 {
 203     int hv = ((word)id) % THREAD_TABLE_SZ;
 204     GC_thread result;
 205     static struct GC_Thread_Rep first_thread;
 206     static GC_bool first_thread_used = FALSE;
 207
 208     if (!first_thread_used) {
 209         result = &first_thread;
 210         first_thread_used = TRUE;
 211         /* Dont acquire allocation lock, since we may already hold it. */
 212     } else {
 213         result = (struct GC_Thread_Rep *)
 214                  GC_generic_malloc_inner(sizeof(struct GC_Thread_Rep), NORMAL);
 215     }
 216     if (result == 0) return(0);
 217     result -> id = id;
 218     result -> next = GC_threads[hv];
 219     GC_threads[hv] = result;
 220     /* result -> flags = 0;     */
 221     /* result -> stop = 0;      */
 222     return(result);
 223 }
 224
 225 /* Delete a thread from GC_threads.  We assume it is there.     */
 226 /* (The code intentionally traps if it wasn't.)                 */
 227 /* Caller holds allocation lock.                                */
 228 void GC_delete_thread(pthread_t id)
 229 {
 230     int hv = ((word)id) % THREAD_TABLE_SZ;
 231     register GC_thread p = GC_threads[hv];
 232     register GC_thread prev = 0;
 233
 234     while (!pthread_equal(p -> id, id)) {
 235         prev = p;
 236         p = p -> next;
 237     }
 238     if (prev == 0) {
 239         GC_threads[hv] = p -> next;
 240     } else {
 241         prev -> next = p -> next;
 242     }
 243 }
 244
 245 /* If a thread has been joined, but we have not yet             */
 246 /* been notified, then there may be more than one thread        */
 247 /* in the table with the same pthread id.                       */
 248 /* This is OK, but we need a way to delete a specific one.      */
 249 void GC_delete_gc_thread(pthread_t id, GC_thread gc_id)
 250 {
 251     int hv = ((word)id) % THREAD_TABLE_SZ;
 252     register GC_thread p = GC_threads[hv];
 253     register GC_thread prev = 0;
 254
 255     while (p != gc_id) {
 256         prev = p;
 257         p = p -> next;
 258     }
 259     if (prev == 0) {
 260         GC_threads[hv] = p -> next;
 261     } else {
 262         prev -> next = p -> next;
 263     }
 264 }
 265
 266 /* Return a GC_thread corresponding to a given thread_t.        */
 267 /* Returns 0 if it's not there.                                 */
 268 /* Caller holds  allocation lock or otherwise inhibits          */
 269 /* updates.                                                     */
 270 /* If there is more than one thread with the given id we        */
 271 /* return the most recent one.                                  */
 272 GC_thread GC_lookup_thread(pthread_t id)
 273 {
 274     int hv = ((word)id) % THREAD_TABLE_SZ;
 275     register GC_thread p = GC_threads[hv];
 276
 277     while (p != 0 && !pthread_equal(p -> id, id)) p = p -> next;
 278     return(p);
 279 }
 280
 281
 282 /* Caller holds allocation lock.        */
 283 void GC_stop_world()
 284 {
 285     pthread_t my_thread = pthread_self();
 286     register int i;
 287     register GC_thread p;
 288     register int result;
 289     struct timespec timeout;
 290
 291     for (i = 0; i < THREAD_TABLE_SZ; i++) {
 292       for (p = GC_threads[i]; p != 0; p = p -> next) {
 293         if (p -> id != my_thread) {
 294             if (p -> flags & FINISHED) {
 295                 p -> stop = STOPPED;
 296                 continue;
 297             }
 298             p -> stop = PLEASE_STOP;
 299             result = pthread_kill(p -> id, SIG_SUSPEND);
 300             /* GC_printf1("Sent signal to 0x%x\n", p -> id); */
 301             switch(result) {
 302                 case ESRCH:
 303                     /* Not really there anymore.  Possible? */
 304                     p -> stop = STOPPED;
 305                     break;
 306                 case 0:
 307                     break;
 308                 default:
 309                     ABORT("pthread_kill failed");
 310             }
 311         }
 312       }
 313     }
 314     pthread_mutex_lock(&GC_suspend_lock);
 315     for (i = 0; i < THREAD_TABLE_SZ; i++) {
 316       for (p = GC_threads[i]; p != 0; p = p -> next) {
 317         while (p -> id != my_thread && p -> stop != STOPPED) {
 318             clock_gettime(CLOCK_REALTIME, &timeout);
 319             timeout.tv_nsec += 50000000; /* 50 msecs */
 320             if (timeout.tv_nsec >= 1000000000) {
 321                 timeout.tv_nsec -= 1000000000;
 322                 ++timeout.tv_sec;
 323             }
 324             result = pthread_cond_timedwait(&GC_suspend_ack_cv,
 325                                             &GC_suspend_lock,
 326                                             &timeout);
 327             if (result == ETIMEDOUT) {
 328                 /* Signal was lost or misdirected.  Try again.      */
 329                 /* Duplicate signals should be benign.              */
 330                 result = pthread_kill(p -> id, SIG_SUSPEND);
 331             }
 332         }
 333       }
 334     }
 335     pthread_mutex_unlock(&GC_suspend_lock);
 336     /* GC_printf1("World stopped 0x%x\n", pthread_self()); */
 337 }
 338
 339 /* Caller holds allocation lock.        */
 340 void GC_start_world()
 341 {
 342     GC_thread p;
 343     unsigned i;
 344
 345     /* GC_printf0("World starting\n"); */
 346     for (i = 0; i < THREAD_TABLE_SZ; i++) {
 347       for (p = GC_threads[i]; p != 0; p = p -> next) {
 348         p -> stop = NOT_STOPPED;
 349       }
 350     }
 351     pthread_mutex_lock(&GC_suspend_lock);
 352     /* All other threads are at pthread_cond_wait in signal handler.    */
 353     /* Otherwise we couldn't have acquired the lock.                    */
 354     pthread_mutex_unlock(&GC_suspend_lock);
 355     pthread_cond_broadcast(&GC_continue_cv);
 356 }
 357
 358 # ifdef MMAP_STACKS
 359 --> not really supported yet.
 360 int GC_is_thread_stack(ptr_t addr)
 361 {
 362     register int i;
 363     register GC_thread p;
 364
 365     for (i = 0; i < THREAD_TABLE_SZ; i++) {
 366       for (p = GC_threads[i]; p != 0; p = p -> next) {
 367         if (p -> stack_size != 0) {
 368             if (p -> stack <= addr &&
 369                 addr < p -> stack + p -> stack_size)
 370                    return 1;
 371        }
 372       }
 373     }
 374     return 0;
 375 }
 376 # endif
 377
 378 /* We hold allocation lock.  We assume the world is stopped.    */
 379 void GC_push_all_stacks()
 380 {
 381     register int i;
 382     register GC_thread p;
 383     register ptr_t sp = GC_approx_sp();
 384     register ptr_t lo, hi;
 385     pthread_t me = pthread_self();
 386
 387     if (!GC_thr_initialized) GC_thr_init();
 388     /* GC_printf1("Pushing stacks from thread 0x%x\n", me); */
 389     for (i = 0; i < THREAD_TABLE_SZ; i++) {
 390       for (p = GC_threads[i]; p != 0; p = p -> next) {
 391         if (p -> flags & FINISHED) continue;
 392         if (pthread_equal(p -> id, me)) {
 393             lo = GC_approx_sp();
 394         } else {
 395             lo = p -> stack_ptr;
 396         }
 397         if (p -> stack_size != 0) {
 398             hi = p -> stack + p -> stack_size;
 399         } else {
 400             /* The original stack. */
 401             hi = GC_stackbottom;
 402         }
 403         GC_push_all_stack(lo, hi);
 404       }
 405     }
 406 }
 407
 408
 409 /* We hold the allocation lock. */
 410 void GC_thr_init()
 411 {
 412     GC_thread t;
 413     struct sigaction act;
 414
 415     if (GC_thr_initialized) return;
 416     GC_thr_initialized = TRUE;
 417     GC_min_stack_sz = HBLKSIZE;
 418     GC_page_sz = sysconf(_SC_PAGESIZE);
 419     (void) sigaction(SIG_SUSPEND, 0, &act);
 420     if (act.sa_handler != SIG_DFL)
 421         ABORT("Previously installed SIG_SUSPEND handler");
 422     /* Install handler. */
 423         act.sa_handler = GC_suspend_handler;
 424         act.sa_flags = SA_RESTART;
 425         (void) sigemptyset(&act.sa_mask);
 426         if (0 != sigaction(SIG_SUSPEND, &act, 0))
 427             ABORT("Failed to install SIG_SUSPEND handler");
 428     /* Add the initial thread, so we can stop it.       */
 429       t = GC_new_thread(pthread_self());
 430       t -> stack_size = 0;
 431       t -> stack_ptr = (ptr_t)(&t);
 432       t -> flags = DETACHED;
 433 }
 434
 435 int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset)
 436 {
 437     sigset_t fudged_set;
 438
 439     if (set != NULL && (how == SIG_BLOCK || how == SIG_SETMASK)) {
 440         fudged_set = *set;
 441         sigdelset(&fudged_set, SIG_SUSPEND);
 442         set = &fudged_set;
 443     }
 444     return(pthread_sigmask(how, set, oset));
 445 }
 446
 447 struct start_info {
 448     void *(*start_routine)(void *);
 449     void *arg;
 450     word flags;
 451     ptr_t stack;
 452     size_t stack_size;
 453     sem_t registered;           /* 1 ==> in our thread table, but       */
 454                                 /* parent hasn't yet noticed.           */
 455 };
 456
 457 void GC_thread_exit_proc(void *arg)
 458 {
 459     GC_thread me;
 460
 461     LOCK();
 462     me = GC_lookup_thread(pthread_self());
 463     if (me -> flags & DETACHED) {
 464         GC_delete_thread(pthread_self());
 465     } else {
 466         me -> flags |= FINISHED;
 467     }
 468     UNLOCK();
 469 }
 470
 471 int GC_pthread_join(pthread_t thread, void **retval)
 472 {
 473     int result;
 474     GC_thread thread_gc_id;
 475
 476     LOCK();
 477     thread_gc_id = GC_lookup_thread(thread);
 478     /* This is guaranteed to be the intended one, since the thread id   */
 479     /* cant have been recycled by pthreads.                             */
 480     UNLOCK();
 481     result = pthread_join(thread, retval);
 482     /* Some versions of the Irix pthreads library can erroneously       */
 483     /* return EINTR when the call succeeds.                             */
 484         if (EINTR == result) result = 0;
 485     LOCK();
 486     /* Here the pthread thread id may have been recycled. */
 487     GC_delete_gc_thread(thread, thread_gc_id);
 488     UNLOCK();
 489     return result;
 490 }
 491
 492 void * GC_start_routine(void * arg)
 493 {
 494     struct start_info * si = arg;
 495     void * result;
 496     GC_thread me;
 497     pthread_t my_pthread;
 498     void *(*start)(void *);
 499     void *start_arg;
 500
 501     my_pthread = pthread_self();
 502     /* If a GC occurs before the thread is registered, that GC will     */
 503     /* ignore this thread.  That's fine, since it will block trying to  */
 504     /* acquire the allocation lock, and won't yet hold interesting      */
 505     /* pointers.                                                        */
 506     LOCK();
 507     /* We register the thread here instead of in the parent, so that    */
 508     /* we don't need to hold the allocation lock during pthread_create. */
 509     /* Holding the allocation lock there would make REDIRECT_MALLOC     */
 510     /* impossible.  It probably still doesn't work, but we're a little  */
 511     /* closer ...                                                       */
 512     /* This unfortunately means that we have to be careful the parent   */
 513     /* doesn't try to do a pthread_join before we're registered.        */
 514     me = GC_new_thread(my_pthread);
 515     me -> flags = si -> flags;
 516     me -> stack = si -> stack;
 517     me -> stack_size = si -> stack_size;
 518     me -> stack_ptr = (ptr_t)si -> stack + si -> stack_size - sizeof(word);
 519     UNLOCK();
 520     start = si -> start_routine;
 521     start_arg = si -> arg;
 522     sem_post(&(si -> registered));
 523     pthread_cleanup_push(GC_thread_exit_proc, 0);
 524     result = (*start)(start_arg);
 525     me -> status = result;
 526     me -> flags |= FINISHED;
 527     pthread_cleanup_pop(1);
 528         /* This involves acquiring the lock, ensuring that we can't exit */
 529         /* while a collection that thinks we're alive is trying to stop  */
 530         /* us.                                                           */
 531     return(result);
 532 }
 533
 534 int
 535 GC_pthread_create(pthread_t *new_thread,
 536                   const pthread_attr_t *attr,
 537                   void *(*start_routine)(void *), void *arg)
 538 {
 539     int result;
 540     GC_thread t;
 541     void * stack;
 542     size_t stacksize;
 543     pthread_attr_t new_attr;
 544     int detachstate;
 545     word my_flags = 0;
 546     struct start_info * si = GC_malloc(sizeof(struct start_info));
 547         /* This is otherwise saved only in an area mmapped by the thread */
 548         /* library, which isn't visible to the collector.                */
 549
 550     if (0 == si) return(ENOMEM);
 551     sem_init(&(si -> registered), 0, 0);
 552     si -> start_routine = start_routine;
 553     si -> arg = arg;
 554     LOCK();
 555     if (!GC_thr_initialized) GC_thr_init();
 556     if (NULL == attr) {
 557         stack = 0;
 558         (void) pthread_attr_init(&new_attr);
 559     } else {
 560         new_attr = *attr;
 561         pthread_attr_getstackaddr(&new_attr, &stack);
 562     }
 563     pthread_attr_getstacksize(&new_attr, &stacksize);
 564     pthread_attr_getdetachstate(&new_attr, &detachstate);
 565     if (stacksize < GC_min_stack_sz) ABORT("Stack too small");
 566     if (0 == stack) {
 567         stack = (void *)GC_stack_alloc(&stacksize);
 568         if (0 == stack) {
 569             UNLOCK();
 570             return(ENOMEM);
 571         }
 572         pthread_attr_setstackaddr(&new_attr, stack);
 573     } else {
 574         my_flags |= CLIENT_OWNS_STACK;
 575     }
 576     if (PTHREAD_CREATE_DETACHED == detachstate) my_flags |= DETACHED;
 577     si -> flags = my_flags;
 578     si -> stack = stack;
 579     si -> stack_size = stacksize;
 580     result = pthread_create(new_thread, &new_attr, GC_start_routine, si);
 581     if (0 == new_thread && !(my_flags & CLIENT_OWNS_STACK)) {
 582         GC_stack_free(stack, stacksize);
 583     }
 584     UNLOCK();
 585     /* Wait until child has been added to the thread table.             */
 586     /* This also ensures that we hold onto si until the child is done   */
 587     /* with it.  Thus it doesn't matter whether it is otherwise         */
 588     /* visible to the collector.                                        */
 589         if (0 != sem_wait(&(si -> registered))) ABORT("sem_wait failed");
 590         sem_destroy(&(si -> registered));
 591     /* pthread_attr_destroy(&new_attr); */
 592     return(result);
 593 }
 594
 595 GC_bool GC_collecting = 0; /* A hint that we're in the collector and       */
 596                         /* holding the allocation lock for an           */
 597                         /* extended period.                             */
 598
 599 /* Reasonably fast spin locks.  Basically the same implementation */
 600 /* as STL alloc.h.  This isn't really the right way to do this.   */
 601 /* but until the POSIX scheduling mess gets straightened out ...  */
 602
 603 unsigned long GC_allocate_lock = 0;
 604
 605 #define SLEEP_THRESHOLD 3
 606
 607 void GC_lock()
 608 {
 609 #   define low_spin_max 30  /* spin cycles if we suspect uniprocessor */
 610 #   define high_spin_max 1000 /* spin cycles for multiprocessor */
 611     static unsigned spin_max = low_spin_max;
 612     unsigned my_spin_max;
 613     static unsigned last_spins = 0;
 614     unsigned my_last_spins;
 615     volatile unsigned junk;
 616 #   define PAUSE junk *= junk; junk *= junk; junk *= junk; junk *= junk
 617     int i;
 618
 619     if (!GC_test_and_set(&GC_allocate_lock, 1)) {
 620         return;
 621     }
 622     junk = 0;
 623     my_spin_max = spin_max;
 624     my_last_spins = last_spins;
 625     for (i = 0; i < my_spin_max; i++) {
 626         if (GC_collecting) goto yield;
 627         if (i < my_last_spins/2 || GC_allocate_lock) {
 628             PAUSE;
 629             continue;
 630         }
 631         if (!GC_test_and_set(&GC_allocate_lock, 1)) {
 632             /*
 633              * got it!
 634              * Spinning worked.  Thus we're probably not being scheduled
 635              * against the other process with which we were contending.
 636              * Thus it makes sense to spin longer the next time.
 637              */
 638             last_spins = i;
 639             spin_max = high_spin_max;
 640             return;
 641         }
 642     }
 643     /* We are probably being scheduled against the other process.  Sleep. */
 644     spin_max = low_spin_max;
 645 yield:
 646     for (i = 0;; ++i) {
 647         if (!GC_test_and_set(&GC_allocate_lock, 1)) {
 648             return;
 649         }
 650         if (i < SLEEP_THRESHOLD) {
 651             sched_yield();
 652         } else {
 653             struct timespec ts;
 654
 655             if (i > 26) i = 26;
 656                         /* Don't wait for more than about 60msecs, even */
 657                         /* under extreme contention.                    */
 658             ts.tv_sec = 0;
 659             ts.tv_nsec = 1 << i;
 660             nanosleep(&ts, 0);
 661         }
 662     }
 663 }
 664
 665
 666
 667 # else
 668
 669 #ifndef LINT
 670   int GC_no_Irix_threads;
 671 #endif
 672
 673 # endif /* IRIX_THREADS */
 674