2009-05-02 05:04:19 -04:00
|
|
|
#include "master.hpp"
|
|
|
|
|
2009-05-04 02:46:13 -04:00
|
|
|
namespace factor
|
|
|
|
{
|
|
|
|
|
2009-09-23 14:05:46 -04:00
|
|
|
void factor_vm::init_card_decks()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-10-13 22:16:04 -04:00
|
|
|
cards_offset = (cell)data->cards - addr_to_card(data->start);
|
|
|
|
decks_offset = (cell)data->decks - addr_to_deck(data->start);
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
2009-10-30 03:26:57 -04:00
|
|
|
data_heap::data_heap(cell young_size_,
|
|
|
|
cell aging_size_,
|
2009-11-01 04:47:09 -05:00
|
|
|
cell tenured_size_)
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-09-25 22:17:20 -04:00
|
|
|
young_size_ = align(young_size_,deck_size);
|
|
|
|
aging_size_ = align(aging_size_,deck_size);
|
|
|
|
tenured_size_ = align(tenured_size_,deck_size);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-09-25 22:17:20 -04:00
|
|
|
young_size = young_size_;
|
|
|
|
aging_size = aging_size_;
|
|
|
|
tenured_size = tenured_size_;
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-30 03:26:57 -04:00
|
|
|
cell total_size = young_size + 2 * aging_size + tenured_size + deck_size;
|
2009-10-16 05:37:27 -04:00
|
|
|
seg = new segment(total_size,false);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-13 22:16:04 -04:00
|
|
|
cell cards_size = addr_to_card(total_size);
|
2009-10-09 12:16:18 -04:00
|
|
|
cards = new card[cards_size];
|
2009-09-25 22:17:20 -04:00
|
|
|
cards_end = cards + cards_size;
|
2009-10-20 23:20:49 -04:00
|
|
|
memset(cards,0,cards_size);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-13 22:16:04 -04:00
|
|
|
cell decks_size = addr_to_deck(total_size);
|
2009-10-09 12:16:18 -04:00
|
|
|
decks = new card_deck[decks_size];
|
2009-09-25 22:17:20 -04:00
|
|
|
decks_end = decks + decks_size;
|
2009-10-20 23:20:49 -04:00
|
|
|
memset(decks,0,decks_size);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-09 12:16:18 -04:00
|
|
|
start = align(seg->start,deck_size);
|
2009-10-07 12:59:59 -04:00
|
|
|
|
2009-10-07 16:48:09 -04:00
|
|
|
tenured = new tenured_space(tenured_size,start);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-20 23:20:49 -04:00
|
|
|
aging = new aging_space(aging_size,tenured->end);
|
2009-10-07 16:48:09 -04:00
|
|
|
aging_semispace = new aging_space(aging_size,aging->end);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-20 23:20:49 -04:00
|
|
|
nursery = new nursery_space(young_size,aging_semispace->end);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-07 15:05:09 -04:00
|
|
|
assert(seg->end - nursery->end <= deck_size);
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
2009-10-07 12:59:59 -04:00
|
|
|
data_heap::~data_heap()
|
|
|
|
{
|
|
|
|
delete seg;
|
|
|
|
delete nursery;
|
|
|
|
delete aging;
|
|
|
|
delete aging_semispace;
|
|
|
|
delete tenured;
|
|
|
|
delete[] cards;
|
|
|
|
delete[] decks;
|
|
|
|
}
|
|
|
|
|
2009-10-13 22:16:04 -04:00
|
|
|
data_heap *data_heap::grow(cell requested_bytes)
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-10-13 22:16:04 -04:00
|
|
|
cell new_tenured_size = (tenured_size * 2) + requested_bytes;
|
2009-10-30 03:26:57 -04:00
|
|
|
return new data_heap(young_size,
|
|
|
|
aging_size,
|
2009-11-01 04:47:09 -05:00
|
|
|
new_tenured_size);
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
2009-10-21 20:41:54 -04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
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(tenured_space *gen)
|
|
|
|
{
|
|
|
|
clear_cards(gen);
|
|
|
|
clear_decks(gen);
|
|
|
|
}
|
|
|
|
|
2009-12-05 19:03:53 -05:00
|
|
|
bool data_heap::high_fragmentation_p()
|
2009-11-03 23:25:22 -05:00
|
|
|
{
|
2009-12-04 03:41:19 -05:00
|
|
|
return (tenured->largest_free_block() <= nursery->size + aging->size);
|
2009-11-03 23:25:22 -05:00
|
|
|
}
|
|
|
|
|
2009-12-05 19:03:53 -05:00
|
|
|
bool data_heap::low_memory_p()
|
|
|
|
{
|
|
|
|
return (tenured->free_space() <= nursery->size + aging->size);
|
|
|
|
}
|
|
|
|
|
2009-11-05 20:03:51 -05:00
|
|
|
void data_heap::mark_all_cards()
|
|
|
|
{
|
|
|
|
memset(cards,-1,cards_end - cards);
|
|
|
|
memset(decks,-1,decks_end - decks);
|
|
|
|
}
|
|
|
|
|
2009-09-23 14:05:46 -04:00
|
|
|
void factor_vm::set_data_heap(data_heap *data_)
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-05-04 05:50:24 -04:00
|
|
|
data = data_;
|
2009-10-07 12:59:59 -04:00
|
|
|
nursery = *data->nursery;
|
2009-05-02 05:04:19 -04:00
|
|
|
init_card_decks();
|
|
|
|
}
|
|
|
|
|
2009-11-01 04:47:09 -05:00
|
|
|
void factor_vm::init_data_heap(cell young_size, cell aging_size, cell tenured_size)
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-11-01 04:47:09 -05:00
|
|
|
set_data_heap(new data_heap(young_size,aging_size,tenured_size));
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Size of the object pointed to by an untagged pointer */
|
2009-10-21 21:12:57 -04:00
|
|
|
cell object::size() const
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-10-20 15:01:46 -04:00
|
|
|
if(free_p()) return ((free_heap_block *)this)->size();
|
|
|
|
|
2009-11-10 22:06:36 -05:00
|
|
|
switch(type())
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
|
|
|
case ARRAY_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(array_size((array*)this),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case BIGNUM_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(array_size((bignum*)this),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case BYTE_ARRAY_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(array_size((byte_array*)this),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case STRING_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(string_size(string_capacity((string*)this)),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case TUPLE_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
{
|
|
|
|
tuple_layout *layout = (tuple_layout *)UNTAG(((tuple *)this)->layout);
|
|
|
|
return align(tuple_size(layout),data_alignment);
|
|
|
|
}
|
2009-05-02 05:04:19 -04:00
|
|
|
case QUOTATION_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(sizeof(quotation),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case WORD_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(sizeof(word),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case FLOAT_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(sizeof(boxed_float),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case DLL_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(sizeof(dll),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case ALIEN_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(sizeof(alien),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case WRAPPER_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(sizeof(wrapper),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
case CALLSTACK_TYPE:
|
2009-10-20 14:13:39 -04:00
|
|
|
return align(callstack_size(untag_fixnum(((callstack *)this)->length)),data_alignment);
|
2009-05-02 05:04:19 -04:00
|
|
|
default:
|
2009-10-20 14:13:39 -04:00
|
|
|
critical_error("Invalid header",(cell)this);
|
2009-05-05 15:17:02 -04:00
|
|
|
return 0; /* can't happen */
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The number of cells from the start of the object which should be scanned by
|
|
|
|
the GC. Some types have a binary payload at the end (string, word, DLL) which
|
|
|
|
we ignore. */
|
2009-10-24 05:27:45 -04:00
|
|
|
cell object::binary_payload_start() const
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-11-16 01:52:32 -05:00
|
|
|
if(free_p()) return 0;
|
|
|
|
|
2009-11-10 22:06:36 -05:00
|
|
|
switch(type())
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
|
|
|
/* these objects do not refer to other objects at all */
|
|
|
|
case FLOAT_TYPE:
|
|
|
|
case BYTE_ARRAY_TYPE:
|
|
|
|
case BIGNUM_TYPE:
|
|
|
|
case CALLSTACK_TYPE:
|
|
|
|
return 0;
|
|
|
|
/* these objects have some binary data at the end */
|
|
|
|
case WORD_TYPE:
|
2009-05-04 05:50:24 -04:00
|
|
|
return sizeof(word) - sizeof(cell) * 3;
|
2009-05-02 05:04:19 -04:00
|
|
|
case ALIEN_TYPE:
|
2009-05-04 05:50:24 -04:00
|
|
|
return sizeof(cell) * 3;
|
2009-05-02 05:04:19 -04:00
|
|
|
case DLL_TYPE:
|
2009-05-04 05:50:24 -04:00
|
|
|
return sizeof(cell) * 2;
|
2009-05-02 05:04:19 -04:00
|
|
|
case QUOTATION_TYPE:
|
2009-05-04 05:50:24 -04:00
|
|
|
return sizeof(quotation) - sizeof(cell) * 2;
|
2009-05-02 05:04:19 -04:00
|
|
|
case STRING_TYPE:
|
2009-05-04 05:50:24 -04:00
|
|
|
return sizeof(string);
|
2009-05-02 05:04:19 -04:00
|
|
|
/* everything else consists entirely of pointers */
|
|
|
|
case ARRAY_TYPE:
|
2009-10-24 05:27:45 -04:00
|
|
|
return array_size<array>(array_capacity((array*)this));
|
2009-05-02 05:04:19 -04:00
|
|
|
case TUPLE_TYPE:
|
2009-10-24 05:27:45 -04:00
|
|
|
return tuple_size(untag<tuple_layout>(((tuple *)this)->layout));
|
2009-05-02 05:04:19 -04:00
|
|
|
case WRAPPER_TYPE:
|
2009-05-04 05:50:24 -04:00
|
|
|
return sizeof(wrapper);
|
2009-05-02 05:04:19 -04:00
|
|
|
default:
|
2009-10-24 05:27:45 -04:00
|
|
|
critical_error("Invalid header",(cell)this);
|
2009-05-05 15:17:02 -04:00
|
|
|
return 0; /* can't happen */
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-27 22:31:28 -04:00
|
|
|
data_heap_room factor_vm::data_room()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-10-27 04:32:28 -04:00
|
|
|
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();
|
2009-10-30 03:26:57 -04:00
|
|
|
room.tenured_contiguous_free = data->tenured->largest_free_block();
|
|
|
|
room.tenured_free_block_count = data->tenured->free_block_count();
|
2009-10-27 04:32:28 -04:00
|
|
|
room.cards = data->cards_end - data->cards;
|
|
|
|
room.decks = data->decks_end - data->decks;
|
2009-11-23 19:51:08 -05:00
|
|
|
room.mark_stack = mark_stack.capacity() * sizeof(cell);
|
2009-10-27 04:32:28 -04:00
|
|
|
|
2009-10-27 22:31:28 -04:00
|
|
|
return room;
|
|
|
|
}
|
|
|
|
|
|
|
|
void factor_vm::primitive_data_room()
|
|
|
|
{
|
|
|
|
data_heap_room room = data_room();
|
2009-12-18 16:59:56 -05:00
|
|
|
ctx->push(tag<byte_array>(byte_array_from_value(&room)));
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
2009-11-05 22:49:03 -05:00
|
|
|
struct object_accumulator {
|
|
|
|
cell type;
|
|
|
|
std::vector<cell> objects;
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-11-05 22:49:03 -05:00
|
|
|
explicit object_accumulator(cell type_) : type(type_) {}
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-11-05 22:49:03 -05:00
|
|
|
void operator()(object *obj)
|
2009-10-20 23:20:49 -04:00
|
|
|
{
|
2009-11-10 22:06:36 -05:00
|
|
|
if(type == TYPE_COUNT || obj->type() == type)
|
2009-11-05 22:49:03 -05:00
|
|
|
objects.push_back(tag_dynamic(obj));
|
2009-10-20 23:20:49 -04:00
|
|
|
}
|
2009-11-05 22:49:03 -05:00
|
|
|
};
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-11-05 22:49:03 -05:00
|
|
|
cell factor_vm::instances(cell type)
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-11-05 22:49:03 -05:00
|
|
|
object_accumulator accum(type);
|
|
|
|
each_object(accum);
|
|
|
|
cell object_count = accum.objects.size();
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-11-06 06:30:37 -05:00
|
|
|
data_roots.push_back(data_root_range(&accum.objects[0],object_count));
|
2009-11-06 01:54:28 -05:00
|
|
|
|
2009-11-05 22:49:03 -05:00
|
|
|
array *objects = allot_array(object_count,false_object);
|
|
|
|
memcpy(objects->data(),&accum.objects[0],object_count * sizeof(cell));
|
2009-11-06 01:54:28 -05:00
|
|
|
|
|
|
|
data_roots.pop_back();
|
2009-05-13 01:58:54 -04:00
|
|
|
|
2009-11-05 22:49:03 -05:00
|
|
|
return tag<array>(objects);
|
|
|
|
}
|
2009-10-31 22:06:34 -04:00
|
|
|
|
2009-11-05 22:49:03 -05:00
|
|
|
void factor_vm::primitive_all_instances()
|
|
|
|
{
|
|
|
|
primitive_full_gc();
|
2009-12-18 16:59:56 -05:00
|
|
|
ctx->push(instances(TYPE_COUNT));
|
2009-11-05 22:49:03 -05:00
|
|
|
}
|
2009-05-13 01:58:54 -04:00
|
|
|
|
2009-05-04 02:46:13 -04:00
|
|
|
}
|