From ebcb6215fbe5802bb85a13c2a4ba452728a923f2 Mon Sep 17 00:00:00 2001 From: "hyunghwan.chung" Date: Fri, 27 Nov 2020 05:13:02 +0000 Subject: [PATCH] working on lazy sweeping --- moo/lib/comp.c | 20 ++--- moo/lib/exec.c | 3 +- moo/lib/gc.c | 229 ++++++++++++++++++++++++++++++----------------- moo/lib/heap.c | 2 +- moo/lib/moo.c | 2 +- moo/lib/moo.h | 16 ++-- moo/lib/obj.c | 34 +++++-- moo/lib/pf-sys.c | 2 +- moo/mod/sck.c | 2 +- moo/mod/x11.c | 2 +- 10 files changed, 201 insertions(+), 111 deletions(-) diff --git a/moo/lib/comp.c b/moo/lib/comp.c index 6531cf0..27c4659 100644 --- a/moo/lib/comp.c +++ b/moo/lib/comp.c @@ -10585,7 +10585,7 @@ static void gc_oopbuf (moo_t* moo, moo_oopbuf_t* oopbuf) for (i = 0; i < oopbuf->count; i++) { - register moo_oop_t x = moo_moveoop(moo, oopbuf->ptr[i]); + moo_oop_t x = moo_updateoopforgc(moo, oopbuf->ptr[i]); oopbuf->ptr[i] = x; } } @@ -10614,12 +10614,12 @@ static void gc_cunit_chain (moo_t* moo) pd = (moo_cunit_pooldic_t*)cunit; if (pd->pd_oop) { - register moo_oop_t x = moo_moveoop(moo, (moo_oop_t)pd->pd_oop); + moo_oop_t x = moo_updateoopforgc(moo, (moo_oop_t)pd->pd_oop); pd->pd_oop = (moo_oop_dic_t)x; } if (pd->ns_oop) { - register moo_oop_t x = moo_moveoop(moo, (moo_oop_t)pd->ns_oop); + moo_oop_t x = moo_updateoopforgc(moo, (moo_oop_t)pd->ns_oop); pd->ns_oop = (moo_oop_nsdic_t)x; } break; @@ -10632,29 +10632,29 @@ static void gc_cunit_chain (moo_t* moo) cc = (moo_cunit_class_t*)cunit; if (cc->self_oop) - cc->self_oop = (moo_oop_class_t)moo_moveoop(moo, (moo_oop_t)cc->self_oop); + cc->self_oop = (moo_oop_class_t)moo_updateoopforgc(moo, (moo_oop_t)cc->self_oop); if (cc->super_oop) - cc->super_oop = moo_moveoop(moo, cc->super_oop); + cc->super_oop = moo_updateoopforgc(moo, cc->super_oop); for (i = 0; i < MOO_COUNTOF(cc->var); i++) { for (j = 0; j < cc->var[i].initv_count; j++) { register moo_oop_t x = cc->var[i].initv[j].v; - if (x) cc->var[i].initv[j].v = moo_moveoop(moo, x); + if (x) cc->var[i].initv[j].v = moo_updateoopforgc(moo, x); } } if (cc->ns_oop) { - register moo_oop_t x = moo_moveoop(moo, (moo_oop_t)cc->ns_oop); + moo_oop_t x = moo_updateoopforgc(moo, (moo_oop_t)cc->ns_oop); cc->ns_oop = (moo_oop_nsdic_t)x; } if (cc->superns_oop) { - register moo_oop_t x = moo_moveoop(moo, (moo_oop_t)cc->superns_oop); + moo_oop_t x = moo_updateoopforgc(moo, (moo_oop_t)cc->superns_oop); cc->superns_oop = (moo_oop_nsdic_t)x; } @@ -10672,11 +10672,11 @@ static void gc_cunit_chain (moo_t* moo) ifce = (moo_cunit_interface_t*)cunit; if (ifce->self_oop) - ifce->self_oop = (moo_oop_interface_t)moo_moveoop(moo, (moo_oop_t)ifce->self_oop); + ifce->self_oop = (moo_oop_interface_t)moo_updateoopforgc(moo, (moo_oop_t)ifce->self_oop); if (ifce->ns_oop) { - register moo_oop_t x = moo_moveoop(moo, (moo_oop_t)ifce->ns_oop); + moo_oop_t x = moo_updateoopforgc(moo, (moo_oop_t)ifce->ns_oop); ifce->ns_oop = (moo_oop_nsdic_t)x; } diff --git a/moo/lib/exec.c b/moo/lib/exec.c index 0e3dee6..ba378a8 100644 --- a/moo/lib/exec.c +++ b/moo/lib/exec.c @@ -206,7 +206,7 @@ static MOO_INLINE void vm_cleanup (moo_t* moo) moo_deregallfinalizables (moo); /* final garbage collection */ - moo_gc (moo); + moo_gc (moo, 1); MOO_DEBUG0 (moo, "VM cleaned up\n"); } @@ -6356,6 +6356,7 @@ int moo_execute (moo_t* moo) moo->proc_switched = 0; moo->abort_req = 0; +moo->gci.lazy_sweep = 1; n = __execute (moo); vm_cleanup (moo); diff --git a/moo/lib/gc.c b/moo/lib/gc.c index 6c09219..4fff5fc 100644 --- a/moo/lib/gc.c +++ b/moo/lib/gc.c @@ -799,7 +799,7 @@ static moo_rbt_walk_t call_module_gc (moo_rbt_t* rbt, moo_rbt_pair_t* pair, void #if defined(MOO_ENABLE_GC_MARK_SWEEP) #if 0 -static MOO_INLINE void gc_mark (moo_t* moo, moo_oop_t oop) +static MOO_INLINE void gc_ms_mark (moo_t* moo, moo_oop_t oop) { moo_oow_t i, sz; @@ -812,7 +812,7 @@ static MOO_INLINE void gc_mark (moo_t* moo, moo_oop_t oop) MOO_OBJ_SET_FLAGS_MOVED(oop, 1); /* mark */ - gc_mark (moo, (moo_oop_t)MOO_OBJ_GET_CLASS(oop)); /* TODO: remove recursion */ + gc_ms_mark (moo, (moo_oop_t)MOO_OBJ_GET_CLASS(oop)); /* TODO: remove recursion */ if (MOO_OBJ_GET_FLAGS_TYPE(oop) == MOO_OBJ_TYPE_OOP) { @@ -836,12 +836,12 @@ static MOO_INLINE void gc_mark (moo_t* moo, moo_oop_t oop) for (i = 0; i < size; i++) { moo_oop_t tmp = MOO_OBJ_GET_OOP_VAL(oop, i); - if (MOO_OOP_IS_POINTER(tmp)) gc_mark (moo, tmp); /* TODO: no resursion */ + if (MOO_OOP_IS_POINTER(tmp)) gc_ms_mark (moo, tmp); /* TODO: no resursion */ } } } #else -static MOO_INLINE void gc_mark_object (moo_t* moo, moo_oop_t oop) +static MOO_INLINE void gc_ms_mark_object (moo_t* moo, moo_oop_t oop) { #if defined(MOO_SUPPORT_GC_DURING_IGNITION) if (!oop) return; @@ -854,7 +854,7 @@ MOO_ASSERT (moo, moo->gci.stack.len < moo->gci.stack.capa); if (moo->gci.stack.len > moo->gci.stack.max) moo->gci.stack.max = moo->gci.stack.len; } -static MOO_INLINE void gc_scan_stack (moo_t* moo) +static MOO_INLINE void gc_ms_scan_stack (moo_t* moo) { moo_oop_t oop; @@ -862,7 +862,7 @@ static MOO_INLINE void gc_scan_stack (moo_t* moo) { oop = moo->gci.stack.ptr[--moo->gci.stack.len]; - gc_mark_object (moo, (moo_oop_t)MOO_OBJ_GET_CLASS(oop)); + gc_ms_mark_object (moo, (moo_oop_t)MOO_OBJ_GET_CLASS(oop)); if (MOO_OBJ_GET_FLAGS_TYPE(oop) == MOO_OBJ_TYPE_OOP) { @@ -885,20 +885,20 @@ static MOO_INLINE void gc_scan_stack (moo_t* moo) for (i = 0; i < size; i++) { - gc_mark_object (moo, MOO_OBJ_GET_OOP_VAL(oop, i)); + gc_ms_mark_object (moo, MOO_OBJ_GET_OOP_VAL(oop, i)); } } } } -static MOO_INLINE void gc_mark (moo_t* moo, moo_oop_t oop) +static MOO_INLINE void gc_ms_mark (moo_t* moo, moo_oop_t oop) { - gc_mark_object (moo, oop); - gc_scan_stack (moo); + gc_ms_mark_object (moo, oop); + gc_ms_scan_stack (moo); } #endif -static MOO_INLINE void gc_mark_root (moo_t* moo) +static MOO_INLINE void gc_ms_mark_roots (moo_t* moo) { moo_oow_t i, gcfin_count; moo_evtcb_t* cb; @@ -913,57 +913,57 @@ static MOO_INLINE void gc_mark_root (moo_t* moo) moo->processor->active->sp = MOO_SMOOI_TO_OOP(moo->sp); } - gc_mark (moo, moo->_nil); - gc_mark (moo, moo->_true); - gc_mark (moo, moo->_false); + gc_ms_mark (moo, moo->_nil); + gc_ms_mark (moo, moo->_true); + gc_ms_mark (moo, moo->_false); for (i = 0; i < MOO_COUNTOF(kernel_classes); i++) { - gc_mark (moo, *(moo_oop_t*)((moo_uint8_t*)moo + kernel_classes[i].offset)); + gc_ms_mark (moo, *(moo_oop_t*)((moo_uint8_t*)moo + kernel_classes[i].offset)); } - gc_mark (moo, (moo_oop_t)moo->sysdic); - gc_mark (moo, (moo_oop_t)moo->processor); - gc_mark (moo, (moo_oop_t)moo->nil_process); - gc_mark (moo, (moo_oop_t)moo->dicnewsym); - gc_mark (moo, (moo_oop_t)moo->dicputassocsym); - gc_mark (moo, (moo_oop_t)moo->does_not_understand_sym); - gc_mark (moo, (moo_oop_t)moo->primitive_failed_sym); - gc_mark (moo, (moo_oop_t)moo->unwindto_return_sym); + gc_ms_mark (moo, (moo_oop_t)moo->sysdic); + gc_ms_mark (moo, (moo_oop_t)moo->processor); + gc_ms_mark (moo, (moo_oop_t)moo->nil_process); + gc_ms_mark (moo, (moo_oop_t)moo->dicnewsym); + gc_ms_mark (moo, (moo_oop_t)moo->dicputassocsym); + gc_ms_mark (moo, (moo_oop_t)moo->does_not_understand_sym); + gc_ms_mark (moo, (moo_oop_t)moo->primitive_failed_sym); + gc_ms_mark (moo, (moo_oop_t)moo->unwindto_return_sym); for (i = 0; i < moo->sem_list_count; i++) { - gc_mark (moo, (moo_oop_t)moo->sem_list[i]); + gc_ms_mark (moo, (moo_oop_t)moo->sem_list[i]); } for (i = 0; i < moo->sem_heap_count; i++) { - gc_mark (moo, (moo_oop_t)moo->sem_heap[i]); + gc_ms_mark (moo, (moo_oop_t)moo->sem_heap[i]); } for (i = 0; i < moo->sem_io_tuple_count; i++) { if (moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_INPUT]) - gc_mark (moo, (moo_oop_t)moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_INPUT]); + gc_ms_mark (moo, (moo_oop_t)moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_INPUT]); if (moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT]) - gc_mark (moo, (moo_oop_t)moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT]); + gc_ms_mark (moo, (moo_oop_t)moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT]); } - gc_mark (moo, (moo_oop_t)moo->sem_gcfin); + gc_ms_mark (moo, (moo_oop_t)moo->sem_gcfin); for (i = 0; i < moo->proc_map_capa; i++) { - gc_mark (moo, moo->proc_map[i]); + gc_ms_mark (moo, moo->proc_map[i]); } for (i = 0; i < moo->volat_count; i++) { - gc_mark (moo, *moo->volat_stack[i]); + gc_ms_mark (moo, *moo->volat_stack[i]); } - if (moo->initial_context) gc_mark (moo, (moo_oop_t)moo->initial_context); - if (moo->active_context) gc_mark (moo, (moo_oop_t)moo->active_context); - if (moo->active_method) gc_mark (moo, (moo_oop_t)moo->active_method); + if (moo->initial_context) gc_ms_mark (moo, (moo_oop_t)moo->initial_context); + if (moo->active_context) gc_ms_mark (moo, (moo_oop_t)moo->active_context); + if (moo->active_method) gc_ms_mark (moo, (moo_oop_t)moo->active_method); moo_rbt_walk (&moo->modtab, call_module_gc, moo); @@ -978,7 +978,7 @@ static MOO_INLINE void gc_mark_root (moo_t* moo) { compact_symbol_table (moo, moo->_nil); /* delete symbol table entries that are not marked */ #if 0 - gc_mark (moo, (moo_oop_t)moo->symtab); /* mark the symbol table */ + gc_ms_mark (moo, (moo_oop_t)moo->symtab); /* mark the symbol table */ #else MOO_OBJ_SET_FLAGS_MOVED(moo->symtab, 1); /* mark */ MOO_OBJ_SET_FLAGS_MOVED(moo->symtab->bucket, 1); /* mark */ @@ -993,7 +993,60 @@ static MOO_INLINE void gc_mark_root (moo_t* moo) moo_clearmethodcache (moo); } -static MOO_INLINE void gc_sweep (moo_t* moo) +void moo_gc_ms_sweep_lazy (moo_t* moo, moo_oow_t allocsize) +{ + moo_gchdr_t* curr, * next, * prev; + moo_oop_t obj; + moo_oow_t freed_size; + + if (!moo->gci.ls.curr) return; + + freed_size = 0; + +//printf ("starting lazy sweep...gci.ls.curr [%p]\n", moo->gci.ls.curr); + prev = moo->gci.ls.prev; + curr = moo->gci.ls.curr; + + while (curr) + { + next = curr->next; + obj = (moo_oop_t)(curr + 1); + + if (MOO_OBJ_GET_FLAGS_MOVED(obj)) /* if marked */ + { + MOO_OBJ_SET_FLAGS_MOVED (obj, 0); /* unmark */ + prev = curr; + } + else + { + moo_oow_t objsize; + + if (prev) prev->next = next; + else moo->gci.b = next; + + objsize = MOO_SIZEOF(moo_obj_t) + moo_getobjpayloadbytes(moo, obj); + freed_size += objsize; + moo->gci.bsz -= objsize; + moo_freeheapmem (moo, moo->heap, curr); /* destroy */ + + if (freed_size > allocsize) /* TODO: can it secure large enough space? */ + { +//printf ("stopping lazy sweeping after %lu free, allocsize %lu\n", (unsigned long int)freed_size, (unsigned long int)allocsize); + moo->gci.ls.curr = next; /* let the next lazy sweeping begin at this point */ + moo->gci.ls.prev = prev; +//printf ("finished lazy sweep...\n"); + return; + } + } + + curr = next; + } + + moo->gci.ls.curr = MOO_NULL; +//printf ("finished lazy sweep...\n"); +} + +static MOO_INLINE void gc_ms_sweep (moo_t* moo) { moo_gchdr_t* curr, * next, * prev; moo_oop_t obj; @@ -1005,30 +1058,31 @@ static MOO_INLINE void gc_sweep (moo_t* moo) next = curr->next; obj = (moo_oop_t)(curr + 1); - if (MOO_OBJ_GET_FLAGS_MOVED(obj)) + if (MOO_OBJ_GET_FLAGS_MOVED(obj)) /* if marked */ { - /* unmark */ - MOO_OBJ_SET_FLAGS_MOVED (obj, 0); + MOO_OBJ_SET_FLAGS_MOVED (obj, 0); /* unmark */ prev = curr; } else { - /* destroy */ if (prev) prev->next = next; else moo->gci.b = next; moo->gci.bsz -= MOO_SIZEOF(moo_obj_t) + moo_getobjpayloadbytes(moo, obj); - moo_freeheapmem (moo, moo->heap, curr); + moo_freeheapmem (moo, moo->heap, curr); /* destroy */ } curr = next; } + +printf ("finised full sweep...\n"); + moo->gci.ls.curr = MOO_NULL; } #endif /* ----------------------------------------------------------------------- */ -static moo_oop_t move_oop_in_heap_space (moo_t* moo, moo_oop_t oop) +static moo_oop_t gc_ss_move_oop (moo_t* moo, moo_oop_t oop) { #if defined(MOO_SUPPORT_GC_DURING_IGNITION) if (!oop) return oop; @@ -1095,7 +1149,7 @@ static moo_oop_t move_oop_in_heap_space (moo_t* moo, moo_oop_t oop) } } -static moo_uint8_t* scan_heap_space (moo_t* moo, moo_uint8_t* ptr, moo_uint8_t** end) +static moo_uint8_t* gc_ss_scan_space (moo_t* moo, moo_uint8_t* ptr, moo_uint8_t** end) { while (ptr < *end) /* the end pointer may get changed, especially the new space. so it's moo_int8_t** */ { @@ -1108,7 +1162,7 @@ static moo_uint8_t* scan_heap_space (moo_t* moo, moo_uint8_t* ptr, moo_uint8_t** nbytes_aligned = moo_getobjpayloadbytes(moo, oop); - tmp = moo_moveoop(moo, (moo_oop_t)MOO_OBJ_GET_CLASS(oop)); + tmp = moo_updateoopforgc(moo, (moo_oop_t)MOO_OBJ_GET_CLASS(oop)); MOO_OBJ_SET_CLASS (oop, tmp); if (MOO_OBJ_GET_FLAGS_TYPE(oop) == MOO_OBJ_TYPE_OOP) @@ -1137,7 +1191,7 @@ static moo_uint8_t* scan_heap_space (moo_t* moo, moo_uint8_t* ptr, moo_uint8_t** { /* i must not use MOO_STORE_OOP() as this operation is * part of garbage collection. */ - tmp = moo_moveoop(moo, tmp); + tmp = moo_updateoopforgc(moo, tmp); MOO_OBJ_SET_OOP_VAL (oop, i, tmp); } } @@ -1170,7 +1224,7 @@ static moo_uint8_t* scan_heap_space (moo_t* moo, moo_uint8_t* ptr, moo_uint8_t** } -static void scan_roots (moo_t* moo) +static void gc_ss_scan_roots (moo_t* moo) { /* * move a referenced object to the new heap. @@ -1206,63 +1260,63 @@ static void scan_roots (moo_t* moo) old_nil = moo->_nil; /* move _nil and the root object table */ - moo->_nil = moo_moveoop(moo, moo->_nil); - moo->_true = moo_moveoop(moo, moo->_true); - moo->_false = moo_moveoop(moo, moo->_false); + moo->_nil = moo_updateoopforgc(moo, moo->_nil); + moo->_true = moo_updateoopforgc(moo, moo->_true); + moo->_false = moo_updateoopforgc(moo, moo->_false); for (i = 0; i < MOO_COUNTOF(kernel_classes); i++) { moo_oop_t tmp; tmp = *(moo_oop_t*)((moo_uint8_t*)moo + kernel_classes[i].offset); - tmp = moo_moveoop(moo, tmp); + tmp = moo_updateoopforgc(moo, tmp); *(moo_oop_t*)((moo_uint8_t*)moo + kernel_classes[i].offset) = tmp; } - moo->sysdic = (moo_oop_nsdic_t)moo_moveoop(moo, (moo_oop_t)moo->sysdic); - moo->processor = (moo_oop_process_scheduler_t)moo_moveoop(moo, (moo_oop_t)moo->processor); - moo->nil_process = (moo_oop_process_t)moo_moveoop(moo, (moo_oop_t)moo->nil_process); - moo->dicnewsym = (moo_oop_char_t)moo_moveoop(moo, (moo_oop_t)moo->dicnewsym); - moo->dicputassocsym = (moo_oop_char_t)moo_moveoop(moo, (moo_oop_t)moo->dicputassocsym); - moo->does_not_understand_sym = (moo_oop_char_t)moo_moveoop(moo, (moo_oop_t)moo->does_not_understand_sym); - moo->primitive_failed_sym = (moo_oop_char_t)moo_moveoop(moo, (moo_oop_t)moo->primitive_failed_sym); - moo->unwindto_return_sym = (moo_oop_char_t)moo_moveoop(moo, (moo_oop_t)moo->unwindto_return_sym); + moo->sysdic = (moo_oop_nsdic_t)moo_updateoopforgc(moo, (moo_oop_t)moo->sysdic); + moo->processor = (moo_oop_process_scheduler_t)moo_updateoopforgc(moo, (moo_oop_t)moo->processor); + moo->nil_process = (moo_oop_process_t)moo_updateoopforgc(moo, (moo_oop_t)moo->nil_process); + moo->dicnewsym = (moo_oop_char_t)moo_updateoopforgc(moo, (moo_oop_t)moo->dicnewsym); + moo->dicputassocsym = (moo_oop_char_t)moo_updateoopforgc(moo, (moo_oop_t)moo->dicputassocsym); + moo->does_not_understand_sym = (moo_oop_char_t)moo_updateoopforgc(moo, (moo_oop_t)moo->does_not_understand_sym); + moo->primitive_failed_sym = (moo_oop_char_t)moo_updateoopforgc(moo, (moo_oop_t)moo->primitive_failed_sym); + moo->unwindto_return_sym = (moo_oop_char_t)moo_updateoopforgc(moo, (moo_oop_t)moo->unwindto_return_sym); for (i = 0; i < moo->sem_list_count; i++) { - moo->sem_list[i] = (moo_oop_semaphore_t)moo_moveoop(moo, (moo_oop_t)moo->sem_list[i]); + moo->sem_list[i] = (moo_oop_semaphore_t)moo_updateoopforgc(moo, (moo_oop_t)moo->sem_list[i]); } for (i = 0; i < moo->sem_heap_count; i++) { - moo->sem_heap[i] = (moo_oop_semaphore_t)moo_moveoop(moo, (moo_oop_t)moo->sem_heap[i]); + moo->sem_heap[i] = (moo_oop_semaphore_t)moo_updateoopforgc(moo, (moo_oop_t)moo->sem_heap[i]); } for (i = 0; i < moo->sem_io_tuple_count; i++) { if (moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_INPUT]) - moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_INPUT] = (moo_oop_semaphore_t)moo_moveoop(moo, (moo_oop_t)moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_INPUT]); + moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_INPUT] = (moo_oop_semaphore_t)moo_updateoopforgc(moo, (moo_oop_t)moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_INPUT]); if (moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT]) - moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT] = (moo_oop_semaphore_t)moo_moveoop(moo, (moo_oop_t)moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT]); + moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT] = (moo_oop_semaphore_t)moo_updateoopforgc(moo, (moo_oop_t)moo->sem_io_tuple[i].sem[MOO_SEMAPHORE_IO_TYPE_OUTPUT]); } - moo->sem_gcfin = (moo_oop_semaphore_t)moo_moveoop(moo, (moo_oop_t)moo->sem_gcfin); + moo->sem_gcfin = (moo_oop_semaphore_t)moo_updateoopforgc(moo, (moo_oop_t)moo->sem_gcfin); for (i = 0; i < moo->proc_map_capa; i++) { - moo->proc_map[i] = moo_moveoop(moo, moo->proc_map[i]); + moo->proc_map[i] = moo_updateoopforgc(moo, moo->proc_map[i]); } for (i = 0; i < moo->volat_count; i++) { - *moo->volat_stack[i] = moo_moveoop(moo, *moo->volat_stack[i]); + *moo->volat_stack[i] = moo_updateoopforgc(moo, *moo->volat_stack[i]); } if (moo->initial_context) - moo->initial_context = (moo_oop_context_t)moo_moveoop(moo, (moo_oop_t)moo->initial_context); + moo->initial_context = (moo_oop_context_t)moo_updateoopforgc(moo, (moo_oop_t)moo->initial_context); if (moo->active_context) - moo->active_context = (moo_oop_context_t)moo_moveoop(moo, (moo_oop_t)moo->active_context); + moo->active_context = (moo_oop_context_t)moo_updateoopforgc(moo, (moo_oop_t)moo->active_context); if (moo->active_method) - moo->active_method = (moo_oop_method_t)moo_moveoop(moo, (moo_oop_t)moo->active_method); + moo->active_method = (moo_oop_method_t)moo_updateoopforgc(moo, (moo_oop_t)moo->active_method); moo_rbt_walk (&moo->modtab, call_module_gc, moo); @@ -1272,16 +1326,16 @@ static void scan_roots (moo_t* moo) } /* scan the objects in the permspace in case an object there points to an object outside the permspace */ - scan_heap_space (moo, (moo_uint8_t*)MOO_ALIGN((moo_uintptr_t)moo->heap->permspace.base, MOO_SIZEOF(moo_oop_t)), &moo->heap->permspace.ptr); + gc_ss_scan_space (moo, (moo_uint8_t*)MOO_ALIGN((moo_uintptr_t)moo->heap->permspace.base, MOO_SIZEOF(moo_oop_t)), &moo->heap->permspace.ptr); /* scan the new heap to move referenced objects */ - newspace_scan_ptr = scan_heap_space(moo, newspace_scan_ptr, &moo->heap->newspace.ptr); + newspace_scan_ptr = gc_ss_scan_space(moo, newspace_scan_ptr, &moo->heap->newspace.ptr); /* check finalizable objects registered and scan the heap again. * symbol table compation is placed after this phase assuming that * no symbol is added to be finalized. */ gcfin_count = move_finalizable_objects(moo); - newspace_scan_ptr = scan_heap_space(moo, newspace_scan_ptr, &moo->heap->newspace.ptr); + newspace_scan_ptr = gc_ss_scan_space(moo, newspace_scan_ptr, &moo->heap->newspace.ptr); /* traverse the symbol table for unreferenced symbols. * if the symbol has not moved to the new heap, the symbol @@ -1290,12 +1344,12 @@ static void scan_roots (moo_t* moo) /*if (!moo->igniting) */ compact_symbol_table (moo, old_nil); /* move the symbol table itself */ - moo->symtab = (moo_oop_dic_t)moo_moveoop(moo, (moo_oop_t)moo->symtab); + moo->symtab = (moo_oop_dic_t)moo_updateoopforgc(moo, (moo_oop_t)moo->symtab); /* scan the new heap again from the end position of * the previous scan to move referenced objects by * the symbol table. */ - newspace_scan_ptr = scan_heap_space(moo, newspace_scan_ptr, &moo->heap->newspace.ptr); + newspace_scan_ptr = gc_ss_scan_space(moo, newspace_scan_ptr, &moo->heap->newspace.ptr); /* the contents of the current heap is not needed any more. * reset the upper bound to the base. don't forget to align the heap @@ -1338,37 +1392,48 @@ static void scan_roots (moo_t* moo) } -void moo_gc (moo_t* moo) +void moo_gc (moo_t* moo, int full) { #if defined(MOO_ENABLE_GC_MARK_SWEEP) if (moo->gc_type == MOO_GC_TYPE_MARK_SWEEP) { MOO_LOG1 (moo, MOO_LOG_GC | MOO_LOG_INFO, "Starting GC (mark-sweep) - gci.bsz = %zu\n", moo->gci.bsz); + moo->gci.stack.len = 0; /*moo->gci.stack.max = 0;*/ - gc_mark_root (moo); - gc_sweep (moo); + gc_ms_mark_roots (moo); + + if (!full && moo->gci.lazy_sweep) + { + moo->gci.ls.prev = MOO_NULL; + moo->gci.ls.curr = moo->gci.b; + } + else + { + gc_ms_sweep (moo); + } + MOO_LOG2 (moo, MOO_LOG_GC | MOO_LOG_INFO, "Finished GC (mark-sweep) - gci.bsz = %zu, gci.stack.max %zu\n", moo->gci.bsz, moo->gci.stack.max); } else #endif { - scan_roots (moo); + gc_ss_scan_roots (moo); } } -moo_oop_t moo_moveoop (moo_t* moo, moo_oop_t oop) +moo_oop_t moo_updateoopforgc (moo_t* moo, moo_oop_t oop) { #if defined(MOO_ENABLE_GC_MARK_SWEEP) if (moo->gc_type == MOO_GC_TYPE_MARK_SWEEP) { - gc_mark (moo, oop); + gc_ms_mark (moo, oop); return oop; } else #endif { - return move_oop_in_heap_space(moo, oop); + return gc_ss_move_oop(moo, oop); } } @@ -1502,7 +1567,7 @@ static moo_oow_t move_finalizable_objects (moo_t* moo) for (x = moo->collectable.first; x; x = x->next) { MOO_ASSERT (moo, (MOO_OBJ_GET_FLAGS_GCFIN(x->oop) & (MOO_GCFIN_FINALIZABLE | MOO_GCFIN_FINALIZED)) == MOO_GCFIN_FINALIZABLE); - x->oop = moo_moveoop(moo, x->oop); + x->oop = moo_updateoopforgc(moo, x->oop); } for (x = moo->finalizable.first; x; ) @@ -1522,7 +1587,7 @@ static moo_oow_t move_finalizable_objects (moo_t* moo) * however this is quite unlikely because some key objects for VM execution * like context objects doesn't require finalization. */ - x->oop = moo_moveoop(moo, x->oop); + x->oop = moo_updateoopforgc(moo, x->oop); /* remove it from the finalizable list */ MOO_DELETE_FROM_LIST (&moo->finalizable, x); @@ -1534,7 +1599,7 @@ static moo_oow_t move_finalizable_objects (moo_t* moo) } else { - x->oop = moo_moveoop(moo, x->oop); + x->oop = moo_updateoopforgc(moo, x->oop); } x = y; diff --git a/moo/lib/heap.c b/moo/lib/heap.c index dd414f8..f5552d0 100644 --- a/moo/lib/heap.c +++ b/moo/lib/heap.c @@ -55,7 +55,7 @@ moo_heap_t* moo_makeheap (moo_t* moo, moo_oow_t size) if (MOO_UNLIKELY(!heap)) { const moo_ooch_t* oldmsg = moo_backuperrmsg(moo); - moo_seterrbfmt (moo, moo_geterrnum(moo), "unable to allocate heap - %js", oldmsg); + moo_seterrbfmt (moo, moo_geterrnum(moo), "unable to allocate a heap - %js", oldmsg); return MOO_NULL; } diff --git a/moo/lib/moo.c b/moo/lib/moo.c index 9221a48..0724b19 100644 --- a/moo/lib/moo.c +++ b/moo/lib/moo.c @@ -276,7 +276,7 @@ void moo_fini (moo_t* moo) } while (moo->gci.b); - MOO_ASSERT (moo, moo->gci.bsz == 0); + MOO_ASSERT (moo, moo->gci.bsz == 0); } if (moo->gci.stack.ptr) diff --git a/moo/lib/moo.h b/moo/lib/moo.h index d0ef763..dfe6643 100644 --- a/moo/lib/moo.h +++ b/moo/lib/moo.h @@ -1816,15 +1816,20 @@ struct moo_t struct { moo_gchdr_t* b; /* object blocks allocated */ + struct + { + moo_gchdr_t* curr; + moo_gchdr_t* prev; + } ls; moo_oow_t bsz; /* total size of object blocks allocated */ moo_oow_t threshold; + int lazy_sweep; struct { moo_oop_t* ptr; moo_oow_t capa; moo_oow_t len; - moo_oow_t max; } stack; } gci; @@ -2219,15 +2224,16 @@ MOO_EXPORT void moo_deregevtcb ( * It is not affected by #MOO_TRAIT_NOGC. */ MOO_EXPORT void moo_gc ( - moo_t* moo + moo_t* moo, + int full ); /** - * The moo_moveoop() function moves an object and returns an updated pointer - * after having moved. it must be called in the GC callback context only. + * The moo_updateoopforgc() function moves an object and returns an updated pointer + * after having moved. It must be called in the GC callback context only. */ -MOO_EXPORT moo_oop_t moo_moveoop ( +MOO_EXPORT moo_oop_t moo_updateoopforgc ( moo_t* moo, moo_oop_t oop ); diff --git a/moo/lib/obj.c b/moo/lib/obj.c index 220a4cc..ea47319 100644 --- a/moo/lib/obj.c +++ b/moo/lib/obj.c @@ -30,7 +30,7 @@ void* moo_allocbytes (moo_t* moo, moo_oow_t size) { #if defined(MOO_BUILD_DEBUG) /* DEBUG_GC is set but NOGC is not set */ - if ((moo->option.trait & (MOO_TRAIT_DEBUG_GC | MOO_TRAIT_NOGC)) == MOO_TRAIT_DEBUG_GC) moo_gc (moo); + if ((moo->option.trait & (MOO_TRAIT_DEBUG_GC | MOO_TRAIT_NOGC)) == MOO_TRAIT_DEBUG_GC) moo_gc (moo, 1); #endif #if defined(MOO_ENABLE_GC_MARK_SWEEP) @@ -45,19 +45,37 @@ void* moo_allocbytes (moo_t* moo, moo_oow_t size) } else { + moo_oow_t allocsize; + if (moo->gci.bsz >= moo->gci.threshold) { - moo_gc (moo); + moo_gc (moo, 0); moo->gci.threshold = moo->gci.bsz + 100000; /* TODO: change this fomula */ } - gch = (moo_gchdr_t*)moo_callocheapmem(moo, moo->heap, MOO_SIZEOF(*gch) + size); + allocsize = MOO_SIZEOF(*gch) + size; + if (moo->gci.lazy_sweep) moo_gc_ms_sweep_lazy (moo, allocsize); + + gch = (moo_gchdr_t*)moo_callocheapmem(moo, moo->heap, allocsize); if (!gch && moo->errnum == MOO_EOOMEM && !(moo->option.trait & MOO_TRAIT_NOGC)) { - moo_gc (moo); - MOO_LOG0 (moo, MOO_LOG_GC | MOO_LOG_INFO, "GC completed\n"); /* TODO: add more inforamtion */ - gch = (moo_gchdr_t*)moo_callocheapmem(moo, moo->heap, MOO_SIZEOF(*gch) + size); - if (MOO_UNLIKELY(!gch)) return MOO_NULL; + moo_gc (moo, 0); + if (moo->gci.lazy_sweep) moo_gc_ms_sweep_lazy (moo, allocsize); + + gch = (moo_gchdr_t*)moo_callocheapmem(moo, moo->heap, allocsize); + if (MOO_UNLIKELY(!gch)) + { + if (moo->gci.lazy_sweep) + { + moo_gc_ms_sweep_lazy (moo, MOO_TYPE_MAX(moo_oow_t)); /* sweep the rest */ + gch = (moo_gchdr_t*)moo_callocheapmem(moo, moo->heap, allocsize); + if (MOO_UNLIKELY(!gch)) return MOO_NULL; + } + else + { + return MOO_NULL; + } + } } } @@ -82,7 +100,7 @@ void* moo_allocbytes (moo_t* moo, moo_oow_t size) ptr = (moo_uint8_t*)moo_allocheapspace(moo, &moo->heap->curspace, size); if (!ptr && moo->errnum == MOO_EOOMEM && !(moo->option.trait & MOO_TRAIT_NOGC)) { - moo_gc (moo); + moo_gc (moo, 1); MOO_LOG4 (moo, MOO_LOG_GC | MOO_LOG_INFO, "GC completed - current heap ptr %p limit %p size %zd free %zd\n", moo->heap->curspace.ptr, moo->heap->curspace.limit, diff --git a/moo/lib/pf-sys.c b/moo/lib/pf-sys.c index b049812..652710a 100644 --- a/moo/lib/pf-sys.c +++ b/moo/lib/pf-sys.c @@ -239,7 +239,7 @@ moo_pfrc_t moo_pf_system_find_next_process (moo_t* moo, moo_mod_t* mod, moo_ooi_ moo_pfrc_t moo_pf_system_collect_garbage (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs) { - moo_gc (moo); + moo_gc (moo, 1); MOO_STACK_SETRETTORCV (moo, nargs); return MOO_PF_SUCCESS; } diff --git a/moo/mod/sck.c b/moo/mod/sck.c index 538c04f..caad93b 100644 --- a/moo/mod/sck.c +++ b/moo/mod/sck.c @@ -615,7 +615,7 @@ static void gc_mod_sck (moo_t* moo, moo_mod_t* mod) MOO_ASSERT (moo, ctx != MOO_NULL); if (ctx->sck_class) { - ctx->sck_class = (moo_oop_class_t)moo_moveoop(moo, (moo_oop_t)ctx->sck_class); + ctx->sck_class = (moo_oop_class_t)moo_updateoopforgc(moo, (moo_oop_t)ctx->sck_class); } } diff --git a/moo/mod/x11.c b/moo/mod/x11.c index 9fec787..bf7075c 100644 --- a/moo/mod/x11.c +++ b/moo/mod/x11.c @@ -834,7 +834,7 @@ static void gc_mod_x11 (moo_t* moo, moo_mod_t* mod) x11_modctx_t* ctx = mod->ctx; MOO_ASSERT (moo, ctx != MOO_NULL); - ctx->x11_class = (moo_oop_class_t)moo_moveoop(moo, (moo_oop_t)ctx->x11_class); + ctx->x11_class = (moo_oop_class_t)moo_updateoopforgc(moo, (moo_oop_t)ctx->x11_class); } int moo_mod_x11 (moo_t* moo, moo_mod_t* mod)