mempool.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstddef>
#include <algorithm>
#include <promeki/namespace.h>
#include <promeki/mutex.h>
#include <promeki/string.h>
#include <promeki/map.h>
#include <promeki/set.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MemPool {
        public:
                struct Stats {
                                size_t totalFree;          
                                size_t totalUsed;          
                                size_t numFreeBlocks;      
                                size_t numAllocatedBlocks; 
                                size_t largestFreeBlock;   
                };
 
                class Block {
                        public:
                                bool     allocated = false; 
                                intptr_t address = 0;       
                                size_t   size = 0;          
                                size_t   alignment = 1;     
 
                                bool operator<(const Block &other) const { return address < other.address; }
 
                                uintptr_t alignedAddress(size_t align) const {
                                        uintptr_t _align = align - 1;
                                        return (address + _align) & ~(_align);
                                }
 
                                uintptr_t alignedAddress() const { return alignedAddress(alignment); }
 
                                size_t padding(size_t align) const {
                                        return align > 1 ? alignedAddress(align) - address : 0;
                                }
 
                                size_t padding() const { return padding(alignment); }
 
                                bool follows(const Block &block) const {
                                        return static_cast<uintptr_t>(block.address) + block.size ==
                                               static_cast<uintptr_t>(address);
                                }
                };
 
                static bool isValidAlignment(size_t val) { return (val > 0) && !(val & (val - 1)); }
 
                using BlockSet = ::promeki::Set<Block>;            
                using BlockMap = ::promeki::Map<uintptr_t, Block>; 
 
                MemPool();
 
                void addRegion(uintptr_t startingAddress, size_t size);
 
                void addRegion(void *startingAddress, size_t size) {
                        addRegion(reinterpret_cast<uintptr_t>(startingAddress), size);
                        return;
                }
 
                const String &name() const { return _name; }
 
                void setName(const String &val) {
                        _name = val;
                        return;
                }
 
                Stats stats() const;
 
                BlockSet memoryMap() const;
 
                void dump() const;
 
                void *allocate(size_t size, size_t alignment = 1);
 
                void free(void *ptr);
 
        private:
                String        _name;
                mutable Mutex _mutex;
                BlockSet      _freeBlocks;
                BlockMap      _allocatedBlocks;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE