conservatory
/
ikarus
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* Added ikrt_register_guardian_pair to replace ikrt_register_guardian.

This commit is contained in:
Abdulaziz Ghuloum 2007-09-01 01:00:35 -04:00
parent 5667428e70
commit 4daea5e4e0
4 changed files with 105 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
bin/ikarus
View File

Binary file not shown.

143
bin/ikarus-collect.c
View File

@ -79,7 +79,7 @@ typedef struct gc_t{
ikp tconc_ep;
ikp tconc_base;
ikpages* tconc_queue;
ik_guardian_table* final_guardians;
//ik_guardian_table* final_guardians;
} gc_t;
static unsigned int
@ -581,91 +581,112 @@ is_live(ikp x, gc_t* gc){
return 0;
}
static ik_guardian_table*
move_guardian(ikp tc, ikp obj, ik_guardian_table* t){
if(t && (t->count < ik_guardian_table_size)){
ik_guardian_pair* p = &t->p[t->count];
p->tc = tc;
p->obj = obj;
t->count++;
return t;
} else {
ik_guardian_table* nt =
(ik_guardian_table*)ik_mmap(sizeof(ik_guardian_table));
nt->next = t;
nt->count = 1;
nt->p[0].tc = tc;
nt->p[0].obj = obj;
return nt;
}
}
static inline int
next_gen(int i){
return ((i == generation_count) ? generation_count : (i+1));
}
static ik_ptr_page*
move_guarded(ikp x, ik_ptr_page* dst){
if((dst == 0) || (dst->count == ik_ptr_page_size)){
ik_ptr_page* y = ik_mmap(sizeof(ik_ptr_page));
y->count = 0;
y->next = dst;
dst = y;
}
dst->ptr[dst->count++] = x;
return dst;
}
static void
forward_guardians(gc_t* gc){
ikpcb* pcb = gc->pcb;
int gen;
ik_ptr_page* forward_list[generation_count];
for(gen = gc->collect_gen; gen>=0; gen--){
/* must move backwards from older to younger generations */
ikp todo = pcb->guardians[gen];
pcb->guardians[gen] = null_object;
ikp forward = pcb->guardians[next_gen(gen)];
ikp dropped = null_object;
while(todo != null_object){
ikp next = ref(todo, off_cdr);
ikp a = ref(todo, off_car);
/* ikp tc = ref(a, off_car); */
ikp obj = ref(a, off_cdr);
if(is_live(obj, gc)){
ref(todo, off_cdr) = forward;
forward = todo;
} else {
ref(todo, off_cdr) = dropped;
dropped = todo;
ik_ptr_page* todo = pcb->guardians[gen];
pcb->guardians[gen] = 0;
ik_ptr_page* forward = 0;
ik_ptr_page* dropped = 0;
while(todo){
int i;
int n = todo->count;
for(i=0; i<n; i++){
ikp a = todo->ptr[i];
ikp obj = ref(a, off_cdr);
if(is_live(obj, gc)){
forward = move_guarded(a, forward);
} else {
dropped = move_guarded(a, dropped);
}
}
ik_ptr_page* next = todo->next;
ik_munmap(todo, sizeof(ik_ptr_page));
todo = next;
}
pcb->guardians[next_gen(gen)] = forward;
forward_list[gen] = forward;
pcb->guardians_dropped[gen] = dropped;
}
for(gen = next_gen(gc->collect_gen); gen>=0; gen--){
pcb->guardians[gen] = add_object(gc, pcb->guardians[gen], "guardians");
for(gen=0; gen<=gc->collect_gen; gen++){
ik_ptr_page* src = forward_list[gen];
ik_ptr_page* dst = pcb->guardians[next_gen(gen)];
while(src){
int i;
int n = src->count;
for(i=0; i<n; i++){
ikp a = add_object(gc, src->ptr[i], "prot");
dst = move_guarded(a, dst);
}
ik_ptr_page* next = src->next;
ik_munmap(src, sizeof(ik_ptr_page));
src = next;
}
pcb->guardians[next_gen(gen)] = dst;
}
for(gen = gc->collect_gen; gen>=0; gen--){
pcb->guardians_dropped[gen] =
add_object(gc, pcb->guardians_dropped[gen], "guardians dropped");
for(gen = 0; gen<=gc->collect_gen; gen++){
ik_ptr_page* src = pcb->guardians_dropped[gen];
while(src){
int i;
int n = src->count;
for(i=0; i<n; i++){
src->ptr[i] = add_object(gc, src->ptr[i], "prot");
}
src = src->next;
}
}
}
static void
empty_dropped_guardians(gc_t* gc){
ikpcb* pcb = gc->pcb;
int gen;
for(gen = gc->collect_gen; gen>=0; gen--){
ikp ls = pcb->guardians_dropped[gen];
while(ls != null_object){
ikp next = ref(ls, off_cdr);
ikp a = ref(ls, off_car);
ikp tc = ref(a, off_car);
ikp obj = ref(a, off_cdr);
assert(tagof(tc) == pair_tag);
ikp d = ref(tc, off_cdr);
assert(tagof(d) == pair_tag);
ref(d, off_car) = obj;
ref(d, off_cdr) = a;
ref(a, off_car) = false_object;
ref(a, off_cdr) = false_object;
ref(tc, off_cdr) = a;
pcb->dirty_vector[page_index(tc)] = -1;
pcb->dirty_vector[page_index(d)] = -1;
ls = next;
for(gen = 0; gen<=gc->collect_gen; gen++){
ik_ptr_page* src = pcb->guardians_dropped[gen];
while(src){
int i;
int n = src->count;
for(i=0; i<n; i++){
ikp a = src->ptr[i];
ikp tc = ref(a, off_car);
ikp obj = ref(a, off_cdr);
assert(tagof(tc) == pair_tag);
ikp d = ref(tc, off_cdr);
assert(tagof(d) == pair_tag);
ref(d, off_car) = obj;
ref(d, off_cdr) = a;
ref(a, off_car) = false_object;
ref(a, off_cdr) = false_object;
ref(tc, off_cdr) = a;
pcb->dirty_vector[page_index(tc)] = -1;
pcb->dirty_vector[page_index(d)] = -1;
}
ik_ptr_page* next = src->next;
ik_munmap(src, sizeof(ik_ptr_page));
src = next;
}
pcb->guardians_dropped[gen] = null_object;
pcb->guardians_dropped[gen] = 0;
}
}

49
bin/ikarus-runtime.c
View File

@ -264,14 +264,6 @@ ikpcb* ik_make_pcb(){
ikpcb* pcb = ik_malloc(sizeof(ikpcb));
bzero(pcb, sizeof(ikpcb));
pcb->collect_key = false_object;
{
int i;
for(i=0; i<generation_count; i++){
pcb->guardians[i] = null_object;
pcb->guardians_forward[i] = null_object;
pcb->guardians_dropped[i] = null_object;
}
}
#define HEAPSIZE (1024 * 4096)
#define STAKSIZE (1024 * 4096)
//#define STAKSIZE (256 * 4096)
@ -893,40 +885,27 @@ ikrt_write_char(){
#if 0
ikp
ikrt_register_guardian(ikp tc, ikp obj, ikpcb* pcb){
ik_guardian_table* g = pcb->guardians[0];
if((!g) || (g->count == ik_guardian_table_size)){
if(sizeof(ik_guardian_table) != pagesize){
fprintf(stderr, "ERR: invalid guardian table size\n");
exit(-1);
}
ik_guardian_table* p =
(ik_guardian_table*)ik_mmap(sizeof(ik_guardian_table));
p->next = g;
p->count = 0;
pcb->guardians[0] = p;
g=p;
}
ik_guardian_pair* p = &(g->p[g->count]);
p->tc = tc;
p->obj = obj;
g->count++;
return 0;
ikp
ikrt_register_guardian_pair(ikp p0, ikpcb* pcb){
ik_ptr_page* x = pcb->guardians[0];
if((x == NULL) || (x->count == ik_ptr_page_size)){
assert(sizeof(ik_ptr_page) == pagesize);
ik_ptr_page* y = ik_mmap(pagesize);
y->count = 0;
y->next = x;
pcb->guardians[0] = y;
x = y;
}
x->ptr[x->count++] = p0;
return void_object;
}
#endif
ikp
ikrt_register_guardian(ikp tc, ikp obj, ikpcb* pcb){
ikp p0 = ik_alloc(pcb, pair_size) + pair_tag;
ikp p1 = ik_alloc(pcb, pair_size) + pair_tag;
ref(p0, off_car) = tc;
ref(p0, off_cdr) = obj;
ref(p1, off_car) = p0;
ref(p1, off_cdr) = pcb->guardians[0];
pcb->guardians[0] = p1;
return void_object;
return ikrt_register_guardian_pair(p0, pcb);
}

23
bin/ikarus.h
View File

@ -90,20 +90,16 @@ typedef struct ikdl{ /* double-link */
struct ikdl* next;
} ikdl;
typedef struct ik_guardian_pair{
ikp tc;
ikp obj;
} ik_guardian_pair;
#define ik_guardian_table_size \
((pagesize - sizeof(int) - sizeof(struct ik_guardian_table*))/sizeof(ik_guardian_pair))
#define ik_ptr_page_size \
((pagesize - sizeof(int) - sizeof(struct ik_ptr_page*))/sizeof(ikp))
typedef struct ik_guardian_table{
typedef struct ik_ptr_page{
int count;
struct ik_guardian_table* next;
ik_guardian_pair p[ik_guardian_table_size];
} ik_guardian_table;
struct ik_ptr_page* next;
ikp ptr[ik_ptr_page_size];
} ik_ptr_page;
typedef struct ikpcb{
/* the first locations may be accessed by some */
@ -135,9 +131,8 @@ typedef struct ikpcb{
int stack_size;
ikp symbol_table;
ikp gensym_table;
ikp guardians[generation_count];
ikp guardians_forward[generation_count];
ikp guardians_dropped[generation_count];
ik_ptr_page* guardians[generation_count];
ik_ptr_page* guardians_dropped[generation_count];
unsigned int* dirty_vector_base;
unsigned int* segment_vector_base;
unsigned char* memory_base;