custom_c++_operator_new2.cpp - custom allocator demo
Posted by Anonymous on Mon 15th Aug 2022 20:30
raw | new post
modification of post by Anonymous (view diff)

/*
 * custom_c++_operator_new2.cpp - custom allocator demo
 *
 * Written by Roland Mainz <roland.mainz@nrubsig.org>
 *
 * - Compile with:
 * $ clang++ -std=c++17 -g -Wall /home/rmainz/work/tlsf/try4/TLSF-2.4.6/src/tlsf.o custom_c++_operator_new2.cpp #
 *
 * - Watch TLSF-calls with:
 * $ ltrace -C -x '*' ./a.out #
 */

#define USE_STATIC_BUFFER_ALLOC 0
#define USE_TLSF_ALLOC 1
#define USE_LIBC_MALLOC 0

#define STATIC_BUFFER_ALLOC_BUFFER_SIZE (512)

#include <iostream>
#include <memory>
#include <limits>


/* required for |main()| test/demo code */
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>

#if USE_TLSF_ALLOC
extern "C" {
#include "/home/rmainz/work/tlsf/try4/TLSF-2.4.6/src/tlsf.h"
}
#endif /* USE_TLSF_ALLOC */

/* misc */
#define STDERR_MSG(msg) \
        (void)write(STDERR_FILENO, (msg), strlen(msg))


#if USE_STATIC_BUFFER_ALLOC
extern "C" {
static struct
{
        char buffer[STATIC_BUFFER_ALLOC_BUFFER_SIZE];
        /* more complex cases would require |pthread_once()| */
        char *buf_ptr = buffer;
} buf_alloc;

void *my_buffer_alloc(size_t size)
{
#define SIZE_ALIGN(size, align) \
        ((size)+((align)-1)-((size)-1)%(align))

        void *mem;
        size_t bs;

        STDERR_MSG("my_buffer_alloc\n");

        bs = SIZE_ALIGN(size, 16);

        mem = buf_alloc.buf_ptr;
        buf_alloc.buf_ptr += bs;

        /* could we satisfy the allocation request ? */
        if ((buf_alloc.buf_ptr - buf_alloc.buffer) >= sizeof(buf_alloc.buffer))
                return NULL;

#if 0
        (void)fprintf(stderr, "my_buffer_alloc(size=%ld, bs=%ld, mem=%lx\n",
                (long)size, (long)bs, (long)mem);
#endif

        return mem;
}

void my_buffer_dealloc(void *ptr)
{
        /*
         * range check - pointer must point within |buf_alloc.buffer|!
         *
         * We use this simple (and cheap) check to catch invalid
         * pointers, or (more important) pointers to memory from
         * other allocators (if we mix&match multiple different
         * allocators or different memory pools from the same
         * allocator system).
         */
        ptrdiff_t x = (char *)ptr - buf_alloc.buffer;
        if ((x < 0) || (x >= (ptrdiff_t)sizeof(buf_alloc.buffer))) {
                /* BUG: LAZY - we should not use stdio here... */
                (void)fprintf(stderr, "delete(): bad pointer %lx!\n", (long)x);
        }
}
} /* extern "C" */
#endif /* USE_STATIC_BUFFER_ALLOC */


void *
operator new(std::size_t size)
//     throw(std::bad_alloc)
{
        STDERR_MSG("##new\n");
        if (size == 0)
                size = 1;
        void* p;
#if USE_STATIC_BUFFER_ALLOC
        if ((p = my_buffer_alloc(size)) == 0)
#elif USE_TLSF_ALLOC
        if ((p = ::tlsf_malloc(size)) == 0)
#elif USE_LIBC_MALLOC
        if ((p = ::malloc(size)) == 0)
#else
#error No allocator library selected.
#endif /* USE_STATIC_BUFFER_ALLOC */
        {
                throw std::bad_alloc();
        }
        return p;
}


void
operator delete(void* ptr) _GLIBCXX_USE_NOEXCEPT
{
        STDERR_MSG("##delete\n");
#if USE_STATIC_BUFFER_ALLOC
        my_buffer_dealloc(ptr);
#elif USE_TLSF_ALLOC
        if (ptr)
                ::tlsf_free(ptr);
#elif USE_LIBC_MALLOC
        if (ptr)
                ::free(ptr);
#else
#error No allocator library selected
#endif /* USE_STATIC_BUFFER_ALLOC */
}


/*
 * static variables:
 * Their memory is allocated/constructor called before calling
 * |main()|, and their destructor is called and memory deallocated
 * after |main()| returned.
 * This causes some nasty headaches for custom |operator new|, e.g.
 * in case we want to rely on stdio, C++ iostream, or other
 * libc/libc++ modules. And don't even start to ask about headaches
 * related to STL and C++ exceptions...
 */
static int *s_f = new int(59);

static std::string s = "xjsdsqwertzuiopasdfghjklxcvbnm,poiuztrewlkjhgfdmnbvcxjsddljkjklsdfjklsddfljkx";


int main(int ac, char *av[])
{
        (void)puts("# >> main:start.");

        int *f = new int(84);


        std::string s = "13123123123122354245234534534534534534656456456456456456242342341233423423524542hello";
        s+=" ";
        s+="world";

        std::cout << s << "#" << *f << "," << *s_f << "#" << std::endl;

        delete f;

#if 0
        /* test if pointer validation of |my_buffer_dealloc()| works */
        delete (int *)malloc(5);
#endif

        (void)puts("# >> main:done.");
        return EXIT_SUCCESS;
}