allocation-cluster.hpp

Go to the documentation of this file.

/*
  ALLOCATION-CLUSTER.hpp  -  allocating and owning a pile of objects

  Copyright (C)         Lumiera.org
    2008,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#ifndef LIB_ALLOCATION_CLUSTER_H
#define LIB_ALLOCATION_CLUSTER_H

#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/sync-classlock.hpp"
#include "lib/scoped-holder.hpp"
#include "lib/scoped-holder-transfer.hpp"

#include <utility>
#include <vector>



namespace lib {
  
  
  class AllocationCluster
    : util::NonCopyable
    {
      
    public:
      AllocationCluster ();
     ~AllocationCluster ()  noexcept;
      
      
      template<class TY, typename...ARGS>
      TY&
      create (ARGS&& ...args)
        {
          TY* obj = new(allocation<TY>()) TY (std::forward<ARGS> (args)...);
          return commit(obj);
        }
      
      
      /* === diagnostics === */
      
      size_t size()  const;
      
      template<class TY>
      size_t count() const;
      
      
    private:
      template<class TY>
      void*
      allocation();
      
      template<class TY>
      TY&
      commit (TY* obj);
      
      
      struct TypeInfo;
      
      class MemoryManager;
      
      template<class TY>
      struct TypeSlot;
      
      static size_t maxTypeIDs;
      
      
      using HMemManager  = ScopedPtrHolder<MemoryManager>;
      using Allo         = Allocator_TransferNoncopyable<HMemManager>;
      using ManagerTable = std::vector<HMemManager,Allo>;
      
      ManagerTable typeHandlers_;  
      
      
      
      HMemManager&
      handler (size_t slot)
        {
          ASSERT (0<slot && slot<=typeHandlers_.size());
          return typeHandlers_[slot-1];
        }
      
      HMemManager const&
      handler (size_t slot)  const
        {
          ASSERT (0<slot && slot<=typeHandlers_.size());
          return typeHandlers_[slot-1];
        }
      
      void* initiateAlloc (size_t& slot);
      void* initiateAlloc (TypeInfo type, size_t& slot);
      
      void finishAlloc (size_t& slot, void*);
      
      size_t countActiveInstances (size_t& slot)  const;
    };
  
  
  
  
  
  //-----implementation-details------------------------
  
  struct AllocationCluster::TypeInfo
    {
      size_t allocSize;
      void (*killIt)(void*);  
      
      template<class TY>
      TypeInfo(TY*)
        : allocSize(sizeof(TY)),
          killIt(&TypeSlot<TY>::kill)
        { }
      
      TypeInfo()  
        : allocSize(0),
          killIt(0)
        { }  
    };
  
  
  
  template<class TY>
  struct AllocationCluster::TypeSlot
    {
      static size_t id_; 
      
      static size_t &
      get()
        {
          return id_; 
        }
      
      static TypeInfo
      setup()
        {
          ClassLock<AllocationCluster> guard;
          if (0 == id_)
            id_= ++maxTypeIDs;
          
          return TypeInfo ((TY*) 0 );
        }
      
      static void
      kill (void* obj)
        {
          TY* p = static_cast<TY*>(obj);
          ASSERT (p);
          ASSERT (INSTANCEOF (TY,p));
          p->~TY();
        }
      
    };
  
  
  template<class TY>
  size_t AllocationCluster::TypeSlot<TY>::id_;
  
  
  
  template<class TY>
  inline void*
  AllocationCluster::allocation()
  {
    void *mem = initiateAlloc (TypeSlot<TY>::get());
    if (not mem)
      mem = initiateAlloc (TypeSlot<TY>::setup(),TypeSlot<TY>::get());
    ENSURE (mem);
    return mem;
  }
  
  template<class TY>
  inline TY&
  AllocationCluster::commit (TY* obj)
  {
    REQUIRE (obj);
    finishAlloc (TypeSlot<TY>::get(), obj);
    return *obj;
  }
  
  
  template<class TY>
  size_t
  AllocationCluster::count()  const
  {
    return countActiveInstances (TypeSlot<TY>::get());
  }
  
  
  
} // namespace lib
#endif /*LIB_ALLOCATION_CLUSTER_H*/