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

VM: Refactor free_list_allocator to Factor style

db4
Erik Charlebois 2013-05-11 22:02:05 -04:00
parent c0aa1c7b3e
commit f40718dfab
1 changed files with 153 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
vm/free_list_allocator.hpp
View File

@ -1,5 +1,4 @@
namespace factor namespace factor {
{
template <typename Block> struct free_list_allocator { template <typename Block> struct free_list_allocator {
cell size; cell size;
@ -24,50 +23,48 @@ template<typename Block> struct free_list_allocator {
cell free_block_count(); cell free_block_count();
void sweep(); void sweep();
template <typename Iterator> void sweep(Iterator& iter); template <typename Iterator> void sweep(Iterator& iter);
template<typename Iterator, typename Fixup> void compact(Iterator &iter, Fixup fixup, const Block **finger); template <typename Iterator, typename Fixup>
template<typename Iterator, typename Fixup> void iterate(Iterator &iter, Fixup fixup); void compact(Iterator& iter, Fixup fixup, const Block** finger);
template <typename Iterator, typename Fixup>
void iterate(Iterator& iter, Fixup fixup);
template <typename Iterator> void iterate(Iterator& iter); template <typename Iterator> void iterate(Iterator& iter);
}; };
template <typename Block> template <typename Block>
free_list_allocator<Block>::free_list_allocator(cell size_, cell start_) : free_list_allocator<Block>::free_list_allocator(cell size_, cell start_)
size(size_), : size(size_),
start(start_), start(start_),
end(start_ + size_), end(start_ + size_),
state(mark_bits<Block>(size_,start_)) state(mark_bits<Block>(size_, start_)) {
{
initial_free_list(0); initial_free_list(0);
} }
template<typename Block> void free_list_allocator<Block>::initial_free_list(cell occupied) template <typename Block>
{ void free_list_allocator<Block>::initial_free_list(cell occupied) {
free_blocks.initial_free_list(start, end, occupied); free_blocks.initial_free_list(start, end, occupied);
} }
template<typename Block> bool free_list_allocator<Block>::contains_p(Block *block) template <typename Block>
{ bool free_list_allocator<Block>::contains_p(Block* block) {
return ((cell) block - start) < size; return ((cell) block - start) < size;
} }
template<typename Block> Block *free_list_allocator<Block>::first_block() template <typename Block> Block* free_list_allocator<Block>::first_block() {
{
return (Block*)start; return (Block*)start;
} }
template<typename Block> Block *free_list_allocator<Block>::last_block() template <typename Block> Block* free_list_allocator<Block>::last_block() {
{
return (Block*)end; return (Block*)end;
} }
template<typename Block> Block *free_list_allocator<Block>::next_block_after(Block *block) template <typename Block>
{ Block* free_list_allocator<Block>::next_block_after(Block* block) {
return (Block*)((cell) block + block->size()); return (Block*)((cell) block + block->size());
} }
template<typename Block> Block *free_list_allocator<Block>::next_allocated_block_after(Block *block) template <typename Block>
{ Block* free_list_allocator<Block>::next_allocated_block_after(Block* block) {
while(block != this->last_block() && block->free_p()) while (block != this->last_block() && block->free_p()) {
{
free_heap_block* free_block = (free_heap_block*)block; free_heap_block* free_block = (free_heap_block*)block;
block = (object*)((cell) free_block + free_block->size()); block = (object*)((cell) free_block + free_block->size());
} }
@ -78,68 +75,58 @@ template<typename Block> Block *free_list_allocator<Block>::next_allocated_block
return block; return block;
} }
template<typename Block> bool free_list_allocator<Block>::can_allot_p(cell size) template <typename Block>
{ bool free_list_allocator<Block>::can_allot_p(cell size) {
return free_blocks.can_allot_p(size); return free_blocks.can_allot_p(size);
} }
template<typename Block> Block *free_list_allocator<Block>::allot(cell size) template <typename Block> Block* free_list_allocator<Block>::allot(cell size) {
{
size = align(size, data_alignment); size = align(size, data_alignment);
free_heap_block* block = free_blocks.find_free_block(size); free_heap_block* block = free_blocks.find_free_block(size);
if(block) if (block) {
{
block = free_blocks.split_free_block(block, size); block = free_blocks.split_free_block(block, size);
return (Block*)block; return (Block*)block;
} } else
else
return NULL; return NULL;
} }
template<typename Block> void free_list_allocator<Block>::free(Block *block) template <typename Block> void free_list_allocator<Block>::free(Block* block) {
{
free_heap_block* free_block = (free_heap_block*)block; free_heap_block* free_block = (free_heap_block*)block;
free_block->make_free(block->size()); free_block->make_free(block->size());
free_blocks.add_to_free_list(free_block); free_blocks.add_to_free_list(free_block);
} }
template<typename Block> cell free_list_allocator<Block>::free_space() template <typename Block> cell free_list_allocator<Block>::free_space() {
{
return free_blocks.free_space; return free_blocks.free_space;
} }
template<typename Block> cell free_list_allocator<Block>::occupied_space() template <typename Block> cell free_list_allocator<Block>::occupied_space() {
{
return size - free_blocks.free_space; return size - free_blocks.free_space;
} }
template<typename Block> cell free_list_allocator<Block>::largest_free_block() template <typename Block>
{ cell free_list_allocator<Block>::largest_free_block() {
return free_blocks.largest_free_block(); return free_blocks.largest_free_block();
} }
template<typename Block> cell free_list_allocator<Block>::free_block_count() template <typename Block> cell free_list_allocator<Block>::free_block_count() {
{
return free_blocks.free_block_count; return free_blocks.free_block_count;
} }
template <typename Block> template <typename Block>
template <typename Iterator> template <typename Iterator>
void free_list_allocator<Block>::sweep(Iterator &iter) void free_list_allocator<Block>::sweep(Iterator& iter) {
{
free_blocks.clear_free_list(); free_blocks.clear_free_list();
Block* start = this->first_block(); Block* start = this->first_block();
Block* end = this->last_block(); Block* end = this->last_block();
while(start != end) while (start != end) {
{
/* find next unmarked block */ /* find next unmarked block */
start = state.next_unmarked_block_after(start); start = state.next_unmarked_block_after(start);
if(start != end) if (start != end) {
{
/* find size */ /* find size */
cell size = state.unmarked_block_size(start); cell size = state.unmarked_block_size(start);
FACTOR_ASSERT(size > 0); FACTOR_ASSERT(size > 0);
@ -154,15 +141,11 @@ void free_list_allocator<Block>::sweep(Iterator &iter)
} }
} }
template<typename Block> template <typename Block> struct null_sweep_iterator {
struct null_sweep_iterator
{
void operator()(Block* free_block, cell size) {} void operator()(Block* free_block, cell size) {}
}; };
template<typename Block> template <typename Block> void free_list_allocator<Block>::sweep() {
void free_list_allocator<Block>::sweep()
{
null_sweep_iterator<Block> none; null_sweep_iterator<Block> none;
sweep(none); sweep(none);
} }
@ -173,13 +156,12 @@ template<typename Block, typename Iterator> struct heap_compactor {
Iterator& iter; Iterator& iter;
const Block** finger; const Block** finger;
explicit heap_compactor(mark_bits<Block> *state_, Block *address_, Iterator &iter_, const Block **finger_) : explicit heap_compactor(mark_bits<Block>* state_, Block* address_,
state(state_), address((char *)address_), iter(iter_), finger(finger_) {} Iterator& iter_, const Block** finger_)
: state(state_), address((char*)address_), iter(iter_), finger(finger_) {}
void operator()(Block *block, cell size) void operator()(Block* block, cell size) {
{ if (this->state->marked_p(block)) {
if(this->state->marked_p(block))
{
*finger = (Block*)((char*)block + size); *finger = (Block*)((char*)block + size);
memmove((Block*)address, block, size); memmove((Block*)address, block, size);
iter(block, (Block*)address, size); iter(block, (Block*)address, size);
@ -192,9 +174,10 @@ template<typename Block, typename Iterator> struct heap_compactor {
state.compute_forwarding(). */ state.compute_forwarding(). */
template <typename Block> template <typename Block>
template <typename Iterator, typename Fixup> template <typename Iterator, typename Fixup>
void free_list_allocator<Block>::compact(Iterator &iter, Fixup fixup, const Block **finger) void free_list_allocator<Block>::compact(Iterator& iter, Fixup fixup,
{ const Block** finger) {
heap_compactor<Block,Iterator> compactor(&state,first_block(),iter,finger); heap_compactor<Block, Iterator> compactor(&state, first_block(), iter,
finger);
iterate(compactor, fixup); iterate(compactor, fixup);
/* 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
@ -202,27 +185,26 @@ void free_list_allocator<Block>::compact(Iterator &iter, Fixup fixup, const Bloc
free_blocks.initial_free_list(start, end, (cell) compactor.address - start); free_blocks.initial_free_list(start, end, (cell) compactor.address - start);
} }
/* During compaction we have to be careful and measure object sizes differently */ /* During compaction we have to be careful and measure object sizes
differently */
template <typename Block> template <typename Block>
template <typename Iterator, typename Fixup> template <typename Iterator, typename Fixup>
void free_list_allocator<Block>::iterate(Iterator &iter, Fixup fixup) void free_list_allocator<Block>::iterate(Iterator& iter, Fixup fixup) {
{
Block* scan = first_block(); Block* scan = first_block();
Block* end = last_block(); Block* end = last_block();
while(scan != end) while (scan != end) {
{
cell size = fixup.size(scan); cell size = fixup.size(scan);
Block* next = (Block*)((cell) scan + size); Block* next = (Block*)((cell) scan + size);
if(!scan->free_p()) iter(scan,size); if (!scan->free_p())
iter(scan, size);
scan = next; scan = next;
} }
} }
template <typename Block> template <typename Block>
template <typename Iterator> template <typename Iterator>
void free_list_allocator<Block>::iterate(Iterator &iter) void free_list_allocator<Block>::iterate(Iterator& iter) {
{
iterate(iter, no_fixup()); iterate(iter, no_fixup());
} }