Linux-线程优先级学习

概念

Linux系统中常用的几种调度类为SCHED_NORMAL、SCHED_FIFO、SCHED_RR。

SCHED_NORMAL：用于普通线程的调度类
SCHED_FIFO和SCHED_RR是用于实时线程的调度类，优先级高于SCHED_NORMAL。

内核中区分普通线程与实时线程是根据线程的优先级，实时线程拥有实时优先级（real-time priority），默认取值为0~99，数值越高优先级越高

普通线程只具有nice值，nice值映射到用户层的取值范围为-20～+19，数值越高优先级越低，默认初始值为0 ，子线程会继承父线程的优先级。

标准函数

#include <pthread.h>

pthread_setschedparam(pthread_t thread, int policy,
                        const struct sched_param *param);
pthread_getschedparam(pthread_t thread, int *policy,
                        struct sched_param *param);

Compile and link with -pthread.

描述：
- pthread_setschedparam函数用于设置调度策略policy和线程参数(也就是优先级)
- pthread_getschedparam函数用户获取调度策略policy和线程参数(也就是优先级)
参数说明：
- policy参数：线程新的调度策略，policy的描述可查看sched_setscheduler(2)
```
// /usr/include/bits/sched.h
#define SCHED_OTHER  0
#define SCHED_FIFO   1
#define SCHED_RR     2
```
- param参数：指定新的调度策略的参数，每一种调度策略的优先级允许设置的范围可查看sched_setscheduler(2)
```
struct sched_param {
    int sched_priority;     /* Scheduling priority */
};
```
返回值：成功返回0，失败返回非0值。常见的错误值
```
// /usr/include/asm-generic/errno-base.h
#define EPERM        1  /* Operation not permitted */
#define ESRCH        3  /* No such process */
#define EINVAL      22  /* Invalid argument */
```
- ESRCH: 线程ID未发现
- EINVAL: policy不合法，或者param不合法
- EPERM: 没有权限，policy为SCHED_FIFO、SCHED_RR时，需要root权限

标准示例

示例演示了使用pthread_setschedparam() 和 pthread_getschedparam()和其它一些与实施调度相关的一些函数。

main thread设置为SCHED_FIFO调度策略，优先级设置为10，并且初始化一个线程属性对象：调度策略SCHED_RR，优先级20。
接着程序设置线程的继承调度器属性为PTHREAD_EXPLICIT_SCHED -- 创建的线程属性应该为线程属性对象的调度器属性。
接着使用线程属性对象创建一个线程，然后显示线程的调度策略和优先级。

源码：standerd_examp.c.c

/* pthreads_sched_test.c */

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>

#define handle_error_en(en, msg) \
    do {                         \
        errno = en;              \
        perror(msg);             \
        exit(EXIT_FAILURE);      \
    } while (0)

static void
usage(char *prog_name, char *msg)
{
    if (msg != NULL)
        fputs(msg, stderr);

    fprintf(stderr, "Usage: %s [options]\n", prog_name);
    fprintf(stderr, "Options are:\n");
#define fpe(msg) fprintf(stderr, "\t%s", msg); /* Shorter */
    fpe("-a<policy><prio> Set scheduling policy and priority in\n");
    fpe("                 thread attributes object\n");
    fpe("                 <policy> can be\n");
    fpe("                     f  SCHED_FIFO\n");
    fpe("                     r  SCHED_RR\n");
    fpe("                     o  SCHED_OTHER\n");
    fpe("-A               Use default thread attributes object\n");
    fpe("-i {e|s}         Set inherit scheduler attribute to\n");
    fpe("                 'explicit' or 'inherit'\n");
    fpe("-m<policy><prio> Set scheduling policy and priority on\n");
    fpe("                 main thread before pthread_create() call\n");
    exit(EXIT_FAILURE);
}

static int
get_policy(char p, int *policy)
{
    switch (p) {
        case 'f':
            *policy = SCHED_FIFO;
            return 1;
        case 'r':
            *policy = SCHED_RR;
            return 1;
        case 'o':
            *policy = SCHED_OTHER;
            return 1;
        default:
            return 0;
    }
}

static void
display_sched_attr(int policy, struct sched_param *param)
{
    printf("    policy=%s, priority=%d\n",
           (policy == SCHED_FIFO)  ? "SCHED_FIFO" :
           (policy == SCHED_RR)    ? "SCHED_RR" :
           (policy == SCHED_OTHER) ? "SCHED_OTHER" :
                                     "???",
           param->sched_priority);
}

static void
display_thread_sched_attr(char *msg)
{
    int                policy, s;
    struct sched_param param;

    s = pthread_getschedparam(pthread_self(), &policy, &param);
    if (s != 0)
        handle_error_en(s, "pthread_getschedparam");

    printf("%s\n", msg);
    display_sched_attr(policy, &param);
}

static void *
thread_start(void *arg)
{
    display_thread_sched_attr("Scheduler attributes of new thread");

    return NULL;
}

int main(int argc, char *argv[])
{
    int                s, opt, inheritsched, use_null_attrib, policy;
    pthread_t          thread;
    pthread_attr_t     attr;
    pthread_attr_t    *attrp;
    char              *attr_sched_str, *main_sched_str, *inheritsched_str;
    struct sched_param param;

    /* Process command-line options */

    use_null_attrib = 0;
    attr_sched_str = NULL;
    main_sched_str = NULL;
    inheritsched_str = NULL;

    while ((opt = getopt(argc, argv, "a:Ai:m:")) != -1) {
        switch (opt) {
            case 'a':
                attr_sched_str = optarg;
                break;
            case 'A':
                use_null_attrib = 1;
                break;
            case 'i':
                inheritsched_str = optarg;
                break;
            case 'm':
                main_sched_str = optarg;
                break;
            default:
                usage(argv[0], "Unrecognized option\n");
        }
    }

    if (use_null_attrib && (inheritsched_str != NULL || attr_sched_str != NULL))
        usage(argv[0], "Can't specify -A with -i or -a\n");

    /* Optionally set scheduling attributes of main thread,
       and display the attributes */

    if (main_sched_str != NULL) {
        if (!get_policy(main_sched_str[0], &policy))
            usage(argv[0], "Bad policy for main thread (-s)\n");
        param.sched_priority = strtol(&main_sched_str[1], NULL, 0);

        s = pthread_setschedparam(pthread_self(), policy, &param);
        if (s != 0)
            handle_error_en(s, "pthread_setschedparam");
    }

    display_thread_sched_attr("Scheduler settings of main thread");
    printf("\n");

    /* Initialize thread attributes object according to options */

    attrp = NULL;

    if (!use_null_attrib) {
        s = pthread_attr_init(&attr);
        if (s != 0)
            handle_error_en(s, "pthread_attr_init");
        attrp = &attr;
    }

    if (inheritsched_str != NULL) {
        if (inheritsched_str[0] == 'e')
            inheritsched = PTHREAD_EXPLICIT_SCHED;
        else if (inheritsched_str[0] == 'i')
            inheritsched = PTHREAD_INHERIT_SCHED;
        else
            usage(argv[0], "Value for -i must be 'e' or 'i'\n");

        s = pthread_attr_setinheritsched(&attr, inheritsched);
        if (s != 0)
            handle_error_en(s, "pthread_attr_setinheritsched");
    }

    if (attr_sched_str != NULL) {
        if (!get_policy(attr_sched_str[0], &policy))
            usage(argv[0],
                  "Bad policy for 'attr' (-a)\n");
        param.sched_priority = strtol(&attr_sched_str[1], NULL, 0);

        s = pthread_attr_setschedpolicy(&attr, policy);
        if (s != 0)
            handle_error_en(s, "pthread_attr_setschedpolicy");
        s = pthread_attr_setschedparam(&attr, &param);
        if (s != 0)
            handle_error_en(s, "pthread_attr_setschedparam");
    }

    /* If we initialized a thread attributes object, display
       the scheduling attributes that were set in the object */

    if (attrp != NULL) {
        s = pthread_attr_getschedparam(&attr, &param);
        if (s != 0)
            handle_error_en(s, "pthread_attr_getschedparam");
        s = pthread_attr_getschedpolicy(&attr, &policy);
        if (s != 0)
            handle_error_en(s, "pthread_attr_getschedpolicy");

        printf("Scheduler settings in 'attr'\n");
        display_sched_attr(policy, &param);

        s = pthread_attr_getinheritsched(&attr, &inheritsched);
        printf("    inheritsched is %s\n",
               (inheritsched == PTHREAD_INHERIT_SCHED)  ? "INHERIT" :
               (inheritsched == PTHREAD_EXPLICIT_SCHED) ? "EXPLICIT" :
                                                          "???");
        printf("\n");
    }

    /* Create a thread that will display its scheduling attributes */

    s = pthread_create(&thread, attrp, &thread_start, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_create");

    /* Destroy unneeded thread attributes object */

    s = pthread_attr_destroy(&attr);
    if (s != 0)
        handle_error_en(s, "pthread_attr_destroy");

    s = pthread_join(thread, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_join");

    exit(EXIT_SUCCESS);
}

测试：

# 默认启动的线程为调度policy为SCHED_OTHER, 默认的调度优先级为0
root@ubuntu:/home/grace# ./a.out 
Scheduler settings of main thread
    policy=SCHED_OTHER, priority=0
# 没有设置attribute
Scheduler settings in 'attr'
    policy=SCHED_OTHER, priority=0
    inheritsched is INHERIT
# 新创建线程优先级和main一致
Scheduler attributes of new thread
    policy=SCHED_OTHER, priority=0

# 设置main线程调度策略为SCHED_FIFO, 调度优先级为10
# 设置thread attributes object的调度策略为SCHED_RR, 优先级为20
# 设置inherit scheduler attribute为PTHREAD_EXPLICIT_SCHED
# 测试结果为新创建的线程的调度策略和优先级为attribute object设置的值
root@ubuntu:/home/grace# ./a.out -mf10 -ar20 -i e
Scheduler settings of main thread
    policy=SCHED_FIFO, priority=10

Scheduler settings in 'attr'
    policy=SCHED_RR, priority=20
    inheritsched is EXPLICIT

Scheduler attributes of new thread
    policy=SCHED_RR, priority=20

# 设置main线程调度策略为SCHED_FIFO, 调度优先级为10
# 设置thread attributes object的调度策略为SCHED_RR, 优先级为20
# 设置inherit scheduler attribute为PTHREAD_INHERIT_SCHED,
# 测试结果为新创建的线程会忽略attribute object设置的值, 属性值直接从父线程继承
root@ubuntu:/home/grace# ./a.out -mf10 -ar20 -i i
Scheduler settings of main thread
    policy=SCHED_FIFO, priority=10

Scheduler settings in 'attr'
    policy=SCHED_RR, priority=20
    inheritsched is INHERIT

Scheduler attributes of new thread
    policy=SCHED_FIFO, priority=10

SCHED_SETSCHEDULER(2)

参考：https://zhuanlan.zhihu.com/p/618044514?utm_id=0

#include <sched.h>
int sched_setscheduler(pid_t pid, int policy, const struct sched_param *param);
int sched_getscheduler(pid_t pid);

struct sched_param {
    ...
    int sched_priority;
    ...
};

sched_setscheduler函数的作用是为pid指定的线程设置调度策略和优先级。如果pid为0，则会设置调用该函数的线程的策略和优先级。

sched_getscheduler函数作用是查询pid指定的线程的调度策略和优先级。如果pid为0，则会查询调用该函数的线程的策略和优先级。

Linux支持的调度策略分为两类：

normal类型：
- SCHED_OTHER the standard round-robin time-sharing policy; # 循环分时调度策略
- SCHED_IDLE for running very low priority background jobs. # 低优先级线程作为背景线程运行
real-time类型
- SCHED_FIFO a first-in, first-out policy; # 先进先出调度策略
- SCHED_RR a round-robin policy. # 轮转调度

Scheduling policies

调度器是内核的一部分，用来决定哪个就绪态线程获取CPU执行。每一个线程有一个关联的调度策略和一个static调度优先级sched_priority，这些参数可以通过sched_setscheduler()函数设置。内核中的调度器根据调度策略和所有处理器的static priority决定调度哪个线程。
使用normal调度策略（SCHED_OTHER, SCHED_IDLE, SCHED_BATCH）的线程，sched_priority参数没有使用，必须设置为0。
使用real-time调度策略（SCHED_FIFO, SCHED_RR）有一个sched_priority，范围1 (low) 到 99 (high)。（real-time类型线程总是高于normal类型线程）。可以使用sched_get_priority_min()和sched_get_priority_max()函数查看每个调度策略对应的优先级范围。
调度器根据sched_priority值保存一个可运行线程列表，然后调度器选择最高的static priority线程列表，选择列表开头的线程运行。
同样的static priority的线程，调度器根据调度算法决定哪个运行。
线程的调度策略决定线程将插入到具有同等优先级的线程列表中的位置。
所有的调度都是抢占式的，如果具有高静态优先级的线程准备运行，则当前正在运行的线程将被抢占并返回到其静态优先级的等待列表中。调度策略仅在具有同等静态优先级的可运行线程列表中确定排序。

SCHED_FIFO: First in-first out scheduling

SCHED_FIFO只能使用static priorities大于0的值。这表示，当一个调度策略为SCHED_FIFO的线程变成运行态时，总是优先于当前正在运行的SCHED_OTHER, SCHED_BATCH, or SCHED_IDLE策略的线程。
SCHED_FIFO是一个简单的调度算法，没有切分时间片。
调度策略为SCHED_FIFO的线程遵循下面的规则：
- 一个低优先级SCHED_FIFO调度的线程被更高优先级的线程抢占后，会放在同等优先级列表的头部，等待所有更高优先级的线程执行完毕后，会恢复执行。
- 当一个阻塞的SCHED_FIFO线程变成就绪态时，会放在同等优先级列表的尾部。
- 可以使用sched_setscheduler（2）、sched_setparam（2）、sched_setattr（2）、pthread_setschedparam（3）或 pthread_setschedprio（3）函数设置正在运行的SCHED_FIFO调度线程的优先级，则对线程在列表中的位置影响却决于线程优先级的更改方向。
  - 如果线程的优先级提高，将其放在新的线程列表的尾部。
  - 如果线程的优先级不变，则其在列表中的位置不变。
  - 如果线程的优先级降低，则将其放在新优先级列表的前面。
- 一个线程调用sched_yield()函数将放到列表的尾部。
- 一个SCHED_FIFO线程会一直运行，除非被I/O请求阻塞，或者被更高优先级线程抢占，或者调用sched_yield()函数。

SCHED_RR: Round-robin scheduling

SCHED_RR调度策略是SCHED_FIFO策略的增强版本。
适用于SCHED_FIFO的策略也适用于SCHED_RR，除了每一个线程仅被运行执行一个最大的时间片。
如果SCHED_RR线程运行时间已经大于等于了时间片，它会被放在同等优先级列表的尾部。
一个SCHED_RR线程被更高优先级的线程抢占后，恢复执行时使用未消耗完的时间片。
时间片可以使用sched_rr_get_interval()函数查询。

SCHED_OTHER调度策略仅能使用static priority为0（real-time的优先级始终高于normal）。
SCHED_OTHER是标准的时间片轮转调度，适用于不需要特殊实时机制的所有线程。
要运行的线程是从static priority为0列表中选择的，该列表基于一个动态优先级。
动态优先级基于nice值，可以通过nice()或者setpriority()设置。
当线程准备运行但被调度器拒绝运行时，nice值也会增加。
nice值是一个属性，它会影响SCHED_OTHER和SCHED_BATCH（见下文）进程的调度。nice 值可以使用 nice（2）、setpriority（2）或 sched_setattr（2）进行修改。
Linux上，nice值的范围是-20（高优先级）到+19（低优先级）。

SCHED_IDLE: Scheduling very low priority jobs

SCHED_IDLE线程的static priority值为0。线程的nice值对此调度策略没有影响。
SCHED_IDLE调度策略适用于优先级非常低的线程。

Resetting scheduling policy for child processes

每一个线程有一个reset-on-fork调度标志。设置此标志后，fork()创建的子进程不会继承特权调度策略，可以通过下面的方式设置此标志：
- 当调用sched_setscheduler()函数时，将标志SCHED_RESET_ON_FORK放入策略参数中。
- 调用 sched_setattr（2）时，在 attr.sched_flags 中指定 SCHED_FLAG_RESET_ON_FORK 标志。
当SCHED_RESET_ON_FORK标志设置后，创建的子线程将遵循下面的规则：
- 如果父线程调度策略为SCHED_FIFO或者SCHED_RR，子线程将恢复为SCHED_OTHER；
- 如果父线程有一个负的nice值，子线程的nice值将变为0；
- 这个标志将在fork()函数创建子线程后失效，也就是子线程不继承这个标志；
- 这个标志可以通过sched_getscheduler()函数查询。

Privileges and resource limits

在Linux 2.6.12版本后，RLIMIT_RTPRIO限制了SCHED_RR和SCHED_FIFO调度策略的非特权程序的static priority上限。更改调度策略和优先级遵守下面的规则：
- 如果一个非特权程序有非0的RLIMIT_RTPRIO软件限制，它可以改变它的调度策略和优先级。但优先级不能设置高于它当前的优先级的最大值和RLIMIT_RTPRIO软限制。
- 如果RLIMIT_RTPRIO为0，则唯一允许的更改是降低优先级或切换到非real-time调度策略。
可以使用RLIMIT_RTTIME资源限制来设置实时进程可能消耗的 CPU 时间的上限，详见getrlimit(2)
从 Linux 2.6.25 开始，Linux 还提供了两个 /proc 文件，可用于保留一定数量的 CPU 时间供非real-time进程使用。以这种方式保留 CPU 时间允许将一些 CPU 时间分配给（例如）可用于终止失控进程的根 shell。这两个文件都以微秒为单位指定时间值：
- /proc/sys/kernel/sched_rt_period_us: 指定相当于 100% CPU 带宽的调度周期。此文件中的值范围为 1 到 INT_MAX，工作范围为 1 微秒到 35 分钟左右。此文件中的默认值为 1,000,000（1 秒）。
- /proc/sys/kernel/sched_rt_runtime_us: 此文件中的值指定系统上所有实时进程可以使用多少“周期”时间。此文件中的值的范围可以从 -1 到 INT_MAX-1。指定 -1 可使运行时间与周期相同;也就是说，没有为非实时进程留出 CPU 时间（这是 Linux 2.6.25 之前的行为）。此文件中的默认值为 950,000（0.95 秒），这意味着 5% 的 CPU 时间保留给不在实时调度策略下运行的进程。

测试代码

sched_test.c

#include <sched.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc,char *argv[]) 
{
    struct sched_param param; 
    int minpri, maxpri, count; 

    // 获取SCHED_FIFO调度策略可配置的最大优先级
    maxpri = sched_get_priority_max(SCHED_FIFO);
    if(maxpri == -1) { 
        perror("sched_get_priority_max() failed"); 
        return -1; 
    }
    printf("max priority of SCHED_FIFO is %d\n", maxpri);

    minpri = sched_get_priority_min(SCHED_FIFO);
    if(minpri == -1) { 
        perror("sched_get_priority_min() failed"); 
        return -1; 
    }
    printf("min priority of SCHED_FIFO is %d\n", minpri);

#if 0
    param.sched_priority = maxpri; 
    if (sched_setscheduler(getpid(), SCHED_FIFO, &param) == -1) { 
        perror("sched_setscheduler() failed"); 
        return -1; 
    }
#endif

    fork();
    fork();

    while(1) {
        count++;
    }

    return 0;
}

功能：设置进程的调度策略为SCHED_FIFO, 并且优先级设置为最大，创建的子进程也会继承父进程的策略和优先级。

F S UID          PID    SPID    PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
4 R root       19435   19435   19434 99 -40   - -   693 -      22:07 pts/5    00:00:07 ./a.out
1 R root       19436   19436   19435 99 -40   - -   693 -      22:07 pts/5    00:00:07 ./a.out
1 R root       19437   19437   19435 99 -40   - -   693 -      22:07 pts/5    00:00:07 ./a.out
1 R root       19438   19438   19436 99 -40   - -   693 -      22:07 pts/5    00:00:07 ./a.out

grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 19435
pid 19435's current scheduling policy: SCHED_FIFO
pid 19435's current scheduling priority: 99
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 19436
pid 19436's current scheduling policy: SCHED_FIFO
pid 19436's current scheduling priority: 99
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 19437
pid 19437's current scheduling policy: SCHED_FIFO
pid 19437's current scheduling priority: 99
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 19438
pid 19438's current scheduling policy: SCHED_FIFO
pid 19438's current scheduling priority: 99

如果把#if 1改为#if 0, 则默认创建的是SCHED_OTHER类型进程

F S UID          PID    SPID    PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
0 R grace      21187   17702 99  80   0 -   694 -      22:13 pts/0    00:00:02 ./a.out
1 R grace      21189   21187 99  80   0 -   694 -      22:13 pts/0    00:00:02 ./a.out
1 R grace      21190   21187 99  80   0 -   694 -      22:13 pts/0    00:00:02 ./a.out
1 R grace      21191   21189 99  80   0 -   694 -      22:13 pts/0    00:00:02 ./a.out

grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 17702
pid 17702's current scheduling policy: SCHED_OTHER
pid 17702's current scheduling priority: 0
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 21187
pid 21187's current scheduling policy: SCHED_OTHER
pid 21187's current scheduling priority: 0
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 21189
pid 21189's current scheduling policy: SCHED_OTHER
pid 21189's current scheduling priority: 0
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 21190
pid 21190's current scheduling policy: SCHED_OTHER
pid 21190's current scheduling priority: 0
grace@LAPTOP-UNTITVOP:~/thread-policy$ chrt -p 21191
pid 21191's current scheduling policy: SCHED_OTHER
pid 21191's current scheduling priority: 0

posted @ 2023-12-07 22:27 zhengcixi 阅读(1724) 评论(0) 编辑收藏举报

刷新页面返回顶部

MrLayflolk

有志者，事竟成。

Linux-线程优先级学习

概念

标准函数

标准示例

相关工具

ps

chrt工具

SCHED_SETSCHEDULER(2)

Scheduling policies

SCHED_FIFO: First in-first out scheduling

SCHED_RR: Round-robin scheduling

SCHED_IDLE: Scheduling very low priority jobs

Resetting scheduling policy for child processes

Privileges and resource limits

测试代码

公告

MrLayflolk

有志者，事竟成。

Linux-线程优先级学习

概念

标准函数

标准示例

相关工具

ps

chrt工具

SCHED_SETSCHEDULER(2)

Scheduling policies

SCHED_FIFO: First in-first out scheduling

SCHED_RR: Round-robin scheduling

SCHED_OTHER: Default Linux time-sharing scheduling

SCHED_IDLE: Scheduling very low priority jobs

Resetting scheduling policy for child processes

Privileges and resource limits

测试代码

公告