From 20fa0c26c9c4216926c5240678fbe27878ce9cca Mon Sep 17 00:00:00 2001 From: ko1 Date: Thu, 21 Nov 2013 08:50:40 +0000 Subject: * gc.c: rename initial_xxx variables to gc_params.xxx. They are not only used initial values. Chikanaga-san: Congratulations on RubyPrize! git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@43757 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- gc.c | 101 ++++++++++++++++++++++++++++++------------------------------------- 1 file changed, 45 insertions(+), 56 deletions(-) (limited to 'gc.c') diff --git a/gc.c b/gc.c index b5d09e0dce..3c1c63d1d8 100644 --- a/gc.c +++ b/gc.c @@ -111,22 +111,22 @@ rb_gc_guarded_ptr(volatile VALUE *ptr) #endif typedef struct { - unsigned int initial_heap_min_slots; - unsigned int initial_heap_min_free_slots; - double initial_growth_factor; - unsigned int initial_growth_max; - unsigned int initial_malloc_limit_min; - unsigned int initial_malloc_limit_max; - double initial_malloc_limit_growth_factor; - unsigned int initial_oldspace_limit_min; - unsigned int initial_oldspace_limit_max; - double initial_oldspace_limit_growth_factor; + unsigned int heap_min_slots; + unsigned int heap_min_free_slots; + double growth_factor; + unsigned int growth_max; + unsigned int malloc_limit_min; + unsigned int malloc_limit_max; + double malloc_limit_growth_factor; + unsigned int oldspace_limit_min; + unsigned int oldspace_limit_max; + double oldspace_limit_growth_factor; #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE VALUE gc_stress; #endif } ruby_gc_params_t; -static ruby_gc_params_t initial_params = { +static ruby_gc_params_t gc_params = { GC_HEAP_MIN_SLOTS, GC_HEAP_MIN_FREE_SLOTS, GC_HEAP_GROWTH_FACTOR, @@ -559,7 +559,7 @@ struct heap_page { /* Aliases */ #if defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE #define rb_objspace (*GET_VM()->objspace) -#define ruby_initial_gc_stress initial_params.gc_stress +#define ruby_initial_gc_stress gc_params.gc_stress VALUE *ruby_initial_gc_stress_ptr = &ruby_initial_gc_stress; #else static rb_objspace_t rb_objspace = {{GC_MALLOC_LIMIT_MIN}}; @@ -591,17 +591,6 @@ VALUE *ruby_initial_gc_stress_ptr = &rb_objspace.gc_stress; #define monitor_level objspace->rgengc.monitor_level #define monitored_object_table objspace->rgengc.monitored_object_table -#define initial_malloc_limit_min initial_params.initial_malloc_limit_min -#define initial_malloc_limit_max initial_params.initial_malloc_limit_max -#define initial_malloc_limit_growth_factor initial_params.initial_malloc_limit_growth_factor -#define initial_oldspace_limit_min initial_params.initial_oldspace_limit_min -#define initial_oldspace_limit_max initial_params.initial_oldspace_limit_max -#define initial_oldspace_limit_growth_factor initial_params.initial_oldspace_limit_growth_factor -#define initial_heap_min_slots initial_params.initial_heap_min_slots -#define initial_heap_min_free_slots initial_params.initial_heap_min_free_slots -#define initial_growth_factor initial_params.initial_growth_factor -#define initial_growth_max initial_params.initial_growth_max - #define is_lazy_sweeping(heap) ((heap)->sweep_pages != 0) #if SIZEOF_LONG == SIZEOF_VOIDP # define nonspecial_obj_id(obj) (VALUE)((SIGNED_VALUE)(obj)|FIXNUM_FLAG) @@ -848,9 +837,9 @@ rb_objspace_alloc(void) memset(objspace, 0, sizeof(*objspace)); ruby_gc_stress = ruby_initial_gc_stress; - malloc_limit = initial_malloc_limit_min; + malloc_limit = gc_params.malloc_limit_min; #if RGENGC_ESTIMATE_OLDSPACE - objspace->rgengc.oldspace_increase_limit = initial_oldspace_limit_min; + objspace->rgengc.oldspace_increase_limit = gc_params.oldspace_limit_min; #endif return objspace; @@ -1137,9 +1126,9 @@ static void heap_set_increment(rb_objspace_t *objspace) { size_t used = heap_pages_used - heap_tomb->used; - size_t next_used_limit = (size_t)(used * initial_growth_factor); - if (initial_growth_max > 0) { - size_t max_used_limit = (size_t)(used + initial_growth_max/HEAP_OBJ_LIMIT); + size_t next_used_limit = (size_t)(used * gc_params.growth_factor); + if (gc_params.growth_max > 0) { + size_t max_used_limit = (size_t)(used + gc_params.growth_max/HEAP_OBJ_LIMIT); if (next_used_limit > max_used_limit) next_used_limit = max_used_limit; } if (next_used_limit == heap_pages_used) next_used_limit++; @@ -1617,7 +1606,7 @@ Init_heap(void) { rb_objspace_t *objspace = &rb_objspace; - heap_add_pages(objspace, heap_eden, initial_heap_min_slots / HEAP_OBJ_LIMIT); + heap_add_pages(objspace, heap_eden, gc_params.heap_min_slots / HEAP_OBJ_LIMIT); init_mark_stack(&objspace->mark_stack); @@ -2794,12 +2783,12 @@ gc_before_sweep(rb_objspace_t *objspace) total_limit_num = objspace_limit_num(objspace); heap_pages_min_free_slots = (size_t)(total_limit_num * 0.30); - if (heap_pages_min_free_slots < initial_heap_min_free_slots) { - heap_pages_min_free_slots = initial_heap_min_free_slots; + if (heap_pages_min_free_slots < gc_params.heap_min_free_slots) { + heap_pages_min_free_slots = gc_params.heap_min_free_slots; } heap_pages_max_free_slots = (size_t)(total_limit_num * 0.80); - if (heap_pages_max_free_slots < initial_heap_min_slots) { - heap_pages_max_free_slots = initial_heap_min_slots; + if (heap_pages_max_free_slots < gc_params.heap_min_slots) { + heap_pages_max_free_slots = gc_params.heap_min_slots; } if (0) fprintf(stderr, "heap_pages_min_free_slots: %d, heap_pages_max_free_slots: %d\n", (int)heap_pages_min_free_slots, (int)heap_pages_max_free_slots); @@ -2817,16 +2806,16 @@ gc_before_sweep(rb_objspace_t *objspace) size_t old_limit = malloc_limit; if (inc > malloc_limit) { - malloc_limit = (size_t)(inc * initial_malloc_limit_growth_factor); - if (initial_malloc_limit_max > 0 && /* ignore max-check if 0 */ - malloc_limit > initial_malloc_limit_max) { + malloc_limit = (size_t)(inc * gc_params.malloc_limit_growth_factor); + if (gc_params.malloc_limit_max > 0 && /* ignore max-check if 0 */ + malloc_limit > gc_params.malloc_limit_max) { malloc_limit = inc; } } else { malloc_limit = (size_t)(malloc_limit * 0.98); /* magic number */ - if (malloc_limit < initial_malloc_limit_min) { - malloc_limit = initial_malloc_limit_min; + if (malloc_limit < gc_params.malloc_limit_min) { + malloc_limit = gc_params.malloc_limit_min; } } @@ -2848,23 +2837,23 @@ gc_before_sweep(rb_objspace_t *objspace) if (objspace->rgengc.oldspace_increase > objspace->rgengc.oldspace_increase_limit) { objspace->rgengc.need_major_gc = TRUE; objspace->rgengc.oldspace_increase_limit = - (size_t)(objspace->rgengc.oldspace_increase_limit * initial_oldspace_limit_growth_factor); - if (objspace->rgengc.oldspace_increase_limit > initial_oldspace_limit_max) { - objspace->rgengc.oldspace_increase_limit = initial_oldspace_limit_max; + (size_t)(objspace->rgengc.oldspace_increase_limit * gc_params.oldspace_limit_growth_factor); + if (objspace->rgengc.oldspace_increase_limit > gc_params.oldspace_limit_max) { + objspace->rgengc.oldspace_increase_limit = gc_params.oldspace_limit_max; } } else { objspace->rgengc.oldspace_increase_limit = - (size_t)(objspace->rgengc.oldspace_increase_limit / ((initial_oldspace_limit_growth_factor - 1)/10 + 1)); - if (objspace->rgengc.oldspace_increase_limit < initial_oldspace_limit_min) { - objspace->rgengc.oldspace_increase_limit = initial_oldspace_limit_min; + (size_t)(objspace->rgengc.oldspace_increase_limit / ((gc_params.oldspace_limit_growth_factor - 1)/10 + 1)); + if (objspace->rgengc.oldspace_increase_limit < gc_params.oldspace_limit_min) { + objspace->rgengc.oldspace_increase_limit = gc_params.oldspace_limit_min; } } if (0) fprintf(stderr, "%d\t%d\t%u\t%u\t%d\n", (int)rb_gc_count(), objspace->rgengc.need_major_gc, (unsigned int)objspace->rgengc.oldspace_increase, (unsigned int)objspace->rgengc.oldspace_increase_limit, - (unsigned int)initial_oldspace_limit_max); + (unsigned int)gc_params.oldspace_limit_max); } else { /* major GC */ @@ -5263,27 +5252,27 @@ rb_gc_set_params(void) { if (rb_safe_level() > 0) return; - get_envparam_int ("RUBY_FREE_MIN", &initial_heap_min_free_slots, 0); + get_envparam_int ("RUBY_FREE_MIN", &gc_params.heap_min_free_slots, 0); - get_envparam_double("RUBY_HEAP_SLOTS_GROWTH_FACTOR", &initial_growth_factor, 1.0); - get_envparam_int ("RUBY_HEAP_SLOTS_GROWTH_MAX", &initial_growth_max, 0); - if (get_envparam_int("RUBY_HEAP_MIN_SLOTS", &initial_heap_min_slots, 0)) { + get_envparam_double("RUBY_HEAP_SLOTS_GROWTH_FACTOR", &gc_params.growth_factor, 1.0); + get_envparam_int ("RUBY_HEAP_SLOTS_GROWTH_MAX", &gc_params.growth_max, 0); + if (get_envparam_int("RUBY_HEAP_MIN_SLOTS", &gc_params.heap_min_slots, 0)) { size_t min_size; rb_objspace_t *objspace = &rb_objspace; - min_size = initial_heap_min_slots / HEAP_OBJ_LIMIT; + min_size = gc_params.heap_min_slots / HEAP_OBJ_LIMIT; if (min_size > heap_eden->used) { heap_add_pages(objspace, heap_eden, min_size - heap_eden->used); } } - get_envparam_int("RUBY_GC_MALLOC_LIMIT", &initial_malloc_limit_min, 0); - get_envparam_int("RUBY_GC_MALLOC_LIMIT_MAX", &initial_malloc_limit_max, 0); - get_envparam_double("RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR", &initial_malloc_limit_growth_factor, 1.0); + get_envparam_int("RUBY_GC_MALLOC_LIMIT", &gc_params.malloc_limit_min, 0); + get_envparam_int("RUBY_GC_MALLOC_LIMIT_MAX", &gc_params.malloc_limit_max, 0); + get_envparam_double("RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR", &gc_params.malloc_limit_growth_factor, 1.0); - get_envparam_int("RUBY_GC_HEAP_OLDSPACE", &initial_oldspace_limit_min, 0); - get_envparam_int("RUBY_GC_HEAP_OLDSPACE_MAX", &initial_oldspace_limit_max, 0); - get_envparam_double("RUBY_GC_HEAP_OLDSPACE_GROWTH_FACTOR", &initial_oldspace_limit_growth_factor, 1.0); + get_envparam_int("RUBY_GC_HEAP_OLDSPACE", &gc_params.oldspace_limit_min, 0); + get_envparam_int("RUBY_GC_HEAP_OLDSPACE_MAX", &gc_params.oldspace_limit_max, 0); + get_envparam_double("RUBY_GC_HEAP_OLDSPACE_GROWTH_FACTOR", &gc_params.oldspace_limit_growth_factor, 1.0); } void -- cgit v1.2.3