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

vm: simplify code heap by eliminating HeapLayout template parameter

db4
Slava Pestov 2009-10-20 14:01:46 -05:00
parent e482940dca
commit a9dbbd1efb
10 changed files with 47 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
vm/code_heap.cpp
View File

@ -3,8 +3,7 @@
namespace factor
{
code_heap::code_heap(bool secure_gc, cell size) :
heap<heap_block,code_heap_layout>(secure_gc,size,true) {}
code_heap::code_heap(bool secure_gc, cell size) : heap<heap_block>(secure_gc,size,true) {}
void code_heap::write_barrier(code_block *compiled)
{

9
vm/code_heap.hpp
View File

@ -1,14 +1,7 @@
namespace factor
{
struct code_heap_layout {
cell block_size(heap_block *block)
{
return block->size();
}
};
struct code_heap : heap<heap_block,code_heap_layout> {
struct code_heap : heap<heap_block> {
/* Set of blocks which need full relocation. */
std::set<code_block *> needs_fixup;

4
vm/copying_collector.hpp
View File

@ -113,7 +113,7 @@ scan_next_object: {
card_end_address(card_index));
if(end < card_end_address(card_index))
{
start = gen->next_object_after(start);
start = gen->next_allocated_block_after(start);
if(start)
{
binary_start = start + this->parent->binary_payload_start((object *)start);
@ -158,7 +158,7 @@ end: this->parent->gc_stats.card_scan_time += (current_micros() - start_time);
while(scan && scan < this->target->here)
{
this->trace_slots((object *)scan);
scan = this->target->next_object_after(scan);
scan = this->target->next_allocated_block_after(scan);
}
}
};

2
vm/data_heap.cpp
View File

@ -93,6 +93,8 @@ cell factor_vm::object_size(cell tagged)
/* Size of the object pointed to by an untagged pointer */
cell object::size()
{
if(free_p()) return ((free_heap_block *)this)->size();
switch(h.hi_tag())
{
case ARRAY_TYPE:

2
vm/full_collector.cpp
View File

@ -100,7 +100,7 @@ void full_collector::cheneys_algorithm()
object *obj = (object *)scan;
this->trace_slots(obj);
this->mark_object_code_block(obj);
scan = target->next_object_after(scan);
scan = target->next_allocated_block_after(scan);
}
}

82
vm/heap.hpp
View File

@ -8,12 +8,11 @@ struct heap_free_list {
free_heap_block *large_blocks;
};
template<typename Block, typename HeapLayout> struct heap {
template<typename Block> struct heap {
bool secure_gc;
segment *seg;
heap_free_list free;
mark_bits<Block,HeapLayout> *state;
HeapLayout layout;
mark_bits<Block> *state;
explicit heap(bool secure_gc_, cell size, bool executable_p);
~heap();
@ -30,7 +29,7 @@ template<typename Block, typename HeapLayout> struct heap {
Block *next_block_after(heap_block *block)
{
return (Block *)((cell)block + layout.block_size(block));
return (Block *)((cell)block + block->size());
}
void clear_free_list();
@ -55,31 +54,29 @@ template<typename Block, typename HeapLayout> struct heap {
while(scan != end)
{
Block *next = next_block_after(scan);
if(!scan->free_p()) iter(scan,layout.block_size(scan));
cell size = scan->size();
Block *next = (Block *)((cell)scan + size);
if(!scan->free_p()) iter(scan,size);
scan = next;
}
}
};
template<typename Block, typename HeapLayout>
void heap<Block,HeapLayout>::clear_free_list()
template<typename Block> void heap<Block>::clear_free_list()
{
memset(&free,0,sizeof(heap_free_list));
}
template<typename Block, typename HeapLayout>
heap<Block,HeapLayout>::heap(bool secure_gc_, cell size, bool executable_p) : secure_gc(secure_gc_)
template<typename Block> heap<Block>::heap(bool secure_gc_, cell size, bool executable_p) : secure_gc(secure_gc_)
{
if(size > (1L << (sizeof(cell) * 8 - 6))) fatal_error("Heap too large",size);
seg = new segment(align_page(size),executable_p);
if(!seg) fatal_error("Out of memory in heap allocator",size);
state = new mark_bits<Block,HeapLayout>(seg->start,size);
state = new mark_bits<Block>(seg->start,size);
clear_free_list();
}
template<typename Block, typename HeapLayout>
heap<Block,HeapLayout>::~heap()
template<typename Block> heap<Block>::~heap()
{
delete seg;
seg = NULL;
@ -87,8 +84,7 @@ heap<Block,HeapLayout>::~heap()
state = NULL;
}
template<typename Block, typename HeapLayout>
void heap<Block,HeapLayout>::add_to_free_list(free_heap_block *block)
template<typename Block> void heap<Block>::add_to_free_list(free_heap_block *block)
{
if(block->size() < free_list_count * block_granularity)
{
@ -105,8 +101,7 @@ void heap<Block,HeapLayout>::add_to_free_list(free_heap_block *block)
/* Called after reading the code heap from the image file, and after code heap
compaction. Makes a free list consisting of one free block, at the very end. */
template<typename Block, typename HeapLayout>
void heap<Block,HeapLayout>::build_free_list(cell size)
template<typename Block> void heap<Block>::build_free_list(cell size)
{
clear_free_list();
free_heap_block *end = (free_heap_block *)(seg->start + size);
@ -115,16 +110,14 @@ void heap<Block,HeapLayout>::build_free_list(cell size)
add_to_free_list(end);
}
template<typename Block, typename HeapLayout>
void heap<Block,HeapLayout>::assert_free_block(free_heap_block *block)
template<typename Block> void heap<Block>::assert_free_block(free_heap_block *block)
{
#ifdef FACTOR_DEBUG
assert(block->free_p());
#endif
}
template<typename Block, typename HeapLayout>
free_heap_block *heap<Block,HeapLayout>::find_free_block(cell size)
template<typename Block> free_heap_block *heap<Block>::find_free_block(cell size)
{
cell attempt = size;
@ -164,8 +157,7 @@ free_heap_block *heap<Block,HeapLayout>::find_free_block(cell size)
return NULL;
}
template<typename Block, typename HeapLayout>
free_heap_block *heap<Block,HeapLayout>::split_free_block(free_heap_block *block, cell size)
template<typename Block> free_heap_block *heap<Block>::split_free_block(free_heap_block *block, cell size)
{
if(block->size() != size)
{
@ -181,8 +173,7 @@ free_heap_block *heap<Block,HeapLayout>::split_free_block(free_heap_block *block
return block;
}
template<typename Block, typename HeapLayout>
Block *heap<Block,HeapLayout>::heap_allot(cell size)
template<typename Block> Block *heap<Block>::heap_allot(cell size)
{
size = align(size,block_granularity);
@ -196,23 +187,20 @@ Block *heap<Block,HeapLayout>::heap_allot(cell size)
return NULL;
}
template<typename Block, typename HeapLayout>
void heap<Block,HeapLayout>::heap_free(Block *block)
template<typename Block> void heap<Block>::heap_free(Block *block)
{
free_heap_block *free_block = (free_heap_block *)block;
free_block->set_free();
add_to_free_list(free_block);
}
template<typename Block, typename HeapLayout>
void heap<Block,HeapLayout>::mark_block(Block *block)
template<typename Block> void heap<Block>::mark_block(Block *block)
{
state->set_marked_p(block);
}
/* Compute total sum of sizes of free blocks, and size of largest free block */
template<typename Block, typename HeapLayout>
void heap<Block,HeapLayout>::heap_usage(cell *used, cell *total_free, cell *max_free)
template<typename Block> void heap<Block>::heap_usage(cell *used, cell *total_free, cell *max_free)
{
*used = 0;
*total_free = 0;
@ -223,7 +211,7 @@ void heap<Block,HeapLayout>::heap_usage(cell *used, cell *total_free, cell *max_
while(scan != end)
{
cell size = layout.block_size(scan);
cell size = scan->size();
if(scan->free_p())
{
@ -239,8 +227,7 @@ void heap<Block,HeapLayout>::heap_usage(cell *used, cell *total_free, cell *max_
}
/* The size of the heap after compaction */
template<typename Block, typename HeapLayout>
cell heap<Block,HeapLayout>::heap_size()
template<typename Block> cell heap<Block>::heap_size()
{
Block *scan = first_block();
Block *end = last_block();
@ -255,7 +242,7 @@ cell heap<Block,HeapLayout>::heap_size()
{
free_heap_block *free_block = (free_heap_block *)scan;
assert(free_block->free_p());
assert((cell)scan + scan->size() == seg->end);
assert((cell)scan + free_block->size() == seg->end);
return (cell)scan - (cell)first_block();
}
@ -265,9 +252,9 @@ cell heap<Block,HeapLayout>::heap_size()
/* After code GC, all live code blocks are marked, so any
which are not marked can be reclaimed. */
template<typename Block, typename HeapLayout>
template<typename Block>
template<typename Iterator>
void heap<Block,HeapLayout>::sweep_heap(Iterator &iter)
void heap<Block>::sweep_heap(Iterator &iter)
{
this->clear_free_list();
@ -277,14 +264,14 @@ void heap<Block,HeapLayout>::sweep_heap(Iterator &iter)
while(scan != end)
{
cell size = scan->size();
if(scan->free_p())
{
free_heap_block *free_scan = (free_heap_block *)scan;
if(prev && prev->free_p())
{
free_heap_block *free_prev = (free_heap_block *)prev;
free_prev->set_size(free_prev->size() + free_scan->size());
free_prev->set_size(free_prev->size() + size);
}
else
prev = scan;
@ -294,17 +281,14 @@ void heap<Block,HeapLayout>::sweep_heap(Iterator &iter)
if(prev && prev->free_p())
this->add_to_free_list((free_heap_block *)prev);
prev = scan;
iter(scan,layout.block_size(scan));
iter(scan,size);
}
else
{
if(secure_gc)
memset(scan + 1,0,layout.block_size(scan) - sizeof(heap_block));
if(prev && prev->free_p())
{
free_heap_block *free_prev = (free_heap_block *)prev;
free_prev->set_size(free_prev->size() + layout.block_size(scan));
free_prev->set_size(free_prev->size() + size);
}
else
{
@ -313,7 +297,7 @@ void heap<Block,HeapLayout>::sweep_heap(Iterator &iter)
}
}
scan = next_block_after(scan);
scan = (Block *)((cell)scan + size);
}
if(prev && prev->free_p())
@ -322,11 +306,11 @@ void heap<Block,HeapLayout>::sweep_heap(Iterator &iter)
/* The forwarding map must be computed first by calling
state->compute_forwarding(). */
template<typename Block, typename HeapLayout>
template<typename Block>
template<typename Iterator>
void heap<Block,HeapLayout>::compact_heap(Iterator &iter)
void heap<Block>::compact_heap(Iterator &iter)
{
heap_compactor<Block,HeapLayout,Iterator> compactor(state,first_block(),iter);
heap_compactor<Block,Iterator> compactor(state,first_block(),iter);
this->iterate_heap(compactor);
/* Now update the free list; there will be a single free block at

2
vm/image.cpp
View File

@ -204,7 +204,7 @@ void factor_vm::relocate_data(cell data_relocation_base, cell code_relocation_ba
{
relocate_object((object *)obj,data_relocation_base,code_relocation_base);
data->tenured->starts.record_object_start_offset((object *)obj);
obj = data->tenured->next_object_after(obj);
obj = data->tenured->next_allocated_block_after(obj);
}
}

11
vm/mark_bits.hpp
View File

@ -4,8 +4,7 @@ namespace factor
const int block_granularity = 16;
const int forwarding_granularity = 64;
template<typename Block, typename HeapLayout> struct mark_bits {
HeapLayout layout;
template<typename Block> struct mark_bits {
cell start;
cell size;
cell bits_size;
@ -72,7 +71,7 @@ template<typename Block, typename HeapLayout> struct mark_bits {
Block *next_block_after(Block *block)
{
return (Block *)((cell)block + layout.block_size(block));
return (Block *)((cell)block + block->size());
}
void set_bitmap_range(u64 *bits, Block *address)
@ -146,12 +145,12 @@ template<typename Block, typename HeapLayout> struct mark_bits {
}
};
template<typename Block, typename HeapLayout, typename Iterator> struct heap_compactor {
mark_bits<Block,HeapLayout> *state;
template<typename Block, typename Iterator> struct heap_compactor {
mark_bits<Block> *state;
char *address;
Iterator &iter;
explicit heap_compactor(mark_bits<Block,HeapLayout> *state_, Block *address_, Iterator &iter_) :
explicit heap_compactor(mark_bits<Block> *state_, Block *address_, Iterator &iter_) :
state(state_), address((char *)address_), iter(iter_) {}
void operator()(Block *block, cell size)

13
vm/tenured_space.hpp
View File

@ -1,19 +1,6 @@
namespace factor
{
struct tenured_space_layout {
cell block_size(object *block)
{
if(block->free_p())
{
free_heap_block *free_block = (free_heap_block *)block;
return free_block->size();
}
else
return block->size();
}
};
struct tenured_space : zone {
object_start_map starts;

2
vm/zone.hpp
View File

@ -22,7 +22,7 @@ struct zone {
return (object *)h;
}
cell next_object_after(cell scan)
cell next_allocated_block_after(cell scan)
{
cell size = ((object *)scan)->size();
if(scan + size < here)