如何使用YCSB模拟正弦波工作负载

方案一：外部脚本动态控制YCSB线程数/请求间隔 #

YCSB的吞吐量和并发线程数直接相关，你可以编写脚本（Python/Bash均可），基于正弦函数计算每个时间窗口的目标QPS，动态调整YCSB的运行参数：

• 先定义正弦波核心参数：基准QPS（base）、振幅（amp）、周期（period，比如60秒），计算公式为 current_qps = base + amp * sin(2π*t/period)，其中t为当前运行时长
• 提前压测得到单线程QPS，之后每隔固定时间（比如1秒）根据目标QPS计算所需线程数：threads = current_qps / single_thread_qps
• 若允许短暂中断，可停止当前YCSB进程并以新线程数重启；若需无中断调整，可启动多个YCSB实例，通过动态启停实例来控制总线程数
• 示例Python脚本片段：

import math
import time
import subprocess
import signal

base_qps = 1000
amp_qps = 500
period = 60  # 60秒一个周期
single_thread_qps = 100  # 提前压测获得的单线程QPS

current_process = None

while True:
    t = time.time() % period
    current_qps = base_qps + amp_qps * math.sin(2 * math.pi * t / period)
    target_threads = max(1, int(current_qps / single_thread_qps))
    
    # 终止旧进程
    if current_process:
        current_process.send_signal(signal.SIGINT)
        current_process.wait()
    
    # 启动新YCSB进程
    cmd = f"ycsb run mongodb -P workloads/workloada -threads {target_threads} -p recordcount=1000000"
    current_process = subprocess.Popen(cmd, shell=True)
    
    time.sleep(1)  # 每秒调整一次

方案二：修改YCSB源代码自定义负载生成器 #

直接修改YCSB核心负载逻辑，在请求发送层加入速率控制：

1. 找到YCSB的Workload接口实现类（如BasicWorkload），或新建自定义Workload类
2. 在请求循环中，根据当前时间计算正弦波对应的请求间隔：interval = 1 / current_qps
3. 每次发送请求后，根据计算出的间隔休眠，以此控制请求发送速率
4. 示例Java修改片段：

public class SinWaveWorkload extends BasicWorkload {
    private long startTime;
    private double baseQps;
    private double ampQps;
    private double periodMs;

    @Override
    public void init(Properties p) throws WorkloadException {
        super.init(p);
        startTime = System.currentTimeMillis();
        baseQps = Double.parseDouble(p.getProperty("sin.baseqps", "1000"));
        ampQps = Double.parseDouble(p.getProperty("sin.ampqps", "500"));
        periodMs = Double.parseDouble(p.getProperty("sin.period", "60000")); // 周期单位：毫秒
    }

    @Override
    public boolean doInsert(DB db, Object threadState) throws DBException {
        boolean result = super.doInsert(db, threadState);
        controlRequestRate();
        return result;
    }

    @Override
    public Iterator<Operation> buildWorkload(DB db, Object threadState) {
        Iterator<Operation> iterator = super.buildWorkload(db, threadState);
        return new Iterator<Operation>() {
            @Override
            public boolean hasNext() {
                return iterator.hasNext();
            }

            @Override
            public Operation next() {
                Operation op = iterator.next();
                controlRequestRate();
                return op;
            }
        };
    }

    private void controlRequestRate() {
        long elapsed = System.currentTimeMillis() - startTime;
        double t = elapsed % periodMs;
        double currentQps = baseQps + ampQps * Math.sin(2 * Math.PI * t / periodMs);
        double intervalMs = 1000 / currentQps;

        try {
            Thread.sleep((long) intervalMs);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

5. 编译修改后的YCSB，运行时指定自定义Workload：ycsb run mongodb -P workloads/workloada -workload com.ycsb.workloads.SinWaveWorkload -p sin.baseqps=1000 -p sin.ampqps=500 -p sin.period=60000

方案三：利用流量控制工具实现外部速率整形 #

若不想修改代码或频繁重启YCSB，可使用Linux的tc工具在网络层控制YCSB发送到数据库的请求速率：

• 先启动YCSB以最大吞吐量运行
• 编写脚本基于正弦波公式，每隔一段时间调整tc的速率限制：

#!/bin/bash
base_rate=1000Mbps
amp_rate=500Mbps
period=60

while true; do
    t=$(date +%s)
    t=$((t % period))
    current_rate=$(echo "scale=2; $base_rate + $amp_rate * s(2*3.14159*$t/$period)" | bc -l)
    # 清除旧规则
    tc qdisc del dev eth0 root 2>/dev/null
    # 设置新速率限制
    tc qdisc add dev eth0 root tbf rate ${current_rate}bps burst 10k latency 70ms
    sleep 1
done

注意：该方法基于网络带宽控制，实际请求数与带宽的对应关系需提前校准，适合精度要求不高的场景

内容的提问来源于stack exchange，提问作者Geo Angelopoulos