libgc/pthread_support.c

   1 /*
   2  * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
   3  * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
   4  * Copyright (c) 1998 by Fergus Henderson.  All rights reserved.
   5  * Copyright (c) 2000-2004 by Hewlett-Packard Company.  All rights reserved.
   6  *
   7  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
   8  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
   9  *
  10  * Permission is hereby granted to use or copy this program
  11  * for any purpose,  provided the above notices are retained on all copies.
  12  * Permission to modify the code and to distribute modified code is granted,
  13  * provided the above notices are retained, and a notice that the code was
  14  * modified is included with the above copyright notice.
  15  */
  16 /*
  17  * Support code for LinuxThreads, the clone()-based kernel
  18  * thread package for Linux which is included in libc6.
  19  *
  20  * This code relies on implementation details of LinuxThreads,
  21  * (i.e. properties not guaranteed by the Pthread standard),
  22  * though this version now does less of that than the other Pthreads
  23  * support code.
  24  *
  25  * Note that there is a lot of code duplication between linux_threads.c
  26  * and thread support for some of the other Posix platforms; any changes
  27  * made here may need to be reflected there too.
  28  */
  29  /* DG/UX ix86 support <takis@xfree86.org> */
  30 /*
  31  * Linux_threads.c now also includes some code to support HPUX and
  32  * OSF1 (Compaq Tru64 Unix, really).  The OSF1 support is based on Eric Benson's
  33  * patch.
  34  *
  35  * Eric also suggested an alternate basis for a lock implementation in
  36  * his code:
  37  * + #elif defined(OSF1)
  38  * +    unsigned long GC_allocate_lock = 0;
  39  * +    msemaphore GC_allocate_semaphore;
  40  * + #  define GC_TRY_LOCK() \
  41  * +    ((msem_lock(&GC_allocate_semaphore, MSEM_IF_NOWAIT) == 0) \
  42  * +     ? (GC_allocate_lock = 1) \
  43  * +     : 0)
  44  * + #  define GC_LOCK_TAKEN GC_allocate_lock
  45  */
  46
  47 /*#define DEBUG_THREADS 1*/
  48 /*#define GC_ASSERTIONS*/
  49
  50 # include "private/pthread_support.h"
  51
  52 # if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \
  53      && !defined(GC_WIN32_THREADS)
  54
  55 # if defined(GC_HPUX_THREADS) && !defined(USE_PTHREAD_SPECIFIC) \
  56      && !defined(USE_COMPILER_TLS)
  57 #   ifdef __GNUC__
  58 #     define USE_PTHREAD_SPECIFIC
  59       /* Empirically, as of gcc 3.3, USE_COMPILER_TLS doesn't work.     */
  60 #   else
  61 #     define USE_COMPILER_TLS
  62 #   endif
  63 # endif
  64
  65 # if defined USE_HPUX_TLS
  66     --> Macro replaced by USE_COMPILER_TLS
  67 # endif
  68
  69 #ifndef USE_COMPILER_TLS
  70 # if (defined(GC_DGUX386_THREADS) || defined(GC_OSF1_THREADS) || \
  71       defined(GC_DARWIN_THREADS) || defined(GC_AIX_THREADS)) || \
  72       defined(GC_NETBSD_THREADS) && !defined(USE_PTHREAD_SPECIFIC) || \
  73       defined(GC_FREEBSD_THREADS) && !defined(USE_PTHREAD_SPECIFIC) || \
  74       defined(GC_OPENBSD_THREADS)
  75 #   define USE_PTHREAD_SPECIFIC
  76 # endif
  77 #endif
  78
  79 # if defined(GC_DGUX386_THREADS) && !defined(_POSIX4A_DRAFT10_SOURCE)
  80 #   define _POSIX4A_DRAFT10_SOURCE 1
  81 # endif
  82
  83 # if defined(GC_DGUX386_THREADS) && !defined(_USING_POSIX4A_DRAFT10)
  84 #   define _USING_POSIX4A_DRAFT10 1
  85 # endif
  86
  87 # ifdef THREAD_LOCAL_ALLOC
  88 #   if !defined(USE_PTHREAD_SPECIFIC) && !defined(USE_COMPILER_TLS)
  89 #     include "private/specific.h"
  90 #   endif
  91
  92 /* Note that these macros should be used only to get/set the GC_thread pointer.
  93  * We need to use both tls and pthread because we use the pthread_create function hook to
  94  * free the data for foreign threads. When that doesn't happen, libgc could have old
  95  * pthread_t that get reused...
  96  */
  97 #   if defined(USE_PTHREAD_SPECIFIC)
  98 #     define GC_getspecific pthread_getspecific
  99 #     define GC_setspecific pthread_setspecific
 100 #     define GC_key_create pthread_key_create
 101       typedef pthread_key_t GC_key_t;
 102 #   endif
 103 #   if defined(USE_COMPILER_TLS)
 104 /* Note sles9 gcc on powerpc gets confused by the define to set GC_thread_tls and pthread_setspecific
 105  * so we actually use a static inline function decalred below that is equivalent to:
 106  *   define GC_setspecific(key, v) (GC_thread_tls = (v), pthread_setspecific ((key), (v)))
 107  */
 108 #     define GC_getspecific(x) (GC_thread_tls)
 109 #     define GC_key_create pthread_key_create
 110       typedef pthread_key_t GC_key_t;
 111 #   endif
 112 # endif
 113 # include <stdlib.h>
 114 # include <pthread.h>
 115 # include <sched.h>
 116 # include <time.h>
 117 # include <errno.h>
 118 # include <unistd.h>
 119 # include <sys/mman.h>
 120 # include <sys/time.h>
 121 # include <sys/types.h>
 122 # include <sys/stat.h>
 123 # include <fcntl.h>
 124 # include <signal.h>
 125
 126 #if defined(GC_DARWIN_THREADS)
 127 # include "private/darwin_semaphore.h"
 128 #else
 129 # include <semaphore.h>
 130 #endif /* !GC_DARWIN_THREADS */
 131
 132 #if defined(GC_DARWIN_THREADS) || defined(GC_FREEBSD_THREADS)
 133 # include <sys/sysctl.h>
 134 #endif /* GC_DARWIN_THREADS */
 135
 136 #if defined(GC_NETBSD_THREADS) || defined(GC_OPENBSD_THREADS)
 137 # include <sys/param.h>
 138 # include <sys/sysctl.h>
 139 #endif
 140
 141
 142
 143 #if defined(GC_DGUX386_THREADS)
 144 # include <sys/dg_sys_info.h>
 145 # include <sys/_int_psem.h>
 146   /* sem_t is an uint in DG/UX */
 147   typedef unsigned int  sem_t;
 148 #endif /* GC_DGUX386_THREADS */
 149
 150 #ifndef __GNUC__
 151 #   define __inline__
 152 #endif
 153
 154 #ifdef GC_USE_LD_WRAP
 155 #   define WRAP_FUNC(f) __wrap_##f
 156 #   define REAL_FUNC(f) __real_##f
 157 #else
 158 #   define WRAP_FUNC(f) GC_##f
 159 #   if !defined(GC_DGUX386_THREADS)
 160 #     define REAL_FUNC(f) f
 161 #   else /* GC_DGUX386_THREADS */
 162 #     define REAL_FUNC(f) __d10_##f
 163 #   endif /* GC_DGUX386_THREADS */
 164 #   undef pthread_create
 165 #   if !defined(GC_DARWIN_THREADS)
 166 #     undef pthread_sigmask
 167 #   endif
 168 #   undef pthread_join
 169 #   undef pthread_detach
 170 #   if defined(NACL)
 171 #     undef pthread_exit
 172 #   endif
 173 #   if defined(GC_OSF1_THREADS) && defined(_PTHREAD_USE_MANGLED_NAMES_) \
 174        && !defined(_PTHREAD_USE_PTDNAM_)
 175 /* Restore the original mangled names on Tru64 UNIX.  */
 176 #     define pthread_create __pthread_create
 177 #     define pthread_join __pthread_join
 178 #     define pthread_detach __pthread_detach
 179 #   endif
 180 #endif
 181
 182 void GC_thr_init();
 183
 184 static GC_bool parallel_initialized = FALSE;
 185
 186 void GC_init_parallel();
 187
 188 static pthread_t main_pthread_self;
 189 static void *main_stack, *main_altstack;
 190 static int main_stack_size, main_altstack_size;
 191
 192 # if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
 193
 194 /* We don't really support thread-local allocation with DBG_HDRS_ALL */
 195
 196 /* work around a dlopen issue (bug #75390), undefs to avoid warnings with redefinitions */
 197 #undef PACKAGE_BUGREPORT
 198 #undef PACKAGE_NAME
 199 #undef PACKAGE_STRING
 200 #undef PACKAGE_TARNAME
 201 #undef PACKAGE_VERSION
 202 #include "mono/utils/mono-compiler.h"
 203
 204 static
 205 GC_key_t GC_thread_key;
 206
 207 #ifdef USE_COMPILER_TLS
 208 __thread void* GC_thread_tls;
 209
 210 /*
 211  * gcc errors out with /tmp/ccdPMFuq.s:2994: Error: symbol `.LTLS4' is already defined
 212  * if the inline is added on powerpc
 213  */
 214 #if !defined(__ppc__) && !defined(__powerpc__)
 215 inline
 216 #endif
 217 static int GC_setspecific (GC_key_t key, void *value) {
 218         GC_thread_tls = value;
 219         return pthread_setspecific (key, value);
 220 }
 221 #endif
 222
 223 static GC_bool keys_initialized;
 224
 225 /* Recover the contents of the freelist array fl into the global one gfl.*/
 226 /* Note that the indexing scheme differs, in that gfl has finer size    */
 227 /* resolution, even if not all entries are used.                        */
 228 /* We hold the allocator lock.                                          */
 229 static void return_freelists(ptr_t *fl, ptr_t *gfl)
 230 {
 231     int i;
 232     ptr_t q, *qptr;
 233     size_t nwords;
 234
 235     for (i = 1; i < NFREELISTS; ++i) {
 236         nwords = i * (GRANULARITY/sizeof(word));
 237         qptr = fl + i;
 238         q = *qptr;
 239         if ((word)q >= HBLKSIZE) {
 240           if (gfl[nwords] == 0) {
 241             gfl[nwords] = q;
 242           } else {
 243             /* Concatenate: */
 244             for (; (word)q >= HBLKSIZE; qptr = &(obj_link(q)), q = *qptr);
 245             GC_ASSERT(0 == q);
 246             *qptr = gfl[nwords];
 247             gfl[nwords] = fl[i];
 248           }
 249         }
 250         /* Clear fl[i], since the thread structure may hang around.     */
 251         /* Do it in a way that is likely to trap if we access it.       */
 252         fl[i] = (ptr_t)HBLKSIZE;
 253     }
 254 }
 255
 256 /* We statically allocate a single "size 0" object. It is linked to     */
 257 /* itself, and is thus repeatedly reused for all size 0 allocation      */
 258 /* requests.  (Size 0 gcj allocation requests are incorrect, and        */
 259 /* we arrange for those to fault asap.)                                 */
 260 static ptr_t size_zero_object = (ptr_t)(&size_zero_object);
 261
 262 void GC_delete_gc_thread(pthread_t id, GC_thread gct);
 263 void GC_destroy_thread_local(GC_thread p);
 264
 265 void GC_thread_deregister_foreign (void *data)
 266 {
 267     GC_thread me = (GC_thread)data;
 268  /*   GC_fprintf1( "\n\n\n\n --- Deregister %x ---\n\n\n\n\n", me->flags ); */
 269     if (me -> flags & FOREIGN_THREAD) {
 270         LOCK();
 271  /*     GC_fprintf0( "\n\n\n\n --- FOO ---\n\n\n\n\n" ); */
 272 #if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
 273         GC_destroy_thread_local (me);
 274 #endif
 275         GC_delete_gc_thread(me->id, me);
 276         UNLOCK();
 277     }
 278 }
 279
 280 /* Each thread structure must be initialized.   */
 281 /* This call must be made from the new thread.  */
 282 /* Caller holds allocation lock.                */
 283 void GC_init_thread_local(GC_thread p)
 284 {
 285     int i;
 286
 287     if (!keys_initialized) {
 288         if (0 != GC_key_create(&GC_thread_key, GC_thread_deregister_foreign)) {
 289             ABORT("Failed to create key for local allocator");
 290         }
 291         keys_initialized = TRUE;
 292     }
 293     if (0 != GC_setspecific(GC_thread_key, p)) {
 294         ABORT("Failed to set thread specific allocation pointers");
 295     }
 296     for (i = 1; i < NFREELISTS; ++i) {
 297         p -> tlfs.ptrfree_freelists[i] = (ptr_t)1;
 298         p -> tlfs.normal_freelists[i] = (ptr_t)1;
 299 #       ifdef GC_GCJ_SUPPORT
 300           p -> tlfs.gcj_freelists[i] = (ptr_t)1;
 301 #       endif
 302     }
 303     /* Set up the size 0 free lists.    */
 304     p -> tlfs.ptrfree_freelists[0] = (ptr_t)(&size_zero_object);
 305     p -> tlfs.normal_freelists[0] = (ptr_t)(&size_zero_object);
 306 #   ifdef GC_GCJ_SUPPORT
 307         p -> tlfs.gcj_freelists[0] = (ptr_t)(-1);
 308 #   endif
 309 }
 310
 311 #ifdef GC_GCJ_SUPPORT
 312   extern ptr_t * GC_gcjobjfreelist;
 313 #endif
 314
 315 /* We hold the allocator lock.  */
 316 void GC_destroy_thread_local(GC_thread p)
 317 {
 318     /* We currently only do this from the thread itself or from */
 319     /* the fork handler for a child process.                    */
 320 #   ifndef HANDLE_FORK
 321       GC_ASSERT(GC_getspecific(GC_thread_key) == (void *)p);
 322 #   endif
 323     return_freelists(p -> tlfs.ptrfree_freelists, GC_aobjfreelist);
 324     return_freelists(p -> tlfs.normal_freelists, GC_objfreelist);
 325 #   ifdef GC_GCJ_SUPPORT
 326         return_freelists(p -> tlfs.gcj_freelists, GC_gcjobjfreelist);
 327 #   endif
 328 }
 329
 330 extern GC_PTR GC_generic_malloc_many();
 331
 332 GC_PTR GC_local_malloc(size_t bytes)
 333 {
 334     if (EXPECT(!SMALL_ENOUGH(bytes),0)) {
 335         return(GC_malloc(bytes));
 336     } else {
 337         int index = INDEX_FROM_BYTES(bytes);
 338         ptr_t * my_fl;
 339         ptr_t my_entry;
 340 #       if defined(REDIRECT_MALLOC) && !defined(USE_PTHREAD_SPECIFIC)
 341         GC_key_t k = GC_thread_key;
 342 #       endif
 343         void * tsd;
 344
 345 #       if defined(REDIRECT_MALLOC) && !defined(USE_PTHREAD_SPECIFIC)
 346             if (EXPECT(0 == k, 0)) {
 347                 /* This can happen if we get called when the world is   */
 348                 /* being initialized.  Whether we can actually complete */
 349                 /* the initialization then is unclear.                  */
 350                 GC_init_parallel();
 351                 k = GC_thread_key;
 352             }
 353 #       endif
 354         tsd = GC_getspecific(GC_thread_key);
 355 #       ifdef GC_ASSERTIONS
 356           LOCK();
 357           GC_ASSERT(tsd == (void *)GC_lookup_thread(pthread_self()));
 358           UNLOCK();
 359 #       endif
 360         my_fl = ((GC_thread)tsd) -> tlfs.normal_freelists + index;
 361         my_entry = *my_fl;
 362         if (EXPECT((word)my_entry >= HBLKSIZE, 1)) {
 363             ptr_t next = obj_link(my_entry);
 364             GC_PTR result = (GC_PTR)my_entry;
 365             *my_fl = next;
 366             obj_link(my_entry) = 0;
 367             PREFETCH_FOR_WRITE(next);
 368             return result;
 369         } else if ((word)my_entry - 1 < DIRECT_GRANULES) {
 370             *my_fl = my_entry + index + 1;
 371             return GC_malloc(bytes);
 372         } else {
 373             GC_generic_malloc_many(BYTES_FROM_INDEX(index), NORMAL, my_fl);
 374             if (*my_fl == 0) return GC_oom_fn(bytes);
 375             return GC_local_malloc(bytes);
 376         }
 377     }
 378 }
 379
 380 GC_PTR GC_local_malloc_atomic(size_t bytes)
 381 {
 382     if (EXPECT(!SMALL_ENOUGH(bytes), 0)) {
 383         return(GC_malloc_atomic(bytes));
 384     } else {
 385         int index = INDEX_FROM_BYTES(bytes);
 386         ptr_t * my_fl = ((GC_thread)GC_getspecific(GC_thread_key))
 387                         -> tlfs.ptrfree_freelists + index;
 388         ptr_t my_entry = *my_fl;
 389
 390         if (EXPECT((word)my_entry >= HBLKSIZE, 1)) {
 391             GC_PTR result = (GC_PTR)my_entry;
 392             *my_fl = obj_link(my_entry);
 393             return result;
 394         } else if ((word)my_entry - 1 < DIRECT_GRANULES) {
 395             *my_fl = my_entry + index + 1;
 396         return GC_malloc_atomic(bytes);
 397         } else {
 398             GC_generic_malloc_many(BYTES_FROM_INDEX(index), PTRFREE, my_fl);
 399             /* *my_fl is updated while the collector is excluded;       */
 400             /* the free list is always visible to the collector as      */
 401             /* such.                                                    */
 402             if (*my_fl == 0) return GC_oom_fn(bytes);
 403             return GC_local_malloc_atomic(bytes);
 404         }
 405     }
 406 }
 407
 408 #ifdef GC_GCJ_SUPPORT
 409
 410 #include "include/gc_gcj.h"
 411
 412 #ifdef GC_ASSERTIONS
 413   extern GC_bool GC_gcj_malloc_initialized;
 414 #endif
 415
 416 extern int GC_gcj_kind;
 417
 418 GC_PTR GC_local_gcj_malloc(size_t bytes,
 419                            void * ptr_to_struct_containing_descr)
 420 {
 421     GC_ASSERT(GC_gcj_malloc_initialized);
 422     if (EXPECT(!SMALL_ENOUGH(bytes), 0)) {
 423         return GC_gcj_malloc(bytes, ptr_to_struct_containing_descr);
 424     } else {
 425         int index = INDEX_FROM_BYTES(bytes);
 426         ptr_t * my_fl = ((GC_thread)GC_getspecific(GC_thread_key))
 427                         -> tlfs.gcj_freelists + index;
 428         ptr_t my_entry = *my_fl;
 429         if (EXPECT((word)my_entry >= HBLKSIZE, 1)) {
 430             GC_PTR result = (GC_PTR)my_entry;
 431             GC_ASSERT(!GC_incremental);
 432             /* We assert that any concurrent marker will stop us.       */
 433             /* Thus it is impossible for a mark procedure to see the    */
 434             /* allocation of the next object, but to see this object    */
 435             /* still containing a free list pointer.  Otherwise the     */
 436             /* marker might find a random "mark descriptor".            */
 437             *(volatile ptr_t *)my_fl = obj_link(my_entry);
 438             /* We must update the freelist before we store the pointer. */
 439             /* Otherwise a GC at this point would see a corrupted       */
 440             /* free list.                                               */
 441             /* A memory barrier is probably never needed, since the     */
 442             /* action of stopping this thread will cause prior writes   */
 443             /* to complete.                                             */
 444             GC_ASSERT(((void * volatile *)result)[1] == 0);
 445             *(void * volatile *)result = ptr_to_struct_containing_descr;
 446             return result;
 447         } else if ((word)my_entry - 1 < DIRECT_GRANULES) {
 448             if (!GC_incremental) *my_fl = my_entry + index + 1;
 449                 /* In the incremental case, we always have to take this */
 450                 /* path.  Thus we leave the counter alone.              */
 451             return GC_gcj_malloc(bytes, ptr_to_struct_containing_descr);
 452         } else {
 453             GC_generic_malloc_many(BYTES_FROM_INDEX(index), GC_gcj_kind, my_fl);
 454             if (*my_fl == 0) return GC_oom_fn(bytes);
 455             return GC_local_gcj_malloc(bytes, ptr_to_struct_containing_descr);
 456         }
 457     }
 458 }
 459
 460 /* Similar to GC_local_gcj_malloc, but the size is in words, and we don't       */
 461 /* adjust it.  The size is assumed to be such that it can be    */
 462 /* allocated as a small object.                                 */
 463 void * GC_local_gcj_fast_malloc(size_t lw, void * ptr_to_struct_containing_descr)
 464 {
 465         ptr_t * my_fl = ((GC_thread)GC_getspecific(GC_thread_key))
 466                 -> tlfs.gcj_freelists + lw;
 467         ptr_t my_entry = *my_fl;
 468
 469     GC_ASSERT(GC_gcj_malloc_initialized);
 470
 471         if (EXPECT((word)my_entry >= HBLKSIZE, 1)) {
 472             GC_PTR result = (GC_PTR)my_entry;
 473             GC_ASSERT(!GC_incremental);
 474             /* We assert that any concurrent marker will stop us.       */
 475             /* Thus it is impossible for a mark procedure to see the    */
 476             /* allocation of the next object, but to see this object    */
 477             /* still containing a free list pointer.  Otherwise the     */
 478             /* marker might find a random "mark descriptor".            */
 479             *(volatile ptr_t *)my_fl = obj_link(my_entry);
 480             /* We must update the freelist before we store the pointer. */
 481             /* Otherwise a GC at this point would see a corrupted       */
 482             /* free list.                                               */
 483             /* A memory barrier is probably never needed, since the     */
 484             /* action of stopping this thread will cause prior writes   */
 485             /* to complete.                                             */
 486             GC_ASSERT(((void * volatile *)result)[1] == 0);
 487             *(void * volatile *)result = ptr_to_struct_containing_descr;
 488             return result;
 489         } else if ((word)my_entry - 1 < DIRECT_GRANULES) {
 490             if (!GC_incremental) *my_fl = my_entry + lw + 1;
 491                 /* In the incremental case, we always have to take this */
 492                 /* path.  Thus we leave the counter alone.              */
 493             return GC_gcj_fast_malloc(lw, ptr_to_struct_containing_descr);
 494         } else {
 495             GC_generic_malloc_many(BYTES_FROM_INDEX(lw), GC_gcj_kind, my_fl);
 496             if (*my_fl == 0) return GC_oom_fn(BYTES_FROM_INDEX(lw));
 497             return GC_local_gcj_fast_malloc(lw, ptr_to_struct_containing_descr);
 498         }
 499 }
 500
 501 #endif /* GC_GCJ_SUPPORT */
 502
 503 # else  /* !THREAD_LOCAL_ALLOC  && !DBG_HDRS_ALL */
 504
 505 #   define GC_destroy_thread_local(t)
 506
 507 # endif /* !THREAD_LOCAL_ALLOC */
 508
 509 #if 0
 510 /*
 511 To make sure that we're using LinuxThreads and not some other thread
 512 package, we generate a dummy reference to `pthread_kill_other_threads_np'
 513 (was `__pthread_initial_thread_bos' but that disappeared),
 514 which is a symbol defined in LinuxThreads, but (hopefully) not in other
 515 thread packages.
 516
 517 We no longer do this, since this code is now portable enough that it might
 518 actually work for something else.
 519 */
 520 void (*dummy_var_to_force_linux_threads)() = pthread_kill_other_threads_np;
 521 #endif /* 0 */
 522
 523 long GC_nprocs = 1;     /* Number of processors.  We may not have       */
 524                         /* access to all of them, but this is as good   */
 525                         /* a guess as any ...                           */
 526
 527 #ifdef PARALLEL_MARK
 528
 529 # ifndef MAX_MARKERS
 530 #   define MAX_MARKERS 16
 531 # endif
 532
 533 static ptr_t marker_sp[MAX_MARKERS] = {0};
 534
 535 void * GC_mark_thread(void * id)
 536 {
 537   word my_mark_no = 0;
 538
 539   marker_sp[(word)id] = GC_approx_sp();
 540   for (;; ++my_mark_no) {
 541     /* GC_mark_no is passed only to allow GC_help_marker to terminate   */
 542     /* promptly.  This is important if it were called from the signal   */
 543     /* handler or from the GC lock acquisition code.  Under Linux, it's */
 544     /* not safe to call it from a signal handler, since it uses mutexes */
 545     /* and condition variables.  Since it is called only here, the      */
 546     /* argument is unnecessary.                                         */
 547     if (my_mark_no < GC_mark_no || my_mark_no > GC_mark_no + 2) {
 548         /* resynchronize if we get far off, e.g. because GC_mark_no     */
 549         /* wrapped.                                                     */
 550         my_mark_no = GC_mark_no;
 551     }
 552 #   ifdef DEBUG_THREADS
 553         GC_printf1("Starting mark helper for mark number %ld\n", my_mark_no);
 554 #   endif
 555     GC_help_marker(my_mark_no);
 556   }
 557 }
 558
 559 extern long GC_markers;         /* Number of mark threads we would      */
 560                                 /* like to have.  Includes the          */
 561                                 /* initiating thread.                   */
 562
 563 pthread_t GC_mark_threads[MAX_MARKERS];
 564
 565 #define PTHREAD_CREATE REAL_FUNC(pthread_create)
 566
 567 static void start_mark_threads()
 568 {
 569     unsigned i;
 570     pthread_attr_t attr;
 571
 572     if (GC_markers > MAX_MARKERS) {
 573         WARN("Limiting number of mark threads\n", 0);
 574         GC_markers = MAX_MARKERS;
 575     }
 576     if (0 != pthread_attr_init(&attr)) ABORT("pthread_attr_init failed");
 577
 578     if (0 != pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED))
 579         ABORT("pthread_attr_setdetachstate failed");
 580
 581 #   if defined(HPUX) || defined(GC_DGUX386_THREADS)
 582       /* Default stack size is usually too small: fix it. */
 583       /* Otherwise marker threads or GC may run out of    */
 584       /* space.                                           */
 585 #     define MIN_STACK_SIZE (8*HBLKSIZE*sizeof(word))
 586       {
 587         size_t old_size;
 588         int code;
 589
 590         if (pthread_attr_getstacksize(&attr, &old_size) != 0)
 591           ABORT("pthread_attr_getstacksize failed\n");
 592         if (old_size < MIN_STACK_SIZE) {
 593           if (pthread_attr_setstacksize(&attr, MIN_STACK_SIZE) != 0)
 594                   ABORT("pthread_attr_setstacksize failed\n");
 595         }
 596       }
 597 #   endif /* HPUX || GC_DGUX386_THREADS */
 598 #   ifdef CONDPRINT
 599       if (GC_print_stats) {
 600         GC_printf1("Starting %ld marker threads\n", GC_markers - 1);
 601       }
 602 #   endif
 603     for (i = 0; i < GC_markers - 1; ++i) {
 604       if (0 != PTHREAD_CREATE(GC_mark_threads + i, &attr,
 605                               GC_mark_thread, (void *)(word)i)) {
 606         WARN("Marker thread creation failed, errno = %ld.\n", errno);
 607       }
 608     }
 609 }
 610
 611 #else  /* !PARALLEL_MARK */
 612
 613 static __inline__ void start_mark_threads()
 614 {
 615 }
 616
 617 #endif /* !PARALLEL_MARK */
 618
 619 GC_bool GC_thr_initialized = FALSE;
 620
 621 volatile GC_thread GC_threads[THREAD_TABLE_SZ];
 622
 623 /*
 624  * gcc-3.3.6 miscompiles the &GC_thread_key+sizeof(&GC_thread_key) expression so
 625  * put it into a separate function.
 626  */
 627 #   if defined(__GNUC__) && defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
 628 static __attribute__((noinline)) unsigned char* get_gc_thread_key_addr GC_PROTO((void))
 629 {
 630         return (unsigned char*)&GC_thread_key;
 631 }
 632
 633 void GC_push_thread_structures GC_PROTO((void))
 634 {
 635     GC_push_all((ptr_t)(GC_threads), (ptr_t)(GC_threads)+sizeof(GC_threads));
 636 #   if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
 637       GC_push_all((ptr_t)get_gc_thread_key_addr(),
 638           (ptr_t)(get_gc_thread_key_addr())+sizeof(&GC_thread_key));
 639 #   endif
 640 }
 641
 642 #else
 643
 644 void GC_push_thread_structures GC_PROTO((void))
 645 {
 646     GC_push_all((ptr_t)(GC_threads), (ptr_t)(GC_threads)+sizeof(GC_threads));
 647 #   if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
 648       GC_push_all((ptr_t)(&GC_thread_key),
 649           (ptr_t)(&GC_thread_key)+sizeof(&GC_thread_key));
 650 #   endif
 651 }
 652
 653 #endif
 654
 655 #ifdef THREAD_LOCAL_ALLOC
 656 /* We must explicitly mark ptrfree and gcj free lists, since the free   */
 657 /* list links wouldn't otherwise be found.  We also set them in the     */
 658 /* normal free lists, since that involves touching less memory than if  */
 659 /* we scanned them normally.                                            */
 660 void GC_mark_thread_local_free_lists(void)
 661 {
 662     int i, j;
 663     GC_thread p;
 664     ptr_t q;
 665
 666     for (i = 0; i < THREAD_TABLE_SZ; ++i) {
 667       for (p = GC_threads[i]; 0 != p; p = p -> next) {
 668         for (j = 1; j < NFREELISTS; ++j) {
 669           q = p -> tlfs.ptrfree_freelists[j];
 670           if ((word)q > HBLKSIZE) GC_set_fl_marks(q);
 671           q = p -> tlfs.normal_freelists[j];
 672           if ((word)q > HBLKSIZE) GC_set_fl_marks(q);
 673 #         ifdef GC_GCJ_SUPPORT
 674             q = p -> tlfs.gcj_freelists[j];
 675             if ((word)q > HBLKSIZE) GC_set_fl_marks(q);
 676 #         endif /* GC_GCJ_SUPPORT */
 677         }
 678       }
 679     }
 680 }
 681 #endif /* THREAD_LOCAL_ALLOC */
 682
 683 static struct GC_Thread_Rep first_thread;
 684
 685 #ifdef NACL
 686 extern volatile int nacl_thread_parked[MAX_NACL_GC_THREADS];
 687 extern volatile int nacl_thread_used[MAX_NACL_GC_THREADS];
 688 extern volatile int nacl_thread_parking_inited;
 689 extern volatile int nacl_num_gc_threads;
 690 extern pthread_mutex_t nacl_thread_alloc_lock;
 691 extern __thread int nacl_thread_idx;
 692 extern __thread GC_thread nacl_gc_thread_self;
 693
 694 extern void nacl_pre_syscall_hook();
 695 extern void nacl_post_syscall_hook();
 696 extern void nacl_register_gc_hooks(void (*pre)(), void (*post)());
 697
 698 #include <stdio.h>
 699
 700 struct nacl_irt_blockhook {
 701   int (*register_block_hooks)(void (*pre)(void), void (*post)(void));
 702 };
 703
 704 extern size_t nacl_interface_query(const char *interface_ident,
 705                             void *table, size_t tablesize);
 706
 707 void nacl_initialize_gc_thread()
 708 {
 709     int i;
 710     static struct nacl_irt_blockhook gc_hook;
 711
 712     pthread_mutex_lock(&nacl_thread_alloc_lock);
 713     if (!nacl_thread_parking_inited)
 714     {
 715         for (i = 0; i < MAX_NACL_GC_THREADS; i++) {
 716             nacl_thread_used[i] = 0;
 717             nacl_thread_parked[i] = 0;
 718         }
 719         // TODO: replace with public 'register hook' function when
 720         // available from glibc
 721         nacl_interface_query("nacl-irt-blockhook-0.1", &gc_hook, sizeof(gc_hook));
 722         gc_hook.register_block_hooks(nacl_pre_syscall_hook, nacl_post_syscall_hook);
 723         nacl_thread_parking_inited = 1;
 724     }
 725     GC_ASSERT(nacl_num_gc_threads <= MAX_NACL_GC_THREADS);
 726     for (i = 0; i < MAX_NACL_GC_THREADS; i++) {
 727         if (nacl_thread_used[i] == 0) {
 728             nacl_thread_used[i] = 1;
 729             nacl_thread_idx = i;
 730             nacl_num_gc_threads++;
 731             break;
 732         }
 733     }
 734     pthread_mutex_unlock(&nacl_thread_alloc_lock);
 735 }
 736
 737 void nacl_shutdown_gc_thread()
 738 {
 739     pthread_mutex_lock(&nacl_thread_alloc_lock);
 740     GC_ASSERT(nacl_thread_idx >= 0 && nacl_thread_idx < MAX_NACL_GC_THREADS);
 741     GC_ASSERT(nacl_thread_used[nacl_thread_idx] != 0);
 742     nacl_thread_used[nacl_thread_idx] = 0;
 743     nacl_thread_idx = -1;
 744     nacl_num_gc_threads--;
 745     pthread_mutex_unlock(&nacl_thread_alloc_lock);
 746 }
 747
 748 #endif /* NACL */
 749
 750 /* Add a thread to GC_threads.  We assume it wasn't already there.      */
 751 /* Caller holds allocation lock.                                        */
 752 GC_thread GC_new_thread(pthread_t id)
 753 {
 754     int hv = ((unsigned long)id) % THREAD_TABLE_SZ;
 755     GC_thread result;
 756     static GC_bool first_thread_used = FALSE;
 757
 758     if (!first_thread_used) {
 759         result = &first_thread;
 760         first_thread_used = TRUE;
 761     } else {
 762         result = (struct GC_Thread_Rep *)
 763                  GC_INTERNAL_MALLOC(sizeof(struct GC_Thread_Rep), NORMAL);
 764     }
 765     if (result == 0) return(0);
 766     result -> id = id;
 767 #ifdef HOST_ANDROID
 768     result -> kernel_id = gettid();
 769 #endif
 770     result -> next = GC_threads[hv];
 771     GC_threads[hv] = result;
 772 #ifdef NACL
 773     nacl_gc_thread_self = result;
 774     nacl_initialize_gc_thread();
 775 #endif
 776     GC_ASSERT(result -> flags == 0 && result -> thread_blocked == 0);
 777     return(result);
 778 }
 779
 780 /* Delete a thread from GC_threads.  We assume it is there.     */
 781 /* (The code intentionally traps if it wasn't.)                 */
 782 /* Caller holds allocation lock.                                */
 783 void GC_delete_thread(pthread_t id)
 784 {
 785     int hv = ((unsigned long)id) % THREAD_TABLE_SZ;
 786     register GC_thread p = GC_threads[hv];
 787     register GC_thread prev = 0;
 788
 789 #ifdef NACL
 790     nacl_shutdown_gc_thread();
 791     nacl_gc_thread_self = NULL;
 792 #endif
 793
 794     while (!pthread_equal(p -> id, id)) {
 795         prev = p;
 796         p = p -> next;
 797     }
 798     if (prev == 0) {
 799         GC_threads[hv] = p -> next;
 800     } else {
 801         prev -> next = p -> next;
 802     }
 803
 804 #ifdef GC_DARWIN_THREADS
 805         mach_port_deallocate(mach_task_self(), p->stop_info.mach_thread);
 806 #endif
 807
 808     GC_INTERNAL_FREE(p);
 809 }
 810
 811 /* If a thread has been joined, but we have not yet             */
 812 /* been notified, then there may be more than one thread        */
 813 /* in the table with the same pthread id.                       */
 814 /* This is OK, but we need a way to delete a specific one.      */
 815 void GC_delete_gc_thread(pthread_t id, GC_thread gc_id)
 816 {
 817     int hv = ((unsigned long)id) % THREAD_TABLE_SZ;
 818     register GC_thread p = GC_threads[hv];
 819     register GC_thread prev = 0;
 820
 821     while (p != gc_id) {
 822         prev = p;
 823         p = p -> next;
 824     }
 825     if (prev == 0) {
 826         GC_threads[hv] = p -> next;
 827     } else {
 828         prev -> next = p -> next;
 829     }
 830
 831 #ifdef GC_DARWIN_THREADS
 832         mach_port_deallocate(mach_task_self(), p->stop_info.mach_thread);
 833 #endif
 834
 835     GC_INTERNAL_FREE(p);
 836 }
 837
 838 /* Return a GC_thread corresponding to a given pthread_t.       */
 839 /* Returns 0 if it's not there.                                 */
 840 /* Caller holds  allocation lock or otherwise inhibits          */
 841 /* updates.                                                     */
 842 /* If there is more than one thread with the given id we        */
 843 /* return the most recent one.                                  */
 844 GC_thread GC_lookup_thread(pthread_t id)
 845 {
 846     int hv = ((unsigned long)id) % THREAD_TABLE_SZ;
 847     register GC_thread p = GC_threads[hv];
 848
 849     while (p != 0 && !pthread_equal(p -> id, id)) p = p -> next;
 850     return(p);
 851 }
 852
 853 int GC_thread_is_registered (void)
 854 {
 855         void *ptr;
 856
 857         LOCK();
 858         ptr = (void *)GC_lookup_thread(pthread_self());
 859         UNLOCK();
 860
 861         return ptr ? 1 : 0;
 862 }
 863
 864 void GC_register_altstack (void *stack, int stack_size, void *altstack, int altstack_size)
 865 {
 866         GC_thread thread;
 867
 868         LOCK();
 869         thread = (void *)GC_lookup_thread(pthread_self());
 870         if (thread) {
 871                 thread->stack = stack;
 872                 thread->stack_size = stack_size;
 873                 thread->altstack = altstack;
 874                 thread->altstack_size = altstack_size;
 875         } else {
 876                 /*
 877                  * This happens if we are called before GC_thr_init ().
 878                  */
 879                 main_pthread_self = pthread_self ();
 880                 main_stack = stack;
 881                 main_stack_size = stack_size;
 882                 main_altstack = altstack;
 883                 main_altstack_size = altstack_size;
 884         }
 885         UNLOCK();
 886 }
 887
 888 #ifdef HANDLE_FORK
 889 /* Remove all entries from the GC_threads table, except the     */
 890 /* one for the current thread.  We need to do this in the child */
 891 /* process after a fork(), since only the current thread        */
 892 /* survives in the child.                                       */
 893 void GC_remove_all_threads_but_me(void)
 894 {
 895     pthread_t self = pthread_self();
 896     int hv;
 897     GC_thread p, next, me;
 898
 899     for (hv = 0; hv < THREAD_TABLE_SZ; ++hv) {
 900       me = 0;
 901       for (p = GC_threads[hv]; 0 != p; p = next) {
 902         next = p -> next;
 903         if (p -> id == self) {
 904           me = p;
 905           p -> next = 0;
 906         } else {
 907 #         ifdef THREAD_LOCAL_ALLOC
 908             if (!(p -> flags & FINISHED)) {
 909               GC_destroy_thread_local(p);
 910             }
 911 #         endif /* THREAD_LOCAL_ALLOC */
 912             if (p != &first_thread) GC_INTERNAL_FREE(p);
 913         }
 914       }
 915       GC_threads[hv] = me;
 916     }
 917     GC_INTERNAL_FREE(p);
 918 }
 919 #endif /* HANDLE_FORK */
 920
 921 #ifdef USE_PROC_FOR_LIBRARIES
 922 int GC_segment_is_thread_stack(ptr_t lo, ptr_t hi)
 923 {
 924     int i;
 925     GC_thread p;
 926
 927 #   ifdef PARALLEL_MARK
 928       for (i = 0; i < GC_markers; ++i) {
 929         if (marker_sp[i] > lo & marker_sp[i] < hi) return 1;
 930       }
 931 #   endif
 932     for (i = 0; i < THREAD_TABLE_SZ; i++) {
 933       for (p = GC_threads[i]; p != 0; p = p -> next) {
 934         if (0 != p -> stack_end) {
 935 #         ifdef STACK_GROWS_UP
 936             if (p -> stack_end >= lo && p -> stack_end < hi) return 1;
 937 #         else /* STACK_GROWS_DOWN */
 938             if (p -> stack_end > lo && p -> stack_end <= hi) return 1;
 939 #         endif
 940         }
 941       }
 942     }
 943     return 0;
 944 }
 945 #endif /* USE_PROC_FOR_LIBRARIES */
 946
 947 #ifdef GC_LINUX_THREADS
 948 /* Return the number of processors, or i<= 0 if it can't be determined. */
 949 int GC_get_nprocs()
 950 {
 951 #ifndef NACL
 952     /* Should be "return sysconf(_SC_NPROCESSORS_ONLN);" but that       */
 953     /* appears to be buggy in many cases.                               */
 954     /* We look for lines "cpu<n>" in /proc/stat.                        */
 955 #   define STAT_BUF_SIZE 4096
 956 #   define STAT_READ read
 957         /* If read is wrapped, this may need to be redefined to call    */
 958         /* the real one.                                                */
 959     char stat_buf[STAT_BUF_SIZE];
 960     int f;
 961     word result = 1;
 962         /* Some old kernels only have a single "cpu nnnn ..."   */
 963         /* entry in /proc/stat.  We identify those as           */
 964         /* uniprocessors.                                       */
 965     size_t i, len = 0;
 966
 967     f = open("/proc/stat", O_RDONLY);
 968     if (f < 0 || (len = STAT_READ(f, stat_buf, STAT_BUF_SIZE)) < 100) {
 969         WARN("Couldn't read /proc/stat\n", 0);
 970         return -1;
 971     }
 972     for (i = 0; i < len - 100; ++i) {
 973         if (stat_buf[i] == '\n' && stat_buf[i+1] == 'c'
 974             && stat_buf[i+2] == 'p' && stat_buf[i+3] == 'u') {
 975             int cpu_no = atoi(stat_buf + i + 4);
 976             if (cpu_no >= result) result = cpu_no + 1;
 977         }
 978     }
 979     close(f);
 980     return result;
 981 #else /* NACL */
 982     return sysconf(_SC_NPROCESSORS_ONLN);
 983 #endif
 984 }
 985 #endif /* GC_LINUX_THREADS */
 986
 987 /* We hold the GC lock.  Wait until an in-progress GC has finished.     */
 988 /* Repeatedly RELEASES GC LOCK in order to wait.                        */
 989 /* If wait_for_all is true, then we exit with the GC lock held and no   */
 990 /* collection in progress; otherwise we just wait for the current GC    */
 991 /* to finish.                                                           */
 992 extern GC_bool GC_collection_in_progress();
 993 void GC_wait_for_gc_completion(GC_bool wait_for_all)
 994 {
 995     if (GC_incremental && GC_collection_in_progress()) {
 996         int old_gc_no = GC_gc_no;
 997
 998         /* Make sure that no part of our stack is still on the mark stack, */
 999         /* since it's about to be unmapped.                                */
1000         while (GC_incremental && GC_collection_in_progress()
1001                && (wait_for_all || old_gc_no == GC_gc_no)) {
1002             ENTER_GC();
1003             GC_in_thread_creation = TRUE;
1004             GC_collect_a_little_inner(1);
1005             GC_in_thread_creation = FALSE;
1006             EXIT_GC();
1007             UNLOCK();
1008             sched_yield();
1009             LOCK();
1010         }
1011     }
1012 }
1013
1014 #ifdef HANDLE_FORK
1015 /* Procedures called before and after a fork.  The goal here is to make */
1016 /* it safe to call GC_malloc() in a forked child.  It's unclear that is */
1017 /* attainable, since the single UNIX spec seems to imply that one       */
1018 /* should only call async-signal-safe functions, and we probably can't  */
1019 /* quite guarantee that.  But we give it our best shot.  (That same     */
1020 /* spec also implies that it's not safe to call the system malloc       */
1021 /* between fork() and exec().  Thus we're doing no worse than it.       */
1022
1023 /* Called before a fork()               */
1024 void GC_fork_prepare_proc(void)
1025 {
1026     /* Acquire all relevant locks, so that after releasing the locks    */
1027     /* the child will see a consistent state in which monitor           */
1028     /* invariants hold.  Unfortunately, we can't acquire libc locks     */
1029     /* we might need, and there seems to be no guarantee that libc      */
1030     /* must install a suitable fork handler.                            */
1031     /* Wait for an ongoing GC to finish, since we can't finish it in    */
1032     /* the (one remaining thread in) the child.                         */
1033       LOCK();
1034 #     if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC)
1035         GC_wait_for_reclaim();
1036 #     endif
1037       GC_wait_for_gc_completion(TRUE);
1038 #     if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC)
1039         GC_acquire_mark_lock();
1040 #     endif
1041 }
1042
1043 /* Called in parent after a fork()      */
1044 void GC_fork_parent_proc(void)
1045 {
1046 #   if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC)
1047       GC_release_mark_lock();
1048 #   endif
1049     UNLOCK();
1050 }
1051
1052 /* Called in child after a fork()       */
1053 void GC_fork_child_proc(void)
1054 {
1055     /* Clean up the thread table, so that just our thread is left. */
1056 #   if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC)
1057       GC_release_mark_lock();
1058 #   endif
1059     GC_remove_all_threads_but_me();
1060 #   ifdef PARALLEL_MARK
1061       /* Turn off parallel marking in the child, since we are probably  */
1062       /* just going to exec, and we would have to restart mark threads. */
1063         GC_markers = 1;
1064         GC_parallel = FALSE;
1065 #   endif /* PARALLEL_MARK */
1066     UNLOCK();
1067 }
1068 #endif /* HANDLE_FORK */
1069
1070 #if defined(GC_DGUX386_THREADS)
1071 /* Return the number of processors, or i<= 0 if it can't be determined. */
1072 int GC_get_nprocs()
1073 {
1074     /* <takis@XFree86.Org> */
1075     int numCpus;
1076     struct dg_sys_info_pm_info pm_sysinfo;
1077     int status =0;
1078
1079     status = dg_sys_info((long int *) &pm_sysinfo,
1080         DG_SYS_INFO_PM_INFO_TYPE, DG_SYS_INFO_PM_CURRENT_VERSION);
1081     if (status < 0)
1082        /* set -1 for error */
1083        numCpus = -1;
1084     else
1085       /* Active CPUs */
1086       numCpus = pm_sysinfo.idle_vp_count;
1087
1088 #  ifdef DEBUG_THREADS
1089     GC_printf1("Number of active CPUs in this system: %d\n", numCpus);
1090 #  endif
1091     return(numCpus);
1092 }
1093 #endif /* GC_DGUX386_THREADS */
1094
1095 /* We hold the allocation lock. */
1096 void GC_thr_init()
1097 {
1098 #   ifndef GC_DARWIN_THREADS
1099       int dummy;
1100 #   endif
1101     GC_thread t;
1102
1103     if (GC_thr_initialized) return;
1104     GC_thr_initialized = TRUE;
1105
1106 #   ifdef HANDLE_FORK
1107       /* Prepare for a possible fork.   */
1108         pthread_atfork(GC_fork_prepare_proc, GC_fork_parent_proc,
1109                        GC_fork_child_proc);
1110 #   endif /* HANDLE_FORK */
1111     /* Add the initial thread, so we can stop it.       */
1112       t = GC_new_thread(pthread_self());
1113 #     ifdef GC_DARWIN_THREADS
1114          t -> stop_info.mach_thread = mach_thread_self();
1115 #     else
1116          t -> stop_info.stack_ptr = (ptr_t)(&dummy);
1117 #     endif
1118       t -> flags = DETACHED | MAIN_THREAD;
1119                  if (pthread_self () == main_pthread_self) {
1120                          t->stack = main_stack;
1121                          t->stack_size = main_stack_size;
1122                          t->altstack = main_altstack;
1123                          t->altstack_size = main_altstack_size;
1124                  }
1125
1126     GC_stop_init();
1127
1128     /* Set GC_nprocs.  */
1129       {
1130         char * nprocs_string = GETENV("GC_NPROCS");
1131         GC_nprocs = -1;
1132         if (nprocs_string != NULL) GC_nprocs = atoi(nprocs_string);
1133       }
1134       if (GC_nprocs <= 0) {
1135 #       if defined(GC_HPUX_THREADS)
1136           GC_nprocs = pthread_num_processors_np();
1137 #       endif
1138 #       if defined(GC_OSF1_THREADS) || defined(GC_AIX_THREADS)
1139           GC_nprocs = sysconf(_SC_NPROCESSORS_ONLN);
1140           if (GC_nprocs <= 0) GC_nprocs = 1;
1141 #       endif
1142 #       if defined(GC_IRIX_THREADS)
1143           GC_nprocs = sysconf(_SC_NPROC_ONLN);
1144           if (GC_nprocs <= 0) GC_nprocs = 1;
1145 #       endif
1146 #       if defined(GC_DARWIN_THREADS) || defined(GC_FREEBSD_THREADS) || defined(GC_NETBSD_THREADS) || defined(GC_OPENBSD_THREADS)
1147           int ncpus = 1;
1148           size_t len = sizeof(ncpus);
1149           sysctl((int[2]) {CTL_HW, HW_NCPU}, 2, &ncpus, &len, NULL, 0);
1150           GC_nprocs = ncpus;
1151 #       endif
1152 #       if defined(GC_LINUX_THREADS) || defined(GC_DGUX386_THREADS)
1153           GC_nprocs = GC_get_nprocs();
1154 #       endif
1155       }
1156       if (GC_nprocs <= 0) {
1157         WARN("GC_get_nprocs() returned %ld\n", GC_nprocs);
1158         GC_nprocs = 2;
1159 #       ifdef PARALLEL_MARK
1160           GC_markers = 1;
1161 #       endif
1162       } else {
1163 #       ifdef PARALLEL_MARK
1164           {
1165             char * markers_string = GETENV("GC_MARKERS");
1166             if (markers_string != NULL) {
1167               GC_markers = atoi(markers_string);
1168             } else {
1169               GC_markers = GC_nprocs;
1170                   if (GC_markers > MAX_MARKERS)
1171                           GC_markers = MAX_MARKERS;
1172             }
1173           }
1174 #       endif
1175       }
1176 #   ifdef PARALLEL_MARK
1177 #     ifdef CONDPRINT
1178         if (GC_print_stats) {
1179           GC_printf2("Number of processors = %ld, "
1180                  "number of marker threads = %ld\n", GC_nprocs, GC_markers);
1181         }
1182 #     endif
1183       if (GC_markers == 1) {
1184         GC_parallel = FALSE;
1185 #       ifdef CONDPRINT
1186           if (GC_print_stats) {
1187             GC_printf0("Single marker thread, turning off parallel marking\n");
1188           }
1189 #       endif
1190       } else {
1191         GC_parallel = TRUE;
1192         /* Disable true incremental collection, but generational is OK. */
1193         GC_time_limit = GC_TIME_UNLIMITED;
1194       }
1195       /* If we are using a parallel marker, actually start helper threads.  */
1196         if (GC_parallel) start_mark_threads();
1197 #   endif
1198 }
1199
1200
1201 /* Perform all initializations, including those that    */
1202 /* may require allocation.                              */
1203 /* Called without allocation lock.                      */
1204 /* Must be called before a second thread is created.    */
1205 /* Called without allocation lock.                      */
1206 void GC_init_parallel()
1207 {
1208     if (parallel_initialized) return;
1209     parallel_initialized = TRUE;
1210
1211     /* GC_init() calls us back, so set flag first.      */
1212     if (!GC_is_initialized) GC_init();
1213     /* Initialize thread local free lists if used.      */
1214 #   if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
1215       LOCK();
1216       GC_init_thread_local(GC_lookup_thread(pthread_self()));
1217       UNLOCK();
1218 #   endif
1219 }
1220
1221
1222 #if !defined(GC_DARWIN_THREADS) && !defined(GC_OPENBSD_THREADS)
1223 #ifndef NACL
1224 int WRAP_FUNC(pthread_sigmask)(int how, const sigset_t *set, sigset_t *oset)
1225 {
1226     sigset_t fudged_set;
1227
1228     if (set != NULL && (how == SIG_BLOCK || how == SIG_SETMASK)) {
1229         fudged_set = *set;
1230         sigdelset(&fudged_set, SIG_SUSPEND);
1231         set = &fudged_set;
1232     }
1233     return(REAL_FUNC(pthread_sigmask)(how, set, oset));
1234 }
1235 #endif
1236 #endif /* !GC_DARWIN_THREADS */
1237
1238 /* Wrappers for functions that are likely to block for an appreciable   */
1239 /* length of time.  Must be called in pairs, if at all.                 */
1240 /* Nothing much beyond the system call itself should be executed        */
1241 /* between these.                                                       */
1242
1243 void GC_start_blocking(void) {
1244 #   define SP_SLOP 128
1245     GC_thread me;
1246     LOCK();
1247     me = GC_lookup_thread(pthread_self());
1248     GC_ASSERT(!(me -> thread_blocked));
1249 #   ifdef SPARC
1250         me -> stop_info.stack_ptr = (ptr_t)GC_save_regs_in_stack();
1251 #   else
1252 #   ifndef GC_DARWIN_THREADS
1253         me -> stop_info.stack_ptr = (ptr_t)GC_approx_sp();
1254 #   endif
1255 #   endif
1256 #   ifdef IA64
1257         me -> backing_store_ptr = (ptr_t)GC_save_regs_in_stack() + SP_SLOP;
1258 #   endif
1259     /* Add some slop to the stack pointer, since the wrapped call may   */
1260     /* end up pushing more callee-save registers.                       */
1261 #   ifndef GC_DARWIN_THREADS
1262 #   ifdef STACK_GROWS_UP
1263         me -> stop_info.stack_ptr += SP_SLOP;
1264 #   else
1265         me -> stop_info.stack_ptr -= SP_SLOP;
1266 #   endif
1267 #   endif
1268     me -> thread_blocked = TRUE;
1269     UNLOCK();
1270 }
1271
1272 void GC_end_blocking(void) {
1273     GC_thread me;
1274     LOCK();   /* This will block if the world is stopped.       */
1275     me = GC_lookup_thread(pthread_self());
1276     GC_ASSERT(me -> thread_blocked);
1277     me -> thread_blocked = FALSE;
1278     UNLOCK();
1279 }
1280
1281 #if defined(GC_DGUX386_THREADS)
1282 #define __d10_sleep sleep
1283 #endif /* GC_DGUX386_THREADS */
1284
1285 /* A wrapper for the standard C sleep function  */
1286 int WRAP_FUNC(sleep) (unsigned int seconds)
1287 {
1288     int result;
1289
1290     GC_start_blocking();
1291     result = REAL_FUNC(sleep)(seconds);
1292     GC_end_blocking();
1293     return result;
1294 }
1295
1296 struct start_info {
1297     void *(*start_routine)(void *);
1298     void *arg;
1299     word flags;
1300     sem_t registered;           /* 1 ==> in our thread table, but       */
1301                                 /* parent hasn't yet noticed.           */
1302 };
1303
1304 /* Called at thread exit.                               */
1305 /* Never called for main thread.  That's OK, since it   */
1306 /* results in at most a tiny one-time leak.  And        */
1307 /* linuxthreads doesn't reclaim the main threads        */
1308 /* resources or id anyway.                              */
1309 void GC_thread_exit_proc(void *arg)
1310 {
1311     GC_thread me;
1312
1313     LOCK();
1314     me = GC_lookup_thread(pthread_self());
1315     GC_destroy_thread_local(me);
1316     if (me -> flags & DETACHED) {
1317 # ifdef THREAD_LOCAL_ALLOC
1318                 /* NULL out the tls key to prevent the dtor function from being called */
1319                 if (0 != GC_setspecific(GC_thread_key, NULL))
1320                         ABORT("Failed to set thread specific allocation pointers");
1321 #endif
1322         GC_delete_thread(pthread_self());
1323     } else {
1324         me -> flags |= FINISHED;
1325     }
1326 #   if defined(THREAD_LOCAL_ALLOC) && !defined(USE_PTHREAD_SPECIFIC) \
1327        && !defined(USE_COMPILER_TLS) && !defined(DBG_HDRS_ALL)
1328       GC_remove_specific(GC_thread_key);
1329 #   endif
1330     /* The following may run the GC from "nonexistent" thread.  */
1331     GC_wait_for_gc_completion(FALSE);
1332     UNLOCK();
1333 }
1334
1335 int WRAP_FUNC(pthread_join)(pthread_t thread, void **retval)
1336 {
1337     int result;
1338     GC_thread thread_gc_id;
1339
1340     LOCK();
1341     thread_gc_id = GC_lookup_thread(thread);
1342     /* This is guaranteed to be the intended one, since the thread id   */
1343     /* cant have been recycled by pthreads.                             */
1344     UNLOCK();
1345     result = REAL_FUNC(pthread_join)(thread, retval);
1346 # if defined (GC_FREEBSD_THREADS)
1347     /* On FreeBSD, the wrapped pthread_join() sometimes returns (what
1348        appears to be) a spurious EINTR which caused the test and real code
1349        to gratuitously fail.  Having looked at system pthread library source
1350        code, I see how this return code may be generated.  In one path of
1351        code, pthread_join() just returns the errno setting of the thread
1352        being joined.  This does not match the POSIX specification or the
1353        local man pages thus I have taken the liberty to catch this one
1354        spurious return value properly conditionalized on GC_FREEBSD_THREADS. */
1355     if (result == EINTR) result = 0;
1356 # endif
1357     if (result == 0) {
1358         LOCK();
1359         /* Here the pthread thread id may have been recycled. */
1360         GC_delete_gc_thread(thread, thread_gc_id);
1361         UNLOCK();
1362     }
1363     return result;
1364 }
1365
1366 #ifdef NACL
1367 /* TODO: remove, NaCl glibc now supports pthread cleanup functions. */
1368 void
1369 WRAP_FUNC(pthread_exit)(void *status)
1370 {
1371     REAL_FUNC(pthread_exit)(status);
1372 }
1373 #endif
1374
1375 int
1376 WRAP_FUNC(pthread_detach)(pthread_t thread)
1377 {
1378     int result;
1379     GC_thread thread_gc_id;
1380
1381     LOCK();
1382     thread_gc_id = GC_lookup_thread(thread);
1383     UNLOCK();
1384     result = REAL_FUNC(pthread_detach)(thread);
1385     if (result == 0) {
1386       LOCK();
1387       thread_gc_id -> flags |= DETACHED;
1388       /* Here the pthread thread id may have been recycled. */
1389       if (thread_gc_id -> flags & FINISHED) {
1390         GC_delete_gc_thread(thread, thread_gc_id);
1391       }
1392       UNLOCK();
1393     }
1394     return result;
1395 }
1396
1397 GC_bool GC_in_thread_creation = FALSE;
1398
1399 typedef void *(*ThreadStartFn)(void *);
1400 void * GC_start_routine_head(void * arg, void *base_addr,
1401                              ThreadStartFn *start, void **start_arg )
1402 {
1403     struct start_info * si = arg;
1404     void * result;
1405     GC_thread me;
1406     pthread_t my_pthread;
1407
1408     my_pthread = pthread_self();
1409 #   ifdef DEBUG_THREADS
1410         GC_printf1("Starting thread 0x%lx\n", my_pthread);
1411         GC_printf1("pid = %ld\n", (long) getpid());
1412         GC_printf1("sp = 0x%lx\n", (long) &arg);
1413 #   endif
1414     LOCK();
1415     GC_in_thread_creation = TRUE;
1416     me = GC_new_thread(my_pthread);
1417     GC_in_thread_creation = FALSE;
1418 #ifdef GC_DARWIN_THREADS
1419     me -> stop_info.mach_thread = mach_thread_self();
1420 #else
1421     me -> stop_info.stack_ptr = 0;
1422 #endif
1423     me -> flags = si -> flags;
1424     /* me -> stack_end = GC_linux_stack_base(); -- currently (11/99)    */
1425     /* doesn't work because the stack base in /proc/self/stat is the    */
1426     /* one for the main thread.  There is a strong argument that that's */
1427     /* a kernel bug, but a pervasive one.                               */
1428 #   ifdef STACK_GROWS_DOWN
1429       me -> stack_end = (ptr_t)(((word)(base_addr) + (GC_page_size - 1))
1430                                 & ~(GC_page_size - 1));
1431 #         ifndef GC_DARWIN_THREADS
1432         me -> stop_info.stack_ptr = me -> stack_end - 0x10;
1433 #         endif
1434         /* Needs to be plausible, since an asynchronous stack mark      */
1435         /* should not crash.                                            */
1436 #   else
1437       me -> stack_end = (ptr_t)((word)(base_addr) & ~(GC_page_size - 1));
1438       me -> stop_info.stack_ptr = me -> stack_end + 0x10;
1439 #   endif
1440     /* This is dubious, since we may be more than a page into the stack, */
1441     /* and hence skip some of it, though it's not clear that matters.    */
1442 #   ifdef IA64
1443       me -> backing_store_end = (ptr_t)
1444                         (GC_save_regs_in_stack() & ~(GC_page_size - 1));
1445       /* This is also < 100% convincing.  We should also read this      */
1446       /* from /proc, but the hook to do so isn't there yet.             */
1447 #   endif /* IA64 */
1448     UNLOCK();
1449
1450     if (start) *start = si -> start_routine;
1451     if (start_arg) *start_arg = si -> arg;
1452
1453         if (!(si->flags & FOREIGN_THREAD))
1454                 sem_post(&(si -> registered));  /* Last action on si.   */
1455                                         /* OK to deallocate.    */
1456 #   if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
1457         LOCK();
1458         GC_init_thread_local(me);
1459         UNLOCK();
1460 #   endif
1461
1462     return me;
1463 }
1464
1465 void GC_allow_register_threads (void)
1466 {
1467     /* No-op for GC pre-v7. */
1468 }
1469
1470 int GC_register_my_thread (struct GC_stack_base *sb)
1471 {
1472     struct start_info si = { 0, }; /* stacked for legibility & locking */
1473     GC_thread me;
1474
1475 #   ifdef DEBUG_THREADS
1476         GC_printf1( "GC_register_my_thread %p\n", &si );
1477 #   endif
1478
1479     si.flags = FOREIGN_THREAD;
1480
1481     if (!parallel_initialized) GC_init_parallel();
1482     LOCK();
1483     if (!GC_thr_initialized) GC_thr_init();
1484     me = GC_lookup_thread(pthread_self());
1485     UNLOCK();
1486     if (me != NULL)
1487         return GC_DUPLICATE;
1488
1489     (void)GC_start_routine_head(&si, sb -> mem_base, NULL, NULL);
1490     return GC_SUCCESS;
1491 }
1492
1493 void * GC_start_routine(void * arg)
1494 {
1495     int dummy;
1496     struct start_info * si = arg;
1497     void * result;
1498     GC_thread me;
1499     ThreadStartFn start;
1500     void *start_arg;
1501
1502     me = GC_start_routine_head (arg, &dummy, &start, &start_arg);
1503
1504     pthread_cleanup_push(GC_thread_exit_proc, 0);
1505 #   ifdef DEBUG_THREADS
1506         GC_printf1("start_routine = 0x%lx\n", start);
1507 #   endif
1508     result = (*start)(start_arg);
1509 #if DEBUG_THREADS
1510         GC_printf1("Finishing thread 0x%x\n", pthread_self());
1511 #endif
1512     me -> status = result;
1513     pthread_cleanup_pop(1);
1514     /* Cleanup acquires lock, ensuring that we can't exit               */
1515     /* while a collection that thinks we're alive is trying to stop     */
1516     /* us.                                                              */
1517     return(result);
1518 }
1519
1520 int
1521 WRAP_FUNC(pthread_create)(pthread_t *new_thread,
1522                   const pthread_attr_t *attr,
1523                   void *(*start_routine)(void *), void *arg)
1524 {
1525     int result;
1526     int detachstate;
1527     word my_flags = 0;
1528     struct start_info * si;
1529         /* This is otherwise saved only in an area mmapped by the thread */
1530         /* library, which isn't visible to the collector.                */
1531
1532     /* We resist the temptation to muck with the stack size here,       */
1533     /* even if the default is unreasonably small.  That's the client's  */
1534     /* responsibility.                                                  */
1535
1536     LOCK();
1537     si = (struct start_info *)GC_INTERNAL_MALLOC(sizeof(struct start_info),
1538                                                  NORMAL);
1539     UNLOCK();
1540     if (!parallel_initialized) GC_init_parallel();
1541     if (0 == si) return(ENOMEM);
1542     sem_init(&(si -> registered), 0, 0);
1543     si -> start_routine = start_routine;
1544     si -> arg = arg;
1545     LOCK();
1546     if (!GC_thr_initialized) GC_thr_init();
1547 #   ifdef GC_ASSERTIONS
1548       {
1549         size_t stack_size;
1550         if (NULL == attr) {
1551            pthread_attr_t my_attr;
1552            pthread_attr_init(&my_attr);
1553            pthread_attr_getstacksize(&my_attr, &stack_size);
1554         } else {
1555            pthread_attr_getstacksize(attr, &stack_size);
1556         }
1557 #       ifdef PARALLEL_MARK
1558           GC_ASSERT(stack_size >= (8*HBLKSIZE*sizeof(word)));
1559 #       else
1560           /* FreeBSD-5.3/Alpha: default pthread stack is 64K,   */
1561           /* HBLKSIZE=8192, sizeof(word)=8                      */
1562           GC_ASSERT(stack_size >= 65536);
1563 #       endif
1564         /* Our threads may need to do some work for the GC.     */
1565         /* Ridiculously small threads won't work, and they      */
1566         /* probably wouldn't work anyway.                       */
1567       }
1568 #   endif
1569     if (NULL == attr) {
1570         detachstate = PTHREAD_CREATE_JOINABLE;
1571     } else {
1572         pthread_attr_getdetachstate(attr, &detachstate);
1573     }
1574     if (PTHREAD_CREATE_DETACHED == detachstate) my_flags |= DETACHED;
1575     si -> flags = my_flags;
1576     UNLOCK();
1577 #   ifdef DEBUG_THREADS
1578         GC_printf1("About to start new thread from thread 0x%X\n",
1579                    pthread_self());
1580 #   endif
1581
1582     result = REAL_FUNC(pthread_create)(new_thread, attr, GC_start_routine, si);
1583
1584 #   ifdef DEBUG_THREADS
1585         GC_printf1("Started thread 0x%X\n", *new_thread);
1586 #   endif
1587     /* Wait until child has been added to the thread table.             */
1588     /* This also ensures that we hold onto si until the child is done   */
1589     /* with it.  Thus it doesn't matter whether it is otherwise         */
1590     /* visible to the collector.                                        */
1591     if (0 == result) {
1592         while (0 != sem_wait(&(si -> registered))) {
1593             if (EINTR != errno) ABORT("sem_wait failed");
1594         }
1595     }
1596     sem_destroy(&(si -> registered));
1597     LOCK();
1598     GC_INTERNAL_FREE(si);
1599     UNLOCK();
1600
1601     return(result);
1602 }
1603
1604 #ifdef GENERIC_COMPARE_AND_SWAP
1605   pthread_mutex_t GC_compare_and_swap_lock = PTHREAD_MUTEX_INITIALIZER;
1606
1607   GC_bool GC_compare_and_exchange(volatile GC_word *addr,
1608                                   GC_word old, GC_word new_val)
1609   {
1610     GC_bool result;
1611     pthread_mutex_lock(&GC_compare_and_swap_lock);
1612     if (*addr == old) {
1613       *addr = new_val;
1614       result = TRUE;
1615     } else {
1616       result = FALSE;
1617     }
1618     pthread_mutex_unlock(&GC_compare_and_swap_lock);
1619     return result;
1620   }
1621
1622   GC_word GC_atomic_add(volatile GC_word *addr, GC_word how_much)
1623   {
1624     GC_word old;
1625     pthread_mutex_lock(&GC_compare_and_swap_lock);
1626     old = *addr;
1627     *addr = old + how_much;
1628     pthread_mutex_unlock(&GC_compare_and_swap_lock);
1629     return old;
1630   }
1631
1632 #endif /* GENERIC_COMPARE_AND_SWAP */
1633 /* Spend a few cycles in a way that can't introduce contention with     */
1634 /* othre threads.                                                       */
1635 void GC_pause()
1636 {
1637     int i;
1638 #   if !defined(__GNUC__) || defined(__INTEL_COMPILER)
1639       volatile word dummy = 0;
1640 #   endif
1641
1642     for (i = 0; i < 10; ++i) {
1643 #     if defined(__GNUC__) && !defined(__INTEL_COMPILER)
1644         __asm__ __volatile__ (" " : : : "memory");
1645 #     else
1646         /* Something that's unlikely to be optimized away. */
1647         GC_noop(++dummy);
1648 #     endif
1649     }
1650 }
1651
1652 #define SPIN_MAX 128    /* Maximum number of calls to GC_pause before   */
1653                         /* give up.                                     */
1654
1655 VOLATILE GC_bool GC_collecting = 0;
1656                         /* A hint that we're in the collector and       */
1657                         /* holding the allocation lock for an           */
1658                         /* extended period.                             */
1659
1660 #if !defined(USE_SPIN_LOCK) || defined(PARALLEL_MARK)
1661 /* If we don't want to use the below spinlock implementation, either    */
1662 /* because we don't have a GC_test_and_set implementation, or because   */
1663 /* we don't want to risk sleeping, we can still try spinning on         */
1664 /* pthread_mutex_trylock for a while.  This appears to be very          */
1665 /* beneficial in many cases.                                            */
1666 /* I suspect that under high contention this is nearly always better    */
1667 /* than the spin lock.  But it's a bit slower on a uniprocessor.        */
1668 /* Hence we still default to the spin lock.                             */
1669 /* This is also used to acquire the mark lock for the parallel          */
1670 /* marker.                                                              */
1671
1672 /* Here we use a strict exponential backoff scheme.  I don't know       */
1673 /* whether that's better or worse than the above.  We eventually        */
1674 /* yield by calling pthread_mutex_lock(); it never makes sense to       */
1675 /* explicitly sleep.                                                    */
1676
1677 #define LOCK_STATS
1678 #ifdef LOCK_STATS
1679   unsigned long GC_spin_count = 0;
1680   unsigned long GC_block_count = 0;
1681   unsigned long GC_unlocked_count = 0;
1682 #endif
1683
1684 void GC_generic_lock(pthread_mutex_t * lock)
1685 {
1686 #ifndef NO_PTHREAD_TRYLOCK
1687     unsigned pause_length = 1;
1688     unsigned i;
1689
1690     if (0 == pthread_mutex_trylock(lock)) {
1691 #       ifdef LOCK_STATS
1692             ++GC_unlocked_count;
1693 #       endif
1694         return;
1695     }
1696     for (; pause_length <= SPIN_MAX; pause_length <<= 1) {
1697         for (i = 0; i < pause_length; ++i) {
1698             GC_pause();
1699         }
1700         switch(pthread_mutex_trylock(lock)) {
1701             case 0:
1702 #               ifdef LOCK_STATS
1703                     ++GC_spin_count;
1704 #               endif
1705                 return;
1706             case EBUSY:
1707                 break;
1708             default:
1709                 ABORT("Unexpected error from pthread_mutex_trylock");
1710         }
1711     }
1712 #endif /* !NO_PTHREAD_TRYLOCK */
1713 #   ifdef LOCK_STATS
1714         ++GC_block_count;
1715 #   endif
1716     pthread_mutex_lock(lock);
1717 }
1718
1719 #endif /* !USE_SPIN_LOCK || PARALLEL_MARK */
1720
1721 #if defined(USE_SPIN_LOCK)
1722
1723 /* Reasonably fast spin locks.  Basically the same implementation */
1724 /* as STL alloc.h.  This isn't really the right way to do this.   */
1725 /* but until the POSIX scheduling mess gets straightened out ...  */
1726
1727 volatile unsigned int GC_allocate_lock = 0;
1728
1729
1730 void GC_lock()
1731 {
1732 #   define low_spin_max 30  /* spin cycles if we suspect uniprocessor */
1733 #   define high_spin_max SPIN_MAX /* spin cycles for multiprocessor */
1734     static unsigned spin_max = low_spin_max;
1735     unsigned my_spin_max;
1736     static unsigned last_spins = 0;
1737     unsigned my_last_spins;
1738     int i;
1739
1740     if (!GC_test_and_set(&GC_allocate_lock)) {
1741         return;
1742     }
1743     my_spin_max = spin_max;
1744     my_last_spins = last_spins;
1745     for (i = 0; i < my_spin_max; i++) {
1746         if (GC_collecting || GC_nprocs == 1) goto yield;
1747         if (i < my_last_spins/2 || GC_allocate_lock) {
1748             GC_pause();
1749             continue;
1750         }
1751         if (!GC_test_and_set(&GC_allocate_lock)) {
1752             /*
1753              * got it!
1754              * Spinning worked.  Thus we're probably not being scheduled
1755              * against the other process with which we were contending.
1756              * Thus it makes sense to spin longer the next time.
1757              */
1758             last_spins = i;
1759             spin_max = high_spin_max;
1760             return;
1761         }
1762     }
1763     /* We are probably being scheduled against the other process.  Sleep. */
1764     spin_max = low_spin_max;
1765 yield:
1766     for (i = 0;; ++i) {
1767         if (!GC_test_and_set(&GC_allocate_lock)) {
1768             return;
1769         }
1770 #       define SLEEP_THRESHOLD 12
1771                 /* Under Linux very short sleeps tend to wait until     */
1772                 /* the current time quantum expires.  On old Linux      */
1773                 /* kernels nanosleep(<= 2ms) just spins under Linux.    */
1774                 /* (Under 2.4, this happens only for real-time          */
1775                 /* processes.)  We want to minimize both behaviors      */
1776                 /* here.                                                */
1777         if (i < SLEEP_THRESHOLD) {
1778             sched_yield();
1779         } else {
1780             struct timespec ts;
1781
1782             if (i > 24) i = 24;
1783                         /* Don't wait for more than about 15msecs, even */
1784                         /* under extreme contention.                    */
1785             ts.tv_sec = 0;
1786             ts.tv_nsec = 1 << i;
1787             nanosleep(&ts, 0);
1788         }
1789     }
1790 }
1791
1792 #else  /* !USE_SPINLOCK */
1793 void GC_lock()
1794 {
1795 #ifndef NO_PTHREAD_TRYLOCK
1796     if (1 == GC_nprocs || GC_collecting) {
1797         pthread_mutex_lock(&GC_allocate_ml);
1798     } else {
1799         GC_generic_lock(&GC_allocate_ml);
1800     }
1801 #else  /* !NO_PTHREAD_TRYLOCK */
1802     pthread_mutex_lock(&GC_allocate_ml);
1803 #endif /* !NO_PTHREAD_TRYLOCK */
1804 }
1805
1806 #endif /* !USE_SPINLOCK */
1807
1808 #if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC)
1809
1810 #ifdef GC_ASSERTIONS
1811   pthread_t GC_mark_lock_holder = NO_THREAD;
1812 #endif
1813
1814 #if 0
1815   /* Ugly workaround for a linux threads bug in the final versions      */
1816   /* of glibc2.1.  Pthread_mutex_trylock sets the mutex owner           */
1817   /* field even when it fails to acquire the mutex.  This causes        */
1818   /* pthread_cond_wait to die.  Remove for glibc2.2.                    */
1819   /* According to the man page, we should use                           */
1820   /* PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP, but that isn't actually   */
1821   /* defined.                                                           */
1822   static pthread_mutex_t mark_mutex =
1823         {0, 0, 0, PTHREAD_MUTEX_ERRORCHECK_NP, {0, 0}};
1824 #else
1825   static pthread_mutex_t mark_mutex = PTHREAD_MUTEX_INITIALIZER;
1826 #endif
1827
1828 static pthread_cond_t builder_cv = PTHREAD_COND_INITIALIZER;
1829
1830 void GC_acquire_mark_lock()
1831 {
1832 /*
1833     if (pthread_mutex_lock(&mark_mutex) != 0) {
1834         ABORT("pthread_mutex_lock failed");
1835     }
1836 */
1837     GC_generic_lock(&mark_mutex);
1838 #   ifdef GC_ASSERTIONS
1839         GC_mark_lock_holder = pthread_self();
1840 #   endif
1841 }
1842
1843 void GC_release_mark_lock()
1844 {
1845     GC_ASSERT(GC_mark_lock_holder == pthread_self());
1846 #   ifdef GC_ASSERTIONS
1847         GC_mark_lock_holder = NO_THREAD;
1848 #   endif
1849     if (pthread_mutex_unlock(&mark_mutex) != 0) {
1850         ABORT("pthread_mutex_unlock failed");
1851     }
1852 }
1853
1854 /* Collector must wait for a freelist builders for 2 reasons:           */
1855 /* 1) Mark bits may still be getting examined without lock.             */
1856 /* 2) Partial free lists referenced only by locals may not be scanned   */
1857 /*    correctly, e.g. if they contain "pointer-free" objects, since the */
1858 /*    free-list link may be ignored.                                    */
1859 void GC_wait_builder()
1860 {
1861     GC_ASSERT(GC_mark_lock_holder == pthread_self());
1862 #   ifdef GC_ASSERTIONS
1863         GC_mark_lock_holder = NO_THREAD;
1864 #   endif
1865     if (pthread_cond_wait(&builder_cv, &mark_mutex) != 0) {
1866         ABORT("pthread_cond_wait failed");
1867     }
1868     GC_ASSERT(GC_mark_lock_holder == NO_THREAD);
1869 #   ifdef GC_ASSERTIONS
1870         GC_mark_lock_holder = pthread_self();
1871 #   endif
1872 }
1873
1874 void GC_wait_for_reclaim()
1875 {
1876     GC_acquire_mark_lock();
1877     while (GC_fl_builder_count > 0) {
1878         GC_wait_builder();
1879     }
1880     GC_release_mark_lock();
1881 }
1882
1883 void GC_notify_all_builder()
1884 {
1885     GC_ASSERT(GC_mark_lock_holder == pthread_self());
1886     if (pthread_cond_broadcast(&builder_cv) != 0) {
1887         ABORT("pthread_cond_broadcast failed");
1888     }
1889 }
1890
1891 #endif /* PARALLEL_MARK || THREAD_LOCAL_ALLOC */
1892
1893 #ifdef PARALLEL_MARK
1894
1895 static pthread_cond_t mark_cv = PTHREAD_COND_INITIALIZER;
1896
1897 void GC_wait_marker()
1898 {
1899     GC_ASSERT(GC_mark_lock_holder == pthread_self());
1900 #   ifdef GC_ASSERTIONS
1901         GC_mark_lock_holder = NO_THREAD;
1902 #   endif
1903     if (pthread_cond_wait(&mark_cv, &mark_mutex) != 0) {
1904         ABORT("pthread_cond_wait failed");
1905     }
1906     GC_ASSERT(GC_mark_lock_holder == NO_THREAD);
1907 #   ifdef GC_ASSERTIONS
1908         GC_mark_lock_holder = pthread_self();
1909 #   endif
1910 }
1911
1912 void GC_notify_all_marker()
1913 {
1914     if (pthread_cond_broadcast(&mark_cv) != 0) {
1915         ABORT("pthread_cond_broadcast failed");
1916     }
1917 }
1918
1919 #endif /* PARALLEL_MARK */
1920
1921 # endif /* GC_LINUX_THREADS and friends */
1922