从调度器视角看CPU负载：Linux如何衡量“任务压力”

#include <iostream>#include <vector>#include <climits>#include <iomanip>// 定义进程结构体struct Process {    int pid;                // 进程ID    int arrival_time;       // 到达时间    int burst_time;         // 运行时间    int start_time;         // 开始执行时间    int completion_time;    // 完成时间    int waiting_time;       // 等待时间    int turnaround_time;    // 周转时间    bool is_completed;      // 完成标记};// 计算调度结果并输出void shortestJobFirst(std::vector<Process>& processes) {    int n = processes.size();    int current_time = 0;    int completed = 0;    int total_waiting_time = 0;    int total_turnaround_time = 0;    while (completed < n) {        // 寻找当前可执行（到达时间<=当前时间且未完成）的进程中运行时间最短的        int shortest_idx = -1;        int min_burst = INT_MAX;        for (int i = 0; i < n; ++i) {            if (processes[i].arrival_time <= current_time && !processes[i].is_completed) {                if (processes[i].burst_time < min_burst) {                    min_burst = processes[i].burst_time;                    shortest_idx = i;                } else if (processes[i].burst_time == min_burst) {                    // 若运行时间相同，选择到达时间更早的进程                    if (processes[i].arrival_time < processes[shortest_idx].arrival_time) {                        shortest_idx = i;                    }                }            }        }        if (shortest_idx == -1) {            // 无可用进程，当前时间推进            current_time++;        } else {            // 执行选中的进程            Process& p = processes[shortest_idx];            p.start_time = current_time;            p.completion_time = p.start_time + p.burst_time;            p.turnaround_time = p.completion_time - p.arrival_time;            p.waiting_time = p.turnaround_time - p.burst_time;            // 累计时间统计            total_waiting_time += p.waiting_time;            total_turnaround_time += p.turnaround_time;            // 更新状态            p.is_completed = true;            completed++;            current_time = p.completion_time;        }    }    // 输出调度结果    std::cout << std::left << std::setw(8) << "PID"              << std::setw(12) << "到达时间"              << std::setw(12) << "运行时间"              << std::setw(12) << "开始时间"              << std::setw(12) << "完成时间"              << std::setw(12) << "等待时间"              << std::setw(12) << "周转时间" << std::endl;    std::cout << "---------------------------------------------------------------" << std::endl;    for (const auto& p : processes) {        std::cout << std::left << std::setw(8) << p.pid                  << std::setw(12) << p.arrival_time                  << std::setw(12) << p.burst_time                  << std::setw(12) << p.start_time                  << std::setw(12) << p.completion_time                  << std::setw(12) << p.waiting_time                  << std::setw(12) << p.turnaround_time << std::endl;    }    // 输出平均指标    double avg_waiting = static_cast<double>(total_waiting_time) / n;    double avg_turnaround = static_cast<double>(total_turnaround_time) / n;    std::cout << "---------------------------------------------------------------" << std::endl;    std::cout << "平均等待时间: " << std::fixed << std::setprecision(2) << avg_waiting << " 单位时间" << std::endl;    std::cout << "平均周转时间: " << std::fixed << std::setprecision(2) << avg_turnaround << " 单位时间" << std::endl;}int main() {    // 初始化进程数据：包含短作业和长作业，模拟短作业连续到达的场景    std::vector<Process> processes = {        {1, 0, 8, 0, 0, 0, 0, false},   // 长作业1：到达时间0，运行时间8        {2, 1, 4, 0, 0, 0, 0, false},   // 短作业1：到达时间1，运行时间4        {3, 2, 2, 0, 0, 0, 0, false},   // 短作业2：到达时间2，运行时间2        {4, 3, 1, 0, 0, 0, 0, false},   // 短作业3：到达时间3，运行时间1        {5, 5, 5, 0, 0, 0, 0, false}   // 中等作业：到达时间5，运行时间5    };    std::cout << "最短优先调度算法执行结果：" << std::endl;    shortestJobFirst(processes);    return 0;}

#include <iostream>#include <vector>#include <queue>#include <iomanip>#include <climits>// 定义进程结构体struct Process {    int pid;                // 进程ID    int arrival_time;       // 到达时间    int burst_time;         // 总运行时间    int remaining_time;     // 剩余运行时间    int completion_time;    // 完成时间    int waiting_time;       // 等待时间    int turnaround_time;    // 周转时间    bool is_completed;      // 完成标记};// 时间片轮转调度函数void roundRobin(std::vector<Process>& processes, int time_quantum) {    int n = processes.size();    int current_time = 0;    int completed = 0;    std::queue<int> ready_queue;   // 就绪队列，存储进程索引    std::vector<bool> in_queue(n, false);   // 标记进程是否已在就绪队列    // 初始化剩余运行时间    for (auto& p : processes) {        p.remaining_time = p.burst_time;        p.is_completed = false;    }    // 首先将到达时间为0的进程加入就绪队列    for (int i = 0; i < n; ++i) {        if (processes[i].arrival_time <= current_time && !in_queue[i]) {            ready_queue.push(i);            in_queue[i] = true;        }    }    while (completed < n) {        if (ready_queue.empty()) {            // 无就绪进程，推进时间到下一个进程的到达时间            int next_arrival = INT_MAX;            for (const auto& p : processes) {                if (!p.is_completed && p.arrival_time < next_arrival) {                    next_arrival = p.arrival_time;                }            }            current_time = next_arrival;            // 将新到达的进程加入就绪队列            for (int i = 0; i < n; ++i) {                if (processes[i].arrival_time <= current_time && !processes[i].is_completed && !in_queue[i]) {                    ready_queue.push(i);                    in_queue[i] = true;                }            }            continue;        }        // 取出队首进程执行        int idx = ready_queue.front();        ready_queue.pop();        in_queue[idx] = false;        Process& p = processes[idx];        // 确定执行时间：取时间片和剩余时间的较小值        int execute_time = std::min(time_quantum, p.remaining_time);        int start_time = current_time;        current_time += execute_time;        p.remaining_time -= execute_time;        // 检查当前时间到达的新进程，加入就绪队列        for (int i = 0; i < n; ++i) {            if (processes[i].arrival_time > start_time && processes[i].arrival_time <= current_time &&                 !processes[i].is_completed && !in_queue[i]) {                ready_queue.push(i);                in_queue[i] = true;            }        }        // 进程未完成，放回就绪队列末尾        if (p.remaining_time > 0) {            ready_queue.push(idx);            in_queue[idx] = true;        } else {            // 进程完成，计算时间指标            p.completion_time = current_time;            p.turnaround_time = p.completion_time - p.arrival_time;            p.waiting_time = p.turnaround_time - p.burst_time;            p.is_completed = true;            completed++;        }    }    // 输出调度结果    std::cout << std::left << std::setw(8) << "PID"              << std::setw(12) << "到达时间"              << std::setw(12) << "运行时间"              << std::setw(12) << "完成时间"              << std::setw(12) << "等待时间"              << std::setw(12) << "周转时间" << std::endl;    std::cout << "---------------------------------------------------------------" << std::endl;    int total_waiting = 0, total_turnaround = 0;    for (const auto& p : processes) {        std::cout << std::left << std::setw(8) << p.pid                  << std::setw(12) << p.arrival_time                  << std::setw(12) << p.burst_time                  << std::setw(12) << p.completion_time                  << std::setw(12) << p.waiting_time                  << std::setw(12) << p.turnaround_time << std::endl;        total_waiting += p.waiting_time;        total_turnaround += p.turnaround_time;    }    // 输出平均指标    double avg_waiting = static_cast<double>(total_waiting) / n;    double avg_turnaround = static_cast<double>(total_turnaround) / n;    std::cout << "---------------------------------------------------------------" << std::endl;    std::cout << "时间片大小: " << time_quantum << " 单位时间" << std::endl;    std::cout << "平均等待时间: " << std::fixed << std::setprecision(2) << avg_waiting << " 单位时间" << std::endl;    std::cout << "平均周转时间: " << std::fixed << std::setprecision(2) << avg_turnaround << " 单位时间" << std::endl;}int main() {    // 初始化进程数据：模拟不同到达时间和运行时间的进程    std::vector<Process> processes = {        {1, 0, 5, 0, 0, 0, 0, false},   // 进程1：到达0，运行5        {2, 1, 3, 0, 0, 0, 0, false},   // 进程2：到达1，运行3        {3, 2, 1, 0, 0, 0, 0, false},   // 进程3：到达2，运行1        {4, 4, 4, 0, 0, 0, 0, false}   // 进程4：到达4，运行4    };    // 设置时间片大小为2个单位时间    const int TIME_QUANTUM = 2;    std::cout << "时间片轮转调度算法执行结果：" << std::endl;    roundRobin(processes, TIME_QUANTUM);    return 0;}在 Linux 调度器的算法家族中，完全公平调度器（CFS）是一颗璀璨的明星。它是 Linux 内核中默认的调度器，负责普通用户任务（SCHED_OTHER 和 SCHED_BATCH）的调度 。CFS 的核心思想是为所有运行的任务提供公平的 CPU 时间分配，就像一位公正无私的裁判，确保每个任务都能在 CPU 资源竞争中获得合理的时间份额 。它摒弃了传统的固定时间片概念，引入了虚拟运行时间（vruntime）。每个进程都有一个虚拟运行时间，当进程执行时，其 vruntime 会根据实际执行时间和进程的权重进行增长。权重较高的进程，其 vruntime 增长速度相对较慢，这意味着它们在相同的实际执行时间内，能够获得更多的 CPU 时间；而权重较低的进程，vruntime 增长速度较快 。在调度决策时，CFS 调度器会从所有就绪任务中挑选出 vruntime 最小的任务来运行，因为这个任务之前获得的 CPU 时间相对较少，理应在下一轮调度中优先获得 CPU 资源 。通过这种方式，CFS 调度器不断地让各个任务的 vruntime 相互追赶，实现了 CPU 时间在不同任务之间的公平分配，使得系统在多任务处理场景下能够高效、稳定地运行 。例如，在一个同时运行多个办公软件、浏览器和后台服务进程的系统中，CFS 调度器能够合理地分配 CPU 时间，让每个任务都能流畅运行，用户在操作办公软件时不会因为浏览器的后台加载任务而感到卡顿，同时后台服务进程也能按时完成自己的任务 。Linux 完全公平调度器实现示例如下：#include <iostream>#include <vector>#include <climits>#include <iomanip>#include <cmath>// 定义NICE值为0的进程默认权重（符合Linux内核实际定义）const int NICE_0_LOAD = 1024;// 定义进程结构体struct Process {    int pid;                // 进程ID    int arrival_time;       // 到达时间    int total_burst_time;   // 总需要运行时间    int actual_runtime;     // 已实际运行时间    int weight;             // 进程权重（值越大，优先级越高）    double vruntime;        // 虚拟运行时间    int completion_time;    // 完成时间    int waiting_time;       // 等待时间    int turnaround_time;    // 周转时间    bool is_completed;      // 是否完成执行    bool is_ready;          // 是否就绪（到达且未完成）};// CFS调度函数实现void cfsScheduler(std::vector<Process>& processes) {    int n = processes.size();    int current_time = 0;    int completed = 0;    // 初始化进程状态    for (auto& p : processes) {        p.actual_runtime = 0;        p.vruntime = 0.0;        p.is_completed = false;        p.is_ready = false;        p.completion_time = 0;    }    while (completed < n) {        // 标记到达的进程为就绪状态        for (auto& p : processes) {            if (p.arrival_time <= current_time && !p.is_completed && !p.is_ready) {                p.is_ready = true;            }        }        // 寻找就绪进程中vruntime最小的进程        int selected_pid = -1;        double min_vruntime = INT_MAX;        for (const auto& p : processes) {            if (p.is_ready && p.vruntime < min_vruntime) {                min_vruntime = p.vruntime;                selected_pid = p.pid;            }        }        if (selected_pid == -1) {            // 无就绪进程，推进系统时间            current_time++;            continue;        }        // 执行选中的进程一个时间单位        Process& selected = processes[selected_pid - 1]; // 假设PID从1开始连续        selected.actual_runtime++;        current_time++;        // 计算虚拟运行时间增量（基于权重的标准化）        double vruntime_increment = static_cast<double>(NICE_0_LOAD) / selected.weight;        selected.vruntime += vruntime_increment;        // 检查进程是否完成执行        if (selected.actual_runtime >= selected.total_burst_time) {            selected.is_completed = true;            selected.is_ready = false;            selected.completion_time = current_time;            selected.turnaround_time = selected.completion_time - selected.arrival_time;            selected.waiting_time = selected.turnaround_time - selected.total_burst_time;            completed++;        }    }}// 输出调度结果void printScheduleResult(const std::vector<Process>& processes) {    std::cout << std::left << std::setw(8) << "PID"              << std::setw(12) << "到达时间"              << std::setw(12) << "总运行时间"              << std::setw(12) << "权重"              << std::setw(12) << "完成时间"              << std::setw(12) << "等待时间"              << std::setw(12) << "周转时间" << std::endl;    std::cout << "---------------------------------------------------------------------------" << std::endl;    int total_waiting = 0, total_turnaround = 0;    int n = processes.size();    for (const auto& p : processes) {        std::cout << std::left << std::setw(8) << p.pid                  << std::setw(12) << p.arrival_time                  << std::setw(12) << p.total_burst_time                  << std::setw(12) << p.weight                  << std::setw(12) << p.completion_time                  << std::setw(12) << p.waiting_time                  << std::setw(12) << p.turnaround_time << std::endl;        total_waiting += p.waiting_time;        total_turnaround += p.turnaround_time;    }    // 计算平均指标    double avg_waiting = static_cast<double>(total_waiting) / n;    double avg_turnaround = static_cast<double>(total_turnaround) / n;    std::cout << "---------------------------------------------------------------------------" << std::endl;    std::cout << "平均等待时间: " << std::fixed << std::setprecision(2) << avg_waiting << " 单位时间" << std::endl;    std::cout << "平均周转时间: " << std::fixed << std::setprecision(2) << avg_turnaround << " 单位时间" << std::endl;}int main() {    // 初始化进程数据：模拟不同到达时间、运行时间和权重的进程    // 权重参考Linux实际值：nice值0对应1024，nice值-5对应1566，nice值5对应677    std::vector<Process> processes = {        {1, 0, 8, 0, 1024, 0.0, 0, 0, 0, false, false},   // 普通进程（nice 0）        {2, 1, 4, 0, 1566, 0.0, 0, 0, 0, false, false},   // 高优先级进程（nice -5）        {3, 2, 3, 0, 677, 0.0, 0, 0, 0, false, false},   // 低优先级进程（nice 5）        {4, 3, 5, 0, 1024, 0.0, 0, 0, 0, false, false}   // 普通进程（nice 0）    };    std::cout << "完全公平调度器（CFS）执行结果：" << std::endl;    cfsScheduler(processes);    printScheduleResult(processes);    return 0;}

#include <iostream>#include <vector>#include <string>#include <cstdlib>#include <cstdio>#include <cmath>#include <unistd.h>#include <sys/wait.h>#include <signal.h>#include <cstring>// 全局变量：用于标记是否接收到退出信号volatile sig_atomic_t g_quit = 0;// 信号处理函数：捕获SIGINT和SIGTERM信号，触发退出void signal_handler(int signum) {    g_quit = 1;}// CPU负载生成函数：循环计算随机数的平方根，占用CPU资源void cpu_worker() {    srand(getpid()); // 按进程ID初始化随机数种子    while (!g_quit) {        double num = static_cast<double>(rand()) / RAND_MAX * 1000000.0;        double result = sqrt(num);        (void)result; // 避免编译器优化掉计算结果    }    exit(0);}// 内存负载生成函数：分配指定大小的内存，并循环修改内容void memory_worker(size_t mem_size_mb) {    size_t mem_size = mem_size_mb * 1024 * 1024; // 转换为字节数    char* buffer = static_cast<char*>(malloc(mem_size));    if (buffer == nullptr) {        perror("内存分配失败");        exit(1);    }    srand(getpid());    while (!g_quit) {        // 循环写入随机数据到内存缓冲区        size_t offset = rand() % (mem_size - sizeof(int));        *reinterpret_cast<int*>(buffer + offset) = rand();        // 读取数据以避免优化        int val = *reinterpret_cast<int*>(buffer + offset);        (void)val;    }    free(buffer);    exit(0);}// 解析命令行参数中的内存大小（支持MB单位）size_t parse_mem_size(const std::string& str) {    if (str.empty()) return 0;    size_t size = atoi(str.c_str());    // 简单处理MB后缀（若有）    if (str.find("M") != std::string::npos || str.find("m") != std::string::npos) {        return size;    }    return size / (1024 * 1024); // 若输入字节数，转换为MB}int main(int argc, char* argv[]) {    // 注册信号处理函数    signal(SIGINT, signal_handler);    signal(SIGTERM, signal_handler);    // 初始化参数    int cpu_workers = 0;    int mem_workers = 0;    size_t mem_size_mb = 128; // 默认内存大小128MB    // 解析命令行参数    for (int i = 1; i < argc; ++i) {        std::string arg = argv[i];        if (arg == "-c" || arg == "--cpu") {            if (i + 1 < argc) {                cpu_workers = atoi(argv[++i]);            }        } else if (arg == "--vm") {            if (i + 1 < argc) {                mem_workers = atoi(argv[++i]);            }        } else if (arg == "--vm-bytes") {            if (i + 1 < argc) {                mem_size_mb = parse_mem_size(argv[++i]);            }        } else if (arg == "-h" || arg == "--help") {            std::cout << "用法: " << argv[0] << " [选项]\n"                      << "选项:\n"                      << "   -c, --cpu N        启动N个CPU负载进程\n"                      << "   --vm N             启动N个内存负载进程\n"                      << "   --vm-bytes SIZE    每个内存负载进程分配的内存大小（单位：MB，如1G=1024M）\n"                      << "   -h, --help         显示帮助信息\n";            return 0;        }    }    if (cpu_workers == 0 && mem_workers == 0) {        std::cerr << "错误：未指定负载类型，请使用-c或--vm参数指定负载进程数\n";        return 1;    }    // 存储子进程ID    std::vector<pid_t> pids;    // 启动CPU负载进程    for (int i = 0; i < cpu_workers; ++i) {        pid_t pid = fork();        if (pid == 0) {            cpu_worker();        } else if (pid > 0) {            pids.push_back(pid);        } else {            perror("fork失败");            return 1;        }    }    // 启动内存负载进程    for (int i = 0; i < mem_workers; ++i) {        pid_t pid = fork();        if (pid == 0) {            memory_worker(mem_size_mb);        } else if (pid > 0) {            pids.push_back(pid);        } else {            perror("fork失败");            return 1;        }    }    std::cout << "已启动 " << cpu_workers << " 个CPU负载进程，"               << mem_workers << " 个内存负载进程（每个内存进程分配 "               << mem_size_mb << "MB 内存）\n"              << "按Ctrl+C停止\n";    // 等待子进程退出，或接收到退出信号    while (!g_quit) {        // 非阻塞等待子进程，避免僵尸进程        for (auto it = pids.begin(); it != pids.end();) {            int status;            pid_t ret = waitpid(*it, &status, WNOHANG);            if (ret == 0) {                ++it;            } else if (ret > 0) {                it = pids.erase(it);            } else {                ++it;            }        }        sleep(1);    }    // 发送SIGTERM信号给所有子进程    std::cout << "\n正在停止所有负载进程...\n";    for (pid_t pid : pids) {        kill(pid, SIGTERM);    }    // 等待所有子进程退出    for (pid_t pid : pids) {        waitpid(pid, nullptr, 0);    }    std::cout << "所有负载进程已停止\n";    return 0;}

g++ -o resource_stress resource_stress.cpp -lm -std=c++11

#include <iostream>#include <vector>#include <thread>#include <mutex>#include <chrono>#include <cstdlib>#include <cstdio>#include <fstream>#include <algorithm>#include <cstring>#include <sys/stat.h>#include <fcntl.h>#include <unistd.h>#include <cmath>// 全局统计变量及互斥锁std::mutex stats_mutex;uint64_t total_operations = 0;uint64_t total_bytes = 0;std::chrono::duration<double> total_elapsed_time(0);// 测试类型枚举enum TestType {    CPU_TEST,    MEMORY_TEST,    FILEIO_TEST};// 文件I/O测试模式枚举enum FileTestMode {    SEQRD,   // 顺序读    SEQWR,   // 顺序写    RNDRD,   // 随机读    RNDWR   // 随机写};// 测试配置结构体struct TestConfig {    TestType test_type;    int num_threads;    // CPU测试配置    int cpu_max_prime;    // 内存测试配置    size_t memory_block_size;    size_t memory_total_size;    // 文件I/O测试配置    size_t file_total_size;    std::string file_test_mode;    std::string test_file_prefix;};// 素数判断函数（试除法，符合sysbench CPU测试逻辑）bool is_prime(int n) {    if (n <= 1) return false;    if (n <= 3) return true;    if (n % 2 == 0 || n % 3 == 0) return false;    for (int i = 5; i * i <= n; i += 6) {        if (n % i == 0 || n % (i + 2) == 0) return false;    }    return true;}// CPU测试线程函数void cpu_worker(const TestConfig& config) {    auto start_time = std::chrono::high_resolution_clock::now();    uint64_t local_ops = 0;    while (true) {        // 计算到指定最大值的素数个数        int prime_count = 0;        for (int i = 2; i <= config.cpu_max_prime; ++i) {            if (is_prime(i)) prime_count++;        }        local_ops++;        // 检查是否达到测试时长（简化为固定运算轮次，实际sysbench为时间控制）        if (local_ops >= 100) break;    }    auto end_time = std::chrono::high_resolution_clock::now();    std::chrono::duration<double> elapsed = end_time - start_time;    std::lock_guard<std::mutex> lock(stats_mutex);    total_operations += local_ops;    total_elapsed_time += elapsed;}// 内存测试线程函数void memory_worker(const TestConfig& config) {    // 分配内存块    char* buffer = new char[config.memory_block_size];    if (!buffer) {        std::cerr << "内存分配失败" << std::endl;        return;    }    auto start_time = std::chrono::high_resolution_clock::now();    uint64_t local_bytes = 0;    while (local_bytes < config.memory_total_size / config.num_threads) {        // 内存写操作        memset(buffer, rand() % 256, config.memory_block_size);        // 内存读操作        for (size_t i = 0; i < config.memory_block_size; ++i) {            volatile char c = buffer[i]; // 避免编译器优化        }        local_bytes += config.memory_block_size * 2; // 写+读字节数    }    auto end_time = std::chrono::high_resolution_clock::now();    std::chrono::duration<double> elapsed = end_time - start_time;    std::lock_guard<std::mutex> lock(stats_mutex);    total_bytes += local_bytes;    total_elapsed_time += elapsed;    delete[] buffer;}// 文件I/O测试线程函数void fileio_worker(const TestConfig& config, int thread_id) {    // 生成线程专属测试文件    std::string filename = config.test_file_prefix + "_" + std::to_string(thread_id);    int fd = open(filename.c_str(), O_CREAT | O_RDWR | O_DIRECT, 0644);    if (fd < 0) {        perror("文件打开失败");        return;    }    // 分配对齐的缓冲区（O_DIRECT要求缓冲区按块大小对齐）    const size_t block_size = 4096;    char* buffer;    posix_memalign((void**)&buffer, block_size, block_size);    if (!buffer) {        perror("缓冲区分配失败");        close(fd);        return;    }    size_t file_size = config.file_total_size / config.num_threads;    uint64_t local_bytes = 0;    auto start_time = std::chrono::high_resolution_clock::now();    if (config.file_test_mode == "seqwr") {        // 顺序写        while (local_bytes < file_size) {            memset(buffer, rand() % 256, block_size);            ssize_t written = write(fd, buffer, block_size);            if (written < 0) break;            local_bytes += written;        }    } else if (config.file_test_mode == "seqrd") {        // 顺序读        lseek(fd, 0, SEEK_SET);        while (local_bytes < file_size) {            ssize_t read_bytes = read(fd, buffer, block_size);            if (read_bytes <= 0) break;            local_bytes += read_bytes;        }    } else if (config.file_test_mode == "rndwr") {        // 随机写        while (local_bytes < file_size) {            off_t offset = rand() % (file_size - block_size);            lseek(fd, offset, SEEK_SET);            memset(buffer, rand() % 256, block_size);            ssize_t written = write(fd, buffer, block_size);            if (written < 0) break;            local_bytes += written;        }    } else if (config.file_test_mode == "rndrd") {        // 随机读        while (local_bytes < file_size) {            off_t offset = rand() % (file_size - block_size);            lseek(fd, offset, SEEK_SET);            ssize_t read_bytes = read(fd, buffer, block_size);            if (read_bytes <= 0) break;            local_bytes += read_bytes;        }    }    auto end_time = std::chrono::high_resolution_clock::now();    std::chrono::duration<double> elapsed = end_time - start_time;    std::lock_guard<std::mutex> lock(stats_mutex);    total_bytes += local_bytes;    total_elapsed_time += elapsed;    // 清理资源    free(buffer);    close(fd);    unlink(filename.c_str());}// 解析命令行参数bool parse_args(int argc, char* argv[], TestConfig& config) {    // 默认配置    config.num_threads = 1;    config.cpu_max_prime = 10000;    config.memory_block_size = 4096;    config.memory_total_size = 1024 * 1024 * 100; // 100MB    config.file_total_size = 1024 * 1024 * 100; // 100MB    config.file_test_mode = "seqrd";    config.test_file_prefix = "sysbench_test_file";    config.test_type = CPU_TEST;    for (int i = 1; i < argc; ++i) {        std::string arg = argv[i];        if (arg == "--test") {            if (i + 1 >= argc) return false;            std::string test = argv[++i];            if (test == "cpu") config.test_type = CPU_TEST;            else if (test == "memory") config.test_type = MEMORY_TEST;            else if (test == "fileio") config.test_type = FILEIO_TEST;            else return false;        } else if (arg == "--num-threads") {            if (i + 1 >= argc) return false;            config.num_threads = atoi(argv[++i]);        } else if (arg == "--cpu-max-prime") {            if (i + 1 >= argc) return false;            config.cpu_max_prime = atoi(argv[++i]);        } else if (arg == "--memory-block-size") {            if (i + 1 >= argc) return false;            config.memory_block_size = atoi(argv[++i]);        } else if (arg == "--file-total-size") {            if (i + 1 >= argc) return false;            config.file_total_size = atoll(argv[++i]) * 1024 * 1024; // 输入MB        } else if (arg == "--file-testmode") {            if (i + 1 >= argc) return false;            config.file_test_mode = argv[++i];        } else if (arg == "-h" || arg == "--help") {            std::cout << "用法: " << argv[0] << " [选项]\n"                      << "选项:\n"                      << "   --test TYPE         测试类型: cpu, memory, fileio\n"                      << "   --num-threads N     线程数（默认1）\n"                      << "   --cpu-max-prime N   CPU测试最大质数（默认10000）\n"                      << "   --memory-block-size N 内存测试块大小（字节，默认4096）\n"                      << "   --file-total-size N 文件I/O测试总大小（MB，默认100）\n"                      << "   --file-testmode MODE 文件I/O模式: seqrd, seqwr, rndrd, rndwr（默认seqrd）\n"                      << "   -h/--help           显示帮助信息\n";            return false;        }    }    return true;}int main(int argc, char* argv[]) {    TestConfig config;    if (!parse_args(argc, argv, config)) {        return 1;    }    std::vector<std::thread> threads;    auto test_start = std::chrono::high_resolution_clock::now();    // 启动测试线程    switch (config.test_type) {        case CPU_TEST:            std::cout << "开始CPU性能测试，线程数: " << config.num_threads                       << ", 最大质数: " << config.cpu_max_prime << std::endl;            for (int i = 0; i < config.num_threads; ++i) {                threads.emplace_back(cpu_worker, config);            }            break;        case MEMORY_TEST:            std::cout << "开始内存性能测试，线程数: " << config.num_threads                       << ", 块大小: " << config.memory_block_size << "字节"                       << ", 总大小: " << config.memory_total_size / 1024 / 1024 << "MB" << std::endl;            for (int i = 0; i < config.num_threads; ++i) {                threads.emplace_back(memory_worker, config);            }            break;        case FILEIO_TEST:            std::cout << "开始文件I/O性能测试，线程数: " << config.num_threads                       << ", 总大小: " << config.file_total_size / 1024 / 1024 << "MB"                       << ", 测试模式: " << config.file_test_mode << std::endl;            for (int i = 0; i < config.num_threads; ++i) {                threads.emplace_back(fileio_worker, config, i);            }            break;    }    // 等待所有线程完成    for (auto& t : threads) {        t.join();    }    auto test_end = std::chrono::high_resolution_clock::now();    std::chrono::duration<double> total_time = test_end - test_start;    // 计算性能指标    std::cout << "\n测试完成，总耗时: " << total_time.count() << "秒\n";    switch (config.test_type) {        case CPU_TEST:            double ops_per_sec = total_operations / total_time.count();            std::cout << "总运算次数: " << total_operations                       << ", 每秒运算次数: " << ops_per_sec << std::endl;            break;        case MEMORY_TEST:            double mem_bandwidth = total_bytes / (1024 * 1024) / total_time.count(); // MB/s            std::cout << "总读写字节数: " << total_bytes                       << ", 内存带宽: " << mem_bandwidth << " MB/s" << std::endl;            break;        case FILEIO_TEST:            double file_bandwidth = total_bytes / (1024 * 1024) / total_time.count(); // MB/s            std::cout << "总读写字节数: " << total_bytes                       << ", 文件I/O吞吐量: " << file_bandwidth << " MB/s" << std::endl;            break;    }    return 0;}

g++ -o sysbench_core sysbench_core.cpp -lpthread -std=c++11