gc.h

#ifndef __GC_H__
#define __GC_H__

#include <stdlib.h>
#include <assert.h>

#include "threadctx.h"

namespace GC
{
    class Object;
    class Root;

    #define GC_MARK(Class) Class(*this)

    struct ObjectHeader 
    { 
        ObjectHeader* next;

        Object* getObject() const { 
            return (Object*)(this + 1);
        }
    };

    class MemoryAllocator
    {
        friend class Object;
      public:
        static MemoryAllocator* getCurrent();

        static void* allocate(size_t size);

        static void mark(Object* obj);

        static void mark(Object** refs, size_t nRefs);

        static void registerRoot(Root* root);
            
        static void unregisterRoot(Root* root);

        static void gc();

        static void allowGC();
        
        MemoryAllocator(size_t gcStartThreshold = 1024*1024, size_t gcAutoStartThreshold = (size_t)-1);

        ~MemoryAllocator();
    
        // internal instance methods
        void  _registerRoot(Root* root);     
        void  _unregisterRoot(Root* root);        
        void  _mark(Object* obj);
        void  _mark(Object** refs, size_t nRefs);
        void* _allocate(size_t size);
        void  _gc();
        void  _allowGC();

      private:
        void markPhase();
        void sweepPhase();

      private:
        size_t  allocated;
        Root*   roots;
        ObjectHeader* objects;
        size_t  startThreshold;
        size_t  autoStartThreshold;

        static ThreadContext<MemoryAllocator> ctx;
    };

    class Object 
    {
      public:
        void* operator new(size_t size) 
        { 
            return MemoryAllocator::allocate(size);
        }

        void* operator new(size_t fixedSize, size_t varyingSize)
        { 
            return MemoryAllocator::allocate(fixedSize + varyingSize);
        }

        void operator delete(void* obj) {
            free((ObjectHeader*)obj - 1); 
        } 
        void operator delete(void* obj, size_t) { 
            free((ObjectHeader*)obj - 1);             
        } 

      protected:
        friend class MemoryAllocator;
        
        virtual void mark(MemoryAllocator* allocator) {}

        virtual~Object() {}

        ObjectHeader* getHeader() { 
            return (ObjectHeader*)this - 1;
        }
    };

    template<class T>
    class Ref 
    {
        T* obj;

      public:
        T& operator*() { 
            return *obj;
        }
        T const& operator*() const { 
            return *obj;
        }
        T* operator->() { 
            return obj; 
        }
        T const* operator->() const { 
            return obj; 
        }
        operator T*() { 
            return obj;
        }
        operator T const*() const { 
            return obj;
        }
        T* operator = (T const* val) {
            return obj = (T*)val;            
        }
        bool operator == (T const* other) { 
            return obj == other;
        }
        bool operator == (Ref<T> const& other) { 
            return obj == other.obj;
        }
        bool operator != (T const* other) { 
            return obj != other;
        }
        bool operator != (Ref<T> const& other) { 
            return obj != other.obj;
        }
        
        Ref(T const* ptr = NULL) : obj((T*)ptr) {}

        Ref(Ref<T> const& ref) : obj(ref.obj) {
            MemoryAllocator::mark(obj);
        }
    };

    class Root
    {
        friend class MemoryAllocator;

      protected:
        Root* next; // roots are linked in L1 list
        
        virtual void mark(MemoryAllocator* allocator) = 0;

        Root() 
        { 
            MemoryAllocator::registerRoot(this);
        }
        
        ~Root() 
        { 
            MemoryAllocator::unregisterRoot(this);
        }        
    };

    template<class T>
    class Var : Root
    {
        T* obj;

      public:
        T& operator*() { 
            return *obj;
        }
        T const& operator*() const { 
            return *obj;
        }
        T* operator->() { 
            return obj; 
        }
        T const* operator->() const { 
            return obj; 
        }
        operator T*() { 
            return obj;
        }
        operator T const*() const { 
            return obj;
        }
        T* operator = (T const* val) {
            obj = (T*)val;
            return val;
        }
        bool operator == (T const* other) { 
            return obj == other;
        }
        bool operator == (Var<T> const& other) { 
            return obj == other.obj;
        }
        bool operator != (T const* other) { 
            return obj != other;
        }
        bool operator != (Var<T> const& other) { 
            return obj != other.obj;
        }
        
        virtual void mark(MemoryAllocator* allocator) { 
            allocator->_mark(obj);
        }

        Var(T* ptr = NULL) : obj(ptr) {}

        Var(Var<T> const& var) : obj(var.obj) {}
    };
    
    template<class T, size_t size>
    class ArrayVar : Root
    {
        T* array[size];

      public:
        T*& operator[](size_t index) 
        { 
            assert(index < size);
            return array[index];
        }
        
        T* operator[](size_t index) const
        { 
            assert(index < size);
            return array[index];
        }        

        ArrayVar() {
            for (size_t i = 0; i < size; i++) { 
                array[i] = NULL;
            }
        }

        virtual void mark(MemoryAllocator* allocator) { 
            allocator->_mark((Object**)array, size);
        }
    };

    template<class T>
    class VectorVar : Root
    {
        T** array;
        size_t used;
        size_t allocated;

      public:
        T*& operator[](size_t index) 
        { 
            assert(index < used);
            return array[index];
        }
        
        T* operator[](size_t index) const
        { 
            assert(index < used);
            return array[index];
        }        

        size_t size() const
        {
            return used;
        }

        void resize(size_t newSize) 
        { 
            size_t i;
            if (newSize > allocated) { 
                allocated = allocated*2 > newSize ? allocated*2 : newSize;
                T** newArray = new T*[allocated];
                for (i = 0; i < used; i++) { 
                    newArray[i] = array[i];
                }
                delete[] array;
                array = newArray;
            }
            for (i = used; i < newSize; i++) { 
                array[i] = NULL;
            }
            used = newSize;
        }

        void push(T const* obj) { 
            resize(used+1);
            array[used-1] = (T*)obj;
        }

        T* pop() { 
            assert(used != 0);
            return array[--used];
        }

        T* top() const { 
            assert(used != 0);
            return array[used-1];
        }

        VectorVar(size_t reserve = 8) {
            used = 0;
            allocated = reserve;
            array = new T*[reserve];
        }

        ~VectorVar() {
            delete[] array;
        }

        virtual void mark(MemoryAllocator* allocator) { 
            allocator->_mark((Object**)array, used);
        }
    };
};    

#endif