memory_manager.hpp

#ifndef SRC_INC_MEMORY_MANAGER_HPP
#define SRC_INC_MEMORY_MANAGER_HPP

#include <fixed_size_allocator.hpp>
#include <intrusive_list.hpp>
#include <string>
#include <vector>

namespace GCpp
{

typedef void (*DestroyItem) (void*);

class GCPP_PUBLIC_SYMBOL MemoryAllocatorBase : protected FixedSizeAllocator
{
    public:
        MemoryAllocatorBase* next;
        
        MemoryAllocatorBase* prior;
        
    private:
        Byte f_status;
        
        size_t f_destroyed;
        
        size_t f_allocated;
        
        void* f_blocks;
        
        std::vector<size_t> f_offsets;
        
        void analyze (void* p_block);
        
        void mark_contained_pointers (void* p_block);
        
        void sweep ();
        
        void unmark ();
        
        void compact ()
        {
            FixedSizeAllocator::compact ();
        }
        
    protected:
        DestroyItem f_destroy_item;
    
    protected:
        MemoryAllocatorBase (size_t f_block_size);
        
    public:
        ~MemoryAllocatorBase ();
        
        size_t destroyed ()
        {
            return f_destroyed;
        }
        
        size_t allocated ()
        {
            return f_allocated;
        }
        
        void* malloc ();
    
        void* confirm (void* p_storage);
    
    friend class GC;
};

template <class T>
void destroy_item (void* p_item)
{
    static_cast<T*> (p_item)->~T ();
}

template <class T>
class MemoryAllocator : public MemoryAllocatorBase
{
    public:
        MemoryAllocator ()
        : MemoryAllocatorBase (sizeof (T))
        {
            f_destroy_item = destroy_item<T>;
        }
};

class GC
{
    private:
        static bool f_stop;
        
        static size_t f_allocated;
        
        static size_t f_threshold;
        
        static IntrusiveList<MemoryAllocatorBase> f_allocators;

        static void mark_recursively (void* p_pointer);
        
        static void mark (void* p_pointer);
        
        static void internal_collect ();
    
    public:
        static void start ();
        
        static void stop ();
        
        static void collect ();
        
        static bool stopped ();
        
        static size_t destroyed ();
        
        static size_t allocated ();
        
        static std::string version ();
        
        static size_t in_use ();
        
        static size_t threshold ();
        
        static void compact (bool p_new_limit=false);
        
        static void finalize ();
    
    friend class MemoryAllocatorBase;
    friend class GCBasePointer;
    friend Byte* OS_malloc (size_t p_size);
    friend void OS_free (Byte* p_block);
};

} // namespace GCpp

#endif /* SRC_INC_MEMORY_MANAGER_HPP */

---