diff --git a/basis/tools/memory/memory.factor b/basis/tools/memory/memory.factor index 5358158aaf..daf905cace 100644 --- a/basis/tools/memory/memory.factor +++ b/basis/tools/memory/memory.factor @@ -108,12 +108,12 @@ PRIVATE> : gc-op-string ( op -- string ) { - { collect-nursery-op [ "Copying from nursery" ] } - { collect-aging-op [ "Copying from aging" ] } - { collect-to-tenured-op [ "Copying to tenured" ] } - { collect-full-op [ "Mark and sweep" ] } - { collect-compact-op [ "Mark and compact" ] } - { collect-growing-heap-op [ "Grow heap" ] } + { COLLECT-NURSERY-OP [ "Copying from nursery" ] } + { COLLECT-AGING-OP [ "Copying from aging" ] } + { COLLECT-TO-TENURED-OP [ "Copying to tenured" ] } + { COLLECT-FULL-OP [ "Mark and sweep" ] } + { COLLECT-COMPACT-OP [ "Mark and compact" ] } + { COLLECT-GROWING-DATA-HEAP-OP [ "Grow heap" ] } } case ; : (space-occupied) ( data-heap-room code-heap-room -- n ) @@ -203,12 +203,12 @@ SYMBOL: gc-events SINGLETONS: +unoptimized+ +optimized+ +profiling+ +pic+ ; TUPLE: code-block -{ owner read-only } -{ parameters read-only } -{ relocation read-only } -{ type read-only } -{ size read-only } -{ entry-point read-only } ; + { owner read-only } + { parameters read-only } + { relocation read-only } + { type read-only } + { size read-only } + { entry-point read-only } ; TUPLE: code-blocks { blocks groups } { cache hashtable } ; diff --git a/basis/vm/vm.factor b/basis/vm/vm.factor index f14fa9f227..405aed8513 100644 --- a/basis/vm/vm.factor +++ b/basis/vm/vm.factor @@ -54,12 +54,12 @@ STRUCT: vm { retainstack-size cell_t } { callstack-size cell_t } ; -CONSTANT: collect-nursery-op 0 -CONSTANT: collect-aging-op 1 -CONSTANT: collect-to-tenured-op 2 -CONSTANT: collect-full-op 3 -CONSTANT: collect-compact-op 4 -CONSTANT: collect-growing-heap-op 5 +CONSTANT: COLLECT-NURSERY-OP 0 +CONSTANT: COLLECT-AGING-OP 1 +CONSTANT: COLLECT-TO-TENURED-OP 2 +CONSTANT: COLLECT-FULL-OP 3 +CONSTANT: COLLECT-COMPACT-OP 4 +CONSTANT: COLLECT-GROWING-DATA-HEAP-OP 5 STRUCT: copying-sizes { size cell_t } diff --git a/vm/aging_collector.cpp b/vm/aging_collector.cpp index 335dbba7de..a152c0270c 100644 --- a/vm/aging_collector.cpp +++ b/vm/aging_collector.cpp @@ -41,7 +41,7 @@ void factor_vm::collect_aging() { // everything else to the aging semi-space, and reset the nursery pointer. { // Change the op so that if we fail here, an assertion will be raised. - current_gc->op = collect_to_tenured_op; + current_gc->op = COLLECT_TO_TENURED_OP; slot_visitor visitor(this, from_tenured_refs_copier(data->tenured, &mark_stack)); @@ -64,7 +64,7 @@ void factor_vm::collect_aging() { } { // If collection fails here, do a to_tenured collection. - current_gc->op = collect_aging_op; + current_gc->op = COLLECT_AGING_OP; std::swap(data->aging, data->aging_semispace); data->reset_aging(); diff --git a/vm/allot.hpp b/vm/allot.hpp index b5c3f45309..49ace31043 100644 --- a/vm/allot.hpp +++ b/vm/allot.hpp @@ -46,7 +46,7 @@ inline object* factor_vm::allot_large_object(cell type, cell size) { // If it still won't fit, grow the heap if (!data->tenured->can_allot_p(required_free)) { - gc(collect_growing_data_heap_op, size); + gc(COLLECT_GROWING_DATA_HEAP_OP, size); } } object* obj = data->tenured->allot(size); diff --git a/vm/compaction.cpp b/vm/compaction.cpp index 4e9590b92b..f243ff81e3 100644 --- a/vm/compaction.cpp +++ b/vm/compaction.cpp @@ -97,8 +97,8 @@ void factor_vm::collect_compact_impl() { const code_block* code_finger = (code_block*)code->allocator->start; { - compaction_fixup fixup(data_forwarding_map, code_forwarding_map, &data_finger, - &code_finger); + compaction_fixup fixup(data_forwarding_map, code_forwarding_map, + &data_finger, &code_finger); slot_visitor forwarder(this, fixup); forwarder.visit_uninitialized_code_blocks(); @@ -150,9 +150,9 @@ void factor_vm::collect_compact() { collect_mark_impl(); collect_compact_impl(); + // Compaction did not free up enough memory. Grow the data heap. if (data->high_fragmentation_p()) { - // Compaction did not free up enough memory. Grow the heap. - set_current_gc_op(collect_growing_data_heap_op); + set_current_gc_op(COLLECT_GROWING_DATA_HEAP_OP); collect_growing_data_heap(0); } diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp index 7b466d88b4..28652b5181 100644 --- a/vm/full_collector.cpp +++ b/vm/full_collector.cpp @@ -111,12 +111,12 @@ void factor_vm::collect_full() { if (data->low_memory_p()) { // Full GC did not free up enough memory. Grow the heap. - set_current_gc_op(collect_growing_data_heap_op); + set_current_gc_op(COLLECT_GROWING_DATA_HEAP_OP); collect_growing_data_heap(0); } else if (data->high_fragmentation_p()) { // Enough free memory, but it is not contiguous. Perform a // compaction. - set_current_gc_op(collect_compact_op); + set_current_gc_op(COLLECT_COMPACT_OP); collect_compact_impl(); } diff --git a/vm/gc.cpp b/vm/gc.cpp index a5e82a79ae..1b22f885c8 100644 --- a/vm/gc.cpp +++ b/vm/gc.cpp @@ -65,15 +65,15 @@ gc_state::~gc_state() { } void factor_vm::start_gc_again() { - if (current_gc->op == collect_nursery_op) { + if (current_gc->op == COLLECT_NURSERY_OP) { // Nursery collection can fail if aging does not have enough // free space to fit all live objects from nursery. - current_gc->op = collect_aging_op; - } else if (current_gc->op == collect_aging_op) { + current_gc->op = COLLECT_AGING_OP; + } else if (current_gc->op == COLLECT_AGING_OP) { // Aging collection can fail if the aging semispace cannot fit // all the live objects from the other aging semispace and the // nursery. - current_gc->op = collect_to_tenured_op; + current_gc->op = COLLECT_TO_TENURED_OP; } else { // Nothing else should fail mid-collection due to insufficient // space in the target generation. @@ -110,34 +110,34 @@ void factor_vm::gc(gc_op op, cell requested_size) { current_gc->event->op = current_gc->op; switch (current_gc->op) { - case collect_nursery_op: + case COLLECT_NURSERY_OP: collect_nursery(); break; - case collect_aging_op: + case COLLECT_AGING_OP: // We end up here if the above fails. collect_aging(); if (data->high_fragmentation_p()) { // Change GC op so that if we fail again, we crash. - set_current_gc_op(collect_full_op); + set_current_gc_op(COLLECT_FULL_OP); collect_full(); } break; - case collect_to_tenured_op: + case COLLECT_TO_TENURED_OP: // We end up here if the above fails. collect_to_tenured(); if (data->high_fragmentation_p()) { // Change GC op so that if we fail again, we crash. - set_current_gc_op(collect_full_op); + set_current_gc_op(COLLECT_FULL_OP); collect_full(); } break; - case collect_full_op: + case COLLECT_FULL_OP: collect_full(); break; - case collect_compact_op: + case COLLECT_COMPACT_OP: collect_compact(); break; - case collect_growing_data_heap_op: + case COLLECT_GROWING_DATA_HEAP_OP: collect_growing_data_heap(requested_size); break; default: @@ -169,15 +169,15 @@ void factor_vm::gc(gc_op op, cell requested_size) { } void factor_vm::primitive_minor_gc() { - gc(collect_nursery_op, 0); + gc(COLLECT_NURSERY_OP, 0); } void factor_vm::primitive_full_gc() { - gc(collect_full_op, 0); + gc(COLLECT_FULL_OP, 0); } void factor_vm::primitive_compact_gc() { - gc(collect_compact_op, 0); + gc(COLLECT_COMPACT_OP, 0); } void factor_vm::primitive_enable_gc_events() { diff --git a/vm/gc.hpp b/vm/gc.hpp index a1eb59addc..b353c00a66 100644 --- a/vm/gc.hpp +++ b/vm/gc.hpp @@ -4,12 +4,12 @@ struct must_start_gc_again { }; enum gc_op { - collect_nursery_op, - collect_aging_op, - collect_to_tenured_op, - collect_full_op, - collect_compact_op, - collect_growing_data_heap_op + COLLECT_NURSERY_OP, + COLLECT_AGING_OP, + COLLECT_TO_TENURED_OP, + COLLECT_FULL_OP, + COLLECT_COMPACT_OP, + COLLECT_GROWING_DATA_HEAP_OP }; struct gc_event {