Merge pull request #2 from Icingworld/dev

Detect and fix some bugs

Author: Icingworld

memory-pool/include/CentralCache.h

@@ -5,16 +5,11 @@
 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, MAX_ARRAY_SIZE> _Spans;    // 页段链表数组

memory-pool/include/Common.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <cstddef>
+
+namespace WW
+{
+
+using size_type = std::size_t;                  // 大小类型定义
+
+constexpr size_type PAGE_SIZE = 4096;           // 单页大小
+constexpr size_type PAGE_SHIFT = 12;            // 页号计算移位数
+
+constexpr size_type MAX_PAGE_NUM = 128;         // 最大页数
+
+constexpr size_type MAX_ARRAY_SIZE = 208;       // 内存块数组大小
+
+constexpr size_type MAX_MEMORY_SIZE = PAGE_SIZE * MAX_PAGE_NUM / 2;    // 内存池可以管理的最大内存
+
+} // namespace WW

memory-pool/include/FreeList.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <cstddef>
+#include <Common.h>
 
 namespace WW
 {
@@ -85,7 +85,7 @@ class FreeListIterator
 class FreeList
 {
 public:
-    using size_type = std::size_t;          // 内存块数量范围为0-65535，使用uint16_t存储
+    using size_type = std::size_t;
     using iterator = FreeListIterator;
 
 private:

memory-pool/include/PageCache.h

@@ -8,18 +8,13 @@
 namespace WW
 {
 
-constexpr std::uint8_t MAX_PAGE_COUNT = 128;    // 最大页数
-
 /**
  * @brief 页缓存
  */
 class PageCache
 {
-public:
-    using size_type = std::size_t;
-
 private:
-    std::array<SpanList, MAX_PAGE_COUNT> _Spans;        // 页段链表数组
+    std::array<SpanList, MAX_PAGE_NUM> _Spans;          // 页段链表数组
     std::unordered_map<size_type, Span *> _Span_map;    // 页号到页段指针的映射
     std::recursive_mutex _Mutex;                        // 页缓存锁
 

memory-pool/include/SpanList.h

@@ -7,21 +7,15 @@
 namespace WW
 {
 
-constexpr std::size_t PAGE_SIZE = 4096;         // 单页大小
-constexpr std::size_t PAGE_SHIFT = 12;          // 页号计算移位数
-
 /**
  * @brief 页段
  * @details 维护一大段连续的内存
  */
 class Span
 {
-public:
-    using size_type = std::size_t;
-
 private:
     FreeList _Free_list;            // 空闲内存块
-    size_type _Page_id;              // 页段号
+    size_type _Page_id;             // 页段号
     Span * _Prev;                   // 前一个页段
     Span * _Next;                   // 后一个页段 
     size_type _Page_count;          // 页数

memory-pool/include/ThreadCache.h

@@ -5,16 +5,11 @@
 namespace WW
 {
 
-constexpr std::size_t MAX_MEMORY_SIZE = PAGE_SIZE * MAX_PAGE_COUNT;    // 内存池可以管理的最大内存
-
 /**
  * @brief 线程缓存
  */
 class ThreadCache
 {
-public:
-    using size_type = std::size_t;
-
 private:
     CentralCache & _Central_cache;                      // 中心缓存
     std::array<FreeList, MAX_ARRAY_SIZE> _Freelists;    // 自由表数组

memory-pool/src/CentralCache.cpp

@@ -82,7 +82,7 @@ void CentralCache::returnRange(size_type size, FreeObject * free_object)
     }
 }
 
-CentralCache::size_type CentralCache::sizeToIndex(size_type size) noexcept
+size_type CentralCache::sizeToIndex(size_type size) noexcept
 {
     if (size <= 128) {
         return (size + 8 - 1) / 8 - 1;
@@ -123,12 +123,12 @@ Span * CentralCache::getFreeSpan(size_type size)
     // 初步计算需要多少页
     std::size_t page_count = total_size / PAGE_SIZE;
     // 如果还有剩余内存，则需要申请额外的一页
-    if (total_size % MAX_PAGE_COUNT != 0) {
+    if (total_size % MAX_PAGE_NUM != 0) {
         page_count += 1;
     }
     // 每个页段最多只有128页
-    if (page_count > MAX_PAGE_COUNT) {
-        page_count = MAX_PAGE_COUNT;
+    if (page_count > MAX_PAGE_NUM) {
+        page_count = MAX_PAGE_NUM;
     }
 
     // 申请页段

memory-pool/src/FreeList.cpp

@@ -105,7 +105,7 @@ bool FreeList::empty() const noexcept
     return (_Head->next() == nullptr);
 }
 
-FreeList::size_type FreeList::size() const noexcept
+size_type FreeList::size() const noexcept
 {
     return _Size;
 }

memory-pool/src/PageCahce.cpp renamed to memory-pool/src/PageCache.cpp

@@ -1,5 +1,7 @@
 #include "PageCache.h"
 
+#include <cstdlib>
+
 namespace WW
 {
 
@@ -12,7 +14,20 @@ PageCache::PageCache()
 
 PageCache::~PageCache()
 {
-    // TODO
+    // 释放所有页段
+    for (size_type i = 0; i < MAX_PAGE_NUM; ++i) {
+        while (!_Spans[i].empty()) {
+            Span & span = _Spans[i].front();
+            _Spans[i].pop_front();
+
+            // 释放页段管理的内存空间
+            void * ptr = Span::idToPtr(span.id());
+            free(ptr);
+
+            // 销毁页段
+            delete(&span);
+        }
+    }
 }
 
 PageCache & PageCache::getPageCache()
@@ -33,7 +48,7 @@ Span * PageCache::fetchSpan(size_type count)
     }
 
     // 没有正好这么大的页段，尝试从更大块内存中切出页段
-    for (size_type i = count; i < MAX_PAGE_COUNT; ++i) {
+    for (size_type i = count; i < MAX_PAGE_NUM; ++i) {
         if (!_Spans[i].empty()) {
             // 取出页段
             Span & bigger_span = _Spans[i].front();
@@ -67,16 +82,16 @@ Span * PageCache::fetchSpan(size_type count)
 
     // 没找到更大的页段，直接申请一个最大的页段，然后按照上面的流程重新获取页段
     Span * max_span = new Span();
-    void * ptr = fetchFromSystem(MAX_PAGE_COUNT);
+    void * ptr = fetchFromSystem(MAX_PAGE_NUM);
     if (ptr == nullptr) {
         return nullptr;
     }
 
     // 计算页号
     max_span->setId(Span::ptrToId(ptr));
-    max_span->setCount(MAX_PAGE_COUNT);
-    // 插入MAX_PAGE_COUNT页的链表中
-    _Spans[MAX_PAGE_COUNT - 1].push_front(max_span);
+    max_span->setCount(MAX_PAGE_NUM);
+    // 插入MAX_PAGE_NUM页的链表中
+    _Spans[MAX_PAGE_NUM - 1].push_front(max_span);
     // 首页号插入哈希表
     _Span_map[max_span->id()] = max_span;
     // 尾页号插入哈希表
@@ -103,23 +118,25 @@ void PageCache::returnSpan(Span * span)
             break;
         }
 
+        Span * span_prev = it->second;
+
         // 判断合并后是否超出上限
-        if (span->count() + it->second->count() > MAX_PAGE_COUNT) {
+        if (span->count() + span_prev->count() > MAX_PAGE_NUM) {
             break;
         }
 
         // 从链表中删除该空闲页
-        _Spans[it->second->count() - 1].erase(it->second);
+        _Spans[span_prev->count() - 1].erase(span_prev);
         // 从哈希表中删除该空闲页的首尾页号
-        _Span_map.erase(it->second->id());
-        _Span_map.erase(it->second->id() + it->second->count() - 1);
+        _Span_map.erase(span_prev->id());
+        _Span_map.erase(span_prev->id() + span_prev->count() - 1);
 
         // 合并页段
-        span->setId(it->second->id());
-        span->setCount(it->second->count() + span->count());
+        span->setId(span_prev->id());
+        span->setCount(span_prev->count() + span->count());
 
         // 删除原空闲页
-        delete it->second;
+        delete span_prev;
     }
 
     // 向后寻找空闲的页
@@ -133,21 +150,23 @@ void PageCache::returnSpan(Span * span)
         }
 
         // 判断合并后是否超出上限
-        if (span->count() + it->second->count() > MAX_PAGE_COUNT) {
+        if (span->count() + it->second->count() > MAX_PAGE_NUM) {
             break;
         }
 
+        Span * span_next = it->second;
+
         // 从链表中删除该空闲页
-        _Spans[it->second->count() - 1].erase(it->second);
+        _Spans[span_next->count() - 1].erase(span_next);
         // 从哈希表中删除该空闲页的首尾页号
-        _Span_map.erase(it->second->id());
-        _Span_map.erase(it->second->id() + it->second->count() - 1);
+        _Span_map.erase(span_next->id());
+        _Span_map.erase(span_next->id() + span_next->count() - 1);
 
         // 合并页段，首页号不变，只需要调整大小
-        span->setCount(it->second->count() + span->count());
+        span->setCount(span_next->count() + span->count());
 
         // 删除原空闲页
-        delete it->second;
+        delete span_next;
     }
 
     // 合并完成，插入新的链表
@@ -173,7 +192,11 @@ Span * PageCache::FreeObjectToSpan(void * ptr)
 
 void * PageCache::fetchFromSystem(size_type count) const noexcept
 {
-    return ::operator new(count * PAGE_SIZE, std::nothrow);
+    void * ptr = nullptr;
+    if (posix_memalign(&ptr, PAGE_SIZE, count * PAGE_SIZE) != 0) {
+        return nullptr;
+    }
+    return ptr;
 }
 
 } // namespace WW

memory-pool/src/SpanList.cpp

@@ -13,7 +13,7 @@ Span::Span()
 {
 }
 
-Span::size_type Span::id() const noexcept
+size_type Span::id() const noexcept
 {
     return _Page_id;
 }
@@ -23,7 +23,7 @@ void Span::setId(size_type page_id) noexcept
     _Page_id = page_id;
 }
 
-Span::size_type Span::count() const noexcept
+size_type Span::count() const noexcept
 {
     return _Page_count;
 }
@@ -53,7 +53,7 @@ void Span::setNext(Span * next) noexcept
     _Next = next;
 }
 
-Span::size_type Span::used() const noexcept
+size_type Span::used() const noexcept
 {
     return _Used;
 }
@@ -68,7 +68,7 @@ FreeList * Span::getFreeList() noexcept
     return &_Free_list;
 }
 
-Span::size_type Span::ptrToId(void * ptr) noexcept
+size_type Span::ptrToId(void * ptr) noexcept
 {
     return reinterpret_cast<std::uintptr_t>(ptr) >> PAGE_SHIFT;
 }