Annotation of OpenXM_contrib/gc/linux_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: * Copyright (c) 1998 by Fergus Henderson. 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 LinuxThreads, the clone()-based kernel
17: * thread package for Linux which is included in libc6.
18: *
19: * This code relies on implementation details of LinuxThreads,
20: * (i.e. properties not guaranteed by the Pthread standard):
21: *
22: * - the function GC_linux_thread_top_of_stack(void)
23: * relies on the way LinuxThreads lays out thread stacks
24: * in the address space.
25: *
26: * Note that there is a lot of code duplication between linux_threads.c
27: * and irix_threads.c; any changes made here may need to be reflected
28: * there too.
29: */
30:
31: /* #define DEBUG_THREADS 1 */
32:
33: /* ANSI C requires that a compilation unit contains something */
34: # include "gc_priv.h"
35:
36: # if defined(LINUX_THREADS)
37:
38: # include <pthread.h>
39: # include <time.h>
40: # include <errno.h>
41: # include <unistd.h>
42: # include <sys/mman.h>
43: # include <sys/time.h>
44: # include <semaphore.h>
45:
46: #undef pthread_create
47: #undef pthread_sigmask
48: #undef pthread_join
49:
50: void GC_thr_init();
51:
52: #if 0
53: void GC_print_sig_mask()
54: {
55: sigset_t blocked;
56: int i;
57:
58: if (pthread_sigmask(SIG_BLOCK, NULL, &blocked) != 0)
59: ABORT("pthread_sigmask");
60: GC_printf0("Blocked: ");
61: for (i = 1; i <= MAXSIG; i++) {
62: if (sigismember(&blocked, i)) { GC_printf1("%ld ",(long) i); }
63: }
64: GC_printf0("\n");
65: }
66: #endif
67:
68: /* We use the allocation lock to protect thread-related data structures. */
69:
70: /* The set of all known threads. We intercept thread creation and */
71: /* joins. We never actually create detached threads. We allocate all */
72: /* new thread stacks ourselves. These allow us to maintain this */
73: /* data structure. */
74: /* Protected by GC_thr_lock. */
75: /* Some of this should be declared volatile, but that's incosnsistent */
76: /* with some library routine declarations. */
77: typedef struct GC_Thread_Rep {
78: struct GC_Thread_Rep * next; /* More recently allocated threads */
79: /* with a given pthread id come */
80: /* first. (All but the first are */
81: /* guaranteed to be dead, but we may */
82: /* not yet have registered the join.) */
83: pthread_t id;
84: word flags;
85: # define FINISHED 1 /* Thread has exited. */
86: # define DETACHED 2 /* Thread is intended to be detached. */
87: # define MAIN_THREAD 4 /* True for the original thread only. */
88:
89: ptr_t stack_end;
90: ptr_t stack_ptr; /* Valid only when stopped. */
91: int signal;
92: void * status; /* The value returned from the thread. */
93: /* Used only to avoid premature */
94: /* reclamation of any data it might */
95: /* reference. */
96: } * GC_thread;
97:
98: GC_thread GC_lookup_thread(pthread_t id);
99:
100: /*
101: * The only way to suspend threads given the pthread interface is to send
102: * signals. We can't use SIGSTOP directly, because we need to get the
103: * thread to save its stack pointer in the GC thread table before
104: * suspending. So we have to reserve a signal of our own for this.
105: * This means we have to intercept client calls to change the signal mask.
106: * The linuxthreads package already uses SIGUSR1 and SIGUSR2,
107: * so we need to reuse something else. I chose SIGPWR.
108: * (Perhaps SIGUNUSED would be a better choice.)
109: */
110: #define SIG_SUSPEND SIGPWR
111:
112: #define SIG_RESTART SIGXCPU
113:
114: sem_t GC_suspend_ack_sem;
115:
116: /*
117: GC_linux_thread_top_of_stack() relies on implementation details of
118: LinuxThreads, namely that thread stacks are allocated on 2M boundaries
119: and grow to no more than 2M.
120: To make sure that we're using LinuxThreads and not some other thread
121: package, we generate a dummy reference to `__pthread_initial_thread_bos',
122: which is a symbol defined in LinuxThreads, but (hopefully) not in other
123: thread packages.
124: */
125: extern char * __pthread_initial_thread_bos;
126: char **dummy_var_to_force_linux_threads = &__pthread_initial_thread_bos;
127:
128: #define LINUX_THREADS_STACK_SIZE (2 * 1024 * 1024)
129:
130: static inline ptr_t GC_linux_thread_top_of_stack(void)
131: {
132: char *sp = GC_approx_sp();
133: ptr_t tos = (ptr_t) (((unsigned long)sp | (LINUX_THREADS_STACK_SIZE - 1)) + 1);
134: #if DEBUG_THREADS
135: GC_printf1("SP = %lx\n", (unsigned long)sp);
136: GC_printf1("TOS = %lx\n", (unsigned long)tos);
137: #endif
138: return tos;
139: }
140:
141: void GC_suspend_handler(int sig)
142: {
143: int dummy;
144: pthread_t my_thread = pthread_self();
145: GC_thread me;
146: sigset_t all_sigs;
147: sigset_t old_sigs;
148: int i;
149: sigset_t mask;
150:
151: if (sig != SIG_SUSPEND) ABORT("Bad signal in suspend_handler");
152:
153: #if DEBUG_THREADS
154: GC_printf1("Suspending 0x%x\n", my_thread);
155: #endif
156:
157: me = GC_lookup_thread(my_thread);
158: /* The lookup here is safe, since I'm doing this on behalf */
159: /* of a thread which holds the allocation lock in order */
160: /* to stop the world. Thus concurrent modification of the */
161: /* data structure is impossible. */
162: me -> stack_ptr = (ptr_t)(&dummy);
163: me -> stack_end = GC_linux_thread_top_of_stack();
164:
165: /* Tell the thread that wants to stop the world that this */
166: /* thread has been stopped. Note that sem_post() is */
167: /* the only async-signal-safe primitive in LinuxThreads. */
168: sem_post(&GC_suspend_ack_sem);
169:
170: /* Wait until that thread tells us to restart by sending */
171: /* this thread a SIG_RESTART signal. */
172: /* SIG_RESTART should be masked at this point. Thus there */
173: /* is no race. */
174: if (sigfillset(&mask) != 0) ABORT("sigfillset() failed");
175: if (sigdelset(&mask, SIG_RESTART) != 0) ABORT("sigdelset() failed");
176: do {
177: me->signal = 0;
178: sigsuspend(&mask); /* Wait for signal */
179: } while (me->signal != SIG_RESTART);
180:
181: #if DEBUG_THREADS
182: GC_printf1("Continuing 0x%x\n", my_thread);
183: #endif
184: }
185:
186: void GC_restart_handler(int sig)
187: {
188: GC_thread me;
189:
190: if (sig != SIG_RESTART) ABORT("Bad signal in suspend_handler");
191:
192: /* Let the GC_suspend_handler() know that we got a SIG_RESTART. */
193: /* The lookup here is safe, since I'm doing this on behalf */
194: /* of a thread which holds the allocation lock in order */
195: /* to stop the world. Thus concurrent modification of the */
196: /* data structure is impossible. */
197: me = GC_lookup_thread(pthread_self());
198: me->signal = SIG_RESTART;
199:
200: /*
201: ** Note: even if we didn't do anything useful here,
202: ** it would still be necessary to have a signal handler,
203: ** rather than ignoring the signals, otherwise
204: ** the signals will not be delivered at all, and
205: ** will thus not interrupt the sigsuspend() above.
206: */
207:
208: #if DEBUG_THREADS
209: GC_printf1("In GC_restart_handler for 0x%x\n", pthread_self());
210: #endif
211: }
212:
213: GC_bool GC_thr_initialized = FALSE;
214:
215: # define THREAD_TABLE_SZ 128 /* Must be power of 2 */
216: volatile GC_thread GC_threads[THREAD_TABLE_SZ];
217:
218: /* Add a thread to GC_threads. We assume it wasn't already there. */
219: /* Caller holds allocation lock. */
220: GC_thread GC_new_thread(pthread_t id)
221: {
222: int hv = ((word)id) % THREAD_TABLE_SZ;
223: GC_thread result;
224: static struct GC_Thread_Rep first_thread;
225: static GC_bool first_thread_used = FALSE;
226:
227: if (!first_thread_used) {
228: result = &first_thread;
229: first_thread_used = TRUE;
230: /* Dont acquire allocation lock, since we may already hold it. */
231: } else {
232: result = (struct GC_Thread_Rep *)
233: GC_generic_malloc_inner(sizeof(struct GC_Thread_Rep), NORMAL);
234: }
235: if (result == 0) return(0);
236: result -> id = id;
237: result -> next = GC_threads[hv];
238: GC_threads[hv] = result;
239: /* result -> flags = 0; */
240: return(result);
241: }
242:
243: /* Delete a thread from GC_threads. We assume it is there. */
244: /* (The code intentionally traps if it wasn't.) */
245: /* Caller holds allocation lock. */
246: void GC_delete_thread(pthread_t id)
247: {
248: int hv = ((word)id) % THREAD_TABLE_SZ;
249: register GC_thread p = GC_threads[hv];
250: register GC_thread prev = 0;
251:
252: while (!pthread_equal(p -> id, id)) {
253: prev = p;
254: p = p -> next;
255: }
256: if (prev == 0) {
257: GC_threads[hv] = p -> next;
258: } else {
259: prev -> next = p -> next;
260: }
261: }
262:
263: /* If a thread has been joined, but we have not yet */
264: /* been notified, then there may be more than one thread */
265: /* in the table with the same pthread id. */
266: /* This is OK, but we need a way to delete a specific one. */
267: void GC_delete_gc_thread(pthread_t id, GC_thread gc_id)
268: {
269: int hv = ((word)id) % THREAD_TABLE_SZ;
270: register GC_thread p = GC_threads[hv];
271: register GC_thread prev = 0;
272:
273: while (p != gc_id) {
274: prev = p;
275: p = p -> next;
276: }
277: if (prev == 0) {
278: GC_threads[hv] = p -> next;
279: } else {
280: prev -> next = p -> next;
281: }
282: }
283:
284: /* Return a GC_thread corresponding to a given thread_t. */
285: /* Returns 0 if it's not there. */
286: /* Caller holds allocation lock or otherwise inhibits */
287: /* updates. */
288: /* If there is more than one thread with the given id we */
289: /* return the most recent one. */
290: GC_thread GC_lookup_thread(pthread_t id)
291: {
292: int hv = ((word)id) % THREAD_TABLE_SZ;
293: register GC_thread p = GC_threads[hv];
294:
295: while (p != 0 && !pthread_equal(p -> id, id)) p = p -> next;
296: return(p);
297: }
298:
299: /* Caller holds allocation lock. */
300: void GC_stop_world()
301: {
302: pthread_t my_thread = pthread_self();
303: register int i;
304: register GC_thread p;
305: register int n_live_threads = 0;
306: register int result;
307:
308: for (i = 0; i < THREAD_TABLE_SZ; i++) {
309: for (p = GC_threads[i]; p != 0; p = p -> next) {
310: if (p -> id != my_thread) {
311: if (p -> flags & FINISHED) continue;
312: n_live_threads++;
313: #if DEBUG_THREADS
314: GC_printf1("Sending suspend signal to 0x%x\n", p -> id);
315: #endif
316: result = pthread_kill(p -> id, SIG_SUSPEND);
317: switch(result) {
318: case ESRCH:
319: /* Not really there anymore. Possible? */
320: n_live_threads--;
321: break;
322: case 0:
323: break;
324: default:
325: ABORT("pthread_kill failed");
326: }
327: }
328: }
329: }
330: for (i = 0; i < n_live_threads; i++) {
331: sem_wait(&GC_suspend_ack_sem);
332: }
333: #if DEBUG_THREADS
334: GC_printf1("World stopped 0x%x\n", pthread_self());
335: #endif
336: }
337:
338: /* Caller holds allocation lock. */
339: void GC_start_world()
340: {
341: pthread_t my_thread = pthread_self();
342: register int i;
343: register GC_thread p;
344: register int n_live_threads = 0;
345: register int result;
346:
347: # if DEBUG_THREADS
348: GC_printf0("World starting\n");
349: # endif
350:
351: for (i = 0; i < THREAD_TABLE_SZ; i++) {
352: for (p = GC_threads[i]; p != 0; p = p -> next) {
353: if (p -> id != my_thread) {
354: if (p -> flags & FINISHED) continue;
355: n_live_threads++;
356: #if DEBUG_THREADS
357: GC_printf1("Sending restart signal to 0x%x\n", p -> id);
358: #endif
359: result = pthread_kill(p -> id, SIG_RESTART);
360: switch(result) {
361: case ESRCH:
362: /* Not really there anymore. Possible? */
363: n_live_threads--;
364: break;
365: case 0:
366: break;
367: default:
368: ABORT("pthread_kill failed");
369: }
370: }
371: }
372: }
373: #if DEBUG_THREADS
374: GC_printf0("World started\n");
375: #endif
376: }
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: #if DEBUG_THREADS
389: GC_printf1("Pushing stacks from thread 0x%lx\n", (unsigned long) me);
390: #endif
391: for (i = 0; i < THREAD_TABLE_SZ; i++) {
392: for (p = GC_threads[i]; p != 0; p = p -> next) {
393: if (p -> flags & FINISHED) continue;
394: if (pthread_equal(p -> id, me)) {
395: lo = GC_approx_sp();
396: } else {
397: lo = p -> stack_ptr;
398: }
399: if ((p -> flags & MAIN_THREAD) == 0) {
400: if (pthread_equal(p -> id, me)) {
401: hi = GC_linux_thread_top_of_stack();
402: } else {
403: hi = p -> stack_end;
404: }
405: } else {
406: /* The original stack. */
407: hi = GC_stackbottom;
408: }
409: #if DEBUG_THREADS
410: GC_printf3("Stack for thread 0x%lx = [%lx,%lx)\n",
411: (unsigned long) p -> id,
412: (unsigned long) lo, (unsigned long) hi);
413: #endif
414: GC_push_all_stack(lo, hi);
415: }
416: }
417: }
418:
419:
420: /* We hold the allocation lock. */
421: void GC_thr_init()
422: {
423: GC_thread t;
424: struct sigaction act;
425:
426: if (GC_thr_initialized) return;
427: GC_thr_initialized = TRUE;
428:
429: if (sem_init(&GC_suspend_ack_sem, 0, 0) != 0)
430: ABORT("sem_init failed");
431:
432: act.sa_flags = SA_RESTART;
433: if (sigfillset(&act.sa_mask) != 0) {
434: ABORT("sigfillset() failed");
435: }
436: /* SIG_RESTART is unmasked by the handler when necessary. */
437: act.sa_handler = GC_suspend_handler;
438: if (sigaction(SIG_SUSPEND, &act, NULL) != 0) {
439: ABORT("Cannot set SIG_SUSPEND handler");
440: }
441:
442: act.sa_handler = GC_restart_handler;
443: if (sigaction(SIG_RESTART, &act, NULL) != 0) {
444: ABORT("Cannot set SIG_SUSPEND handler");
445: }
446:
447: /* Add the initial thread, so we can stop it. */
448: t = GC_new_thread(pthread_self());
449: t -> stack_ptr = 0;
450: t -> flags = DETACHED | MAIN_THREAD;
451: }
452:
453: int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset)
454: {
455: sigset_t fudged_set;
456:
457: if (set != NULL && (how == SIG_BLOCK || how == SIG_SETMASK)) {
458: fudged_set = *set;
459: sigdelset(&fudged_set, SIG_SUSPEND);
460: set = &fudged_set;
461: }
462: return(pthread_sigmask(how, set, oset));
463: }
464:
465: struct start_info {
466: void *(*start_routine)(void *);
467: void *arg;
468: word flags;
469: sem_t registered; /* 1 ==> in our thread table, but */
470: /* parent hasn't yet noticed. */
471: };
472:
473:
474: void GC_thread_exit_proc(void *arg)
475: {
476: GC_thread me;
477: struct start_info * si = arg;
478:
479: LOCK();
480: me = GC_lookup_thread(pthread_self());
481: if (me -> flags & DETACHED) {
482: GC_delete_thread(pthread_self());
483: } else {
484: me -> flags |= FINISHED;
485: }
486: UNLOCK();
487: }
488:
489: int GC_pthread_join(pthread_t thread, void **retval)
490: {
491: int result;
492: GC_thread thread_gc_id;
493:
494: LOCK();
495: thread_gc_id = GC_lookup_thread(thread);
496: /* This is guaranteed to be the intended one, since the thread id */
497: /* cant have been recycled by pthreads. */
498: UNLOCK();
499: result = pthread_join(thread, retval);
500: LOCK();
501: /* Here the pthread thread id may have been recycled. */
502: GC_delete_gc_thread(thread, thread_gc_id);
503: UNLOCK();
504: return result;
505: }
506:
507: void * GC_start_routine(void * arg)
508: {
509: struct start_info * si = arg;
510: void * result;
511: GC_thread me;
512: pthread_t my_pthread;
513: void *(*start)(void *);
514: void *start_arg;
515:
516: my_pthread = pthread_self();
517: LOCK();
518: me = GC_new_thread(my_pthread);
519: me -> flags = si -> flags;
520: me -> stack_ptr = 0;
521: me -> stack_end = 0;
522: UNLOCK();
523: start = si -> start_routine;
524: start_arg = si -> arg;
525: sem_post(&(si -> registered));
526: pthread_cleanup_push(GC_thread_exit_proc, si);
527: # ifdef DEBUG_THREADS
528: GC_printf1("Starting thread 0x%lx\n", pthread_self());
529: GC_printf1("pid = %ld\n", (long) getpid());
530: GC_printf1("sp = 0x%lx\n", (long) &arg);
531: GC_printf1("start_routine = 0x%lx\n", start);
532: # endif
533: result = (*start)(start_arg);
534: #if DEBUG_THREADS
535: GC_printf1("Finishing thread 0x%x\n", pthread_self());
536: #endif
537: me -> status = result;
538: me -> flags |= FINISHED;
539: pthread_cleanup_pop(1);
540: /* Cleanup acquires lock, ensuring that we can't exit */
541: /* while a collection that thinks we're alive is trying to stop */
542: /* us. */
543: return(result);
544: }
545:
546: int
547: GC_pthread_create(pthread_t *new_thread,
548: const pthread_attr_t *attr,
549: void *(*start_routine)(void *), void *arg)
550: {
551: int result;
552: GC_thread t;
553: pthread_t my_new_thread;
554: void * stack;
555: size_t stacksize;
556: pthread_attr_t new_attr;
557: int detachstate;
558: word my_flags = 0;
559: struct start_info * si = GC_malloc(sizeof(struct start_info));
560: /* This is otherwise saved only in an area mmapped by the thread */
561: /* library, which isn't visible to the collector. */
562:
563: if (0 == si) return(ENOMEM);
564: sem_init(&(si -> registered), 0, 0);
565: si -> start_routine = start_routine;
566: si -> arg = arg;
567: LOCK();
568: if (!GC_thr_initialized) GC_thr_init();
569: if (NULL == attr) {
570: stack = 0;
571: (void) pthread_attr_init(&new_attr);
572: } else {
573: new_attr = *attr;
574: }
575: pthread_attr_getdetachstate(&new_attr, &detachstate);
576: if (PTHREAD_CREATE_DETACHED == detachstate) my_flags |= DETACHED;
577: si -> flags = my_flags;
578: UNLOCK();
579: result = pthread_create(new_thread, &new_attr, GC_start_routine, si);
580: /* Wait until child has been added to the thread table. */
581: /* This also ensures that we hold onto si until the child is done */
582: /* with it. Thus it doesn't matter whether it is otherwise */
583: /* visible to the collector. */
584: if (0 != sem_wait(&(si -> registered))) ABORT("sem_wait failed");
585: sem_destroy(&(si -> registered));
586: /* pthread_attr_destroy(&new_attr); */
587: /* pthread_attr_destroy(&new_attr); */
588: return(result);
589: }
590:
591: GC_bool GC_collecting = 0;
592: /* A hint that we're in the collector and */
593: /* holding the allocation lock for an */
594: /* extended period. */
595:
596: /* Reasonably fast spin locks. Basically the same implementation */
597: /* as STL alloc.h. This isn't really the right way to do this. */
598: /* but until the POSIX scheduling mess gets straightened out ... */
599:
600: volatile unsigned int GC_allocate_lock = 0;
601:
602:
603: void GC_lock()
604: {
605: # define low_spin_max 30 /* spin cycles if we suspect uniprocessor */
606: # define high_spin_max 1000 /* spin cycles for multiprocessor */
607: static unsigned spin_max = low_spin_max;
608: unsigned my_spin_max;
609: static unsigned last_spins = 0;
610: unsigned my_last_spins;
611: volatile unsigned junk;
612: # define PAUSE junk *= junk; junk *= junk; junk *= junk; junk *= junk
613: int i;
614:
615: if (!GC_test_and_set(&GC_allocate_lock)) {
616: return;
617: }
618: junk = 0;
619: my_spin_max = spin_max;
620: my_last_spins = last_spins;
621: for (i = 0; i < my_spin_max; i++) {
622: if (GC_collecting) goto yield;
623: if (i < my_last_spins/2 || GC_allocate_lock) {
624: PAUSE;
625: continue;
626: }
627: if (!GC_test_and_set(&GC_allocate_lock)) {
628: /*
629: * got it!
630: * Spinning worked. Thus we're probably not being scheduled
631: * against the other process with which we were contending.
632: * Thus it makes sense to spin longer the next time.
633: */
634: last_spins = i;
635: spin_max = high_spin_max;
636: return;
637: }
638: }
639: /* We are probably being scheduled against the other process. Sleep. */
640: spin_max = low_spin_max;
641: yield:
642: for (i = 0;; ++i) {
643: if (!GC_test_and_set(&GC_allocate_lock)) {
644: return;
645: }
646: # define SLEEP_THRESHOLD 12
647: /* nanosleep(<= 2ms) just spins under Linux. We */
648: /* want to be careful to avoid that behavior. */
649: if (i < SLEEP_THRESHOLD) {
650: sched_yield();
651: } else {
652: struct timespec ts;
653:
654: if (i > 26) i = 26;
655: /* Don't wait for more than about 60msecs, even */
656: /* under extreme contention. */
657: ts.tv_sec = 0;
658: ts.tv_nsec = 1 << i;
659: nanosleep(&ts, 0);
660: }
661: }
662: }
663:
664: # endif /* LINUX_THREADS */
665:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to linux_threads.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gc