fix the bugs, The tcmalloc project is basically completed, but there are still many areas that need to be modified and optimized.

Author: ffengc

README.md

@@ -20,6 +20,8 @@
   - [thread\_cache内存释放](#thread_cache内存释放)
   - [central\_cache内存释放](#central_cache内存释放)
   - [page\_cache内存释放](#page_cache内存释放)
+  - [大于256k的情况](#大于256k的情况)
+  - [处理代码中`new`的问题](#处理代码中new的问题)
 
 ***
 
@@ -1180,4 +1182,18 @@ void page_cache::release_span_to_page(span* s) {
 为什么这里不用循环存储呢？
 
 因为这里的pc的内存只是被span挂起来啊，不会被切啊，所以知道地址就了啊！
-给cc的那些，会被切开变成很多固定大小的内存块啊！所以这里不用循环存。
+给cc的那些，会被切开变成很多固定大小的内存块啊！所以这里不用循环存。
+
+## 大于256k的情况
+
+1. <=256kb -> 按照前面三层缓存的情况进行操作
+2. \>256kb的情况
+   a. 128\*8k > size > 32\*8k这个情况: 还可以找pagecache
+   b. 否则直接找系统
+
+然后这一部分就是有多处要改，不过都很简单很容易找到，大家可以直接看代码。处理完之后，测试一下申请大内存就行。
+
+
+## 处理代码中`new`的问题
+
+代码中有些地方用了`new span`。这个就很不对。我们弄这个tcmalloc是用来替代malloc的，既然是替代，那我们的代码里面怎么能有`new`，`new`也是调用`malloc`的，所以我们要改一下。

debug

@@ -48,6 +48,17 @@ inline static void* system_alloc(size_t kpage) {
     return ptr;
 }
 
+inline static void system_free(void* ptr, size_t size = 0) {
+    /**
+     * linux的munmap需要给大小
+     */
+#if defined(_WIN32) || defined(_WIN64)
+    VirtualFree(ptr, 0, MEM_RELEASE);
+#elif defined(__linux__) // ...
+    munmap(ptr, size);
+#endif
+}
+
 // 管理切分好的小对象的自由链表
 class free_list {
 private:
@@ -116,8 +127,8 @@ class size_class {
         else if (size <= 256 * 1024)
             return __round_up(size, 8 * 1024);
         else {
-            assert(false);
-            return -1;
+            // 大内存
+            return __round_up(size, 1 << PAGE_SHIFT);
         }
     }
     // 计算映射的哪一个自由链表桶

include/common.hpp

@@ -20,7 +20,7 @@ class page_cache {
     static page_cache* get_instance() { return &__s_inst; }
     span* map_obj_to_span(void* obj);
     // 释放空闲的span回到pc，并合并相邻的span
-    void release_span_to_page(span* s);
+    void release_span_to_page(span* s, size_t size = 0);
 public:
     // 获取一个K页的span
     span* new_span(size_t k);

include/page_cache.hpp

@@ -4,9 +4,20 @@
 
 #include "common.hpp"
 #include "log.hpp"
+#include "page_cache.hpp"
 #include "thread_cache.hpp"
 
 static void* tcmalloc(size_t size) {
+    if (size > MAX_BYTES) {
+        // 处理申请大内存的情况
+        size_t align_size = size_class::round_up(size);
+        size_t k_page = align_size >> PAGE_SHIFT;
+        page_cache::get_instance()->__page_mtx.lock();
+        span* cur_span = page_cache::get_instance()->new_span(k_page); // 直接找pc
+        page_cache::get_instance()->__page_mtx.unlock();
+        void* ptr = (void*)(cur_span->__page_id << PAGE_SHIFT); // span转化成地址
+        return ptr;
+    }
     if (p_tls_thread_cache == nullptr)
         // 相当于单例
         p_tls_thread_cache = new thread_cache;
@@ -17,6 +28,13 @@ static void* tcmalloc(size_t size) {
 }
 
 static void tcfree(void* ptr, size_t size) {
+    if (size > MAX_BYTES) {
+        span* s = page_cache::get_instance()->map_obj_to_span(ptr); // 找到这个span
+        page_cache::get_instance()->__page_mtx.lock();
+        page_cache::get_instance()->release_span_to_page(s, size); // 直接调用pc的
+        page_cache::get_instance()->__page_mtx.unlock();
+        return;
+    }
     assert(p_tls_thread_cache);
     p_tls_thread_cache->deallocate(ptr, size);
 }

include/tcmalloc.hpp

@@ -6,29 +6,39 @@ page_cache page_cache::__s_inst;
 
 // cc向pc获取k页的span
 span* page_cache::new_span(size_t k) {
-    assert(k > 0 && k < PAGES_NUM);
+    assert(k > 0);
+    // 处理大内存情况
+    if (k > PAGES_NUM - 1) {
+        void* ptr = system_alloc(k);
+        span* cur_span = new span;
+        cur_span->__page_id = (PAGE_ID)ptr >> PAGE_SHIFT;
+        cur_span->__n = k;
+        // map记录一下
+        __id_span_map[cur_span->__page_id] = cur_span;
+        return cur_span;
+    }
     // 先检查第k个桶是否有span
     // #ifdef PROJECT_DEBUG
     //     LOG(DEBUG) << "before ***" << std::endl;
     // #endif
-    if (!__span_lists[k].empty())
-        return __span_lists[k].pop_front(); // ? __span_lists->pop_front();
+    if (!__span_lists[k].empty()) {
+        span* s = __span_lists[k].pop_front(); // ? __span_lists->pop_front();
+        // 建立id和span的映射，方便central cache回收小块内存时，查找对应的span
+        for (PAGE_ID i = 0; i < s->__n; ++i) {
+            __id_span_map[s->__page_id + i] = s;
+        }
+        return s;
+    }
     // #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 号桶里面去
-#ifdef PROJECT_DEBUG
-            LOG(DEBUG) << "before ***" << std::endl;
-#endif
+            // 可以开始切了
+            // 假设这个页是n页的，需要的是k页的
+            // 1. 从__span_lists中拿下来 2. 切开 3. 一个返回给cc 4. 另一个挂到 n-k 号桶里面去
             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>
@@ -82,7 +92,16 @@ span* page_cache::map_obj_to_span(void* obj) {
     return nullptr;
 }
 
-void page_cache::release_span_to_page(span* s) {
+void page_cache::release_span_to_page(span* s, size_t size) {
+    // 第二个参数是为了linux下一次释放大内存，需要大小
+    // std::cout << s->__n << std::endl; // 33
+    if (s->__n >= PAGES_NUM) {
+        // 处理大内存
+        void* ptr = (void*)(s->__page_id << PAGE_SHIFT);
+        system_free(s, size);
+        delete s;
+        return;
+    }
     // 对span前后对页尝试进行合并，缓解内存碎片问题
     while (true) {
         PAGE_ID prev_id = s->__page_id - 1; // 前一块span的id一定是当前span的id-1
@@ -103,7 +122,7 @@ void page_cache::release_span_to_page(span* s) {
         delete prev_span; // 删掉这个span
     } // 向前合并的逻辑 while end;
     while (true) {
-        PAGE_ID next_id = s->__page_id + s->__n - 1; // 注意这里的页号是+n-1了
+        PAGE_ID next_id = s->__page_id + s->__n; // 注意这里的页号是+n了
         auto ret = __id_span_map.find(next_id);
         if (ret == __id_span_map.end()) // 后面的页号没有了
             break;

out

@@ -1,11 +1,11 @@
 
 
 #include "./include/tcmalloc.hpp"
+#include <functional>
 #include <iostream>
 #include <map>
 #include <random>
 #include <thread>
-#include <functional>
 
 void alloc1() {
     for (size_t i = 0; i < 5; i++) {
@@ -48,7 +48,7 @@ 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::uniform_int_distribution<> distrib(1, 127 * 100); // 设置随机数分布范围1-127
     // 生成并输出随机数
     std::map<void*, size_t> s;
     for (int i = 0; i < alloc_times; i++) {
@@ -61,14 +61,19 @@ void test_dealloc(int alloc_times = 10) {
 }
 
 void test_multi_thread() {
-    std::thread t1(std::bind(test_dealloc, 200));
+    std::thread t1(std::bind(test_dealloc, 1000));
     // std::thread t2(std::bind(test_dealloc, 20));
     t1.join();
     // t2.join();
     std::cout << "run successful" << std::endl;
 }
 
+void big_alloc() {
+    void* ptr = tcmalloc(8 * 127 * 1024);
+    tcfree(ptr, 8 * 127 * 1024);
+}
+
 int main() {
-    test_multi_thread();
+    big_alloc();
     return 0;
 }