Annotation of OpenXM_contrib2/asir2000/gc/linux_threads.c, Revision 1.1.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: * 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_kill_other_threads_np'
122: (was `__pthread_initial_thread_bos' but that disappeared),
123: which is a symbol defined in LinuxThreads, but (hopefully) not in other
124: thread packages.
125: */
126: extern char * __pthread_initial_thread_bos;
127: char **dummy_var_to_force_linux_threads = &__pthread_kill_other_threads_np;
128:
129: #define LINUX_THREADS_STACK_SIZE (2 * 1024 * 1024)
130:
131: static inline ptr_t GC_linux_thread_top_of_stack(void)
132: {
133: char *sp = GC_approx_sp();
134: ptr_t tos = (ptr_t) (((unsigned long)sp | (LINUX_THREADS_STACK_SIZE - 1)) + 1);
135: #if DEBUG_THREADS
136: GC_printf1("SP = %lx\n", (unsigned long)sp);
137: GC_printf1("TOS = %lx\n", (unsigned long)tos);
138: #endif
139: return tos;
140: }
141:
142: void GC_suspend_handler(int sig)
143: {
144: int dummy;
145: pthread_t my_thread = pthread_self();
146: GC_thread me;
147: sigset_t all_sigs;
148: sigset_t old_sigs;
149: int i;
150: sigset_t mask;
151:
152: if (sig != SIG_SUSPEND) ABORT("Bad signal in suspend_handler");
153:
154: #if DEBUG_THREADS
155: GC_printf1("Suspending 0x%x\n", my_thread);
156: #endif
157:
158: me = GC_lookup_thread(my_thread);
159: /* The lookup here is safe, since I'm doing this on behalf */
160: /* of a thread which holds the allocation lock in order */
161: /* to stop the world. Thus concurrent modification of the */
162: /* data structure is impossible. */
163: me -> stack_ptr = (ptr_t)(&dummy);
164: me -> stack_end = GC_linux_thread_top_of_stack();
165:
166: /* Tell the thread that wants to stop the world that this */
167: /* thread has been stopped. Note that sem_post() is */
168: /* the only async-signal-safe primitive in LinuxThreads. */
169: sem_post(&GC_suspend_ack_sem);
170:
171: /* Wait until that thread tells us to restart by sending */
172: /* this thread a SIG_RESTART signal. */
173: /* SIG_RESTART should be masked at this point. Thus there */
174: /* is no race. */
175: if (sigfillset(&mask) != 0) ABORT("sigfillset() failed");
176: if (sigdelset(&mask, SIG_RESTART) != 0) ABORT("sigdelset() failed");
177: do {
178: me->signal = 0;
179: sigsuspend(&mask); /* Wait for signal */
180: } while (me->signal != SIG_RESTART);
181:
182: #if DEBUG_THREADS
183: GC_printf1("Continuing 0x%x\n", my_thread);
184: #endif
185: }
186:
187: void GC_restart_handler(int sig)
188: {
189: GC_thread me;
190:
191: if (sig != SIG_RESTART) ABORT("Bad signal in suspend_handler");
192:
193: /* Let the GC_suspend_handler() know that we got a SIG_RESTART. */
194: /* The lookup here is safe, since I'm doing this on behalf */
195: /* of a thread which holds the allocation lock in order */
196: /* to stop the world. Thus concurrent modification of the */
197: /* data structure is impossible. */
198: me = GC_lookup_thread(pthread_self());
199: me->signal = SIG_RESTART;
200:
201: /*
202: ** Note: even if we didn't do anything useful here,
203: ** it would still be necessary to have a signal handler,
204: ** rather than ignoring the signals, otherwise
205: ** the signals will not be delivered at all, and
206: ** will thus not interrupt the sigsuspend() above.
207: */
208:
209: #if DEBUG_THREADS
210: GC_printf1("In GC_restart_handler for 0x%x\n", pthread_self());
211: #endif
212: }
213:
214: GC_bool GC_thr_initialized = FALSE;
215:
216: # define THREAD_TABLE_SZ 128 /* Must be power of 2 */
217: volatile GC_thread GC_threads[THREAD_TABLE_SZ];
218:
219: /* Add a thread to GC_threads. We assume it wasn't already there. */
220: /* Caller holds allocation lock. */
221: GC_thread GC_new_thread(pthread_t id)
222: {
223: int hv = ((word)id) % THREAD_TABLE_SZ;
224: GC_thread result;
225: static struct GC_Thread_Rep first_thread;
226: static GC_bool first_thread_used = FALSE;
227:
228: if (!first_thread_used) {
229: result = &first_thread;
230: first_thread_used = TRUE;
231: /* Dont acquire allocation lock, since we may already hold it. */
232: } else {
233: result = (struct GC_Thread_Rep *)
234: GC_generic_malloc_inner(sizeof(struct GC_Thread_Rep), NORMAL);
235: }
236: if (result == 0) return(0);
237: result -> id = id;
238: result -> next = GC_threads[hv];
239: GC_threads[hv] = result;
240: /* result -> flags = 0; */
241: return(result);
242: }
243:
244: /* Delete a thread from GC_threads. We assume it is there. */
245: /* (The code intentionally traps if it wasn't.) */
246: /* Caller holds allocation lock. */
247: void GC_delete_thread(pthread_t id)
248: {
249: int hv = ((word)id) % THREAD_TABLE_SZ;
250: register GC_thread p = GC_threads[hv];
251: register GC_thread prev = 0;
252:
253: while (!pthread_equal(p -> id, id)) {
254: prev = p;
255: p = p -> next;
256: }
257: if (prev == 0) {
258: GC_threads[hv] = p -> next;
259: } else {
260: prev -> next = p -> next;
261: }
262: }
263:
264: /* If a thread has been joined, but we have not yet */
265: /* been notified, then there may be more than one thread */
266: /* in the table with the same pthread id. */
267: /* This is OK, but we need a way to delete a specific one. */
268: void GC_delete_gc_thread(pthread_t id, GC_thread gc_id)
269: {
270: int hv = ((word)id) % THREAD_TABLE_SZ;
271: register GC_thread p = GC_threads[hv];
272: register GC_thread prev = 0;
273:
274: while (p != gc_id) {
275: prev = p;
276: p = p -> next;
277: }
278: if (prev == 0) {
279: GC_threads[hv] = p -> next;
280: } else {
281: prev -> next = p -> next;
282: }
283: }
284:
285: /* Return a GC_thread corresponding to a given thread_t. */
286: /* Returns 0 if it's not there. */
287: /* Caller holds allocation lock or otherwise inhibits */
288: /* updates. */
289: /* If there is more than one thread with the given id we */
290: /* return the most recent one. */
291: GC_thread GC_lookup_thread(pthread_t id)
292: {
293: int hv = ((word)id) % THREAD_TABLE_SZ;
294: register GC_thread p = GC_threads[hv];
295:
296: while (p != 0 && !pthread_equal(p -> id, id)) p = p -> next;
297: return(p);
298: }
299:
300: /* Caller holds allocation lock. */
301: void GC_stop_world()
302: {
303: pthread_t my_thread = pthread_self();
304: register int i;
305: register GC_thread p;
306: register int n_live_threads = 0;
307: register int result;
308:
309: for (i = 0; i < THREAD_TABLE_SZ; i++) {
310: for (p = GC_threads[i]; p != 0; p = p -> next) {
311: if (p -> id != my_thread) {
312: if (p -> flags & FINISHED) continue;
313: n_live_threads++;
314: #if DEBUG_THREADS
315: GC_printf1("Sending suspend signal to 0x%x\n", p -> id);
316: #endif
317: result = pthread_kill(p -> id, SIG_SUSPEND);
318: switch(result) {
319: case ESRCH:
320: /* Not really there anymore. Possible? */
321: n_live_threads--;
322: break;
323: case 0:
324: break;
325: default:
326: ABORT("pthread_kill failed");
327: }
328: }
329: }
330: }
331: for (i = 0; i < n_live_threads; i++) {
332: sem_wait(&GC_suspend_ack_sem);
333: }
334: #if DEBUG_THREADS
335: GC_printf1("World stopped 0x%x\n", pthread_self());
336: #endif
337: }
338:
339: /* Caller holds allocation lock. */
340: void GC_start_world()
341: {
342: pthread_t my_thread = pthread_self();
343: register int i;
344: register GC_thread p;
345: register int n_live_threads = 0;
346: register int result;
347:
348: # if DEBUG_THREADS
349: GC_printf0("World starting\n");
350: # endif
351:
352: for (i = 0; i < THREAD_TABLE_SZ; i++) {
353: for (p = GC_threads[i]; p != 0; p = p -> next) {
354: if (p -> id != my_thread) {
355: if (p -> flags & FINISHED) continue;
356: n_live_threads++;
357: #if DEBUG_THREADS
358: GC_printf1("Sending restart signal to 0x%x\n", p -> id);
359: #endif
360: result = pthread_kill(p -> id, SIG_RESTART);
361: switch(result) {
362: case ESRCH:
363: /* Not really there anymore. Possible? */
364: n_live_threads--;
365: break;
366: case 0:
367: break;
368: default:
369: ABORT("pthread_kill failed");
370: }
371: }
372: }
373: }
374: #if DEBUG_THREADS
375: GC_printf0("World started\n");
376: #endif
377: }
378:
379: /* We hold allocation lock. We assume the world is stopped. */
380: void GC_push_all_stacks()
381: {
382: register int i;
383: register GC_thread p;
384: register ptr_t sp = GC_approx_sp();
385: register ptr_t lo, hi;
386: pthread_t me = pthread_self();
387:
388: if (!GC_thr_initialized) GC_thr_init();
389: #if DEBUG_THREADS
390: GC_printf1("Pushing stacks from thread 0x%lx\n", (unsigned long) me);
391: #endif
392: for (i = 0; i < THREAD_TABLE_SZ; i++) {
393: for (p = GC_threads[i]; p != 0; p = p -> next) {
394: if (p -> flags & FINISHED) continue;
395: if (pthread_equal(p -> id, me)) {
396: lo = GC_approx_sp();
397: } else {
398: lo = p -> stack_ptr;
399: }
400: if ((p -> flags & MAIN_THREAD) == 0) {
401: if (pthread_equal(p -> id, me)) {
402: hi = GC_linux_thread_top_of_stack();
403: } else {
404: hi = p -> stack_end;
405: }
406: } else {
407: /* The original stack. */
408: hi = GC_stackbottom;
409: }
410: #if DEBUG_THREADS
411: GC_printf3("Stack for thread 0x%lx = [%lx,%lx)\n",
412: (unsigned long) p -> id,
413: (unsigned long) lo, (unsigned long) hi);
414: #endif
415: GC_push_all_stack(lo, hi);
416: }
417: }
418: }
419:
420:
421: /* We hold the allocation lock. */
422: void GC_thr_init()
423: {
424: GC_thread t;
425: struct sigaction act;
426:
427: if (GC_thr_initialized) return;
428: GC_thr_initialized = TRUE;
429:
430: if (sem_init(&GC_suspend_ack_sem, 0, 0) != 0)
431: ABORT("sem_init failed");
432:
433: act.sa_flags = SA_RESTART;
434: if (sigfillset(&act.sa_mask) != 0) {
435: ABORT("sigfillset() failed");
436: }
437: /* SIG_RESTART is unmasked by the handler when necessary. */
438: act.sa_handler = GC_suspend_handler;
439: if (sigaction(SIG_SUSPEND, &act, NULL) != 0) {
440: ABORT("Cannot set SIG_SUSPEND handler");
441: }
442:
443: act.sa_handler = GC_restart_handler;
444: if (sigaction(SIG_RESTART, &act, NULL) != 0) {
445: ABORT("Cannot set SIG_SUSPEND handler");
446: }
447:
448: /* Add the initial thread, so we can stop it. */
449: t = GC_new_thread(pthread_self());
450: t -> stack_ptr = 0;
451: t -> flags = DETACHED | MAIN_THREAD;
452: }
453:
454: int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset)
455: {
456: sigset_t fudged_set;
457:
458: if (set != NULL && (how == SIG_BLOCK || how == SIG_SETMASK)) {
459: fudged_set = *set;
460: sigdelset(&fudged_set, SIG_SUSPEND);
461: set = &fudged_set;
462: }
463: return(pthread_sigmask(how, set, oset));
464: }
465:
466: struct start_info {
467: void *(*start_routine)(void *);
468: void *arg;
469: word flags;
470: sem_t registered; /* 1 ==> in our thread table, but */
471: /* parent hasn't yet noticed. */
472: };
473:
474:
475: void GC_thread_exit_proc(void *arg)
476: {
477: GC_thread me;
478: struct start_info * si = arg;
479:
480: LOCK();
481: me = GC_lookup_thread(pthread_self());
482: if (me -> flags & DETACHED) {
483: GC_delete_thread(pthread_self());
484: } else {
485: me -> flags |= FINISHED;
486: }
487: UNLOCK();
488: }
489:
490: int GC_pthread_join(pthread_t thread, void **retval)
491: {
492: int result;
493: GC_thread thread_gc_id;
494:
495: LOCK();
496: thread_gc_id = GC_lookup_thread(thread);
497: /* This is guaranteed to be the intended one, since the thread id */
498: /* cant have been recycled by pthreads. */
499: UNLOCK();
500: result = pthread_join(thread, retval);
501: LOCK();
502: /* Here the pthread thread id may have been recycled. */
503: GC_delete_gc_thread(thread, thread_gc_id);
504: UNLOCK();
505: return result;
506: }
507:
508: void * GC_start_routine(void * arg)
509: {
510: struct start_info * si = arg;
511: void * result;
512: GC_thread me;
513: pthread_t my_pthread;
514: void *(*start)(void *);
515: void *start_arg;
516:
517: my_pthread = pthread_self();
518: LOCK();
519: me = GC_new_thread(my_pthread);
520: me -> flags = si -> flags;
521: me -> stack_ptr = 0;
522: me -> stack_end = 0;
523: UNLOCK();
524: start = si -> start_routine;
525: start_arg = si -> arg;
526: sem_post(&(si -> registered));
527: pthread_cleanup_push(GC_thread_exit_proc, si);
528: # ifdef DEBUG_THREADS
529: GC_printf1("Starting thread 0x%lx\n", pthread_self());
530: GC_printf1("pid = %ld\n", (long) getpid());
531: GC_printf1("sp = 0x%lx\n", (long) &arg);
532: GC_printf1("start_routine = 0x%lx\n", start);
533: # endif
534: result = (*start)(start_arg);
535: #if DEBUG_THREADS
536: GC_printf1("Finishing thread 0x%x\n", pthread_self());
537: #endif
538: me -> status = result;
539: me -> flags |= FINISHED;
540: pthread_cleanup_pop(1);
541: /* Cleanup acquires lock, ensuring that we can't exit */
542: /* while a collection that thinks we're alive is trying to stop */
543: /* us. */
544: return(result);
545: }
546:
547: int
548: GC_pthread_create(pthread_t *new_thread,
549: const pthread_attr_t *attr,
550: void *(*start_routine)(void *), void *arg)
551: {
552: int result;
553: GC_thread t;
554: pthread_t my_new_thread;
555: void * stack;
556: size_t stacksize;
557: pthread_attr_t new_attr;
558: int detachstate;
559: word my_flags = 0;
560: struct start_info * si = GC_malloc(sizeof(struct start_info));
561: /* This is otherwise saved only in an area mmapped by the thread */
562: /* library, which isn't visible to the collector. */
563:
564: if (0 == si) return(ENOMEM);
565: sem_init(&(si -> registered), 0, 0);
566: si -> start_routine = start_routine;
567: si -> arg = arg;
568: LOCK();
569: if (!GC_thr_initialized) GC_thr_init();
570: if (NULL == attr) {
571: stack = 0;
572: (void) pthread_attr_init(&new_attr);
573: } else {
574: new_attr = *attr;
575: }
576: pthread_attr_getdetachstate(&new_attr, &detachstate);
577: if (PTHREAD_CREATE_DETACHED == detachstate) my_flags |= DETACHED;
578: si -> flags = my_flags;
579: UNLOCK();
580: result = pthread_create(new_thread, &new_attr, GC_start_routine, si);
581: /* Wait until child has been added to the thread table. */
582: /* This also ensures that we hold onto si until the child is done */
583: /* with it. Thus it doesn't matter whether it is otherwise */
584: /* visible to the collector. */
585: if (0 != sem_wait(&(si -> registered))) ABORT("sem_wait failed");
586: sem_destroy(&(si -> registered));
587: /* pthread_attr_destroy(&new_attr); */
588: /* pthread_attr_destroy(&new_attr); */
589: return(result);
590: }
591:
592: GC_bool GC_collecting = 0;
593: /* A hint that we're in the collector and */
594: /* holding the allocation lock for an */
595: /* extended period. */
596:
597: /* Reasonably fast spin locks. Basically the same implementation */
598: /* as STL alloc.h. This isn't really the right way to do this. */
599: /* but until the POSIX scheduling mess gets straightened out ... */
600:
601: volatile unsigned int GC_allocate_lock = 0;
602:
603:
604: void GC_lock()
605: {
606: # define low_spin_max 30 /* spin cycles if we suspect uniprocessor */
607: # define high_spin_max 1000 /* spin cycles for multiprocessor */
608: static unsigned spin_max = low_spin_max;
609: unsigned my_spin_max;
610: static unsigned last_spins = 0;
611: unsigned my_last_spins;
612: volatile unsigned junk;
613: # define PAUSE junk *= junk; junk *= junk; junk *= junk; junk *= junk
614: int i;
615:
616: if (!GC_test_and_set(&GC_allocate_lock)) {
617: return;
618: }
619: junk = 0;
620: my_spin_max = spin_max;
621: my_last_spins = last_spins;
622: for (i = 0; i < my_spin_max; i++) {
623: if (GC_collecting) goto yield;
624: if (i < my_last_spins/2 || GC_allocate_lock) {
625: PAUSE;
626: continue;
627: }
628: if (!GC_test_and_set(&GC_allocate_lock)) {
629: /*
630: * got it!
631: * Spinning worked. Thus we're probably not being scheduled
632: * against the other process with which we were contending.
633: * Thus it makes sense to spin longer the next time.
634: */
635: last_spins = i;
636: spin_max = high_spin_max;
637: return;
638: }
639: }
640: /* We are probably being scheduled against the other process. Sleep. */
641: spin_max = low_spin_max;
642: yield:
643: for (i = 0;; ++i) {
644: if (!GC_test_and_set(&GC_allocate_lock)) {
645: return;
646: }
647: # define SLEEP_THRESHOLD 12
648: /* nanosleep(<= 2ms) just spins under Linux. We */
649: /* want to be careful to avoid that behavior. */
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: # endif /* LINUX_THREADS */
666:
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_contrib2 / asir2000 / gc