steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

VM: Refactor data_heap* to Factor style

db4
Erik Charlebois 2013-05-11 21:56:29 -04:00
parent fb34be6fa7
commit 75e6c88534
3 changed files with 217 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
vm/data_heap.cpp
View File

@ -1,18 +1,13 @@
#include "master.hpp" #include "master.hpp"
namespace factor namespace factor {
{
void factor_vm::init_card_decks() void factor_vm::init_card_decks() {
{
cards_offset = (cell) data->cards - addr_to_card(data->start); cards_offset = (cell) data->cards - addr_to_card(data->start);
decks_offset = (cell) data->decks - addr_to_deck(data->start); decks_offset = (cell) data->decks - addr_to_deck(data->start);
} }
data_heap::data_heap(cell young_size_, data_heap::data_heap(cell young_size_, cell aging_size_, cell tenured_size_) {
cell aging_size_,
cell tenured_size_)
{
young_size_ = align(young_size_, deck_size); young_size_ = align(young_size_, deck_size);
aging_size_ = align(aging_size_, deck_size); aging_size_ = align(aging_size_, deck_size);
tenured_size_ = align(tenured_size_, deck_size); tenured_size_ = align(tenured_size_, deck_size);
@ -46,8 +41,7 @@ data_heap::data_heap(cell young_size_,
FACTOR_ASSERT(seg->end - nursery->end <= deck_size); FACTOR_ASSERT(seg->end - nursery->end <= deck_size);
} }
data_heap::~data_heap() data_heap::~data_heap() {
{
delete seg; delete seg;
delete nursery; delete nursery;
delete aging; delete aging;
@ -57,77 +51,62 @@ data_heap::~data_heap()
delete[] decks; delete[] decks;
} }
data_heap *data_heap::grow(cell requested_bytes) data_heap* data_heap::grow(cell requested_bytes) {
{
cell new_tenured_size = (tenured_size * 2) + requested_bytes; cell new_tenured_size = (tenured_size * 2) + requested_bytes;
return new data_heap(young_size, return new data_heap(young_size, aging_size, new_tenured_size);
aging_size,
new_tenured_size);
} }
template<typename Generation> void data_heap::clear_cards(Generation *gen) template <typename Generation> void data_heap::clear_cards(Generation* gen) {
{
cell first_card = addr_to_card(gen->start - start); cell first_card = addr_to_card(gen->start - start);
cell last_card = addr_to_card(gen->end - start); cell last_card = addr_to_card(gen->end - start);
memset(&cards[first_card], 0, last_card - first_card); memset(&cards[first_card], 0, last_card - first_card);
} }
template<typename Generation> void data_heap::clear_decks(Generation *gen) template <typename Generation> void data_heap::clear_decks(Generation* gen) {
{
cell first_deck = addr_to_deck(gen->start - start); cell first_deck = addr_to_deck(gen->start - start);
cell last_deck = addr_to_deck(gen->end - start); cell last_deck = addr_to_deck(gen->end - start);
memset(&decks[first_deck], 0, last_deck - first_deck); memset(&decks[first_deck], 0, last_deck - first_deck);
} }
void data_heap::reset_generation(nursery_space *gen) void data_heap::reset_generation(nursery_space* gen) { gen->here = gen->start; }
{
gen->here = gen->start;
}
void data_heap::reset_generation(aging_space *gen) void data_heap::reset_generation(aging_space* gen) {
{
gen->here = gen->start; gen->here = gen->start;
clear_cards(gen); clear_cards(gen);
clear_decks(gen); clear_decks(gen);
gen->starts.clear_object_start_offsets(); gen->starts.clear_object_start_offsets();
} }
void data_heap::reset_generation(tenured_space *gen) void data_heap::reset_generation(tenured_space* gen) {
{
clear_cards(gen); clear_cards(gen);
clear_decks(gen); clear_decks(gen);
} }
bool data_heap::high_fragmentation_p() bool data_heap::high_fragmentation_p() {
{
return (tenured->largest_free_block() <= high_water_mark()); return (tenured->largest_free_block() <= high_water_mark());
} }
bool data_heap::low_memory_p() bool data_heap::low_memory_p() {
{
return (tenured->free_space() <= high_water_mark()); return (tenured->free_space() <= high_water_mark());
} }
void data_heap::mark_all_cards() void data_heap::mark_all_cards() {
{
memset(cards, -1, cards_end - cards); memset(cards, -1, cards_end - cards);
memset(decks, -1, decks_end - decks); memset(decks, -1, decks_end - decks);
} }
void factor_vm::set_data_heap(data_heap *data_) void factor_vm::set_data_heap(data_heap* data_) {
{
data = data_; data = data_;
nursery = *data->nursery; nursery = *data->nursery;
init_card_decks(); init_card_decks();
} }
void factor_vm::init_data_heap(cell young_size, cell aging_size, cell 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)); set_data_heap(new data_heap(young_size, aging_size, tenured_size));
} }
data_heap_room factor_vm::data_room() data_heap_room factor_vm::data_room() {
{
data_heap_room room; data_heap_room room;
room.nursery_size = nursery.size; room.nursery_size = nursery.size;
@ -149,8 +128,7 @@ data_heap_room factor_vm::data_room()
} }
/* Allocates memory */ /* Allocates memory */
void factor_vm::primitive_data_room() void factor_vm::primitive_data_room() {
{
data_heap_room room = data_room(); data_heap_room room = data_room();
ctx->push(tag<byte_array>(byte_array_from_value(&room))); ctx->push(tag<byte_array>(byte_array_from_value(&room)));
} }
@ -161,24 +139,21 @@ struct object_accumulator {
explicit object_accumulator(cell type_) : type(type_) {} explicit object_accumulator(cell type_) : type(type_) {}
void operator()(object *obj) void operator()(object* obj) {
{
if (type == TYPE_COUNT || obj->type() == type) if (type == TYPE_COUNT || obj->type() == type)
objects.push_back(tag_dynamic(obj)); objects.push_back(tag_dynamic(obj));
} }
}; };
/* Allocates memory */ /* Allocates memory */
cell factor_vm::instances(cell type) cell factor_vm::instances(cell type) {
{
object_accumulator accum(type); object_accumulator accum(type);
each_object(accum); each_object(accum);
return std_vector_to_array(accum.objects); return std_vector_to_array(accum.objects);
} }
/* Allocates memory */ /* Allocates memory */
void factor_vm::primitive_all_instances() void factor_vm::primitive_all_instances() {
{
primitive_full_gc(); primitive_full_gc();
ctx->push(instances(TYPE_COUNT)); ctx->push(instances(TYPE_COUNT));
} }

7
vm/data_heap.hpp
View File

@ -1,5 +1,4 @@
namespace factor namespace factor {
{
struct data_heap { struct data_heap {
cell start; cell start;
@ -32,9 +31,7 @@ struct data_heap {
bool high_fragmentation_p(); bool high_fragmentation_p();
bool low_memory_p(); bool low_memory_p();
void mark_all_cards(); void mark_all_cards();
cell high_water_mark() { cell high_water_mark() { return nursery->size + aging->size; }
return nursery->size + aging->size;
}
}; };
struct data_heap_room { struct data_heap_room {

52
vm/data_heap_checker.cpp
View File

@ -3,8 +3,7 @@
/* A tool to debug write barriers. Call check_data_heap() to ensure that all /* A tool to debug write barriers. Call check_data_heap() to ensure that all
cards that should be marked are actually marked. */ cards that should be marked are actually marked. */
namespace factor namespace factor {
{
enum generation { enum generation {
nursery_generation, nursery_generation,
@ -12,16 +11,14 @@ enum generation {
tenured_generation tenured_generation
}; };
inline generation generation_of(factor_vm *parent, object *obj) inline generation generation_of(factor_vm* parent, object* obj) {
{
if (parent->data->nursery->contains_p(obj)) if (parent->data->nursery->contains_p(obj))
return nursery_generation; return nursery_generation;
else if (parent->data->aging->contains_p(obj)) else if (parent->data->aging->contains_p(obj))
return aging_generation; return aging_generation;
else if (parent->data->tenured->contains_p(obj)) else if (parent->data->tenured->contains_p(obj))
return tenured_generation; return tenured_generation;
else else {
{
critical_error("Bad object", (cell) obj); critical_error("Bad object", (cell) obj);
return (generation) - 1; return (generation) - 1;
} }
@ -32,37 +29,38 @@ struct slot_checker {
object* obj; object* obj;
generation gen; generation gen;
explicit slot_checker(factor_vm *parent_, object *obj_, generation gen_) : explicit slot_checker(factor_vm* parent_, object* obj_, generation gen_)
parent(parent_), obj(obj_), gen(gen_) {} : parent(parent_), obj(obj_), gen(gen_) {}
void check_write_barrier(cell *slot_ptr, generation target, char mask) void check_write_barrier(cell* slot_ptr, generation target, char mask) {
{
cell object_card_pointer = parent->cards_offset + ((cell) obj >> card_bits); cell object_card_pointer = parent->cards_offset + ((cell) obj >> card_bits);
cell slot_card_pointer = parent->cards_offset + ((cell)slot_ptr >> card_bits); cell slot_card_pointer =
parent->cards_offset + ((cell) slot_ptr >> card_bits);
char slot_card_value = *(char*)slot_card_pointer; char slot_card_value = *(char*)slot_card_pointer;
if((slot_card_value & mask) != mask) if ((slot_card_value & mask) != mask) {
{
std::cout << "card not marked" << std::endl; std::cout << "card not marked" << std::endl;
std::cout << "source generation: " << gen << std::endl; std::cout << "source generation: " << gen << std::endl;
std::cout << "target generation: " << target << std::endl; std::cout << "target generation: " << target << std::endl;
std::cout << "object: 0x" << std::hex << (cell)obj << std::dec << std::endl; std::cout << "object: 0x" << std::hex << (cell)
obj << std::dec << std::endl;
std::cout << "object type: " << obj->type() << 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 pointer: 0x" << std::hex << (cell)
std::cout << "slot value: 0x" << std::hex << *slot_ptr << std::dec << std::endl; slot_ptr << std::dec << std::endl;
std::cout << "card of object: 0x" << std::hex << object_card_pointer << std::dec << std::endl; std::cout << "slot value: 0x" << std::hex << *slot_ptr << std::dec
std::cout << "card of slot: 0x" << std::hex << slot_card_pointer << std::dec << std::endl; << 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; std::cout << std::endl;
parent->factorbug(); parent->factorbug();
} }
} }
void operator()(cell *slot_ptr) void operator()(cell* slot_ptr) {
{ if (!immediate_p(*slot_ptr)) {
if(!immediate_p(*slot_ptr))
{
generation target = generation_of(parent, untag<object>(*slot_ptr)); generation target = generation_of(parent, untag<object>(*slot_ptr));
switch(gen) switch (gen) {
{
case nursery_generation: case nursery_generation:
break; break;
case aging_generation: case aging_generation:
@ -85,15 +83,13 @@ struct object_checker {
explicit object_checker(factor_vm* parent_) : parent(parent_) {} explicit object_checker(factor_vm* parent_) : parent(parent_) {}
void operator()(object *obj) void operator()(object* obj) {
{
slot_checker checker(parent, obj, generation_of(parent, obj)); slot_checker checker(parent, obj, generation_of(parent, obj));
obj->each_slot(checker); obj->each_slot(checker);
} }
}; };
void factor_vm::check_data_heap() void factor_vm::check_data_heap() {
{
object_checker checker(this); object_checker checker(this);
each_object(checker); each_object(checker);
} }