allocator.h

Go to the documentation of this file.

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

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

#include <atomic>

namespace JASS
    {
    /*
        CLASS ALLOCATOR
        ---------------
    */
    class allocator
        {
        protected:
            #ifdef __aarch64__
                static constexpr size_t alignment_boundary = sizeof(void *);        
            #else
                static constexpr size_t alignment_boundary = 1;                         
            #endif
        protected:
            std::atomic<size_t> used;                       
            std::atomic<size_t> allocated;              

        public:
            /*
                ALLOCATOR::ALLOCATOR()
                ----------------------
            */
            allocator() :
                used(0),
                allocated(0)
                {
                }

            /*
                ALLOCATOR::~ALLOCATOR()
                -----------------------
            */
            virtual ~allocator()
                {
                /*
                    Nothing
                */
                }

            /*
                ALLOCATOR::OPERATOR==()
                -----------------------
            */
            virtual bool operator==(const allocator &with) = 0;
            
            /*
                ALLOCATOR::OPERATOR!=()
                -----------------------
            */
            virtual bool operator!=(const allocator &with) = 0;

            /*
                ALLOCATOR::MALLOC()
                -------------------
            */
            virtual void *malloc(size_t bytes, size_t alignment = alignment_boundary) = 0;
            
            /*
                ALLOCATOR::CAPACITY()
                ---------------------
            */
            size_t capacity(void) const
                {
                return allocated;
                }
            
            /*
                ALLOCATOR::SIZE()
                -----------------
            */
            size_t size(void) const
                {
                return used;
                }
            
            /*
                ALLOCATOR::REALIGN()
                --------------------
            */
            static size_t realign(const void *address, size_t boundary)
                {
                return realign((uintptr_t)address, boundary);
                }

            /*
                ALLOCATOR::REALIGN()
                --------------------
            */
            static size_t realign(uintptr_t current_pointer, size_t boundary)
                {
                /*
                    Compute the amount of padding that is needed to pad to a boundary of size alignment_boundary
                */
                size_t padding = (current_pointer % boundary == 0) ? 0 : boundary - current_pointer % boundary;

                /*
                    Return the number of bytes that must be addedd to address to make it aligned
                */
                return padding;
                }

            /*
                ALLOCATOR::REWIND()
                -------------------
            */
            virtual void rewind(void) = 0;
        };
}