Feature #1047 » 1047.patch
| gc.c (working copy) | ||
|---|---|---|
|
#ifndef GC_MALLOC_LIMIT
|
||
|
#define GC_MALLOC_LIMIT 8000000
|
||
|
#endif
|
||
|
static unsigned int GC_MALLOC_LIMIT_VAL = GC_MALLOC_LIMIT;
|
||
|
#define nomem_error GET_VM()->special_exceptions[ruby_error_nomemory]
|
||
| ... | ... | |
|
#define HEAP_MIN_SLOTS 10000
|
||
|
#define FREE_MIN 4096
|
||
|
static unsigned int HEAP_MIN_SLOTS_VAL = HEAP_MIN_SLOTS;
|
||
|
struct gc_list {
|
||
|
VALUE *varptr;
|
||
|
struct gc_list *next;
|
||
| ... | ... | |
|
{
|
||
|
rb_objspace_t *objspace = malloc(sizeof(rb_objspace_t));
|
||
|
memset(objspace, 0, sizeof(*objspace));
|
||
|
malloc_limit = GC_MALLOC_LIMIT;
|
||
|
malloc_limit = GC_MALLOC_LIMIT_VAL;
|
||
|
ruby_gc_stress = ruby_initial_gc_stress;
|
||
|
return objspace;
|
||
| ... | ... | |
|
{
|
||
|
size_t add, i;
|
||
|
add = HEAP_MIN_SLOTS / HEAP_OBJ_LIMIT;
|
||
|
add = HEAP_MIN_SLOTS_VAL / HEAP_OBJ_LIMIT;
|
||
|
if (!add) {
|
||
|
add = 1;
|
||
| ... | ... | |
|
GC_PROF_SET_MALLOC_INFO;
|
||
|
if (malloc_increase > malloc_limit) {
|
||
|
malloc_limit += (size_t)((malloc_increase - malloc_limit) * (double)live / (live + freed));
|
||
|
if (malloc_limit < GC_MALLOC_LIMIT) malloc_limit = GC_MALLOC_LIMIT;
|
||
|
if (malloc_limit < GC_MALLOC_LIMIT_VAL) malloc_limit = GC_MALLOC_LIMIT_VAL;
|
||
|
}
|
||
|
malloc_increase = 0;
|
||
|
if (freed < free_min) {
|
||
| ... | ... | |
|
return UINT2NUM((&rb_objspace)->count);
|
||
|
}
|
||
|
/*
|
||
|
* call-seq:
|
||
|
* GC.malloc_limit -> Integer
|
||
|
*
|
||
|
* The size of the malloc limit (minimum heap size).
|
||
|
*
|
||
|
* It returns the bare minimum size of the heap.
|
||
|
*/
|
||
|
|
||
|
static VALUE
|
||
|
gc_malloc_limit_get(VALUE self)
|
||
|
{
|
||
|
rb_objspace_t *objspace = &rb_objspace;
|
||
|
return UINT2NUM(malloc_limit);
|
||
|
}
|
||
|
/*
|
||
|
*
|
||
|
* call-seq:
|
||
|
* GC.malloc_limit = integer -> Integer
|
||
|
*
|
||
|
* Updates the size of the malloc limit (minimum heap size).
|
||
|
*
|
||
|
* It returns the new bare minimum size of the heap.
|
||
|
*/
|
||
|
|
||
|
static VALUE
|
||
|
gc_malloc_limit_set(VALUE self, VALUE new_limit)
|
||
|
{
|
||
|
rb_objspace_t *objspace = &rb_objspace;
|
||
|
malloc_limit = GC_MALLOC_LIMIT_VAL = NUM2UINT(new_limit);
|
||
|
return new_limit;
|
||
|
}
|
||
|
/*
|
||
|
* call-seq:
|
||
|
* GC.heap_min_slots -> Integer
|
||
|
*
|
||
|
* The minimum number of slots in each heap slab.
|
||
|
*
|
||
|
* It returns the number of slots to allocate for each heap slab.
|
||
|
*/
|
||
|
|
||
|
static VALUE
|
||
|
gc_heap_min_slots_get(VALUE self)
|
||
|
{
|
||
|
return UINT2NUM(HEAP_MIN_SLOTS_VAL);
|
||
|
}
|
||
|
/*
|
||
|
*
|
||
|
* call-seq:
|
||
|
* GC.heap_min_slots = integer -> Integer
|
||
|
*
|
||
|
* Updates the minimum number of slots in each heap slab.
|
||
|
*
|
||
|
* It returns the new number of slots to allocate for each heap slab.
|
||
|
*/
|
||
|
|
||
|
static VALUE
|
||
|
gc_heap_min_slots_set(VALUE self, VALUE new_num_slots)
|
||
|
{
|
||
|
HEAP_MIN_SLOTS_VAL = NUM2UINT(new_num_slots);
|
||
|
return new_num_slots;
|
||
|
}
|
||
|
#if CALC_EXACT_MALLOC_SIZE
|
||
|
/*
|
||
|
* call-seq:
|
||
| ... | ... | |
|
rb_define_singleton_method(rb_mGC, "stress", gc_stress_get, 0);
|
||
|
rb_define_singleton_method(rb_mGC, "stress=", gc_stress_set, 1);
|
||
|
rb_define_singleton_method(rb_mGC, "count", gc_count, 0);
|
||
|
rb_define_singleton_method(rb_mGC, "malloc_limit", gc_malloc_limit_get, 0);
|
||
|
rb_define_singleton_method(rb_mGC, "malloc_limit=", gc_malloc_limit_set, 1);
|
||
|
rb_define_singleton_method(rb_mGC, "heap_slots", gc_heap_min_slots_get, 0);
|
||
|
rb_define_singleton_method(rb_mGC, "heap_slots=", gc_heap_min_slots_set, 1);
|
||
|
rb_define_method(rb_mGC, "garbage_collect", rb_gc_start, 0);
|
||
|
rb_mProfiler = rb_define_module_under(rb_mGC, "Profiler");
|
||