Своя реализация malloc, calloc, realloc

static constexpr void * xmalloc(size_type nmemb, size_type size)
{    
        size_type new_size = nmemb * size;  
        if ((new_size == 0 ) || ((SIZE_MAX / nmemb) < size) || !(_HEAP_MAXREQ > new_size)) [[unlikely]] {return nullptr; }      
        return _malloca(new_size);
}
static constexpr void * xcalloc(size_type nmemb, size_type size)
{    
        void * newptr = xmalloc(nmemb, size);
        if(newptr)[[likely]]{
            size_type new_size = nmemb * size;
            memset(newptr, 0 , new_size);
            return newptr;
        }else return nullptr;
        
}
static constexpr void * xrealloc(void * ptr, size_type nmemb, size_type size)
{assert(ptr);
        void * newptr = xmalloc(nmemb, size);
        if(newptr)[[likely]]{
            if (newptr != ptr) {
                size_type new_size = nmemb * size;
                memcpy(newptr, ptr, new_size);
                return newptr;
            }return ptr;
        }else return nullptr;
}
 
***
где-то в конце _freea(buf)

    #undef _malloca
    #define _malloca(size)                                                                 \
        __pragma(warning(suppress: 6255 6386))                                             \
        (_MallocaComputeSize(size) != 0                                                    \
            ? (((_MallocaComputeSize(size) <= _ALLOCA_S_THRESHOLD)                         \
                ? _MarkAllocaS(_alloca(_MallocaComputeSize(size)), _ALLOCA_S_STACK_MARKER) \
                : _MarkAllocaS(malloc(_MallocaComputeSize(size)), _ALLOCA_S_HEAP_MARKER))) \
            : NULL)

#include <chrono>
//static auto start_time = std::chrono::steady_clock::now();
static auto start_time = std::chrono::high_resolution_clock::now();
 
inline void StartCounter()
{
 
     start_time = std::chrono::steady_clock::now();
     //start_time = std::chrono::high_resolution_clock::now();
}
inline double GetCounter()
{
 
    auto end_time = std::chrono::steady_clock::now();
    //auto end_time = std::chrono::high_resolution_clock::now();
    auto elapsed_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
    return elapsed_ns.count() ;
}
int main()
{
    wchar_t * arr = nullptr;
    double c = 0.0;
m:
for(size_t i = 0; i < 10000; i++)
{ 
    StartCounter();
    arr =   (wchar_t *)x_alloc.xmalloc(i+1, sizeof(wchar_t));
    x_alloc.xfree();
    c+=GetCounter();
 
}std::cout <<(c/10000.0) <<" "  << std::endl; c = 0.0;
 
for(size_t i = 0; i < 10000; i++)
{ 
    StartCounter();
    arr =   (wchar_t *)_aligned_malloc((i+1)*sizeof(wchar_t),alignment);
    _aligned_free(arr);
    c+=GetCounter();
 
}std::cout <<(c/10000.0) <<" "  << std::endl; c = 0.0;
 
    system("Pause");
    goto m;

pointer xmalloc(size_type nmemb, size_type size = t_size<value_type>)noexcept
{       
    size_type new_size = test_size (nmemb , size);  if(xalloc.error == err_allocate) [[unlikely]] { return nullptr; }
    
    if(xalloc.error == err_s)
    {
        xalloc.alloc_capacity=size_mem_buf;
        xalloc.alloc_free=size_mem_buf;
    }
    if (new_size < xalloc.alloc_free)[[likely]]
    {   
        xalloc.alloc_free-=new_size;
        if (xalloc.freeptr == nullptr) [[unlikely]]
        {
            xalloc.freeptr=buffer.ptr();
        }       
            newptr = xalloc.freeptr;
            xalloc.freeptr+=new_size;
            xalloc.alloc_size=new_size;
            xalloc.array_f=true;
            xalloc.error=allocate_ok;
    }
    else {
        if ((newptr = reinterpret_cast<pointer> (_aligned_malloc(new_size, alignment))) != nullptr)[[likely]]{
            xalloc.array_f=false;
            xalloc.error=allocate_ok;
            
        }else {xalloc.error=err_allocate; return nullptr; }
    }
    return newptr;      
}