#include <vld.h>

#include <vld.h>
#include <iostream>

int main() {
    // 制造一個(gè)內(nèi)存泄漏
    int* leakedMemory = new int[100];
    
    std::cout << "程序運(yùn)行中..." << std::endl;
    // 注意：這里沒(méi)有 delete[] leakedMemory
    
    return 0;
}

#include <mcheck.h>

int main() {
    mtrace();    // 開(kāi)啟記賬本
    
    // 你的代碼...
    
    muntrace();  // 合上記賬本
    return 0;
}

# 設(shè)置日志文件
export MALLOC_TRACE=mtrace.log

# 編譯并運(yùn)行
g++ -g program.cpp -o program
./program

# 查看結(jié)果
mtrace ./program mtrace.log

Memory not freed:
-----------------
           Address     Size     Caller
0x000055974621b6a0      0x4  at 0x7f94b084170c
0x000055974621b6c0     0x14  at 0x7f94b084170c

# 下載安裝包 DrMemory-Linux-2.6.0.tar.gz
訪(fǎng)問(wèn)網(wǎng)址: https://drmemory.org/page_download.html 
# 解壓并設(shè)置
tar -zxvf DrMemory-Linux-2.6.0.tar.gz
echo 'export PATH=$PATH:~/drmemory/DrMemory-Linux-2.5.0/bin' >> ~/.bashrc
source ~/.bashrc

# 編譯時(shí)添加調(diào)試信息
g++ -g your_program.cpp -o your_program

# 啟動(dòng)檢測(cè)
drmemory -- ./your_program

# 部分輸出：
ERRORS FOUND:
~~Dr.M~~ 0 unique, 0 total unaddressable access(es)      # 未分配內(nèi)存訪(fǎng)問(wèn)
~~Dr.M~~ 0 unique, 0 total uninitialized access(es)      # 未初始化內(nèi)存
~~Dr.M~~ 0 unique, 0 total invalid heap argument(s)      # 無(wú)效的堆操作
~~Dr.M~~ 0 unique, 0 total warning(s)                    # 警告信息
~~Dr.M~~ 1 unique, 1 total, 20 byte(s) of leak(s)       # 確認(rèn)的內(nèi)存泄漏
~~Dr.M~~ 0 unique, 0 total, 0 byte(s) of possible leak(s) # 可能的內(nèi)存泄漏

# 安裝
sudo apt-get install valgrind

# 使用 g++ 編譯 C++ 程序
g++ -g -O0 your_program.cpp -o your_program

# 基本使用
valgrind --leak-check=full ./your_program

--leak-check=full          # 詳細(xì)的內(nèi)存泄漏檢測(cè)
--show-leak-kinds=all      # 顯示所有類(lèi)型的泄漏
--track-origins=yes        # 追蹤未初始化值的來(lái)源
--verbose                  # 顯示更詳細(xì)的信息

--tool=memcheck            # 默認(rèn)工具，檢測(cè)內(nèi)存錯(cuò)誤
--tool=helgrind            # 檢測(cè)線(xiàn)程錯(cuò)誤，如數(shù)據(jù)競(jìng)爭(zhēng)
--tool=cachegrind          # 緩存和分支預(yù)測(cè)分析
--tool=callgrind           # 函數(shù)調(diào)用分析
--tool=massif              # 堆內(nèi)存使用分析

#include <stdlib.h>

int main() {
    // 分配內(nèi)存但忘記釋放
    int* array = (int*)malloc(10 * sizeof(int));
    return 0;
}

$ valgrind --leak-check=full ./memory_leak
==15673== Memcheck, a memory error detector
==15673== Command: ./memory_leak
==15673== 
==15673== HEAP SUMMARY:
==15673==     in use at exit: 40 bytes in 1 blocks
==15673==   total heap usage: 1 allocs, 0 frees, 40 bytes allocated
==15673== 
==15673== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==15673==    at 0x4C31B25: malloc (vg_replace_malloc.c:299)
==15673==    by 0x400544: main (memory_leak.c:5)
==15673== 
==15673== LEAK SUMMARY:
==15673==    definitely lost: 40 bytes in 1 blocks
==15673==    indirectly lost: 0 bytes in 0 blocks
==15673==    possibly lost: 0 bytes in 0 blocks
==15673==    still reachable: 0 bytes in 0 blocks
==15673==    suppressed: 0 bytes in 0 blocks

#include <string.h>

int main() {
    char buffer[10];
    // 越界寫(xiě)入
    strcpy(buffer, "This string is too long for the buffer");
    return 0;
}

xioakang@ubuntu:~/C++/memoryLeak$ valgrind ./test 
==14614== Memcheck, a memory error detector
==14614== Command: ./test
==14614== 
*** stack smashing detected ***: terminated
==14614== 
==14614== Process terminating with default action of signal 6 (SIGABRT)
==14614==    at 0x4B0E00B: raise (raise.c:51)
==14614==    by 0x4AED858: abort (abort.c:79)
==14614==    by 0x4B58265: __libc_message (libc_fatal.c:156)
==14614==    by 0x4BFACD9: __fortify_fail (fortify_fail.c:26)
==14614==    by 0x4BFACA5: __stack_chk_fail (stack_chk_fail.c:24)
==14614==    by 0x109208: main (test.cpp:6)
==14614== 
==14614== HEAP SUMMARY:
==14614==     in use at exit: 0 bytes in 0 blocks
==14614==   total heap usage: 1 allocs, 1 frees, 73,728 bytes allocated
==14614== 
==14614== All heap blocks were freed -- no leaks are possible

#include <stdio.h>

int main() {
    int a;  // 未初始化
    if (a > 0) {  // 使用未初始化的值
        printf("a is positive\n");
    }
    return 0;
}

xioakang@ubuntu:~/C++/memoryLeak$ valgrind --track-origins=yes ./test 
==14842== Memcheck, a memory error detector
==14842== Command: ./test
==14842== 
==14842== Conditional jump or move depends on uninitialised value(s)
==14842==    at 0x109199: main (test.cpp:8)
==14842==  Uninitialised value was created by a stack allocation
==14842==    at 0x109189: main (test.cpp:6)
==14842== 
==14842== 
==14842== HEAP SUMMARY:
==14842==     in use at exit: 0 bytes in 0 blocks
==14842==   total heap usage: 1 allocs, 1 frees, 73,728 bytes allocated
==14842== 
==14842== All heap blocks were freed -- no leaks are possible

#include <stdlib.h>
#include <stdio.h>

int main() {
    int* ptr = (int*)malloc(sizeof(int));
    *ptr = 10;
    free(ptr);        // 釋放內(nèi)存
    *ptr = 20;        // 使用已釋放的內(nèi)存
    printf("%d\n", *ptr);
    
    return 0;
}

$ valgrind ./use_after_free
==17982== Memcheck, a memory error detector
==17982== Command: ./use_after_free
==17982== 
==17982== Invalid write of size 4
==17982==    at 0x400563: main (use_after_free.c:8)
==17982==  Address 0x5204040 is 0 bytes inside a block of size 4 free'd
==17982==    at 0x4C30D3B: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==17982==    by 0x400558: main (use_after_free.c:7)
==17982== 
==17982== Invalid read of size 4
==17982==    at 0x400572: main (use_after_free.c:9)
==17982==  Address 0x5204040 is 0 bytes inside a block of size 4 free'd
==17982==    at 0x4C30D3B: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==17982==    by 0x400558: main (use_after_free.c:7)

#include <iostream>
#include <cstring>

#include <stdlib.h>

int main() {
    int* ptr = (int*)malloc(sizeof(int));

    free(ptr);    // 第一次釋放
    free(ptr);    // 第二次釋放（錯(cuò)誤）

    return 0;
}

xioakang@ubuntu:~/C++/memoryLeak$ valgrind ./test 
==15063== Memcheck, a memory error detector
==15063== Command: ./test
==15063== 
==15063== Invalid free() / delete / delete[] / realloc()
==15063==    at 0x483CA3F: free (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==15063==    by 0x1091DA: main (test.cpp:10)
==15063==  Address 0x4e48080 is 0 bytes inside a block of size 4 free'd
==15063==    at 0x483CA3F: free (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==15063==    by 0x1091CE: main (test.cpp:9)
==15063==  Block was alloc'd at
==15063==    at 0x483B7F3: malloc (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==15063==    by 0x1091BE: main (test.cpp:7)
==15063== 
==15063== 
==15063== HEAP SUMMARY:
==15063==     in use at exit: 0 bytes in 0 blocks
==15063==   total heap usage: 2 allocs, 3 frees, 73,732 bytes allocated
==15063== 
==15063== All heap blocks were freed -- no leaks are possible

#include <stdlib.h>
#include <new>

int main() {
    // 使用 new 分配
    int* ptr1 = newint;
    
    // 錯(cuò)誤：使用 free 釋放
    free(ptr1);
    
    // 使用 malloc 分配
    int* ptr2 = (int*)malloc(sizeof(int));
    
    // 錯(cuò)誤：使用 delete 釋放
    delete ptr2;
    
    return0;
}

xioakang@ubuntu:~/C++/memoryLeak$ valgrind ./test 
==16032== Memcheck, a memory error detector
==16032== Command: ./test
==16032== 
==16032== Mismatched free() / delete / delete []
==16032==    at 0x483CA3F: free (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==16032==    by 0x10920E: main (test.cpp:12)
==16032==  Address 0x4e48080 is 0 bytes inside a block of size 4 alloc'd
==16032==    at 0x483BE63: operator new(unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==16032==    by 0x1091FE: main (test.cpp:9)
==16032== 
==16032== Mismatched free() / delete / delete []
==16032==    at 0x483D1CF: operator delete(void*, unsigned long) (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==16032==    by 0x109232: main (test.cpp:18)
==16032==  Address 0x4e480d0 is 0 bytes inside a block of size 4 alloc'd
==16032==    at 0x483B7F3: malloc (in /usr/lib/x86_64-linux-gnu/valgrind/vgpreload_memcheck-amd64-linux.so)
==16032==    by 0x109218: main (test.cpp:15)

#include <pthread.h>
#include <stdio.h>

int shared_counter = 0;

void* increment_counter(void* arg) {
    for (int i = 0; i < 100000; i++) {
        shared_counter++; // 無(wú)鎖保護(hù)的共享數(shù)據(jù)訪(fǎng)問(wèn)
    }
    returnNULL;
}

int main() {
    pthread_t thread1, thread2;
    
    pthread_create(&thread1, NULL, increment_counter, NULL);
    pthread_create(&thread2, NULL, increment_counter, NULL);
    
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    
    printf("Final counter value: %d\n", shared_counter);
    return0;
}

$ g++ -pthread -g thread_race.cpp -o thread_race
$ valgrind --tool=helgrind ./thread_race
==19245== Helgrind, a thread error detector
==19245== Command: ./thread_race
==19245== 
==19245== Possible data race during read of size 4 at 0x601068 by thread #3
==19245==    at 0x400664: increment_counter(void*) (thread_race.cpp:8)
==19245==  This conflicts with a previous write of size 4 by thread #2
==19245==    at 0x400664: increment_counter(void*) (thread_race.cpp:8)
==19245==  Address 0x601068 is 0 bytes inside global var "shared_counter"
==19245==    declared at thread_race.cpp:4

# 編譯時(shí)開(kāi)啟 ASan（比普通調(diào)試只慢2-3倍?。?g++ -fsanitize=address -g your_program.cpp -o your_program

# 直接運(yùn)行即可
./your_program

int main() {
    int array[5] = {0};
    array[10] = 1;  // 越界訪(fǎng)問(wèn)
    return 0;
}

==30498==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7ffd46e3503c at pc 0x5632a6f8b1a9 bp 0x7ffd46e34ff0 sp 0x7ffd46e34fe0
WRITE of size 4 at 0x7ffd46e3503c thread T0
    #0 0x5632a6f8b1a8 in main example.cpp:3

int main() {
    int* p = new int(42);
    delete p;
    *p = 10;  // 使用已釋放的內(nèi)存
    return 0;
}

==30655==ERROR: AddressSanitizer: heap-use-after-free on address 0x606000000040 at pc 0x7fb5617bb1a9 bp 0x7ffc28c56f10 sp 0x7ffc28c56f00
WRITE of size 4 at 0x606000000040 thread T0
    #0 0x7fb5617bb1a8 in main example.cpp:4

int main() {
    int* p = new int[100];  // 沒(méi)有配對(duì)的 delete[]
    return 0;
}

==31041==ERROR: LeakSanitizer: detected memory leaks
Direct leak of 400 bytes in 1 objects allocated from:
    #0 0x7f84e5bd4bc8 in operator new[](unsigned long) 
    #1 0x55907893a1b9 in main example.cpp:2

void function() {
    char buffer[10];
    strcpy(buffer, "This string is too long for the buffer");
}

==31299==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7ffce822c8aa at pc 0x7f9e5f43282c
WRITE of size 38 at 0x7ffce822c8aa thread T0
    #0 0x7f9e5f43282b in strcpy
    #1 0x561fe803a1c9 in function example.cpp:3

# g++ 可能不支持 MSan，但是 clang 支持
# 安裝 Clang
sudo apt-get install clang

# 編譯時(shí)開(kāi)啟 MSan 
clang -fsanitize=memory -fPIE -pie -g your_program.cpp -o your_program

int main() {
    int value;  // 未初始化
    int result = value + 10;  // 使用未初始化的值
    return result;
}

==31604==WARNING: MemorySanitizer: use-of-uninitialized-value
    #0 0x7f3a53be02cf in main uninit_var.cpp:3:18
    #1 0x7f3a53814023 in __libc_start_main (...) 
    #2 0x7f3a53be014e in _start (...)
SUMMARY: MemorySanitizer: use-of-uninitialized-value uninit_var.cpp:3:18 in main

struct Point {
    int x;
    int y;
};

int main() {
    Point p;
    p.x = 5;  // 只初始化了x
    // p.y 未初始化
    
    int sum = p.x + p.y;  // 使用未初始化的p.y
    
    // 添加條件判斷，使未初始化值的使用更明顯
    if (sum > 10) {
        return1;
    }
    
    return0;
}

==31842==WARNING: MemorySanitizer: use-of-uninitialized-value
    #0 0x7f52f8abd32f in main struct_partial_init.cpp:9:20
    #1 0x7f52f87cb023 in __libc_start_main (...)
    #2 0x7f52f8abd14e in _start (...)
SUMMARY: MemorySanitizer: use-of-uninitialized-value struct_partial_init.cpp:9:20 in main

void copy(int* dst, int* src) {
    *dst = *src;  // 傳播可能未初始化的值
}

int main() {
    int a;  // 未初始化
    int b;
    
    copy(&b, &a);  // 將未初始化的a復(fù)制到b
    return b;  // 使用可能未初始化的值
}

==32067==WARNING: MemorySanitizer: use-of-uninitialized-value
    #0 0x7fef55aa834e in copy pointer_propagation.cpp:2:13
    #1 0x7fef55aa83a1 in main pointer_propagation.cpp:8:5
    #2 0x7fef557b6023 in __libc_start_main (...)
SUMMARY: MemorySanitizer: use-of-uninitialized-value pointer_propagation.cpp:2:13 in copy

int main(int argc, char* argv[]) {
    int value;
    
    if (argc > 1) {
        value = 10;  // 只在條件為真時(shí)初始化
    }
    
    return value;  // 如果argc <= 1，value未初始化
}

==32301==WARNING: MemorySanitizer: use-of-uninitialized-value
    #0 0x7f9df5c7c3f6 in main conditional_init.cpp:8:12
    #1 0x7f9df5a8a023 in __libc_start_main (...)
SUMMARY: MemorySanitizer: use-of-uninitialized-value conditional_init.cpp:8:12 in main

# 編譯你的庫(kù)時(shí)也要加上這些選項(xiàng)
g++ -fsanitize=memory -fPIE -pie -g your_library.cpp -c

# 安裝
sudo apt-get install heaptrack heaptrack-gui
# 編譯程序
g++ -g your_program.cpp -o your_program

# 基本使用
heaptrack ./your_program
# 或者附加到正在運(yùn)行的程序
heaptrack -p $(pidof your_program)

# 分析結(jié)果
heaptrack_gui heaptrack.your_program.12345.gz

#include <stdlib.h>
#include <unistd.h>

void leak_memory() {
    void* ptr = malloc(1024);
    // 忘記釋放
}

int main() {
    for (int i = 0; i < 100; i++) {
        leak_memory();
        usleep(10000);  // 短暫暫停，便于觀察
    }
    return0;
}

$ heaptrack ./memory_leak
heaptrack output will be written to "heaptrack.memory_leak.12345.gz"
starting application...
...
$ heaptrack_gui heaptrack.memory_leak.12345.gz

#include <stdlib.h>
#include <string.h>

void allocate_small() {
    for (int i = 0; i < 1000; i++) {
        char* buffer = (char*)malloc(64);
        memset(buffer, 0, 64);
        free(buffer);
    }
}

void allocate_large() {
    for (int i = 0; i < 10; i++) {
        char* buffer = (char*)malloc(1024 * 1024);
        memset(buffer, 0, 1024 * 1024);
        free(buffer);
    }
}

int main() {
    allocate_small();
    allocate_large();
    return0;
}

$ heaptrack ./allocation_hotspots
heaptrack output will be written to "heaptrack.allocation_hotspots.12345.gz"
...
$ heaptrack_gui heaptrack.allocation_hotspots.12345.gz

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

void slowly_leak() {
    staticint iteration = 0;
    iteration++;
    
    // 每10次迭代泄漏一些內(nèi)存
    if (iteration % 10 == 0) {
        void* leak = malloc(1024 * 100);  // 泄漏約100KB
        printf("Iteration %d: Potential leak at %p\n", iteration, leak);
    }
    
    // 正常分配和釋放的內(nèi)存
    void* normal = malloc(2048);
    free(normal);
    
    sleep(1);  // 每秒執(zhí)行一次
}

int main() {
    printf("Server started with PID: %d\n", getpid());
    printf("Waiting for connections...\n");
    
    // 模擬服務(wù)器主循環(huán)
    while (1) {
        slowly_leak();
    }
    
    return0;
}

$ g++ -g server.c -o server
$ ./server
Server started with PID: 23456
Waiting for connections...
Iteration 10: Potential leak at 0x55f7a83e12a0
Iteration 20: Potential leak at 0x55f7a83e1940
...

$ heaptrack -p 23456
heaptrack output will be written to "heaptrack.server.23456.12345.gz"
injecting into application via GDB, this might take some time...
injection finished

$ heaptrack_gui heaptrack.server.23456.12345.gz

heaptrack -o output_file ./your_program &
heaptrack_gui output_file

# heaptrack的性能開(kāi)銷(xiāo)通常為20-50%
# valgrind的性能開(kāi)銷(xiāo)通常為3-10倍

# 支持多種視圖
# - 時(shí)間線(xiàn)視圖：查看內(nèi)存使用隨時(shí)間變化
# - 火焰圖：查看內(nèi)存分配調(diào)用棧
# - 熱點(diǎn)函數(shù)：查看內(nèi)存分配最頻繁的函數(shù)

# 不使用GUI也可以查看結(jié)果
heaptrack_print heaptrack.your_program.12345.gz

# 安裝
sudo apt-get install google-perftools libgoogle-perftools-dev

# 編譯程序
g++ -g your_program.cpp -o your_program

# 基本使用（內(nèi)存泄漏檢測(cè)）
LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libtcmalloc.so HEAPCHECK=normal ./your_program

# CPU 性能分析
LD_PRELOAD=/usr/lib/libprofiler.so CPUPROFILE=cpu.prof ./your_program
google-pprof --text ./your_program cpu.prof

#include <stdlib.h>

void leaky_function() {
    int* data = new int[100];  // 分配但不釋放
}

int main() {
    for (int i = 0; i < 10; i++) {
        leaky_function();
    }
    return 0;
}

$ g++ -g memory_leak.cpp -o memory_leak 
$ LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libtcmalloc.so HEAPCHECK=normal ./memory_leak

WARNING: Perftools heap leak checker is active -- Performance may suffer
Have memory regions w/o callers: might report false leaks
Leak check _main_ detected leaks of 4000 bytes in 10 objects
The 1 largest leaks:
Using local file ./memory_leak.
/usr/bin/addr2line: DWARF error: section .debug_info is larger than its filesize! (0x93f189 vs 0x530e70)
Leak of 4000 bytes in 10 objects allocated from:
 @ 55881f71719f leaky_function
 @ 55881f7171c4 main
 @ 7f99004e5083 __libc_start_main
 @ 55881f7170ce _start


... [more similar leaks] ...

If this is a false positive, try running with HEAP_CHECK_DRACONIAN.

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <vector>
#include <thread>

void memory_task(int thread_id) {
    std::vector<void*> pointers;
    
    for (int i = 0; i < 1000000; i++) {
        size_t size = 8 + (i % 64) * 16;
        void* ptr = malloc(size);
        pointers.push_back(ptr);
        
        if (i % 7 == 0 && !pointers.empty()) {
            size_t index = i % pointers.size();
            free(pointers[index]);
            pointers[index] = NULL;
        }
    }
    
    // 清理
    for (void* ptr : pointers) {
        if (ptr) free(ptr);
    }
}

int main() {
    clock_t start = clock();
    
    // 創(chuàng)建8個(gè)線(xiàn)程，同時(shí)進(jìn)行內(nèi)存密集操作
    std::thread threads[8];
    for (int i = 0; i < 8; i++) {
        threads[i] = std::thread(memory_task, i);
    }
    
    // 等待所有線(xiàn)程完成
    for (int i = 0; i < 8; i++) {
        threads[i].join();
    }
    
    clock_t end = clock();
    printf("Execution time: %f seconds\n", (double)(end - start) / CLOCKS_PER_SEC);
    
    return0;
}

# 使用標(biāo)準(zhǔn)庫(kù) malloc
$ g++ -g malloc_benchmark.cpp -o std_malloc
$ ./std_malloc
Execution time: 35.994701 seconds

# 使用 TCMalloc
$ g++ -g malloc_benchmark.cpp -o tcmalloc_version -ltcmalloc
$ ./tcmalloc_version
Execution time: 8.005729 seconds

#include <math.h>
#include <stdio.h>
#include <unistd.h>

void cpu_intensive_function1() {
    double result = 0;
    for (int i = 0; i < 1000000; i++) {
        result += sin(i) * cos(i);
    }
}

void cpu_intensive_function2() {
    double result = 0;
    for (int i = 0; i < 2000000; i++) {
        result += sqrt(i) * log(i+1);
    }
}

void mixed_function() {
    cpu_intensive_function1();
    sleep(1);  // IO等待
    cpu_intensive_function2();
}

int main() {
    mixed_function();
    return0;
}

$ g++ -g cpu_profile.cpp -o cpu_profile
$ LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libprofiler.so CPUPROFILE=cpu.prof CPUPROFILE_FREQUENCY=1000 ./cpu_profile
$ google-pprof --text ./cpu_profile cpu.prof
Using local file cpu.prof.
/usr/bin/addr2line: DWARF error: section .debug_info is larger than its filesize! (0x17356f vs 0x13c5f8)
/usr/bin/addr2line: DWARF error: section .debug_info is larger than its filesize! (0x93f189 vs 0x530e70)
Total: 6 samples
       4  66.7%  66.7%        4  66.7% f64xsubf128
       1  16.7%  83.3%        3  50.0% cpu_intensive_function2
       1  16.7% 100.0%        1  16.7% logf64
       0   0.0% 100.0%        6 100.0% __libc_start_main
       0   0.0% 100.0%        6 100.0% _start
       0   0.0% 100.0%        3  50.0% cpu_intensive_function1
       0   0.0% 100.0%        6 100.0% main
       0   0.0% 100.0%        6 100.0% mixed_function
       0   0.0% 100.0%        1  16.7% std::cos
       0   0.0% 100.0%        2  33.3% std::log
       0   0.0% 100.0%        2  33.3% std::sin

$ google-pprof --web ./test cpu.prof

# 簡(jiǎn)單使用
g++ your_program.cpp -o your_program -ltcmalloc

# 查看內(nèi)存使用統(tǒng)計(jì)
$ MALLOCSTATS=1 ./your_program

# 比 Valgrind 等工具的性能影響小得多
# 適合生產(chǎn)環(huán)境使用

# 不同級(jí)別的檢查
HEAPCHECK=minimal   # 最快，僅檢查明顯泄漏
HEAPCHECK=normal    # 平衡性能和檢測(cè)能力
HEAPCHECK=strict    # 更嚴(yán)格的檢查
HEAPCHECK=draconian # 最嚴(yán)格的檢查

# 配合 pprof 可視化工具使用
google-pprof --web ./your_program cpu.prof  # 在瀏覽器中查看