#include "master.hpp"
-namespace factor
-{
+namespace factor {
-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);
+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);
}
-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);
+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_;
+ 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 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 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);
+ 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);
+ start = align(seg->start, deck_size);
- tenured = new tenured_space(tenured_size,start);
+ tenured = new tenured_space(tenured_size, start);
- aging = new aging_space(aging_size,tenured->end);
- aging_semispace = new aging_space(aging_size,aging->end);
+ 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);
+ nursery = new nursery_space(young_size, aging_semispace->end);
- FACTOR_ASSERT(seg->end - nursery->end <= deck_size);
+ FACTOR_ASSERT(seg->end - nursery->end <= deck_size);
}
-data_heap::~data_heap()
-{
- delete seg;
- delete nursery;
- delete aging;
- delete aging_semispace;
- delete tenured;
- delete[] cards;
- delete[] decks;
+data_heap::~data_heap() {
+ delete seg;
+ delete nursery;
+ delete aging;
+ delete aging_semispace;
+ delete tenured;
+ delete[] cards;
+ delete[] decks;
}
-data_heap *data_heap::grow(cell requested_bytes)
-{
- cell new_tenured_size = (tenured_size * 2) + requested_bytes;
- return new data_heap(young_size,
- aging_size,
- new_tenured_size);
+data_heap* data_heap::grow(cell requested_bytes) {
+ cell new_tenured_size = (tenured_size * 2) + requested_bytes;
+ return new data_heap(young_size, aging_size, new_tenured_size);
}
-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);
+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);
}
-template<typename Generation> void data_heap::clear_decks(Generation *gen)
-{
- cell first_deck = addr_to_deck(gen->start - start);
- cell last_deck = addr_to_deck(gen->end - start);
- memset(&decks[first_deck],0,last_deck - first_deck);
+template <typename Generation> void data_heap::clear_decks(Generation* gen) {
+ cell first_deck = addr_to_deck(gen->start - start);
+ cell last_deck = addr_to_deck(gen->end - start);
+ memset(&decks[first_deck], 0, last_deck - first_deck);
}
-void data_heap::reset_generation(nursery_space *gen)
-{
- gen->here = gen->start;
-}
+void data_heap::reset_generation(nursery_space* gen) { gen->here = gen->start; }
-void data_heap::reset_generation(aging_space *gen)
-{
- gen->here = gen->start;
- clear_cards(gen);
- clear_decks(gen);
- gen->starts.clear_object_start_offsets();
+void data_heap::reset_generation(aging_space* gen) {
+ gen->here = gen->start;
+ clear_cards(gen);
+ clear_decks(gen);
+ gen->starts.clear_object_start_offsets();
}
-void data_heap::reset_generation(tenured_space *gen)
-{
- clear_cards(gen);
- clear_decks(gen);
+void data_heap::reset_generation(tenured_space* gen) {
+ clear_cards(gen);
+ clear_decks(gen);
}
-bool data_heap::high_fragmentation_p()
-{
- return (tenured->largest_free_block() <= high_water_mark());
+bool data_heap::high_fragmentation_p() {
+ return (tenured->largest_free_block() <= high_water_mark());
}
-bool data_heap::low_memory_p()
-{
- return (tenured->free_space() <= high_water_mark());
+bool data_heap::low_memory_p() {
+ return (tenured->free_space() <= high_water_mark());
}
-void data_heap::mark_all_cards()
-{
- memset(cards,-1,cards_end - cards);
- memset(decks,-1,decks_end - decks);
+void data_heap::mark_all_cards() {
+ memset(cards, -1, cards_end - cards);
+ memset(decks, -1, decks_end - decks);
}
-void factor_vm::set_data_heap(data_heap *data_)
-{
- data = data_;
- nursery = *data->nursery;
- init_card_decks();
+void factor_vm::set_data_heap(data_heap* data_) {
+ data = data_;
+ nursery = *data->nursery;
+ init_card_decks();
}
-void factor_vm::init_data_heap(cell young_size, cell aging_size, cell tenured_size)
-{
- set_data_heap(new data_heap(young_size,aging_size,tenured_size));
+void factor_vm::init_data_heap(cell young_size, cell aging_size,
+ cell tenured_size) {
+ set_data_heap(new data_heap(young_size, aging_size, tenured_size));
}
-data_heap_room factor_vm::data_room()
-{
- data_heap_room room;
+data_heap_room factor_vm::data_room() {
+ data_heap_room room;
- room.nursery_size = nursery.size;
- room.nursery_occupied = nursery.occupied_space();
- room.nursery_free = nursery.free_space();
- room.aging_size = data->aging->size;
- room.aging_occupied = data->aging->occupied_space();
- room.aging_free = data->aging->free_space();
- room.tenured_size = data->tenured->size;
- room.tenured_occupied = data->tenured->occupied_space();
- room.tenured_total_free = data->tenured->free_space();
- room.tenured_contiguous_free = data->tenured->largest_free_block();
- room.tenured_free_block_count = data->tenured->free_block_count();
- room.cards = data->cards_end - data->cards;
- room.decks = data->decks_end - data->decks;
- room.mark_stack = mark_stack.capacity() * sizeof(cell);
+ room.nursery_size = nursery.size;
+ room.nursery_occupied = nursery.occupied_space();
+ room.nursery_free = nursery.free_space();
+ room.aging_size = data->aging->size;
+ room.aging_occupied = data->aging->occupied_space();
+ room.aging_free = data->aging->free_space();
+ room.tenured_size = data->tenured->size;
+ room.tenured_occupied = data->tenured->occupied_space();
+ room.tenured_total_free = data->tenured->free_space();
+ room.tenured_contiguous_free = data->tenured->largest_free_block();
+ room.tenured_free_block_count = data->tenured->free_block_count();
+ room.cards = data->cards_end - data->cards;
+ room.decks = data->decks_end - data->decks;
+ room.mark_stack = mark_stack.capacity() * sizeof(cell);
- return room;
+ return room;
}
/* Allocates memory */
-void factor_vm::primitive_data_room()
-{
- data_heap_room room = data_room();
- ctx->push(tag<byte_array>(byte_array_from_value(&room)));
+void factor_vm::primitive_data_room() {
+ data_heap_room room = data_room();
+ ctx->push(tag<byte_array>(byte_array_from_value(&room)));
}
struct object_accumulator {
- cell type;
- std::vector<cell> objects;
+ cell type;
+ std::vector<cell> objects;
- explicit object_accumulator(cell type_) : type(type_) {}
+ explicit object_accumulator(cell type_) : type(type_) {}
- void operator()(object *obj)
- {
- if(type == TYPE_COUNT || obj->type() == type)
- objects.push_back(tag_dynamic(obj));
- }
+ void operator()(object* obj) {
+ if (type == TYPE_COUNT || obj->type() == type)
+ objects.push_back(tag_dynamic(obj));
+ }
};
/* Allocates memory */
-cell factor_vm::instances(cell type)
-{
- object_accumulator accum(type);
- each_object(accum);
- return std_vector_to_array(accum.objects);
+cell factor_vm::instances(cell type) {
+ object_accumulator accum(type);
+ each_object(accum);
+ return std_vector_to_array(accum.objects);
}
/* Allocates memory */
-void factor_vm::primitive_all_instances()
-{
- primitive_full_gc();
- ctx->push(instances(TYPE_COUNT));
+void factor_vm::primitive_all_instances() {
+ primitive_full_gc();
+ ctx->push(instances(TYPE_COUNT));
}
}
/* A tool to debug write barriers. Call check_data_heap() to ensure that all
cards that should be marked are actually marked. */
-namespace factor
-{
+namespace factor {
enum generation {
- nursery_generation,
- aging_generation,
- tenured_generation
+ nursery_generation,
+ aging_generation,
+ tenured_generation
};
-inline generation generation_of(factor_vm *parent, object *obj)
-{
- if(parent->data->nursery->contains_p(obj))
- return nursery_generation;
- else if(parent->data->aging->contains_p(obj))
- return aging_generation;
- else if(parent->data->tenured->contains_p(obj))
- return tenured_generation;
- else
- {
- critical_error("Bad object",(cell)obj);
- return (generation)-1;
- }
+inline generation generation_of(factor_vm* parent, object* obj) {
+ if (parent->data->nursery->contains_p(obj))
+ return nursery_generation;
+ else if (parent->data->aging->contains_p(obj))
+ return aging_generation;
+ else if (parent->data->tenured->contains_p(obj))
+ return tenured_generation;
+ else {
+ critical_error("Bad object", (cell) obj);
+ return (generation) - 1;
+ }
}
struct slot_checker {
- factor_vm *parent;
- object *obj;
- generation gen;
+ factor_vm* parent;
+ object* obj;
+ generation gen;
- explicit slot_checker(factor_vm *parent_, object *obj_, generation gen_) :
- parent(parent_), obj(obj_), gen(gen_) {}
+ explicit slot_checker(factor_vm* parent_, object* obj_, generation gen_)
+ : parent(parent_), obj(obj_), gen(gen_) {}
- void check_write_barrier(cell *slot_ptr, generation target, char mask)
- {
- cell object_card_pointer = parent->cards_offset + ((cell)obj >> card_bits);
- cell slot_card_pointer = parent->cards_offset + ((cell)slot_ptr >> card_bits);
- char slot_card_value = *(char *)slot_card_pointer;
- if((slot_card_value & mask) != mask)
- {
- std::cout << "card not marked" << std::endl;
- std::cout << "source generation: " << gen << std::endl;
- std::cout << "target generation: " << target << std::endl;
- std::cout << "object: 0x" << std::hex << (cell)obj << std::dec << std::endl;
- std::cout << "object type: " << obj->type() << std::endl;
- std::cout << "slot pointer: 0x" << std::hex << (cell)slot_ptr << std::dec << std::endl;
- std::cout << "slot value: 0x" << std::hex << *slot_ptr << std::dec << std::endl;
- std::cout << "card of object: 0x" << std::hex << object_card_pointer << std::dec << std::endl;
- std::cout << "card of slot: 0x" << std::hex << slot_card_pointer << std::dec << std::endl;
- std::cout << std::endl;
- parent->factorbug();
- }
- }
+ void check_write_barrier(cell* slot_ptr, generation target, char mask) {
+ cell object_card_pointer = parent->cards_offset + ((cell) obj >> card_bits);
+ cell slot_card_pointer =
+ parent->cards_offset + ((cell) slot_ptr >> card_bits);
+ char slot_card_value = *(char*)slot_card_pointer;
+ if ((slot_card_value & mask) != mask) {
+ std::cout << "card not marked" << std::endl;
+ std::cout << "source generation: " << gen << std::endl;
+ std::cout << "target generation: " << target << std::endl;
+ std::cout << "object: 0x" << std::hex << (cell)
+ obj << std::dec << std::endl;
+ std::cout << "object type: " << obj->type() << std::endl;
+ std::cout << "slot pointer: 0x" << std::hex << (cell)
+ slot_ptr << std::dec << std::endl;
+ std::cout << "slot value: 0x" << std::hex << *slot_ptr << std::dec
+ << std::endl;
+ std::cout << "card of object: 0x" << std::hex << object_card_pointer
+ << std::dec << std::endl;
+ std::cout << "card of slot: 0x" << std::hex << slot_card_pointer
+ << std::dec << std::endl;
+ std::cout << std::endl;
+ parent->factorbug();
+ }
+ }
- void operator()(cell *slot_ptr)
- {
- if(!immediate_p(*slot_ptr))
- {
- generation target = generation_of(parent,untag<object>(*slot_ptr));
- switch(gen)
- {
- case nursery_generation:
- break;
- case aging_generation:
- if(target == nursery_generation)
- check_write_barrier(slot_ptr,target,card_points_to_nursery);
- break;
- case tenured_generation:
- if(target == nursery_generation)
- check_write_barrier(slot_ptr,target,card_points_to_nursery);
- else if(target == aging_generation)
- check_write_barrier(slot_ptr,target,card_points_to_aging);
- break;
- }
- }
- }
+ void operator()(cell* slot_ptr) {
+ if (!immediate_p(*slot_ptr)) {
+ generation target = generation_of(parent, untag<object>(*slot_ptr));
+ switch (gen) {
+ case nursery_generation:
+ break;
+ case aging_generation:
+ if (target == nursery_generation)
+ check_write_barrier(slot_ptr, target, card_points_to_nursery);
+ break;
+ case tenured_generation:
+ if (target == nursery_generation)
+ check_write_barrier(slot_ptr, target, card_points_to_nursery);
+ else if (target == aging_generation)
+ check_write_barrier(slot_ptr, target, card_points_to_aging);
+ break;
+ }
+ }
+ }
};
struct object_checker {
- factor_vm *parent;
+ factor_vm* parent;
- explicit object_checker(factor_vm *parent_) : parent(parent_) {}
+ explicit object_checker(factor_vm* parent_) : parent(parent_) {}
- void operator()(object *obj)
- {
- slot_checker checker(parent,obj,generation_of(parent,obj));
- obj->each_slot(checker);
- }
+ void operator()(object* obj) {
+ slot_checker checker(parent, obj, generation_of(parent, obj));
+ obj->each_slot(checker);
+ }
};
-void factor_vm::check_data_heap()
-{
- object_checker checker(this);
- each_object(checker);
+void factor_vm::check_data_heap() {
+ object_checker checker(this);
+ each_object(checker);
}
}
projects / factor.git / commitdiff