context.h

/*
 * Copyright (c) 2021-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_CONTEXT_H
#define COOK_MEM_CONTEXT_H
 
#include <cstdint>
 
#include "config.h"
#include "mmaparena.h"
#include "logger.h"
#include "pool.h"
 
namespace cookmem
{
 
template<class Arena, class Logger, class TreeType = PtrRBTree, class T=void>
class MemContext
{
public:
    typedef MemContext<Arena, Logger, TreeType, T>  MemCtx;
    typedef MemPool<Arena, Logger, TreeType, T>     Pool;
 
    typedef typename Pool::size_type        size_type;
    typedef typename Pool::difference_type  difference_type;
    typedef typename Pool::value_type       value_type;
    typedef typename Pool::pointer          pointer;
    typedef typename Pool::const_pointer    const_pointer;
 
public:
    MemContext (Arena&          arena,
                Logger&         logger,
                std::uint8_t    paddingSize = DEFAULT_PADDING_SIZE)
    : m_arena (arena),
      m_logger (logger),
      m_pool (m_arena, m_logger, paddingSize)
    {
    }
 
    MemContext (MemCtx& other)
    : m_arena (other.getArena ()),
      m_logger (other.getLogger ()),
      m_pool (m_arena, m_logger, other.getPaddingSize ())
    {
    }
 
    virtual ~MemContext()
    {
    }
 
    inline T*
    allocate (size_type size) { return m_pool.allocate (size); }
 
    inline T*
    allocateAligned (size_type size, size_type alignment) { return m_pool.allocateAligned (size, alignment); }
 
    inline T*
    reallocate (T* ptr, size_type size) { return m_pool.reallocate (ptr, size); }
 
    inline T*
    callocate (size_type num, size_type size) { return m_pool.callocate (num, size); }
 
    inline void
    deallocate (T* ptr, size_type size = 0) { m_pool.deallocate (ptr, size); }
 
    inline void
    validate () { m_pool.validate (); }
 
    inline bool
    contains (T* ptr, bool checkUsed = false) { return m_pool.contains (ptr, checkUsed); }
 
    inline size_type
    getSize (T* ptr) { return m_pool.getUserSize (ptr); }
 
    inline void
    releaseAll () { m_pool.releaseAll (); }
 
    inline void
    releaseAllToSystem ()
    {
        m_pool.releaseAll ();
        m_arena.releaseAll ();
    }
 
    inline size_type
    getFootprintLimit () const { return m_pool.getFootprintLimit (); }
 
    inline void
    setFootprintLimit (size_type footprintLimit) { m_pool.setFootprintLimit (footprintLimit); }
 
    inline size_type
    getFootprint () const { return m_pool.getFootprint (); }
 
    inline size_type
    getMaxFootprint () const { return m_pool.getMaxFootprint (); }
 
    void
    setTrimEmptySegmentsInterval (size_type interval)
    {
        m_pool.setTrimEmptySegmentsInterval (interval);
    }
 
    size_type
    getTrimEmptySegmentsInterval () const
    {
        return m_pool.getTrimEmptySegmentsInterval ();
    }
 
    void
    setImmediateReleaseThreshold (size_type threshold)
    {
        m_pool.setImmediateReleaseThreshold (threshold);
    }
 
    size_type
    getImmediateReleaseThreshold () const
    {
        return m_pool.getImmediateReleaseThreshold ();
    }
 
    inline bool
    isStoringExactSize () const { return m_pool.isStoringExactSize (); }
 
    void
    setStoringExactSize (bool b) { m_pool.setStoringExactSize (b); }
 
    bool
    isPadding () const { return m_pool.isPadding (); }
 
    std::uint8_t
    getPaddingSize () const { return m_pool.getPaddingSize (); }
 
    std::uint8_t
    getPaddingByte () const { return m_pool.getPaddingByte (); }
 
    void
    setPaddingByte (std::uint8_t paddingByte) { m_pool.setPaddingByte (paddingByte); }
 
    inline Arena&
    getArena () { return m_arena;  }
 
    inline Logger&
    getLogger () { return m_logger;  }
 
    inline Pool&
    getPool () { return m_pool; }
 
private:
    Arena&      m_arena;
    Logger&     m_logger;
    Pool        m_pool;
};
 
template<class Arena, class Logger>
struct SimpleMemContainer
{
    Arena   arena;
    Logger  logger;
 
    SimpleMemContainer ()
    : arena (),
      logger ()
    {
    }
 
    virtual ~SimpleMemContainer ()
    {
    }
};
 
template<class Arena = MmapArena, class Logger = NoActionMemLogger, class TreeType = PtrRBTree, class T=void>
class SimpleMemContext : private SimpleMemContainer<Arena, Logger>, public MemContext<Arena, Logger, TreeType, T>
{
public:
    typedef SimpleMemContainer<Arena, Logger>   Container;
    typedef MemContext<Arena, Logger, TreeType, T>  MemCtx;
 
    typedef typename MemCtx::size_type          size_type;
    typedef typename MemCtx::difference_type    difference_type;
    typedef typename MemCtx::value_type         value_type;
    typedef typename MemCtx::pointer            pointer;
    typedef typename MemCtx::const_pointer      const_pointer;
 
public:
    SimpleMemContext (std::uint8_t paddingSize = DEFAULT_PADDING_SIZE)
    : Container (),
      MemCtx (Container::arena, Container::logger, paddingSize)
    {
    }
 
    SimpleMemContext (SimpleMemContext& other, bool shareArena)
    : Container (),
      MemCtx (shareArena ? other.getArena () : Container::arena,
              Container::logger,
              other.getPaddingSize ())
    {
    }
 
    virtual ~SimpleMemContext ()
    {
    }
};
 
template<class Arena, class Logger>
struct CachedMemContainer
{
    Arena               arena;
    CachedArena<Arena>  cachedArena;
    Logger              logger;
 
    CachedMemContainer ()
    : arena (),
      cachedArena (arena),
      logger ()
    {
    }
 
    virtual ~CachedMemContainer ()
    {
    }
};
 
template<class Arena = MmapArena, class Logger = NoActionMemLogger, class TreeType = PtrRBTree, class T = void>
class CachedMemContext : private CachedMemContainer<Arena, Logger>, public MemContext<CachedArena<Arena>, Logger, TreeType, T>
{
public:
    typedef CachedMemContainer<Arena, Logger>   Container;
    typedef MemContext<CachedArena<Arena>, Logger, TreeType, T> MemCtx;
 
    typedef typename MemCtx::size_type          size_type;
    typedef typename MemCtx::difference_type    difference_type;
    typedef typename MemCtx::value_type         value_type;
    typedef typename MemCtx::pointer            pointer;
    typedef typename MemCtx::const_pointer      const_pointer;
 
public:
    CachedMemContext (std::uint8_t paddingSize = DEFAULT_PADDING_SIZE)
    : Container (),
      MemCtx (Container::cachedArena, Container::logger, paddingSize)
    {
    }
 
    CachedMemContext (CachedMemContext& other, bool shareArena)
    : Container (),
      MemCtx (shareArena ? other.getArena () : Container::cachedArena,
              Container::logger,
              other.getPaddingSize ())
    {
    }
 
    virtual ~CachedMemContext ()
    {
    }
};
 
}   // namespace cookmem
 
#endif  // COOK_MEM_CONTEXT_H