vm/mark_bits.hpp

   1 namespace factor
   2 {
   3
   4 const int forwarding_granularity = 128;
   5
   6 template<typename Block, int Granularity> struct mark_bits {
   7         cell start;
   8         cell size;
   9         cell bits_size;
  10         unsigned int *marked;
  11         unsigned int *freed;
  12         cell forwarding_size;
  13         cell *forwarding;
  14
  15         void clear_mark_bits()
  16         {
  17                 memset(marked,0,bits_size * sizeof(unsigned int));
  18         }
  19
  20         void clear_free_bits()
  21         {
  22                 memset(freed,0,bits_size * sizeof(unsigned int));
  23         }
  24
  25         void clear_forwarding()
  26         {
  27                 memset(forwarding,0,forwarding_size * sizeof(cell));
  28         }
  29
  30         explicit mark_bits(cell start_, cell size_) :
  31                 start(start_),
  32                 size(size_),
  33                 bits_size(size / Granularity / 32),
  34                 marked(new unsigned int[bits_size]),
  35                 freed(new unsigned int[bits_size]),
  36                 forwarding_size(size / Granularity / forwarding_granularity),
  37                 forwarding(new cell[forwarding_size])
  38         {
  39                 clear_mark_bits();
  40                 clear_free_bits();
  41                 clear_forwarding();
  42         }
  43
  44         ~mark_bits()
  45         {
  46                 delete[] marked;
  47                 marked = NULL;
  48                 delete[] freed;
  49                 freed = NULL;
  50                 delete[] forwarding;
  51                 forwarding = NULL;
  52         }
  53
  54         std::pair<cell,cell> bitmap_deref(Block *address)
  55         {
  56                 cell word_number = (((cell)address - start) / Granularity);
  57                 cell word_index = (word_number >> 5);
  58                 cell word_shift = (word_number & 31);
  59
  60 #ifdef FACTOR_DEBUG
  61                 assert(word_index < bits_size);
  62 #endif
  63
  64                 return std::make_pair(word_index,word_shift);
  65         }
  66
  67         bool bitmap_elt(unsigned int *bits, Block *address)
  68         {
  69                 std::pair<cell,cell> pair = bitmap_deref(address);
  70                 return (bits[pair.first] & (1 << pair.second)) != 0;
  71         }
  72
  73         void set_bitmap_elt(unsigned int *bits, Block *address, bool flag)
  74         {
  75                 std::pair<cell,cell> pair = bitmap_deref(address);
  76                 if(flag)
  77                         bits[pair.first] |= (1 << pair.second);
  78                 else
  79                         bits[pair.first] &= ~(1 << pair.second);
  80         }
  81
  82         bool is_marked_p(Block *address)
  83         {
  84                 return bitmap_elt(marked,address);
  85         }
  86
  87         void set_marked_p(Block *address, bool marked_p)
  88         {
  89                 set_bitmap_elt(marked,address,marked_p);
  90         }
  91
  92         bool is_free_p(Block *address)
  93         {
  94                 return bitmap_elt(freed,address);
  95         }
  96
  97         void set_free_p(Block *address, bool free_p)
  98         {
  99                 set_bitmap_elt(freed,address,free_p);
 100         }
 101 };
 102
 103 }