Annotation of OpenXM_contrib/gc/irix_threads.c, Revision 1.1.1.1
1.1 maekawa 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>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to 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