深入浅出理解DeepSeek 3FS (3) 步步引导轻松理解内存管理，面试必看

https://github.com/watchpoints/master-cpp/blob/main/cpp/03_new.cpp

#include <iostream>
class Foo
{
public:
     int number;
     Foo(int n)
     {
       number = n;
     }
};
int main() {
    Foo* ptr = new Foo(10);
    return0;
}

__cxx_global_var_init:
        push    rbp                  # 1. 保存当前栈帧指针
        mov     rbp, rsp              # 2. 设置新的栈帧
        sub     rsp, 32               # 3. 在栈上分配 32 字节的局部变量空间
        mov     edi, 4                # 4. 设置 operator new 的参数，分配 4 字节的空间
        call    operator new(unsigned long)@PLT  # 5. 调用 operator new 进行内存分配
        mov     rdi, rax              # 6. 将分配的地址存入 rdi（作为 Foo::Foo(int) 构造函数的 this 指针）
        mov     rax, rdi              # 7. 复制 rdi 到 rax
        mov     qword ptr [rbp - 24], rax  # 8. 将 this 指针存入栈中的局部变量（用于后续操作）
        mov     esi, 10               # 9. 设置 Foo::Foo(int) 构造函数的参数，传递值 10
        call    Foo::Foo(int) [base object constructor]  # 10. 调用 Foo 类的构造函数
        jmp     .LBB0_1               # 11. 跳转到 .LBB0_1 继续执行后续逻辑

+----------------------+
| new 关键字 (C++)    |  [libstdc++.so]
| 调用 operator new   |
+----------------------+
        |
        v
+----------------------+
| std::operator new   |  [libstdc++.so]
| (分配内存, 调用 malloc) |
+----------------------+
        |
        v
+----------------------+
| malloc() (glibc)    |  [libc.so]
| 分配内存  根据大小判断     |
+----------------------+
        |
  +-----+------+
  |            |
  v            v
+----------------------+   +----------------------+
| brk() (堆扩展)       |   | mmap() (大块内存)   |
| size ≤ 128 KB        |   | size > 128 KB        |
| [syscall to kernel]  |   | [syscall to kernel]  |
+----------------------+   +----------------------+
        |                           |
        v                           v
+----------------------+   +----------------------+
| Linux 内核管理      |   | Linux 内核管理      |
| 分配物理内存         |   | 分配独立映射区域    |
+----------------------+   +----------------------+

 如果使用 `gcc` 编译 C++ 代码（不推荐），
就需要手动添加 `-lstdc++` 选项来链接标准库

gcc 03_new.cpp 
 
/usr/bin/ld: /tmp/ccZKC4VY.o: in function `main':
03_new.cpp:(.text+0x13): undefined reference to `operator new(unsigned long)'

gcc 03_new.cpp  -lstdc++(需要手工制定)

// A freestanding C runtime may not provide "malloc" -- but there is no
// other reasonable way to implement "operator new".
// 一些独立的 C 运行时环境可能不提供 "malloc"，但没有其他合理的方法来实现 "operator new"。
// 因此，这里直接声明 `malloc` 函数，保证后续调用不会出错。
extern"C"void *malloc (std::size_t);

#endif

// `operator new` 的弱定义版本，可以被用户自定义版本覆盖。
// 当 new 关键字被调用时，会执行此函数以分配内存。
_GLIBCXX_WEAK_DEFINITION void *
operator new (std::size_t sz) _GLIBCXX_THROW (std::bad_alloc)
{
void *p;

// `malloc(0)` 在不同的 C 标准库实现中可能会有不确定的行为（返回 nullptr 或者有效指针）。
// 为了避免这种不确定性，如果 `sz == 0`，则将其设为 1，确保 `malloc` 至少分配 1 字节。
if (__builtin_expect (sz == 0, false))
    sz = 1;

// 循环尝试调用 `malloc`，直到成功分配内存或者 `new_handler` 处理失败
while ((p = malloc (sz)) == 0) // 如果 `malloc(sz)` 返回 `nullptr`，表示内存分配失败
    {
      // 获取当前的 new_handler（可以通过 `std::set_new_handler` 设定）
      new_handler handler = std::get_new_handler ();
      
      // 如果没有设置 `new_handler`，则直接抛出 `std::bad_alloc` 异常，终止程序。
      if (!handler)
        _GLIBCXX_THROW_OR_ABORT(bad_alloc());
      
      // 调用用户自定义的 `new_handler`，该处理程序可能会尝试释放一些内存，
      // 或者执行其他策略（如记录日志、延迟执行），以便下一次 `malloc` 可能成功。
      handler ();
    }

// 成功分配内存，返回指针
return p;
}

https://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/new_op.cc
// ------------------ BEGIN COPY ------------------
// Implement all new and delete operators as weak definitions
// in this shared library, so that they can be overridden by programs
// that define non-weak copies of the functions.

static void* operator_new_impl(std::size_t size) {
if (size == 0)
    size = 1;
void* p;
while ((p = std::malloc(size)) == nullptr) {
    // If malloc fails and there is a new_handler,
    // call it to try free up memory.
    std::new_handler nh = std::get_new_handler();
    if (nh)
      nh();
    else
      break;
  }
return p;
}

#include <stdio.h>

int main() {
    printf("Hello, PLT!\n"); //使用libc这个动态库
    return 0;
}

#include <iostream>
#include <cstdlib>

// 自定义 operator new（强定义）
void* operator new(std::size_t size) {
    std::cout << "Custom operator new called, size: " << size << std::endl;
    returnmalloc(size);
}

int main() {
    int* p = newint; // 这里会调用自定义的 operator new
    delete p;
    return0;
}

 输出

Custom operatornew called, size: 4

- `operatornew` 在标准库中是弱符号（`__attribute__((weak))`）。
    
- 当程序员提供了自己的 `operatornew`，它作为 **强符号** 替换了标准库的实现。
    
- 因此，`new` 关键字调用的是自定义的 `operatornew`，而不是标准库的版本。

// Override global new/delete with custom memory allocator.
// 用强符号代替标准库的弱符号
void *operator new(size_t size) { return hf3fs::memory::allocate(size); }

void operator delete(void *mem) noexcept { hf3fs::memory::deallocate(mem); }


inline void *allocate(size_t size) { return std::malloc(size); }
  

+----------------------+
| new 关键字 (C++)    |  [c++语法]
| 调用 operator new   |
+----------------------+
        |
        v
+----------------------+
| std::operator new   |  [libstdc++.so]
| (分配内存, 调用 malloc) |
+----------------------+
        |
        v
+----------------------+
| malloc() (glibc)    |  [glibc.so]
| 分配内存  根据大小判断     |
+----------------------+
        |
  +-----+------+
  |            |
  v            v
+----------------------+   +----------------------+
| brk() (堆扩展)       |   | mmap() (大块内存)   |
| size ≤ 128 KB        |   | size > 128 KB        |
| [syscall to kernel]  |   | [syscall to kernel]  |
+----------------------+   +----------------------+
        |                           |
        v                           v
+----------------------+   +----------------------+
| Linux 内核管理      |   | Linux 内核管理      |
| 分配物理内存         |   | 分配独立映射区域    |

new 操作
 ├── operator new(size)       // 调用标准库中的 operator new
 │    ├── malloc(size)       // 调用 C 语言的 malloc
 │    │    ├── _int_malloc() // glibc 内部分配
 │    │    │    ├── sbrk()   // 小块分配（扩展 heap）
 │    │    │    ├── mmap()   // 大块分配（独立映射）
 │    │    └── 返回分配的内存地址
 │    └── 返回指针
 ├── 构造函数初始化对象
 └── 返回对象指针

// wrap.c

#include <stdio.h>

#include <stdlib.h>

void* __real_malloc(size_t size); // 只声明不定义__real_malloc

void* __wrap_malloc(size_t size) // 定义__wrap_malloc

{

    printf("__wrap_malloc called, size:%zd\n", size); // log输出

    return __real_malloc(size); // 通过__real_malloc调用真正的malloc

}

下面是测试用例：

// test.c

#include <stdio.h>

#include <stdlib.h>

int main()

{

    char* c = (char*)malloc(sizeof(char)); // 调用malloc

    printf("c = %p\n", c);

    free(c); // 调用free，防止内存泄漏

    return 0;

}
下面是编译链接过程：

gcc -c wrap.c test.c

gcc -Wl,--wrap,malloc -o test wrap.o test.o // 链接参数-Wl,--wrap,malloc12

结果查看：

./test

    


### 3. C++ 中的特殊注意

- **C++ 名字修饰问题：**  
    如果你用 C++ 来实现包装函数（比如 __wrap_malloc），一定要在函数声明前加上 `extern "C"`。  
    这样做可以防止 C++ 的名字修饰（name mangling），确保链接器能正确找到 `__wrap_malloc`。  
    示例：
    
    ```cpp
    extern "C" void* __wrap_malloc(size_t size) {
        // 包装逻辑
        return __real_malloc(size);
    }
    ```
    

---



## 3FS 是怎么做的

- 定义宏开关
CMakeLists.txt
option(OVERRIDE_CXX_NEW_DELETE "Override C++ new/delete operator" OFF)

- 宏开关开启不同特性（c语言没有c++函数重载这个特性）

```c
src\memory\common\OverrideCppNewDelete.h

#ifdef OVERRIDE_CXX_NEW_DELETE
void *allocate(size_t size)
#else
inline void *allocate(size_t size) { return std::malloc(size); }

gAllocator = getMemoryAllocatorFunc();


void *allocate(size_t size) {
//这里通过环境变量 MEMORY_ALLOCATOR_LIB_PATH 来指定要加载的内存分配器库。
//例如，如果你想使用jemalloc.tcmalloc：
//set MEMORY_ALLOCATOR_LIB_PATH=D:\path\to\jemalloc.dll
//set MEMORY_ALLOCATOR_LIB_PATH=D:\path\to\tcmalloc.dll
if (!gAllocatorInited) {
    std::call_once(gInitOnce, loadMemoryAllocatorLib);
    gAllocatorInited = true;
  }
//- 首次调用内存分配相关函数时触发加载


void *mem;

if (gAllocator == nullptr)
    mem = std::malloc(allocateSize);
    // 使用系统默认分配器
else

    mem = gAllocator->allocate(allocateSize);
    // 使用自定义分配器

#define GET_MEMORY_ALLOCATOR_FUNC_NAME "getMemoryAllocator"

//这种设计允许在运行时动态切换不同的内存分配器实现，提供了很好的灵活性和可扩展性。
namespace hf3fs::memory {
class MemoryAllocatorInterface {

public:

virtual ~MemoryAllocatorInterface() = default;

virtual void *allocate(size_t size) = 0;

virtual void deallocate(void *mem) = 0;

virtual void *memalign(size_t alignment, size_t size) = 0;

virtual void logstatus(char *buf, size_t size) = 0;

virtual bool profiling(bool active, const char *prefix) = 0;

};

using GetMemoryAllocatorFunc = MemoryAllocatorInterface *(*)();
//这种设计允许在运行时动态切换不同的内存分配器实现，提供了很好的灵活性和可扩展性。
//这种设计允许在运行时动态切换不同的内存分配器实现，提供了很好的灵活性和可扩展性。

class JemallocMemoryAllocator : public MemoryAllocatorInterface
   void *allocate(size_t size) override { return je_malloc(size); }
   bool profiling(bool active, const char *prefix) override


extern "C" {

hf3fs::memory::MemoryAllocatorInterface *getMemoryAllocator() {

static hf3fs::memory::JemallocMemoryAllocator jemalloc;

return &jemalloc;
}


class CustomMemoryAllocator :public MemoryAllocatorInterface
void *allocate(size_t size) override {
        // 实现内存分配逻辑
        returnmalloc(size);
    }
    
// 导出获取分配器的函数
extern"C"MemoryAllocatorInterface* getMemoryAllocator() {
    static CustomMemoryAllocator allocator;
    return &allocator;
}

static void loadMemoryAllocatorLib() {

  GetMemoryAllocatorFunc getMemoryAllocatorFunc = nullptr;
constchar *mallocLibPath =  std::getenv("MEMORY_ALLOCATOR_LIB_PATH");
  mallocLib = ::dlopen(mallocLibPath, RTLD_NOW | RTLD_GLOBAL);
//dlsym 函数每次调用只能查找和返回一个符号（函数或变量）的地址。
//# 获取函数的运行时地址
  getMemoryAllocatorFunc = (GetMemoryAllocatorFunc)::dlsym(mallocLib, GET_MEMORY_ALLOCATOR_FUNC_NAME);
//GetMemoryAllocatorFunc
工作流程是：

1. 通过 dlsym 获取函数指针
2. 调用该函数指针获取分配器实例
3. 将实例保存到全局变量 gAllocator [疑问 这个我没看懂 怎么关联的]
4. 后续的内