steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

moved write_barrier inline function impls to vm.hpp

db4
Phil Dawes 2009-08-17 21:37:11 +01:00
parent a6c3c1e7d2
commit 31905b68a7
3 changed files with 103 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vm/master.hpp
View File

@ -47,9 +47,9 @@
#include "bignumint.hpp"
#include "bignum.hpp"
#include "code_block.hpp"
#include "vm.hpp"
#include "data_heap.hpp"
#include "write_barrier.hpp"
#include "vm.hpp"
#include "data_gc.hpp"
#include "local_roots.hpp"
#include "generic_arrays.hpp"

103
vm/vm.hpp
View File

@ -362,7 +362,6 @@ struct factorvm {
inline cell allot_float(double n);
inline bignum *float_to_bignum(cell tagged);
inline double bignum_to_float(cell tagged);
// next method here:
//io
void init_c_io();
@ -580,4 +579,106 @@ struct factorvm {
extern factorvm *vm;
// write_barrier.hpp
inline card *factorvm::addr_to_card(cell a)
{
return (card*)(((cell)(a) >> card_bits) + cards_offset);
}
inline card *addr_to_card(cell a)
{
return vm->addr_to_card(a);
}
inline cell factorvm::card_to_addr(card *c)
{
return ((cell)c - cards_offset) << card_bits;
}
inline cell card_to_addr(card *c)
{
return vm->card_to_addr(c);
}
inline cell factorvm::card_offset(card *c)
{
return *(c - (cell)data->cards + (cell)data->allot_markers);
}
inline cell card_offset(card *c)
{
return vm->card_offset(c);
}
inline card_deck *factorvm::addr_to_deck(cell a)
{
return (card_deck *)(((cell)a >> deck_bits) + decks_offset);
}
inline card_deck *addr_to_deck(cell a)
{
return vm->addr_to_deck(a);
}
inline cell factorvm::deck_to_addr(card_deck *c)
{
return ((cell)c - decks_offset) << deck_bits;
}
inline cell deck_to_addr(card_deck *c)
{
return vm->deck_to_addr(c);
}
inline card *factorvm::deck_to_card(card_deck *d)
{
return (card *)((((cell)d - decks_offset) << (deck_bits - card_bits)) + cards_offset);
}
inline card *deck_to_card(card_deck *d)
{
return vm->deck_to_card(d);
}
inline card *factorvm::addr_to_allot_marker(object *a)
{
return (card *)(((cell)a >> card_bits) + allot_markers_offset);
}
inline card *addr_to_allot_marker(object *a)
{
return vm->addr_to_allot_marker(a);
}
/* the write barrier must be called any time we are potentially storing a
pointer from an older generation to a younger one */
inline void factorvm::write_barrier(object *obj)
{
*addr_to_card((cell)obj) = card_mark_mask;
*addr_to_deck((cell)obj) = card_mark_mask;
}
inline void write_barrier(object *obj)
{
return vm->write_barrier(obj);
}
/* we need to remember the first object allocated in the card */
inline void factorvm::allot_barrier(object *address)
{
card *ptr = addr_to_allot_marker(address);
if(*ptr == invalid_allot_marker)
*ptr = ((cell)address & addr_card_mask);
}
inline void allot_barrier(object *address)
{
return vm->allot_barrier(address);
}
// next method here:
}

97
vm/write_barrier.hpp
View File

@ -22,110 +22,13 @@ static const cell card_bits = 8;
static const cell card_size = (1<<card_bits);
static const cell addr_card_mask = (card_size-1);
inline card *factorvm::addr_to_card(cell a)
{
return (card*)(((cell)(a) >> card_bits) + cards_offset);
}
inline card *addr_to_card(cell a)
{
return vm->addr_to_card(a);
}
inline cell factorvm::card_to_addr(card *c)
{
return ((cell)c - cards_offset) << card_bits;
}
inline cell card_to_addr(card *c)
{
return vm->card_to_addr(c);
}
inline cell factorvm::card_offset(card *c)
{
return *(c - (cell)data->cards + (cell)data->allot_markers);
}
inline cell card_offset(card *c)
{
return vm->card_offset(c);
}
typedef u8 card_deck;
static const cell deck_bits = (card_bits + 10);
static const cell deck_size = (1<<deck_bits);
static const cell addr_deck_mask = (deck_size-1);
inline card_deck *factorvm::addr_to_deck(cell a)
{
return (card_deck *)(((cell)a >> deck_bits) + decks_offset);
}
inline card_deck *addr_to_deck(cell a)
{
return vm->addr_to_deck(a);
}
inline cell factorvm::deck_to_addr(card_deck *c)
{
return ((cell)c - decks_offset) << deck_bits;
}
inline cell deck_to_addr(card_deck *c)
{
return vm->deck_to_addr(c);
}
inline card *factorvm::deck_to_card(card_deck *d)
{
return (card *)((((cell)d - decks_offset) << (deck_bits - card_bits)) + cards_offset);
}
inline card *deck_to_card(card_deck *d)
{
return vm->deck_to_card(d);
}
static const cell invalid_allot_marker = 0xff;
extern cell allot_markers_offset;
inline card *factorvm::addr_to_allot_marker(object *a)
{
return (card *)(((cell)a >> card_bits) + allot_markers_offset);
}
inline card *addr_to_allot_marker(object *a)
{
return vm->addr_to_allot_marker(a);
}
/* the write barrier must be called any time we are potentially storing a
pointer from an older generation to a younger one */
inline void factorvm::write_barrier(object *obj)
{
*addr_to_card((cell)obj) = card_mark_mask;
*addr_to_deck((cell)obj) = card_mark_mask;
}
inline void write_barrier(object *obj)
{
return vm->write_barrier(obj);
}
/* we need to remember the first object allocated in the card */
inline void factorvm::allot_barrier(object *address)
{
card *ptr = addr_to_allot_marker(address);
if(*ptr == invalid_allot_marker)
*ptr = ((cell)address & addr_card_mask);
}
inline void allot_barrier(object *address)
{
return vm->allot_barrier(address);
}
}