mempool.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <algorithm>
#include <promeki/core/namespace.h>
#include <promeki/core/mutex.h>
#include <promeki/core/string.h>
#include <promeki/core/map.h>
#include <promeki/core/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 block.address + block.size == address;
                                }
 
                        };
 
                static bool isValidAlignment(size_t val) {
                        return (val > 0) && !(val & (val - 1));
                }
 
                using BlockSet = Set<Block>;        
                using BlockMap = 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