arena.h

/*
 * Copyright (c) 2018-2026 Heng Yuan
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef COOK_MEM_ARENA_H
#define COOK_MEM_ARENA_H
 
#include <cstddef>
#include <cstdint>
 
#include "config.h"
#include "rbtree.h"
 
namespace cookmem
{
 
class MemArena
{
public:
    virtual ~MemArena() {}
 
    virtual void*
    getSegment (std::size_t& size) = 0;
 
    virtual bool
    freeSegment (void* ptr, std::size_t size) = 0;
 
    virtual void
    releaseAll () = 0;
};
 
class FixedArena
{
public:
    FixedArena (void* ptr, std::size_t size)
    : m_used (false)
    {
        const std::size_t mask = ALLOCATION_ALIGNMENT - 1;
        std::size_t remain = reinterpret_cast<std::uintptr_t> (ptr) & mask;
        if (remain)
        {
            std::size_t inc = ALLOCATION_ALIGNMENT - remain;
            m_page = static_cast<char*> (ptr) + inc;
            // A buffer smaller than the bytes skipped has no usable space.
            size = (size > inc) ? size - inc : 0;
        }
        else
        {
            m_page = ptr;
        }
        size &= ~mask;
        m_size = size;
    }
 
    void*
    getSegment (std::size_t& size)
    {
        if (m_used || size > m_size)
        {
            return NULL;
        }
        m_used = true;
        size = m_size;
        return m_page;
    }
 
    bool
    freeSegment (void* ptr, std::size_t size)
    {
        if (!m_used || ptr != m_page || size != m_size)
        {
            return true;
        }
        m_used = false;
        return false;
    }
 
    void
    releaseAll ()
    {
    }
 
private:
    void*       m_page;
    std::size_t m_size;
    bool        m_used;
};
 
template<class Arena, class TreeType = PtrRBTree>
class CachedArena
{
public:
    typedef TreeType   PtrTreeType;
public:
    CachedArena (Arena& arena)
    : m_arena (arena),
      m_tree ()
    {
    }
 
    ~CachedArena ()
    {
        releaseAll ();
    }
 
    CachedArena (const CachedArena&) = delete;
    CachedArena& operator= (const CachedArena&) = delete;
 
    void*
    getSegment (std::size_t& size)
    {
        void* seg = m_tree.remove(size);
        if (seg)
        {
            return seg;
        }
        return m_arena.getSegment(size);
    }
 
    bool
    freeSegment (void* ptr, std::size_t size)
    {
        m_tree.add (ptr, size);
        return false;
    }
 
    void
    releaseAll ()
    {
        for (;;)
        {
            std::size_t size = 0;
            void* seg = m_tree.remove (size);
            if (seg == nullptr)
            {
                break;
            }
            m_arena.freeSegment (seg, size);
        }
    }
 
private:
    Arena&      m_arena;
    PtrTreeType m_tree;
};
 
 
}   // namespace cookmem
 
#endif  // COOK_MEM_ARENA_H