factor/vm/data_heap.cpp

322 lines
7.9 KiB
C++
Raw Normal View History

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
{
cell start = align(data->seg->start,deck_size);
allot_markers_offset = (cell)data->allot_markers - (start >> card_bits);
cards_offset = (cell)data->cards - (start >> card_bits);
decks_offset = (cell)data->decks - (start >> deck_bits);
2009-05-02 05:04:19 -04:00
}
data_heap::data_heap(factor_vm *myvm, cell young_size_, cell aging_size_, cell tenured_size_)
2009-05-02 05:04:19 -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
young_size = young_size_;
aging_size = aging_size_;
tenured_size = tenured_size_;
2009-05-02 05:04:19 -04:00
cell total_size = young_size + 2 * aging_size + 2 * tenured_size;
2009-05-02 05:04:19 -04:00
total_size += deck_size;
2009-05-02 05:04:19 -04:00
2009-10-07 09:33:54 -04:00
seg = new segment(total_size);
2009-05-02 05:04:19 -04:00
cell cards_size = total_size >> card_bits;
2009-05-02 05:04:19 -04:00
cards = new char[cards_size];
cards_end = cards + cards_size;
2009-05-02 05:04:19 -04:00
cell decks_size = total_size >> deck_bits;
decks = new char[decks_size];
decks_end = decks + decks_size;
2009-05-02 05:04:19 -04:00
allot_markers = new char[cards_size];
allot_markers_end = allot_markers + cards_size;
cell alloter = align(seg->start,deck_size);
2009-05-02 05:04:19 -04:00
tenured = new zone;
tenured_semispace = new zone;
alloter = tenured->init_zone(tenured_size,alloter);
alloter = tenured_semispace->init_zone(tenured_size,alloter);
2009-05-02 05:04:19 -04:00
aging = new zone;
aging_semispace = new zone;
alloter = aging->init_zone(aging_size,alloter);
alloter = aging_semispace->init_zone(aging_size,alloter);
2009-05-02 05:04:19 -04:00
nursery = new zone;
alloter = nursery->init_zone(young_size,alloter);
2009-05-02 05:04:19 -04:00
if(seg->end - alloter > deck_size)
2009-10-07 09:33:54 -04:00
critical_error("Bug in alloc_data_heap",alloter);
2009-05-02 05:04:19 -04:00
}
data_heap::~data_heap()
{
delete seg;
delete nursery;
delete aging;
delete aging_semispace;
delete tenured;
delete tenured_semispace;
delete[] allot_markers;
delete[] cards;
delete[] decks;
}
2009-09-23 14:05:46 -04:00
data_heap *factor_vm::grow_data_heap(data_heap *data, cell requested_bytes)
2009-05-02 05:04:19 -04:00
{
2009-05-04 05:50:24 -04:00
cell new_tenured_size = (data->tenured_size * 2) + requested_bytes;
2009-05-02 05:04:19 -04:00
return new data_heap(this,
2009-05-04 05:50:24 -04:00
data->young_size,
data->aging_size,
2009-05-02 05:04:19 -04:00
new_tenured_size);
}
void factor_vm::clear_cards(zone *gen)
2009-05-02 05:04:19 -04:00
{
/* NOTE: reverse order due to heap layout. */
card *first_card = addr_to_card(gen->start);
card *last_card = addr_to_card(gen->end);
2009-05-02 05:04:19 -04:00
memset(first_card,0,last_card - first_card);
}
void factor_vm::clear_decks(zone *gen)
2009-05-02 05:04:19 -04:00
{
/* NOTE: reverse order due to heap layout. */
card_deck *first_deck = addr_to_deck(gen->start);
card_deck *last_deck = addr_to_deck(gen->end);
2009-05-02 05:04:19 -04:00
memset(first_deck,0,last_deck - first_deck);
}
void factor_vm::clear_allot_markers(zone *gen)
2009-05-02 05:04:19 -04:00
{
card *first_card = addr_to_allot_marker((object *)gen->start);
card *last_card = addr_to_allot_marker((object *)gen->end);
memset(first_card,invalid_allot_marker,last_card - first_card);
2009-05-02 05:04:19 -04:00
}
/* After garbage collection, any generations which are now empty need to have
their allocation pointers and cards reset. */
void factor_vm::reset_generation(zone *gen)
2009-05-02 05:04:19 -04:00
{
gen->here = gen->start;
if(secure_gc) memset((void*)gen->start,69,gen->size);
2009-05-02 05:04:19 -04:00
2009-10-06 09:55:42 -04:00
clear_cards(gen);
clear_decks(gen);
clear_allot_markers(gen);
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_;
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();
reset_generation(data->aging);
reset_generation(data->tenured);
2009-05-02 05:04:19 -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
{
set_data_heap(new data_heap(this,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-05-04 05:50:24 -04:00
return untagged_object_size(untag<object>(tagged));
2009-05-02 05:04:19 -04:00
}
/* Size of the object pointed to by an untagged pointer */
2009-09-23 14:05:46 -04:00
cell factor_vm::untagged_object_size(object *pointer)
2009-05-02 05:04:19 -04:00
{
return align8(unaligned_object_size(pointer));
}
/* Size of the data area of an object pointed to by an untagged pointer */
2009-09-23 14:05:46 -04:00
cell factor_vm::unaligned_object_size(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
{
case ARRAY_TYPE:
2009-05-04 05:50:24 -04:00
return array_size((array*)pointer);
2009-05-02 05:04:19 -04:00
case BIGNUM_TYPE:
2009-05-04 05:50:24 -04:00
return array_size((bignum*)pointer);
2009-05-02 05:04:19 -04:00
case BYTE_ARRAY_TYPE:
2009-05-04 05:50:24 -04:00
return array_size((byte_array*)pointer);
2009-05-02 05:04:19 -04:00
case STRING_TYPE:
2009-05-04 05:50:24 -04:00
return string_size(string_capacity((string*)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 QUOTATION_TYPE:
2009-05-04 05:50:24 -04:00
return sizeof(quotation);
2009-05-02 05:04:19 -04:00
case WORD_TYPE:
2009-05-04 05:50:24 -04:00
return sizeof(word);
2009-05-02 05:04:19 -04:00
case FLOAT_TYPE:
2009-05-04 05:50:24 -04:00
return sizeof(boxed_float);
2009-05-02 05:04:19 -04:00
case DLL_TYPE:
2009-05-04 05:50:24 -04:00
return sizeof(dll);
2009-05-02 05:04:19 -04:00
case ALIEN_TYPE:
2009-05-04 05:50:24 -04:00
return sizeof(alien);
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
case CALLSTACK_TYPE:
2009-05-04 05:50:24 -04:00
return callstack_size(untag_fixnum(((callstack *)pointer)->length));
2009-05-02 05:04:19 -04:00
default:
2009-05-04 05:50:24 -04:00
critical_error("Invalid header",(cell)pointer);
return 0; /* can't happen */
2009-05-02 05:04:19 -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);
return 0; /* can't happen */
2009-05-02 05:04:19 -04:00
}
}
/* Push memory usage statistics in data heap */
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
growable_array a(this);
2009-05-02 05:04:19 -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
{
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()
{
gc_off = false;
}
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)
general_error(ERROR_HEAP_SCAN,F,F,NULL);
if(heap_scan_ptr >= data->tenured->here)
2009-05-02 05:04:19 -04:00
return F;
2009-05-04 05:50:24 -04:00
object *obj = (object *)heap_scan_ptr;
heap_scan_ptr += untagged_object_size(obj);
return tag_dynamic(obj);
2009-05-02 05:04:19 -04:00
}
/* Push object at heap scan cursor and advance; pushes f when done */
void factor_vm::primitive_next_object()
2009-05-02 05:04:19 -04:00
{
dpush(next_object());
}
/* Re-enables GC */
void factor_vm::primitive_end_scan()
2009-05-02 05:04:19 -04:00
{
gc_off = false;
}
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-05-02 05:04:19 -04:00
while((obj = next_object()) != F)
iterator(tagged<object>(obj));
end_scan();
}
2009-05-02 05:04:19 -04:00
struct word_counter {
cell count;
explicit word_counter() : count(0) {}
void operator()(tagged<object> obj) { if(obj.type_p(WORD_TYPE)) count++; }
};
struct word_accumulator {
growable_array words;
explicit word_accumulator(int count,factor_vm *vm) : words(vm,count) {}
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()
{
word_counter counter;
each_object(counter);
word_accumulator accum(counter.count,this);
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
}