static void
clear_all_old(mrb_state *mrb)
{
size_t origin_mode = mrb->is_generational_gc_mode;
gc_assert(is_generational(mrb));
if (is_major_gc(mrb)) {
advance_phase(mrb, GC_STATE_NONE);
}
mrb->is_generational_gc_mode = FALSE;
prepare_incremental_sweep(mrb);
advance_phase(mrb, GC_STATE_NONE);
mrb->variable_gray_list = mrb->gray_list = NULL;
mrb->is_generational_gc_mode = origin_mode;
}
MRB_API void
mrb_incremental_gc(mrb_state *mrb)
{
mrb_gc *gc = &mrb->gc;
if (gc->disabled || gc->iterating) return;
GC_INVOKE_TIME_REPORT("mrb_incremental_gc()");
GC_TIME_START;
if (is_minor_gc(gc)) {
incremental_gc_until(mrb, gc, MRB_GC_STATE_ROOT);
}
else {
incremental_gc_step(mrb, gc);
}
if (gc->state == MRB_GC_STATE_ROOT) {
mrb_assert(gc->live >= gc->live_after_mark);
gc->threshold = (gc->live_after_mark/100) * gc->interval_ratio;
if (gc->threshold < GC_STEP_SIZE) {
gc->threshold = GC_STEP_SIZE;
}
if (is_major_gc(gc)) {
size_t threshold = gc->live_after_mark/100 * MAJOR_GC_INC_RATIO;
gc->full = FALSE;
if (threshold < MAJOR_GC_TOOMANY) {
gc->majorgc_old_threshold = threshold;
}
else {
/* too many objects allocated during incremental GC, */
/* instead of increasing threshold, invoke full GC. */
mrb_full_gc(mrb);
}
}
else if (is_minor_gc(gc)) {
if (gc->live > gc->majorgc_old_threshold) {
clear_all_old(mrb, gc);
gc->full = TRUE;
}
}
}
GC_TIME_STOP_AND_REPORT;
}
void
mrb_incremental_gc(mrb_state *mrb)
{
if (mrb->gc_disabled) return;
GC_INVOKE_TIME_REPORT("mrb_incremental_gc()");
GC_TIME_START;
if (is_minor_gc(mrb)) {
do {
incremental_gc(mrb, ~0);
} while (mrb->gc_state != GC_STATE_NONE);
}
else {
size_t limit = 0, result = 0;
limit = (GC_STEP_SIZE/100) * mrb->gc_step_ratio;
while (result < limit) {
result += incremental_gc(mrb, limit);
if (mrb->gc_state == GC_STATE_NONE)
break;
}
}
if (mrb->gc_state == GC_STATE_NONE) {
gc_assert(mrb->live >= mrb->gc_live_after_mark);
mrb->gc_threshold = (mrb->gc_live_after_mark/100) * mrb->gc_interval_ratio;
if (mrb->gc_threshold < GC_STEP_SIZE) {
mrb->gc_threshold = GC_STEP_SIZE;
}
if (is_major_gc(mrb)) {
mrb->majorgc_old_threshold = mrb->gc_live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO;
mrb->gc_full = FALSE;
}
else if (is_minor_gc(mrb)) {
if (mrb->live > mrb->majorgc_old_threshold) {
clear_all_old(mrb);
mrb->gc_full = TRUE;
}
}
}
else {
mrb->gc_threshold = mrb->live + GC_STEP_SIZE;
}
GC_TIME_STOP_AND_REPORT;
}
static void
change_gen_gc_mode(mrb_state *mrb, mrb_int enable)
{
if (is_generational(mrb) && !enable) {
if (is_major_gc(mrb)) {
advance_phase(mrb, GC_STATE_NONE);
}
else {
clear_all_old(mrb);
gc_assert(mrb->gc_state == GC_STATE_NONE);
}
mrb->gc_full = FALSE;
}
else if (!is_generational(mrb) && enable) {
advance_phase(mrb, GC_STATE_NONE);
mrb->majorgc_old_threshold = mrb->gc_live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO;
mrb->gc_full = FALSE;
}
mrb->is_generational_gc_mode = enable;
}
static void
clear_all_old(mrb_state *mrb)
{
mrb_bool origin_mode = mrb->is_generational_gc_mode;
mrb_assert(is_generational(mrb));
if (is_major_gc(mrb)) {
/* finish the half baked GC */
incremental_gc_until(mrb, GC_STATE_NONE);
}
/* Sweep the dead objects, then reset all the live objects
* (including all the old objects, of course) to white. */
mrb->is_generational_gc_mode = FALSE;
prepare_incremental_sweep(mrb);
incremental_gc_until(mrb, GC_STATE_NONE);
mrb->is_generational_gc_mode = origin_mode;
/* The gray objects has already been painted as white */
mrb->atomic_gray_list = mrb->gray_list = NULL;
}
static void
clear_all_old(mrb_state *mrb, mrb_gc *gc)
{
mrb_bool origin_mode = gc->generational;
mrb_assert(is_generational(gc));
if (is_major_gc(gc)) {
/* finish the half baked GC */
incremental_gc_until(mrb, gc, MRB_GC_STATE_ROOT);
}
/* Sweep the dead objects, then reset all the live objects
* (including all the old objects, of course) to white. */
gc->generational = FALSE;
prepare_incremental_sweep(mrb, gc);
incremental_gc_until(mrb, gc, MRB_GC_STATE_ROOT);
gc->generational = origin_mode;
/* The gray objects have already been painted as white */
gc->atomic_gray_list = gc->gray_list = NULL;
}
MRB_API void
mrb_incremental_gc(mrb_state *mrb)
{
mrb_gc *gc = &mrb->gc;
if (gc->disabled || gc->iterating) return;
GC_INVOKE_TIME_REPORT("mrb_incremental_gc()");
GC_TIME_START;
if (is_minor_gc(gc)) {
incremental_gc_until(mrb, gc, MRB_GC_STATE_ROOT);
}
else {
incremental_gc_step(mrb, gc);
}
if (gc->state == MRB_GC_STATE_ROOT) {
mrb_assert(gc->live >= gc->live_after_mark);
gc->threshold = (gc->live_after_mark/100) * gc->interval_ratio;
if (gc->threshold < GC_STEP_SIZE) {
gc->threshold = GC_STEP_SIZE;
}
if (is_major_gc(gc)) {
gc->majorgc_old_threshold = gc->live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO;
gc->full = FALSE;
}
else if (is_minor_gc(gc)) {
if (gc->live > gc->majorgc_old_threshold) {
clear_all_old(mrb, gc);
gc->full = TRUE;
}
}
}
GC_TIME_STOP_AND_REPORT;
}
void
mrb_incremental_gc(mrb_state *mrb)
{
if (mrb->gc_disabled) return;
GC_INVOKE_TIME_REPORT("mrb_incremental_gc()");
GC_TIME_START;
if (is_minor_gc(mrb)) {
incremental_gc_until(mrb, GC_STATE_NONE);
}
else {
incremental_gc_step(mrb);
}
if (mrb->gc_state == GC_STATE_NONE) {
mrb_assert(mrb->live >= mrb->gc_live_after_mark);
mrb->gc_threshold = (mrb->gc_live_after_mark/100) * mrb->gc_interval_ratio;
if (mrb->gc_threshold < GC_STEP_SIZE) {
mrb->gc_threshold = GC_STEP_SIZE;
}
if (is_major_gc(mrb)) {
mrb->majorgc_old_threshold = mrb->gc_live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO;
mrb->gc_full = FALSE;
}
else if (is_minor_gc(mrb)) {
if (mrb->live > mrb->majorgc_old_threshold) {
clear_all_old(mrb);
mrb->gc_full = TRUE;
}
}
}
GC_TIME_STOP_AND_REPORT;
}
void
test_incremental_gc(void)
{
mrb_state *mrb = mrb_open();
size_t max = ~0, live = 0, total = 0, freed = 0;
RVALUE *free;
struct heap_page *page;
puts("test_incremental_gc");
change_gen_gc_mode(mrb, FALSE);
puts(" in mrb_full_gc");
mrb_full_gc(mrb);
mrb_assert(mrb->gc_state == GC_STATE_NONE);
puts(" in GC_STATE_NONE");
incremental_gc(mrb, max);
mrb_assert(mrb->gc_state == GC_STATE_MARK);
puts(" in GC_STATE_MARK");
incremental_gc_until(mrb, GC_STATE_SWEEP);
mrb_assert(mrb->gc_state == GC_STATE_SWEEP);
puts(" in GC_STATE_SWEEP");
page = mrb->heaps;
while (page) {
RVALUE *p = page->objects;
RVALUE *e = p + MRB_HEAP_PAGE_SIZE;
while (p<e) {
if (is_black(&p->as.basic)) {
live++;
}
if (is_gray(&p->as.basic) && !is_dead(mrb, &p->as.basic)) {
printf("%p\n", &p->as.basic);
}
p++;
}
page = page->next;
total += MRB_HEAP_PAGE_SIZE;
}
mrb_assert(mrb->gray_list == NULL);
incremental_gc(mrb, max);
mrb_assert(mrb->gc_state == GC_STATE_SWEEP);
incremental_gc(mrb, max);
mrb_assert(mrb->gc_state == GC_STATE_NONE);
free = (RVALUE*)mrb->heaps->freelist;
while (free) {
freed++;
free = (RVALUE*)free->as.free.next;
}
mrb_assert(mrb->live == live);
mrb_assert(mrb->live == total-freed);
puts("test_incremental_gc(gen)");
incremental_gc_until(mrb, GC_STATE_SWEEP);
change_gen_gc_mode(mrb, TRUE);
mrb_assert(mrb->gc_full == FALSE);
mrb_assert(mrb->gc_state == GC_STATE_NONE);
puts(" in minor");
mrb_assert(is_minor_gc(mrb));
mrb_assert(mrb->majorgc_old_threshold > 0);
mrb->majorgc_old_threshold = 0;
mrb_incremental_gc(mrb);
mrb_assert(mrb->gc_full == TRUE);
mrb_assert(mrb->gc_state == GC_STATE_NONE);
puts(" in major");
mrb_assert(is_major_gc(mrb));
do {
mrb_incremental_gc(mrb);
} while (mrb->gc_state != GC_STATE_NONE);
mrb_assert(mrb->gc_full == FALSE);
mrb_close(mrb);
}
