feat page_cache free part, still with bugs

Author: ffengc

README.md

@@ -19,6 +19,7 @@
   - [内存申请流程联调](#内存申请流程联调)
   - [thread\_cache内存释放](#thread_cache内存释放)
   - [central\_cache内存释放](#central_cache内存释放)
+  - [page\_cache内存释放](#page_cache内存释放)
 
 ***
 
@@ -1110,4 +1111,73 @@ void central_cache::release_list_to_spans(void* start, size_t size) {
 
 细节在注释里面写的很清楚了。
 
-要注意，调用pc的接口的时候，就记得把桶锁解掉。
+要注意，调用pc的接口的时候，就记得把桶锁解掉。
+
+## page_cache内存释放
+
+就是这个函数。
+
+```cpp
+void page_cache::release_span_to_page(span* s) {
+    // 对span前后对页尝试进行合并，缓解内存碎片问题
+}
+```
+
+然后刚才的map可以帮助我们查找前后的page。
+
+然后我们前后找的时候，要区分这个页是不是在centralCache上的，如果在cc上，那就不能合并。
+
+然后这个判断不能用use_count==0这个判断条件。有可能这个span刚从pc拿过来，还没给别人的时候，use_count就是0，这个span，pc是不能回收合并的。
+
+所以可以给span添加一个参数is_use就行了。
+
+```cpp
+// 管理大块内存
+class span {
+public:
+    PAGE_ID __page_id; // 大块内存起始页的页号
+    size_t __n = 0; // 页的数量
+    // 双向链表结构
+    span* __next = nullptr;
+    span* __prev = nullptr;
+    size_t __use_count = 0; // 切成段小块内存，被分配给threadCache的计数器
+    void* __free_list = nullptr; // 切好的小块内存的自由链表
+    bool is_use = false; // 是否在被使用
+};
+```
+
+然后cc.cc这里改一下，拿到之后改成true就行。
+
+cc.cc
+```cpp
+    page_cache::get_instance()->__page_mtx.lock();
+    span* cur_span = page_cache::get_instance()->new_span(size_class::num_move_page(size));
+    cur_span->is_use = true; // 表示已经被使用
+    page_cache::get_instance()->__page_mtx.unlock();
+```
+
+
+然后继续写这个逻辑:
+
+page_cache.cc
+```cpp
+void page_cache::release_span_to_page(span* s) {
+    // 对span前后对页尝试进行合并，缓解内存碎片问题
+    PAGE_ID prev_id = s->__page_id - 1; // 前一块span的id一定是当前span的id-1
+    // 拿到id如何找span: 之前写好的map能拿到吗？
+}
+```
+
+现在的问题是，之前的map能拿到吗？还拿不到，因为我们之前的map只记录了分给cc的span的映射，没有存留在pc那些，没有分出去的映射。
+所以我们要在`span* page_cache::new_span(size_t k) {`里面添加一下，留在pagecache那些块的映射。
+
+```cpp
+            // 存储n_span的首尾页号跟n_span的映射，方便pc回收内存时进行合并查找
+            __id_span_map[n_span->__page_id] = n_span;
+            __id_span_map[n_span->__page_id + n_span->__n - 1] = n_span;
+```
+
+为什么这里不用循环存储呢？
+
+因为这里的pc的内存只是被span挂起来啊，不会被切啊，所以知道地址就了啊！
+给cc的那些，会被切开变成很多固定大小的内存块啊！所以这里不用循环存。

debug

@@ -8,6 +8,11 @@
 #include <mutex>
 #include <unordered_map>
 
+#ifdef PROJECT_DEBUG
+#include "log.hpp"
+#include <iostream>
+#endif
+
 #if defined(_WIN32) || defined(_WIN64)
 #include <windows.h>
 #elif defined(__aarch64__) // ...
@@ -70,9 +75,13 @@ class free_list {
         return obj;
     }
     void pop(void*& start, void*& end, size_t n) {
-        // 这里是输出参数了
-        assert(n >= __size);
+// 这里是输出参数了
+#ifdef PROJECT_DEBUG
+        LOG(DEBUG) << "call here" << std::endl;
+#endif
+        assert(n <= __size);
         start = __free_list_ptr;
+        end = start; // debug 20240507 miss this
         for (size_t i = 0; i < n - 1; i++)
             end = free_list::__next_obj(end);
         __free_list_ptr = free_list::__next_obj(end);
@@ -178,6 +187,7 @@ class span {
     span* __prev = nullptr;
     size_t __use_count = 0; // 切成段小块内存，被分配给threadCache的计数器
     void* __free_list = nullptr; // 切好的小块内存的自由链表
+    bool __is_use = false; // 是否在被使用
 };
 
 // 带头双向循环链表

include/common.hpp

@@ -4,6 +4,7 @@
 #define __YUFC_LOG__
 
 #include <iostream>
+#include <map>
 #include <string>
 
 enum STATUES // 日志等级
@@ -14,12 +15,40 @@ enum STATUES // 日志等级
     ERROR,
     FATAL
 };
+
+// 定义颜色代码
+#define RESET "\033[0m"
+#define RED "\033[1;31m" // 加粗红色
+#define GREEN "\033[1;32m" // 加粗绿色
+#define YELLOW "\033[1;33m" // 加粗黄色
+#define BLUE "\033[1;34m" // 加粗蓝色
+#define MAGENTA "\033[1;35m" // 加粗洋红
+
+// 根据日志等级获取相应颜色
+inline const char* GetColor(const std::string& level) {
+    std::map<std::string, int> m = { { "INFO", 0 }, { "DEBUG", 1 }, { "WARNING", 2 }, { "ERROR", 3 }, { "FATAL", 4 } };
+    switch (m[level]) {
+    case INFO:
+        return BLUE;
+    case DEBUG:
+        return GREEN;
+    case WARNING:
+        return YELLOW;
+    case ERROR:
+        return MAGENTA;
+    case FATAL:
+        return RED;
+    default:
+        return RESET;
+    }
+}
+
 // LOG() << "message"
 inline std::ostream& Log(const std::string& level, const std::string& file_name, int line) {
     // 添加日志等级
-    std::string message = "[";
-    message += level;
-    message += "]";
+    std::string levelTag = std::string("[") + level + "]";
+    std::string coloredLevelTag = std::string(GetColor(level)) + levelTag + RESET;
+    std::string message = coloredLevelTag;
     // 添加报错文件名称
     message += "[";
     message += file_name;

include/log.hpp

@@ -1,5 +1,7 @@
-test.out: *.cc ./src/*.cc
+out: *.cc ./src/*.cc
+	g++ -o $@ $^ -std=c++11 -lpthread
+debug: *.cc ./src/*.cc
 	g++ -o $@ $^ -std=c++11 -lpthread -DPROJECT_DEBUG
 .PHONY:clean
 clean:
-	rm -f test.out
+	rm -f out debug

makefile

@@ -53,6 +53,7 @@ span* central_cache::get_non_empty_span(span_list& list, size_t size) {
 #endif
     page_cache::get_instance()->__page_mtx.lock();
     span* cur_span = page_cache::get_instance()->new_span(size_class::num_move_page(size));
+    cur_span->__is_use = true; // 表示已经被使用
     page_cache::get_instance()->__page_mtx.unlock();
 #ifdef PROJECT_DEBUG
     LOG(DEBUG) << "central_cache::get_non_empty_span() get new span success" << std::endl;
@@ -96,7 +97,13 @@ void central_cache::release_list_to_spans(void* start, size_t size) {
             // 说明这个span切分出去的所有小块都回来了
             // 归还给pagecache
             // 1. 把这一页从cc的这个桶的spanlist中拿掉
+            // #ifdef PROJECT_DEBUG
+            //             LOG(DEBUG) << "***" << std::endl;
+            // #endif
             __span_lists[index].erase(cur_span); // 从桶里面拿走
+            // #ifdef PROJECT_DEBUG
+            //             LOG(DEBUG) << "after ***" << std::endl;
+            // #endif
             // 2. 此时不用管这个span的freelist了，因为这些内存本来就是span初始地址后面的，然后顺序也是乱的，直接置空即可
             //      (这里还不太理解)
             cur_span->__free_list = nullptr;

out

@@ -8,15 +8,27 @@ page_cache page_cache::__s_inst;
 span* page_cache::new_span(size_t k) {
     assert(k > 0 && k < PAGES_NUM);
     // 先检查第k个桶是否有span
+    // #ifdef PROJECT_DEBUG
+    //     LOG(DEBUG) << "before ***" << std::endl;
+    // #endif
     if (!__span_lists[k].empty())
-        return __span_lists->pop_front();
+        return __span_lists[k].pop_front(); // ? __span_lists->pop_front();
+    // #ifdef PROJECT_DEBUG
+    //     LOG(DEBUG) << "after ***" << std::endl;
+    // #endif
     // 第k个桶是空的->去检查后面的桶里面有无span，如果有，可以把它进行切分
     for (size_t i = k + 1; i < PAGES_NUM; i++) {
         if (!__span_lists[i].empty()) {
-            // 可以开始切了
-            // 假设这个页是n页的，需要的是k页的
-            // 1. 从__span_lists中拿下来 2. 切开 3. 一个返回给cc 4. 另一个挂到 n-k 号桶里面去
+// 可以开始切了
+// 假设这个页是n页的，需要的是k页的
+// 1. 从__span_lists中拿下来 2. 切开 3. 一个返回给cc 4. 另一个挂到 n-k 号桶里面去
+#ifdef PROJECT_DEBUG
+            LOG(DEBUG) << "before ***" << std::endl;
+#endif
             span* n_span = __span_lists[i].pop_front();
+#ifdef PROJECT_DEBUG
+            LOG(DEBUG) << "after ***" << std::endl;
+#endif
             span* k_span = new span;
             // 在n_span头部切除k页下来
             k_span->__page_id = n_span->__page_id; // <1>
@@ -33,6 +45,9 @@ span* page_cache::new_span(size_t k) {
              */
             // 剩下的挂到相应位置
             __span_lists[n_span->__n].push_front(n_span);
+            // 存储n_span的首尾页号跟n_span的映射，方便pc回收内存时进行合并查找
+            __id_span_map[n_span->__page_id] = n_span;
+            __id_span_map[n_span->__page_id + n_span->__n - 1] = n_span;
             // 这里记录映射(简历id和span的映射，方便cc回收小块内存时，查找对应的span)
             for (PAGE_ID j = 0; j < k_span->__n; j++) {
                 __id_span_map[k_span->__page_id + j] = k_span;
@@ -62,10 +77,50 @@ span* page_cache::map_obj_to_span(void* obj) {
     auto ret = __id_span_map.find(id);
     if (ret != __id_span_map.end())
         return ret->second;
-    LOG(FATAL);
+    LOG(FATAL) << std::endl;
     assert(false);
     return nullptr;
 }
 
 void page_cache::release_span_to_page(span* s) {
+    // 对span前后对页尝试进行合并，缓解内存碎片问题
+    while (true) {
+        PAGE_ID prev_id = s->__page_id - 1; // 前一块span的id一定是当前span的id-1
+        // 拿到id如何找span: 之前写好的map能拿到吗？
+        // 找到了，如果isuse是false，就能合并了（向前合并+向后合并）
+        // 如果遇到了合并大小超过了128页了，也要停止了
+        auto ret = __id_span_map.find(prev_id);
+        if (ret == __id_span_map.end()) // 前面的页号没有了，不合并了
+            break;
+        span* prev_span = ret->second;
+        if (prev_span->__is_use == true) // 前面相邻页的span在使用，不合并了
+            break;
+        if (prev_span->__n + s->__n > PAGES_NUM - 1) // 合并出超过128页的span没办法管理，不合并了
+            break;
+        s->__page_id = prev_span->__page_id;
+        s->__n += prev_span->__n;
+        __span_lists[prev_span->__n].erase(prev_span); // 防止野指针，删掉
+        delete prev_span; // 删掉这个span
+    } // 向前合并的逻辑 while end;
+    while (true) {
+        PAGE_ID next_id = s->__page_id + s->__n - 1; // 注意这里的页号是+n-1了
+        auto ret = __id_span_map.find(next_id);
+        if (ret == __id_span_map.end()) // 后面的页号没有了
+            break;
+        span* next_span = ret->second;
+        if (next_span->__is_use == true) // 后面相邻页的span在使用，不合并了
+            break;
+        if (next_span->__n + s->__n > PAGES_NUM - 1) // 合并出超过128页的span没办法管理，不合并了
+            break;
+        s->__page_id; // 起始页号不用变了，因为是向后合并
+        s->__n += next_span->__n;
+        __span_lists[next_span->__n].erase(next_span); // 防止野指针，删掉
+        delete next_span;
+    }
+    // 已经合并完成了，把东西挂起来
+    __span_lists[s->__n].push_front(s);
+    s->__is_use = false;
+    // 处理一下映射，方便别人找到我
+    __id_span_map[s->__page_id] = s;
+    __id_span_map[s->__page_id + s->__n - 1] = s;
 }

src/central_cache.cc

@@ -58,6 +58,10 @@ void thread_cache::deallocate(void* ptr, size_t size) {
     __free_lists[index].push(ptr);
     // 当链表长度大于一次批量申请的内存的时候，就开始还一段list给cc
     if (__free_lists[index].size() >= __free_lists[index].max_size()) {
+#ifdef PROJECT_DEBUG
+        LOG(DEBUG) << __free_lists[index].size() << ":" << __free_lists[index].max_size() << std::endl;
+        LOG(DEBUG) << "call list_too_long" << std::endl;
+#endif
         list_too_long(__free_lists[index], size);
     }
 }
@@ -66,5 +70,8 @@ void thread_cache::list_too_long(free_list& list, size_t size) {
     void* start = nullptr;
     void* end = nullptr;
     list.pop(start, end, list.max_size());
+    #ifdef PROJECT_DEBUG
+    LOG(DEBUG) << "list pop success -> call release_list_to_spans()" << std::endl;
+    #endif
     central_cache::get_instance()->release_list_to_spans(start, size);
 }

src/page_cache.cc

@@ -2,7 +2,10 @@
 
 #include "./include/tcmalloc.hpp"
 #include <iostream>
+#include <map>
+#include <random>
 #include <thread>
+#include <functional>
 
 void alloc1() {
     for (size_t i = 0; i < 5; i++) {
@@ -41,7 +44,31 @@ void test_alloc2() {
     void* p2 = tcmalloc(6); // 这一次一定会找新的span
 }
 
+void test_dealloc(int alloc_times = 10) {
+    // 创建随机数生成器
+    std::random_device rd;
+    std::mt19937 gen(rd()); // 以随机设备作为种子
+    std::uniform_int_distribution<> distrib(1, 127 * 1024); // 设置随机数分布范围1-127
+    // 生成并输出随机数
+    std::map<void*, size_t> s;
+    for (int i = 0; i < alloc_times; i++) {
+        int sz = distrib(gen);
+        s.insert({ tcmalloc(sz), sz }); // 申请随机值
+    }
+    for (auto& e : s) {
+        tcfree(e.first, e.second);
+    }
+}
+
+void test_multi_thread() {
+    std::thread t1(std::bind(test_dealloc, 200));
+    // std::thread t2(std::bind(test_dealloc, 20));
+    t1.join();
+    // t2.join();
+    std::cout << "run successful" << std::endl;
+}
+
 int main() {
-    test_alloc2();
+    test_multi_thread();
     return 0;
 }