allocation-cluster.cpp

Go to the documentation of this file.

/*
  AllocationCluster  -  allocating and owning a pile of objects

   Copyright (C)
     2008,            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/allocation-cluster.hpp"
#include "lib/linked-elements.hpp"
#include "lib/format-string.hpp"
#include "lib/util-quant.hpp"
#include "lib/util.hpp"


using util::unConst;
using util::isPow2;
using util::isnil;
using util::_Fmt;
using std::byte;


namespace lib {
  namespace {// Internals...
    
    struct PolicyInvokeDtor
      : lib::linked_elements::NoOwnership
      {
        template<class X>
        void
        dispose (X* elm)
          {
            REQUIRE (elm);
            elm->~X();
          }
      };

  }//(End)configuration and internals
  
  
  
  
  
  class AllocationCluster::StorageManager
    {
      
      using Destructors = lib::LinkedElements<Destructor, PolicyInvokeDtor>;
      
      struct Extent
        : util::NonCopyable
        {
          Extent* next;
          Destructors dtors;
          std::byte storage[max_size()];
        };
      using Extents = lib::LinkedElements<Extent>;
      
      static_assert (sizeof(Destructors) == sizeof(void*));
      static_assert (sizeof(Extents)     == sizeof(void*));
      
      union ManagementView
        {
          Storage storage;
          Extents extents;
        };         //Note: storage.pos and extents.head_ reside at the same location
      
      ManagementView view_;
      
      StorageManager()  = delete;    
      
    public:
      static StorageManager&
      access (AllocationCluster& clu)
        {
          return reinterpret_cast<StorageManager&> (clu);
        }
      
      void
      addBlock()
        {
          closeCurrentBlock();
          prependNextBlock();
        }
      
      void
      discardAll()
        {
          closeCurrentBlock();
          view_.extents.clear();
        }
      
      void
      attach (Destructor& dtor)
        {
          getCurrentBlockStart()->dtors.push (dtor);
        }
      
      
      bool
      empty()  const
        {
          return nullptr == view_.storage.pos;
        }
      
      size_t
      determineExtentCnt()  const
        {
          return empty()? 0
                        : lib::asLinkedElements (getCurrentBlockStart())
                              .size();
        }
      
      size_t
      calcAllocInCurrentBlock()  const
        {
          ENSURE (max_size() >= view_.storage.rest);
          return max_size() - view_.storage.rest;
        }
      
      
    private:
      Extent*
      getCurrentBlockStart()  const
        {
          REQUIRE (not empty());
          void* pos = static_cast<byte*>(view_.storage.pos)
                                       + view_.storage.rest
                                       - EXTENT_SIZ;
          return static_cast<Extent*> (pos);
        }
      
      void
      closeCurrentBlock()
        {
          if (empty()) return;
          // relocate the pos-pointer to the start of the block
          view_.storage.pos = getCurrentBlockStart();
          view_.storage.rest = 0;
        }
      
      void
      prependNextBlock()
        {
          view_.extents.emplace();
          view_.storage.pos = & view_.extents.top().storage;
          view_.storage.rest = max_size();
        }
    };
  
  
  
  
  
  AllocationCluster::AllocationCluster()
    : storage_{}
    {
      TRACE (memory, "new AllocationCluster");
    }
  
  
  AllocationCluster::~AllocationCluster()  noexcept
  try
    {
      TRACE (memory, "shutting down AllocationCluster");
      StorageManager::access(*this).discardAll();
    }
  ERROR_LOG_AND_IGNORE (progress, "discarding AllocationCluster")
  
  
  
  AllocationCluster::Destructor::~Destructor() { };
  
  
  
  void
  AllocationCluster::expandStorage (size_t allocRequest)
  {
    ENSURE (allocRequest <= max_size());
    StorageManager::access(*this).addBlock();
  }
  
  
  void
  AllocationCluster::registerDestructor (Destructor& dtor)
  {
    StorageManager::access(*this).attach (dtor);
  }
  
  
  
  void
  AllocationCluster::__enforce_limits (size_t allocSiz, size_t align)
  {
    REQUIRE (allocSiz);
    REQUIRE (align);
    REQUIRE (isPow2 (align));
    
    if (allocSiz > max_size())
      throw err::Fatal{_Fmt{"AllocationCluster: desired allocation of %d bytes "
                            "exceeds the fixed extent size of %d"} % allocSiz % max_size()
                      ,LERR_(CAPACITY)};
    
    if (align > max_size())
      throw err::Fatal{_Fmt{"AllocationCluster: data requires alignment at %d bytes, "
                            "which is beyond the fixed extent size of %d"} % align % max_size()
                      ,LERR_(CAPACITY)};
  }
  
  
  
  /* === diagnostics helpers === */
  
  size_t
  AllocationCluster::numExtents()  const
  {
    return StorageManager::access (unConst(*this)).determineExtentCnt();
  }

  size_t
  AllocationCluster::numBytes()  const
  {
    size_t extents = numExtents();
    if (not extents) return 0;
    size_t bytes = StorageManager::access (unConst(*this)).calcAllocInCurrentBlock();
    return (extents - 1) * max_size() + bytes;
  }
  
  
} // namespace lib