vm: don't call nano_count() from the GC at all, unless GC event recording is on

diff --git a/vm/aging_collector.cpp b/vm/aging_collector.cpp
index c832ca792faf4e1eee2a9397780f87fe254347cf..c747592f42d2e4fae7beeb68818f6461e0a7f8cc 100644 (file)
--- a/vm/aging_collector.cpp
+++ b/vm/aging_collector.cpp
@@ -22,15 +22,17 @@ void factor_vm::collect_aging()
 
                to_tenured_collector collector(this);
 
-               current_gc->event->started_card_scan();
+               gc_event *event = current_gc->event;
+
+               if(event) event->started_card_scan();
                collector.trace_cards(data->tenured,
                        card_points_to_aging,
                        full_unmarker());
-               current_gc->event->ended_card_scan(collector.cards_scanned,collector.decks_scanned);
+               if(event) event->ended_card_scan(collector.cards_scanned,collector.decks_scanned);
 
-               current_gc->event->started_code_scan();
+               if(event) event->started_code_scan();
                collector.trace_code_heap_roots(&code->points_to_aging);
-               current_gc->event->ended_code_scan(collector.code_blocks_scanned);
+               if(event) event->ended_code_scan(collector.code_blocks_scanned);
 
                collector.tenure_reachable_objects();
        }

diff --git a/vm/compaction.cpp b/vm/compaction.cpp
index 9d26062a5c498895b9b7ec2f527f26be4118284b..343a61b8badfd2faa17f92af0b1c40e4565b5304 100644 (file)
--- a/vm/compaction.cpp
+++ b/vm/compaction.cpp
@@ -190,7 +190,9 @@ void factor_vm::update_code_roots_for_compaction()
 /* Compact data and code heaps */
 void factor_vm::collect_compact_impl(bool trace_contexts_p)
 {
-       current_gc->event->started_compaction();
+       gc_event *event = current_gc->event;
+
+       if(event) event->started_compaction();
 
        tenured_space *tenured = data->tenured;
        mark_bits<object> *data_forwarding_map = &tenured->state;
@@ -232,7 +234,7 @@ void factor_vm::collect_compact_impl(bool trace_contexts_p)
        update_code_roots_for_compaction();
        callbacks->update();
 
-       current_gc->event->ended_compaction();
+       if(event) event->ended_compaction();
 }
 
 struct code_compaction_fixup {

diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp
index 19d8b576a5bcbf7b77cb7ca8ec50814276ae1628..852c058bd255d2e0075c9384041a8a48a959be8b 100644 (file)
--- a/vm/full_collector.cpp
+++ b/vm/full_collector.cpp
@@ -92,15 +92,17 @@ void factor_vm::collect_mark_impl(bool trace_contexts_p)
 
 void factor_vm::collect_sweep_impl()
 {
-       current_gc->event->started_data_sweep();
+       gc_event *event = current_gc->event;
+
+       if(event) event->started_data_sweep();
        data->tenured->sweep();
-       current_gc->event->ended_data_sweep();
+       if(event) event->ended_data_sweep();
 
        update_code_roots_for_sweep();
 
-       current_gc->event->started_code_sweep();
+       if(event) event->started_code_sweep();
        code->allocator->sweep();
-       current_gc->event->ended_code_sweep();
+       if(event) event->ended_code_sweep();
 }
 
 void factor_vm::collect_full(bool trace_contexts_p)
@@ -110,14 +112,12 @@ void factor_vm::collect_full(bool trace_contexts_p)
 
        if(data->low_memory_p())
        {
-               current_gc->op = collect_growing_heap_op;
-               current_gc->event->op = collect_growing_heap_op;
+               set_current_gc_op(collect_growing_heap_op);
                collect_growing_heap(0,trace_contexts_p);
        }
        else if(data->high_fragmentation_p())
        {
-               current_gc->op = collect_compact_op;
-               current_gc->event->op = collect_compact_op;
+               set_current_gc_op(collect_compact_op);
                collect_compact_impl(trace_contexts_p);
        }
 

diff --git a/vm/gc.cpp b/vm/gc.cpp
index d898ba89af46eb687ebe70f56b04cf5b8cb4331c..866a19f7f621658ea274334e3a1cc5165e77ea0c 100755 (executable)
--- a/vm/gc.cpp
+++ b/vm/gc.cpp
@@ -80,23 +80,33 @@ void gc_event::ended_gc(factor_vm *parent)
        total_time = (cell)(nano_count() - start_time);
 }
 
-gc_state::gc_state(gc_op op_, factor_vm *parent) : op(op_), start_time(nano_count())
+gc_state::gc_state(gc_op op_, factor_vm *parent) : op(op_)
 {
-       event = new gc_event(op,parent);
+       if(parent->gc_events)
+       {
+               event = new gc_event(op,parent);
+               start_time = nano_count();
+       }
+       else
+               event = NULL;
 }
 
 gc_state::~gc_state()
 {
-       delete event;
-       event = NULL;
+       if(event)
+       {
+               delete event;
+               event = NULL;
+       }
 }
 
 void factor_vm::end_gc()
 {
-       current_gc->event->ended_gc(this);
-       if(gc_events) gc_events->push_back(*current_gc->event);
-       delete current_gc->event;
-       current_gc->event = NULL;
+       if(gc_events)
+       {
+               current_gc->event->ended_gc(this);
+               gc_events->push_back(*current_gc->event);
+       }
 }
 
 void factor_vm::start_gc_again()
@@ -123,7 +133,14 @@ void factor_vm::start_gc_again()
                break;
        }
 
-       current_gc->event = new gc_event(current_gc->op,this);
+       if(gc_events)
+               current_gc->event = new gc_event(current_gc->op,this);
+}
+
+void factor_vm::set_current_gc_op(gc_op op)
+{
+       current_gc->op = op;
+       if(gc_events) current_gc->event->op = op;
 }
 
 void factor_vm::gc(gc_op op, cell requested_bytes, bool trace_contexts_p)
@@ -144,7 +161,7 @@ void factor_vm::gc(gc_op op, cell requested_bytes, bool trace_contexts_p)
        {
                try
                {
-                       current_gc->event->op = current_gc->op;
+                       if(gc_events) current_gc->event->op = current_gc->op;
 
                        switch(current_gc->op)
                        {
@@ -155,8 +172,7 @@ void factor_vm::gc(gc_op op, cell requested_bytes, bool trace_contexts_p)
                                collect_aging();
                                if(data->high_fragmentation_p())
                                {
-                                       current_gc->op = collect_full_op;
-                                       current_gc->event->op = collect_full_op;
+                                       set_current_gc_op(collect_full_op);
                                        collect_full(trace_contexts_p);
                                }
                                break;
@@ -164,8 +180,7 @@ void factor_vm::gc(gc_op op, cell requested_bytes, bool trace_contexts_p)
                                collect_to_tenured();
                                if(data->high_fragmentation_p())
                                {
-                                       current_gc->op = collect_full_op;
-                                       current_gc->event->op = collect_full_op;
+                                       set_current_gc_op(collect_full_op);
                                        collect_full(trace_contexts_p);
                                }
                                break;

diff --git a/vm/gc.hpp b/vm/gc.hpp
index f6e9a875a63c04bbf165b155f9421885af6f89a0..76029d81ee851ab4b499eafc35822bd77c93d2e7 100755 (executable)
--- a/vm/gc.hpp
+++ b/vm/gc.hpp
@@ -28,7 +28,7 @@ struct gc_event {
        cell compaction_time;
        u64 temp_time;
 
-       explicit gc_event(gc_op op_, factor_vm *parent);
+       gc_event(gc_op op_, factor_vm *parent);
        void started_card_scan();
        void ended_card_scan(cell cards_scanned_, cell decks_scanned_);
        void started_code_scan();

diff --git a/vm/nursery_collector.cpp b/vm/nursery_collector.cpp
index 062aa6aed33294b8f4b0bf092eefaabfc848a52b..7ea81391b25a8f2c252b3b37e957896f00ec0434 100644 (file)
--- a/vm/nursery_collector.cpp
+++ b/vm/nursery_collector.cpp
@@ -18,7 +18,9 @@ void factor_vm::collect_nursery()
        collector.trace_roots();
        collector.trace_contexts();
 
-       current_gc->event->started_card_scan();
+       gc_event *event = current_gc->event;
+
+       if(event) event->started_card_scan();
        collector.trace_cards(data->tenured,
                card_points_to_nursery,
                simple_unmarker(card_points_to_nursery));
@@ -28,11 +30,11 @@ void factor_vm::collect_nursery()
                        card_points_to_nursery,
                        full_unmarker());
        }
-       current_gc->event->ended_card_scan(collector.cards_scanned,collector.decks_scanned);
+       if(event) event->ended_card_scan(collector.cards_scanned,collector.decks_scanned);
 
-       current_gc->event->started_code_scan();
+       if(event) event->started_code_scan();
        collector.trace_code_heap_roots(&code->points_to_nursery);
-       current_gc->event->ended_code_scan(collector.code_blocks_scanned);
+       if(event) event->ended_code_scan(collector.code_blocks_scanned);
 
        collector.cheneys_algorithm();
 

diff --git a/vm/to_tenured_collector.cpp b/vm/to_tenured_collector.cpp
index b29affc480ccfbbd3d26d8e2dbf0f8c37b8d593f..4d11cdb27b1797220180fd6987b03baf82cc859f 100644 (file)
--- a/vm/to_tenured_collector.cpp
+++ b/vm/to_tenured_collector.cpp
@@ -30,15 +30,17 @@ void factor_vm::collect_to_tenured()
        collector.trace_roots();
        collector.trace_contexts();
 
-       current_gc->event->started_card_scan();
+       gc_event *event = current_gc->event;
+
+       if(event) event->started_card_scan();
        collector.trace_cards(data->tenured,
                card_points_to_aging,
                full_unmarker());
-       current_gc->event->ended_card_scan(collector.cards_scanned,collector.decks_scanned);
+       if(event) event->ended_card_scan(collector.cards_scanned,collector.decks_scanned);
 
-       current_gc->event->started_code_scan();
+       if(event) event->started_code_scan();
        collector.trace_code_heap_roots(&code->points_to_aging);
-       current_gc->event->ended_code_scan(collector.code_blocks_scanned);
+       if(event) event->ended_code_scan(collector.code_blocks_scanned);
 
        collector.tenure_reachable_objects();
 

diff --git a/vm/vm.hpp b/vm/vm.hpp
index 682ab873b7386e422b2c090e3c04beb806d95474..44ac81a70c554b22e29bfd39f1172fd89b765dba 100755 (executable)
--- a/vm/vm.hpp
+++ b/vm/vm.hpp
@@ -299,6 +299,7 @@ struct factor_vm
 
        // gc
        void end_gc();
+       void set_current_gc_op(gc_op op);
        void start_gc_again();
        void update_code_heap_for_minor_gc(std::set<code_block *> *remembered_set);
        void collect_nursery();