// Resurrect the obj tree whose root is the obj which p_ref points to
static inline void resurrect_obj_tree(Collector *collector, REF *p_ref)
{
GC *gc = collector->gc;
GC_Metadata *metadata = gc->metadata;
Partial_Reveal_Object *p_obj = read_slot(p_ref);
assert(p_obj && gc_obj_is_dead(gc, p_obj));
void *p_ref_or_obj = p_ref;
Trace_Object_Func trace_object;
/* set trace_object() function */
if(collect_is_minor()){
if(gc_is_gen_mode()){
if(minor_is_forward())
trace_object = trace_obj_in_gen_fw;
else if(minor_is_semispace())
trace_object = trace_obj_in_gen_ss;
else
assert(0);
}else{
if(minor_is_forward())
trace_object = trace_obj_in_nongen_fw;
else if(minor_is_semispace())
trace_object = trace_obj_in_nongen_ss;
else
assert(0);
}
} else if(collect_is_major_normal() || !gc_has_nos()){
p_ref_or_obj = p_obj;
if(gc_has_space_tuner(gc) && (gc->tuner->kind != TRANS_NOTHING)){
trace_object = trace_obj_in_space_tune_marking;
unsigned int obj_size = vm_object_size(p_obj);
#ifdef USE_32BITS_HASHCODE
obj_size += hashcode_is_set(p_obj) ? GC_OBJECT_ALIGNMENT : 0;
#endif
if(!obj_belongs_to_space(p_obj, gc_get_los((GC_Gen*)gc))){
collector->non_los_live_obj_size += obj_size;
collector->segment_live_size[SIZE_TO_SEGMENT_INDEX(obj_size)] += obj_size;
} else {
collector->los_live_obj_size += round_up_to_size(obj_size, KB);
}
} else if(!gc_has_nos()){
trace_object = trace_obj_in_ms_marking;
} else {
trace_object = trace_obj_in_normal_marking;
}
} else if(collect_is_fallback()){
if(major_is_marksweep())
trace_object = trace_obj_in_ms_fallback_marking;
else
trace_object = trace_obj_in_fallback_marking;
} else {
assert(major_is_marksweep());
p_ref_or_obj = p_obj;
if( gc->gc_concurrent_status == GC_CON_NIL )
trace_object = trace_obj_in_ms_marking;
else
trace_object = trace_obj_in_ms_concurrent_mark;
}
collector->trace_stack = free_task_pool_get_entry(metadata);
collector_tracestack_push(collector, p_ref_or_obj);
pool_put_entry(metadata->mark_task_pool, collector->trace_stack);
collector->trace_stack = free_task_pool_get_entry(metadata);
Vector_Block *task_block = pool_get_entry(metadata->mark_task_pool);
while(task_block){
POINTER_SIZE_INT *iter = vector_block_iterator_init(task_block);
while(!vector_block_iterator_end(task_block, iter)){
void *p_ref_or_obj = (void*)*iter;
assert(((collect_is_minor()||collect_is_fallback()) && *(Partial_Reveal_Object **)p_ref_or_obj)
|| ((collect_is_major_normal()||major_is_marksweep()||!gc_has_nos()) && p_ref_or_obj));
trace_object(collector, p_ref_or_obj);
if(collector->result == FALSE) break; /* Resurrection fallback happens; force return */
iter = vector_block_iterator_advance(task_block, iter);
}
vector_stack_clear(task_block);
pool_put_entry(metadata->free_task_pool, task_block);
if(collector->result == FALSE){
gc_task_pool_clear(metadata->mark_task_pool);
break; /* force return */
}
task_block = pool_get_entry(metadata->mark_task_pool);
}
task_block = (Vector_Block*)collector->trace_stack;
vector_stack_clear(task_block);
pool_put_entry(metadata->free_task_pool, task_block);
collector->trace_stack = NULL;
}
static inline void move_obj_between_chunks(Wspace *wspace, Chunk_Header **dest_ptr, Chunk_Header *src)
{
Chunk_Header *dest = *dest_ptr;
assert(dest->slot_size == src->slot_size);
unsigned int slot_size = dest->slot_size;
unsigned int alloc_num = src->alloc_num;
assert(alloc_num);
#ifdef USE_32BITS_HASHCODE
Hashcode_Buf* old_hashcode_buf = src->hashcode_buf;
Hashcode_Buf* new_hashcode_buf = dest->hashcode_buf;
#endif
while(alloc_num && dest){
Partial_Reveal_Object *p_obj = next_alloc_slot_in_chunk(src);
Partial_Reveal_Object *target = (Partial_Reveal_Object *)alloc_in_chunk(dest);
if(dest->slot_index == MAX_SLOT_INDEX){
dest->status = CHUNK_USED | CHUNK_NORMAL;
wspace_reg_used_chunk(wspace,dest);
dest = NULL;
}
assert(p_obj && target);
memcpy(target, p_obj, slot_size);
#ifdef USE_32BITS_HASHCODE
if(hashcode_is_set(p_obj)){
int hashcode;
if(new_hashcode_buf == NULL) {
new_hashcode_buf = hashcode_buf_create();
hashcode_buf_init(new_hashcode_buf);
dest->hashcode_buf = new_hashcode_buf;
}
if(hashcode_is_buffered(p_obj)){
/*already buffered objects;*/
hashcode = hashcode_buf_lookup(p_obj, old_hashcode_buf);
hashcode_buf_update(target, hashcode, new_hashcode_buf);
}else{
/*objects need buffering.*/
hashcode = hashcode_gen(p_obj);
hashcode_buf_update(target, hashcode, new_hashcode_buf);
Obj_Info_Type oi = get_obj_info_raw(target);
set_obj_info(target, oi | HASHCODE_BUFFERED_BIT);
}
}
#endif
#ifdef SSPACE_VERIFY
wspace_modify_mark_in_compact(target, p_obj, slot_size);
#endif
obj_set_fw_in_oi(p_obj, target);
--alloc_num;
}
#ifdef USE_32BITS_HASHCODE
if(alloc_num == 0) {
if(old_hashcode_buf) hashcode_buf_destory(old_hashcode_buf);
src->hashcode_buf = NULL;
}
#endif
/* dest might be set to NULL, so we use *dest_ptr here */
assert((*dest_ptr)->alloc_num <= (*dest_ptr)->slot_num);
src->alloc_num = alloc_num;
if(!dest){
assert((*dest_ptr)->alloc_num == (*dest_ptr)->slot_num);
*dest_ptr = NULL;
clear_free_slot_in_table(src->table, src->slot_index);
}
}
