allocation-cluster.hpp

Go to the documentation of this file.

/*
  ALLOCATION-CLUSTER.hpp  -  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.
 
*/
 
#ifndef LIB_ALLOCATION_CLUSTER_H
#define LIB_ALLOCATION_CLUSTER_H
 
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
 
#include <type_traits>
#include <utility>
#include <memory>
 
 
 
namespace lib {
  namespace test { class AllocationCluster_test; } // declared friend for low-level-checks
  namespace err = lumiera::error;
  
  
  class AllocationCluster
    : util::MoveOnly
    {
      class StorageManager;
      
      struct Storage
        {
          void*  pos{nullptr};
          size_t rest{0};
          
          auto bytePos() { return static_cast<std::byte*> (pos); }
          
          void*
          allot (size_t bytes, size_t alignment)
            {
              void* loc = std::align (alignment, bytes, pos, rest);
              if (loc)
                { // requested allocation indeed fits in space
                  pos = bytePos() + bytes;
                  rest -= bytes;
                }
              return loc;
            }
          
          void adjustPos (int offset);
          bool hasReserve (int offset)  const;
          bool matches_last_allocation (void const* loc, size_t siz) const;
        };
      Storage storage_;
      
      
    public:
      AllocationCluster ();
     ~AllocationCluster ()  noexcept;
      
      static constexpr size_t EXTENT_SIZ = 256;
      static constexpr size_t max_size();
      
      
      /* === diagnostics === */
      size_t numExtents() const;
      size_t numBytes()   const;
      
      
      template<class TY, typename...ARGS>
      TY& create (ARGS&& ...);
      
      template<class TY, typename...ARGS>
      TY& createDisposable (ARGS&& ...);
      
      
      template<typename X>
      struct Allocator
        {
          using value_type = X;
          
          [[nodiscard]] X* allocate (size_t n)   { return mother_->allot<X>(n); }
          void deallocate (X*, size_t)  noexcept { /* rejoice */ }
          
          Allocator(AllocationCluster* m) : mother_{m} { }
          // standard copy acceptable
          template<typename T>
          Allocator(Allocator<T> const& o) : mother_{o.mother_} { }
          
          template<typename T>
          bool operator== (Allocator<T> const& o) const { return mother_ == o.mother_; }
          
          AllocationCluster* mother_;
        };
      
      template<typename X>
      Allocator<X> getAllocator() { return this; }
      
      
      bool canAdjust (void* loc, size_t oldSiz, size_t newSiz)  const;
      void doAdjust  (void* loc, size_t oldSiz, size_t newSiz);
      
    private:
      void*
      allotMemory (size_t bytes, size_t alignment)
        {
          __enforce_limits (bytes, alignment);
          void* loc = storage_.allot(bytes, alignment);
          if (loc) return loc;
          expandStorage (bytes);
          return allotMemory (bytes, alignment);
        }
      
      template<typename X>
      X*
      allot (size_t cnt =1)
        {
          return static_cast<X*> (allotMemory (cnt * sizeof(X), alignof(X)));
        }
      
      
      class Destructor
        : util::NonCopyable
        {
        public:
          virtual ~Destructor();    
          Destructor* next{nullptr};//   intrusive linked list...
        };
      
      template<typename X>
      struct AllocationWithDestructor
        : Destructor
        {
          X payload;
          
          template<typename...ARGS>
          AllocationWithDestructor (ARGS&& ...args)
            : payload(std::forward<ARGS> (args)...)
            { }
        };
      
      void expandStorage (size_t);
      void registerDestructor (Destructor&);
      void __enforce_limits (size_t,size_t);
      
      friend class test::AllocationCluster_test;
    };
  
  
  
  
  
  //-----implementation-details------------------------
  
  size_t constexpr
  AllocationCluster::max_size()
  {
    size_t ADMIN_OVERHEAD = 2 * sizeof(void*);
    return EXTENT_SIZ - ADMIN_OVERHEAD;
  }
 
  template<class TY, typename...ARGS>
  inline TY&
  AllocationCluster::createDisposable (ARGS&& ...args)
  {
    return * new(allot<TY>()) TY (std::forward<ARGS> (args)...);
  }
 
  template<class TY, typename...ARGS>
  inline TY&
  AllocationCluster::create (ARGS&& ...args)
  {
    if constexpr (std::is_trivial_v<TY>)
      return createDisposable<TY> (std::forward<ARGS> (args)...);
    
    using Frame = AllocationWithDestructor<TY>;
    auto& frame = createDisposable<Frame> (std::forward<ARGS> (args)...);
    registerDestructor (frame);
    return frame.payload;
  }
  
  
  inline void
  AllocationCluster::doAdjust(void* loc, size_t oldSiz, size_t newSiz)
  {
    if (not canAdjust (loc,oldSiz,newSiz))
      throw err::Invalid {"AllocationCluster: unable to perform this allocation adjustment."};
    storage_.adjustPos (int(newSiz) - int(oldSiz));
  }
  
  inline bool
  AllocationCluster::canAdjust(void* loc, size_t oldSiz, size_t newSiz)  const
  {
    int offset{int(newSiz) - int(oldSiz)};               // is properly limited iff oldSiz is correct
    return storage_.matches_last_allocation (loc, oldSiz)
       and storage_.hasReserve (offset);
  }
  
  inline void
  AllocationCluster::Storage::adjustPos (int offset)  
  {
    REQUIRE (pos);
    REQUIRE (hasReserve (offset));
    pos = bytePos() + offset;
    rest -= offset;
  }
  
  inline bool
  AllocationCluster::Storage::hasReserve (int offset)  const
  {
    return offset <= int(rest);
  }
  
  inline bool
  AllocationCluster::Storage::matches_last_allocation (void const* loc, size_t siz)  const
  {
    return loc == static_cast<std::byte const*> (pos) - siz;
  }
  
  
  
  
  
  //-----Policies-to-use-AllocationCluster------------------------
  
  namespace allo { // Setup for custom allocator policies
    
    // Forward declaration: configuration policy for lib::SeveralBuilder
    template<class I, class E, template<typename> class ALO>
    struct AllocationPolicy;
    
    template<template<typename> class ALO, typename...ARGS>
    struct SetupSeveral;
    
    template<>
    struct SetupSeveral<std::void_t, lib::AllocationCluster&>
      {
        template<typename X>
        using Adapter = AllocationCluster::template Allocator<X>;
        
        template<class I, class E>
        struct Policy
          : AllocationPolicy<I,E,Adapter>
          {
            using Base = AllocationPolicy<I,E,Adapter>;
            using Bucket = Base::Bucket;
            
            size_t static constexpr ALLOC_LIMIT = AllocationCluster::max_size();
            
            
            Policy (AllocationCluster& clu)
              : AllocationPolicy<I,E,Adapter> (clu.getAllocator<std::byte>())
              { }
            
            bool
            canExpand (Bucket* bucket, size_t request)
              {
                if (not bucket) return false;
                size_t currSize = bucket->getAllocSize();
                long delta = long(request) - long(bucket->buffSiz);
                return this->mother_->canAdjust (bucket,currSize, currSize+delta);
              }
            
            Bucket*
            realloc (Bucket* bucket, size_t cnt, size_t spread)
              {
                size_t request = cnt*spread;
                REQUIRE (request);
                if (not canExpand (bucket,request))
                  return Base::realloc (bucket,cnt,spread);
                
                size_t currSize = bucket->getAllocSize();
                size_t delta = request - bucket->buffSiz;
                this->mother_->doAdjust (bucket, currSize, currSize+delta);
                bucket->buffSiz += delta;
                ENSURE (bucket->buffSiz == request);
                return bucket;
              }
          };
      };
    //
  }//(End)Allocator configuration
  
  
} // namespace lib
#endif /*LIB_ALLOCATION_CLUSTER_H*/