Merge pull request #8 from Icingworld/dev

Code review

Author: Icingworld

README.md

@@ -2,13 +2,13 @@
 
 该项目是`WW`系列中，作为学习用途的内存池库
 
-## 特点
+## 一、特点
 
 + 采用`tcmalloc`的三层缓存架构，提高内存的分配效率
 
 + C++11风格，代码易读性强
 
-## 结构
+## 二、结构
 
 采用三层缓存的结构，其中
 
@@ -18,31 +18,32 @@
 
 + 线程缓存`ThreadCache`: 管理少量的小块内存，负责从中心缓存中获取小块内存，并提供给应用程序使用
 
-### 页缓存`PageCahce`
+### 1. 页缓存`PageCahce`
 
 页缓存以页为单位管理内存，在中心缓存申请内存时，页缓存挑选合适的页段，然后将其切片成小块页段提供给中心缓存
 
 ![page_cache](doc/img/page_cache.png)
 
-### 中心缓存`CentralCache`
+### 2. 中心缓存`CentralCache`
 
 中心缓存从页缓存中获取合适大小的页段，然后根据需要的内存块大小，切割为一定数量的内存块，挂载到一个内存块链表上，供线程缓存使用
 
 ![central_cache](doc/img/central_cache.png)
 
-### 线程缓存`ThreadCache`
+### 3. 线程缓存`ThreadCache`
 
 线程缓存从中心缓存中批量获取内存块，供应用程序申请使用
 
 ![thread_cache](doc/img/thread_cache.png)
 
-## 使用
+## 三、使用
 
-### 要求
+### 1. 要求
 
-+ 环境：`Linux x86_64`
++ 操作系统：64位`Linux`或`Windows`
++ C++：`C++11`或更高版本
 
-### 直接使用
+### 2. 直接使用
 
 直接操作线程缓存实例，示例见[threadcache_test.cpp](test/src/threadcache_test.cpp)
 
@@ -64,7 +65,7 @@ int main()
 }
 ```
 
-### 封装使用
+### 3. 封装使用
 
 将内存池封装为分配器等，示例见[memory_test.cpp](test/src/memory_test.cpp)
 
@@ -89,3 +90,25 @@ void deallocate(pointer ptr, size_type n)
     thread_cache.deallocate(ptr, n * sizeof(T));
 }
 ```
+
+## 四、性能
+
+基准测试位于[memory_benchmark.cpp](benchmark/src/memory_benchmark.cpp)
+
+运行环境：
+
++ 操作系统：`Ubuntu 22.04 LTS`
++ CPU：`12th Gen Intel(R) Core(TM) i7-12700`
++ 核心/线程：4 核心 / 4 线程
++ 内存：8 GB
++ 虚拟化：`VMware`
+
+### 1. 运行结果参考
+
+![memory_benchmark](doc/img/memory_benchmark.png)
+
+### 2. `perf`火焰图参考
+
+火焰图来自基准测试中的[analyze_benchmark.cpp](benchmark/src/analyze_benchmark.cpp)
+
+![flamegraph](doc/img/flamegraph.svg)

benchmark/CMakeLists.txt

@@ -9,4 +9,17 @@ target_include_directories(memory_benchmark PRIVATE
 
 target_link_libraries(memory_benchmark PRIVATE
     WW::memory
-)
+)
+
+# analyze_benchmark.cpp
+add_executable(analyze_benchmark
+    src/analyze_benchmark.cpp
+)
+
+target_include_directories(analyze_benchmark PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+
+target_link_libraries(analyze_benchmark PRIVATE
+    WW::memory
+)

benchmark/include/allocator.h

@@ -31,7 +31,7 @@ class allocator
 
 public:
     allocator()
-        : thread_cache(WW::ThreadCache::getThreadCache())
+        : thread_cache(WW::ThreadCache::get_thread_cache())
     {
     }
 

benchmark/src/analyze_benchmark.cpp

@@ -0,0 +1,68 @@
+#include <vector>
+#include <thread>
+
+#include <allocator.h>
+
+using namespace WW;
+
+constexpr size_type THREAD = 2;                 // 线程数
+constexpr size_type ROUND = 1000;               // 轮数
+constexpr size_type TIMES = 1000;               // 单次测试操作次数
+
+/**
+ * @brief 测试结构
+ */
+template <size_type Size>
+class TestCase
+{
+public:
+    char padding[Size];
+};
+
+int main()
+{
+    std::vector<std::thread> pool_threads;
+    pool_threads.reserve(THREAD);
+
+    // 512bytes
+    pool_threads.emplace_back([]() {
+        allocator<TestCase<512>> alloc;
+
+        for (size_type j = 0; j < ROUND; ++j) {
+            std::vector<TestCase<512> *> ptrs;
+            ptrs.reserve(TIMES);
+
+            for (size_type k = 0; k < TIMES; ++k) {
+                TestCase<512> * ptr = alloc.allocate(1);
+                ptrs.emplace_back(ptr);
+            }
+
+            for (size_type k = 0; k < TIMES; ++k) {
+                alloc.deallocate(ptrs[k], 1);
+            }
+        }
+    });
+
+    // 1024bytes
+    pool_threads.emplace_back([]() {
+        allocator<TestCase<1024>> alloc;        
+
+        for (size_type j = 0; j < ROUND; ++j) {
+            std::vector<TestCase<1024> *> ptrs;
+            ptrs.reserve(TIMES);
+
+            for (size_type k = 0; k < TIMES; ++k) {
+                TestCase<1024> * ptr = alloc.allocate(1);
+                ptrs.emplace_back(ptr);
+            }
+
+            for (size_type k = 0; k < TIMES; ++k) {
+                alloc.deallocate(ptrs[k], 1);
+            }
+        }
+    });
+    
+    for (std::thread & thread : pool_threads) {
+        thread.join();
+    }
+}