0

我需要估计在同一台计算机的另一个内核上迁移一个 linux 进程需要多少成本。要迁移我使用 sched_setaffinity 系统调用的进程，但我注意到迁移并不总是立即发生，这是我的要求。

更深入地说，我正在创建一个 C 程序，它每次进行两次大量简单计算，第一次没有迁移，第二次有迁移。计算两个时间戳之间的差异应该可以让我粗略估计迁移开销。但是，我需要弄清楚如何迁移当前进程并等到迁移发生

#define _GNU_SOURCE
#define _POSIX_C_SOURCE 199309L

#include <assert.h>
#include <sched.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <stdint.h>

//Migrates the process
int migrate(pid_t pid) {
    const int totCPU = 8;
    const int nextCPU = (sched_getcpu() +1) % totCPU;

    cpu_set_t target;
    CPU_SET(nextCPU, &target);
    if(sched_setaffinity(pid, sizeof(target), &target) < 0)
        perror("Setaffinity");

    return nextCPU;
}

int main(void) {
    long i =0;
    const long iterations = 4;
    uint64_t total_sequential_delays = 0;
    uint64_t total_migration_delays = 0;
    uint64_t delta_us;

    for(int i=0; i < iterations; i++) {
        struct timespec start, end;

        //Migration benchmark only happens in odd iterations
        bool do_migration = i % 2 == 1;
        //Start timestamp
        clock_gettime(CLOCK_MONOTONIC_RAW, &start);
        //Target CPU to migrate
        int target;
        if(do_migration) {
            target = migrate(0);
            //if current CPU is not the target CPU
            if(target != sched_getcpu()) {
                do {
                    clock_gettime(CLOCK_MONOTONIC_RAW, &end);
                }
                while(target != sched_getcpu());
            }
        }

        //Simple computation 
        double k = 5;
        for(int j = 1; j <= 9999; j++) {
            k *= j / (k-3);
        }

        //End timestamp
        clock_gettime(CLOCK_MONOTONIC_RAW, &end);

        //Elapsed time
        delta_us = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_nsec - start.tv_nsec) / 1000;
        if(do_migration) total_migration_delays += delta_us;
        else total_sequential_delays += delta_us;
    }

    //Compute the averages
    double avg_migration = total_migration_delays / iterations;
    double avg_sequential = total_sequential_delays / iterations;

    //Print them
    printf("\navg_migration=%f, avg_sequential=%f",avg_migration,avg_sequential);

    return EXIT_SUCCESS;
}

这里的问题是 do-while 循环（第 46-49 行）有时会永远运行。

4

2 回答 2

0

我需要估计在同一台计算机的另一个内核上迁移一个 linux 进程需要多少成本。

好的，成本可以估算为：

  • 设置新的 CPU 亲和性并执行“yield”或“ sleep(0)”以强制任务切换/重新调度（包括任务切换开销等）所花费的时间。

  • 每个未来的缓存未命中成本“缓存在旧 CPU 上，但尚未缓存在新 CPU 中”内存访问

  • 未来每次“虚拟到物理转换已缓存在旧 CPU 上但尚未缓存在新 CPU 中”内存访问的 TLB 未命中成本

  • NUMA 处罚

  • 负载平衡问题（例如，从“轻负载”CPU 或内核迁移到“由其他进程重负载”的 CPU 或内核可能会导致严重的性能问题，包括内核决定将其他进程迁移到不同 CPU 以修复负载平衡的成本，其中其他流程支付的成本/间接费用可能应包含在迁移流程造成的总成本中）。

注意：

a) 有多个级别的高速缓存（跟踪高速缓存、指令高速缓存、L1 数据高速缓存、L2 数据高速缓存……）并且一些高速缓存在一些 CPU 之间共享（例如，L1 可能在同一内核内的逻辑 CPU 之间共享，L2 可能由 2 个核心共享，L3 可能由 8 个核心共享）。

b) TLB 未命中成本取决于很多因素（例如，如果内核在没有 PCID 功能的情况下使用 Meltdown 缓解措施，并且无论如何每次系统调用都会清除 TLB 信息）。

c) NUMA 惩罚是延迟成本 - 在前一个 CPU（对于前一个 NUMA 节点）上分配的对 RAM 的每次访问（例如缓存未命中）都将比在新/当前 CPU 上分配的对 RAM 的访问具有更高的延迟（正确NUMA 节点）。

d) 所有缓存未命中成本、TLB 未命中成本和 NUMA 惩罚取决于内存访问模式。没有内存访问的基准测试会产生误导。

e) 缓存未命中成本、TLB 未命中成本和 NUMA 惩罚在很大程度上取决于所涉及的硬件 - 例如，在一台“具有快速 RAM 且没有 NUMA 的慢速 CPU”计算机上的基准测试与另一台“具有慢速 RAM 的快速 CPU”完全无关和许多 NUMA 域”计算机。同样，它高度依赖于哪些 CPU（例如，从 CPU #0 迁移到 CPU #1 可能花费很少，而从 CPU #0 迁移到 CPU #15 可能非常昂贵）。

要迁移我使用 sched_setaffinity 系统调用的进程，但我注意到迁移并不总是立即发生，这是我的要求。

在“ sleep(0);”之后加一个“ sched_setaffinity();”。

于 2019-10-29T20:04:54.857 回答
0

您没有清除目标集：

cpu_set_t target;
CPU_ZERO(&target);  /* you need to add this line */
CPU_SET(nextCPU, &target);

所以你不知道你在设置你的亲和力。另一个问题是没有预先支付迁移成本，因此简单地测量从 set_affinity() 到您安顿下来的时间并不是真正合适的测量。运行包含在单个 cpu 中的工作负载可能会更好，然后是两个、三个。此外，请考虑您的工作负载是否应该涉及遍历较大的数据结构，可能带有更新，因为缓存投资的损失也是迁移成本。

于 2019-10-29T18:50:13.450 回答