logger.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_LOGGER_H
#define COOK_MEM_LOGGER_H
 
#include <cstddef>
#include <cstdio>
 
#include "exception.h"
 
namespace cookmem
{
 
typedef enum
{
    MEM_ALLOC_NONE,
    MEM_ALLOC_SMALL,
    MEM_ALLOC_TREE,
    MEM_ALLOC_DV,
    MEM_ALLOC_ARENA,
    MEM_ALLOC_BIG,
 
    MEM_ALLOC_COUNT
} MemAllocType_et;
 
class MemLogger
{
public:
    virtual ~MemLogger () { }
 
    virtual void
    logGetSegment (void* segment, std::size_t segmentSize) = 0;
 
    virtual void
    logFreeSegment (void* segment, std::size_t segmentSize) = 0;
 
    virtual void
    logTrimEmptySegments () = 0;
 
    virtual void
    logAllocation (void* userPtr, std::size_t userSize, MemAllocType_et allocType) = 0;
 
    virtual void
    logReallocation (void* userPtr, std::size_t oldUserSize, std::size_t newUserSize) = 0;
 
    virtual void
    logDeallocation (void* userPtr, std::size_t userSize) = 0;
 
    virtual void
    logError (void* userPtr, MemError_et error, const char* file = __FILE__, int line = __LINE__) = 0;
};
 
class NoActionMemLogger
{
public:
    NoActionMemLogger ()
    {
    }
 
    inline void logGetSegment (void*, std::size_t) { }
 
    inline void logFreeSegment (void*, std::size_t) { }
 
    inline void logTrimEmptySegments () { }
 
    inline void logAllocation (void*, std::size_t, MemAllocType_et) { }
 
    inline void logReallocation (void*, std::size_t, std::size_t) { }
 
    inline void logDeallocation (void*, std::size_t) { }
 
    inline void
    logError (void*,
              MemError_et error,
              const char* file = __FILE__,
              int line = __LINE__)
    {
        throw Exception (error, "memory corruption detected.", file, line);
    }
};
 
struct MemStatistics
{
public:
    MemStatistics ()
    : m_numAllocations (0),
      m_numDeallocations (0),
      m_numGetSegments (0),
      m_numFreeSegments (0),
      m_numTrimEmptySegments (0),
      m_totalAllocated (0),
      m_totalDeallocated (0),
      m_totalGetSegmentSize (0),
      m_totalFreeSegmentSize (0),
      m_currentAllocated (0),
      m_peakAllocated (0),
      m_currentSegments (0),
      m_peakSegments (0),
      m_currentSegmentSize (0),
      m_peakSegmentSize (0),
      m_numAllocationsByType {}
    {
    }
 
    std::size_t getNumAllocations () const { return m_numAllocations; }
    std::size_t getNumAllocations (MemAllocType_et allocType) const
    {
        return m_numAllocationsByType[allocType];
    }
    std::size_t getNumDeallocations () const { return m_numDeallocations; }
    std::size_t getNumGetSegments () const { return m_numGetSegments; }
    std::size_t getNumFreeSegments () const { return m_numFreeSegments; }
    std::size_t getNumTrimEmptySegments () const { return m_numTrimEmptySegments; }
    std::size_t getTotalAllocated () const { return m_totalAllocated; }
    std::size_t getTotalDeallocated () const { return m_totalDeallocated; }
    std::size_t getTotalGetSegmentSize () const { return m_totalGetSegmentSize; }
    std::size_t getTotalFreeSegmentSize () const { return m_totalFreeSegmentSize; }
    std::size_t getCurrentAllocated () const { return m_currentAllocated; }
    std::size_t getPeakAllocated () const { return m_peakAllocated; }
    std::size_t getCurrentSegments () const { return m_currentSegments; }
    std::size_t getPeakSegments () const { return m_peakSegments; }
    std::size_t getCurrentSegmentSize () const { return m_currentSegmentSize; }
    std::size_t getPeakSegmentSize () const { return m_peakSegmentSize; }
 
    // Internal use only.  These setters are used by StatsLogger.
    void setNumAllocations (std::size_t value) { m_numAllocations = value; }
    void setNumAllocations (MemAllocType_et allocType, std::size_t value)
    {
        m_numAllocationsByType[allocType] = value;
    }
    void setNumDeallocations (std::size_t value) { m_numDeallocations = value; }
    void setNumGetSegments (std::size_t value) { m_numGetSegments = value; }
    void setNumFreeSegments (std::size_t value) { m_numFreeSegments = value; }
    void setNumTrimEmptySegments (std::size_t value) { m_numTrimEmptySegments = value; }
    void setTotalAllocated (std::size_t value) { m_totalAllocated = value; }
    void setTotalDeallocated (std::size_t value) { m_totalDeallocated = value; }
    void setTotalGetSegmentSize (std::size_t value) { m_totalGetSegmentSize = value; }
    void setTotalFreeSegmentSize (std::size_t value) { m_totalFreeSegmentSize = value; }
    void setCurrentAllocated (std::size_t value) { m_currentAllocated = value; }
    void setPeakAllocated (std::size_t value) { m_peakAllocated = value; }
    void setCurrentSegments (std::size_t value) { m_currentSegments = value; }
    void setPeakSegments (std::size_t value) { m_peakSegments = value; }
    void setCurrentSegmentSize (std::size_t value) { m_currentSegmentSize = value; }
    void setPeakSegmentSize (std::size_t value) { m_peakSegmentSize = value; }
 
    void
    printStats () const
    {
        std::printf ("current allocations: %zu bytes, peak allocations: %zu bytes, "
                     "current segments: %zu (%zu bytes), peak segments: %zu (%zu bytes)\n",
                     m_currentAllocated,
                     m_peakAllocated,
                     m_currentSegments,
                     m_currentSegmentSize,
                     m_peakSegments,
                     m_peakSegmentSize);
        std::printf ("empty-segment trimming passes: %zu\n", m_numTrimEmptySegments);
 
        std::printf ("allocations by type:\n");
        for (std::size_t i = 0; i < MEM_ALLOC_COUNT; ++i)
        {
            std::printf ("  %s: %zu\n",
                         getAllocationTypeName (static_cast<MemAllocType_et> (i)),
                         m_numAllocationsByType[i]);
        }
    }
 
    static const char*
    getAllocationTypeName (MemAllocType_et allocType)
    {
        static const char* const names[MEM_ALLOC_COUNT] =
        {
            "none",
            "small",
            "tree",
            "dv",
            "arena",
            "big"
        };
        std::size_t index = static_cast<std::size_t> (allocType);
        return index < MEM_ALLOC_COUNT ? names[index] : "unknown";
    }
 
private:
    std::size_t m_numAllocations;
    std::size_t m_numDeallocations;
    std::size_t m_numGetSegments;
    std::size_t m_numFreeSegments;
    std::size_t m_numTrimEmptySegments;
    std::size_t m_totalAllocated;
    std::size_t m_totalDeallocated;
    std::size_t m_totalGetSegmentSize;
    std::size_t m_totalFreeSegmentSize;
    std::size_t m_currentAllocated;
    std::size_t m_peakAllocated;
    std::size_t m_currentSegments;
    std::size_t m_peakSegments;
    std::size_t m_currentSegmentSize;
    std::size_t m_peakSegmentSize;
    std::size_t m_numAllocationsByType[MEM_ALLOC_COUNT];
};
 
class StatsLogger
{
public:
    void
    logTrimEmptySegments ()
    {
        m_stats.setNumTrimEmptySegments (m_stats.getNumTrimEmptySegments () + 1);
    }
 
    void
    logGetSegment (void* segment, std::size_t segmentSize)
    {
        if (segment == nullptr)
        {
            return;
        }
        m_stats.setNumGetSegments (m_stats.getNumGetSegments () + 1);
        m_stats.setTotalGetSegmentSize (m_stats.getTotalGetSegmentSize () + segmentSize);
 
        std::size_t numSegments = m_stats.getCurrentSegments () + 1;
        std::size_t segmentSizeTotal = m_stats.getCurrentSegmentSize () + segmentSize;
        m_stats.setCurrentSegments (numSegments);
        m_stats.setCurrentSegmentSize (segmentSizeTotal);
        if (m_stats.getPeakSegments () < numSegments)
        {
            m_stats.setPeakSegments (numSegments);
        }
        if (m_stats.getPeakSegmentSize () < segmentSizeTotal)
        {
            m_stats.setPeakSegmentSize (segmentSizeTotal);
        }
    }
 
    void
    logFreeSegment (void* segment, std::size_t segmentSize)
    {
        if (segment == nullptr)
        {
            return;
        }
        m_stats.setNumFreeSegments (m_stats.getNumFreeSegments () + 1);
        m_stats.setTotalFreeSegmentSize (m_stats.getTotalFreeSegmentSize () + segmentSize);
        m_stats.setCurrentSegments (m_stats.getCurrentSegments () - 1);
        m_stats.setCurrentSegmentSize (m_stats.getCurrentSegmentSize () - segmentSize);
    }
 
    void
    logAllocation (void* userPtr, std::size_t userSize, MemAllocType_et allocType)
    {
        if (userPtr != nullptr)
        {
            m_stats.setNumAllocations (m_stats.getNumAllocations () + 1);
            m_stats.setTotalAllocated (m_stats.getTotalAllocated () + userSize);
            std::size_t currentAllocated = m_stats.getCurrentAllocated () + userSize;
            m_stats.setCurrentAllocated (currentAllocated);
            if (m_stats.getPeakAllocated () < currentAllocated)
            {
                m_stats.setPeakAllocated (currentAllocated);
            }
            m_stats.setNumAllocations (allocType,
                                       m_stats.getNumAllocations (allocType) + 1);
        }
    }
 
    void
    logReallocation (void* userPtr, std::size_t oldUserSize, std::size_t newUserSize)
    {
        if (userPtr != nullptr && newUserSize > oldUserSize)
        {
            std::size_t delta = newUserSize - oldUserSize;
            m_stats.setTotalAllocated (m_stats.getTotalAllocated () + delta);
            std::size_t currentAllocated = m_stats.getCurrentAllocated () + delta;
            m_stats.setCurrentAllocated (currentAllocated);
            if (m_stats.getPeakAllocated () < currentAllocated)
            {
                m_stats.setPeakAllocated (currentAllocated);
            }
        }
        else if (userPtr != nullptr)
        {
            std::size_t delta = oldUserSize - newUserSize;
            m_stats.setTotalDeallocated (m_stats.getTotalDeallocated () + delta);
            m_stats.setCurrentAllocated (m_stats.getCurrentAllocated () - delta);
        }
    }
 
    void
    logDeallocation (void* userPtr, std::size_t userSize)
    {
        if (userPtr != nullptr)
        {
            m_stats.setNumDeallocations (m_stats.getNumDeallocations () + 1);
            m_stats.setTotalDeallocated (m_stats.getTotalDeallocated () + userSize);
            m_stats.setCurrentAllocated (m_stats.getCurrentAllocated () - userSize);
        }
    }
 
    void
    logError (void*,
              MemError_et error,
              const char* file = __FILE__,
              int line = __LINE__)
    {
        throw Exception (error, "memory corruption detected.", file, line);
    }
 
    MemStatistics& getStats () { return m_stats; }
 
    const MemStatistics& getStats () const { return m_stats; }
 
private:
    MemStatistics m_stats;
};
 
}   // namespace cookmem
 
#endif  // COOK_MEM_LOGGER_H