From a9dbbd1efb5c8b3cbda11f6511457b4f4a5bcca7 Mon Sep 17 00:00:00 2001 From: Slava Pestov Date: Tue, 20 Oct 2009 14:01:46 -0500 Subject: [PATCH] vm: simplify code heap by eliminating HeapLayout template parameter --- vm/code_heap.cpp | 3 +- vm/code_heap.hpp | 9 +---- vm/copying_collector.hpp | 4 +- vm/data_heap.cpp | 2 + vm/full_collector.cpp | 2 +- vm/heap.hpp | 82 ++++++++++++++++------------------------ vm/image.cpp | 2 +- vm/mark_bits.hpp | 11 +++--- vm/tenured_space.hpp | 13 ------- vm/zone.hpp | 2 +- 10 files changed, 47 insertions(+), 83 deletions(-) diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp index df557074af..c65dec9a69 100755 --- a/vm/code_heap.cpp +++ b/vm/code_heap.cpp @@ -3,8 +3,7 @@ namespace factor { -code_heap::code_heap(bool secure_gc, cell size) : - heap(secure_gc,size,true) {} +code_heap::code_heap(bool secure_gc, cell size) : heap(secure_gc,size,true) {} void code_heap::write_barrier(code_block *compiled) { diff --git a/vm/code_heap.hpp b/vm/code_heap.hpp index b29e33ca64..d4c5d4e40b 100755 --- a/vm/code_heap.hpp +++ b/vm/code_heap.hpp @@ -1,14 +1,7 @@ namespace factor { -struct code_heap_layout { - cell block_size(heap_block *block) - { - return block->size(); - } -}; - -struct code_heap : heap { +struct code_heap : heap { /* Set of blocks which need full relocation. */ std::set needs_fixup; diff --git a/vm/copying_collector.hpp b/vm/copying_collector.hpp index 4bb56945a1..ea7faf2423 100644 --- a/vm/copying_collector.hpp +++ b/vm/copying_collector.hpp @@ -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); } } }; diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp index 05f8f3a044..d3951b2b27 100755 --- a/vm/data_heap.cpp +++ b/vm/data_heap.cpp @@ -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: diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp index 1bb03d08e7..9c8a825c1f 100644 --- a/vm/full_collector.cpp +++ b/vm/full_collector.cpp @@ -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); } } diff --git a/vm/heap.hpp b/vm/heap.hpp index c82b88ee2f..c06eab8dc7 100644 --- a/vm/heap.hpp +++ b/vm/heap.hpp @@ -8,12 +8,11 @@ struct heap_free_list { free_heap_block *large_blocks; }; -template struct heap { +template struct heap { bool secure_gc; segment *seg; heap_free_list free; - mark_bits *state; - HeapLayout layout; + mark_bits *state; explicit heap(bool secure_gc_, cell size, bool executable_p); ~heap(); @@ -30,7 +29,7 @@ template 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 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 -void heap::clear_free_list() +template void heap::clear_free_list() { memset(&free,0,sizeof(heap_free_list)); } -template -heap::heap(bool secure_gc_, cell size, bool executable_p) : secure_gc(secure_gc_) +template heap::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(seg->start,size); + state = new mark_bits(seg->start,size); clear_free_list(); } -template -heap::~heap() +template heap::~heap() { delete seg; seg = NULL; @@ -87,8 +84,7 @@ heap::~heap() state = NULL; } -template -void heap::add_to_free_list(free_heap_block *block) +template void heap::add_to_free_list(free_heap_block *block) { if(block->size() < free_list_count * block_granularity) { @@ -105,8 +101,7 @@ void heap::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 -void heap::build_free_list(cell size) +template void heap::build_free_list(cell size) { clear_free_list(); free_heap_block *end = (free_heap_block *)(seg->start + size); @@ -115,16 +110,14 @@ void heap::build_free_list(cell size) add_to_free_list(end); } -template -void heap::assert_free_block(free_heap_block *block) +template void heap::assert_free_block(free_heap_block *block) { #ifdef FACTOR_DEBUG assert(block->free_p()); #endif } -template -free_heap_block *heap::find_free_block(cell size) +template free_heap_block *heap::find_free_block(cell size) { cell attempt = size; @@ -164,8 +157,7 @@ free_heap_block *heap::find_free_block(cell size) return NULL; } -template -free_heap_block *heap::split_free_block(free_heap_block *block, cell size) +template free_heap_block *heap::split_free_block(free_heap_block *block, cell size) { if(block->size() != size) { @@ -181,8 +173,7 @@ free_heap_block *heap::split_free_block(free_heap_block *block return block; } -template -Block *heap::heap_allot(cell size) +template Block *heap::heap_allot(cell size) { size = align(size,block_granularity); @@ -196,23 +187,20 @@ Block *heap::heap_allot(cell size) return NULL; } -template -void heap::heap_free(Block *block) +template void heap::heap_free(Block *block) { free_heap_block *free_block = (free_heap_block *)block; free_block->set_free(); add_to_free_list(free_block); } -template -void heap::mark_block(Block *block) +template void heap::mark_block(Block *block) { state->set_marked_p(block); } /* Compute total sum of sizes of free blocks, and size of largest free block */ -template -void heap::heap_usage(cell *used, cell *total_free, cell *max_free) +template void heap::heap_usage(cell *used, cell *total_free, cell *max_free) { *used = 0; *total_free = 0; @@ -223,7 +211,7 @@ void heap::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::heap_usage(cell *used, cell *total_free, cell *max_ } /* The size of the heap after compaction */ -template -cell heap::heap_size() +template cell heap::heap_size() { Block *scan = first_block(); Block *end = last_block(); @@ -255,7 +242,7 @@ cell heap::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::heap_size() /* After code GC, all live code blocks are marked, so any which are not marked can be reclaimed. */ -template +template template -void heap::sweep_heap(Iterator &iter) +void heap::sweep_heap(Iterator &iter) { this->clear_free_list(); @@ -277,14 +264,14 @@ void heap::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::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::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::sweep_heap(Iterator &iter) /* The forwarding map must be computed first by calling state->compute_forwarding(). */ -template +template template -void heap::compact_heap(Iterator &iter) +void heap::compact_heap(Iterator &iter) { - heap_compactor compactor(state,first_block(),iter); + heap_compactor compactor(state,first_block(),iter); this->iterate_heap(compactor); /* Now update the free list; there will be a single free block at diff --git a/vm/image.cpp b/vm/image.cpp index 7d8c4a2d32..d45e09a600 100755 --- a/vm/image.cpp +++ b/vm/image.cpp @@ -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); } } diff --git a/vm/mark_bits.hpp b/vm/mark_bits.hpp index bc318524b4..0f14622fcf 100644 --- a/vm/mark_bits.hpp +++ b/vm/mark_bits.hpp @@ -4,8 +4,7 @@ namespace factor const int block_granularity = 16; const int forwarding_granularity = 64; -template struct mark_bits { - HeapLayout layout; +template struct mark_bits { cell start; cell size; cell bits_size; @@ -72,7 +71,7 @@ template 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 struct mark_bits { } }; -template struct heap_compactor { - mark_bits *state; +template struct heap_compactor { + mark_bits *state; char *address; Iterator &iter; - explicit heap_compactor(mark_bits *state_, Block *address_, Iterator &iter_) : + explicit heap_compactor(mark_bits *state_, Block *address_, Iterator &iter_) : state(state_), address((char *)address_), iter(iter_) {} void operator()(Block *block, cell size) diff --git a/vm/tenured_space.hpp b/vm/tenured_space.hpp index a700b58bfd..b36d96c4aa 100644 --- a/vm/tenured_space.hpp +++ b/vm/tenured_space.hpp @@ -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; diff --git a/vm/zone.hpp b/vm/zone.hpp index 42196f315b..55f34fe67e 100644 --- a/vm/zone.hpp +++ b/vm/zone.hpp @@ -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)