vm/write_barrier.hpp

   1 /* card marking write barrier. a card is a byte storing a mark flag,
   2 and the offset (in cells) of the first object in the card.
   3
   4 the mark flag is set by the write barrier when an object in the
   5 card has a slot written to.
   6
   7 the offset of the first object is set by the allocator. */
   8
   9 VM_C_API factor::cell cards_offset;
  10 VM_C_API factor::cell decks_offset;
  11
  12 namespace factor
  13 {
  14
  15 /* if card_points_to_nursery is set, card_points_to_aging must also be set. */
  16 static const cell card_points_to_nursery = 0x80;
  17 static const cell card_points_to_aging = 0x40;
  18 static const cell card_mark_mask = (card_points_to_nursery | card_points_to_aging);
  19 typedef u8 card;
  20
  21 static const cell card_bits = 8;
  22 static const cell card_size = (1<<card_bits);
  23 static const cell addr_card_mask = (card_size-1);
  24
  25 inline card *factorvm::addr_to_card(cell a)
  26 {
  27         return (card*)(((cell)(a) >> card_bits) + cards_offset);
  28 }
  29
  30 inline card *addr_to_card(cell a)
  31 {
  32         return vm->addr_to_card(a);
  33 }
  34
  35 inline cell factorvm::card_to_addr(card *c)
  36 {
  37         return ((cell)c - cards_offset) << card_bits;
  38 }
  39
  40 inline cell card_to_addr(card *c)
  41 {
  42         return vm->card_to_addr(c);
  43 }
  44
  45 inline cell factorvm::card_offset(card *c)
  46 {
  47         return *(c - (cell)data->cards + (cell)data->allot_markers);
  48 }
  49
  50 inline cell card_offset(card *c)
  51 {
  52         return vm->card_offset(c);
  53 }
  54
  55 typedef u8 card_deck;
  56
  57 static const cell deck_bits = (card_bits + 10);
  58 static const cell deck_size = (1<<deck_bits);
  59 static const cell addr_deck_mask = (deck_size-1);
  60
  61 inline card_deck *factorvm::addr_to_deck(cell a)
  62 {
  63         return (card_deck *)(((cell)a >> deck_bits) + decks_offset);
  64 }
  65
  66 inline card_deck *addr_to_deck(cell a)
  67 {
  68         return vm->addr_to_deck(a);
  69 }
  70
  71 inline cell factorvm::deck_to_addr(card_deck *c)
  72 {
  73         return ((cell)c - decks_offset) << deck_bits;
  74 }
  75
  76 inline cell deck_to_addr(card_deck *c)
  77 {
  78         return vm->deck_to_addr(c);
  79 }
  80
  81 inline card *factorvm::deck_to_card(card_deck *d)
  82 {
  83         return (card *)((((cell)d - decks_offset) << (deck_bits - card_bits)) + cards_offset);
  84 }
  85
  86 inline card *deck_to_card(card_deck *d)
  87 {
  88         return vm->deck_to_card(d);
  89 }
  90
  91 static const cell invalid_allot_marker = 0xff;
  92
  93 extern cell allot_markers_offset;
  94
  95 inline card *factorvm::addr_to_allot_marker(object *a)
  96 {
  97         return (card *)(((cell)a >> card_bits) + allot_markers_offset);
  98 }
  99
 100 inline card *addr_to_allot_marker(object *a)
 101 {
 102         return vm->addr_to_allot_marker(a);
 103 }
 104
 105 /* the write barrier must be called any time we are potentially storing a
 106 pointer from an older generation to a younger one */
 107 inline void factorvm::write_barrier(object *obj)
 108 {
 109         *addr_to_card((cell)obj) = card_mark_mask;
 110         *addr_to_deck((cell)obj) = card_mark_mask;
 111 }
 112
 113 inline void write_barrier(object *obj)
 114 {
 115         return vm->write_barrier(obj);
 116 }
 117
 118 /* we need to remember the first object allocated in the card */
 119 inline void factorvm::allot_barrier(object *address)
 120 {
 121         card *ptr = addr_to_allot_marker(address);
 122         if(*ptr == invalid_allot_marker)
 123                 *ptr = ((cell)address & addr_card_mask);
 124 }
 125
 126 inline void allot_barrier(object *address)
 127 {
 128         return vm->allot_barrier(address);
 129 }
 130
 131 }