vm: refactoring card logic a bit

diff --git a/vm/copying_collector.hpp b/vm/copying_collector.hpp
index c2a3269f3b7d76c1350424d267cbb2adb1858067..e7d2207fd5d7ed415c479211981b23ca5f5925f5 100644 (file)
--- a/vm/copying_collector.hpp
+++ b/vm/copying_collector.hpp
@@ -16,7 +16,8 @@ struct complex_unmarker {
        complex_unmarker(card unmask_none_, card unmask_some_) :
                unmask_none(unmask_none_), unmask_some(unmask_some_) {}
 
-       void operator()(bool result, card *ptr) {
+       void operator()(bool result, card *ptr)
+       {
                *ptr &= (result ? ~unmask_some : ~unmask_none);
        }
 };
@@ -42,15 +43,30 @@ struct copying_collector : collector<TargetGeneration,Policy> {
                return copied;
        }
 
+       inline cell card_index(cell deck)
+       {
+               return deck << (deck_bits - card_bits);
+       }
+
+       inline cell card_deck_index(cell a)
+       {
+               return (a - this->data->start) >> deck_bits;
+       }
+
+       inline cell card_start_address(cell card)
+       {
+               return (card << card_bits) + this->data->start;
+       }
+
        template<typename SourceGeneration, typename Unmarker>
-       bool trace_card(SourceGeneration *gen, card *ptr, Unmarker unmarker)
+       bool trace_card(SourceGeneration *gen, card *cards, cell card_index, Unmarker unmarker)
        {
-               cell card_start = this->myvm->card_to_addr(ptr);
+               cell card_start = card_start_address(card_index);
                cell card_scan = card_start + gen->first_object_in_card(card_start);
-               cell card_end = this->myvm->card_to_addr(ptr + 1);
+               cell card_end = card_start_address(card_index + 1);
 
                bool result = this->trace_objects_between(gen,card_scan,&card_end);
-               unmarker(result,ptr);
+               unmarker(result,&cards[card_index]);
 
                this->myvm->gc_stats.cards_scanned++;
 
@@ -58,15 +74,18 @@ struct copying_collector : collector<TargetGeneration,Policy> {
        }
 
        template<typename SourceGeneration, typename Unmarker>
-       bool trace_card_deck(SourceGeneration *gen, card_deck *deck, card mask, Unmarker unmarker)
+       bool trace_card_deck(SourceGeneration *gen, cell deck_index, card mask, Unmarker unmarker)
        {
-               card *first_card = this->myvm->deck_to_card(deck);
-               card *last_card = this->myvm->deck_to_card(deck + 1);
+               cell first_card = card_index(deck_index);
+               cell last_card = card_index(deck_index + 1);
 
                bool copied = false;
 
-               for(card *ptr = first_card; ptr < last_card; ptr++)
-                       if(*ptr & mask) copied |= trace_card(gen,ptr,unmarker);
+               card *cards = this->data->cards;
+               for(cell i = first_card; i < last_card; i++)
+               {
+                       if(cards[i] & mask) copied |= trace_card(gen,cards,i,unmarker);
+               }
 
                this->myvm->gc_stats.decks_scanned++;
 
@@ -78,11 +97,15 @@ struct copying_collector : collector<TargetGeneration,Policy> {
        {
                u64 start = current_micros();
 
-               card_deck *first_deck = this->myvm->addr_to_deck(gen->start);
-               card_deck *last_deck = this->myvm->addr_to_deck(gen->end);
+               cell first_deck = card_deck_index(gen->start);
+               cell last_deck = card_deck_index(gen->end);
 
-               for(card_deck *ptr = first_deck; ptr < last_deck; ptr++)
-                       if(*ptr & mask) unmarker(trace_card_deck(gen,ptr,mask,unmarker),ptr);
+               card_deck *decks = this->data->decks;
+               for(cell i = first_deck; i < last_deck; i++)
+               {
+                       if(decks[i] & mask)
+                               unmarker(trace_card_deck(gen,i,mask,unmarker),&decks[i]);
+               }
 
                this->myvm->gc_stats.card_scan_time += (current_micros() - start);
        }

diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp
index 52f815c139c31a9678dba8c6a202d7e9684fab09..f028dd7a00178d5e6060c528e11ab542af77bf04 100755 (executable)
--- a/vm/data_heap.cpp
+++ b/vm/data_heap.cpp
@@ -28,14 +28,14 @@ data_heap::data_heap(factor_vm *myvm, cell young_size_, cell aging_size_, cell t
 
        cell cards_size = total_size >> card_bits;
 
-       cards = new char[cards_size];
+       cards = new card[cards_size];
        cards_end = cards + cards_size;
 
        cell decks_size = total_size >> deck_bits;
-       decks = new char[decks_size];
+       decks = new card_deck[decks_size];
        decks_end = decks + decks_size;
 
-       cell start = align(seg->start,deck_size);
+       start = align(seg->start,deck_size);
 
        tenured = new tenured_space(tenured_size,start);
        tenured_semispace = new tenured_space(tenured_size,tenured->end);

diff --git a/vm/data_heap.hpp b/vm/data_heap.hpp
index 36c75e23b90224032acaf723152d6280eeccdb32..fdc2cbfbf65d8e95083276d53a2fea146e8b1eea 100755 (executable)
--- a/vm/data_heap.hpp
+++ b/vm/data_heap.hpp
@@ -2,6 +2,8 @@ namespace factor
 {
 
 struct data_heap {
+       cell start;
+
        cell young_size;
        cell aging_size;
        cell tenured_size;
@@ -14,11 +16,11 @@ struct data_heap {
        tenured_space *tenured;
        tenured_space *tenured_semispace;
 
-       char *cards;
-       char *cards_end;
+       card *cards;
+       card *cards_end;
 
-       char *decks;
-       char *decks_end;
+       card_deck *decks;
+       card_deck *decks_end;
        
        explicit data_heap(factor_vm *myvm, cell young_size, cell aging_size, cell tenured_size);
        ~data_heap();

diff --git a/vm/debug.cpp b/vm/debug.cpp
index 5460a309fd4e6736bbcbdce381041e629b97a0ed..64514b9261835553e3cba8d073f93108f16014bb 100755 (executable)
--- a/vm/debug.cpp
+++ b/vm/debug.cpp
@@ -346,8 +346,6 @@ void factor_vm::factorbug()
        print_string(".s .r .c         -- print data, retain, call stacks\n");
        print_string("e                -- dump environment\n");
        print_string("g                -- dump generations\n");
-       print_string("card <addr>      -- print card containing address\n");
-       print_string("addr <card>      -- print address containing card\n");
        print_string("data             -- data heap dump\n");
        print_string("words            -- words dump\n");
        print_string("tuples           -- tuples dump\n");
@@ -423,18 +421,6 @@ void factor_vm::factorbug()
                }
                else if(strcmp(cmd,"g") == 0)
                        dump_generations();
-               else if(strcmp(cmd,"card") == 0)
-               {
-                       cell addr = read_cell_hex();
-                       print_cell_hex((cell)addr_to_card(addr));
-                       nl();
-               }
-               else if(strcmp(cmd,"addr") == 0)
-               {
-                       card *ptr = (card *)read_cell_hex();
-                       print_cell_hex(card_to_addr(ptr));
-                       nl();
-               }
                else if(strcmp(cmd,"q") == 0)
                        return;
                else if(strcmp(cmd,"x") == 0)

diff --git a/vm/old_space.hpp b/vm/old_space.hpp
index 1f136e8c6c0681944e3e89d94b5a7fbc74d82a89..6e2664c758042448693f8153b2b8bde7d9dc8581 100644 (file)
--- a/vm/old_space.hpp
+++ b/vm/old_space.hpp
@@ -10,9 +10,24 @@ struct old_space : zone {
        old_space(cell size_, cell start_);
        ~old_space();
 
+       cell object_start_map_index(cell address)
+       {
+               return (address - start) >> card_bits;
+       }
+
+       /* Find the first object starting on or after the given address */
        cell first_object_in_card(cell address)
        {
-               return object_start_offsets[(address - start) >> card_bits];
+               return object_start_offsets[object_start_map_index(address)];
+       }
+
+       /* Find the card which contains the header of the object which contains
+       the given address */
+       cell find_object_start_card(cell address)
+       {
+               cell i = object_start_map_index(address);
+               while(i >= 0 && object_start_offsets[i] == card_starts_inside_object) i--;
+               return i;
        }
 
        void record_object_start_offset(object *obj);

diff --git a/vm/os-unix.cpp b/vm/os-unix.cpp
index e792483e0de65e2aee5f139289d4cf17e62cdfc5..b5dbbfbc03c15f7933e84baadfba3e9aaef889ce 100644 (file)
--- a/vm/os-unix.cpp
+++ b/vm/os-unix.cpp
@@ -211,7 +211,6 @@ void unix_init_signals()
        misc_sigaction.sa_sigaction = misc_signal_handler;
        misc_sigaction.sa_flags = SA_SIGINFO;
 
-       sigaction_safe(SIGABRT,&misc_sigaction,NULL);
        sigaction_safe(SIGQUIT,&misc_sigaction,NULL);
        sigaction_safe(SIGILL,&misc_sigaction,NULL);