gc++.cxx

#include <gc++.hpp>
#include <common.hpp>
#include <fixed_size_allocator.hpp>
#include <detail/gc++.hpp>
#include <algorithm>
#include <boost/detail/atomic_count.hpp>

using namespace GCpp;
using namespace std;

namespace
{

GCPP_MUTEX pointer_list_mutex;

boost::detail::atomic_count pause_counter (0);

} // anonymous namespace

GCPP_MUTEX GCpp::create_allocator_mutex;

IntrusiveList<GCBasePointer> GCPointerManager::f_pointers;
size_t GCPointerManager::f_size (0);

GCBasePointer::GCBasePointer (void* p_storage)
: f_storage (p_storage),
  f_state (unknown_tag)
{
    GCPointerManager::register_pointer (this);
}

GCBasePointer::GCBasePointer (const GCBasePointer& p_other)
: f_storage (p_other.f_storage),
  f_state (unknown_tag)
{
    GCPointerManager::register_pointer (this);
}

GCBasePointer::~GCBasePointer ()
{
    GCPointerManager::forget_pointer (this);
    f_storage = 0;
}

char GCBasePointer::fetch_state ()
{
    return FixedSizeAllocatorManager::contains (this) ? leaf_tag : root_tag;
}

void GCBasePointer::mark ()
{
    GC::mark_recursively (this);
}

GCPointerManager::iterator GCPointerManager::begin ()
{
    return f_pointers.begin ();
}

GCPointerManager::iterator GCPointerManager::end ()
{
    return f_pointers.end ();
}

void GCPointerManager::register_pointer (GCBasePointer* p_item)
{
    GCPP_LOCK lck (pointer_list_mutex);
    f_pointers.push_back (p_item);
}

void GCPointerManager::forget_pointer (GCBasePointer* p_item)
{
    GCPP_LOCK lck (pointer_list_mutex);
    f_pointers.remove (p_item);
}

bool GCPointerManager::is_pointer (void* p_item)
{
    return find (f_pointers.begin (), f_pointers.end (), p_item) != f_pointers.end ();
}

size_t GCPointerManager::size ()
{
    return f_size;
}

GC_pause::GC_pause ()
{
    ++pause_counter;
    GC::stop ();
}

GC_pause::~GC_pause ()
{
    if (--pause_counter == 0)
        GC::start ();
}

---