void factor_vm::clear_cards(old_space *gen)
{
/* NOTE: reverse order due to heap layout. */
card *first_card = addr_to_card(gen->start);
card *last_card = addr_to_card(gen->end);
memset(first_card,0,last_card - first_card);
}
data_heap::data_heap(cell young_size_,
cell aging_size_,
cell tenured_size_)
{
young_size_ = align(young_size_,deck_size);
aging_size_ = align(aging_size_,deck_size);
tenured_size_ = align(tenured_size_,deck_size);
young_size = young_size_;
aging_size = aging_size_;
tenured_size = tenured_size_;
cell total_size = young_size + 2 * aging_size + tenured_size + deck_size;
seg = new segment(total_size,false);
cell cards_size = addr_to_card(total_size);
cards = new card[cards_size];
cards_end = cards + cards_size;
memset(cards,0,cards_size);
cell decks_size = addr_to_deck(total_size);
decks = new card_deck[decks_size];
decks_end = decks + decks_size;
memset(decks,0,decks_size);
start = align(seg->start,deck_size);
tenured = new tenured_space(tenured_size,start);
aging = new aging_space(aging_size,tenured->end);
aging_semispace = new aging_space(aging_size,aging->end);
nursery = new nursery_space(young_size,aging_semispace->end);
FACTOR_ASSERT(seg->end - nursery->end <= deck_size);
}
void trace_cards(SourceGeneration *gen, card mask, Unmarker unmarker)
{
card_deck *decks = data->decks;
card_deck *cards = data->cards;
cell gen_start_card = addr_to_card(gen->start - data->start);
cell first_deck = card_deck_for_address(gen->start);
cell last_deck = card_deck_for_address(gen->end);
cell start = 0, binary_start = 0, end = 0;
for(cell deck_index = first_deck; deck_index < last_deck; deck_index++)
{
if(decks[deck_index] & mask)
{
decks_scanned++;
cell first_card = first_card_in_deck(deck_index);
cell last_card = last_card_in_deck(deck_index);
for(cell card_index = first_card; card_index < last_card; card_index++)
{
if(cards[card_index] & mask)
{
cards_scanned++;
if(end < card_start_address(card_index))
{
start = gen->starts.find_object_containing_card(card_index - gen_start_card);
binary_start = start + ((object *)start)->binary_payload_start();
end = start + ((object *)start)->size();
}
scan_next_object: if(start < card_end_address(card_index))
{
trace_partial_objects(
start,
binary_start,
card_start_address(card_index),
card_end_address(card_index));
if(end < card_end_address(card_index))
{
start = gen->next_object_after(start);
if(start)
{
binary_start = start + ((object *)start)->binary_payload_start();
end = start + ((object *)start)->size();
goto scan_next_object;
}
}
}
unmarker(&cards[card_index]);
if(!start) return;
}
}
unmarker(&decks[deck_index]);
}
}
}
void object_start_map::clear_object_start_offsets() {
memset(object_start_offsets, card_starts_inside_object, addr_to_card(size));
}
// we need to remember the first object allocated in the card
void object_start_map::record_object_start_offset(object* obj) {
cell idx = addr_to_card((cell)obj - start);
card obj_start = ((cell)obj & addr_card_mask);
object_start_offsets[idx] = std::min(object_start_offsets[idx], obj_start);
}
template<typename Generation> void data_heap::clear_cards(Generation *gen)
{
cell first_card = addr_to_card(gen->start - start);
cell last_card = addr_to_card(gen->end - start);
memset(&cards[first_card],0,last_card - first_card);
}
void factor_vm::init_card_decks()
{
cards_offset = (cell)data->cards - addr_to_card(data->start);
decks_offset = (cell)data->decks - addr_to_deck(data->start);
}
