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