vm: cleanup

diff --git a/vm/copying_collector.hpp b/vm/copying_collector.hpp
index 11465a0de7905658e8ffdc05fd0d3b7b0b326eae..9e1675366042b30a1afb6a724f72cc1e6edcf395 100644 (file)
--- a/vm/copying_collector.hpp
+++ b/vm/copying_collector.hpp
@@ -17,7 +17,7 @@ struct copying_collector : collector<TargetGeneration,Policy> {
                }
        }
 
-       template<typename SourceGeneration> void trace_card(SourceGeneration *gen, card *ptr)
+       template<typename SourceGeneration> void trace_card(SourceGeneration *gen, card *ptr, card unmask)
        {
                cell card_start = this->myvm->card_to_addr(ptr);
                cell card_scan = card_start + gen->card_offset(card_start);
@@ -25,6 +25,8 @@ struct copying_collector : collector<TargetGeneration,Policy> {
 
                trace_objects_between(gen,card_scan,&card_end);
 
+               *ptr &= ~unmask;
+
                this->myvm->gc_stats.cards_scanned++;
        }
 
@@ -42,14 +44,10 @@ struct copying_collector : collector<TargetGeneration,Policy> {
                        {
                                card *ptr = (card *)quad_ptr;
 
-                               for(int card = 0; card < 4; card++)
-                               {
-                                       if(ptr[card] & mask)
-                                       {
-                                               trace_card(gen,&ptr[card]);
-                                               ptr[card] &= ~unmask;
-                                       }
-                               }
+                               if(ptr[0] & mask) trace_card(gen,&ptr[0],unmask);
+                               if(ptr[1] & mask) trace_card(gen,&ptr[1],unmask);
+                               if(ptr[2] & mask) trace_card(gen,&ptr[2],unmask);
+                               if(ptr[3] & mask) trace_card(gen,&ptr[3],unmask);
                        }
                }
 
@@ -129,6 +127,7 @@ struct copying_collector : collector<TargetGeneration,Policy> {
                this->trace_handle(&compiled->owner);
                this->trace_handle(&compiled->literals);
                this->trace_handle(&compiled->relocation);
+               this->myvm->gc_stats.code_blocks_scanned++;
        }
 
        void trace_code_heap_roots(std::set<code_block *> *remembered_set)

diff --git a/vm/gc.cpp b/vm/gc.cpp
index 795b75f149c5b1cb3f661a95477fcba871e99f87..a435e5f465aa354e2a86bda83acfbbc75cf62a61 100755 (executable)
--- a/vm/gc.cpp
+++ b/vm/gc.cpp
@@ -36,8 +36,8 @@ void factor_vm::free_unmarked_code_blocks()
 void factor_vm::update_dirty_code_blocks(std::set<code_block *> *remembered_set)
 {
        /* The youngest generation that any code block can now reference */
-       std::set<code_block *>::iterator iter = remembered_set->begin();
-       std::set<code_block *>::iterator end = remembered_set->end();
+       std::set<code_block *>::const_iterator iter = remembered_set->begin();
+       std::set<code_block *>::const_iterator end = remembered_set->end();
 
        for(; iter != end; iter++) update_literal_references(*iter);
 }
@@ -146,7 +146,7 @@ void factor_vm::primitive_gc_stats()
        result.add(tag<bignum>(ulong_long_to_bignum(gc_stats.cards_scanned)));
        result.add(tag<bignum>(ulong_long_to_bignum(gc_stats.decks_scanned)));
        result.add(tag<bignum>(ulong_long_to_bignum(gc_stats.card_scan_time)));
-       result.add(allot_cell(gc_stats.code_heap_scans));
+       result.add(allot_cell(gc_stats.code_blocks_scanned));
 
        result.trim();
        dpush(result.elements.value());

diff --git a/vm/gc.hpp b/vm/gc.hpp
index 9304a3ad03064a6d827f45972cb6d5bb2cda92c4..d95d8df83314847806f79b03d2c0e39bca362c99 100755 (executable)
--- a/vm/gc.hpp
+++ b/vm/gc.hpp
@@ -15,7 +15,7 @@ struct gc_statistics {
        u64 cards_scanned;
        u64 decks_scanned;
        u64 card_scan_time;
-       cell code_heap_scans;
+       u64 code_blocks_scanned;
 };
 
 struct gc_state {