Merge pull request #1 from Icingworld/dev

Review the code

Author: Icingworld

memory-pool/include/CentralCache.h

@@ -5,14 +5,19 @@
 namespace WW
 {
 
+constexpr std::size_t MAX_ARRAY_SIZE = 208;     // 内存大小数组最大大小
+
 /**
  * @brief 中心缓存
  */
 class CentralCache
 {
+public:
+    using size_type = std::size_t;
+
 private:
-    PageCache & page_cache;                 // 页缓存
-    std::array<SpanList, 208> spans;        // 页段链表数组
+    PageCache & _Page_cache;                        // 页缓存
+    std::array<SpanList, MAX_ARRAY_SIZE> _Spans;    // 页段链表数组
 
 private:
     CentralCache();
@@ -22,7 +27,7 @@ class CentralCache
     CentralCache & operator=(const CentralCache &) = delete;
 
 public:
-    ~CentralCache();
+    ~CentralCache() = default;
 
 public:
     /**
@@ -32,30 +37,31 @@ class CentralCache
 
     /**
      * @brief 获取指定大小的空闲内存块
-     * @param index 索引
+     * @param size 内存块大小
      * @param count 个数
-     * @return 空闲内存块链表
+     * @return 成功时返回`FreeObject *`，失败时返回`nullptr`
      */
-    FreeObject * fetchRange(std::size_t index, std::size_t count);
+    FreeObject * fetchRange(size_type size, size_type count);
 
     /**
      * @brief 将空闲内存块归还到中心缓存
      * @param index 索引
      * @param free_object 空闲内存块链表
      */
-    void returnRange(std::size_t index, FreeObject * free_object);
+    void returnRange(size_type size, FreeObject * free_object);
 
 private:
     /**
-     * @brief 索引转换为块大小
+     * @brief 内存块大小转换为数组索引
      */
-    std::size_t indexToSize(std::size_t index) const noexcept;
+    static size_type sizeToIndex(size_type size) noexcept;
 
     /**
      * @brief 从自由表中获取一个空闲的页段
      * @param index 索引
+     * @return 成功时返回`Span *`，失败时返回`nullptr`
      */
-    Span * getFreeSpan(std::size_t index);
+    Span * getFreeSpan(size_type index);
 };
 
 } // namespace WW

memory-pool/include/FreeList.h

@@ -10,59 +10,128 @@ namespace WW
  */
 class FreeObject
 {
-public:
-    FreeObject * next;  // 下一个空闲内存块
+private:
+    FreeObject * _Next;  // 下一个空闲内存块
 
 public:
     FreeObject();
 
     explicit FreeObject(FreeObject * next);
 
-    ~FreeObject();
+    ~FreeObject() = default;
+
+public:
+    /**
+     * @brief 获取下一个空闲内存块
+     */
+    FreeObject * next() const noexcept;
+
+    /**
+     * @brief 设置下一个空闲内存块
+     */
+    void setNext(FreeObject * next) noexcept;
+};
+
+/**
+ * @brief 空闲内存块链表迭代器
+ */
+class FreeListIterator
+{
+private:
+    FreeObject * _Free_object;       // 空闲内存块指针
+
+public:
+    explicit FreeListIterator(FreeObject * free_object) noexcept;
+
+    ~FreeListIterator() = default;
+
+public:
+    /**
+     * @brief 迭代器是否相等
+     */
+    bool operator==(const FreeListIterator & other) const noexcept;
+
+    /**
+     * @brief 迭代器是否不相等
+     */
+    bool operator!=(const FreeListIterator & other) const noexcept;
+
+    /**
+     * @brief 解引用迭代器
+     * @details 对于内存块，解引用直接返回内存块地址
+     */
+    FreeObject * operator*() noexcept;
+
+    /**
+     * @brief 解引用迭代器
+     */
+    FreeObject * operator->() noexcept;
+
+    /**
+     * @brief 向后移动
+     */
+    FreeListIterator & operator++() noexcept;
+
+    /**
+     * @brief 向后移动
+     */
+    FreeListIterator operator++(int) noexcept;
 };
 
 /**
  * @brief 空闲内存块链表
+ * @details 单向链表
  */
 class FreeList
 {
+public:
+    using size_type = std::size_t;          // 内存块数量范围为0-65535，使用uint16_t存储
+    using iterator = FreeListIterator;
+
 private:
-    FreeObject * head;      // 链表头部，不是虚拟节点
-    std::size_t freesize;   // 空闲内存块数量
+    FreeObject * _Head;         // 虚拟头节点
+    size_type _Size;            // 空闲内存块数量
 
 public:
     FreeList();
 
+    ~FreeList();
+
 public:
     /**
      * @brief 获取链表头部元素
      */
-    FreeObject * front() const noexcept;
+    FreeObject * front() noexcept;
 
     /**
      * @brief 将空闲内存块插入到链表头部
      */
     void push_front(FreeObject * free_object);
 
     /**
-     * @brief 从链表头部取出空闲内存块
+     * @brief 从链表头部移除内存块
      */
     void pop_front();
 
     /**
-     * @brief 链表是否为空
+     * @brief 获取链表头部
      */
-    bool empty() const noexcept;
+    iterator begin() noexcept;
 
     /**
-     * @brief 清空链表
+     * @brief 获取链表尾部
      */
-    void clear();
+    iterator end() noexcept;
+
+    /**
+     * @brief 链表是否为空
+     */
+    bool empty() const noexcept;
 
     /**
      * @brief 获取空闲内存块数量
      */
-    std::size_t size() const noexcept;
+    size_type size() const noexcept;
 };
 
 } // namespace WW

memory-pool/include/PageCache.h

@@ -8,15 +8,20 @@
 namespace WW
 {
 
+constexpr std::uint8_t MAX_PAGE_COUNT = 128;    // 最大页数
+
 /**
  * @brief 页缓存
  */
 class PageCache
 {
+public:
+    using size_type = std::size_t;
+
 private:
-    std::array<SpanList, 128> spans;                    // 页段链表数组
-    std::unordered_map<std::size_t, Span *> span_map;   // 页号到页段的映射
-    std::recursive_mutex mutex;                         // 页缓存锁
+    std::array<SpanList, MAX_PAGE_COUNT> _Spans;        // 页段链表数组
+    std::unordered_map<size_type, Span *> _Span_map;    // 页号到页段指针的映射
+    std::recursive_mutex _Mutex;                        // 页缓存锁
 
 private:
     PageCache();
@@ -36,9 +41,10 @@ class PageCache
 
     /**
      * @brief 获取指定大小的页段
-     * @param page_count 页数
+     * @param count 页数
+     * @return 成功时返回`Span *`，失败时返回`nullptr`
      */
-    Span * fetchSpan(std::size_t page_count);
+    Span * fetchSpan(size_type count);
 
     /**
      * @brief 将页段归还到页缓存
@@ -48,14 +54,16 @@ class PageCache
 
     /**
      * @brief 通过内存地址找到所属页段
+     * @param ptr 内存地址
+     * @return 成功找到返回`Span *`，失败时返回`nullptr`
      */
     Span * FreeObjectToSpan(void * ptr);
 
 private:
     /**
      * @brief 从系统内存中获取指定大小的内存
      */
-    void * fetchFromSystem(std::size_t page_count) const noexcept;
+    void * fetchFromSystem(size_type count) const noexcept;
 };
 
 } // namespace WW