Ruby » Ruby master

int

dln_loadable(void)

{

return 1;

}

int

dln_loadable(void)

{

return 0;

}

if (!gc_decided()) {

vfprintf(stderr, fmt, args);

va_end(args);

abort();

}

require 'mkmf'

create_makefile("gc_bmp")

/**********************************************************************

gc_bmp.c -

$Author$

created at: Tue Oct 5 09:44:46 JST 1993

Copyright (C) 1993-2007 Yukihiro Matsumoto

Copyright (C) 2000 Network Applied Communication Laboratory, Inc.

Copyright (C) 2000 Information-technology Promotion Agency, Japan

**********************************************************************/

#include "ruby.h"

#include "ruby/re.h"

#include "ruby/io.h"

#include <stdio.h>

#include <setjmp.h>

#include <sys/types.h>

#ifndef FALSE

# define FALSE 0

#elif FALSE

# error FALSE must be false

#endif

#ifndef TRUE

# define TRUE 1

#elif !TRUE

# error TRUE must be true

#endif

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifdef HAVE_SYS_RESOURCE_H

#include <sys/resource.h>

#endif

#if defined _WIN32 || defined __CYGWIN__

#include <windows.h>

#endif

#ifdef HAVE_VALGRIND_MEMCHECK_H

# include <valgrind/memcheck.h>

# ifndef VALGRIND_MAKE_MEM_DEFINED

# define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE(p, n)

# endif

# ifndef VALGRIND_MAKE_MEM_UNDEFINED

# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE(p, n)

# endif

#else

# define VALGRIND_MAKE_MEM_DEFINED(p, n) /* empty */

# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) /* empty */

#endif

int rb_io_fptr_finalize(struct rb_io_t*);

#define rb_setjmp(env) RUBY_SETJMP(env)

#define rb_jmp_buf rb_jmpbuf_t

/* Make alloca work the best possible way. */

#ifdef __GNUC__

# ifndef atarist

# ifndef alloca

# define alloca __builtin_alloca

# endif

# endif /* atarist */

#else

# ifdef HAVE_ALLOCA_H

# include <alloca.h>

# else

# ifdef _AIX

#pragma alloca

# else

# ifndef alloca /* predefined by HP cc +Olibcalls */

void *alloca ();

# endif

# endif /* AIX */

# endif /* HAVE_ALLOCA_H */

#endif /* __GNUC__ */

#ifndef GC_MALLOC_LIMIT

#define GC_MALLOC_LIMIT 8000000

#endif

#define MARK_STACK_MAX 1024

/* for GC profile */

#define GC_PROFILE_MORE_DETAIL 1

typedef struct gc_profile_record {

double gc_time;

double gc_mark_time;

double gc_sweep_time;

double gc_invoke_time;

size_t heap_use_slots;

size_t heap_live_objects;

size_t heap_free_objects;

size_t heap_total_objects;

size_t heap_use_size;

size_t heap_total_size;

int have_finalize;

size_t allocate_increase;

size_t allocate_limit;

} gc_profile_record;

static double

getrusage_time(void)

{

#ifdef RUSAGE_SELF

struct rusage usage;

struct timeval time;

getrusage(RUSAGE_SELF, &usage);

time = usage.ru_utime;

return time.tv_sec + time.tv_usec * 1e-6;

#elif defined _WIN32

FILETIME creation_time, exit_time, kernel_time, user_time;

ULARGE_INTEGER ui;

LONG_LONG q;

double t;

if (GetProcessTimes(GetCurrentProcess(),

&creation_time, &exit_time, &kernel_time, &user_time) == 0)

{

return 0.0;

}

memcpy(&ui, &user_time, sizeof(FILETIME));

q = ui.QuadPart / 10L;

t = (DWORD)(q % 1000000L) * 1e-6;

q /= 1000000L;

#ifdef __GNUC__

t += q;

#else

t += (double)(DWORD)(q >> 16) * (1 << 16);

t += (DWORD)q & ~(~0 << 16);

#endif

return t;

#else

return 0.0;

#endif

}

#define GC_PROF_TIMER_START do {\

if (objspace->profile.run) {\

if (!objspace->profile.record) {\

objspace->profile.size = 1000;\

objspace->profile.record = malloc(sizeof(gc_profile_record) * objspace->profile.size);\

}\

if (count >= objspace->profile.size) {\

objspace->profile.size += 1000;\

objspace->profile.record = realloc(objspace->profile.record, sizeof(gc_profile_record) * objspace->profile.size);\

}\

if (!objspace->profile.record) {\

rb_bug("gc_profile malloc or realloc miss");\

}\

MEMZERO(&objspace->profile.record[count], gc_profile_record, 1);\

gc_time = getrusage_time();\

objspace->profile.record[count].gc_invoke_time = gc_time - objspace->profile.invoke_time;\

}\

} while(0)

#define GC_PROF_TIMER_STOP do {\

if (objspace->profile.run) {\

gc_time = getrusage_time() - gc_time;\

if (gc_time < 0) gc_time = 0;\

objspace->profile.record[count].gc_time = gc_time;\

objspace->profile.count++;\

}\

} while(0)

#if GC_PROFILE_MORE_DETAIL

#define INIT_GC_PROF_PARAMS double gc_time = 0, mark_time = 0, sweep_time = 0;\

size_t count = objspace->profile.count

#define GC_PROF_MARK_TIMER_START do {\

if (objspace->profile.run) {\

mark_time = getrusage_time();\

}\

} while(0)

#define GC_PROF_MARK_TIMER_STOP do {\

if (objspace->profile.run) {\

mark_time = getrusage_time() - mark_time;\

if (mark_time < 0) mark_time = 0;\

objspace->profile.record[count].gc_mark_time = mark_time;\

}\

} while(0)

#define GC_PROF_SWEEP_TIMER_START do {\

if (objspace->profile.run) {\

sweep_time = getrusage_time();\

}\

} while(0)

#define GC_PROF_SWEEP_TIMER_STOP do {\

if (objspace->profile.run) {\

sweep_time = getrusage_time() - sweep_time;\

if (sweep_time < 0) sweep_time = 0;\

objspace->profile.record[count].gc_sweep_time = sweep_time;\

}\

} while(0)

#define GC_PROF_SET_MALLOC_INFO do {\

if (objspace->profile.run) {\

gc_profile_record *record = &objspace->profile.record[objspace->profile.count];\

record->allocate_increase = malloc_increase;\

record->allocate_limit = malloc_limit; \

}\

} while(0)

#define GC_PROF_SET_HEAP_INFO do {\

if (objspace->profile.run) {\

gc_profile_record *record = &objspace->profile.record[objspace->profile.count];\

record->heap_use_slots = heaps_used;\

record->heap_live_objects = live;\

record->heap_free_objects = freed; \

record->heap_total_objects = heaps_used * HEAP_OBJ_LIMIT;\

record->have_finalize = final_list ? Qtrue : Qfalse;\

record->heap_use_size = live * sizeof(RVALUE); \

record->heap_total_size = heaps_used * (HEAP_OBJ_LIMIT * sizeof(RVALUE));\

}\

} while(0)

#else

#define INIT_GC_PROF_PARAMS double gc_time = 0;\

size_t count = objspace->profile.count

#define GC_PROF_MARK_TIMER_START

#define GC_PROF_MARK_TIMER_STOP

#define GC_PROF_SWEEP_TIMER_START

#define GC_PROF_SWEEP_TIMER_STOP

#define GC_PROF_SET_MALLOC_INFO

#define GC_PROF_SET_HEAP_INFO do {\

if (objspace->profile.run) {\

gc_profile_record *record = &objspace->profile.record[objspace->profile.count];\

record->heap_total_objects = heaps_used * HEAP_OBJ_LIMIT;\

record->heap_use_size = live * sizeof(RVALUE); \

record->heap_total_size = heaps_used * HEAP_SIZE;\

}\

} while(0)

#endif

#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)

#pragma pack(push, 1) /* magic for reducing sizeof(RVALUE): 24 -> 20 */

#endif

typedef struct RVALUE {

union {

struct {

VALUE flags; /* always 0 for freed obj */

struct RVALUE *next;

} free;

struct {

VALUE flags;

struct RVALUE *next;

int *map;

VALUE slot;

int limit;

} bitmap;

struct RBasic basic;

struct RObject object;

struct RClass klass;

struct RFloat flonum;

struct RString string;

struct RArray array;

struct RRegexp regexp;

struct RHash hash;

struct RData data;

struct RTypedData typeddata;

struct RStruct rstruct;

struct RBignum bignum;

struct RFile file;

struct RMatch match;

struct RRational rational;

struct RComplex complex;

} as;

#ifdef GC_DEBUG

const char *file;

int line;

#endif

} RVALUE;

#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)

#pragma pack(pop)

#endif

struct heaps_slot {

void *membase;

RVALUE *slot;

size_t limit;

RVALUE *bitmap;

};

#define HEAP_MIN_SLOTS 10000

#define FREE_MIN 4096

struct gc_list {

VALUE *varptr;

struct gc_list *next;

};

#define CALC_EXACT_MALLOC_SIZE 0

typedef struct rb_objspace {

struct {

size_t limit;

size_t increase;

#if CALC_EXACT_MALLOC_SIZE

size_t allocated_size;

size_t allocations;

#endif

} malloc_params;

struct {

size_t increment;

struct heaps_slot *ptr;

size_t length;

size_t used;

RVALUE *freelist;

RVALUE *range[2];

RVALUE *freed;

} heap;

struct {

int dont_gc;

int during_gc;

} flags;

struct {

st_table *table;

RVALUE *deferred;

} final;

struct {

VALUE buffer[MARK_STACK_MAX];

VALUE *ptr;

int overflow;

} markstack;

struct {

int run;

gc_profile_record *record;

size_t count;

size_t size;

double invoke_time;

} profile;

struct gc_list *global_list;

unsigned int count;

int gc_stress;

struct {

RVALUE *freed_bitmap;

} ext_heap;

} rb_objspace_t;

#define malloc_limit objspace->malloc_params.limit

#define malloc_increase objspace->malloc_params.increase

#define heap_slots objspace->heap.slots

#define heaps objspace->heap.ptr

#define heaps_length objspace->heap.length

#define heaps_used objspace->heap.used

#define freelist objspace->heap.freelist

#define lomem objspace->heap.range[0]

#define himem objspace->heap.range[1]

#define heaps_inc objspace->heap.increment

#define heaps_freed objspace->heap.freed

#define dont_gc objspace->flags.dont_gc

#define during_gc objspace->flags.during_gc

#define finalizer_table objspace->final.table

#define deferred_final_list objspace->final.deferred

#define mark_stack objspace->markstack.buffer

#define mark_stack_ptr objspace->markstack.ptr

#define mark_stack_overflow objspace->markstack.overflow

#define global_List objspace->global_list

#define ruby_gc_stress objspace->gc_stress

#define need_call_final (finalizer_table && finalizer_table->num_entries)

static void rb_objspace_call_finalizer(rb_objspace_t *objspace);

#include "ruby/gc_ext.h"

static rb_gc_inner_t *gc_inner;

/* TODO: more suitable and safety expression */

#define T_BITMAP (T_FIXNUM + 1)

#define FL_ALIGNOFF FL_MARK

static rb_objspace_t *

rb_objspace_alloc_tmp(void)

{

rb_objspace_t *objspace = malloc(sizeof(rb_objspace_t));

memset(objspace, 0, sizeof(*objspace));

malloc_limit = GC_MALLOC_LIMIT;

return objspace;

}

static void

rb_objspace_free_tmp(rb_objspace_t *objspace)

{

rb_objspace_call_finalizer(objspace);

if (objspace->profile.record) {

free(objspace->profile.record);

objspace->profile.record = 0;

}

if (global_List) {

struct gc_list *list, *next;

for (list = global_List; list; list = next) {

next = list->next;

free(list);

}

}

if (heaps) {

size_t i;

for (i = 0; i < heaps_used; ++i) {

free(heaps[i].membase);

}

free(heaps);

heaps_used = 0;

heaps = 0;

}

free(objspace);

}

/* tiny heap size */

/* 32KB */

/*#define HEAP_SIZE 0x8000 */

/* 128KB */

/*#define HEAP_SIZE 0x20000 */

/* 64KB */

/*#define HEAP_SIZE 0x10000 */

/* 16KB */

#define BITMAP_ALIGN 0x4000

/* 8KB */

/*#define HEAP_SIZE 0x2000 */

/* 4KB */

/*#define HEAP_SIZE 0x1000 */

/* 2KB */

/*#define HEAP_SIZE 0x800 */

#define HEAP_SIZE ((BITMAP_ALIGN / sizeof(struct RVALUE) + 2) * sizeof(RVALUE))

#define BITMAP_MASK (0xFFFFFFFF - BITMAP_ALIGN + 1)

#define HEAP_OBJ_LIMIT (HEAP_SIZE / sizeof(struct RVALUE) - 1)

extern VALUE rb_cMutex;

extern st_table *rb_class_tbl;

int ruby_disable_gc_stress = 0;

static void run_final(rb_objspace_t *objspace, VALUE obj);

static int garbage_collect(rb_objspace_t *objspace);

/*

* call-seq:

* GC.stress => true or false

*

* returns current status of GC stress mode.

*/

static VALUE

gc_stress_get(VALUE self)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

return ruby_gc_stress ? Qtrue : Qfalse;

}

/*

* call-seq:

* GC.stress = bool => bool

*

* updates GC stress mode.

*

* When GC.stress = true, GC is invoked for all GC opportunity:

* all memory and object allocation.

*

* Since it makes Ruby very slow, it is only for debugging.

*/

static VALUE

gc_stress_set(VALUE self, VALUE flag)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

rb_secure(2);

ruby_gc_stress = RTEST(flag);

return flag;

}

/*

* call-seq:

* GC::Profiler.enable? => true or false

*

* returns current status of GC profile mode.

*/

static VALUE

gc_profile_enable_get(VALUE self)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

return objspace->profile.run;

}

/*

* call-seq:

* GC::Profiler.enable => nil

*

* updates GC profile mode.

* start profiler for GC.

*

*/

static VALUE

gc_profile_enable(void)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

objspace->profile.run = TRUE;

return Qnil;

}

/*

* call-seq:

* GC::Profiler.disable => nil

*

* updates GC profile mode.

* stop profiler for GC.

*

*/

static VALUE

gc_profile_disable(void)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

objspace->profile.run = FALSE;

return Qnil;

}

/*

* call-seq:

* GC::Profiler.clear => nil

*

* clear before profile data.

*

*/

static VALUE

gc_profile_clear(void)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

MEMZERO(objspace->profile.record, gc_profile_record, objspace->profile.size);

objspace->profile.count = 0;

return Qnil;

}

static void vm_xfree(rb_objspace_t *objspace, void *ptr);

static void *

vm_xmalloc(rb_objspace_t *objspace, size_t size)

{

void *mem;

if ((ssize_t)size < 0) {

gc_inner->negative_size_allocation_error("negative allocation size (or too big)");

}

if (size == 0) size = 1;

#if CALC_EXACT_MALLOC_SIZE

size += sizeof(size_t);

#endif

if ((ruby_gc_stress && !ruby_disable_gc_stress) ||

(malloc_increase+size) > malloc_limit) {

gc_inner->garbage_collect_with_gvl(objspace);

}

mem = malloc(size);

if (!mem) {

if (gc_inner->garbage_collect_with_gvl(objspace)) {

mem = malloc(size);

}

if (!mem) {

gc_inner->ruby_memerror();

}

}

malloc_increase += size;

#if CALC_EXACT_MALLOC_SIZE

objspace->malloc_params.allocated_size += size;

objspace->malloc_params.allocations++;

((size_t *)mem)[0] = size;

mem = (size_t *)mem + 1;

#endif

return mem;

}

static void *

vm_xrealloc(rb_objspace_t *objspace, void *ptr, size_t size)

{

void *mem;

if ((ssize_t)size < 0) {

gc_inner->negative_size_allocation_error("negative re-allocation size");

}

if (!ptr) return vm_xmalloc(objspace, size);

if (size == 0) {

vm_xfree(objspace, ptr);

return 0;

}

if (ruby_gc_stress && !ruby_disable_gc_stress)

gc_inner->garbage_collect_with_gvl(objspace);

#if CALC_EXACT_MALLOC_SIZE

size += sizeof(size_t);

objspace->malloc_params.allocated_size -= size;

ptr = (size_t *)ptr - 1;

#endif

mem = realloc(ptr, size);

if (!mem) {

if (gc_inner->garbage_collect_with_gvl(objspace)) {

mem = realloc(ptr, size);

}

if (!mem) {

gc_inner->ruby_memerror();

}

}

malloc_increase += size;

#if CALC_EXACT_MALLOC_SIZE

objspace->malloc_params.allocated_size += size;

((size_t *)mem)[0] = size;

mem = (size_t *)mem + 1;

#endif

return mem;

}

static void

vm_xfree(rb_objspace_t *objspace, void *ptr)

{

#if CALC_EXACT_MALLOC_SIZE

size_t size;

ptr = ((size_t *)ptr) - 1;

size = ((size_t*)ptr)[0];

objspace->malloc_params.allocated_size -= size;

objspace->malloc_params.allocations--;

#endif

free(ptr);

}

static void *

ruby_xmalloc_tmp(size_t size)

{

return vm_xmalloc(gc_inner->get_objspace(), size);

}

static void *

ruby_xmalloc2_tmp(size_t n, size_t size)

{

size_t len = size * n;

if (n != 0 && size != len / n) {

rb_raise(rb_eArgError, "malloc: possible integer overflow");

}

return vm_xmalloc(gc_inner->get_objspace(), len);

}

static void *

ruby_xcalloc_tmp(size_t n, size_t size)

{

void *mem = ruby_xmalloc2(n, size);

memset(mem, 0, n * size);

return mem;

}

static void *

ruby_xrealloc_tmp(void *ptr, size_t size)

{

return vm_xrealloc(gc_inner->get_objspace(), ptr, size);

}

static void *

ruby_xrealloc2_tmp(void *ptr, size_t n, size_t size)

{

size_t len = size * n;

if (n != 0 && size != len / n) {

rb_raise(rb_eArgError, "realloc: possible integer overflow");

}

return ruby_xrealloc(ptr, len);

}

static void

ruby_xfree_tmp(void *x)

{

if (x)

vm_xfree(gc_inner->get_objspace(), x);

}

/*

* call-seq:

* GC.enable => true or false

*

* Enables garbage collection, returning <code>true</code> if garbage

* collection was previously disabled.

*

* GC.disable #=> false

* GC.enable #=> true

* GC.enable #=> false

*

*/

static VALUE

rb_gc_enable_tmp(void)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

int old = dont_gc;

dont_gc = FALSE;

return old ? Qtrue : Qfalse;

}

/*

* call-seq:

* GC.disable => true or false

*

* Disables garbage collection, returning <code>true</code> if garbage

* collection was already disabled.

*

* GC.disable #=> false

* GC.disable #=> true

*

*/

static VALUE

rb_gc_disable_tmp(void)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

int old = dont_gc;

dont_gc = TRUE;

return old ? Qtrue : Qfalse;

}

extern VALUE rb_mGC;

static void

rb_gc_register_address_tmp(VALUE *addr)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

struct gc_list *tmp;

tmp = ALLOC(struct gc_list);

tmp->next = global_List;

tmp->varptr = addr;

global_List = tmp;

}

static void

rb_gc_unregister_address_tmp(VALUE *addr)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

struct gc_list *tmp = global_List;

if (tmp->varptr == addr) {

global_List = tmp->next;

xfree(tmp);

return;

}

while (tmp->next) {

if (tmp->next->varptr == addr) {

struct gc_list *t = tmp->next;

tmp->next = tmp->next->next;

xfree(t);

break;

}

tmp = tmp->next;

}

}

static void

allocate_heaps(rb_objspace_t *objspace, size_t next_heaps_length)

{

struct heaps_slot *p;

size_t size;

size = next_heaps_length*sizeof(struct heaps_slot);

if (heaps_used > 0) {

p = (struct heaps_slot *)realloc(heaps, size);

if (p) heaps = p;

}

else {

p = heaps = (struct heaps_slot *)malloc(size);

}

if (p == 0) {

during_gc = 0;

rb_memerror();

}

heaps_length = next_heaps_length;

}

#define FIND_BITMAP(res, p) do {\

if (((RVALUE *)p)->as.free.flags & FL_ALIGNOFF) {\

res = (RVALUE *)((((VALUE)p & BITMAP_MASK) + BITMAP_ALIGN) / sizeof(RVALUE) * sizeof(RVALUE)); \

}\

else {\

res = (RVALUE *)(((VALUE)p & BITMAP_MASK) / sizeof(RVALUE) * sizeof(RVALUE));\

}\

} while(0)

#define NUM_IN_SLOT(p, slot) (((VALUE)p - (VALUE)slot)/sizeof(RVALUE))

#define BITMAP_INDEX(bmap, p) (NUM_IN_SLOT(p, bmap->as.bitmap.slot) / (sizeof(int) * 8))

/* #define BITMAP_INDEX(bmap, p) (NUM_IN_SLOT(p, bmap->as.bitmap.slot) >> 5) */

#define BITMAP_OFFSET(bmap, p) (NUM_IN_SLOT(p, bmap->as.bitmap.slot) & ((sizeof(int) * 8)-1))

#define MARKED_IN_BITMAP(bmap, p) (bmap->as.bitmap.map[BITMAP_INDEX(bmap, p)] & 1 << BITMAP_OFFSET(bmap, p))

#define MARK_IN_BITMAP(bmap, p) (bmap->as.bitmap.map[BITMAP_INDEX(bmap, p)] |= 1 << BITMAP_OFFSET(bmap, p))

#define CLEAR_IN_BITMAP(bmap, p) (bmap->as.bitmap.map[BITMAP_INDEX(bmap, p)] &= ~(1 << BITMAP_OFFSET(bmap, p)))

#define MARKED_IN_BITMAP_DIRECT(map, index, offset) (map[index] & 1 << offset)

#define MARK_IN_BITMAP_DIRECT(map, index, offset) (map[index] |= 1 << offset)

/* for debug */

void

bitmap_p(RVALUE *p)

{

RVALUE *bmap;

int index, offset, marked;

FIND_BITMAP(bmap, p);

index = BITMAP_INDEX(bmap, p);

offset = BITMAP_OFFSET(bmap, p);

marked = MARKED_IN_BITMAP(bmap, p);

printf("bitmap : ((RVALUE *)%p)\n", bmap);

printf("map_index : %d | offset : %d\n", index, offset);

printf("is mark ? %s\n", marked? "true" : "false");

}

VALUE

find_bitmap(RVALUE *p) {

RVALUE *res;

FIND_BITMAP(res, p);

return (VALUE)res;

}

void

dump_bitmap(RVALUE *bmap) {

int i;

for (i = 0; i < 26; i++) {

printf("dump %p map %d : %d %s\n", bmap, i, bmap->as.bitmap.map[i], bmap->as.bitmap.map[i]? "remain" : "clean");

}

}

void

bitmap2obj(RVALUE *bmap, int index, int offset)

{

printf("(RVALUE *)%p\n", (RVALUE *)(bmap->as.bitmap.slot + (index * sizeof(int) * 8 + offset) * sizeof(RVALUE)));

}

static void

make_bitmap(struct heaps_slot *slot)

{

RVALUE *p, *pend, *bitmap, *last, *border;

int *map = 0;

int size;

p = slot->slot;

pend = p + slot->limit;

last = pend - 1;

RBASIC(last)->flags = 0;

FIND_BITMAP(bitmap, last);

if (bitmap < p || pend <= bitmap) {

rb_bug("not include in heap slot: result bitmap(%p), find (%p), p (%p), pend(%p)", bitmap, last, p, pend);

}

border = bitmap;

if (!((VALUE)border % BITMAP_ALIGN)) {

border--;

}

while (p < pend) {

if (p <= border) {

RBASIC(p)->flags = FL_ALIGNOFF;

}

else {

RBASIC(p)->flags = 0;

}

p++;

}

size = sizeof(int) * (HEAP_OBJ_LIMIT / (sizeof(int) * 8)+1);

map = (int *)malloc(size);

if (map == 0) {

rb_memerror();

}

MEMZERO(map, int, (size/sizeof(int)));

bitmap->as.bitmap.flags |= T_BITMAP;

bitmap->as.bitmap.map = map;

bitmap->as.bitmap.slot = (VALUE)slot->slot;

bitmap->as.bitmap.limit = slot->limit;

slot->bitmap = bitmap;

}

void

test_bitmap(RVALUE *p, RVALUE *pend)

{

RVALUE *first, *bmap = 0, *bmap_tmp;

int i;

first = p;

FIND_BITMAP(bmap_tmp, p);

while (p < pend) {

if (MARKED_IN_BITMAP(bmap, p)) printf("already marking! %p\n", p);

if (bmap_tmp != p) {

FIND_BITMAP(bmap, p);

if (bmap_tmp != bmap) printf("diffrence bmap %p : %p\n", bmap_tmp, bmap);

MARK_IN_BITMAP(bmap, p);

}

else {

MARK_IN_BITMAP(bmap, p);

}

if (!MARKED_IN_BITMAP(bmap, p)) printf("not marking! %p\n", p);

p++;

}

for (i =0; i < 26; i++) {

printf("bitmap[%d] : %x\n", i, bmap->as.bitmap.map[i]);

}

p = first;

while (p < pend) {

if (bmap_tmp != p) {

FIND_BITMAP(bmap, p);

CLEAR_IN_BITMAP(bmap, p);

}

else {

CLEAR_IN_BITMAP(bmap, p);

}

if (MARKED_IN_BITMAP(bmap, p)) printf("not clear! %p\n", p);

p++;

}

for (i =0; i < 26; i++) {

printf("bitmap[%d] : %x\n", i, bmap->as.bitmap.map[i]);

}

}

static void

assign_heap_slot(rb_objspace_t *objspace)

{

RVALUE *p, *pend, *membase;

size_t hi, lo, mid;

size_t objs;

objs = HEAP_OBJ_LIMIT;

p = (RVALUE*)malloc(HEAP_SIZE);

if (p == 0) {

during_gc = 0;

rb_memerror();

}

membase = p;

if ((VALUE)p % sizeof(RVALUE) != 0) {

p = (RVALUE*)((VALUE)p + sizeof(RVALUE) - ((VALUE)p % sizeof(RVALUE)));

}

lo = 0;

hi = heaps_used;

while (lo < hi) {

register RVALUE *mid_membase;

mid = (lo + hi) / 2;

mid_membase = heaps[mid].membase;

if (mid_membase < membase) {

lo = mid + 1;

}

else if (mid_membase > membase) {

hi = mid;

}

else {

rb_bug("same heap slot is allocated: %p at %"PRIuVALUE, (void *)membase, (VALUE)mid);

}

}

if (hi < heaps_used) {

MEMMOVE(&heaps[hi+1], &heaps[hi], struct heaps_slot, heaps_used - hi);

}

heaps[hi].membase = membase;

heaps[hi].slot = p;

heaps[hi].limit = objs;

pend = p + objs;

if (lomem == 0 || lomem > p) lomem = p;

if (himem < pend) himem = pend;

heaps_used++;

make_bitmap(&heaps[hi]);

while (p < pend) {

if (BUILTIN_TYPE(p) != T_BITMAP) {

p->as.free.next = freelist;

freelist = p;

}

p++;

}

}

static void

init_heap(rb_objspace_t *objspace)

{

size_t add, i;

add = HEAP_MIN_SLOTS / HEAP_OBJ_LIMIT;

if (!add) {

add = 1;

}

if ((heaps_used + add) > heaps_length) {

allocate_heaps(objspace, heaps_used + add);

}

for (i = 0; i < add; i++) {

assign_heap_slot(objspace);

}

heaps_inc = 0;

objspace->profile.invoke_time = getrusage_time();

}

static void

set_heaps_increment(rb_objspace_t *objspace)

{

size_t next_heaps_length = (size_t)(heaps_used * 1.8);

if (next_heaps_length == heaps_used) {

next_heaps_length++;

}

heaps_inc = next_heaps_length - heaps_used;

if (next_heaps_length > heaps_length) {

allocate_heaps(objspace, next_heaps_length);

}

}

static int

heaps_increment(rb_objspace_t *objspace)

{

if (heaps_inc > 0) {

assign_heap_slot(objspace);

heaps_inc--;

return TRUE;

}

return FALSE;

}

#define RANY(o) ((RVALUE*)(o))

static VALUE

rb_newobj_from_heap(rb_objspace_t *objspace)

{

VALUE obj;

int bmap_left = 0;

if ((ruby_gc_stress && !ruby_disable_gc_stress) || !freelist) {

if (!heaps_increment(objspace) && !garbage_collect(objspace)) {

during_gc = 0;

rb_memerror();

}

}

obj = (VALUE)freelist;

freelist = freelist->as.free.next;

if (RANY(obj)->as.free.flags & FL_ALIGNOFF) {

bmap_left = Qtrue;

}

MEMZERO((void*)obj, RVALUE, 1);

if (bmap_left) {

RANY(obj)->as.free.flags = FL_ALIGNOFF;

}

#ifdef GC_DEBUG

RANY(obj)->file = rb_sourcefile();

RANY(obj)->line = rb_sourceline();

#endif

return obj;

}

/* TODO: remove this function. */

#if USE_VALUE_CACHE

static VALUE

rb_fill_value_cache(rb_thread_t *th)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

int i;

VALUE rv;

RVALUE *bmap;

/* LOCK */

for (i=0; i<RUBY_VM_VALUE_CACHE_SIZE; i++) {

VALUE v = rb_newobj_from_heap(objspace);

th->value_cache[i] = v;

FIND_BITMAP(bmap, v);

MARK_IN_BITMAP(bmap, v);

}

th->value_cache_ptr = &th->value_cache[0];

rv = rb_newobj_from_heap(objspace);

/* UNLOCK */

return rv;

}

#endif

static int

rb_during_gc_tmp(void)

{

rb_objspace_t *objspace = gc_inner->get_objspace();

return during_gc;

}

static VALUE

rb_newobj_tmp(void)

{

#if USE_VALUE_CACHE

rb_thread_t *th = GET_THREAD();

VALUE v = *th->value_cache_ptr;

#endif

rb_objspace_t *objspace = gc_inner->get_objspace();

if (during_gc) {

dont_gc = 1;

during_gc = 0;

rb_bug("object allocation during garbage collection phase");

}

#if USE_VALUE_CACHE

if (v) {

rb_set_flag_force(v, 0);

th->value_cache_ptr++;

}

else {

v = rb_fill_value_cache(th);

}

#if defined(GC_DEBUG)

printf("cache index: %d, v: %p, th: %p\n",

th->value_cache_ptr - th->value_cache, v, th);

#endif

return v;

#else

return rb_newobj_from_heap(objspace);

#endif

}

static void

rb_set_flag_force_tmp(VALUE obj, VALUE t)

{

t = t & ~FL_ALIGNOFF;

if (RBASIC(obj)->flags & FL_ALIGNOFF) {

RBASIC(obj)->flags = FL_ALIGNOFF | t;

}

else {

RBASIC(obj)->flags = t;

}

}

static VALUE

rb_data_object_alloc_tmp(VALUE klass, void *datap, RUBY_DATA_FUNC dmark,

RUBY_DATA_FUNC dfree)

{

NEWOBJ(data, struct RData);

if (klass) Check_Type(klass, T_CLASS);

OBJSETUP(data, klass, T_DATA);

data->data = datap;

data->dfree = dfree;

data->dmark = dmark;

return (VALUE)data;

}

static VALUE

rb_data_typed_object_alloc_tmp(VALUE klass, void *datap,

const rb_data_type_t *type)

{

NEWOBJ(data, struct RTypedData);

if (klass) Check_Type(klass, T_CLASS);

OBJSETUP(data, klass, T_DATA);

data->data = datap;

data->typed_flag = 1;

data->type = type;

return (VALUE)data;

}

static size_t

rb_objspace_data_type_memsize_tmp(VALUE obj)

{

if (RTYPEDDATA_P(obj)) {

return RTYPEDDATA_TYPE(obj)->dsize(RTYPEDDATA_DATA(obj));

}

else {

return 0;

}

}

static const char *

rb_objspace_data_type_name_tmp(VALUE obj)

{

if (RTYPEDDATA_P(obj)) {

return RTYPEDDATA_TYPE(obj)->wrap_struct_name;

}

else {

return 0;

}

}

#ifdef __ia64

#define SET_STACK_END (SET_MACHINE_STACK_END(&th->machine_stack_end), th->machine_register_stack_end = rb_ia64_bsp())

#else

#define SET_STACK_END SET_MACHINE_STACK_END(&th->machine_stack_end)

#endif

#define STACK_START (th->machine_stack_start)

#define STACK_END (th->machine_stack_end)

#define STACK_LEVEL_MAX (th->machine_stack_maxsize/sizeof(VALUE))

#if STACK_GROW_DIRECTION < 0

# define STACK_LENGTH (size_t)(STACK_START - STACK_END)

#elif STACK_GROW_DIRECTION > 0

# define STACK_LENGTH (size_t)(STACK_END - STACK_START + 1)

#else

# define STACK_LENGTH ((STACK_END < STACK_START) ? (size_t)(STACK_START - STACK_END) \

: (size_t)(STACK_END - STACK_START + 1))

#endif

#if !STACK_GROW_DIRECTION

int ruby_stack_grow_direction;

static int

ruby_get_stack_grow_direction_tmp(volatile VALUE *addr)

{

VALUE *end;

SET_MACHINE_STACK_END(&end);

if (end > addr) return ruby_stack_grow_direction = 1;

return ruby_stack_grow_direction = -1;

}

#endif

#define GC_WATER_MARK 512

static int

ruby_stack_check_tmp(void)

{

#if defined(POSIX_SIGNAL) && defined(SIGSEGV) && defined(HAVE_SIGALTSTACK)

return 0;

#else

return gc_inner->stack_check();

#endif

}

static void

init_mark_stack(rb_objspace_t *objspace)

{

mark_stack_overflow = 0;

mark_stack_ptr = mark_stack;

}

#define MARK_STACK_EMPTY (mark_stack_ptr == mark_stack)

static void gc_mark(rb_objspace_t *objspace, VALUE ptr, int lev);

#define IS_FREE_CELL(obj) ((obj->as.basic.flags & ~(FL_ALIGNOFF)) == 0)

static void

gc_mark_all(rb_objspace_t *objspace)

{

RVALUE *p, *pend, *bmap;

size_t i;

init_mark_stack(objspace);

for (i = 0; i < heaps_used; i++) {

p = heaps[i].slot; pend = p + heaps[i].limit;

bmap = heaps[i].bitmap;

while (p < pend) {

if (MARKED_IN_BITMAP(bmap, p) &&

!(IS_FREE_CELL(p))) {

gc_inner->gc_mark_children(objspace, (VALUE)p, 0);

}

p++;

}

}

}

static void

gc_mark_rest(rb_objspace_t *objspace)

{

VALUE tmp_arry[MARK_STACK_MAX];

VALUE *p;

p = (mark_stack_ptr - mark_stack) + tmp_arry;

MEMCPY(tmp_arry, mark_stack, VALUE, p - tmp_arry);

init_mark_stack(objspace);

while (p != tmp_arry) {

p--;

gc_inner->gc_mark_children(objspace, *p, 0);

}

}

static inline int

is_pointer_to_heap(rb_objspace_t *objspace, void *ptr)

{

register RVALUE *p = RANY(ptr);

register struct heaps_slot *heap;

register size_t hi, lo, mid;

if (p < lomem || p > himem) return FALSE;

if ((VALUE)p % sizeof(RVALUE) != 0) return FALSE;

/* check if p looks like a pointer using bsearch*/

lo = 0;

hi = heaps_used;

while (lo < hi) {

mid = (lo + hi) / 2;

heap = &heaps[mid];

if (heap->slot <= p) {

if (p < heap->slot + heap->limit)

return TRUE;

lo = mid + 1;

}

else {

hi = mid;

}

}

return FALSE;

}

static void

mark_locations_array(rb_objspace_t *objspace, register VALUE *x, register long n)

{

VALUE v;

while (n--) {

v = *x;

VALGRIND_MAKE_MEM_DEFINED(&v, sizeof(v));

if (is_pointer_to_heap(objspace, (void *)v)) {

gc_mark(objspace, v, 0);

}

x++;

}

}

static void

gc_mark_locations(rb_objspace_t *objspace, VALUE *start, VALUE *end)

{

long n;

if (end <= start) return;

n = end - start;

mark_locations_array(objspace, start, n);

}

static void

rb_gc_mark_locations_tmp(VALUE *start, VALUE *end)

{

gc_mark_locations(gc_inner->get_objspace(), start, end);

}

#define rb_gc_mark_locations(start, end) gc_mark_locations(objspace, start, end)

struct mark_tbl_arg {

rb_objspace_t *objspace;

int lev;

};

static int

mark_entry(ID key, VALUE value, st_data_t data)

{

struct mark_tbl_arg *arg = (void*)data;

gc_mark(arg->objspace, value, arg->lev);

return ST_CONTINUE;

}

static void

mark_tbl(rb_objspace_t *objspace, st_table *tbl, int lev)

{

struct mark_tbl_arg arg;

if (!tbl) return;

arg.objspace = objspace;

arg.lev = lev;

st_foreach(tbl, mark_entry, (st_data_t)&arg);

}

static int

mark_key(VALUE key, VALUE value, st_data_t data)

{

struct mark_tbl_arg *arg = (void*)data;

gc_mark(arg->objspace, key, arg->lev);

return ST_CONTINUE;

}

static void

mark_set(rb_objspace_t *objspace, st_table *tbl, int lev)

{

struct mark_tbl_arg arg;

if (!tbl) return;

arg.objspace = objspace;

arg.lev = lev;

st_foreach(tbl, mark_key, (st_data_t)&arg);

}

static void

rb_mark_set_tmp(st_table *tbl)

{

mark_set(gc_inner->get_objspace(), tbl, 0);

}

static int

mark_keyvalue(VALUE key, VALUE value, st_data_t data)

{

struct mark_tbl_arg *arg = (void*)data;

gc_mark(arg->objspace, key, arg->lev);

gc_mark(arg->objspace, value, arg->lev);

return ST_CONTINUE;

}

static void

mark_hash(rb_objspace_t *objspace, st_table *tbl, int lev)

{

struct mark_tbl_arg arg;

if (!tbl) return;

arg.objspace = objspace;

arg.lev = lev;

st_foreach(tbl, mark_keyvalue, (st_data_t)&arg);

}

static int

mark_method_entry_i(ID key, const rb_method_entry_t *me, st_data_t data)

{

struct mark_tbl_arg *arg = (void*)data;

gc_inner->mark_method_entry(arg->objspace, me, arg->lev);