SCHED_IDLE 实际上会阻止在非空闲核心上执行吗？

Question

我正在尝试使用 SCHED_IDLE 在没有优先级继承互斥锁的情况下实现无限制优先级反转的非特权测试用例。该测试适用于 SCHED_FIFO 和不同的实时优先级（非 PI 互斥锁死锁，立即使用 PI 互斥锁解决），但要将其包含在运行没有实时权限的测试集中，我希望使用 SCHED_IDLE 代替，"medium" 和 "high" 优先级线程都是 SCHED_OTHER（在这种情况下它不是真正的优先级 "inversion"，但这个概念应该仍然工作 - "medium" 应该排除 "low" 的执行）。

不幸的是，测试无法区分 PI 和非 PI 互斥；无论哪种方式，它都会取得进展。显然 SCHED_IDLE 任务是运行ning 即使有另一个运行nable 任务。 CPU affinity 已设置为将它们全部绑定到同一个核心，这样低优先级任务就无法迁移到运行的不同核心。而且我知道 SCHED_IDLE 任务应该运行在内核空间中以提升的权限来防止内核空间优先级反转，所以我尝试确保 "low" 线程不会进入内核空间通过使其在用户空间中处于忙循环状态，并且 strace 没有迹象表明它在不应该向前推进的时候正在进行系统调用。

Linux 的 SCHED_IDLE 是否只允许空闲任务运行当核心实际上不空闲时？或者还有其他我可能遗漏的东西吗？

这里是测试代码，稍作修改，使其可以运行实时模式或 SCHED_IDLE:

#define _GNU_SOURCE
#include <pthread.h>
#include <sched.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <semaphore.h>

sem_t sem;

void *start1(void *p)
{
    pthread_mutex_lock(p);
    sem_post(&sem);
    sem_post(&sem);
    usleep(100000);
    pthread_mutex_unlock(p);
    return 0;
}

void *start2(void *p)
{
    sem_wait(&sem);
    time_t t0 = time(0);
    while (pthread_mutex_trylock(p)) {
        if (time(0)>t0+5) return 0;
    }
    pthread_mutex_unlock(p);
    return 0;
}

void *start3(void *p)
{
    sem_wait(&sem);
    struct timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    ts.tv_sec += 5;
    int r;
    if (r=pthread_mutex_timedlock(p, &ts)) {
        printf("failed: %d %s\n", r, strerror(r));
    } else {
        pthread_mutex_unlock(p);
    }
    return 0;
}

int main(int argc, char **argv)
{
    int policy = argc>1 ? SCHED_IDLE : SCHED_FIFO;
    int a = sched_get_priority_min(policy);
    pthread_attr_t attr;
    pthread_t t1,t2,t3;
    struct sched_param param = {0};

    cpu_set_t set = {0};
    CPU_ZERO(&set);
    CPU_SET(0, &set);
    pthread_setaffinity_np(pthread_self(), sizeof set, &set);

    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
    pthread_attr_setschedpolicy(&attr, policy);

    pthread_mutexattr_t ma;
    pthread_mutexattr_init(&ma);
    pthread_mutexattr_setprotocol(&ma, PTHREAD_PRIO_INHERIT);
    pthread_mutexattr_settype(&ma, PTHREAD_MUTEX_ERRORCHECK);
    pthread_mutex_t mtx;
    pthread_mutex_init(&mtx, &ma);

    sem_init(&sem, 0, 0);

    param.sched_priority = a+1;
    pthread_attr_setschedparam(&attr, &param);
    if (pthread_create(&t2, policy==SCHED_IDLE ? 0 : &attr, start2, &mtx)) return 1;

    param.sched_priority = a+2;
    pthread_attr_setschedparam(&attr, &param);
    if (pthread_create(&t3, policy==SCHED_IDLE ? 0 : &attr, start3, &mtx)) return 1;

    param.sched_priority = a;
    pthread_attr_setschedparam(&attr, &param);
    if (pthread_create(&t1, &attr, start1, &mtx)) return 1;

    pthread_join(t1, 0);
    pthread_join(t2, 0);
    pthread_join(t3, 0);
    return 0;
}

Answer 1

Does Linux's SCHED_IDLE just allow idle tasks to run when the core is not actually idle? Or is there something else I might be missing?

这是正确的。 SCHED_IDLE 给出任务 a very low but non-zero weighting - 比 19 项任务少 CPU 大约 70% 的时间。

SCHED_IDLE 实际上会阻止在非空闲核心上执行吗？

Does SCHED_IDLE actually preclude execution on non-idle core?

c

linux

posix

pthreads

priority-inversion