X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2Fsm%2FMarkWeak.c;h=96b4f674f3036b4ced605843ba542bed6d6388fc;hb=a11bb49b97eaba892730baf1565e922715dbc07f;hp=ce88466fdf90bbc07fb6400f7618ccf6f1d91e00;hpb=122ff64971cbef8260221840caefc1a3411f41b5;p=ghc-hetmet.git diff --git a/rts/sm/MarkWeak.c b/rts/sm/MarkWeak.c index ce88466..96b4f67 100644 --- a/rts/sm/MarkWeak.c +++ b/rts/sm/MarkWeak.c @@ -74,10 +74,11 @@ static WeakStage weak_stage; */ StgWeak *old_weak_ptr_list; // also pending finaliser list -/* List of all threads during GC - */ +// List of threads found to be unreachable StgTSO *resurrected_threads; -static StgTSO *old_all_threads; + +// List of blocked threads found to have pending throwTos +StgTSO *exception_threads; void initWeakForGC(void) @@ -85,13 +86,8 @@ initWeakForGC(void) old_weak_ptr_list = weak_ptr_list; weak_ptr_list = NULL; weak_stage = WeakPtrs; - - /* The all_threads list is like the weak_ptr_list. - * See traverseWeakPtrList() for the details. - */ - old_all_threads = all_threads; - all_threads = END_TSO_QUEUE; resurrected_threads = END_TSO_QUEUE; + exception_threads = END_TSO_QUEUE; } rtsBool @@ -100,6 +96,7 @@ traverseWeakPtrList(void) StgWeak *w, **last_w, *next_w; StgClosure *new; rtsBool flag = rtsFalse; + const StgInfoTable *info; switch (weak_stage) { @@ -124,12 +121,14 @@ traverseWeakPtrList(void) continue; } - switch (get_itbl(w)->type) { - - case EVACUATED: - next_w = (StgWeak *)((StgEvacuated *)w)->evacuee; + info = w->header.info; + if (IS_FORWARDING_PTR(info)) { + next_w = (StgWeak *)UN_FORWARDING_PTR(info); *last_w = next_w; continue; + } + + switch (INFO_PTR_TO_STRUCT(info)->type) { case WEAK: /* Now, check whether the key is reachable. @@ -185,53 +184,82 @@ traverseWeakPtrList(void) * the weak ptr list. If we discover any threads that are about to * become garbage, we wake them up and administer an exception. */ - { - StgTSO *t, *tmp, *next, **prev; + { + StgTSO *t, *tmp, *next, **prev; + nat g, s; + step *stp; - prev = &old_all_threads; - for (t = old_all_threads; t != END_TSO_QUEUE; t = next) { - - tmp = (StgTSO *)isAlive((StgClosure *)t); + // Traverse thread lists for generations we collected... + for (g = 0; g <= N; g++) { + for (s = 0; s < generations[g].n_steps; s++) { + stp = &generations[g].steps[s]; + + prev = &stp->old_threads; + + for (t = stp->old_threads; t != END_TSO_QUEUE; t = next) { - if (tmp != NULL) { - t = tmp; - } + tmp = (StgTSO *)isAlive((StgClosure *)t); - ASSERT(get_itbl(t)->type == TSO); - switch (t->what_next) { - case ThreadRelocated: - next = t->_link; - *prev = next; - continue; - case ThreadKilled: - case ThreadComplete: - // finshed or died. The thread might still be alive, but we - // don't keep it on the all_threads list. Don't forget to - // stub out its global_link field. - next = t->global_link; - t->global_link = END_TSO_QUEUE; - *prev = next; - continue; - default: - ; - } + if (tmp != NULL) { + t = tmp; + } + + ASSERT(get_itbl(t)->type == TSO); + switch (t->what_next) { + case ThreadRelocated: + next = t->_link; + *prev = next; + continue; + case ThreadKilled: + case ThreadComplete: + // finshed or died. The thread might still + // be alive, but we don't keep it on the + // all_threads list. Don't forget to + // stub out its global_link field. + next = t->global_link; + t->global_link = END_TSO_QUEUE; + *prev = next; + continue; + default: + ; + } - if (tmp == NULL) { - // not alive (yet): leave this thread on the - // old_all_threads list. - prev = &(t->global_link); - next = t->global_link; - } - else { - // alive: move this thread onto the all_threads list. - next = t->global_link; - t->global_link = all_threads; - all_threads = t; - *prev = next; - } - } + if (tmp == NULL) { + // not alive (yet): leave this thread on the + // old_all_threads list. + prev = &(t->global_link); + next = t->global_link; + } + else { + // alive + next = t->global_link; + *prev = next; + + // This is a good place to check for blocked + // exceptions. It might be the case that a thread is + // blocked on delivering an exception to a thread that + // is also blocked - we try to ensure that this + // doesn't happen in throwTo(), but it's too hard (or + // impossible) to close all the race holes, so we + // accept that some might get through and deal with + // them here. A GC will always happen at some point, + // even if the system is otherwise deadlocked. + if (t->blocked_exceptions != END_TSO_QUEUE) { + t->global_link = exception_threads; + exception_threads = t; + } else { + // move this thread onto the correct threads list. + step *new_step; + new_step = Bdescr((P_)t)->step; + t->global_link = new_step->threads; + new_step->threads = t; + } + } + } + } + } } - + /* If we evacuated any threads, we need to go back to the scavenger. */ if (flag) return rtsTrue; @@ -239,14 +267,23 @@ traverseWeakPtrList(void) /* And resurrect any threads which were about to become garbage. */ { + nat g, s; + step *stp; StgTSO *t, *tmp, *next; - for (t = old_all_threads; t != END_TSO_QUEUE; t = next) { - next = t->global_link; - tmp = t; - evacuate((StgClosure **)&tmp); - tmp->global_link = resurrected_threads; - resurrected_threads = tmp; - } + + for (g = 0; g <= N; g++) { + for (s = 0; s < generations[g].n_steps; s++) { + stp = &generations[g].steps[s]; + + for (t = stp->old_threads; t != END_TSO_QUEUE; t = next) { + next = t->global_link; + tmp = t; + evacuate((StgClosure **)&tmp); + tmp->global_link = resurrected_threads; + resurrected_threads = tmp; + } + } + } } /* Finally, we can update the blackhole_queue. This queue @@ -333,8 +370,9 @@ markWeakPtrList ( void ) last_w = &weak_ptr_list; for (w = weak_ptr_list; w; w = w->link) { // w might be WEAK, EVACUATED, or DEAD_WEAK (actually CON_STATIC) here - ASSERT(w->header.info == &stg_DEAD_WEAK_info - || get_itbl(w)->type == WEAK || get_itbl(w)->type == EVACUATED); + ASSERT(IS_FORWARDING_PTR(w->header.info) + || w->header.info == &stg_DEAD_WEAK_info + || get_itbl(w)->type == WEAK); tmp = w; evacuate((StgClosure **)&tmp); *last_w = w;