machine/memory/root.hpp

   1 #ifndef RBX_GC_ROOT_HPP
   2 #define RBX_GC_ROOT_HPP
   3
   4
   5 #include <stdexcept>
   6
   7 #include "memory/header.hpp"
   8
   9 #include "linkedlist.hpp"
  10 #include "defines.hpp"
  11
  12 namespace rubinius {
  13 namespace memory {
  14   class Root;
  15
  16   /**
  17    *  Roots is a structure comprising of Root objects.
  18    *
  19    *  @todo Add more information about class. --rue
  20    *  @todo Document methods. --rue
  21    */
  22   class Roots : public LinkedList {
  23     std::mutex lock_;
  24
  25   public:   /* Ctors */
  26     Roots()
  27       : LinkedList()
  28       , lock_()
  29     {}
  30
  31   public:   /* Interface */
  32     Root* front();
  33
  34     typedef LinkedList::Iterator<Roots, Root> Iterator;
  35
  36     void add(Root*);
  37     void remove(Root*);
  38   };
  39
  40   /**
  41    *  A Root envelops an Object.
  42    *
  43    *  Each Root is also associated with a certain Roots structure
  44    *  and could be used to access its other members. The Root can
  45    *  be associated with (or "migrated to") a different Roots.
  46    *
  47    *  @todo Document remaining methods. --rue
  48    */
  49   class Root : public LinkedList::Node {
  50     /** The Roots structure this Root belongs to. */
  51     Roots*  roots_;
  52
  53   protected:
  54     /** Enveloped Object. */
  55     Object*  object_;
  56
  57   public: /** Constructors */
  58
  59     Root()
  60       : LinkedList::Node()
  61       , roots_(NULL)
  62       , object_(cUndef)
  63     {}
  64
  65     Root(Roots* roots)
  66       : LinkedList::Node()
  67       , roots_(roots)
  68       , object_(cUndef)
  69     {}
  70
  71     Root(Roots* roots, Object* obj)
  72       : LinkedList::Node()
  73       , roots_(roots)
  74       , object_(obj)
  75     {
  76       roots_->add(this);
  77     }
  78
  79     Root(STATE);
  80     Root(STATE, Object* obj);
  81
  82     /** Copy construction uses set() semantics. */
  83     Root(const Root& other)
  84       : LinkedList::Node()
  85       , roots_(NULL)
  86       , object_(cUndef)
  87     {
  88       set(other.object_, other.roots_);
  89     }
  90
  91     ~Root() {
  92       if(roots_ && object_ && object_ != cUndef) roots_->remove(this);
  93     }
  94
  95   public: /** Methods */
  96
  97     /** Assignment uses set() semantics. */
  98     Root& operator=(Root& other) {
  99       set(other.object_, other.roots_);
 100       return *this;
 101     }
 102
 103     /** Obtain the enveloped Object. */
 104     Object* get() const {
 105       return object_;
 106     }
 107
 108     /** Envelope the given Object. Must have roots already. */
 109     void set(Object* obj) {
 110       assert(roots_ && "invalid Root usage. Cannot set object before roots");
 111       set(obj, roots_);
 112     }
 113
 114     /** Envelope the given Object, migrating to given Roots if it is new. */
 115     void set(Object* obj, Roots* r);
 116
 117     // Used in the JIT to allow for loading of Roots directly.
 118     Object** object_address() {
 119       return &object_;
 120     }
 121   };
 122
 123   /**
 124    *  TypedRoot is a Root that knows the type of its Object.
 125    *
 126    *  @todo Use base type of object rather than pointer type
 127    *        as ObjType and change usage accordingly? This
 128    *        allows, among other things, using `as()` rather
 129    *        than a direct C++ cast. --rue
 130    */
 131   template <typename ObjType>
 132     class TypedRoot : public Root {
 133     public:
 134       TypedRoot()
 135         : Root()
 136       {}
 137
 138       /** As Root::Root(roots), but retains object's type. */
 139       TypedRoot(Roots* roots)
 140         : Root(roots)
 141       {}
 142
 143       /** As Root::Root(STATE), but retains object's type. */
 144       TypedRoot(STATE)
 145         : Root(state)
 146       {}
 147
 148       /** As Root::Root(STATE, Object*), but retains object's type. */
 149       TypedRoot(STATE, ObjType obj)
 150         : Root(state, reinterpret_cast<Object*>(obj))
 151       {}
 152
 153       /** Transparently delegate dereferencing to enveloped object. */
 154       /** @todo Use as<ObjType>() when using base type instead of pointer. --rue */
 155       ObjType operator->() const {
 156         // assert(object_ && "Using an unassigned root!");
 157         return reinterpret_cast<ObjType>(object_);
 158       }
 159
 160       /** Return the enveloped object as the real ObjType. */
 161       /** @todo Use as<ObjType>() when using base type instead of pointer. --rue */
 162       ObjType get() const {
 163         // assert(object_ && "Using an unassigned root!");
 164         return reinterpret_cast<ObjType>(object_);
 165       }
 166     };
 167 }
 168 }
 169
 170 #endif