tracking-allocator.cpp

Go to the documentation of this file.

/*
  TrackingAllocator  -  custom allocator for memory management diagnostics
 
   Copyright (C)
     2024,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
* *****************************************************************/
 
 
#include "lib/test/tracking-allocator.hpp"
#include "lib/uninitialised-storage.hpp"
#include "lib/iter-explorer.hpp"
#include "lib/depend.hpp"
#include "lib/util.hpp"
 
 
#include <string>
#include <unordered_map>
 
using std::string;
using std::make_shared;
using std::make_pair;
using util::contains;
using util::joinDash;
using util::showAdr;
 
 
namespace lib {
namespace test{
  
  
  class MemoryPool
    : util::NonCopyable
    {
      // using the allocated memory location as key
      using Location = void*;
      struct LocationHash
        {
          HashVal operator() (Location const& loc) const { return HashVal(loc); }
        };
      
      struct Allocation
        : util::MoveOnly
        {
          UninitialisedDynBlock<byte> buff{};
          size_t entryID{0};
        };
      
      using AllocTab = std::unordered_map<const Location, Allocation, LocationHash>;
      
      
      Literal poolID_;
      AllocTab allocs_;
      HashVal checksum_;
      size_t entryNr_;
      
    public:
      MemoryPool (Literal id)
        : poolID_{id}
        , allocs_{}
        , checksum_{0}
        , entryNr_{0}
        { }
      
      Allocation& addAlloc (size_t bytes);
      void discardAlloc (void* loc, size_t);
      
      Allocation const* findAlloc (Location)  const;
      
      HashVal getChecksum()     const;
      size_t getAllocationCnt() const;
      size_t calcAllocSize()    const;
      
      Literal getPoolID()  const { return poolID_; }
    };
  
  
  namespace { // implementation details for common memory management
    
    /* === Logging primitives === */
    
    inline EventLog& log() { return TrackingAllocator::log; }
    
    template<typename...XS>
    inline void
    logAlarm (XS const& ...xs)
    {
      log().error (joinDash(xs...));
    }
    
    template<typename...ARGS>
    inline void
    logAlloc (Literal pool, string fun, ARGS const& ...args)
    {
      log().call (pool,fun,args...);
    }
    
    
    class PoolRegistry
      : util::NonCopyable
      {                                          // note: obsolete entries never discarded
        using PoolTab = std::unordered_map<Literal, std::weak_ptr<MemoryPool>>;
        
        PoolTab pools_{};
        
      public:
        static PoolHandle locate (Literal poolID);
        
      private:
        PoolHandle fetch_or_create (Literal poolID);
      };
    
    Depend<MemoryPool> globalPool;
    Depend<PoolRegistry> poolReg;
    
    
    PoolHandle
    PoolRegistry::locate (Literal poolID)
    {
      return poolReg().fetch_or_create (poolID);
    }
    
    
    PoolHandle
    PoolRegistry::fetch_or_create (Literal poolID)
    {
      auto& entry = pools_[poolID];
      auto handle = entry.lock();
      if (handle) return handle;
      
      // create a new pool and enrol it for given ID
      PoolHandle newPool = make_shared<MemoryPool> (poolID);
      entry = newPool;
      return newPool;
    }
  }//(End)Implementation memory pools and registration
  
  
  
  
  
  TrackingAllocator::TrackingAllocator()
    : mem_{PoolRegistry::locate(GLOBAL)}
    { }
  
  TrackingAllocator::TrackingAllocator (Literal id)
    : mem_{PoolRegistry::locate(id)}
    { }
  
  
  TrackingAllocator::Location
  TrackingAllocator::allocate (size_t bytes)
  {
    ENSURE (mem_);
    return mem_->addAlloc (bytes)
                    .buff.front();
  }
  
  void
  TrackingAllocator::deallocate (Location loc, size_t bytes) noexcept
  {
    ENSURE (mem_);
    mem_->discardAlloc (loc, bytes);
  }
  
  MemoryPool::Allocation&
  MemoryPool::addAlloc (size_t bytes)
  {
    Allocation newAlloc;
    newAlloc.buff.allocate (bytes);
    Location loc = newAlloc.buff.front();
    ASSERT (not contains (allocs_, loc));
    newAlloc.entryID = ++entryNr_;
    logAlloc (poolID_, "allocate", bytes, newAlloc.entryID, showAdr(loc));
    checksum_ += newAlloc.entryID * bytes;
    return allocs_.emplace (loc, move(newAlloc))
                  .first->second;
  }
  
  void
  MemoryPool::discardAlloc (Location loc, size_t bytes)
  {
    if (contains (allocs_, loc))
      {
        auto& entry = allocs_[loc];
        ASSERT (entry.buff);
        ASSERT (entry.buff.front() == loc);
        if (entry.buff.size() != bytes)     // *deliberately* tolerating wrong data, but log incident to support diagnostics
          logAlarm ("SizeMismatch", bytes, "≠", entry.buff.size(), entry.entryID, showAdr(loc));
        
        logAlloc (poolID_, "deallocate", bytes, entry.entryID, bytes, showAdr(loc));
        checksum_ -= entry.entryID * bytes;  // Note: using the given size (if wrong ⟿ checksum mismatch)
        allocs_.erase(loc);
      }
    else // deliberately no exception here (for better diagnostics)
      logAlarm ("FreeUnknown", bytes, showAdr(loc));
  }
  
  
  MemoryPool::Allocation const*
  MemoryPool::findAlloc (Location loc)  const
  {
    return contains (allocs_, loc)? & allocs_.at(loc)
                                  : nullptr;
  }
  
  
  HashVal
  MemoryPool::getChecksum()  const
  {
    return checksum_;
  }
  
  size_t
  MemoryPool::getAllocationCnt()  const
  {
    return allocs_.size();
  }
  
  size_t
  MemoryPool::calcAllocSize()  const
  {
    return explore(allocs_)
              .transform ([](auto& it){ return it->second.buff.size(); })
              .resultSum();
  }
  
  
  
  /* ===== Diagnostics ===== */
  
  EventLog TrackingAllocator::log{"test::TrackingAllocator"};
  
  
  HashVal
  TrackingAllocator::checksum (Literal poolID)
  {
    PoolHandle pool = PoolRegistry::locate (poolID);
    return pool->getChecksum();
  }
  
  size_t
  TrackingAllocator::use_count (Literal poolID)
  {
    PoolHandle pool = PoolRegistry::locate (poolID);
    return pool.use_count() - 1;
  }
  
  size_t
  TrackingAllocator::numAlloc  (Literal poolID)
  {
    PoolHandle pool = PoolRegistry::locate (poolID);
    return pool->getAllocationCnt();
  }
  
  size_t
  TrackingAllocator::numBytes  (Literal poolID)
  {
    PoolHandle pool = PoolRegistry::locate (poolID);
    return pool->calcAllocSize();
  }
  
  
  bool
  TrackingAllocator::manages (Location memLoc)  const
  {
    ENSURE (mem_);
    return bool(mem_->findAlloc (memLoc));
  }
  
  size_t
  TrackingAllocator::getSize(Location memLoc) const
  {
    ENSURE (mem_);
    auto* entry = mem_->findAlloc (memLoc);
    return entry? entry->buff.size()
                : 0;
  }
  
  HashVal
  TrackingAllocator::getID (Location memLoc) const
  {
    ENSURE (mem_);
    auto* entry = mem_->findAlloc (memLoc);
    return entry? entry->entryID
                : 0;
  }
  
  Literal
  TrackingAllocator::poolID()  const
  {
    ENSURE (mem_);
    return mem_->getPoolID();
  }
 
  
  
}} // namespace lib::test