一个 cpp 协程库的前世今生（二十四）对象池与栈内存池

template <typename ObjectType>class co_object_pool final : private co_noncopyable{private:    std::deque<void*> pool__;                                     // 内存池    co_spinlock       mu__ { co_spinlock::lock_type::in_thread }; // 互斥锁    size_t            max_cap__;                                  // 最大容量public:    co_object_pool(size_t max_cap); // 构造函数    template <typename... ConstructParam>    ObjectType* create_obj(ConstructParam&&... params); // 创建对象    void        destroy_obj(ObjectType* obj);           // 销毁对象    void        clear_free_object();                    // 清空空闲对象    ~co_object_pool();                                  // 析构函数};

template <typename ObjectType>co_object_pool<ObjectType>::co_object_pool(size_t max_cap)    : max_cap__(max_cap){}
template <typename ObjectType>template <typename... ConstructParam>ObjectType* co_object_pool<ObjectType>::create_obj(ConstructParam&&... params){    std::lock_guard<co_spinlock> lck(mu__);    void*                        mem = nullptr;    if (pool__.empty())    {        mem = std::aligned_alloc(alignof(ObjectType), sizeof(ObjectType));    }    else    {        mem = pool__.front();        pool__.pop_front();    }    assert(mem != nullptr);    return new (mem) ObjectType(std::forward<ConstructParam>(params)...);}
template <typename ObjectType>void co_object_pool<ObjectType>::destroy_obj(ObjectType* obj){    std::lock_guard<co_spinlock> lck(mu__);    obj->~ObjectType();    if (pool__.size() > max_cap__)    {        free(obj);    }    else    {        pool__.push_front(obj); // 尽快用到这块内存    }}
template <typename ObjectType>void co_object_pool<ObjectType>::clear_free_object(){    std::lock_guard<co_spinlock> lck(mu__);    for (auto& obj : pool__)    {        free(obj);    }    pool__.clear();}
template <typename ObjectType>co_object_pool<ObjectType>::~co_object_pool(){    clear_free_object();}

class co_stack final : private co_noncopyable{    co_byte* stack__;                          // 堆栈指针    size_t   size__;                           // 堆栈大小    co_stack(co_byte* ptr, size_t stack_size); // 构造函数public:    size_t   stack_size() const; // 堆栈大小    co_byte* stack() const;      // 堆栈指针    co_byte* stack_top() const;  // 堆栈顶部指针
    friend class co_object_pool<co_stack>;};

class co_mem_pool final : private co_noncopyable{private:    static unsigned long long         align_2_zone_edge__(unsigned long long 南市); // 对齐到zone边界    static unsigned long long         align_size__(unsigned long long size);        // 对齐到8字节    size_t                            get_zone_index__(size_t size) const;          // 获取zone的索引    co_spinlock                       mu__ { co_spinlock::lock_type::in_thread };   // 互斥锁    const size_t                      min_zone__;                                   // 最小zone    const size_t                      zone_count__;                                 // zone数量    const size_t                      max_cap__;                                    // 最大容量    std::vector<std::deque<co_byte*>> mem_pool__;                                   // 内存池public:    co_mem_pool(size_t min_zone, size_t zone_count, size_t max_cap); // 构造函数    co_byte* alloc_mem(size_t size);                                 // 分配内存    void     free_mem(co_byte* ptr, size_t size);                    // 释放内存    void     free_pool();                                            // 释放内存池    ~co_mem_pool();                                                  // 析构函数};

co_byte* co_mem_pool::alloc_mem(size_t size){    size_t zone_index = get_zone_index__(size);    if (zone_index >= zone_count__)    {        return reinterpret_cast<co_byte*>(std::aligned_alloc(sizeof(void*), align_size__(size)));    }
    std::lock_guard<co_spinlock> lock(mu__);    if (mem_pool__[zone_index].empty())    {        return reinterpret_cast<co_byte*>(std::aligned_alloc(sizeof(void*), 1 << (zone_index + min_zone__)));    }    auto ret = mem_pool__[zone_index].front();    mem_pool__[zone_index].pop_front();    return ret;}