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-13 22:16:04 -04:00
|
|
|
data_heap::data_heap(cell young_size_, cell aging_size_, 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-06 03:39:12 -04:00
|
|
|
cell total_size = young_size + 2 * aging_size + 2 * tenured_size;
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-05-08 16:05:55 -04:00
|
|
|
total_size += deck_size;
|
2009-05-02 05:04:19 -04:00
|
|
|
|
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-05-02 05:04:19 -04:00
|
|
|
|
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-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-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);
|
|
|
|
tenured_semispace = new tenured_space(tenured_size,tenured->end);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-07 16:48:09 -04:00
|
|
|
aging = new aging_space(aging_size,tenured_semispace->end);
|
|
|
|
aging_semispace = new aging_space(aging_size,aging->end);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-07 15:05:09 -04:00
|
|
|
nursery = new zone(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 tenured_semispace;
|
|
|
|
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;
|
|
|
|
return new data_heap(young_size,aging_size,new_tenured_size);
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
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-10-06 09:55:42 -04:00
|
|
|
nursery.here = nursery.start;
|
2009-05-02 05:04:19 -04:00
|
|
|
init_card_decks();
|
2009-10-20 14:13:39 -04:00
|
|
|
data->reset_generation(data->aging);
|
|
|
|
data->reset_generation(data->tenured);
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
2009-10-06 03:39:12 -04:00
|
|
|
void factor_vm::init_data_heap(cell young_size, cell aging_size, cell tenured_size, bool secure_gc_)
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-10-13 22:16:04 -04:00
|
|
|
set_data_heap(new data_heap(young_size,aging_size,tenured_size));
|
2009-05-02 05:04:19 -04:00
|
|
|
secure_gc = secure_gc_;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Size of the object pointed to by a tagged pointer */
|
2009-09-23 14:05:46 -04:00
|
|
|
cell factor_vm::object_size(cell tagged)
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
|
|
|
if(immediate_p(tagged))
|
|
|
|
return 0;
|
|
|
|
else
|
2009-10-20 14:13:39 -04:00
|
|
|
return untag<object>(tagged)->size();
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Size of the object pointed to by an untagged pointer */
|
2009-10-20 14:13:39 -04:00
|
|
|
cell object::size()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-10-20 14:13:39 -04:00
|
|
|
switch(h.hi_tag())
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-27 14:42:18 -04:00
|
|
|
void factor_vm::primitive_size()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
|
|
|
box_unsigned_cell(object_size(dpop()));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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-09-23 14:05:46 -04:00
|
|
|
cell factor_vm::binary_payload_start(object *pointer)
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-05-04 05:50:24 -04:00
|
|
|
switch(pointer->h.hi_tag())
|
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-05-04 05:50:24 -04:00
|
|
|
return array_size<array>(array_capacity((array*)pointer));
|
2009-05-02 05:04:19 -04:00
|
|
|
case TUPLE_TYPE:
|
2009-05-04 05:50:24 -04:00
|
|
|
return tuple_size(untag<tuple_layout>(((tuple *)pointer)->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-05-04 05:50:24 -04:00
|
|
|
critical_error("Invalid header",(cell)pointer);
|
2009-05-05 15:17:02 -04:00
|
|
|
return 0; /* can't happen */
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Push memory usage statistics in data heap */
|
2009-09-27 14:42:18 -04:00
|
|
|
void factor_vm::primitive_data_room()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-05-04 05:50:24 -04:00
|
|
|
dpush(tag_fixnum((data->cards_end - data->cards) >> 10));
|
|
|
|
dpush(tag_fixnum((data->decks_end - data->decks) >> 10));
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-08-17 16:37:09 -04:00
|
|
|
growable_array a(this);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-07 12:59:59 -04:00
|
|
|
a.add(tag_fixnum((nursery.end - nursery.here) >> 10));
|
|
|
|
a.add(tag_fixnum((nursery.size) >> 10));
|
|
|
|
|
|
|
|
a.add(tag_fixnum((data->aging->end - data->aging->here) >> 10));
|
|
|
|
a.add(tag_fixnum((data->aging->size) >> 10));
|
|
|
|
|
|
|
|
a.add(tag_fixnum((data->tenured->end - data->tenured->here) >> 10));
|
|
|
|
a.add(tag_fixnum((data->tenured->size) >> 10));
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-05-02 10:19:09 -04:00
|
|
|
a.trim();
|
2009-05-04 05:50:24 -04:00
|
|
|
dpush(a.elements.value());
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Disables GC and activates next-object ( -- obj ) primitive */
|
2009-09-23 14:05:46 -04:00
|
|
|
void factor_vm::begin_scan()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
2009-10-07 12:59:59 -04:00
|
|
|
heap_scan_ptr = data->tenured->start;
|
2009-05-02 05:04:19 -04:00
|
|
|
gc_off = true;
|
|
|
|
}
|
|
|
|
|
2009-09-23 14:05:46 -04:00
|
|
|
void factor_vm::end_scan()
|
2009-05-13 01:58:54 -04:00
|
|
|
{
|
|
|
|
gc_off = false;
|
|
|
|
}
|
|
|
|
|
2009-09-27 14:42:18 -04:00
|
|
|
void factor_vm::primitive_begin_scan()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
|
|
|
begin_scan();
|
|
|
|
}
|
|
|
|
|
2009-09-23 14:05:46 -04:00
|
|
|
cell factor_vm::next_object()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
|
|
|
if(!gc_off)
|
2009-10-18 21:26:21 -04:00
|
|
|
general_error(ERROR_HEAP_SCAN,false_object,false_object,NULL);
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-10-07 12:59:59 -04:00
|
|
|
if(heap_scan_ptr >= data->tenured->here)
|
2009-10-18 21:26:21 -04:00
|
|
|
return false_object;
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-05-04 05:50:24 -04:00
|
|
|
object *obj = (object *)heap_scan_ptr;
|
2009-10-20 14:13:39 -04:00
|
|
|
heap_scan_ptr += obj->size();
|
2009-05-04 05:50:24 -04:00
|
|
|
return tag_dynamic(obj);
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Push object at heap scan cursor and advance; pushes f when done */
|
2009-09-27 14:42:18 -04:00
|
|
|
void factor_vm::primitive_next_object()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
|
|
|
dpush(next_object());
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Re-enables GC */
|
2009-09-27 14:42:18 -04:00
|
|
|
void factor_vm::primitive_end_scan()
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
|
|
|
gc_off = false;
|
|
|
|
}
|
|
|
|
|
2009-10-03 09:47:05 -04:00
|
|
|
template<typename Iterator> void factor_vm::each_object(Iterator &iterator)
|
2009-05-02 05:04:19 -04:00
|
|
|
{
|
|
|
|
begin_scan();
|
2009-05-04 05:50:24 -04:00
|
|
|
cell obj;
|
2009-10-18 21:26:21 -04:00
|
|
|
while(to_boolean(obj = next_object()))
|
2009-10-03 09:47:05 -04:00
|
|
|
iterator(tagged<object>(obj));
|
2009-05-13 01:58:54 -04:00
|
|
|
end_scan();
|
|
|
|
}
|
2009-05-02 05:04:19 -04:00
|
|
|
|
2009-05-13 01:58:54 -04:00
|
|
|
struct word_counter {
|
|
|
|
cell count;
|
2009-10-03 09:47:05 -04:00
|
|
|
explicit word_counter() : count(0) {}
|
2009-05-13 01:58:54 -04:00
|
|
|
void operator()(tagged<object> obj) { if(obj.type_p(WORD_TYPE)) count++; }
|
|
|
|
};
|
|
|
|
|
|
|
|
struct word_accumulator {
|
|
|
|
growable_array words;
|
2009-10-03 09:47:05 -04:00
|
|
|
explicit word_accumulator(int count,factor_vm *vm) : words(vm,count) {}
|
2009-05-13 01:58:54 -04:00
|
|
|
void operator()(tagged<object> obj) { if(obj.type_p(WORD_TYPE)) words.add(obj.value()); }
|
|
|
|
};
|
|
|
|
|
2009-09-23 14:05:46 -04:00
|
|
|
cell factor_vm::find_all_words()
|
2009-05-13 01:58:54 -04:00
|
|
|
{
|
|
|
|
word_counter counter;
|
|
|
|
each_object(counter);
|
2009-08-17 16:37:09 -04:00
|
|
|
word_accumulator accum(counter.count,this);
|
2009-05-13 01:58:54 -04:00
|
|
|
each_object(accum);
|
|
|
|
accum.words.trim();
|
|
|
|
return accum.words.elements.value();
|
2009-05-02 05:04:19 -04:00
|
|
|
}
|
2009-05-04 02:46:13 -04:00
|
|
|
|
|
|
|
}
|