精华内容
下载资源
问答
  • 进程调度优先级

    2020-06-24 15:16:41
    Linux内核的三种调度策略: ...放在队列尾保证了所有具有相同优先级的RR任务的调度公平 Linux线程优先级设置: 首先,可以通过以下两个函数来获得线程可以设置的最高和最低优先级,函数中的策略即...

    Linux内核的三种调度策略:

        1.SCHED_OTHER 分时调度策略

        2.SCHED_FIFO  实时调度策略,先到先服务。一旦占用cpu则一直运行。一直运行直到有更高优先级任务到达或自己放弃

        3.SCHED_RR实  时调度策略,时间片轮转。当进程的时间片用完,系统将重新分配时间片,并置于就绪队列尾。放在队列尾保证了所有具有相同优先级的RR任务的调度公平

    Linux线程优先级设置:

        首先,可以通过以下两个函数来获得线程可以设置的最高和最低优先级,函数中的策略即上述三种策略的宏定义:

      int sched_get_priority_max(int policy);
      int sched_get_priority_min(int policy);

    注意:SCHED_OTHER 是不支持优先级使用的,而 SCHED_FIFO 和 SCHED_RR 支持优先级的使用,他们分别为1和99,数值越大优先级越高。(用户态下)

        设置和获取优先级通过以下两个函数:

    int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
    int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);
      param.sched_priority = 51; //设置优先级

        系统创建线程时,默认的线程是 SCHED_OTHER。所以如果我们要改变线程的调度策略的话,可以通过下面的这个函数实现。

    int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);

        上面的param使用了下面的这个数据结构:

    struct sched_param
    {
        int __sched_priority; // 所要设定的线程优先级
    };

        我们可以通过下面的测试程序来说明,我们自己使用的系统的支持的优先级:

    复制代码

    #include <stdio.h>
    #include <pthread.h>
    #include <sched.h>
    #include <assert.h>
    
    static int api_get_thread_policy (pthread_attr_t *attr)
    {
        int policy;
        int rs = pthread_attr_getschedpolicy (attr, &policy);
        assert (rs == 0);
    
        switch (policy)
        {
            case SCHED_FIFO:
                printf ("policy = SCHED_FIFO\n");
                break;
            case SCHED_RR:
                printf ("policy = SCHED_RR");
                break;
            case SCHED_OTHER:
                printf ("policy = SCHED_OTHER\n");
                break;
            default:
                printf ("policy = UNKNOWN\n");
                break; 
        }
        return policy;
    }
    
    static void api_show_thread_priority (pthread_attr_t *attr,int policy)
    {
        int priority = sched_get_priority_max (policy);
        assert (priority != -1);
        printf ("max_priority = %d\n", priority);
        priority = sched_get_priority_min (policy);
        assert (priority != -1);
        printf ("min_priority = %d\n", priority);
    }
    
    static int api_get_thread_priority (pthread_attr_t *attr)
    {
        struct sched_param param;
        int rs = pthread_attr_getschedparam (attr, &param);
        assert (rs == 0);
        printf ("priority = %d\n", param.__sched_priority);
        return param.__sched_priority;
    }
    
    static void api_set_thread_policy (pthread_attr_t *attr,int policy)
    {
        int rs = pthread_attr_setschedpolicy (attr, policy);
        assert (rs == 0);
        api_get_thread_policy (attr);
    }
        
    int main(void)
    {
        pthread_attr_t attr;       // 线程属性
        struct sched_param sched;  // 调度策略
        int rs;
    
        /* 
         * 对线程属性初始化
         * 初始化完成以后,pthread_attr_t 结构所包含的结构体
         * 就是操作系统实现支持的所有线程属性的默认值
         */
        rs = pthread_attr_init (&attr);
        assert (rs == 0);     // 如果 rs 不等于 0,程序 abort() 退出
    
        /* 获得当前调度策略 */
        int policy = api_get_thread_policy (&attr);
    
        /* 显示当前调度策略的线程优先级范围 */
        printf ("Show current configuration of priority\n");
        api_show_thread_priority(&attr, policy);
    
        /* 获取 SCHED_FIFO 策略下的线程优先级范围 */
        printf ("show SCHED_FIFO of priority\n");
        api_show_thread_priority(&attr, SCHED_FIFO);
    
        /* 获取 SCHED_RR 策略下的线程优先级范围 */
        printf ("show SCHED_RR of priority\n");
        api_show_thread_priority(&attr, SCHED_RR);
    
        /* 显示当前线程的优先级 */
        printf ("show priority of current thread\n");
        int priority = api_get_thread_priority (&attr);
    
        /* 手动设置调度策略 */
        printf ("Set thread policy\n");
    
        printf ("set SCHED_FIFO policy\n");
        api_set_thread_policy(&attr, SCHED_FIFO);
    
        printf ("set SCHED_RR policy\n");
        api_set_thread_policy(&attr, SCHED_RR);
    
        /* 还原之前的策略 */
        printf ("Restore current policy\n");
        api_set_thread_policy (&attr, policy);
    
        /* 
         * 反初始化 pthread_attr_t 结构
         * 如果 pthread_attr_init 的实现对属性对象的内存空间是动态分配的,
         * phread_attr_destory 就会释放该内存空间
         */
        rs = pthread_attr_destroy (&attr);
        assert (rs == 0);
    
        return 0;
    }

    复制代码

     

    下面是测试程序的运行结果:

    复制代码

    policy=SCHED_OTHER
    Show current configuration of priority
    max_priority=0
    min_priority=0
    show SCHED_FIFO of priority
    max_priority=99
    min_priority=1
    show SCHED_RR of priority
    max_priority=99
    min_priority=1
    show priority of current thread
    priority=0Set thread policy
    set SCHED_FIFO policy
    policy= SCHED_FIFO
    set SCHED_RR policy
    policy= SCHED_RRRestore current policy
    policy=SCHED_OTHER

    复制代码

    ------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    linux 实时线程优先级问题——数值越大优先级越高吗?  

    2012-06-03 15:14:23|  分类: linux内核开发 |字号 订阅

         今天查看了linux下的实时线程,FIFO和RR策略的调度,遇到一个问题:

         priority越大优先级越高呢?还是越小越高呢?

         回答这个问题要明白一个问题,首先,linux2.6内核将任务优先级进行了一个划分:

        0——99  实时进程 

       100——139   非实时进程

        现在,这个划分是起决定作用的,而且一定是数值越小,优先级越高。

        但是,有时候从网上会看到 优先级数值越大,优先级越高?这又是怎么回事?难道有一种说法错了吗?

       实际的原因是这样的,对于一个实时进程,他有两个参数来表明优先级——prio 和 rt_priority,

       prio才是调度所用的最终优先级数值,这个值越小,优先级越高;

       而rt_priority 被称作实时进程优先级,他要经过转化——prio=MAX_RT_PRIO - 1- p->rt_priority; 

       MAX_RT_PRIO = 99;这样意味着rt_priority值越大,优先级越高;

       而内核提供的修改优先级的函数(pthread_attr_setschedparam),是修改rt_priority的值,所以越大,优先级越高

       所以用户在使用实时进程或线程,在修改优先级时,就会有“优先级值越大,优先级越高的说法”,也是对的。

     

    http://bbs.chinaunix.net/thread-1996337-1-1.html
                    关于进程时间片的计算
        进程的时间片time_slice是基于进程静态优先级的。
        静态优先级越高(值越小),时间片就越大。
        计算时间片是通过函数task_timeslice()(kernel/sched.c)来完成的。
        通过优先级来计算时间片的等式为:
            timeslice=MIN_TIMESLICE+((MAX_TIMESLICE-MIN_TIMESLICE)*(MAX_PRIO-1-(p)->static_prio)/(MAX_USER_PRIO-1))
        这样的话就可以将100~139 的优先级映射到200ms~10ms 的时间片上去,优先级数值越大,则分配的时间片越小。
    在Kernel2.6中时间片的计算是分散的,具体的计算既可以用task_timeslice(),也可以用其他方法。
        进程创建时,将父进程的时间片分一半给子进程,同时父进程的时间片减半。
        进程用完时间片以后,需要重新计算时间片,并将进程插入到相应的运行队列。
        进程退出时,根据first_timeslice的值来决定是否将子进程的时间片返还给父进程。
    平均等待时间sleep_avg
        平均等待时间sleep_avg既决定了进程优先级,又影响了进程交互程度。
        进程的平均等待时间(以nanosecond 为单位),在0 到NS_MAX_SLEEP_AVG 之间取值,初值为0。
        这个值是动态优先级计算的关键因子,sleep_avg 越大,计算出来的进程优先级也越高(数值越小)。

    ------------------
       ------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    chrt命令:修改进程的调度策略和优先级

    宋宝华: 关于Linux进程优先级数字混乱的彻底澄清 

            Linux进程的调度优先级数字会在好几个地方出现:内核,用户,top命令。他们各自都有自己的表示法。我们用一个实际的例子来说明,下面在Linux写一个最简单的程序:

    编译它运行,把调度策略设置为SCHED_FIFO,优先级设置为50:$ sudo chrt -f 50 ./a.out这个时候我们在top命令里面观察a.out:

    我们看到a.out的PR(优先级是)-51,CPU利用率100%。
    但是从内核的视角上面来看,又会用99减去用户在chrt里面设置的优先级:


    上面的MAX_RT_PRIO的值为:

     

    所以上述进程的优先级,在三个不同视角的值分别为:

    用户

    内核

    Top

    50

    49

    -51

     

    咋回事

    Linux的RT调度策略和普通进程在调度算法上面有差异,RT的SCHED_FIFO和SCHED_RR采用的是一个bitmap:

    每次从第0bit开始往后面搜索第一个有进程ready的bit,然后调度这个优先级上面的进程执行,所以在内核里面,prio数值越小,优先级越高
    但是从用户态的API里面,则是数值越大,优先级越高。下面的代码,一个线程通过调用API把自己设置为SCHED_FIFO,优先级50

    这个上面的50,对应内核的49。如果我们把优先级设置为51:

    这个51,对应内核bitmap上面的48。所以,你会发现,从用户的视角来看,数值变大,优先级变高。上面这2个视角,都不是top命令的视角。对于RT的进程而言,TOP的视角里面的PR= -1 -用户视角譬如,下面用户视角的88

    $ sudo chrt -f 88 ./a.out

    对应内核视角的11,对应top视角的-89

    这实在让人有一点晕!!
    这里还有一个特例,就是用户视角的99(内核bitmap视角的0),显示为top命令的RT:

    这说明一点,只有最高优先级的RT进程,才在top里面显示为rt。

    普通的呢?

    普通的讲nice的人相对来说比较简单,我们更关注它的nice值,-20~19之间,nice越低,优先级越高,权重越大,在CFS的红黑树左边的机会大。

    你发现.nice为5的进程,在top命令显示PR是25。下面我们看nice是-5的:

    它显示的是PR=15。由此大家可以发现规律,对于普通的采用CFS策略的NORMAL进程,top里面的PR=20+NICE

    在一起

    总结一下,4个例子

    用户

    内核

    Top

    RT 50

    49 (99-50)

    -51 (-1-50)

    RT 99

    rt

    NICE 5

     

    25

    NICE -5

     

    15

    由此发现,在top里面,RT策略的PR都显示为负数;最高优先级的RT,显示为rt。top命令里面也是,数字越小,优先级越高。

     

    展开全文
  • CPU隔离和进程调度优先级设置的相关知识:1. uboot 启动参数中增加 ”isolcpus=1“ , 计数从0开始 表示隔离第2个CPU, 系统启动后,程序不能在第2个CPU上运行。 如果要使用隔离的CPU,需要在代码中添加如下代码...
    CPU隔离和进程调度优先级设置的相关知识:
    1.  uboot 启动参数中增加 ”isolcpus=1“  , 计数从0开始
         表示隔离第2个CPU, 系统启动后,程序不能在第2个CPU上运行。
         如果要使用隔离的CPU,需要在代码中添加如下代码。    

    pid_t tid;
    cpu_set_t set;
    tid = gettid();
    CPU_ZERO( &set );
    CPU_SET( 1, &set );
    sched_setaffinity( tid, sizeof(cpu_set_t), &set );

    查看线程运行在那个CPU上:
     a . 执行top -H,    显示所有线程信息
     b.  按f键进入菜单向,使用方向键移动到“ P       = Last Used Cpu”,用空格键选中
     c.   按q键回到上级菜单显示如下,多了一列P,
      PID USER      PR  NI    VIRT    RES %CPU %MEM     TIME+     P      S COMMAND           
        1   root          20   0        2.3m   0.7m  0.0     0.3          0:04.65    0       S  init              
       92  root          20   0        1.8m   0.6m  0.0     0.2          0:00.01    1       S  `- pvalue_valid+ 

    2.  设置线程调度策略和优先级
    pthread_attr_t attr;
     int policy, inher;
     struct sched_param param;      
                                                                                                       
     pthread_attr_init(&attr);
     // policy = SCHED_FIFO;
     policy = SCHED_RR;
          
      ret = pthread_attr_setschedpolicy(&attr, policy);
      if (ret != 0)   printf(" pthread_attr_setschedpolicy/n%s/n", strerror(ret));
     
      param.sched_priority = 99;
      ret = pthread_attr_setschedparam(&attr, &param);
       if (ret != 0)   printf(" pthread_attr_setschedparam/n%s/n", strerror(ret));

      pthread_attr_setinheritsched(&attr,PTHREAD_EXPLICIT_SCHED);   //设置线程调度策略时,必须设置此参数,否则会继承父进程的属性。
      ret = pthread_create(&thread_la, &attr, threadTEST, NULL);

    查看线程调度策略和优先级,可以用命令chrt
    chrt -p pid 
    设置为实时调度,优先级99,执行命令
    chrt -r  -p  99  pid 

    3. 补充,另外 PC(Ubuntu)机上有个taskset命令 (默认已安装),可以设置程序运行在那个cpu上,但要隔离CPU,设置比较麻烦。大家可以设置程序运行在那个CPU上。
       
     例: 程序启动时
         taskset   -c 0,5,7,9-11   ./app             
         app启动后可以在0,5,7,9,10,11号cpu上运行;    cpuid是从0 开始计数,cpuid可以10进制,也可以16进制0x00EA1, 1位代表一个cpu,最低位为cpu0

      例:程序运行后
         taskset   -cp 0    11111
         设置进程号为 11111的进程在 cpu 0上运行。

    查看使用上面的提到的TOP命令。


    4    可以使用Cgroup,配置比较复杂,可以查一下资料,这里指示做简单的介绍。

    Cgroup(control group)是将任意进程进行分组化管理的Linux内核功能。Cgroup本身是提供将进程进行分组化管理的功能和接口的基础结构,I/O或内存的分配控制等具体的资源管理功能是通过这个功能来实现的。这些具体的资源管理功能称为Cgroup子系统或控制器。

    Cgroup子系统有控制内存的Memory控制器、控制进程调度的CPU控制器等。运行中的内核可以使用的Cgroup子系统由/proc/cgroup来确认。

    Cgroup提供了一个cgroup虚拟文件系统,作为进行分组管理和各子系统设置的用户接口。要使用Cgroup,必须挂载cgroup文件系统。这时通过挂载选项指定使用哪个子系统。

    展开全文
  • C语言编写的操作系统作业--模拟进程调度 优先级算法
  • sched_setscheduler()函数 sched_setscheduler()函数将pid所指定进程的调度策略和调度参数分别设置为param指向的sched_param结构中指定的policy和参数。...FreeSWITCH对进程调度相关处理 目前,...

    sched_setscheduler()函数

    sched_setscheduler()函数将pid所指定进程的调度策略和调度参数分别设置为param指向的sched_param结构中指定的policy和参数。sched_param结构中的sched_priority成员的值可以为任何整数,该整数位于policy所指定调度策略的优先级范围内(含边界值)

    FreeSWITCH对进程调度相关处理

    目前,Linux支持通过参数policy中指定值的方法设定以下“正常”(即非实时)调度策略:

    SCHED_OTHER 标准的循环分时策略
    SCHED_BATCH 用于“批量”样式执行过程
    SCHED_IDLE      用于运行非常低优先级的后台作业  
    

    对于上述每个策略,param->sched_priority必须为0。

    另外还支持各种”实时“策略,用于线程执行方式的需要精确控制以时间为核心的特殊应用程序,即调度实时线程。
    实时策略中可以指定的值是:

    SCHED_FIFO    先进先出策略
    SCHED_RR      轮询策略。
    

    对于上述的策略,param->sched_priority需要指定调度线程的优先级。
    sched_getscheduler()返回由pid标识的线程的当前调度策略。如果pid等于0,则将检索调用线程的策略。

    参数设置:

    #ifdef USE_SCHED_SETSCHEDULER
    /*
     * Try to use a round-robin scheduler
     * with a fallback if that does not work
     */
    struct sched_param sched = { 0 };
    sched.sched_priority = SWITCH_PRI_LOW;
    #endif
    

    进行调度策略的设定:

    #ifdef USE_SCHED_SETSCHEDULER
    	if (sched_setscheduler(0, SCHED_FIFO, &sched) < 0) {
    		fprintf(stderr, "ERROR: Failed to set SCHED_FIFO scheduler (%s)\n", strerror(errno));
    		sched.sched_priority = 0;
    		if (sched_setscheduler(0, SCHED_OTHER, &sched) < 0 ) {
    			fprintf(stderr, "ERROR: Failed to set SCHED_OTHER scheduler (%s)\n", strerror(errno));
    			return -1;
    		}
    	}
    #endif
    

    进行调度优先级的设定:

    #ifdef HAVE_SETPRIORITY
    	/*
    	 * setpriority() works on FreeBSD (6.2), nice() doesn't
    	 */
    	if (setpriority(PRIO_PROCESS, getpid(), -10) < 0) {
    		fprintf(stderr, "ERROR: Could not set nice level\n");
    		return -1;
    	}
    #else
    	if (nice(-10) != -10) {
    		fprintf(stderr, "ERROR: Could not set nice level\n");
    		return -1;
    	}
    #endif
    
    展开全文
  • 进程调度模拟设计——优先级法、最高响应比优先调度算法
  • 用C++写的操作系统进程调度,模拟短进程优先和优先级法进行进程调度,字符界面
  • 使用C模拟的操作系统以优先级为标准调度进程的算法,进程调度一次优先级减1,同时剩余运行时间减1
  • 进程调度 优先级法 c语言版 亲测vc6.0编译通过#include "stdio.h"#include #include #define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb /* 定义进程控制块PCB */{char name[10];...

    进程调度 优先级法 c语言版 亲测vc6.0编译通过

    #include "stdio.h"

    #include

    #include

    #define getpch(type) (type*)malloc(sizeof(type))

    #define NULL 0

    struct pcb /* 定义进程控制块PCB */

    {

    char name[10];

    char state;

    int super;

    int ntime;

    int rtime;

    struct pcb* link;

    }*ready=NULL,*p;

    typedef struct pcb PCB;

    void sort() /* 建立对进程进行优先级排列函数*/

    {

    PCB *first, *second;

    int insert=0;

    if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/

    {

    p->link=ready;

    ready=p;

    }

    else /* 进程比较优先级,插入适当的位置中*/

    {

    first=ready;

    second=first->link;

    while(second!=NULL)

    {

    if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/

    { /*插入到当前进程前面*/

    p->link=second;

    first->link=p;

    second=NULL;

    insert=1;

    }

    else /* 插入进程优先数最低,则插入到队尾*/

    {

    first=first->link;

    second=second->link;

    }

    }

    if(insert==0) first->link=p;

    }

    }

    void input() /* 建立进程控制块函数*/

    {

    int i,num;

    system("cls"); /*清屏*/

    printf("\n 你要轮转调度几个进程,请输入");

    scanf("%d",&num);

    for(i=1;i<=num;i++)

    {

    printf("\n 进程号No.%d:\n",i);

    p=getpch(PCB);

    printf("\n 输入进程名:");

    scanf("%s",p->name);

    printf("\n 输入进程优先权数:");

    scanf("%d",&p->super);

    printf("\n 输入完成该进程所需时间:");

    scanf("%d",&p->ntime);

    printf("\n");

    p->rtime=0;p->state='w';

    p->link=NULL;

    sort(); /* 调用sort函数*/

    }

    }

    int space()

    {

    int l=0;

    PCB* pr=ready;

    while(pr!=NULL)

    {

    l++;

    pr=pr->link;

    }

    return(l);

    }

    void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/

    {

    printf("\n");

    printf("\n进程名\t 状态\t 优先权\t 进程需要的时间\t 执行次数\n");

    printf(" %s\t",pr->name);

    printf(" %c\t",pr->state);

    printf(" %d\t",pr->super);

    printf(" %d\t",pr->ntime);

    printf(" %d\t",pr->rtime);

    printf("\n");

    }

    void check() /* 建立进程查看函数 */

    {

    PCB* pr;

    printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/

    展开全文
  • 实验代码: #include<stdio.h> #include<stdlib.h> #include"procelink.h" void main() { process *PQ; int n;... printf("请输入进程个数:"); scanf("%d",&n); printf("请输入...
  • C++进程优先级调度进程优先级调度进程优先级调度C++进程优先级调度进程优先级调度进程优先级调度
  • 在Linux下改变进程优先级 ...作为多任务的操作系统,Linux内核为每个创建的进程分配时间片并根据其优先级进行调度。当进程被创建时,其对应的task_struct里包含了四个优先级: struct task_struct { ...
  • 操作系统进程调度中,优先级调度算法模拟,模拟进程调度,采用优先级调度算法,非抢占式,资源分配,资源分配。
  • 静态优先级 动态优先级 基本时间片 平均睡眠时间 惩罚值 运行队列
  • linux进程调度,优先级、进程nice值

    万次阅读 2016-05-03 16:06:04
    我自己补充一下:APUE8.16中讲到进程调度,UNIX系统历史上对进程提供的只是基于调度优先级的粗粒度的控制.调度策略和调度优先级是由内核确定的.但是内核可以通过调整nice值选择以更低优先级运行(通过调整nice值降低它...
  • 进程调度中的所谓调度就是从就绪队列中选择一个进程投入CPU运行,则调度的主战场就是就绪队列,核心是调度算法,实质性的动作是进程的切换。 对于以时间片为主的调度,时钟中断就是驱动力,确保每个进程在CPU上运行...
  • 操作系统实验课程中进程优先级调度算法利用C语言实现程序
  • 进程动态优先级调度

    2016-11-26 18:30:00
    简单的进程优先级动态调度 cup运行: 每执行一次,优先级减一,运行时间减一。 就绪队列中的进程:每次按优先级降序排序(优先级越大越优先执行),若优先级相等再按时间升序排序(时间越小越优先执行)。 所用...
  • 进程调度,代码挺详细的,对进程的调度描述的很好。
  • 操作系统进程调度优先级反转,调度策略,linux进程调度策略。
  • 1. 调度策略 主要三种: SCHED_FIFO 先进先出,不使用时间片,一直运行直到有更高优先级(SCHED_FIFO或SCHED_RR)任务到达或自己放弃; SCHED_FIFO级任务比任何SCHED_NORMAL级任务都优先得到调度; 多个通...
  • 进程优先级/进程调度策略

    千次阅读 2018-07-12 09:36:50
    http://www.cnitblog.com/flutist1225/articles/19989.html 如何查看/设置/调整进程的... 修改为实时进程: chrt进程的nice值不是进程优先级,他们不是一个概念,但是进程nice值会影响到进程优先级变化。 5. ...
  • 本文件包含完整的大作业完整的资源,包含c++源代码,可运行,有调度视频,有实验报告。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,943
精华内容 1,577
关键字:

进程调度优先级