[BACK]Return to irix_threads.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / gc

Annotation of OpenXM_contrib2/asir2000/gc/irix_threads.c, Revision 1.1

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

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>