Fcalva/cyclone
1
0
Fork 0
mirror of https://github.com/justinethier/cyclone.git synced 2025-07-15 16:57:35 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Re-enable cooperation code

Browse source
This commit is contained in:
Justin Ethier 2015-12-24 01:32:40 -05:00
parent b31c6181c8
commit 43ff5c5454
1 changed files with 58 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

118
gc.c
View file

@ -1167,32 +1167,30 @@ void gc_wait_handshake()
pthread_mutex_unlock(&(m->lock));
}else if (statusc == STATUS_SYNC2) {
ATOMIC_SET_IF_EQ(&(m->gc_status), statusc, statusm);
}
// TODO: allow collector to cooperate on behalf of a mutator for the async phase
// else if (statusc == STATUS_ASYNC) {
//printf("DEBUG - is mutator still blocked?\n");
// // Check again, if thread is still blocked we need to cooperate
// if (ATOMIC_SET_IF_EQ(&(m->thread_state),
// CYC_THREAD_STATE_BLOCKED,
// CYC_THREAD_STATE_BLOCKED_COOPERATING)) {
//printf("DEBUG - update mutator GC status\n");
// ATOMIC_SET_IF_EQ(&(m->gc_status), statusc, statusm);
// pthread_mutex_lock(&(m->lock));
//printf("DEBUG - collector is cooperating for blocked mutator\n");
// buf_len = gc_minor(m, m->stack_limit, m->stack_start, m->gc_cont, NULL, 0);
// // Mark thread "roots", based on code from mutator's cooperator
// gc_mark_gray(m, m->gc_cont);
// //for (i = 0; i < m->gc_num_args; i++) {
// // gc_mark_gray(m, m->gc_args[i]);
// //}
// // Also, mark everything the collector moved to the heap
// for (i = 0; i < buf_len; i++) {
// gc_mark_gray(m, m->moveBuf[i]);
// }
// m->gc_alloc_color = ATOMIC_GET(&gc_color_mark);
// pthread_mutex_unlock(&(m->lock));
// }
// }
} else if (statusc == STATUS_ASYNC) {
printf("DEBUG - is mutator still blocked?\n");
// Check again, if thread is still blocked we need to cooperate
if (ATOMIC_SET_IF_EQ(&(m->thread_state),
CYC_THREAD_STATE_BLOCKED,
CYC_THREAD_STATE_BLOCKED_COOPERATING)) {
printf("DEBUG - update mutator GC status\n");
ATOMIC_SET_IF_EQ(&(m->gc_status), statusc, statusm);
pthread_mutex_lock(&(m->lock));
printf("DEBUG - collector is cooperating for blocked mutator\n");
buf_len = gc_minor(m, m->stack_limit, m->stack_start, m->gc_cont, NULL, 0);
// Mark thread "roots", based on code from mutator's cooperator
gc_mark_gray(m, m->gc_cont);
//for (i = 0; i < m->gc_num_args; i++) {
// gc_mark_gray(m, m->gc_args[i]);
//}
// Also, mark everything the collector moved to the heap
for (i = 0; i < buf_len; i++) {
gc_mark_gray(m, m->moveBuf[i]);
}
m->gc_alloc_color = ATOMIC_GET(&gc_color_mark);
pthread_mutex_unlock(&(m->lock));
}
}
} else if (thread_status == CYC_THREAD_STATE_TERMINATED) {
// Thread is no longer running
break;
@ -1382,49 +1380,49 @@ void gc_thread_data_free(gc_thread_data *thd)
void gc_mutator_thread_blocked(gc_thread_data *thd, object cont)
{
ATOMIC_SET_IF_EQ(&(thd->thread_state),
if(!ATOMIC_SET_IF_EQ(&(thd->thread_state),
CYC_THREAD_STATE_RUNNABLE,
CYC_THREAD_STATE_BLOCKED);
CYC_THREAD_STATE_BLOCKED)){
fprintf(stderr, "Unable to change thread from runnable to blocked. status = %d\n", thd->thread_state);
exit(1);
}
thd->gc_cont = cont;
thd->gc_num_args = 0; // Will be set later, after collection
}
void gc_mutator_thread_runnable(gc_thread_data *thd, object result)
{
ATOMIC_SET_IF_EQ(&(thd->thread_state),
CYC_THREAD_STATE_BLOCKED,
CYC_THREAD_STATE_RUNNABLE);
// // Transition from blocked back to runnable using CAS.
// // If we are unable to transition back, assume collector
// // has cooperated on behalf of this mutator thread.
// if (!ATOMIC_SET_IF_EQ(&(thd->thread_state),
// CYC_THREAD_STATE_BLOCKED,
// CYC_THREAD_STATE_RUNNABLE)){
//printf("DEBUG - Collector cooperated, wait for it to finish\n");
// // wait for the collector to finish
// pthread_mutex_lock(&(thd->lock));
// pthread_mutex_unlock(&(thd->lock));
// // update thread status
// while(!ATOMIC_SET_IF_EQ(&(thd->thread_state),
// CYC_THREAD_STATE_BLOCKED_COOPERATING,
// CYC_THREAD_STATE_RUNNABLE)){}
// // transport result to heap, if necessary (IE, is not a value type)
// if (is_object_type(result)) {
// // TODO: need to move object to heap
// // TODO: also, then need to gc_mark_gray heap obj
// fprintf(stderr, "Unhandled object type result, TODO: implement\n");
// exit(1);
// }
// // Setup value to send to continuation
// thd->gc_args[0] = result;
// thd->gc_num_args = 1;
// // Whoa.
//printf("DEBUG - Call into gc_cont after collector coop\n");
// longjmp(*(thd->jmp_start), 1);
// } else {
// Transition from blocked back to runnable using CAS.
// If we are unable to transition back, assume collector
// has cooperated on behalf of this mutator thread.
if (!ATOMIC_SET_IF_EQ(&(thd->thread_state),
CYC_THREAD_STATE_BLOCKED,
CYC_THREAD_STATE_RUNNABLE)){
printf("DEBUG - Collector cooperated, wait for it to finish. status is %d\n", thd->thread_state);
// wait for the collector to finish
pthread_mutex_lock(&(thd->lock));
pthread_mutex_unlock(&(thd->lock));
// update thread status
while(!ATOMIC_SET_IF_EQ(&(thd->thread_state),
CYC_THREAD_STATE_BLOCKED_COOPERATING,
CYC_THREAD_STATE_RUNNABLE)){}
// transport result to heap, if necessary (IE, is not a value type)
if (is_object_type(result)) {
// TODO: need to move object to heap
// TODO: also, then need to gc_mark_gray heap obj
fprintf(stderr, "Unhandled object type result, TODO: implement\n");
exit(1);
}
// Setup value to send to continuation
thd->gc_args[0] = result;
thd->gc_num_args = 1;
// Whoa.
printf("DEBUG - Call into gc_cont after collector coop\n");
longjmp(*(thd->jmp_start), 1);
} else {
// Collector didn't do anything; make a normal continuation call
(((closure)(thd->gc_cont))->fn)(thd, 1, thd->gc_cont, result);
// }
}
}
//// Unit testing: