simple-allocator.hpp

Go to the documentation of this file.

/*
  SIMPLE-ALLOCATOR.hpp  -  frontend for plain explicit allocations 

  Copyright (C)         Lumiera.org
    2011,               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_SIMPLE_ALLOCATOR_H
#define LIB_SIMPLE_ALLOCATOR_H

#include "lib/error.hpp"
#include "lib/meta/generator.hpp"
#include "lib/meta/typelist-util.hpp"
#include "lib/meta/util.hpp"
#include "lib/typed-counter.hpp"
#include "include/logging.h"

#include <boost/static_assert.hpp>
#include <memory>



namespace lib {
  
  using lib::meta::Types;
  using lib::meta::IsInList;
  using lib::meta::InstantiateForEach;
  
  
  
  /* === Policies for simple custom allocator  === */
  
  template<typename TY>
  class CustomAllocator
    : public std::allocator<TY>
    { };
  
  
  struct UseInstantiationCounting
    {
      template<class XX>
      size_t
      allocationCount()  const
        {
          return allocCnt_.get<XX>();
        }
      
      template<class XX>
      void
      incrementCount()
        {
          allocCnt_.inc<XX>();
        }
      
      template<class XX>
      void
      decrementCount()
        {
          allocCnt_.dec<XX>();
        }
      
    private:
      lib::TypedCounter allocCnt_;
    };
  
  struct NoInstantiationCount
    {
      template<class XX>  size_t allocationCount()  const { return 0; }
      template<class XX>  void    incrementCount()  { /* NOP */ }
      template<class XX>  void    decrementCount()  { /* NOP */ }
    };
    
  
  
  
  
  
  /* === Allocator frontend === */
  
  template<typename TYPES
          ,class COUNTER = NoInstantiationCount       
          >
  class SimpleAllocator
    : InstantiateForEach< typename TYPES::List     // for each of those types...
                        , CustomAllocator         //  ...mix in the custom allocator
                        >
    , COUNTER                                   // ...Instantiation accounting policy
    {
      
      template<class XX>
      XX *
      allocateSlot ()
        {
          TRACE (memory, "allocate «%s»", util::typeStr<XX>().c_str());
          XX * newStorage = CustomAllocator<XX>::allocate (1);
          COUNTER::template incrementCount<XX>();
          return newStorage;
        }
      
      template<class XX>
      void
      releaseSlot (XX* entry)
        {
          TRACE (memory, "release «%s»", util::typeStr<XX>().c_str());
          CustomAllocator<XX>::deallocate (entry, 1);
          COUNTER::template decrementCount<XX>();
        }
      
      
      template<class XX>
      void
      ___assertSupportedType()
        {
          typedef typename TYPES::List PreconfiguredTypes;
          typedef IsInList<XX, PreconfiguredTypes> IsSupportedType;
          
          BOOST_STATIC_ASSERT (IsSupportedType::value);
        }
      
      
      
      
      public: /* ==== build objects with managed allocation ==== */
      
#define _EXCEPTION_SAFE_INVOKE(_CTOR_)                      \
                                                             \
          ___assertSupportedType<XX>();                       \
          XX* storage = allocateSlot<XX>();                    \
          try                                                   \
            {                                                    \
              return (new(storage) _CTOR_ );                     \
            }                                                    \
          catch(...)                                             \
            {                                                    \
              releaseSlot<XX>(storage);                          \
              throw;                                             \
            }
      
      template< class XX>
      XX*                                                                              //_____________________
      create ()                                                                       
        {
          _EXCEPTION_SAFE_INVOKE ( XX() )
        }
      
      
      template< class XX, typename P1>
      XX*                                                                              //___________________
      create (P1& p1)                                                                 
        {
          _EXCEPTION_SAFE_INVOKE ( XX (p1) )
        }
      
      
      template< class XX
              , typename P1
              , typename P2
              >
      XX*                                                                              //___________________
      create (P1& p1, P2& p2)                                                         
        {
          _EXCEPTION_SAFE_INVOKE ( XX (p1,p2) )
        }
      
      
      template< class XX
              , typename P1
              , typename P2
              , typename P3
              >
      XX*                                                                              //___________________
      create (P1& p1, P2& p2, P3& p3)                                                 
        {
          _EXCEPTION_SAFE_INVOKE ( XX (p1,p2,p3) )
        }
      
      
      template< class XX
              , typename P1
              , typename P2
              , typename P3
              , typename P4
              >
      XX*                                                                              //___________________
      create (P1& p1, P2& p2, P3& p3, P4& p4)                                         
        {
          _EXCEPTION_SAFE_INVOKE ( XX (p1,p2,p3,p4) )
        }
      
      
      template< class XX
              , typename P1
              , typename P2
              , typename P3
              , typename P4
              , typename P5
              >
      XX*                                                                              //___________________
      create (P1& p1, P2& p2, P3& p3, P4& p4, P5& p5)                                 
        {
          _EXCEPTION_SAFE_INVOKE ( XX (p1,p2,p3,p4,p5) )
        }
      
#undef _EXCEPTION_SAFE_INVOKE
      
      
      
      template<class XX>
      void
      destroy (XX* entry)
        {
          if (!entry) return;
          ___assertSupportedType<XX>();
          try
            {
              entry->~XX();
            }
          catch(...)
            {
              lumiera_err errorID = lumiera_error();
              WARN (common_dbg, "dtor of «%s» failed: %s", util::typeStr(entry).c_str()
                                                         , errorID );
            }
          releaseSlot<XX> (entry);
        }
      
      
      template<class XX>
      size_t
      numSlots()  const
        {
          return COUNTER::template allocationCount<XX>();
        }
    };
  
  
  
  
} // namespace lib
#endif