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

VM: move allot_code_block() to the allot.hpp file

char-rename
Björn Lindqvist 2016-10-13 03:01:28 +02:00
parent d8554ad24e
commit 026b626203
2 changed files with 33 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
vm/allot.hpp
View File

@ -3,6 +3,39 @@ namespace factor {
// It is up to the caller to fill in the object's fields in a
// meaningful fashion!
// Allocates memory
inline code_block* factor_vm::allot_code_block(cell size,
code_block_type type) {
cell block_size = size + sizeof(code_block);
code_block* block = code->allocator->allot(block_size);
// If allocation failed, do a full GC and compact the code heap.
// A full GC that occurs as a result of the data heap filling up does not
// trigger a compaction. This setup ensures that most GCs do not compact
// the code heap, but if the code fills up, it probably means it will be
// fragmented after GC anyway, so its best to compact.
if (block == NULL) {
primitive_compact_gc();
block = code->allocator->allot(block_size);
// Insufficient room even after code GC, give up
if (block == NULL) {
std::cout << "Code heap used: " << code->allocator->occupied_space()
<< "\n";
std::cout << "Code heap free: " << code->allocator->free_space << "\n";
std::cout << "Request : " << block_size << "\n";
fatal_error("Out of memory in allot_code_block", 0);
}
}
// next time we do a minor GC, we have to trace this code block, since
// the fields of the code_block struct might point into nursery or aging
this->code->write_barrier(block);
block->set_type(type);
return block;
}
// Allocates memory
inline object* factor_vm::allot_large_object(cell type, cell size) {
// If tenured space does not have enough room, collect and compact

31
vm/code_blocks.cpp
View File

@ -283,33 +283,6 @@ void factor_vm::fixup_labels(array* labels, code_block* compiled) {
}
}
// Might GC
// Allocates memory
code_block* factor_vm::allot_code_block(cell size, code_block_type type) {
code_block* block = code->allocator->allot(size + sizeof(code_block));
// If allocation failed, do a full GC and compact the code heap.
// A full GC that occurs as a result of the data heap filling up does not
// trigger a compaction. This setup ensures that most GCs do not compact
// the code heap, but if the code fills up, it probably means it will be
// fragmented after GC anyway, so its best to compact.
if (block == NULL) {
primitive_compact_gc();
block = code->allocator->allot(size + sizeof(code_block));
// Insufficient room even after code GC, give up
if (block == NULL) {
std::cout << "Code heap used: " << code->allocator->occupied_space()
<< "\n";
std::cout << "Code heap free: " << code->allocator->free_space << "\n";
fatal_error("Out of memory in allot_code_block", 0);
}
}
block->set_type(type);
return block;
}
// Might GC
// Allocates memory
code_block* factor_vm::add_code_block(code_block_type type, cell code_,
@ -359,10 +332,6 @@ code_block* factor_vm::add_code_block(code_block_type type, cell code_,
std::make_pair(compiled, literals.value()));
this->code->all_blocks.insert((cell)compiled);
// next time we do a minor GC, we have to trace this code block, since
// the fields of the code_block struct might point into nursery or aging
this->code->write_barrier(compiled);
return compiled;
}