valgrind 命令 #

valgrind [valgrind选项] [valgrind工具] [工具选项] 程序 [程序选项]

valgrind --leak-check=full ./myprogram arg1 arg2

valgrind --tool=cachegrind ./myprogram arg1 arg2

valgrind --tool=callgrind ./myprogram arg1 arg2

valgrind --tool=helgrind ./myprogram arg1 arg2

valgrind --tool=massif ./myprogram arg1 arg2

valgrind --log-file=valgrind.log ./myprogram arg1 arg2

valgrind --trace-children=yes ./myprogram arg1 arg2

valgrind --track-origins=yes ./myprogram arg1 arg2

valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes ./myprogram

valgrind --suppressions=suppress.txt ./myprogram

#include <valgrind/valgrind.h>

// 告诉Valgrind忽略接下来的内存泄漏
VALGRIND_DISABLE_ERROR_REPORTING;
// 执行一些可能会产生误报的代码
VALGRIND_ENABLE_ERROR_REPORTING;

// 手动检查内存泄漏
VALGRIND_DO_LEAK_CHECK;

// 添加自定义错误
VALGRIND_ERROR_PRINTF("Custom error message");

valgrind --vgdb=yes --vgdb-error=0 ./myprogram

gdb ./myprogram
(gdb) target remote | /usr/lib/valgrind/../../bin/vgdb

valgrind --tool=callgrind --instr-atstart=no ./myprogram

callgrind_control -i on   # 开始收集数据
# 执行感兴趣的操作
callgrind_control -i off  # 停止收集数据

valgrind --tool=cachegrind --I1=32768,8,64 --D1=32768,8,64 --LL=8388608,16,64 ./myprogram

valgrind --tool=drd --check-stack-var=yes --exclusive-threshold=100 ./myprogram

valgrind --tool=callgrind --separate-threads=yes --dump-instr=yes --collect-jumps=yes ./myprogram

callgrind_annotate callgrind.out.12345

// memcheck_example.c
#include <stdlib.h>

int main() {
    int *x = malloc(10 * sizeof(int));
    x[10] = 0;  // 越界写入

    int y;
    if(y == 0)  // 使用未初始化的值
        return 1;

    return 0;
    // 忘记释放x，导致内存泄漏
}

gcc -g -O0 memcheck_example.c -o memcheck_example
valgrind --leak-check=full ./memcheck_example

// helgrind_example.c
#include <pthread.h>
#include <stdio.h>

int shared_var = 0;

void* thread_func(void* arg) {
    shared_var++;  // 没有锁保护的共享变量访问
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, thread_func, NULL);
    pthread_create(&t2, NULL, thread_func, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("shared_var = %d\n", shared_var);
    return 0;
}

gcc -g -O0 -pthread helgrind_example.c -o helgrind_example
valgrind --tool=helgrind ./helgrind_example

// cachegrind_example.c
#include <stdlib.h>

#define SIZE 10000

void matrix_multiply(int **a, int **b, int **c, int size) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            c[i][j] = 0;
            for (int k = 0; k < size; k++) {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }
}

int main() {
    int size = 1000;
    int **a = malloc(size * sizeof(int*));
    int **b = malloc(size * sizeof(int*));
    int **c = malloc(size * sizeof(int*));

    for (int i = 0; i < size; i++) {
        a[i] = malloc(size * sizeof(int));
        b[i] = malloc(size * sizeof(int));
        c[i] = malloc(size * sizeof(int));
        for (int j = 0; j < size; j++) {
            a[i][j] = i + j;
            b[i][j] = i - j;
        }
    }

    matrix_multiply(a, b, c, size);

    // 释放内存
    for (int i = 0; i < size; i++) {
        free(a[i]);
        free(b[i]);
        free(c[i]);
    }
    free(a);
    free(b);
    free(c);

    return 0;
}

gcc -g -O0 cachegrind_example.c -o cachegrind_example
valgrind --tool=cachegrind ./cachegrind_example

// massif_example.c
#include <stdlib.h>
#include <string.h>

void allocate_memory() {
    void *p = malloc(1000000);  // 分配1MB
    memset(p, 0, 1000000);
    // 不释放p，导致内存泄漏
}

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

gcc -g -O0 massif_example.c -o massif_example
valgrind --tool=massif ./massif_example
ms_print massif.out.12345

// drd_example.c
#include <pthread.h>
#include <unistd.h>

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;

void* thread1_func(void* arg) {
    pthread_mutex_lock(&mutex1);
    sleep(1);  // 增加死锁的可能性
    pthread_mutex_lock(&mutex2);

    // 临界区

    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}

void* thread2_func(void* arg) {
    pthread_mutex_lock(&mutex2);
    sleep(1);  // 增加死锁的可能性
    pthread_mutex_lock(&mutex1);

    // 临界区

    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, thread1_func, NULL);
    pthread_create(&t2, NULL, thread2_func, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    return 0;
}

gcc -g -O0 -pthread drd_example.c -o drd_example
valgrind --tool=drd ./drd_example

gcc -g -O0 -Wall program.c -o program

valgrind --gen-suppressions=all --log-file=suppression.log ./program

valgrind --suppressions=my_suppressions.supp ./program

#include <stdio.h>

#ifdef VALGRIND_DEBUG
#include <valgrind/memcheck.h>
#define VALGRIND_MALLOC_FREELIKE_BLOCK(addr, size) VALGRIND_MALLOCLIKE_BLOCK(addr, size, 0, 0)
#define VALGRIND_FREE_FREELIKE_BLOCK(addr) VALGRIND_FREELIKE_BLOCK(addr, 0)
#else
#define VALGRIND_MALLOC_FREELIKE_BLOCK(addr, size)
#define VALGRIND_FREE_FREELIKE_BLOCK(addr)
#endif

void* my_custom_allocator(size_t size) {
    void* ptr = /* custom allocation */;
    VALGRIND_MALLOC_FREELIKE_BLOCK(ptr, size);
    return ptr;
}

void my_custom_deallocator(void* ptr) {
    VALGRIND_FREE_FREELIKE_BLOCK(ptr);
    /* custom deallocation */
}

VALGRIND_OPTS="--leak-check=full --track-origins=yes" ./run_my_program.sh

valgrind --tool=callgrind --toggle-collect=main ./program

#include <valgrind/valgrind.h>

// 手动检查内存泄漏
VALGRIND_DO_LEAK_CHECK;

// 标记内存为已初始化
VALGRIND_MAKE_MEM_DEFINED(ptr, size);

// 标记内存为未初始化
VALGRIND_MAKE_MEM_UNDEFINED(ptr, size);

// 添加自定义错误消息
VALGRIND_PRINTF("Custom message: %d\n", value);

valgrind --tool=callgrind ./program
callgrind_annotate callgrind.out.12345 source_file.c

kcachegrind callgrind.out.12345

massif-visualizer massif.out.12345

valgrind --vgdb=yes --vgdb-error=0 ./program

gdb ./program
(gdb) target remote | /usr/lib/valgrind/../../bin/vgdb