# 查看当前 CPU 核心数
nproc

# 对于 64 核机器，默认 256 个 Arena（可能过多）
# 推荐减少到 8-16
export MALLOC_CONF="narenas:8"

// arena_test.c - 测试不同 Arena 数量对性能的影响
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <time.h>
#include <jemalloc/jemalloc.h>

#define N_THREADS  16
#define N_ALLOCS   100000
#define OBJ_SIZE   256

static void *worker(void *arg) {
    void *ptrs[N_ALLOCS];
    for (int i = 0; i < N_ALLOCS; i++) {
        ptrs[i] = malloc(OBJ_SIZE);
        memset(ptrs[i], 0, OBJ_SIZE);
    }
    for (int i = 0; i < N_ALLOCS; i++) {
        free(ptrs[i]);
    }
    return NULL;
}

int main(int argc, char *argv[]) {
    pthread_t threads[N_THREADS];
    struct timespec t0, t1;

    clock_gettime(CLOCK_MONOTONIC, &t0);
    for (int i = 0; i < N_THREADS; i++)
        pthread_create(&threads[i], NULL, worker, NULL);
    for (int i = 0; i < N_THREADS; i++)
        pthread_join(threads[i], NULL);
    clock_gettime(CLOCK_MONOTONIC, &t1);

    double elapsed = (t1.tv_sec - t0.tv_sec) + (t1.tv_nsec - t0.tv_nsec) / 1e9;
    printf("narenas=%-4s  elapsed=%.3fs\n",
           argc > 1 ? argv[1] : "default", elapsed);

    return 0;
}

gcc -O2 -o arena_test arena_test.c -ljemalloc -lpthread

# 不同 Arena 数量对比
for n in 1 4 8 16 32 64; do
    MALLOC_CONF="narenas:$n" ./arena_test $n
done

# 场景 1：内存敏感（容器化服务）
export MALLOC_CONF="dirty_decay_ms:1000,muzzy_decay_ms:3000"
# 特点：快速归还 OS，RSS 稳定

# 场景 2：性能优先（批处理）
export MALLOC_CONF="dirty_decay_ms:30000,muzzy_decay_ms:60000"
# 特点：减少系统调用，吞吐量更高

# 场景 3：永不变还（极端性能优化）
export MALLOC_CONF="dirty_decay_ms:-1,muzzy_decay_ms:-1"
# 特点：RSS 只增不减，但分配性能最高

#include <jemalloc/jemalloc.h>

// 手动触发所有 Arena 的脏页回收
void purge_all_arenas() {
    unsigned narenas;
    size_t len = sizeof(narenas);
    je_mallctl("arenas.narenas", &narenas, &len, NULL, 0);

    for (unsigned i = 0; i < narenas; i++) {
        char cmd[64];
        snprintf(cmd, sizeof(cmd), "arena.%u.purge", i);
        je_mallctl(cmd, NULL, NULL, NULL, 0);
    }
}

// 在内存紧张时调用
void on_memory_pressure() {
    purge_all_arenas();
}

# 默认 TC 上限为 32KB（某些版本为 16KB）
# 增大可提升中等大小对象的分配性能
export MALLOC_CONF="tcache_max:65536"  # 64KB

# 查看当前值
MALLOC_CONF="stats_print:true" ./my_program 2>&1 | grep tcache_max

# 启用元数据 THP（可减少 TLB miss）
export MALLOC_CONF="metadata_thp:auto"

# 查看系统 THP 状态
cat /sys/kernel/mm/transparent_hugepage/enabled
# [always] madvise never

# 验证效果
MALLOC_CONF="metadata_thp:auto,stats_print:true" ./my_program 2>&1 | grep thp

// 绑定线程到特定 NUMA 节点并使用对应 Arena
#include <pthread.h>
#include <sched.h>
#include <jemalloc/jemalloc.h>

void setup_numa_thread(int node, unsigned arena_id) {
    // 绑定 CPU
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    // 简化示例：假设 node 0 对应 CPU 0-7，node 1 对应 CPU 8-15
    for (int i = node * 8; i < (node + 1) * 8; i++) {
        CPU_SET(i, &cpuset);
    }
    pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);

    // 绑定 Arena
    je_mallctl("thread.arena", NULL, NULL, &arena_id, sizeof(arena_id));
}

# 限制进程到 NUMA 节点 0
numactl --cpunodebind=0 --membind=0 ./my_server

# 启用后台线程
export MALLOC_CONF="background_thread:true"

# 查看后台线程状态
MALLOC_CONF="background_thread:true,stats_print:true" ./my_program 2>&1 | grep background

# 适合高并发低延迟服务
export MALLOC_CONF="background_thread:true,dirty_decay_ms:2000"

// tune_bench.c - 系统化调优测试
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <time.h>
#include <jemalloc/jemalloc.h>

typedef struct {
    int id;
    int n_allocs;
    int obj_size_min;
    int obj_size_max;
} thread_arg_t;

static void *bench_thread(void *arg) {
    thread_arg_t *a = (thread_arg_t *)arg;
    void **ptrs = malloc(a->n_allocs * sizeof(void *));

    for (int i = 0; i < a->n_allocs; i++) {
        size_t sz = a->obj_size_min +
                    rand() % (a->obj_size_max - a->obj_size_min + 1);
        ptrs[i] = malloc(sz);
        if (ptrs[i]) memset(ptrs[i], 0xAB, sz);
    }
    for (int i = 0; i < a->n_allocs; i++) {
        free(ptrs[i]);
    }
    free(ptrs);
    return NULL;
}

int main(int argc, char *argv[]) {
    int n_threads = argc > 1 ? atoi(argv[1]) : 8;
    int n_allocs  = argc > 2 ? atoi(argv[2]) : 50000;

    pthread_t *threads = malloc(n_threads * sizeof(pthread_t));
    thread_arg_t *args = malloc(n_threads * sizeof(thread_arg_t));

    struct timespec t0, t1;
    clock_gettime(CLOCK_MONOTONIC, &t0);

    for (int i = 0; i < n_threads; i++) {
        args[i] = (thread_arg_t){i, n_allocs, 16, 4096};
        pthread_create(&threads[i], NULL, bench_thread, &args[i]);
    }
    for (int i = 0; i < n_threads; i++) {
        pthread_join(threads[i], NULL);
    }

    clock_gettime(CLOCK_MONOTONIC, &t1);
    double elapsed = (t1.tv_sec - t0.tv_sec) + (t1.tv_nsec - t0.tv_nsec) / 1e9;
    double ops = (double)n_threads * n_allocs * 2 / elapsed;

    printf("threads=%d allocs=%d elapsed=%.3fs ops=%.0f/s\n",
           n_threads, n_allocs, elapsed, ops);

    free(threads);
    free(args);
    return 0;
}

gcc -O2 -o tune_bench tune_bench.c -ljemalloc -lpthread

# 测试脚本
cat << 'SCRIPT' > tune_test.sh
#!/bin/bash
echo "=== Arena Count Test ==="
for n in 1 4 8 16 32; do
    printf "narenas=%-3d " $n
    MALLOC_CONF="narenas:$n" ./tune_bench 16 50000
done

echo ""
echo "=== Dirty Decay Test ==="
for ms in 0 1000 5000 30000 -1; do
    printf "dirty_decay=%-6d " $ms
    MALLOC_CONF="dirty_decay_ms:$ms" ./tune_bench 16 50000
done

echo ""
echo "=== Background Thread Test ==="
for bt in true false; do
    printf "bg_thread=%-5s " $bt
    MALLOC_CONF="background_thread:$bt" ./tune_bench 16 50000
done
SCRIPT
chmod +x tune_test.sh
./tune_test.sh