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 namespace factor
{ {
code_heap::code_heap(bool secure_gc, cell size) : code_heap::code_heap(bool secure_gc, cell size) : heap<heap_block>(secure_gc,size,true) {}
heap<heap_block,code_heap_layout>(secure_gc,size,true) {}
void code_heap::write_barrier(code_block *compiled) void code_heap::write_barrier(code_block *compiled)
{ {

9
vm/code_heap.hpp
View File

@ -1,14 +1,7 @@
namespace factor namespace factor
{ {
struct code_heap_layout { struct code_heap : heap<heap_block> {
cell block_size(heap_block *block)
{
return block->size();
}
};
struct code_heap : heap<heap_block,code_heap_layout> {
/* Set of blocks which need full relocation. */ /* Set of blocks which need full relocation. */
std::set<code_block *> needs_fixup; 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)); card_end_address(card_index));
if(end < 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) if(start)
{ {
binary_start = start + this->parent->binary_payload_start((object *)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) while(scan && scan < this->target->here)
{ {
this->trace_slots((object *)scan); 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 */ /* Size of the object pointed to by an untagged pointer */
cell object::size() cell object::size()
{ {
if(free_p()) return ((free_heap_block *)this)->size();
switch(h.hi_tag()) switch(h.hi_tag())
{ {
case ARRAY_TYPE: case ARRAY_TYPE:

2
vm/full_collector.cpp
View File

@ -100,7 +100,7 @@ void full_collector::cheneys_algorithm()
object *obj = (object *)scan; object *obj = (object *)scan;
this->trace_slots(obj); this->trace_slots(obj);
this->mark_object_code_block(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; free_heap_block *large_blocks;
}; };
template<typename Block, typename HeapLayout> struct heap { template<typename Block> struct heap {
bool secure_gc; bool secure_gc;
segment *seg; segment *seg;
heap_free_list free; heap_free_list free;
mark_bits<Block,HeapLayout> *state; mark_bits<Block> *state;
HeapLayout layout;
explicit heap(bool secure_gc_, cell size, bool executable_p); explicit heap(bool secure_gc_, cell size, bool executable_p);
~heap(); ~heap();
@ -30,7 +29,7 @@ template<typename Block, typename HeapLayout> struct heap {
Block *next_block_after(heap_block *block) 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(); void clear_free_list();
@ -55,31 +54,29 @@ template<typename Block, typename HeapLayout> struct heap {
while(scan != end) while(scan != end)
{ {
Block *next = next_block_after(scan); cell size = scan->size();
if(!scan->free_p()) iter(scan,layout.block_size(scan)); Block *next = (Block *)((cell)scan + size);
if(!scan->free_p()) iter(scan,size);
scan = next; scan = next;
} }
} }
}; };
template<typename Block, typename HeapLayout> template<typename Block> void heap<Block>::clear_free_list()
void heap<Block,HeapLayout>::clear_free_list()
{ {
memset(&free,0,sizeof(heap_free_list)); memset(&free,0,sizeof(heap_free_list));
} }
template<typename Block, typename HeapLayout> template<typename Block> heap<Block>::heap(bool secure_gc_, cell size, bool executable_p) : secure_gc(secure_gc_)
heap<Block,HeapLayout>::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); if(size > (1L << (sizeof(cell) * 8 - 6))) fatal_error("Heap too large",size);
seg = new segment(align_page(size),executable_p); seg = new segment(align_page(size),executable_p);
if(!seg) fatal_error("Out of memory in heap allocator",size); 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(); clear_free_list();
} }
template<typename Block, typename HeapLayout> template<typename Block> heap<Block>::~heap()
heap<Block,HeapLayout>::~heap()
{ {
delete seg; delete seg;
seg = NULL; seg = NULL;
@ -87,8 +84,7 @@ heap<Block,HeapLayout>::~heap()
state = NULL; state = NULL;
} }
template<typename Block, typename HeapLayout> template<typename Block> void heap<Block>::add_to_free_list(free_heap_block *block)
void heap<Block,HeapLayout>::add_to_free_list(free_heap_block *block)
{ {
if(block->size() < free_list_count * block_granularity) 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 /* 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. */ compaction. Makes a free list consisting of one free block, at the very end. */
template<typename Block, typename HeapLayout> template<typename Block> void heap<Block>::build_free_list(cell size)
void heap<Block,HeapLayout>::build_free_list(cell size)
{ {
clear_free_list(); clear_free_list();
free_heap_block *end = (free_heap_block *)(seg->start + size); 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); add_to_free_list(end);
} }
template<typename Block, typename HeapLayout> template<typename Block> void heap<Block>::assert_free_block(free_heap_block *block)
void heap<Block,HeapLayout>::assert_free_block(free_heap_block *block)
{ {
#ifdef FACTOR_DEBUG #ifdef FACTOR_DEBUG
assert(block->free_p()); assert(block->free_p());
#endif #endif
} }
template<typename Block, typename HeapLayout> template<typename Block> free_heap_block *heap<Block>::find_free_block(cell size)
free_heap_block *heap<Block,HeapLayout>::find_free_block(cell size)
{ {
cell attempt = size; cell attempt = size;
@ -164,8 +157,7 @@ free_heap_block *heap<Block,HeapLayout>::find_free_block(cell size)
return NULL; return NULL;
} }
template<typename Block, typename HeapLayout> template<typename Block> free_heap_block *heap<Block>::split_free_block(free_heap_block *block, cell size)
free_heap_block *heap<Block,HeapLayout>::split_free_block(free_heap_block *block, cell size)
{ {
if(block->size() != size) if(block->size() != size)
{ {
@ -181,8 +173,7 @@ free_heap_block *heap<Block,HeapLayout>::split_free_block(free_heap_block *block
return block; return block;
} }
template<typename Block, typename HeapLayout> template<typename Block> Block *heap<Block>::heap_allot(cell size)
Block *heap<Block,HeapLayout>::heap_allot(cell size)
{ {
size = align(size,block_granularity); size = align(size,block_granularity);
@ -196,23 +187,20 @@ Block *heap<Block,HeapLayout>::heap_allot(cell size)
return NULL; return NULL;
} }
template<typename Block, typename HeapLayout> template<typename Block> void heap<Block>::heap_free(Block *block)
void heap<Block,HeapLayout>::heap_free(Block *block)
{ {
free_heap_block *free_block = (free_heap_block *)block; free_heap_block *free_block = (free_heap_block *)block;
free_block->set_free(); free_block->set_free();
add_to_free_list(free_block); add_to_free_list(free_block);
} }
template<typename Block, typename HeapLayout> template<typename Block> void heap<Block>::mark_block(Block *block)
void heap<Block,HeapLayout>::mark_block(Block *block)
{ {
state->set_marked_p(block); state->set_marked_p(block);
} }
/* Compute total sum of sizes of free blocks, and size of largest free block */ /* Compute total sum of sizes of free blocks, and size of largest free block */
template<typename Block, typename HeapLayout> template<typename Block> void heap<Block>::heap_usage(cell *used, cell *total_free, cell *max_free)
void heap<Block,HeapLayout>::heap_usage(cell *used, cell *total_free, cell *max_free)
{ {
*used = 0; *used = 0;
*total_free = 0; *total_free = 0;
@ -223,7 +211,7 @@ void heap<Block,HeapLayout>::heap_usage(cell *used, cell *total_free, cell *max_
while(scan != end) while(scan != end)
{ {
cell size = layout.block_size(scan); cell size = scan->size();
if(scan->free_p()) 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 */ /* The size of the heap after compaction */
template<typename Block, typename HeapLayout> template<typename Block> cell heap<Block>::heap_size()
cell heap<Block,HeapLayout>::heap_size()
{ {
Block *scan = first_block(); Block *scan = first_block();
Block *end = last_block(); Block *end = last_block();
@ -255,7 +242,7 @@ cell heap<Block,HeapLayout>::heap_size()
{ {
free_heap_block *free_block = (free_heap_block *)scan; free_heap_block *free_block = (free_heap_block *)scan;
assert(free_block->free_p()); 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(); 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 /* After code GC, all live code blocks are marked, so any
which are not marked can be reclaimed. */ which are not marked can be reclaimed. */
template<typename Block, typename HeapLayout> template<typename Block>
template<typename Iterator> template<typename Iterator>
void heap<Block,HeapLayout>::sweep_heap(Iterator &iter) void heap<Block>::sweep_heap(Iterator &iter)
{ {
this->clear_free_list(); this->clear_free_list();
@ -277,14 +264,14 @@ void heap<Block,HeapLayout>::sweep_heap(Iterator &iter)
while(scan != end) while(scan != end)
{ {
cell size = scan->size();
if(scan->free_p()) if(scan->free_p())
{ {
free_heap_block *free_scan = (free_heap_block *)scan;
if(prev && prev->free_p()) if(prev && prev->free_p())
{ {
free_heap_block *free_prev = (free_heap_block *)prev; 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 else
prev = scan; prev = scan;
@ -294,17 +281,14 @@ void heap<Block,HeapLayout>::sweep_heap(Iterator &iter)
if(prev && prev->free_p()) if(prev && prev->free_p())
this->add_to_free_list((free_heap_block *)prev); this->add_to_free_list((free_heap_block *)prev);
prev = scan; prev = scan;
iter(scan,layout.block_size(scan)); iter(scan,size);
} }
else else
{ {
if(secure_gc)
memset(scan + 1,0,layout.block_size(scan) - sizeof(heap_block));
if(prev && prev->free_p()) if(prev && prev->free_p())
{ {
free_heap_block *free_prev = (free_heap_block *)prev; 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 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()) 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 /* The forwarding map must be computed first by calling
state->compute_forwarding(). */ state->compute_forwarding(). */
template<typename Block, typename HeapLayout> template<typename Block>
template<typename Iterator> 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); this->iterate_heap(compactor);
/* Now update the free list; there will be a single free block at /* 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); relocate_object((object *)obj,data_relocation_base,code_relocation_base);
data->tenured->starts.record_object_start_offset((object *)obj); 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 block_granularity = 16;
const int forwarding_granularity = 64; const int forwarding_granularity = 64;
template<typename Block, typename HeapLayout> struct mark_bits { template<typename Block> struct mark_bits {
HeapLayout layout;
cell start; cell start;
cell size; cell size;
cell bits_size; cell bits_size;
@ -72,7 +71,7 @@ template<typename Block, typename HeapLayout> struct mark_bits {
Block *next_block_after(Block *block) 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) 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 { template<typename Block, typename Iterator> struct heap_compactor {
mark_bits<Block,HeapLayout> *state; mark_bits<Block> *state;
char *address; char *address;
Iterator &iter; 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_) {} state(state_), address((char *)address_), iter(iter_) {}
void operator()(Block *block, cell size) void operator()(Block *block, cell size)

13
vm/tenured_space.hpp
View File

@ -1,19 +1,6 @@
namespace factor 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 { struct tenured_space : zone {
object_start_map starts; object_start_map starts;

2
vm/zone.hpp
View File

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