loft.hh

Go to the documentation of this file.

 // This Source Code Form is licensed MPL-2.0: http://mozilla.org/MPL/2.0
#pragma once
 
#include <ase/cxxaux.hh>
 
namespace Ase {
 
namespace Loft {
 
enum Flags : size_t {
  PREFAULT_PAGES = 1,
};
 
} // Loft
 
struct LoftFree {
  size_t size = 0;
  void (*dtor_)     (void*) = nullptr;
  void   operator() (void*);
};
 
template<typename T>
using LoftPtr = std::unique_ptr<T,LoftFree>;
 
LoftPtr<void>   loft_alloc              (size_t size, size_t align = 0);
 
LoftPtr<void>   loft_calloc             (size_t nelem, size_t elemsize, size_t align = 0);
 
template<class T, class ...Args>
LoftPtr<T>      loft_make_unique        (Args &&...args);
 
size_t          loft_bucket_size        (size_t nbytes);
 
struct LoftConfig {
  size_t preallocate = 0;       
  size_t watermark = 0;         
  Loft::Flags flags = Loft::Flags (0);
};
 
void   loft_set_config       (const LoftConfig &config);
 
void   loft_get_config       (LoftConfig &config);
 
void   loft_set_notifier     (const std::function<void()> &lowmem);
 
void   loft_set_growth_notifier (const std::function<void(size_t total,size_t needed)> &willgrow);
 
size_t loft_grow_preallocate (size_t preallocation_amount = 0);
 
 
struct LoftStats {
  std::vector<std::pair<size_t,size_t>> buckets; // size,count
  size_t narenas = 0;           
  size_t available = 0;         
  size_t allocated = 0;         
  size_t maxchunk = 0;          
};
 
void      loft_get_stats    (LoftStats &stats);
 
String    loft_stats_string (const LoftStats &stats);
 
namespace Loft {
 
struct AllocatorBase {
protected:
  static void*  loft_btalloc    (size_t size, size_t align);
  static void   loft_btfree     (void *p, size_t size);
};
 
template<typename T>
class Allocator : AllocatorBase {
public:
  using value_type = T;
                   Allocator  () noexcept = default;
  template<typename U> Allocator  (const Allocator<U>& other) noexcept   {}
  bool                 operator== (const Allocator<T> &o) const noexcept { return true; }
  bool                 operator!= (const Allocator<T> &o) const noexcept { return !this->operator== (o); }
  constexpr void       deallocate (T *p, size_t n) const noexcept        { loft_btfree (p, n); }
  [[nodiscard]] constexpr T*
  allocate (std::size_t n) const
  {
    void *const mem = loft_btalloc (n * sizeof (T), alignof (T));
    if (!mem)
      throw std::bad_alloc();
    return reinterpret_cast<T*> (mem);
  }
  static constexpr bool allows_read_after_free = true;
};
 
} // Loft
 
// == implementations ==
template<class T, class ...Args> inline LoftPtr<T>
loft_make_unique (Args &&...args)
{
  LoftPtr<void> vp = loft_alloc (sizeof (T), alignof (T));
  if (!vp) return {};
  T *const t = new (vp.get()) T (std::forward<Args> (args)...);
  LoftFree lfree = vp.get_deleter();
  void *vptr = vp.release();
  ASE_ASSERT (t == vptr); // require T* == void*
  lfree.dtor_ = [] (void *p) {
    T *const t = static_cast<T*> (p);
    t->~T();
  };
  // dprintf (2, "--LOFT: %s: ctor: %s: size=%zd ptr=%p dtor_=%p\n", __func__, typeid_name<T>().c_str(), lfree.size, t, lfree.dtor_);
  return std::unique_ptr<T,LoftFree> (t, lfree);
}
 
} // Ase