void minor_sweep_phase_young()
{
int size, perc;
int reclaiming = 0;
int alive = 0;
old_bytes_in_young_blocks_since_last_major = 0;
for(size=MIN_TERM_SIZE; size<MAX_TERM_SIZE; size++) {
Block *prev_block = NULL;
Block *next_block;
ATerm old_freelist;
Block *block = at_blocks[size];
header_type *end = top_at_blocks[size];
/* empty the freelist*/
at_freelist[size] = NULL;
while(block) {
/* set empty = 0 to avoid recycling*/
int empty = 1;
int alive_in_block = 0;
int dead_in_block = 0;
int free_in_block = 0;
int old_in_block = 0;
int capacity = (end-(block->data))/size;
header_type *cur;
assert(block->size == size);
old_freelist = at_freelist[size];
for(cur=block->data ; cur<end ; cur+=size) {
ATerm t = (ATerm)cur;
if(IS_MARKED(t->header) || IS_OLD(t->header)) {
if(IS_OLD(t->header)) {
old_in_block++;
}
CLR_MARK(t->header);
alive_in_block++;
empty = 0;
assert(!IS_MARKED(t->header));
} else {
switch(ATgetType(t)) {
case AT_FREE:
/* AT_freelist[size] is not empty: so DO NOT ADD t*/
t->aterm.next = at_freelist[size];
at_freelist[size] = t;
free_in_block++;
break;
case AT_INT:
case AT_REAL:
case AT_APPL:
case AT_LIST:
case AT_PLACEHOLDER:
case AT_BLOB:
AT_freeTerm(size, t);
t->header = FREE_HEADER;
t->aterm.next = at_freelist[size];
at_freelist[size] = t;
dead_in_block++;
break;
case AT_SYMBOL:
AT_freeSymbol((SymEntry)t);
t->header = FREE_HEADER;
t->aterm.next = at_freelist[size];
at_freelist[size] = t;
dead_in_block++;
break;
default:
ATabort("panic in sweep phase\n");
}
assert(!IS_MARKED(t->header));
}
}
assert(alive_in_block + dead_in_block + free_in_block == capacity);
next_block = block->next_by_size;
#ifndef NDEBUG
if(empty) {
for(cur=block->data; cur<end; cur+=size) {
assert(ATgetType((ATerm)cur) == AT_FREE);
}
}
#endif
/* Do not reclaim frozen blocks */
if(IS_FROZEN(block)) {
at_freelist[size] = old_freelist;
}
/* TODO: create freeList Old*/
if(0 && empty) {
at_freelist[size] = old_freelist;
reclaim_empty_block(at_blocks, size, block, prev_block);
} else if(0 && 100*old_in_block/capacity >= TO_OLD_RATIO) {
promote_block_to_old(size, block, prev_block);
} else {
old_bytes_in_young_blocks_since_last_major += (old_in_block*SIZE_TO_BYTES(size));
prev_block = block;
}
block = next_block;
if(block) {
end = block->end;
}
alive += alive_in_block;
reclaiming += dead_in_block;
}
#ifndef NDEBUG
if(at_freelist[size]) {
ATerm data;
/*fprintf(stderr,"minor_sweep_phase_young: ensure empty freelist[%d]\n",size);*/
for(data = at_freelist[size] ; data ; data=data->aterm.next) {
if(!EQUAL_HEADER(data->header,FREE_HEADER)) {
fprintf(stderr,"data = %p header = %x\n",data,(unsigned int) data->header);
}
assert(EQUAL_HEADER(data->header,FREE_HEADER));
assert(ATgetType(data) == AT_FREE);
}
}
#endif
}
if(alive) {
perc = (100*reclaiming)/alive;
STATS(reclaim_perc, perc);
}
}
bool
is_frozen (Value* value)
{
return IS_FROZEN(value);
}
