dl_buffer_pool.h

浏览该文件的文档.

#pragma once
 
#include <vector>
#include <cassert>
 
namespace dl
{
    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;
}