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