tracking-allocator.hpp

Go to the documentation of this file.

/*
  TRACKING-ALLOCATOR.hpp  -  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.

* *****************************************************************/


#ifndef LIB_TEST_TRACKING_ALLOCATOR_H
#define LIB_TEST_TRACKING_ALLOCATOR_H

#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/nocopy.hpp"
#include "lib/hash-value.h"
#include "lib/test/event-log.hpp"
#include "lib/format-string.hpp"

#include <utility>
#include <memory>

using std::byte;


namespace lib {
namespace test {
  
  
  namespace {
    const Symbol GLOBAL{"GLOBAL"};
  }
  
  class MemoryPool;
  
  using PoolHandle = std::shared_ptr<MemoryPool>;
  
  
  
  class TrackingAllocator
    {
      PoolHandle mem_;
      
    public:
      TrackingAllocator();
      
      TrackingAllocator (Literal id);
      
      // standard copy operations acceptable
      
      using Location = void*;
      
      [[nodiscard]] Location allocate (size_t n);
      void deallocate (Location, size_t =0) noexcept;
      
      
      friend bool
      operator== (TrackingAllocator const& a1, TrackingAllocator const& a2)
      {
        return a1.mem_ == a2.mem_;
      }
      friend bool
      operator!= (TrackingAllocator const& a1, TrackingAllocator const& a2)
      {
        return not (a1 == a2);
      }
      
      
      /* ===== Diagnostics ===== */
      
      bool manages (Location)  const;
      size_t getSize(Location) const;
      HashVal getID (Location) const;
      Literal poolID ()        const;
      
      static HashVal checksum (Literal pool =GLOBAL);
      static size_t use_count (Literal pool =GLOBAL);
      static size_t numAlloc  (Literal pool =GLOBAL);
      static size_t numBytes  (Literal pool =GLOBAL);
      
      static EventLog log;
    };
  
  
  template<typename TY>
  class TrackAlloc
    : public TrackingAllocator
    {
    public:
      using TrackingAllocator::TrackingAllocator;

      template<typename X>
      TrackAlloc (TrackAlloc<X> const& anchor)
        : TrackingAllocator{anchor}
        { }
      
      
      /* ===== C++ standard allocator interface ===== */
      
      using value_type = TY;
      
      // define that (non-equivalent) allocators migrate alongside on assignments....
      using propagate_on_container_copy_assignment = std::true_type; 
      using propagate_on_container_move_assignment = std::true_type; 
      using propagate_on_container_swap            = std::true_type; 
      
      
      [[nodiscard]] TY* allocate (size_t cnt);
      void deallocate (TY*, size_t) noexcept;
    };
  
  
  
  class TrackingFactory
    : public TrackingAllocator
    {
    public:
      using TrackingAllocator::TrackingAllocator;

      TrackingFactory (TrackingAllocator const& anchor)
        : TrackingAllocator{anchor}
        { }
      
      template<class TY, typename...ARGS>
      TY*
      create (ARGS&& ...args)
        {
          Location loc = allocate(sizeof(TY));
          log.call (poolID(),"create-"+util::typeStr<TY>(), std::forward<ARGS> (args)...);
          try {
              return new(loc) TY (std::forward<ARGS> (args)...);
            }
          catch (std::exception& mishap)
            {
              log.error (util::_Fmt{"CtorFail: type=%s, problem:%s"} % util::typeStr<TY>() % mishap.what());
              throw;
            }
          catch (...)
            {
              log.error ("CtorFail: unknown cause");
              throw;
            }
        }
      
      template<class TY>
      void
      dispose (TY* elm)  noexcept
        {
          if (not elm)
            {
              log.warn("dispose(nullptr)");
              return;
            }
          log.call (poolID(),"destroy-"+util::typeStr<TY>());
          elm->~TY();
          deallocate(elm, sizeof(TY));
        }
    };
  
  
  
  template<typename TY>
  TY*
  TrackAlloc<TY>::allocate (size_t cnt)
  {
    return static_cast<TY*> (TrackingAllocator::allocate (cnt * sizeof(TY)));
  }
  
  template<typename TY>
  void
  TrackAlloc<TY>::deallocate (TY* loc, size_t cnt) noexcept
  {
    TrackingAllocator::deallocate (loc, cnt * sizeof(TY));
  }
  
  
  
  
}} // namespace lib::test
#endif /*LIB_TEST_TRACKING_ALLOCATOR_H*/