BlockAllocator.hpp

Go to the documentation of this file.

/*
 * Original work Copyright (c) 2006-2009 Erin Catto http://www.box2d.org
 * Modified work Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef PLAYRHO_COMMON_BLOCKALLOCATOR_HPP
#define PLAYRHO_COMMON_BLOCKALLOCATOR_HPP
 
#include <PlayRho/Common/Settings.hpp>
 
namespace playrho {
 
    PLAYRHO_CONSTEXPR const std::size_t AllocatorBlockSizes[] =
    {
        16, 32, 64, 96, 128, 160, 192, 224, 256, 320, 384, 448, 512, 640,
    };
    
    class BlockAllocator
    {
    public:
        
        using size_type = std::size_t;
 
        static PLAYRHO_CONSTEXPR const auto ChunkSize = size_type{16 * 1024};
        
        static PLAYRHO_CONSTEXPR size_type GetMaxBlockSize() noexcept
        {
            return AllocatorBlockSizes[size(AllocatorBlockSizes) - 1];
        }
        
        static PLAYRHO_CONSTEXPR size_type GetChunkArrayIncrement() noexcept
        {
            return size_type{128};
        }
        
        BlockAllocator();
        
        BlockAllocator(const BlockAllocator& other) = delete;
 
        BlockAllocator(BlockAllocator&& other) = delete;
 
        ~BlockAllocator() noexcept;
        
        BlockAllocator& operator= (const BlockAllocator& other) = delete;
 
        BlockAllocator& operator= (BlockAllocator&& other) = delete;
 
        void* Allocate(size_type n);
 
        template <typename T>
        T* AllocateArray(size_type n)
        {
            return static_cast<T*>(Allocate(n * sizeof(T)));
        }
        
        void Free(void* p, size_type n);
        
        void Clear();
        
        auto GetChunkCount() const noexcept
        {
            return m_chunkCount;
        }
 
    private:
        struct Chunk;
        struct Block;
        
        size_type m_chunkCount = 0; 
        size_type m_chunkSpace = GetChunkArrayIncrement(); 
        Chunk* m_chunks; 
        Block* m_freeLists[size(AllocatorBlockSizes)]; 
    };
    
    template <typename T>
    inline void Delete(const T* p, BlockAllocator& allocator)
    {
        p->~T();
        allocator.Free(const_cast<T*>(p), sizeof(T));
    }
    
    struct BlockDeallocator
    {
        using size_type = BlockAllocator::size_type;
        
        BlockDeallocator() = default;
 
        PLAYRHO_CONSTEXPR inline BlockDeallocator(BlockAllocator* a, size_type n) noexcept:
            allocator{a}, nelem{n}
        {
            // Intentionally empty.
        }
        
        void operator()(void *p) noexcept
        {
            allocator->Free(p, nelem);
        }
        
        BlockAllocator* allocator; 
        size_type nelem; 
    };
    
    inline bool operator==(const BlockAllocator& a, const BlockAllocator& b)
    {
        return &a == &b;
    }
    
    inline bool operator!=(const BlockAllocator& a, const BlockAllocator& b)
    {
        return &a != &b;
    }
    
} // namespace playrho
 
#endif // PLAYRHO_COMMON_BLOCKALLOCATOR_HPP