203 lines
4.3 KiB
C++
203 lines
4.3 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{}
|
|
{
|
|
}
|
|
~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)
|
|
{
|
|
std::lock_guard guard{ _mutex };
|
|
if (_memFree.empty())
|
|
return (std::byte*)malloc(size);
|
|
else
|
|
{
|
|
std::byte* ret = _memFree.top();
|
|
_memFree.pop();
|
|
return ret;
|
|
}
|
|
}
|
|
void Put(std::byte* p)
|
|
{
|
|
std::lock_guard guard{ _mutex };
|
|
_memFree.push(p);
|
|
}
|
|
std::stack<std::byte*> _memFree;
|
|
std::mutex _mutex;
|
|
};
|
|
std::array<Node, 16> _allNode;
|
|
};
|
|
|
|
extern BufferPool g_bufferPool;
|
|
} |