C++ `jemalloc` / `tcmalloc` 在多线程环境下的内存分配性能

哈喽，各位好！今天咱们来聊聊C++多线程环境下内存分配那点事儿。特别是 jemalloc 和 tcmalloc 这两位大神，它们是如何在多线程的世界里大显身手的。

前言：内存分配，你别小看它！

在单线程程序里，内存分配就像是你自己在家收拾东西，想怎么搞就怎么搞，效率很高。但是，到了多线程程序里，这就好比一家人（多个线程）共用一个储物间（堆），如果大家不排队、不协调，那肯定乱成一锅粥，效率直线下降。

所以，多线程环境下的内存分配，绝对是性能瓶颈的大户。如果分配器效率不高，线程们就会频繁地争抢锁，导致程序卡顿，CPU利用率低下。

主角登场：jemalloc 和 tcmalloc

jemalloc (Facebook出品) 和 tcmalloc (Google出品) 都是专门为多线程环境优化的内存分配器。它们的核心思想都是：减少锁的竞争，提高并发度。

核心思想：分而治之

这两位大神都采用了“分而治之”的思想，将整个堆分成多个小的区域，让不同的线程在不同的区域里分配内存，从而减少锁的竞争。

jemalloc 的秘密武器： arenas

jemalloc 使用了 arenas 的概念。你可以把 arena 想象成独立的内存池，每个线程优先从自己的 arena 里分配内存。如果线程的 arena 空间不够了，jemalloc 才会考虑从全局的 arena 或者其他的 arena 里分配。

线程局部缓存 (Thread-Local Cache): 每个线程都有自己的 arena，分配内存时首先检查自己的 arena，减少了对全局锁的争用。
多级分配 (Multiple Size Classes): jemalloc 将内存块分成不同的大小等级，方便快速查找和分配。
内存碎片整理 (Fragmentation Mitigation): jemalloc 内置了碎片整理机制，可以减少内存碎片，提高内存利用率。

tcmalloc 的秘密武器：thread caches

tcmalloc 也有类似的机制，叫做 thread caches。每个线程拥有一个或多个 thread caches，这些 caches 缓存了不同大小的空闲内存块。线程首先从自己的 cache 里分配内存，如果 cache 里没有合适的块，再从全局的堆里分配。

线程局部缓存 (Thread-Local Cache): 与 jemalloc 类似，tcmalloc 也使用线程局部缓存来减少锁竞争。
中心化堆 (Central Heap): 当线程局部缓存为空时，tcmalloc 会从中心化堆分配内存。
页堆管理 (Page Heap): tcmalloc 使用页堆来管理大块内存。

代码示例：jemalloc 的简单使用

#include <iostream>
#include <thread>
#include <vector>
#include <jemalloc/jemalloc.h> // 引入 jemalloc 头文件

void* allocate_memory(size_t size) {
  void* ptr = malloc(size); // 使用 jemalloc 分配内存
  if (ptr == nullptr) {
    std::cerr << "Memory allocation failed!" << std::endl;
    exit(1);
  }
  return ptr;
}

void free_memory(void* ptr) {
  free(ptr); // 使用 jemalloc 释放内存
}

void thread_function(int thread_id, size_t allocation_size, int num_allocations) {
  for (int i = 0; i < num_allocations; ++i) {
    void* data = allocate_memory(allocation_size);
    // 在这里使用分配的内存
    memset(data, 0, allocation_size); // 简单地初始化内存
    free_memory(data);
  }
  std::cout << "Thread " << thread_id << " finished." << std::endl;
}

int main() {
  const int num_threads = 4;
  const size_t allocation_size = 1024 * 1024; // 1MB
  const int num_allocations = 100;

  std::vector<std::thread> threads;
  for (int i = 0; i < num_threads; ++i) {
    threads.emplace_back(thread_function, i, allocation_size, num_allocations);
  }

  for (auto& thread : threads) {
    thread.join();
  }

  std::cout << "All threads finished." << std::endl;
  return 0;
}

编译和链接 jemalloc:

要使用 jemalloc，你需要先安装它，然后编译你的代码并链接 jemalloc 库。

安装:
- Linux (Debian/Ubuntu): sudo apt-get install libjemalloc-dev
- macOS (Homebrew): brew install jemalloc

编译和链接:

g++ your_code.cpp -o your_program -ljemalloc

代码示例：tcmalloc 的简单使用

#include <iostream>
#include <thread>
#include <vector>
#include <gperftools/tcmalloc.h> // 引入 tcmalloc 头文件

void* allocate_memory(size_t size) {
  void* ptr = malloc(size); // 使用 tcmalloc 分配内存
  if (ptr == nullptr) {
    std::cerr << "Memory allocation failed!" << std::endl;
    exit(1);
  }
  return ptr;
}

void free_memory(void* ptr) {
  free(ptr); // 使用 tcmalloc 释放内存
}

void thread_function(int thread_id, size_t allocation_size, int num_allocations) {
  for (int i = 0; i < num_allocations; ++i) {
    void* data = allocate_memory(allocation_size);
    // 在这里使用分配的内存
    memset(data, 0, allocation_size); // 简单地初始化内存
    free_memory(data);
  }
  std::cout << "Thread " << thread_id << " finished." << std::endl;
}

int main() {
  const int num_threads = 4;
  const size_t allocation_size = 1024 * 1024; // 1MB
  const int num_allocations = 100;

  std::vector<std::thread> threads;
  for (int i = 0; i < num_threads; ++i) {
    threads.emplace_back(thread_function, i, allocation_size, num_allocations);
  }

  for (auto& thread : threads) {
    thread.join();
  }

  std::cout << "All threads finished." << std::endl;
  return 0;
}

编译和链接 tcmalloc:

要使用 tcmalloc，你需要先安装 gperftools，然后编译你的代码并链接 tcmalloc 库。

安装:
- Linux (Debian/Ubuntu): sudo apt-get install libgoogle-perftools-dev
- macOS (Homebrew): brew install gperftools

编译和链接:

g++ your_code.cpp -o your_program -ltcmalloc

如何选择：jemalloc vs tcmalloc

jemalloc 和 tcmalloc 都是非常优秀的内存分配器，它们在多线程环境下的性能都比标准的 malloc 要好得多。那么，我们该如何选择呢？

特性	`jemalloc`	`tcmalloc`
设计理念	分而治之，多 arenas	线程局部缓存，中心化堆
内存碎片整理	内置碎片整理机制	依赖于操作系统的内存管理
监控和调试	提供了丰富的监控和调试工具	提供了性能分析工具 (pprof)
适用场景	对内存碎片敏感，需要精细控制内存分配的应用	对性能要求高，需要快速分配和释放内存的应用
社区活跃度	活跃	活跃
易用性	使用简单，配置灵活	使用简单，集成方便

一些经验之谈：

性能测试: 在实际应用中，最好对 jemalloc 和 tcmalloc 进行性能测试，看看哪个更适合你的应用场景。
监控工具: jemalloc 和 tcmalloc 都提供了丰富的监控工具，可以帮助你了解内存分配的情况，及时发现问题。
配置选项: jemalloc 和 tcmalloc 都有很多配置选项，可以根据你的应用需求进行调整。例如，你可以调整 arena 的数量，或者调整 thread caches 的大小。
内存泄漏: 即使使用了优秀的内存分配器，也需要注意内存泄漏的问题。可以使用 Valgrind 等工具来检测内存泄漏。
大页内存: 在某些情况下，使用大页内存 (Huge Pages) 可以提高内存分配的性能。jemalloc 和 tcmalloc 都支持大页内存。
NUMA 架构: 如果你的系统是 NUMA 架构，需要注意内存的本地性。尽量让线程在本地的内存节点上分配内存。jemalloc 和 tcmalloc 都有 NUMA 感知的特性。

深入研究：jemalloc 和 tcmalloc 的内部实现

如果你想更深入地了解 jemalloc 和 tcmalloc 的内部实现，可以阅读它们的源代码。这绝对是一次非常有价值的学习体验。

jemalloc 源代码: https://github.com/jemalloc/jemalloc
tcmalloc 源代码: 包含在 gperftools 项目中 https://github.com/gperftools/gperftools

总结：内存分配，选择适合自己的才是最好的！

jemalloc 和 tcmalloc 都是非常优秀的内存分配器，它们在多线程环境下能够显著提高内存分配的性能。选择哪个取决于你的具体应用场景和需求。记住，没有银弹，只有最适合你的解决方案。

希望今天的分享对大家有所帮助！下次再见！

发表回复 取消回复

发表回复取消回复