VM: refactor gc_event so that the phase times are stored in an array

So that you don't need a new method for each gc phase to time.

diff --git a/basis/tools/memory/memory.factor b/basis/tools/memory/memory.factor
index daf905cace4d09d90aa8788be7683083eb37ac48..e07de9bbfb6963c7d455ee74efbd2536292577e6 100644 (file)
--- a/basis/tools/memory/memory.factor
+++ b/basis/tools/memory/memory.factor
@@ -1,11 +1,10 @@
 ! Copyright (C) 2005, 2011 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: accessors arrays assocs binary-search classes
-classes.struct combinators combinators.smart continuations fry
-generalizations generic grouping io io.styles kernel make math
-math.order math.parser math.statistics memory layouts namespaces
-parser prettyprint sequences sequences.generalizations sorting
-splitting strings system vm words hints hashtables ;
+USING: accessors arrays assocs binary-search classes classes.struct
+combinators combinators.smart continuations fry grouping hashtables
+hints io io.styles kernel layouts math math.order math.parser
+math.statistics memory namespaces prettyprint sequences
+sequences.generalizations sorting vm ;
 IN: tools.memory
 
 <PRIVATE
@@ -186,6 +185,9 @@ SYMBOL: gc-events
 : gc-stats. ( -- )
     gc-events get compute-gc-stats gc-stats-table simple-table. ;
 
+: sum-phase-times ( events phase -- n )
+    '[ times>> _ swap nth ] map-sum nanos>string ; inline
+
 : gc-summary. ( -- )
     gc-events get {
         { "Collections:" [ length commas ] }
@@ -193,11 +195,11 @@ SYMBOL: gc-events
         { "Decks scanned:" [ [ decks-scanned>> ] map-sum commas ] }
         { "Code blocks scanned:" [ [ code-blocks-scanned>> ] map-sum commas ] }
         { "Total time:" [ [ total-time>> ] map-sum nanos>string ] }
-        { "Card scan time:" [ [ card-scan-time>> ] map-sum nanos>string ] }
-        { "Code block scan time:" [ [ code-scan-time>> ] map-sum nanos>string ] }
-        { "Data heap sweep time:" [ [ data-sweep-time>> ] map-sum nanos>string ] }
-        { "Code heap sweep time:" [ [ code-sweep-time>> ] map-sum nanos>string ] }
-        { "Compaction time:" [ [ compaction-time>> ] map-sum nanos>string ] }
+        { "Card scan time:" [ PHASE-CARD-SCAN sum-phase-times ] }
+        { "Code block scan time:" [ PHASE-CODE-SCAN sum-phase-times ] }
+        { "Data heap sweep time:" [ PHASE-DATA-SWEEP sum-phase-times ] }
+        { "Code heap sweep time:" [ PHASE-CODE-SWEEP sum-phase-times ] }
+        { "Data compaction time:" [ PHASE-DATA-COMPACTION sum-phase-times ] }
     } object-table. ;
 
 SINGLETONS: +unoptimized+ +optimized+ +profiling+ +pic+ ;

diff --git a/basis/vm/vm.factor b/basis/vm/vm.factor
index 405aed851373c8faf97d79141aee2c7db0b4481a..4b89fa6f98479c4417923c8883b3fefb823afd8d 100644 (file)
--- a/basis/vm/vm.factor
+++ b/basis/vm/vm.factor
@@ -81,23 +81,27 @@ STRUCT: data-heap-room
 { decks cell_t }
 { mark-stack cell_t } ;
 
+CONSTANT: PHASE-CARD-SCAN 0
+CONSTANT: PHASE-CODE-SCAN 1
+CONSTANT: PHASE-DATA-SWEEP 2
+CONSTANT: PHASE-CODE-SWEEP 3
+CONSTANT: PHASE-DATA-COMPACTION 4
+
+! gc-event should be kept in sync with:
+!   vm/gc.hpp
 STRUCT: gc-event
-{ op uint }
-{ data-heap-before data-heap-room }
-{ code-heap-before mark-sweep-sizes }
-{ data-heap-after data-heap-room }
-{ code-heap-after mark-sweep-sizes }
-{ cards-scanned cell_t }
-{ decks-scanned cell_t }
-{ code-blocks-scanned cell_t }
-{ start-time ulonglong }
-{ total-time cell_t }
-{ card-scan-time cell_t }
-{ code-scan-time cell_t }
-{ data-sweep-time cell_t }
-{ code-sweep-time cell_t }
-{ compaction-time cell_t }
-{ temp-time ulonglong } ;
+    { op uint }
+    { data-heap-before data-heap-room }
+    { code-heap-before mark-sweep-sizes }
+    { data-heap-after data-heap-room }
+    { code-heap-after mark-sweep-sizes }
+    { cards-scanned cell_t }
+    { decks-scanned cell_t }
+    { code-blocks-scanned cell_t }
+    { start-time ulonglong }
+    { total-time cell_t }
+    { times cell_t[5] }
+    { temp-time ulonglong } ;
 
 ! gc-info should be kept in sync with:
 !   vm/gc_info.hpp

diff --git a/vm/aging_collector.cpp b/vm/aging_collector.cpp
index a152c0270c560a95d399a454d0bb691455b541ef..c934984e01e304ba99941c0b801dd426c7b0f193 100644 (file)
--- a/vm/aging_collector.cpp
+++ b/vm/aging_collector.cpp
@@ -51,15 +51,19 @@ void factor_vm::collect_aging() {
     if (event)
       event->reset_timer();
     visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
-    if (event)
-      event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
+    if (event) {
+      event->ended_phase(PHASE_CARD_SCAN);
+      event->cards_scanned += visitor.cards_scanned;
+      event->decks_scanned += visitor.decks_scanned;
+    }
 
     if (event)
       event->reset_timer();
     visitor.visit_code_heap_roots(&code->points_to_aging);
-    if (event)
-      event->ended_code_scan(code->points_to_aging.size());
-
+    if (event) {
+      event->ended_phase(PHASE_CODE_SCAN);
+      event->code_blocks_scanned += code->points_to_aging.size();
+    }
     visitor.visit_mark_stack(&mark_stack);
   }
   {

diff --git a/vm/compaction.cpp b/vm/compaction.cpp
index f243ff81e3fcd5e5c1dc0651ee85ddb58e96d58a..027be093bd274a3e6c5ca89ae2263893d93c2407 100644 (file)
--- a/vm/compaction.cpp
+++ b/vm/compaction.cpp
@@ -143,7 +143,7 @@ void factor_vm::collect_compact_impl() {
   code->initialize_all_blocks_set();
 
   if (event)
-    event->ended_compaction();
+    event->ended_phase(PHASE_DATA_COMPACTION);
 }
 
 void factor_vm::collect_compact() {

diff --git a/vm/full_collector.cpp b/vm/full_collector.cpp
index 28652b5181b1a9b26001e6b8f93b28707c2c56a1..3c87cdb6d107b3b1d400169fca6f23f780d47b12 100644 (file)
--- a/vm/full_collector.cpp
+++ b/vm/full_collector.cpp
@@ -84,7 +84,7 @@ void factor_vm::collect_sweep_impl() {
     event->reset_timer();
   data->tenured->sweep();
   if (event)
-    event->ended_data_sweep();
+    event->ended_phase(PHASE_DATA_SWEEP);
 
   // After a sweep, invalidate any code heap roots which are not
   // marked, so that if a block makes a tail call to a generic word,
@@ -102,7 +102,7 @@ void factor_vm::collect_sweep_impl() {
     event->reset_timer();
   code->sweep();
   if (event)
-    event->ended_code_sweep();
+    event->ended_phase(PHASE_CODE_SWEEP);
 }
 
 void factor_vm::collect_full() {

diff --git a/vm/gc.cpp b/vm/gc.cpp
index 1b22f885c851810ea5872a7d2d6d29cf4515fdfb..58e39d8d6274adc992164b1abae7902e25651436 100644 (file)
--- a/vm/gc.cpp
+++ b/vm/gc.cpp
@@ -8,11 +8,7 @@ gc_event::gc_event(gc_op op, factor_vm* parent)
       decks_scanned(0),
       code_blocks_scanned(0),
       start_time(nano_count()),
-      card_scan_time(0),
-      code_scan_time(0),
-      data_sweep_time(0),
-      code_sweep_time(0),
-      compaction_time(0) {
+      times{0} {
   data_heap_before = parent->data_room();
   code_heap_before = parent->code->allocator->as_allocator_room();
   start_time = nano_count();
@@ -20,27 +16,8 @@ gc_event::gc_event(gc_op op, factor_vm* parent)
 
 void gc_event::reset_timer() { temp_time = nano_count(); }
 
-void gc_event::ended_card_scan(cell cards_scanned_, cell decks_scanned_) {
-  cards_scanned += cards_scanned_;
-  decks_scanned += decks_scanned_;
-  card_scan_time = (cell)(nano_count() - temp_time);
-}
-
-void gc_event::ended_code_scan(cell code_blocks_scanned_) {
-  code_blocks_scanned += code_blocks_scanned_;
-  code_scan_time = (cell)(nano_count() - temp_time);
-}
-
-void gc_event::ended_data_sweep() {
-  data_sweep_time = (cell)(nano_count() - temp_time);
-}
-
-void gc_event::ended_code_sweep() {
-  code_sweep_time = (cell)(nano_count() - temp_time);
-}
-
-void gc_event::ended_compaction() {
-  compaction_time = (cell)(nano_count() - temp_time);
+void gc_event::ended_phase(gc_phase phase) {
+  times[phase] = (cell)(nano_count() - temp_time);
 }
 
 void gc_event::ended_gc(factor_vm* parent) {

diff --git a/vm/gc.hpp b/vm/gc.hpp
index b353c00a66a9925799059bcdfa15928b783b6db4..09414155803634c457b934f994e430190cd429ce 100644 (file)
--- a/vm/gc.hpp
+++ b/vm/gc.hpp
@@ -12,6 +12,15 @@ enum gc_op {
   COLLECT_GROWING_DATA_HEAP_OP
 };
 
+// These are the phases of the gc cycles we record the times of.
+enum gc_phase {
+  PHASE_CARD_SCAN,
+  PHASE_CODE_SCAN,
+  PHASE_DATA_SWEEP,
+  PHASE_CODE_SWEEP,
+  PHASE_DATA_COMPACTION,
+};
+
 struct gc_event {
   gc_op op;
   data_heap_room data_heap_before;
@@ -23,20 +32,12 @@ struct gc_event {
   cell code_blocks_scanned;
   uint64_t start_time;
   cell total_time;
-  cell card_scan_time;
-  cell code_scan_time;
-  cell data_sweep_time;
-  cell code_sweep_time;
-  cell compaction_time;
+  cell times[5];
   uint64_t temp_time;
 
   gc_event(gc_op op, factor_vm* parent);
   void reset_timer();
-  void ended_card_scan(cell cards_scanned_, cell decks_scanned_);
-  void ended_code_scan(cell code_blocks_scanned_);
-  void ended_data_sweep();
-  void ended_code_sweep();
-  void ended_compaction();
+  void ended_phase(gc_phase phase);
   void ended_gc(factor_vm* parent);
 };
 

diff --git a/vm/nursery_collector.cpp b/vm/nursery_collector.cpp
index e2c005f09f94ad1d6973a9eb07ab975aa7c306bb..3634110d1e4a7222e7595cd21eeb2bd78236fe02 100644 (file)
--- a/vm/nursery_collector.cpp
+++ b/vm/nursery_collector.cpp
@@ -50,14 +50,19 @@ void factor_vm::collect_nursery() {
   visitor.visit_cards(data->tenured, card_points_to_nursery,
                       card_points_to_nursery);
   visitor.visit_cards(data->aging, card_points_to_nursery, 0xff);
-  if (event)
-    event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
+  if (event) {
+    event->ended_phase(PHASE_CARD_SCAN);
+    event->cards_scanned += visitor.cards_scanned;
+    event->decks_scanned += visitor.decks_scanned;
+  }
 
   if (event)
     event->reset_timer();
   visitor.visit_code_heap_roots(&code->points_to_nursery);
-  if (event)
-    event->ended_code_scan(code->points_to_nursery.size());
+  if (event) {
+    event->ended_phase(PHASE_CODE_SCAN);
+    event->code_blocks_scanned += code->points_to_nursery.size();
+  }
 
   visitor.cheneys_algorithm(data->aging, scan);
 

diff --git a/vm/to_tenured_collector.cpp b/vm/to_tenured_collector.cpp
index 3616945c522a58045effa6da3dd3c567ef0138d6..532dcaeade453bfa737850f20742910f5f0b1c9e 100644 (file)
--- a/vm/to_tenured_collector.cpp
+++ b/vm/to_tenured_collector.cpp
@@ -14,15 +14,19 @@ void factor_vm::collect_to_tenured() {
   if (event)
     event->reset_timer();
   visitor.visit_cards(data->tenured, card_points_to_aging, 0xff);
-  if (event)
-    event->ended_card_scan(visitor.cards_scanned, visitor.decks_scanned);
+  if (event) {
+    event->ended_phase(PHASE_CARD_SCAN);
+    event->cards_scanned += visitor.cards_scanned;
+    event->decks_scanned += visitor.decks_scanned;
+  }
 
   if (event)
     event->reset_timer();
   visitor.visit_code_heap_roots(&code->points_to_aging);
-  if (event)
-    event->ended_code_scan(code->points_to_aging.size());
-
+  if (event) {
+    event->ended_phase(PHASE_CODE_SCAN);
+    event->code_blocks_scanned += code->points_to_aging.size();
+  }
   visitor.visit_mark_stack(&mark_stack);
 
   data->reset_nursery();