# 默认测试：单线程，写操作
sysbench memory run

# 指定线程数
sysbench memory --threads=4 run

# 写操作测试
sysbench memory --memory-oper=write --threads=4 --time=30 run

# 读操作测试
sysbench memory --memory-oper=read --threads=4 --time=30 run

# 顺序访问（连续内存地址）
sysbench memory --memory-access-mode=seq --threads=4 --time=30 run

# 随机访问（随机内存地址）
sysbench memory --memory-access-mode=rnd --threads=4 --time=30 run

#!/bin/bash
# memory_bandwidth.sh - 内存带宽测试

echo "块大小,写带宽(MiB/s),读带宽(MiB/s)"

for bs in "1K" "4K" "16K" "64K" "256K" "1M" "4M" "16M" "64M" "256M" "1G"; do
  # 写带宽
  write_bw=$(sysbench memory \
    --memory-block-size=$bs \
    --memory-oper=write \
    --memory-total-size=10G \
    --memory-scope=global \
    --threads=1 \
    --time=30 run 2>&1 | grep "MiB/sec" | awk '{print $2}')
  
  # 读带宽
  read_bw=$(sysbench memory \
    --memory-block-size=$bs \
    --memory-oper=read \
    --memory-total-size=10G \
    --memory-scope=global \
    --threads=1 \
    --time=30 run 2>&1 | grep "MiB/sec" | awk '{print $2}')
  
  echo "$bs,$write_bw,$read_bw"
done

#!/bin/bash
# memory_multi_thread_bw.sh - 多线程内存带宽

echo "线程数,写带宽(MiB/s),读带宽(MiB/s),写加速比,读加速比"

single_write=""
single_read=""

for threads in 1 2 4 8 16 32; do
  write_bw=$(sysbench memory \
    --memory-block-size=256M \
    --memory-oper=write \
    --memory-total-size=100G \
    --memory-scope=global \
    --threads=$threads \
    --time=30 run 2>&1 | grep "MiB/sec" | awk '{print $2}')
  
  read_bw=$(sysbench memory \
    --memory-block-size=256M \
    --memory-oper=read \
    --memory-total-size=100G \
    --memory-scope=global \
    --threads=$threads \
    --time=30 run 2>&1 | grep "MiB/sec" | awk '{print $2}')
  
  if [ -z "$single_write" ]; then
    single_write=$write_bw
    single_read=$read_bw
    w_speedup="1.00"
    r_speedup="1.00"
  else
    w_speedup=$(echo "scale=2; $write_bw / $single_write" | bc)
    r_speedup=$(echo "scale=2; $read_bw / $single_read" | bc)
  fi
  
  echo "$threads,$write_bw,$read_bw,$w_speedup,$r_speedup"
done

#!/bin/bash
# memory_latency.sh - 内存延迟测试

echo "块大小,平均延迟(ms),P95延迟(ms),最大延迟(ms)"

for bs in "1K" "4K" "16K" "64K" "256K" "1M" "4M" "16M" "64M" "256M" "1G"; do
  result=$(sysbench memory \
    --memory-block-size=$bs \
    --memory-oper=read \
    --memory-access-mode=rnd \
    --memory-total-size=10G \
    --memory-scope=global \
    --threads=1 \
    --time=30 run 2>&1)
  
  avg=$(echo "$result" | grep "avg:" | awk '{print $2}')
  p95=$(echo "$result" | grep "95th" | awk '{print $3}')
  max=$(echo "$result" | grep "max:" | awk '{print $2}')
  
  echo "$bs,$avg,$p95,$max"
done

// pointer_chase.c - 简单的内存延迟测试
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>

#define ARRAY_SIZE (256 * 1024 * 1024 / sizeof(int))  // 256MB

int main() {
    int *array = malloc(ARRAY_SIZE * sizeof(int));
    
    // 初始化随机链表
    for (int i = 0; i < ARRAY_SIZE; i++) array[i] = i;
    // Fisher-Yates shuffle
    for (int i = ARRAY_SIZE - 1; i > 0; i--) {
        int j = rand() % (i + 1);
        int tmp = array[i]; array[i] = array[j]; array[j] = tmp;
    }
    
    // Pointer chasing
    struct timespec start, end;
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    int idx = 0;
    for (int i = 0; i < 10000000; i++) {
        idx = array[idx];
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    
    double ns = (end.tv_sec - start.tv_sec) * 1e9 + (end.tv_nsec - start.tv_nsec);
    printf("Average latency: %.1f ns\n", ns / 10000000);
    printf("Dummy: %d\n", idx);  // 防止优化
    
    free(array);
    return 0;
}

# 编译运行
gcc -O2 -o pointer_chase pointer_chase.c
./pointer_chase
# 典型结果：Average latency: 60-100 ns (DRAM)

# 查看当前大页配置
cat /proc/meminfo | grep Huge

# 配置大页（假设需要 4GB 大页内存）
# 4GB / 2MB per page = 2048 pages
echo 2048 | sudo tee /proc/sys/vm/nr_hugepages

# 永久配置
echo "vm.nr_hugepages = 2048" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# 验证
grep HugePages /proc/meminfo

#!/bin/bash
# hugepages_test.sh - HugePages 性能对比

echo "=== 普通页面 (4KB) ==="
sysbench memory \
  --memory-block-size=256M \
  --memory-oper=read \
  --memory-total-size=100G \
  --threads=8 \
  --time=30 run 2>&1 | grep -E "(MiB/sec|avg:|95th)"

echo ""
echo "=== HugePages (2MB) ==="
sysbench memory \
  --memory-block-size=256M \
  --memory-oper=read \
  --memory-total-size=100G \
  --memory-hugetlb=on \
  --threads=8 \
  --time=30 run 2>&1 | grep -E "(MiB/sec|avg:|95th)"

#!/bin/bash
# numa_memory_test.sh - NUMA 内存带宽测试

# 查看 NUMA 拓扑
echo "=== NUMA 拓扑 ==="
numactl --hardware
echo ""

# 在 Node 0 上运行（使用本地内存）
echo "=== Node 0 本地内存 ==="
numactl --cpunodebind=0 --membind=0 \
  sysbench memory --memory-block-size=256M --memory-oper=read \
  --memory-total-size=100G --threads=8 --time=30 run 2>&1 | \
  grep "MiB/sec"

# 在 Node 0 上运行（使用 Node 1 的内存）
echo "=== Node 0 访问远程内存 ==="
numactl --cpunodebind=0 --membind=1 \
  sysbench memory --memory-block-size=256M --memory-oper=read \
  --memory-total-size=100G --threads=8 --time=30 run 2>&1 | \
  grep "MiB/sec"

# 跨节点交织访问
echo "=== 交织内存访问 ==="
numactl --interleave=all \
  sysbench memory --memory-block-size=256M --memory-oper=read \
  --memory-total-size=100G --threads=16 --time=30 run 2>&1 | \
  grep "MiB/sec"

#!/bin/bash
# db_buffer_pool_eval.sh
# 评估 Buffer Pool 大小对内存性能的影响

# 模拟不同 Buffer Pool 大小
for bs in "64M" "256M" "1G" "4G" "16G"; do
  echo "Block Size (模拟 Buffer Pool): $bs"
  
  # 顺序访问模式（类似 Buffer Pool 顺序扫描）
  sysbench memory \
    --memory-block-size=$bs \
    --memory-oper=read \
    --memory-access-mode=seq \
    --memory-total-size=100G \
    --threads=16 \
    --time=30 run 2>&1 | grep "MiB/sec"
  
  # 随机访问模式（类似 OLTP 随机查询）
  sysbench memory \
    --memory-block-size=$bs \
    --memory-oper=read \
    --memory-access-mode=rnd \
    --memory-total-size=100G \
    --threads=16 \
    --time=30 run 2>&1 | grep "MiB/sec"
  
  echo ""
done

#!/bin/bash
# memory_stress.sh - 内存压力测试

TOTAL_MEM_GB=$(free -g | awk '/Mem/{print $2}')
TEST_SIZE="$((TOTAL_MEM_GB * 2))G"  # 使用 2 倍物理内存

echo "=== 内存压力测试 ==="
echo "物理内存: ${TOTAL_MEM_GB}GB"
echo "测试数据量: $TEST_SIZE"
echo ""

# 使用所有核心
sysbench memory \
  --memory-block-size=1M \
  --memory-oper=write \
  --memory-total-size=$TEST_SIZE \
  --memory-scope=global \
  --threads=$(nproc) \
  --time=300 \
  --histogram \
  run

echo ""
echo "=== 监控内存使用 ==="
free -h
vmstat 1 5

#!/bin/bash
# memory_saturation.sh - 测试内存带宽是否饱和

echo "线程数,读带宽(MiB/s),写带宽(MiB/s),总带宽(MiB/s)"

for threads in 1 2 4 6 8 10 12 14 16; do
  read_bw=$(sysbench memory \
    --memory-block-size=256M --memory-oper=read \
    --memory-total-size=100G --threads=$threads --time=30 run 2>&1 | \
    grep "MiB/sec" | awk '{print $2}')
  
  write_bw=$(sysbench memory \
    --memory-block-size=256M --memory-oper=write \
    --memory-total-size=100G --threads=$threads --time=30 run 2>&1 | \
    grep "MiB/sec" | awk '{print $2}')
  
  total=$(echo "$read_bw + $write_bw" | bc)
  echo "$threads,$read_bw,$write_bw,$total"
done