Files
dl_old/dl/memory/dl_buffer_pool.h
T
2026-06-01 18:58:19 +08:00

198 lines
4.2 KiB
C++

/**
* @file dl_buffer_pool.h
* @brief buffer池
*
*
* @version 1.0
* @author lveyou
* @date 26-05-31
*
* @note 针对Buffer类的性能优化
*/
#pragma once
#include <vector>
#include <cassert>
namespace dl
{
//! Buffer池
class BufferPool
{
public:
// index、size仅做返回值(内存不会置0)
std::byte* Malloc(size_t new_size, size_t& index, size_t& size)
{
// 新大小所在index
size_t new_index = ToIndex(new_size);
index = new_index;
if (index == 16)
{// 需要的太大
size = new_size;
return (std::byte*)malloc(new_size);
}
size = ToSize(new_index);
return _allNode[index].Get(size);
}
// 传入旧地址、需求大小(不是2的幂)、所在index(返回新index),旧大小(返回新size)
// 保留旧内存值,新内存不置0
std::byte* Realloc(std::byte* p, size_t new_size, size_t& index, size_t& size)
{
assert(new_size > size);
assert(index <= 16);
// 新大小所在index
size_t new_index = ToIndex(new_size);
if (new_index == 16)
{// 需要的太大
if (index == 16)
{// 之前就是自由内存
size = new_size * 2;
return (std::byte*)realloc(p, size);
}
else
{// 之前是小内存
// 归还小内存,并且分配自由内存
_allNode[index].Put(p);
size_t old_size = size;
index = 16;
size = new_size;
std::byte* ret = (std::byte*)malloc(size);
memcpy(ret, p, old_size);
memset(ret + old_size, 0, size - old_size);
return ret;
}
}
// 新的是小内存
assert(index != 16 && index != new_index);// 之前不可能是自由内存 且不在同一空间
// 归还小内存,并且分配新的小内存(更大的)
_allNode[index].Put(p);
new_size = ToSize(new_index);
std::byte* ret = _allNode[new_index].Get(new_size);
memcpy(ret, p, size);
index = new_index;
size = new_size;
return ret;
}
void Free(std::byte* p, size_t index, size_t size)
{
if (index == 16)
{
free(p);
return;
}
_allNode[index].Put(p);
}
std::string Dump()
{
std::string ret = "--------------Buffer Pool--------------\n";
for (size_t i = 0; i < 16; ++i)
{
size_t size = ToSize(i);
std::string unit;
if (size < 1024)
unit = "byte";
else if(size < 1024 * 1024)
{
unit = "kb";
size /= 1024;
}
else
{
unit = "mb";
size /= 1024 * 1024;
}
ret += fmt::format("[{:02}] {:<3} {:<4} x {}\n", i, size, unit, _allNode[i]._memFree.size());
}
return ret;
}
size_t ToSize(size_t index)
{
switch (index)
{
case 0: return 256;
case 1: return 512;
case 2: return 1024;
case 3: return 2048;
case 4: return 4096;
case 5: return 8192;
case 6: return 16384;
case 7: return 32768;
case 8: return 65536;
case 9: return 131072;
case 10: return 262144;
case 11: return 524288;
case 12: return 1048576;
case 13: return 2097152;
case 14: return 4194304;
case 15: return 8388608;
default: return 0;
}
}
size_t ToIndex(size_t size)
{
if (size <= 256) return 0;
if (size <= 512) return 1;
if (size <= 1024) return 2;
if (size <= 2048) return 3;
if (size <= 4096) return 4;
if (size <= 8192) return 5;
if (size <= 16384) return 6;
if (size <= 32768) return 7;
if (size <= 65536) return 8;
if (size <= 131072) return 9;
if (size <= 262144) return 10;
if (size <= 524288) return 11;
if (size <= 1048576) return 12;
if (size <= 2097152) return 13;
if (size <= 4194304) return 14;
if (size <= 8388608) return 15;
return 16;
}
BufferPool()
{
_allNode.resize(16);
}
~BufferPool()
{
for (auto& iter : _allNode)
{
while (!iter._memFree.empty())
{
free(iter._memFree.top());
iter._memFree.pop();
}
}
}
private:
class Node
{
public:
std::byte* Get(size_t size)
{
if (_memFree.empty())
return (std::byte*)malloc(size);
else
{
std::byte* ret = _memFree.top();
_memFree.pop();
return ret;
}
}
void Put(std::byte* p)
{
_memFree.push(p);
}
std::stack<std::byte*> _memFree;
};
std::vector<Node> _allNode;
};
extern BufferPool g_bufferPool;
}