allocator_pool.h

Go to the documentation of this file.

/*
    ALLOCATOR_POOL.H
    ----------------
    Copyright (c) 2016 Andrew Trotman
    Released under the 2-clause BSD license (See:https://en.wikipedia.org/wiki/BSD_licenses)
*/
#pragma once

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <assert.h>

#include <vector>
#include <mutex>

#ifdef __APPLE__
    #include <sys/mman.h>
    #include <mach/vm_statistics.h>
#endif

#include "allocator.h"

namespace JASS
    {
    template <typename TYPE> class dynamic_array;           // forward declare as its used in allocator_pool::_unittest()
    /*
        CLASS ALLOCATOR_POOL
        --------------------
    */
    class allocator_pool : public allocator
        {
        protected:
            static const size_t default_allocation_size = 1024 * 1024 * 128;            
            
        protected:
            size_t block_size;                  

#ifdef USE_CRT_MALLOC
        std::vector<void *> crt_malloc_list;    
        std::mutex mutex;                               
#endif

        protected:
            /*
                CLASS ALLOCATOR_POOL::CHUNK
                ---------------------------
            */
            class chunk
                {
                public:
                    std::atomic<uint8_t *> chunk_at;    
                    uint8_t *chunk_end;                 
                    chunk *next_chunk;                  
                    size_t chunk_size;                  
                    #ifdef WIN32
                        #pragma warning(push)           // Xcode thinks thinks a 0-sized entity in a class is OK, but Visual Studio kicks up a fuss (but does it anyway).
                        #pragma warning(disable : 4200)
                    #endif
                        uint8_t data[];                 
                    #ifdef WIN32
                        #pragma warning(pop)
                    #endif
            };

        protected:
            std::atomic<chunk *> current_chunk;         

        private:
            /*
                ALLOCATOR_POOL::ALLOCATOR_POOL()
                --------------------------------
            */
            allocator_pool(allocator_pool &) = delete;

            /*
                ALLOCATOR_POOL::OPERATOR=()
                ---------------------------
            */
            allocator_pool &operator=(const allocator_pool &) = delete;

        protected:
            /*
                ALLOCATOR_POOL::ALLOC()
                -----------------------
            */
            void *alloc(size_t size) const
                {
//              #ifdef __APPLE__
//                  /*
//                      If we're on OSX then use large pages (2MB) if we can. If mmap() fails then fall-back to malloc().
//                      mmap() failure can be either out of memory, or not enough pages of that size exist (i.e. fragmenation).
//                  */
//                  size_t block_size = 2 * 1024 * 1024;
//                  size = ((size + block_size - 1) / block_size) * block_size;
//                  auto got = ::mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, VM_FLAGS_SUPERPAGE_SIZE_2MB, 0);
//                  if (got == MAP_FAILED)
//                      return ::malloc((size_t)size);
//                  else
//                      return got;
//              #else
                    /*
                        On other operating systems we use malloc()
                    */
                    return ::malloc((size_t)size);
//              #endif
                }
            
            /*
                ALLOCATOR_POOL::DEALLOC()
                -------------------------
            */
            void dealloc(void *buffer) const
                {
                ::free(buffer);
                }
            
            /*
                ALLOCATOR_POOL::ADD_CHUNK()
                ---------------------------
            */
            chunk *add_chunk(size_t bytes);
            
        public:
            /*
                ALLOCATOR_POOL::ALLOCATOR_POOL()
                --------------------------------
            */
            allocator_pool(size_t block_size_for_allocation = default_allocation_size);

            /*
                ALLOCATOR_POOL::~ALLOCATOR_POOL()
                ---------------------------------
            */
            virtual ~allocator_pool();

            /*
                ALLOCATOR_POOL::OPERATOR==()
                ----------------------------
            */
            virtual bool operator==(const allocator &with)
                {
                try
                    {
                    /*
                        Downcast the parameter to an allocator_memory and see if it matches this.
                    */
                    auto other = dynamic_cast<const allocator_pool *>(&with);
                    return (used == other->size()) && (allocated == other->capacity()) && (current_chunk.load() == other->current_chunk.load());
                    }
                catch (...)
                    {
                    return false;
                    }
                }
            
            /*
                ALLOCATOR_POOL::OPERATOR!=()
                ----------------------------
            */
            virtual bool operator!=(const allocator &with)
                {
                try
                    {
                    /*
                        Downcast the parameter to an allocator_memory and see if it matches this.
                    */
                    auto other = dynamic_cast<const allocator_pool *>(&with);
                    return (used != other->size()) || (allocated != other->capacity()) || (current_chunk.load() != other->current_chunk.load());
                    }
                catch (...)
                    {
                    return false;
                    }
                }

            /*
                ALLOCATOR_POOL::MALLOC()
                ------------------------
            */
            virtual void *malloc(size_t bytes, size_t alignment = alignment_boundary);
            
            /*
                ALLOCATOR_POOL::REWIND()
                ------------------------
            */
            virtual void rewind(void);

            /*
                ALLOCATOR_POOL::UNITTEST_THREAD()
                ---------------------------------
            */
            static void unittest_thread(dynamic_array<uint8_t *> &answer, allocator_pool &memory, uint8_t bytes);

            /*
                ALLOCATOR_POOL::UNITTEST()
                --------------------------
            */
            static void unittest(void);
        };
}