Аллокатор памяти, ошибка Fatal glibc error: malloc assertion failure in sysmalloc

#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <timer.h>
#include <linearallocator.h>
 
struct ass_i;
 
const long ALL = 400;
LinearAllocator<ass_i> *_alloc = new LinearAllocator<ass_i>(ALL);
 
struct ass_i
{
    int a{};
    double dub{};
    void *operator new(size_t v) noexcept
    {
        return _alloc->allocate(&v);//malloc(v);
    }
 
    void operator delete(void *v)
    {
        _alloc->deallocate(static_cast<ass_i*>(v),16);
    }
};
 
int main()
{
    std::vector<ass_i*> _vec{};
    while(true)
    {
        Timer t;
        for (long x = 0 ; x < ALL ; x++)
        {
            ass_i *a = new ass_i();
            a->a = x;
            _vec.push_back(std::move(a));
        }
        _alloc->drop();
    }
 
    return 0;
}

#ifndef LINEARALLOCATOR_H
#define LINEARALLOCATOR_H
 
#include <cstdlib>
#include <iostream>
#include <ostream>
 
template <typename T>
class LinearAllocator
{
    void *chanck = nullptr;
    inline static long pos {};
 
public:
    using value_type = T;
    explicit LinearAllocator(long size)
    {
        chanck = new char[(sizeof(T) * size)];
        pos = 0;
        std::cout << (sizeof(T) * size) << " " << sizeof(chanck) << " " << pos << std::endl;
    }
    T* allocate(std::size_t *size)
    {
        T* ret = static_cast<T*>(::new(&chanck + (sizeof(T) * pos)) T());
        pos ++;
        //std::cout << "pos  " << pos << std::endl;
        return ret;
    }
    void deallocate(T* p,std::size_t)
    {
        delete p;
        //pos--;
    }
    void drop()
    {
        pos = 0;
    }
 
};
 
#endif // LINEARALLOCATOR_H

// C++ program for illustration
// of std::allocator() function
#include <iostream>
#include <memory>
using namespace std;
int main()
{
 
    // allocator for integer values
    allocator<int> myAllocator;
 
    // allocate space for five ints
    int* arr = myAllocator.allocate(5);
 
    // construct arr[0] and arr[3]
    // myAllocator.construct(arr, 100); // no longer allowed in C++20
    arr[0] = 100; // do this instead
    arr[3] = 10;
 
    cout << arr[3] << endl;
    cout << arr[0] << endl;
 
    // deallocate space for five ints
    myAllocator.deallocate(arr, 5);
 
    return 0;
}

    //main
    void* alloc = new char[1024];
    ass_i *a1 = ::new(&alloc) ass_i();
    ass_i *a2 = ::new(&alloc + sizeof(ass_i) ) ass_i();
    ass_i *a3 = ::new(&alloc + sizeof(ass_i) + sizeof(ass_i) ) ass_i();

#include <iostream>
#include <memory>
#include <type_traits>
#include <stdexcept>
#include <string>
 
template<class T>
concept TriviallyDestructible = std::is_trivially_destructible<T>::value;
 
template<class T>
   requires TriviallyDestructible<T>
class LinearAllocator{
public:
   explicit LinearAllocator(std::size_t elems) 
      :  capacity{elems}, 
         chunk{new char[sizeof(T)*elems]},
         p{(T*)chunk.get()},
         e{p + capacity}
   {}
   
   T* get(){
      if (p == e)
         throw std::length_error("LinearAllocator: limit reached");
      return ::new (p++) T{};
   }
   template<class... Args>
   T* get(Args... args){
      if ( p == e)
         throw std::length_error("LinearAllocator: limit reached");
      return ::new (p++) T{args...};
   }
   void clear(){
      p = (T*)chunk.get();
   }
private:
   const std::size_t capacity;
   std::unique_ptr<char[]> chunk;
   T *p, *e;
};
 
struct Item{
   int i;
   double d;
};
 
int main(){
   // LinearAllocator<std::string> LA_String(100); // compile error
   LinearAllocator<Item> items_allocator(100ULL);
   unsigned c = 100;
   while(c--){
      items_allocator.get();
   }
   
   // takes 101-th element
   try{
      items_allocator.get();
   }
   catch(const std::exception& e){
      std::cout << e.what() << std::endl;
   }
   
   items_allocator.clear();
   
   // try again
   c = 10;
   int i = 1;
   double d = 1.1;
   while(c--){
      auto p = items_allocator.get(i++, d*=2);
      std::cout << p->i << ' ' << p->d << std::endl;
   }
}

chunk{new (std::align_val_t(alignof(T))) char[sizeof(T)*elems]}

void* p = std::malloc(something);
// p уже максимально выровнен, потому что на этом этапе неизвестно для чего этот p будет применяться

#include <iostream>
#include <limits>
#include <memory>
#include <vector>
 
template<class T>
class TrackingAllocator
{
public:
    using value_type = T;
 
    using pointer = T *;
    using const_pointer = const T *;
 
    using size_type = size_t;
 
    TrackingAllocator() = default;
 
    template<class U>
    TrackingAllocator(const TrackingAllocator<U> &other) {}
 
    ~TrackingAllocator() = default;
 
    pointer allocate(size_type numObjects)
    {
        mAllocations += numObjects;
        return static_cast<pointer>(operator new(sizeof(T) * numObjects));
    }
 
    void deallocate(pointer p, size_type numObjects)
    {
        operator delete(p);
    }
 
    size_type get_allocations() const
    {
        return mAllocations;
    }
 
private:
    static size_type mAllocations;
};
 
template<class T>
typename TrackingAllocator<T>::size_type TrackingAllocator<T>::mAllocations = 0;
 
int main()
{
    std::vector<int, TrackingAllocator<int>> v(5);
    std::cout << v.get_allocator().get_allocations() << std::endl;
 
    return 0;
}

    pointer allocate(size_type numObjects)
    {
        mAllocations += numObjects;
        return static_cast<pointer>(operator new(sizeof(T) * numObjects));
    }

template <typename T>
class MyAlloc
{
public:
    typedef T value_type;
    char *aloc = new char[10000000 * sizeof(T)];
 
    MyAlloc()
    {
        std::cout << "size is " << 10000000 * sizeof(T) << std::endl;
    }
 
    T* allocate(std::size_t num)
    {
        //return static_cast<T*>(::operator new(num*sizeof(T)));
        std::cout << "alloc num " << num << std::endl;
        return static_cast<T*>(::operator new(num*sizeof(T)));
    }
 
    void deallocate(T* p, std::size_t num)
    {
       //delete (p);
    }
};

int main()
{
    const long SIZE_X = 1000;
    std::array<std::byte,SIZE_X> *adata = new std::array<std::byte,SIZE_X>();
    std::pmr::monotonic_buffer_resource memoryPool{adata->data(),adata->size()};
    //std::pmr::vector<long> _vec{&memoryPool};
 
    std::vector<long, MyAlloc<long>> _vec{};
 
    while(true)
    {
        Timer *t = new Timer();
        for (long z=0;z<SIZE_X;z++)
        {
            _vec.push_back(z);
        }
        t->~Timer();
 
    }
 
    return 0;
}