C++性能优化 —— TCMalloc的原理与使用

06-29 646阅读

一、TCMalloc简介

1、TCMalloc简介

TCMalloc(Thread-Caching Malloc，线程缓存的malloc）是Google开发的内存分配算法库，最初作为Google性能工具库 perftools 的一部分，提供高效的多线程内存管理实现，用于替代操作系统的内存分配相关的函数（malloc、free，new，new[]等），具有减少内存碎片、适用于多核、更好的并行性支持等特性。

TCMalloc属于gperftools，gperftools项目包括heap-checker、heap-profiler、cpu-profiler、TCMalloc等组件。

gperftools源码地址：

https://github.com/gperftools/gperftools

TCMalloc源码地址：

GitHub - google/tcmalloc

2、TCMalloc安装

（1）TCMalloc源码安装

bazel源增加：

/etc/yum.repos.d/bazel.repo
[copr:copr.fedorainfracloud.org:vbatts:bazel]
name=Copr repo for bazel owned by vbatts
baseurl=https://download.copr.fedorainfracloud.org/results/vbatts/bazel/epel-7-$basearch/
type=rpm-md
skip_if_unavailable=True
gpgcheck=1
gpgkey=https://download.copr.fedorainfracloud.org/results/vbatts/bazel/pubkey.gpg
repo_gpgcheck=0
enabled=1
enabled_metadata=1

在线安装bazel：

yum install bazel3

TCMalloc源码下载：

git clone https://github.com/google/tcmalloc.git
cd tcmalloc && bazel test //tcmalloc/...

由于TCMalloc依赖gcc 9.2+,clang 9.0+: -std=c++17，因此推荐使用其它方式安装。

（2）gperftools源码安装

gperftools源码下载：

git clone https://github.com/gperftools/gperftools.git

生成构建工具：

autogen.sh

配置编译选项：

configure --disable-debugalloc --enable-minimal

编译：make -j4

安装：make install

TCMalloc库安装在/usr/local/lib目录下。

（3）在线安装

epel源安装：

yum install -y epel-release

gperftools安装：

yum install -y gperftools.x86_64

3、Linux64位系统支持

在Linux64位系统环境下，gperftools使用glibc内置的stack-unwinder可能会引发死锁，因此官方推荐在配置和安装gperftools前，先安装libunwind-0.99-beta。

在Linux64位系统上使用libunwind只能使用TCMalloc，但heap-checker、heap-profiler和cpu-profiler不能正常使用。

如果不希望安装libunwind，也可以用gperftools内置的stack unwinder，但需要应用程序、TCMalloc库、系统库（比如libc）在编译时开启帧指针（frame pointer）选项。

在x86-64下，编译时开启帧指针选项并不是默认行为。因此需要指定-fno-omit-frame-pointer编译所有应用程序，然后在configure时通过--enable-frame-pointers选项使用内置的gperftools stack unwinder。

二、TCMalloc架构

1、TCMalloc架构

C++性能优化 —— TCMalloc的原理与使用

Front-end（前端）：负责提供快速分配和重分配内存给应用，由Per-thread cache和Per-CPU cache两部分组成。

Middle-end（中台）：负责给Front-end提供缓存。当Front-end缓存内存不够用时，从Middle-end申请内存。

Back-end（后端）：负责从操作系统获取内存，并给Middle-end提供缓存使用。

C++性能优化 —— TCMalloc的原理与使用

TCMalloc中每个线程都有独立的线程缓存ThreadCache，线程的内存分配请求会向ThreadCache申请，ThreadCache内存不够用会向CentralCache申请，CentralCache内存不够用时会向PageHeap申请，PageHeap不够用就会向OS操作系统申请。

相关视频推荐

linux c/c++后端开发中的重点技术：内存管理（内存管理架构、numa、slab、vmalloc、内存池、内存泄漏、物理内存、虚拟内存、MMU机制C++性能优化 —— TCMalloc的原理与使用https://www.bilibili.com/video/BV1Vc411F7wv/

Linux C/C++开发（后端/音视频/游戏/嵌入式/高性能网络/存储/基础架构/安全）

需要C/C++ Linux服务器架构师学习资料加qun812855908获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享

C++性能优化 —— TCMalloc的原理与使用

TCMalloc将整个虚拟内存空间划分为n个同等大小的Page，将n个连续的page连接在一起组成一个Span；PageHeap向OS申请内存，申请的span可能只有一个page，也可能有n个page。

（1）Page

Page是操作系统对内存管理的单位，TCMalloc中以Page为单位管理内存，Page默认大小为8KB，通常为Linux系统中Page大小的倍数关系，如8、32、64，可以在编译选项配置时通过--with-tcmalloc-pagesize参数指定。

Page越大，TCMalloc的速度相对越快，但其占用的内存也会越高。默认Page大小通过减少内存碎片来最小化内存使用，使用更大的Page则会带来更多的内存碎片，但速度上会有所提升。

（2）Span

Span是PageHeap中管理内存Page的单位，由一个或多个连续的Page组成，比如2个Page组成的span，多个span使用链表来管理，TCMalloc以Span为单位向操作系统申请内存。

C++性能优化 —— TCMalloc的原理与使用

第1个span包含2个page，第2个和第4个span包含3个page，第3个span包含5个page。

Span会记录起始page的PageID（start）以及所包含page的数量（length）。

Span要么被拆分成多个相同size class的小对象用于小对象分配，要么作为一个整体用于中对象或大对象分配。当作用作小对象分配时，span的sizeclass成员变量记录了其对应的size class。

span中包含两个Span类型的指针（prev，next），用于将多个span以链表的形式存储。

Span有三种状态：IN_USE、ON_NORMAL_FREELIST、ON_RETURNED_FREELIST。

IN_USE是正在使用中，要么被拆分成小对象分配给CentralCache或者ThreadCache，要么已经分配给应用程序。

ON_NORMAL_FREELIST是空闲状态。

ON_RETURNED_FREELIST指span对应的内存已经被PageHeap释放给系统。

（3）ThreadCache

ThreadCache是每个线程独立拥有的Cache，包含多个空闲内存链表（size classes），每一个链表（size-class）都有大小相同的object。

线程可以从各自Thread Cache的FreeList获取对象，不需要加锁，所以速度很快。如果ThreadCache的FreeList为空，需要从CentralCache中的CentralFreeList中获取若干个object到ThreadCache对应的size class列表中，然后再取出其中一个object返回。

（4）Size Class

TCMalloc定义了很多个size class，每个size class都维护了一个可分配的FreeList，FreeList中的每一项称为一个object，同一个size-class的FreeList中每个object大小相同。

在申请小内存时(小于256K)，TCMalloc会根据申请内存大小映射到某个size-class中。比如，申请0到8个字节的大小时，会被映射到size-class1中，分配8个字节大小；申请9到16字节大小时，会被映射到size-class2中，分配16个字节大小，以此类推。

C++性能优化 —— TCMalloc的原理与使用

（5）CentralCache

CentralCache是ThreadCache的缓存，ThreadCache内存不足时会向CentralCache申请。CentralCache本质是一组CentralFreeList，链表数量和ThreadCache数量相同。ThreadCache中内存过多时，可以放回CentralCache中。

如果CentralFreeList中的object不够，CentralFreeList会向PageHeap申请一连串由Span组成的Page，并将申请的Page切割成一系列的object后，再将部分object转移给ThreadCache。

当申请的内存大于256K时，不在通过ThreadCache分配，而是通过PageHeap直接分配大内存。

C++性能优化 —— TCMalloc的原理与使用

（6）PageHeap

PageHeap保存存储Span的若干链表，CentralCache内存不足时，可以从PageHeap获取Span，然后把Span切割成object。

PageHeap申请内存时按照Page申请，但管理内存的基本单位是Span，Span代表若干连续Page。

C++性能优化 —— TCMalloc的原理与使用

C++性能优化 —— TCMalloc的原理与使用

PageHeap组织结构如下：

C++性能优化 —— TCMalloc的原理与使用

2、Front-end

Front-end处理对特定大小内存的请求，有一个内存缓存用于分配或保存空闲内存。Front-end缓存一次只能由单个线程访问，不需要任何锁，因此大多数分配和释放都很快。

只要有适当大小的缓存内存，Front-end将满足任何请求。如果特定大小的缓存为空，Front-end将从Middle-end请求一批内存来填充缓存。Middle-end包括CentralfReelList和TransferCache。

如果Middle-end内存耗尽，或者用户请求的内存大小大于Front-end缓存的最大值，则请求将转到Back-end，以满足大块内存分配，或重新填充Middle-end的缓存。Back-end也称为PageHeap。

Front-end由两种不同的实现模式：

（1）Per-thread

TCMalloc最初支持对象的Per-thread缓存，但会导致内存占用随着线程数增加而增加。现代应用程序可能有大量的线程，会导致每个线程占用内存累积起来很大，也可能会导致由单个较小线程缓存累积起来的内存占用会很大。

（2）Per-CPU

TCMalloc近期开始支持Per-CPU模式。在Per-CPU模式下，系统中的每个逻辑CPU都有自己的缓存，可以从中分配内存。在x86架构，逻辑CPU相当于一个超线程。

3、Middle-end

Middle-end负责向Front-end提供内存并将内存返回Back-end。Middle-end由Transfer cache和Central free list组成，每个类大小都有一个Transfer cache和一个Central free list。缓存由互斥锁保护，因此访问缓存会产生串行化成本。

（1）Transfer cache

当Front-end请求内存或返回内存时，将访问Transfer cache。

Transfer cache保存一个指向空闲内存的指针数组，可以快速地将对象移动到数组中，或者代表Front-end从数组中获取对象。

当一个线程正在分配另一个线程释放的内存时，Transfer cache就可以得到内存名称。Transfer cache允许内存在两个不同的线程之间快速流动。

如果Transfer cache无法满足内存请求，或者没有足够的空间容纳返回的对象，Transfer cache将访问Central free list。

（2）Central Free List

Central Free List使用spans管理内存，span是一个或多个TCMalloc内存Page的集合。

一个或多个对象的内存请求由Central Free List来满足，方法是从span中提取对象，直到满足请求为止。如果span中没有足够的可用对象，则会从Back-end请求更多的span。

当对象返回到Central Free List时，每个对象都映射到其所属的span（使用pagemap，然后释放到span中）。如果驻留在指定span中的所有对象都返回给span，则整个span将返回给Back-end。

4、Back-end

TCMalloc中Back-end有三项职责：

（1）管理大量未使用的内存块。

（2）负责在没有合适大小的内存来满足分配请求时从操作系统获取内存。

（3）负责将不需要的内存返回给操作系统。

TCMalloc有两种Back-end：

（1）Legacy Pageheap，管理TCMalloc中Page大小的内存块。

Legacy Pageheap是一个可用内存连续页面的特定长度的空闲列表数组。对于k128），或者是要分配一块1MB以内的内存，但无法由中对象分配逻辑来满足，此时k 128，则将其插入到大span的set中，否则，将其插入到对应的小span链表中。

（3）如果找不到合适的span，则使用sbrk或mmap向系统申请新的内存以生成新的span，并重新执行中对象或大对象的分配算法。

四、TCMalloc使用指南

1、TCMalloc库简介

libtcmalloc_and_profiler.so

libtcmalloc_debug.so：Debug版本。

libtcmalloc_minimal_debug.so：

libtcmalloc_minimal.so

libtcmalloc.so

libtcmalloc_minimal版本不包含heap profiler和heap checker。

2、动态库方式

通过-ltcmalloc或-ltcmalloc_minimal将TCMalloc链接到应用程序。

通过LD_PRELOAD预载入TCMalloc库可以不用重新编译应用程序即可使用TCMalloc。

LD_PRELOAD="/usr/lib/libtcmalloc.so"

3、静态库方式

在编译选项的最后加入/usr/local/lib/libtcmalloc_minimal.a链接静态库。

4、TCMalloc生效

TCMalloc在libc_override.h中实现了覆盖机制，在使用指定-ltcmalloc链接后，应用程序对malloc、free、new、delete等调用就从默认glibc中的函数调用变为TCMalloc库中相应的函数调用。

（1）仅使用GLibc库

在glibc中，内存分配相关的函数都是弱符号（weak symbol），因此TCMalloc只需要定义自己的函数将其覆盖即可。

libc_override_redefine.h中定义如下：

void* operator new(size_t size) { return TCMallocInternalNew(size); }
void operator delete(void* p) noexcept { TCMallocInternalDelete(p); }
void* operator new[](size_t size) { return TCMallocInternalNewArray(size); }
void operator delete[](void* p) noexcept { TCMallocInternalDeleteArray(p); }
void* operator new(size_t size, const std::nothrow_t& nt) noexcept {
  return TCMallocInternalNewNothrow(size, nt);
}
 
void* operator new[](size_t size, const std::nothrow_t& nt) noexcept {
  return TCMallocInternalNewArrayNothrow(size, nt);
}
 
void operator delete(void* ptr, const std::nothrow_t& nt) noexcept {
  return TCMallocInternalDeleteNothrow(ptr, nt);
}
 
void operator delete[](void* ptr, const std::nothrow_t& nt) noexcept {
  return TCMallocInternalDeleteArrayNothrow(ptr, nt);
}
 
extern "C" {
    void* malloc(size_t s) noexcept { return TCMallocInternalMalloc(s); }
    void free(void* p) noexcept { TCMallocInternalFree(p); }
    void sdallocx(void* p, size_t s, int flags) {
      TCMallocInternalSdallocx(p, s, flags);
    }
 
    void* realloc(void* p, size_t s) noexcept {
      return TCMallocInternalRealloc(p, s);
    }
 
    void* calloc(size_t n, size_t s) noexcept {
      return TCMallocInternalCalloc(n, s);
    }
 
    void cfree(void* p) noexcept { TCMallocInternalCfree(p); }
 
    void* memalign(size_t a, size_t s) noexcept {
      return TCMallocInternalMemalign(a, s);
    }
 
    void* valloc(size_t s) noexcept { return TCMallocInternalValloc(s); }
    void* pvalloc(size_t s) noexcept { return TCMallocInternalPvalloc(s); }
    int posix_memalign(void** r, size_t a, size_t s) noexcept {
      return TCMallocInternalPosixMemalign(r, a, s);
    }
 
    void malloc_stats(void) noexcept { TCMallocInternalMallocStats(); }
    int mallopt(int cmd, int v) noexcept { return TCMallocInternalMallOpt(cmd, v); }
    #ifdef HAVE_STRUCT_MALLINFO
    struct mallinfo mallinfo(void) noexcept {
      return TCMallocInternalMallocInfo();
    }
    #endif
 
    size_t malloc_size(void* p) noexcept { return TCMallocInternalMallocSize(p); }
    size_t malloc_usable_size(void* p) noexcept {
      return TCMallocInternalMallocSize(p);
    }
 
}  // extern "C"

（2）使用GCC编译器编译

如果使用了GCC编译器，则使用其支持的函数属性：alias。

libc_override_gcc_and_weak.h：

#define TCMALLOC_ALIAS(tc_fn) \
  __attribute__((alias(#tc_fn), visibility("default")))
 
void* operator new(size_t size) noexcept(false)
    TCMALLOC_ALIAS(TCMallocInternalNew);
 
void operator delete(void* p) noexcept TCMALLOC_ALIAS(TCMallocInternalDelete);
 
void operator delete(void* p, size_t size) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteSized);
 
void* operator new[](size_t size) noexcept(false)
    TCMALLOC_ALIAS(TCMallocInternalNewArray);
 
void operator delete[](void* p) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteArray);
 
void operator delete[](void* p, size_t size) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteArraySized);
 
void* operator new(size_t size, const std::nothrow_t& nt) noexcept
    TCMALLOC_ALIAS(TCMallocInternalNewNothrow);
 
void* operator new[](size_t size, const std::nothrow_t& nt) noexcept
    TCMALLOC_ALIAS(TCMallocInternalNewArrayNothrow);
 
void operator delete(void* p, const std::nothrow_t& nt) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteNothrow);
 
void operator delete[](void* p, const std::nothrow_t& nt) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteArrayNothrow);
 
void* operator new(size_t size, std::align_val_t alignment) noexcept(false)
    TCMALLOC_ALIAS(TCMallocInternalNewAligned);
 
void* operator new(size_t size, std::align_val_t alignment,
                   const std::nothrow_t&) noexcept
    TCMALLOC_ALIAS(TCMallocInternalNewAligned_nothrow);
 
void operator delete(void* p, std::align_val_t alignment) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteAligned);
 
void operator delete(void* p, std::align_val_t alignment,
                     const std::nothrow_t&) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteAligned_nothrow);
 
void operator delete(void* p, size_t size, std::align_val_t alignment) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteSizedAligned);
 
void* operator new[](size_t size, std::align_val_t alignment) noexcept(false)
    TCMALLOC_ALIAS(TCMallocInternalNewArrayAligned);
 
void* operator new[](size_t size, std::align_val_t alignment,
                     const std::nothrow_t&) noexcept
    TCMALLOC_ALIAS(TCMallocInternalNewArrayAligned_nothrow);
 
void operator delete[](void* p, std::align_val_t alignment) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteArrayAligned);
 
void operator delete[](void* p, std::align_val_t alignment,
                       const std::nothrow_t&) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteArrayAligned_nothrow);
 
void operator delete[](void* p, size_t size,
                       std::align_val_t alignemnt) noexcept
    TCMALLOC_ALIAS(TCMallocInternalDeleteArraySizedAligned);
 
 
extern "C" {
 
void* malloc(size_t size) noexcept TCMALLOC_ALIAS(TCMallocInternalMalloc);
 
void free(void* ptr) noexcept TCMALLOC_ALIAS(TCMallocInternalFree);
 
void sdallocx(void* ptr, size_t size, int flags) noexcept
 
    TCMALLOC_ALIAS(TCMallocInternalSdallocx);
 
void* realloc(void* ptr, size_t size) noexcept
 
    TCMALLOC_ALIAS(TCMallocInternalRealloc);
 
void* calloc(size_t n, size_t size) noexcept
 
    TCMALLOC_ALIAS(TCMallocInternalCalloc);
 
void cfree(void* ptr) noexcept TCMALLOC_ALIAS(TCMallocInternalCfree);
 
void* memalign(size_t align, size_t s) noexcept
 
    TCMALLOC_ALIAS(TCMallocInternalMemalign);
 
void* aligned_alloc(size_t align, size_t s) noexcept
 
    TCMALLOC_ALIAS(TCMallocInternalAlignedAlloc);
 
void* valloc(size_t size) noexcept TCMALLOC_ALIAS(TCMallocInternalValloc);
 
void* pvalloc(size_t size) noexcept TCMALLOC_ALIAS(TCMallocInternalPvalloc);
 
int posix_memalign(void** r, size_t a, size_t s) noexcept
 
    TCMALLOC_ALIAS(TCMallocInternalPosixMemalign);
 
void malloc_stats(void) noexcept TCMALLOC_ALIAS(TCMallocInternalMallocStats);
 
int mallopt(int cmd, int value) noexcept
 
    TCMALLOC_ALIAS(TCMallocInternalMallOpt);
 
struct mallinfo mallinfo(void) noexcept
 
    TCMALLOC_ALIAS(TCMallocInternalMallocInfo);
 
size_t malloc_size(void* p) noexcept TCMALLOC_ALIAS(TCMallocInternalMallocSize);
 
size_t malloc_usable_size(void* p) noexcept
 
    TCMALLOC_ALIAS(TCMallocInternalMallocSize);
 
}  // extern "C"

5、TCMalloc调优

默认情况下，TCMaloc会将长时间未用的内存交还系统。tcmalloc_release_rate标识用于控制交回频率，可以在运行时强制调用ReleaseFreeMemory回收未使用内存。

MallocExtension::instance()->ReleaseFreeMemory();

通过 SetMemoryReleaseRate来设置tcmalloc_release_rate。如果设置为0，代表永远不交回；数字越大代表交回的频率越大，值在0-10之间，可以通过设置 TCMALLOC_RELEASE_RATE环境变量来设置。

GetMemoryReleaseRate可以查看当前释放的概率值。

TCMALLOC_SAMPLE_PARAMETER：采样时间间隔，默认值为0。

TCMALLOC_RELEASE_RATE：释放未使用内存的频率，默认值为1.0。

TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD：内存最大分配阈值，默认值为1073741824（1GB）。

TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES：分配给线程缓冲的最大内存上限，默认值为16777216（16MB）。

6、TCMalloc测试

malloc.cpp：

#include 
#include 
#include 
#include 
#include 
 
#define MAX_OBJECT_NUMBER       (1024)
#define MAX_MEMORY_SIZE         (1024*100)
 
struct BufferUnit{
   int   size;
   char* data;
};
 
struct BufferUnit   buffer_units[MAX_OBJECT_NUMBER];
 
void MallocBuffer(int buffer_size) {
 
for(int i=0; i
VPS购买请点击我

文章版权声明：除非注明，否则均为主机测评原创文章，转载或复制请以超链接形式并注明出处。

相关阅读

目录[+]