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