memory_pool.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_MEMORY_POOL_H
#define YAZE_APP_GFX_MEMORY_POOL_H
 
#include <cstdint>
#include <memory>
#include <unordered_map>
#include <vector>
 
namespace yaze {
namespace gfx {
 
class MemoryPool {
 public:
  static MemoryPool& Get();
 
  void* Allocate(size_t size);
 
  void Deallocate(void* ptr);
 
  void* AllocateAligned(size_t size, size_t alignment);
 
  std::pair<size_t, size_t> GetMemoryStats() const;
 
  std::pair<size_t, size_t> GetAllocationStats() const;
 
  void Clear();
 
  struct MemoryBlock {
    void* data;
    size_t size;
    bool in_use;
    size_t alignment;
 
    MemoryBlock(void* d, size_t s, size_t a = 0)
        : data(d), size(s), in_use(false), alignment(a) {}
  };
 
 private:
  MemoryPool();
  ~MemoryPool();
 
  // Block size categories for common graphics operations
  static constexpr size_t kSmallBlockSize = 1024;  // 8x8 tiles, small palettes
  static constexpr size_t kMediumBlockSize =
      4096;  // 16x16 tiles, medium graphics
  static constexpr size_t kLargeBlockSize =
      16384;  // 32x32 tiles, large graphics
  static constexpr size_t kHugeBlockSize =
      65536;  // Graphics sheets, large buffers
 
  // Pre-allocated block pools
  std::vector<MemoryBlock> small_blocks_;
  std::vector<MemoryBlock> medium_blocks_;
  std::vector<MemoryBlock> large_blocks_;
  std::vector<MemoryBlock> huge_blocks_;
 
  // Allocation tracking
  std::unordered_map<void*, MemoryBlock*> allocated_blocks_;
  size_t total_allocations_;
  size_t total_deallocations_;
  size_t total_used_bytes_;
  size_t total_allocated_bytes_;
 
  // Helper methods
  MemoryBlock* FindFreeBlock(size_t size);
  void InitializeBlockPool(std::vector<MemoryBlock>& pool, size_t block_size,
                           size_t count);
  size_t GetPoolIndex(size_t size) const;
};
 
template <typename T>
class PoolAllocator {
 public:
  using value_type = T;
  using pointer = T*;
  using const_pointer = const T*;
  using reference = T&;
  using const_reference = const T&;
  using size_type = std::size_t;
  using difference_type = std::ptrdiff_t;
 
  PoolAllocator() = default;
  template <typename U>
  PoolAllocator(const PoolAllocator<U>&) {}
 
  pointer allocate(size_type n) {
    return static_cast<pointer>(MemoryPool::Get().Allocate(n * sizeof(T)));
  }
 
  void deallocate(pointer p, size_type) { MemoryPool::Get().Deallocate(p); }
 
  template <typename U>
  bool operator==(const PoolAllocator<U>&) const {
    return true;
  }
 
  template <typename U>
  bool operator!=(const PoolAllocator<U>&) const {
    return false;
  }
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_MEMORY_POOL_H