C++内存池

Love The Way You Lie 2024-03-30 09:08 26阅读 0赞

#### 一、内存池的介绍 ####

内存池简单说，是为了减少频繁使用 malloc/free new/delete 等系统调用，造成的性能损耗而设计的。当我们的程序需要频繁地申请和释放内存时，频繁地使用内存管理的系统调用可能会造成性能的瓶颈。内存池的思想是预先申请一大块内存来做一个内存池，之后把内存管理放在应用层执行，当内存池不足时再向系统申请内存，减少系统调用的开销。

我们知道malloc是标准库函数，真正的申请内存动作需要操作系统完成。所以由应用程序到操作系统就需要三层（应用层，标准库，操作系统）。内存池是专为应用程序提供的专属的内存管理器，它属于应用程序层。所以程序申请内存的时候就不需要通过标准库和操作系统，明显降低了开销。

![1c773bc600b0fea4b4f78cba785e8da5.png][]

#### 二、设计一个内存池 ####

内存池是一个一个的 block（内存块） 以链表的形式连接起来的。每一个 block 是一块大的内存，当内存池的大小不够分配时，就会向操作系统申请新的block 加入链表。然后在当前block内部，维护一个 freeSlots\_ 的链表来记录当前空闲内存单元的位置，该链表的每一项都是对象被释放后归还给内存池的空间。内存池刚创建时freeSlots\_ 是空的，之后随着用户创建对象，再将对象释放掉，这时候要把内存归还给内存池，怎么归还呢？就是把指向这个对象的内存的指针加到freeSlots\_ 链表的前面。

用户在创建对象的时候，先检查 freeSlots\_链表是否为空，不为空（表示有空闲内存）的时候直接取出一项作为分配出的空间，将该地址返回，并且将头信息里的空闲单元改成下一个空闲单元。如果 freeSlots\_链表为空（表示没有空闲内存），那就在当前 block 内取出一个 Slot\_ 大小的内存分配出去，如果 block 里面的内存已经使用完了呢？就向操作系统申请一个新的 block。内存池工作期间的内存只会增长，并不释放给操作系统。最后直到内存池销毁的时候，才把所有的 block delete 掉。

![87c45d3bc76d4a368d8571223d5bed5f.png][]

#### 三、实现 ####

我们模仿STL的**allocator** 来实现，先定义标准接口

memory.h

#ifndef MEMORY_POOL_H
    #define MEMORY_POOL_H
    
    #include <climits>
    #include <cstddef>
    
    template <typename T, size_t BlockSize = 4096>
    class MemoryPool
    {
    public:
      /* Member types */
      typedef T value_type;
      typedef T *pointer;
      typedef T &reference;
      typedef const T *const_pointer;
      typedef const T &const_reference;
      typedef std::size_t size_type;
      typedef std::ptrdiff_t difference_type;
      typedef std::false_type propagate_on_container_copy_assignment;
      typedef std::true_type propagate_on_container_move_assignment;
      typedef std::true_type propagate_on_container_swap;
    
      template <typename U>
      struct rebind
      {
        typedef MemoryPool<U> other;
      };
    
      /* Member functions */
      MemoryPool() noexcept;
      MemoryPool(const MemoryPool &memoryPool) noexcept;
      MemoryPool(MemoryPool &&memoryPool) noexcept;
      template <class U>
      MemoryPool(const MemoryPool<U> &memoryPool) noexcept;
    
      ~MemoryPool() noexcept;
    
      MemoryPool &operator=(const MemoryPool &memoryPool) = delete;
      MemoryPool &operator=(MemoryPool &&memoryPool) noexcept;
    
      pointer address(reference x) const noexcept;
      const_pointer address(const_reference x) const noexcept;
    
      // Can only allocate one object at a time. n and hint are ignored
      pointer allocate(size_type n = 1, const_pointer hint = 0);
      void deallocate(pointer p, size_type n = 1);
    
      size_type max_size() const noexcept;
    
      template <class U, class... Args>
      void construct(U *p, Args &&... args);
      template <class U>
      void destroy(U *p);
    
      template <class... Args>
      pointer newElement(Args &&... args);
      void deleteElement(pointer p);
    
    private:
      union Slot_
      {
        value_type element;
        Slot_ *next;
      };
    
      typedef char *data_pointer_;
      typedef Slot_ slot_type_;
      typedef Slot_ *slot_pointer_;
    
      slot_pointer_ currentBlock_;
      slot_pointer_ currentSlot_;
      slot_pointer_ lastSlot_;
      slot_pointer_ freeSlots_;
    
      size_type padPointer(data_pointer_ p, size_type align) const noexcept;
      void allocateBlock();
    
      static_assert(BlockSize >= 2 * sizeof(slot_type_), "BlockSize too small.");
    };
    
    #endif // MEMORY_POOL_H

MemoryPool.cpp

#ifndef MEMORY_BLOCK_TCC
    #define MEMORY_BLOCK_TCC
    
    #include "MemoryPool.h"
    
    template <typename T, size_t BlockSize>
    inline typename MemoryPool<T, BlockSize>::size_type
    MemoryPool<T, BlockSize>::padPointer(data_pointer_ p, size_type align)
        const noexcept
    {
      uintptr_t result = reinterpret_cast<uintptr_t>(p);
      return ((align - result) % align);
    }
    
    template <typename T, size_t BlockSize>
    MemoryPool<T, BlockSize>::MemoryPool() noexcept
    {
      currentBlock_ = nullptr;
      currentSlot_ = nullptr;
      lastSlot_ = nullptr;
      freeSlots_ = nullptr;
    }
    
    template <typename T, size_t BlockSize>
    MemoryPool<T, BlockSize>::MemoryPool(const MemoryPool &memoryPool) noexcept : MemoryPool()
    {
    }
    
    template <typename T, size_t BlockSize>
    MemoryPool<T, BlockSize>::MemoryPool(MemoryPool &&memoryPool) noexcept
    {
      currentBlock_ = memoryPool.currentBlock_;
      memoryPool.currentBlock_ = nullptr;
      currentSlot_ = memoryPool.currentSlot_;
      lastSlot_ = memoryPool.lastSlot_;
      freeSlots_ = memoryPool.freeSlots;
    }
    
    template <typename T, size_t BlockSize>
    template <class U>
    MemoryPool<T, BlockSize>::MemoryPool(const MemoryPool<U> &memoryPool) noexcept : MemoryPool()
    {
    }
    
    template <typename T, size_t BlockSize>
    MemoryPool<T, BlockSize> &
    MemoryPool<T, BlockSize>::operator=(MemoryPool &&memoryPool) noexcept
    {
      if (this != &memoryPool)
      {
        std::swap(currentBlock_, memoryPool.currentBlock_);
        currentSlot_ = memoryPool.currentSlot_;
        lastSlot_ = memoryPool.lastSlot_;
        freeSlots_ = memoryPool.freeSlots;
      }
      return *this;
    }
    
    template <typename T, size_t BlockSize>
    MemoryPool<T, BlockSize>::~MemoryPool() noexcept
    {
      slot_pointer_ curr = currentBlock_;
      while (curr != nullptr)
      {
        slot_pointer_ prev = curr->next;
        operator delete(reinterpret_cast<void *>(curr));
        curr = prev;
      }
    }
    
    template <typename T, size_t BlockSize>
    inline typename MemoryPool<T, BlockSize>::pointer
    MemoryPool<T, BlockSize>::address(reference x)
        const noexcept
    {
      return &x;
    }
    
    template <typename T, size_t BlockSize>
    inline typename MemoryPool<T, BlockSize>::const_pointer
    MemoryPool<T, BlockSize>::address(const_reference x)
        const noexcept
    {
      return &x;
    }
    
    template <typename T, size_t BlockSize>
    void MemoryPool<T, BlockSize>::allocateBlock()
    {
      // Allocate space for the new block and store a pointer to the previous one
      data_pointer_ newBlock = reinterpret_cast<data_pointer_>(operator new(BlockSize));
      reinterpret_cast<slot_pointer_>(newBlock)->next = currentBlock_;
      currentBlock_ = reinterpret_cast<slot_pointer_>(newBlock);
      // Pad block body to staisfy the alignment requirements for elements
      data_pointer_ body = newBlock + sizeof(slot_pointer_);
      size_type bodyPadding = padPointer(body, alignof(slot_type_));
      currentSlot_ = reinterpret_cast<slot_pointer_>(body + bodyPadding);
      lastSlot_ = reinterpret_cast<slot_pointer_>(newBlock + BlockSize - sizeof(slot_type_) + 1);
    }
    
    template <typename T, size_t BlockSize>
    inline typename MemoryPool<T, BlockSize>::pointer
    MemoryPool<T, BlockSize>::allocate(size_type n, const_pointer hint)
    {
      if (freeSlots_ != nullptr)
      {
        pointer result = reinterpret_cast<pointer>(freeSlots_);
        freeSlots_ = freeSlots_->next;
        return result;
      }
      else
      {
        if (currentSlot_ >= lastSlot_)
          allocateBlock();
        return reinterpret_cast<pointer>(currentSlot_++);
      }
    }
    
    template <typename T, size_t BlockSize>
    inline void
    MemoryPool<T, BlockSize>::deallocate(pointer p, size_type n)
    {
      if (p != nullptr)
      {
        reinterpret_cast<slot_pointer_>(p)->next = freeSlots_;
        freeSlots_ = reinterpret_cast<slot_pointer_>(p);
      }
    }
    
    template <typename T, size_t BlockSize>
    inline typename MemoryPool<T, BlockSize>::size_type
    MemoryPool<T, BlockSize>::max_size()
        const noexcept
    {
      size_type maxBlocks = -1 / BlockSize;
      return (BlockSize - sizeof(data_pointer_)) / sizeof(slot_type_) * maxBlocks;
    }
    
    template <typename T, size_t BlockSize>
    template <class U, class... Args>
    inline void
    MemoryPool<T, BlockSize>::construct(U *p, Args &&... args)
    {
      new (p) U(std::forward<Args>(args)...);
    }
    
    template <typename T, size_t BlockSize>
    template <class U>
    inline void
    MemoryPool<T, BlockSize>::destroy(U *p)
    {
      p->~U();
    }
    
    template <typename T, size_t BlockSize>
    template <class... Args>
    inline typename MemoryPool<T, BlockSize>::pointer
    MemoryPool<T, BlockSize>::newElement(Args &&... args)
    {
      pointer result = allocate();
      construct<value_type>(result, std::forward<Args>(args)...);
      return result;
    }
    
    template <typename T, size_t BlockSize>
    inline void
    MemoryPool<T, BlockSize>::deleteElement(pointer p)
    {
      if (p != nullptr)
      {
        p->~value_type();
        deallocate(p);
      }
    }
    
    #endif // MEMORY_BLOCK_TCC

源码：

[https://github.com/cacay/MemoryPool][https_github.com_cacay_MemoryPool]

参考：

[内存池（memory pool）\_书笑生的博客-CSDN博客\_内存池][memory pool_-CSDN]

[C++11实现高效内存池 - nepu\_bin - 博客园][C_11_ - nepu_bin -]

[1c773bc600b0fea4b4f78cba785e8da5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/6c29a086c6684f8ba732ff719ea115fc.png
[87c45d3bc76d4a368d8571223d5bed5f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d08b4275405742e6b97a7e2cd3a3a85f.png
[https_github.com_cacay_MemoryPool]: https://github.com/cacay/MemoryPool
[memory pool_-CSDN]: https://blog.csdn.net/weixin_48101150/article/details/121336318
[C_11_ - nepu_bin -]: https://www.cnblogs.com/bincodes/p/15191716.html