FreeList.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Memory/Pool.h"

namespace honey { namespace lockfree
{


template<class T>
class FreeList : mt::NoCopy
{
    template<class> friend class FreeListAllocator;
public:
    typedef T value_type;
    typedef MemPool::Bucket::Handle Handle;
    typedef MemPool::Bucket::TaggedHandle TaggedHandle;
    
    FreeList(szt capacity = 0)                      : _pool({make_tuple(sizeof(T), capacity)}) {}
    
    void reserve(szt capacity)                      { _pool._buckets[0]->reserve(capacity); }
    szt capacity() const                            { return _pool._buckets[0]->_blockCount; }
    
    T* alloc()                                      { return static_cast<T*>(_pool.alloc(sizeof(T))); }
    template<class... Args>
    T* construct(Args&&... args)                    { return new (alloc()) T{forward<Args>(args)...}; }
    
    void free(T* ptr)                               { assert(ptr); _pool.free(ptr); }
    void destroy(T* ptr)                            { assert(ptr); ptr->~T(); free(ptr); }
    
    Handle handle(T* ptr) const                     { return ptr ? MemPool::Bucket::blockHeader(reinterpret_cast<uint8*>(ptr))->handle : nullptr; }
    T* deref(Handle handle) const                   { return reinterpret_cast<T*>(MemPool::Bucket::blockData(_pool._buckets[0]->deref(handle))); }
    
private:
    MemPool _pool;
};

template<class T>
class FreeListAllocator : public MemPoolAllocator<FreeListAllocator, T>
{
public:
    FreeListAllocator() = default;
    template<class U>
    FreeListAllocator(const FreeListAllocator<U>&) {}

    MemPool& pool()                                 { return _freeList._pool; }
    
private:
    FreeList<T> _freeList;
};

} }