From 3ab2f9371e60039936356afaee9f509d782259fd Mon Sep 17 00:00:00 2001 From: furunkel Date: Mon, 19 Oct 2015 22:29:43 +0200 Subject: Clean up GC code --- include/mruby.h | 34 +++----------------------- include/mruby/gc.h | 65 +++++++++++++++++++++++++++++++++++++++++++++++--- include/mruby/object.h | 18 -------------- 3 files changed, 65 insertions(+), 52 deletions(-) (limited to 'include') diff --git a/include/mruby.h b/include/mruby.h index d50ec3496..452caed07 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -35,6 +35,7 @@ #include "mrbconf.h" #include "mruby/common.h" #include "mruby/value.h" +#include "mruby/gc.h" #include "mruby/version.h" /** @@ -114,16 +115,11 @@ struct mrb_context { struct RFiber *fib; }; -enum gc_state { - GC_STATE_ROOT = 0, - GC_STATE_MARK, - GC_STATE_SWEEP -}; - struct mrb_jmpbuf; typedef void (*mrb_atexit_func)(struct mrb_state*); + typedef struct mrb_state { struct mrb_jmpbuf *jmp; @@ -153,32 +149,8 @@ typedef struct mrb_state { struct RClass *symbol_class; struct RClass *kernel_module; - struct heap_page *heaps; /* heaps for GC */ - struct heap_page *sweeps; - struct heap_page *free_heaps; - size_t live; /* count of live objects */ -#ifdef MRB_GC_FIXED_ARENA - struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */ -#else - struct RBasic **arena; /* GC protection array */ - int arena_capa; -#endif - int arena_idx; - - enum gc_state gc_state; /* state of gc */ - int current_white_part; /* make white object by white_part */ - struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */ - struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */ - size_t gc_live_after_mark; - size_t gc_threshold; - int gc_interval_ratio; - int gc_step_ratio; - mrb_bool gc_disabled:1; - mrb_bool gc_full:1; - mrb_bool is_generational_gc_mode:1; - mrb_bool out_of_memory:1; - size_t majorgc_old_threshold; struct alloca_header *mems; + mrb_gc gc; mrb_sym symidx; struct kh_n2s *name2sym; /* symbol hash */ diff --git a/include/mruby/gc.h b/include/mruby/gc.h index 0b33617de..2bd8b8539 100644 --- a/include/mruby/gc.h +++ b/include/mruby/gc.h @@ -14,9 +14,68 @@ */ MRB_BEGIN_DECL -typedef void (mrb_each_object_callback)(mrb_state *mrb, struct RBasic *obj, void *data); -void mrb_objspace_each_objects(mrb_state *mrb, mrb_each_object_callback *callback, void *data); -MRB_API void mrb_free_context(mrb_state *mrb, struct mrb_context *c); + +struct mrb_state; + +typedef void (mrb_each_object_callback)(struct mrb_state *mrb, struct RBasic *obj, void *data); +void mrb_objspace_each_objects(struct mrb_state *mrb, mrb_each_object_callback *callback, void *data); +MRB_API void mrb_free_context(struct mrb_state *mrb, struct mrb_context *c); + + +/* white: 011, black: 100, gray: 000 */ +#define MRB_GC_GRAY 0 +#define MRB_GC_WHITE_A 1 +#define MRB_GC_WHITE_B (1 << 1) +#define MRB_GC_BLACK (1 << 2) +#define MRB_GC_WHITES (MRB_GC_WHITE_A | MRB_GC_WHITE_B) +#define MRB_GC_COLOR_MASK 7 + +typedef enum { + GC_STATE_ROOT = 0, + GC_STATE_MARK, + GC_STATE_SWEEP +} mrb_gc_state; + +typedef struct mrb_heap_page { + struct RBasic *freelist; + struct mrb_heap_page *prev; + struct mrb_heap_page *next; + struct mrb_heap_page *free_next; + struct mrb_heap_page *free_prev; + mrb_bool old:1; + void *objects[]; +} mrb_heap_page; + +typedef struct mrb_gc { + mrb_heap_page *heaps; /* heaps for GC */ + mrb_heap_page *sweeps; + mrb_heap_page *free_heaps; + size_t live; /* count of live objects */ +#ifdef MRB_GC_FIXED_ARENA + struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */ +#else + struct RBasic **arena; /* GC protection array */ + int arena_capa; +#endif + int arena_idx; + + mrb_gc_state gc_state; /* state of gc */ + int current_white_part; /* make white object by white_part */ + struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */ + struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */ + size_t gc_live_after_mark; + size_t gc_threshold; + int gc_interval_ratio; + int gc_step_ratio; + mrb_bool disabled :1; + mrb_bool full :1; + mrb_bool generational :1; + mrb_bool out_of_memory :1; + size_t majorgc_old_threshold; +} mrb_gc; + +MRB_API mrb_bool +mrb_object_dead_p(struct mrb_state *mrb, struct RObject *object); MRB_END_DECL diff --git a/include/mruby/object.h b/include/mruby/object.h index 6633a23e8..9fbfe34f3 100644 --- a/include/mruby/object.h +++ b/include/mruby/object.h @@ -16,24 +16,6 @@ #define MRB_FLAG_TEST(obj, flag) ((obj)->flags & flag) -/* white: 011, black: 100, gray: 000 */ -#define MRB_GC_GRAY 0 -#define MRB_GC_WHITE_A 1 -#define MRB_GC_WHITE_B (1 << 1) -#define MRB_GC_BLACK (1 << 2) -#define MRB_GC_WHITES (MRB_GC_WHITE_A | MRB_GC_WHITE_B) -#define MRB_GC_COLOR_MASK 7 - -#define paint_gray(o) ((o)->color = MRB_GC_GRAY) -#define paint_black(o) ((o)->color = MRB_GC_BLACK) -#define paint_white(o) ((o)->color = MRB_GC_WHITES) -#define paint_partial_white(s, o) ((o)->color = (s)->current_white_part) -#define is_gray(o) ((o)->color == MRB_GC_GRAY) -#define is_white(o) ((o)->color & MRB_GC_WHITES) -#define is_black(o) ((o)->color & MRB_GC_BLACK) -#define is_dead(s, o) (((o)->color & other_white_part(s) & MRB_GC_WHITES) || (o)->tt == MRB_TT_FREE) -#define flip_white_part(s) ((s)->current_white_part = other_white_part(s)) -#define other_white_part(s) ((s)->current_white_part ^ MRB_GC_WHITES) struct RBasic { MRB_OBJECT_HEADER; -- cgit v1.2.3 From 5c093ed22b1a5200d50b221832d5d04f6d38c21b Mon Sep 17 00:00:00 2001 From: furunkel Date: Mon, 19 Oct 2015 22:34:47 +0200 Subject: Remove segregated value struct declaration --- include/mruby.h | 1 - src/gc.c | 34 ---------------------------------- 2 files changed, 35 deletions(-) (limited to 'include') diff --git a/include/mruby.h b/include/mruby.h index 452caed07..8a26146df 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -119,7 +119,6 @@ struct mrb_jmpbuf; typedef void (*mrb_atexit_func)(struct mrb_state*); - typedef struct mrb_state { struct mrb_jmpbuf *jmp; diff --git a/src/gc.c b/src/gc.c index 3c10a1311..c4257d400 100644 --- a/src/gc.c +++ b/src/gc.c @@ -97,40 +97,6 @@ struct free_obj { struct RBasic *next; }; -typedef struct { - union { - struct free_obj free; - struct RBasic basic; - struct RClass klass; - struct RProc proc; - struct RException exc; - } as; -} infreq_value; - -typedef struct { - union { - struct free_obj free; - struct RBasic basic; - struct RObject object; -#ifdef MRB_WORD_BOXING - struct RFloat floatv; - struct RCptr cptr; -#endif - } as; -} small_value; - -typedef struct { - union { - struct free_obj free; - struct RBasic basic; - struct RString string; - struct RArray array; - struct RHash hash; - struct RRange range; - struct RData data; - } as; -} large_value; - typedef struct { union { struct free_obj free; -- cgit v1.2.3 From 2f8b0f66bcce744a5cf6320237087d29313c9855 Mon Sep 17 00:00:00 2001 From: furunkel Date: Mon, 19 Oct 2015 22:43:09 +0200 Subject: Move MRB_GC_ARENA_SIZE to gc.h and fix compiler warnings --- include/mruby.h | 4 ---- include/mruby/gc.h | 6 +++++- src/gc.c | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) (limited to 'include') diff --git a/include/mruby.h b/include/mruby.h index 8a26146df..b0161aff7 100644 --- a/include/mruby.h +++ b/include/mruby.h @@ -65,10 +65,6 @@ struct mrb_state; */ typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud); -#ifndef MRB_GC_ARENA_SIZE -#define MRB_GC_ARENA_SIZE 100 -#endif - #ifndef MRB_FIXED_STATE_ATEXIT_STACK_SIZE #define MRB_FIXED_STATE_ATEXIT_STACK_SIZE 5 #endif diff --git a/include/mruby/gc.h b/include/mruby/gc.h index 2bd8b8539..d7687c05e 100644 --- a/include/mruby/gc.h +++ b/include/mruby/gc.h @@ -30,6 +30,10 @@ MRB_API void mrb_free_context(struct mrb_state *mrb, struct mrb_context *c); #define MRB_GC_WHITES (MRB_GC_WHITE_A | MRB_GC_WHITE_B) #define MRB_GC_COLOR_MASK 7 +#ifndef MRB_GC_ARENA_SIZE +#define MRB_GC_ARENA_SIZE 100 +#endif + typedef enum { GC_STATE_ROOT = 0, GC_STATE_MARK, @@ -75,7 +79,7 @@ typedef struct mrb_gc { } mrb_gc; MRB_API mrb_bool -mrb_object_dead_p(struct mrb_state *mrb, struct RObject *object); +mrb_object_dead_p(struct mrb_state *mrb, struct RBasic *object); MRB_END_DECL diff --git a/src/gc.c b/src/gc.c index c4257d400..360002c5d 100644 --- a/src/gc.c +++ b/src/gc.c @@ -260,7 +260,7 @@ mrb_free(mrb_state *mrb, void *p) } MRB_API mrb_bool -mrb_object_dead_p(mrb_state *mrb, struct RObject *object) { +mrb_object_dead_p(mrb_state *mrb, struct RBasic *object) { return is_dead(&mrb->gc, object); } @@ -394,7 +394,7 @@ gc_protect(mrb_state *mrb, mrb_gc *gc, struct RBasic *p) if (gc->arena_idx >= MRB_GC_ARENA_SIZE) { /* arena overflow error */ gc->arena_idx = MRB_GC_ARENA_SIZE - 4; /* force room in arena */ - mrb_raise(gc, E_RUNTIME_ERROR, "arena overflow error"); + mrb_raise(mrb, E_RUNTIME_ERROR, "arena overflow error"); } #else if (gc->arena_idx >= gc->arena_capa) { -- cgit v1.2.3 From 2b39d87fe8794ac66bce4896f1ec346579983500 Mon Sep 17 00:00:00 2001 From: furunkel Date: Mon, 19 Oct 2015 23:00:07 +0200 Subject: Remove gc_ prefix of mrb_gc fields --- include/mruby/gc.h | 10 +++--- src/gc.c | 96 +++++++++++++++++++++++++++--------------------------- 2 files changed, 53 insertions(+), 53 deletions(-) (limited to 'include') diff --git a/include/mruby/gc.h b/include/mruby/gc.h index d7687c05e..3c19e13e8 100644 --- a/include/mruby/gc.h +++ b/include/mruby/gc.h @@ -63,14 +63,14 @@ typedef struct mrb_gc { #endif int arena_idx; - mrb_gc_state gc_state; /* state of gc */ + mrb_gc_state state; /* state of gc */ int current_white_part; /* make white object by white_part */ struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */ struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */ - size_t gc_live_after_mark; - size_t gc_threshold; - int gc_interval_ratio; - int gc_step_ratio; + size_t live_after_mark; + size_t threshold; + int interval_ratio; + int step_ratio; mrb_bool disabled :1; mrb_bool full :1; mrb_bool generational :1; diff --git a/src/gc.c b/src/gc.c index 360002c5d..ff729f150 100644 --- a/src/gc.c +++ b/src/gc.c @@ -147,10 +147,10 @@ gettimeofday_time(void) #define GC_TIME_STOP_AND_REPORT do {\ gc_time = gettimeofday_time() - gc_time;\ gc_total_time += gc_time;\ - fprintf(stderr, "gc_state: %d\n", gc->gc_state);\ + fprintf(stderr, "gc_state: %d\n", gc->state);\ fprintf(stderr, "live: %zu\n", gc->live);\ fprintf(stderr, "majorgc_old_threshold: %zu\n", gc->majorgc_old_threshold);\ - fprintf(stderr, "gc_threshold: %zu\n", gc->gc_threshold);\ + fprintf(stderr, "gc_threshold: %zu\n", gc->threshold);\ fprintf(stderr, "gc_time: %30.20f\n", gc_time);\ fprintf(stderr, "gc_total_time: %30.20f\n\n", gc_total_time);\ } while(0) @@ -346,8 +346,8 @@ mrb_gc_init(mrb_state *mrb, mrb_gc *gc) gc->heaps = NULL; gc->free_heaps = NULL; add_heap(mrb, gc); - gc->gc_interval_ratio = DEFAULT_GC_INTERVAL_RATIO; - gc->gc_step_ratio = DEFAULT_GC_STEP_RATIO; + gc->interval_ratio = DEFAULT_GC_INTERVAL_RATIO; + gc->step_ratio = DEFAULT_GC_STEP_RATIO; #ifndef MRB_GC_TURN_OFF_GENERATIONAL gc->generational = TRUE; gc->full = TRUE; @@ -471,7 +471,7 @@ mrb_obj_alloc(mrb_state *mrb, enum mrb_vtype ttype, struct RClass *cls) #ifdef MRB_GC_STRESS mrb_full_gc(mrb); #endif - if (gc->gc_threshold < gc->live) { + if (gc->threshold < gc->live) { mrb_incremental_gc(mrb); } if (gc->free_heaps == NULL) { @@ -923,9 +923,9 @@ final_marking_phase(mrb_state *mrb, mrb_gc *gc) static void prepare_incremental_sweep(mrb_state *mrb, mrb_gc *gc) { - gc->gc_state = GC_STATE_SWEEP; + gc->state = GC_STATE_SWEEP; gc->sweeps = gc->heaps; - gc->gc_live_after_mark = gc->live; + gc->live_after_mark = gc->live; } static size_t @@ -984,7 +984,7 @@ incremental_sweep_phase(mrb_state *mrb, mrb_gc *gc, size_t limit) } tried_sweep += MRB_HEAP_PAGE_SIZE; gc->live -= freed; - gc->gc_live_after_mark -= freed; + gc->live_after_mark -= freed; } gc->sweeps = page; return tried_sweep; @@ -993,10 +993,10 @@ incremental_sweep_phase(mrb_state *mrb, mrb_gc *gc, size_t limit) static size_t incremental_gc(mrb_state *mrb, mrb_gc *gc, size_t limit) { - switch (gc->gc_state) { + switch (gc->state) { case GC_STATE_ROOT: root_scan_phase(mrb, gc); - gc->gc_state = GC_STATE_MARK; + gc->state = GC_STATE_MARK; flip_white_part(gc); return 0; case GC_STATE_MARK: @@ -1012,7 +1012,7 @@ incremental_gc(mrb_state *mrb, mrb_gc *gc, size_t limit) size_t tried_sweep = 0; tried_sweep = incremental_sweep_phase(mrb, gc, limit); if (tried_sweep == 0) - gc->gc_state = GC_STATE_ROOT; + gc->state = GC_STATE_ROOT; return tried_sweep; } default: @@ -1027,21 +1027,21 @@ incremental_gc_until(mrb_state *mrb, mrb_gc *gc, mrb_gc_state to_state) { do { incremental_gc(mrb, gc, SIZE_MAX); - } while (gc->gc_state != to_state); + } while (gc->state != to_state); } static void incremental_gc_step(mrb_state *mrb, mrb_gc *gc) { size_t limit = 0, result = 0; - limit = (GC_STEP_SIZE/100) * gc->gc_step_ratio; + limit = (GC_STEP_SIZE/100) * gc->step_ratio; while (result < limit) { result += incremental_gc(mrb, gc, limit); - if (gc->gc_state == GC_STATE_ROOT) + if (gc->state == GC_STATE_ROOT) break; } - gc->gc_threshold = gc->live + GC_STEP_SIZE; + gc->threshold = gc->live + GC_STEP_SIZE; } static void @@ -1083,15 +1083,15 @@ mrb_incremental_gc(mrb_state *mrb) incremental_gc_step(mrb, gc); } - if (gc->gc_state == GC_STATE_ROOT) { - mrb_assert(gc->live >= gc->gc_live_after_mark); - gc->gc_threshold = (gc->gc_live_after_mark/100) * gc->gc_interval_ratio; - if (gc->gc_threshold < GC_STEP_SIZE) { - gc->gc_threshold = GC_STEP_SIZE; + if (gc->state == 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->gc_live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO; + gc->majorgc_old_threshold = gc->live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO; gc->full = FALSE; } else if (is_minor_gc(gc)) { @@ -1121,16 +1121,16 @@ mrb_full_gc(mrb_state *mrb) clear_all_old(mrb, gc); gc->full = TRUE; } - else if (gc->gc_state != GC_STATE_ROOT) { + else if (gc->state != GC_STATE_ROOT) { /* finish half baked GC cycle */ incremental_gc_until(mrb, gc, GC_STATE_ROOT); } incremental_gc_until(mrb, gc, GC_STATE_ROOT); - gc->gc_threshold = (gc->gc_live_after_mark/100) * gc->gc_interval_ratio; + gc->threshold = (gc->live_after_mark/100) * gc->interval_ratio; if (is_generational(gc)) { - gc->majorgc_old_threshold = gc->gc_live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO; + gc->majorgc_old_threshold = gc->live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO; gc->full = FALSE; } @@ -1185,13 +1185,13 @@ mrb_field_write_barrier(mrb_state *mrb, struct RBasic *obj, struct RBasic *value if (!is_white(value)) return; mrb_assert(!is_dead(gc, value) && !is_dead(gc, obj)); - mrb_assert(is_generational(gc) || mrb->gc.gc_state != GC_STATE_ROOT); + mrb_assert(is_generational(gc) || mrb->gc.state != GC_STATE_ROOT); - if (is_generational(gc) || mrb->gc.gc_state == GC_STATE_MARK) { + if (is_generational(gc) || mrb->gc.state == GC_STATE_MARK) { add_gray_list(mrb, gc, value); } else { - mrb_assert(mrb->gc.gc_state == GC_STATE_SWEEP); + mrb_assert(mrb->gc.state == GC_STATE_SWEEP); paint_partial_white(gc, obj); /* for never write barriers */ } } @@ -1213,7 +1213,7 @@ mrb_write_barrier(mrb_state *mrb, struct RBasic *obj) if (!is_black(obj)) return; mrb_assert(!is_dead(gc, obj)); - mrb_assert(is_generational(gc) || gc->gc_state != GC_STATE_ROOT); + mrb_assert(is_generational(gc) || gc->state != GC_STATE_ROOT); paint_gray(obj); obj->gcnext = gc->atomic_gray_list; gc->atomic_gray_list = obj; @@ -1290,7 +1290,7 @@ gc_disable(mrb_state *mrb, mrb_value obj) static mrb_value gc_interval_ratio_get(mrb_state *mrb, mrb_value obj) { - return mrb_fixnum_value(mrb->gc.gc_interval_ratio); + return mrb_fixnum_value(mrb->gc.interval_ratio); } /* @@ -1308,7 +1308,7 @@ gc_interval_ratio_set(mrb_state *mrb, mrb_value obj) mrb_int ratio; mrb_get_args(mrb, "i", &ratio); - mrb->gc.gc_interval_ratio = ratio; + mrb->gc.interval_ratio = ratio; return mrb_nil_value(); } @@ -1323,7 +1323,7 @@ gc_interval_ratio_set(mrb_state *mrb, mrb_value obj) static mrb_value gc_step_ratio_get(mrb_state *mrb, mrb_value obj) { - return mrb_fixnum_value(mrb->gc.gc_step_ratio); + return mrb_fixnum_value(mrb->gc.step_ratio); } /* @@ -1341,7 +1341,7 @@ gc_step_ratio_set(mrb_state *mrb, mrb_value obj) mrb_int ratio; mrb_get_args(mrb, "i", &ratio); - mrb->gc.gc_step_ratio = ratio; + mrb->gc.step_ratio = ratio; return mrb_nil_value(); } @@ -1350,12 +1350,12 @@ change_gen_gc_mode(mrb_state *mrb, mrb_gc *gc, mrb_bool enable) { if (is_generational(gc) && !enable) { clear_all_old(mrb, gc); - mrb_assert(gc->gc_state == GC_STATE_ROOT); + mrb_assert(gc->state == GC_STATE_ROOT); gc->full = FALSE; } else if (!is_generational(gc) && enable) { incremental_gc_until(mrb, gc, GC_STATE_ROOT); - gc->majorgc_old_threshold = gc->gc_live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO; + gc->majorgc_old_threshold = gc->live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO; gc->full = FALSE; } gc->generational = enable; @@ -1467,7 +1467,7 @@ test_mrb_field_write_barrier(void) puts(" in GC_STATE_MARK"); - gc->gc_state = GC_STATE_MARK; + gc->state = GC_STATE_MARK; mrb_field_write_barrier(mrb, obj, value); mrb_assert(is_gray(value)); @@ -1475,7 +1475,7 @@ test_mrb_field_write_barrier(void) puts(" in GC_STATE_SWEEP"); paint_partial_white(mrb, value); - gc->gc_state = GC_STATE_SWEEP; + gc->state = GC_STATE_SWEEP; mrb_field_write_barrier(mrb, obj, value); mrb_assert(obj->color & gc->current_white_part); @@ -1483,7 +1483,7 @@ test_mrb_field_write_barrier(void) puts(" fail with black"); - gc->gc_state = GC_STATE_MARK; + gc->state = GC_STATE_MARK; paint_white(obj); paint_partial_white(mrb, value); mrb_field_write_barrier(mrb, obj, value); @@ -1492,7 +1492,7 @@ test_mrb_field_write_barrier(void) puts(" fail with gray"); - gc->gc_state = GC_STATE_MARK; + gc->state = GC_STATE_MARK; paint_black(obj); paint_gray(value); mrb_field_write_barrier(mrb, obj, value); @@ -1507,7 +1507,7 @@ test_mrb_field_write_barrier(void) paint_black(obj); paint_partial_white(mrb, mrb_basic_ptr(value)); - gc->gc_state = GC_STATE_MARK; + gc->state = GC_STATE_MARK; mrb_field_write_barrier_value(mrb, obj, value); mrb_assert(is_gray(mrb_basic_ptr(value))); @@ -1528,7 +1528,7 @@ test_mrb_write_barrier(void) paint_black(obj); puts(" in GC_STATE_MARK"); - gc->gc_state = GC_STATE_MARK; + gc->state = GC_STATE_MARK; mrb_write_barrier(mrb, obj); mrb_assert(is_gray(obj)); @@ -1615,13 +1615,13 @@ test_incremental_gc(void) puts(" in mrb_full_gc"); mrb_full_gc(mrb); - mrb_assert(gc->gc_state == GC_STATE_ROOT); + mrb_assert(gc->state == GC_STATE_ROOT); puts(" in GC_STATE_ROOT"); incremental_gc(mrb, max); - mrb_assert(gc->gc_state == GC_STATE_MARK); + mrb_assert(gc->state == GC_STATE_MARK); puts(" in GC_STATE_MARK"); incremental_gc_until(mrb, GC_STATE_SWEEP); - mrb_assert(gc->gc_state == GC_STATE_SWEEP); + mrb_assert(gc->state == GC_STATE_SWEEP); puts(" in GC_STATE_SWEEP"); page = gc->heaps; @@ -1644,10 +1644,10 @@ test_incremental_gc(void) mrb_assert(gc->gray_list == NULL); incremental_gc(mrb, max); - mrb_assert(gc->gc_state == GC_STATE_SWEEP); + mrb_assert(gc->state == GC_STATE_SWEEP); incremental_gc(mrb, max); - mrb_assert(gc->gc_state == GC_STATE_ROOT); + mrb_assert(gc->state == GC_STATE_ROOT); free = (RVALUE*)gc->heaps->freelist; while (free) { @@ -1663,7 +1663,7 @@ test_incremental_gc(void) change_gen_gc_mode(mrb, TRUE); mrb_assert(gc->full == FALSE); - mrb_assert(gc->gc_state == GC_STATE_ROOT); + mrb_assert(gc->state == GC_STATE_ROOT); puts(" in minor"); mrb_assert(is_minor_gc(mrb)); @@ -1671,13 +1671,13 @@ test_incremental_gc(void) gc->majorgc_old_threshold = 0; mrb_incremental_gc(mrb); mrb_assert(gc->full == TRUE); - mrb_assert(gc->gc_state == GC_STATE_ROOT); + mrb_assert(gc->state == GC_STATE_ROOT); puts(" in major"); mrb_assert(is_major_gc(mrb)); do { mrb_incremental_gc(mrb); - } while (gc->gc_state != GC_STATE_ROOT); + } while (gc->state != GC_STATE_ROOT); mrb_assert(gc->full == FALSE); mrb_close(mrb); -- cgit v1.2.3 From 1c6b1d01554143452dc07daa3a956c58e4916658 Mon Sep 17 00:00:00 2001 From: furunkel Date: Tue, 20 Oct 2015 10:54:47 +0200 Subject: Prefix mrb_gc_state enum members, make color defines private --- include/mruby/gc.h | 15 ++------ src/gc.c | 110 ++++++++++++++++++++++++++++------------------------- 2 files changed, 62 insertions(+), 63 deletions(-) (limited to 'include') diff --git a/include/mruby/gc.h b/include/mruby/gc.h index 3c19e13e8..64efb07c0 100644 --- a/include/mruby/gc.h +++ b/include/mruby/gc.h @@ -21,23 +21,14 @@ typedef void (mrb_each_object_callback)(struct mrb_state *mrb, struct RBasic *ob void mrb_objspace_each_objects(struct mrb_state *mrb, mrb_each_object_callback *callback, void *data); MRB_API void mrb_free_context(struct mrb_state *mrb, struct mrb_context *c); - -/* white: 011, black: 100, gray: 000 */ -#define MRB_GC_GRAY 0 -#define MRB_GC_WHITE_A 1 -#define MRB_GC_WHITE_B (1 << 1) -#define MRB_GC_BLACK (1 << 2) -#define MRB_GC_WHITES (MRB_GC_WHITE_A | MRB_GC_WHITE_B) -#define MRB_GC_COLOR_MASK 7 - #ifndef MRB_GC_ARENA_SIZE #define MRB_GC_ARENA_SIZE 100 #endif typedef enum { - GC_STATE_ROOT = 0, - GC_STATE_MARK, - GC_STATE_SWEEP + MRB_GC_STATE_ROOT = 0, + MRB_GC_STATE_MARK, + MRB_GC_STATE_SWEEP } mrb_gc_state; typedef struct mrb_heap_page { diff --git a/src/gc.c b/src/gc.c index ff729f150..b098541c0 100644 --- a/src/gc.c +++ b/src/gc.c @@ -172,16 +172,24 @@ gettimeofday_time(void) #define GC_STEP_SIZE 1024 -#define paint_gray(o) ((o)->color = MRB_GC_GRAY) -#define paint_black(o) ((o)->color = MRB_GC_BLACK) -#define paint_white(o) ((o)->color = MRB_GC_WHITES) +/* white: 011, black: 100, gray: 000 */ +#define GC_GRAY 0 +#define GC_WHITE_A 1 +#define GC_WHITE_B (1 << 1) +#define GC_BLACK (1 << 2) +#define GC_WHITES (GC_WHITE_A | GC_WHITE_B) +#define GC_COLOR_MASK 7 + +#define paint_gray(o) ((o)->color = GC_GRAY) +#define paint_black(o) ((o)->color = GC_BLACK) +#define paint_white(o) ((o)->color = GC_WHITES) #define paint_partial_white(s, o) ((o)->color = (s)->current_white_part) -#define is_gray(o) ((o)->color == MRB_GC_GRAY) -#define is_white(o) ((o)->color & MRB_GC_WHITES) -#define is_black(o) ((o)->color & MRB_GC_BLACK) +#define is_gray(o) ((o)->color == GC_GRAY) +#define is_white(o) ((o)->color & GC_WHITES) +#define is_black(o) ((o)->color & GC_BLACK) #define flip_white_part(s) ((s)->current_white_part = other_white_part(s)) -#define other_white_part(s) ((s)->current_white_part ^ MRB_GC_WHITES) -#define is_dead(s, o) (((o)->color & other_white_part(s) & MRB_GC_WHITES) || (o)->tt == MRB_TT_FREE) +#define other_white_part(s) ((s)->current_white_part ^ GC_WHITES) +#define is_dead(s, o) (((o)->color & other_white_part(s) & GC_WHITES) || (o)->tt == MRB_TT_FREE) #define objects(p) ((RVALUE *)p->objects) @@ -342,7 +350,7 @@ mrb_gc_init(mrb_state *mrb, mrb_gc *gc) gc->arena_capa = MRB_GC_ARENA_SIZE; #endif - gc->current_white_part = MRB_GC_WHITE_A; + gc->current_white_part = GC_WHITE_A; gc->heaps = NULL; gc->free_heaps = NULL; add_heap(mrb, gc); @@ -923,7 +931,7 @@ final_marking_phase(mrb_state *mrb, mrb_gc *gc) static void prepare_incremental_sweep(mrb_state *mrb, mrb_gc *gc) { - gc->state = GC_STATE_SWEEP; + gc->state = MRB_GC_STATE_SWEEP; gc->sweeps = gc->heaps; gc->live_after_mark = gc->live; } @@ -994,12 +1002,12 @@ static size_t incremental_gc(mrb_state *mrb, mrb_gc *gc, size_t limit) { switch (gc->state) { - case GC_STATE_ROOT: + case MRB_GC_STATE_ROOT: root_scan_phase(mrb, gc); - gc->state = GC_STATE_MARK; + gc->state = MRB_GC_STATE_MARK; flip_white_part(gc); return 0; - case GC_STATE_MARK: + case MRB_GC_STATE_MARK: if (gc->gray_list) { return incremental_marking_phase(mrb, gc, limit); } @@ -1008,11 +1016,11 @@ incremental_gc(mrb_state *mrb, mrb_gc *gc, size_t limit) prepare_incremental_sweep(mrb, gc); return 0; } - case GC_STATE_SWEEP: { + case MRB_GC_STATE_SWEEP: { size_t tried_sweep = 0; tried_sweep = incremental_sweep_phase(mrb, gc, limit); if (tried_sweep == 0) - gc->state = GC_STATE_ROOT; + gc->state = MRB_GC_STATE_ROOT; return tried_sweep; } default: @@ -1037,7 +1045,7 @@ incremental_gc_step(mrb_state *mrb, mrb_gc *gc) limit = (GC_STEP_SIZE/100) * gc->step_ratio; while (result < limit) { result += incremental_gc(mrb, gc, limit); - if (gc->state == GC_STATE_ROOT) + if (gc->state == MRB_GC_STATE_ROOT) break; } @@ -1052,14 +1060,14 @@ clear_all_old(mrb_state *mrb, mrb_gc *gc) mrb_assert(is_generational(gc)); if (is_major_gc(gc)) { /* finish the half baked GC */ - incremental_gc_until(mrb, gc, GC_STATE_ROOT); + 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, GC_STATE_ROOT); + incremental_gc_until(mrb, gc, MRB_GC_STATE_ROOT); gc->generational = origin_mode; /* The gray objects have already been painted as white */ @@ -1077,13 +1085,13 @@ mrb_incremental_gc(mrb_state *mrb) GC_TIME_START; if (is_minor_gc(gc)) { - incremental_gc_until(mrb, gc, GC_STATE_ROOT); + incremental_gc_until(mrb, gc, MRB_GC_STATE_ROOT); } else { incremental_gc_step(mrb, gc); } - if (gc->state == GC_STATE_ROOT) { + 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) { @@ -1121,12 +1129,12 @@ mrb_full_gc(mrb_state *mrb) clear_all_old(mrb, gc); gc->full = TRUE; } - else if (gc->state != GC_STATE_ROOT) { + else if (gc->state != MRB_GC_STATE_ROOT) { /* finish half baked GC cycle */ - incremental_gc_until(mrb, gc, GC_STATE_ROOT); + incremental_gc_until(mrb, gc, MRB_GC_STATE_ROOT); } - incremental_gc_until(mrb, gc, GC_STATE_ROOT); + incremental_gc_until(mrb, gc, MRB_GC_STATE_ROOT); gc->threshold = (gc->live_after_mark/100) * gc->interval_ratio; if (is_generational(gc)) { @@ -1185,13 +1193,13 @@ mrb_field_write_barrier(mrb_state *mrb, struct RBasic *obj, struct RBasic *value if (!is_white(value)) return; mrb_assert(!is_dead(gc, value) && !is_dead(gc, obj)); - mrb_assert(is_generational(gc) || mrb->gc.state != GC_STATE_ROOT); + mrb_assert(is_generational(gc) || gc->state != MRB_GC_STATE_ROOT); - if (is_generational(gc) || mrb->gc.state == GC_STATE_MARK) { + if (is_generational(gc) || gc->state == MRB_GC_STATE_MARK) { add_gray_list(mrb, gc, value); } else { - mrb_assert(mrb->gc.state == GC_STATE_SWEEP); + mrb_assert(gc->state == MRB_GC_STATE_SWEEP); paint_partial_white(gc, obj); /* for never write barriers */ } } @@ -1213,7 +1221,7 @@ mrb_write_barrier(mrb_state *mrb, struct RBasic *obj) if (!is_black(obj)) return; mrb_assert(!is_dead(gc, obj)); - mrb_assert(is_generational(gc) || gc->state != GC_STATE_ROOT); + mrb_assert(is_generational(gc) || gc->state != MRB_GC_STATE_ROOT); paint_gray(obj); obj->gcnext = gc->atomic_gray_list; gc->atomic_gray_list = obj; @@ -1350,11 +1358,11 @@ change_gen_gc_mode(mrb_state *mrb, mrb_gc *gc, mrb_bool enable) { if (is_generational(gc) && !enable) { clear_all_old(mrb, gc); - mrb_assert(gc->state == GC_STATE_ROOT); + mrb_assert(gc->state == MRB_GC_STATE_ROOT); gc->full = FALSE; } else if (!is_generational(gc) && enable) { - incremental_gc_until(mrb, gc, GC_STATE_ROOT); + incremental_gc_until(mrb, gc, MRB_GC_STATE_ROOT); gc->majorgc_old_threshold = gc->live_after_mark/100 * DEFAULT_MAJOR_GC_INC_RATIO; gc->full = FALSE; } @@ -1466,16 +1474,16 @@ test_mrb_field_write_barrier(void) paint_partial_white(mrb, value); - puts(" in GC_STATE_MARK"); - gc->state = GC_STATE_MARK; + puts(" in MRB_GC_STATE_MARK"); + gc->state = MRB_GC_STATE_MARK; mrb_field_write_barrier(mrb, obj, value); mrb_assert(is_gray(value)); - puts(" in GC_STATE_SWEEP"); + puts(" in MRB_GC_STATE_SWEEP"); paint_partial_white(mrb, value); - gc->state = GC_STATE_SWEEP; + gc->state = MRB_GC_STATE_SWEEP; mrb_field_write_barrier(mrb, obj, value); mrb_assert(obj->color & gc->current_white_part); @@ -1483,7 +1491,7 @@ test_mrb_field_write_barrier(void) puts(" fail with black"); - gc->state = GC_STATE_MARK; + gc->state = MRB_GC_STATE_MARK; paint_white(obj); paint_partial_white(mrb, value); mrb_field_write_barrier(mrb, obj, value); @@ -1492,7 +1500,7 @@ test_mrb_field_write_barrier(void) puts(" fail with gray"); - gc->state = GC_STATE_MARK; + gc->state = MRB_GC_STATE_MARK; paint_black(obj); paint_gray(value); mrb_field_write_barrier(mrb, obj, value); @@ -1507,7 +1515,7 @@ test_mrb_field_write_barrier(void) paint_black(obj); paint_partial_white(mrb, mrb_basic_ptr(value)); - gc->state = GC_STATE_MARK; + gc->state = MRB_GC_STATE_MARK; mrb_field_write_barrier_value(mrb, obj, value); mrb_assert(is_gray(mrb_basic_ptr(value))); @@ -1527,8 +1535,8 @@ test_mrb_write_barrier(void) obj = mrb_basic_ptr(mrb_ary_new(mrb)); paint_black(obj); - puts(" in GC_STATE_MARK"); - gc->state = GC_STATE_MARK; + puts(" in MRB_GC_STATE_MARK"); + gc->state = MRB_GC_STATE_MARK; mrb_write_barrier(mrb, obj); mrb_assert(is_gray(obj)); @@ -1615,15 +1623,15 @@ test_incremental_gc(void) puts(" in mrb_full_gc"); mrb_full_gc(mrb); - mrb_assert(gc->state == GC_STATE_ROOT); - puts(" in GC_STATE_ROOT"); + mrb_assert(gc->state == MRB_GC_STATE_ROOT); + puts(" in MRB_GC_STATE_ROOT"); incremental_gc(mrb, max); - mrb_assert(gc->state == GC_STATE_MARK); - puts(" in GC_STATE_MARK"); - incremental_gc_until(mrb, GC_STATE_SWEEP); - mrb_assert(gc->state == GC_STATE_SWEEP); + mrb_assert(gc->state == MRB_GC_STATE_MARK); + puts(" in MRB_GC_STATE_MARK"); + incremental_gc_until(mrb, MRB_GC_STATE_SWEEP); + mrb_assert(gc->state == MRB_GC_STATE_SWEEP); - puts(" in GC_STATE_SWEEP"); + puts(" in MRB_GC_STATE_SWEEP"); page = gc->heaps; while (page) { RVALUE *p = objects(page); @@ -1644,10 +1652,10 @@ test_incremental_gc(void) mrb_assert(gc->gray_list == NULL); incremental_gc(mrb, max); - mrb_assert(gc->state == GC_STATE_SWEEP); + mrb_assert(gc->state == MRB_GC_STATE_SWEEP); incremental_gc(mrb, max); - mrb_assert(gc->state == GC_STATE_ROOT); + mrb_assert(gc->state == MRB_GC_STATE_ROOT); free = (RVALUE*)gc->heaps->freelist; while (free) { @@ -1659,11 +1667,11 @@ test_incremental_gc(void) mrb_assert(gc->live == total-freed); puts("test_incremental_gc(gen)"); - incremental_gc_until(mrb, GC_STATE_SWEEP); + incremental_gc_until(mrb, MRB_GC_STATE_SWEEP); change_gen_gc_mode(mrb, TRUE); mrb_assert(gc->full == FALSE); - mrb_assert(gc->state == GC_STATE_ROOT); + mrb_assert(gc->state == MRB_GC_STATE_ROOT); puts(" in minor"); mrb_assert(is_minor_gc(mrb)); @@ -1671,13 +1679,13 @@ test_incremental_gc(void) gc->majorgc_old_threshold = 0; mrb_incremental_gc(mrb); mrb_assert(gc->full == TRUE); - mrb_assert(gc->state == GC_STATE_ROOT); + mrb_assert(gc->state == MRB_GC_STATE_ROOT); puts(" in major"); mrb_assert(is_major_gc(mrb)); do { mrb_incremental_gc(mrb); - } while (gc->state != GC_STATE_ROOT); + } while (gc->state != MRB_GC_STATE_ROOT); mrb_assert(gc->full == FALSE); mrb_close(mrb); -- cgit v1.2.3