精华内容
下载资源
问答
  • 时间片轮转调度

    2018-11-28 18:44:13
    用高级语言模拟实现动态分区存储管理,要求: 1、分区分配算法至少实现首次适应算法、最佳适应算法和最坏适应算法中的至少一种。熟悉并掌握各种算法的空闲区组织方式。 2、分区的初始化——可以由用户输入初始分区的...
  • 时间片轮转调度算法

    2019-05-02 12:41:06
    操作系统用时间片轮转调度算法实现进程块的调度,按进程调度顺序打印进程执行信息
  • 时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual ...
  • 操作系统课程时间片轮转调度模拟程序,程序相对简单,通过这个模拟程序能够帮助学习者会更好的学习os,供有需要的人学习使用。
  • 内容:南邮实验周,时间片轮转调度算法模拟实验完整代码 时间:2018/5/31 说明:该代码实现功能的完整描述见我空间的“南邮实验周_时间片轮转调度算法模拟_报告”
  • 时间片轮转调度算法的计算

    万次阅读 多人点赞 2018-04-25 14:39:23
    在分时系统中,最简单最常用的就是基于时间片轮转调度算法,时间片轮转调度算法是非常公平的处理机分配方式,让就绪队列的每个进程每次仅运行一个时间片。1.时间片轮转调度算法的基本原理 在时间片轮转调度算法中,...

    在分时系统中,最简单最常用的就是基于时间片轮转调度算法,时间片轮转调度算法是非常公平的处理机分配方式,让就绪队列的每个进程每次仅运行一个时间片。

    1.时间片轮转调度算法的基本原理

       在时间片轮转调度算法中,系统根据先来先服务的原则,将所有的就绪进程排成一个就绪队列,并且每隔一段时间产生一次中断,激活系统中的进程调度程序,完成一次处理机调度,把处理机分配给就绪队列队首进程,让其执行指令。当时间片结束或进程执行结束,系统再次将cpu分配给队首进程。

    2.进程切换时机

          时间片尚未结束,进程已经执行结束,立即激活调度程序,将其从就绪队列中删除,在调度就绪队列的队首进程执行,开启新的时间片(计数器置0)。

        时间片已经结束,进程尚未结束,立即激活进程调度程序,未执行完的进程放到就绪队列的队尾。

    3.时间片大小的确定

       在轮转调度算法中时间片的大小对系统的性能有很大的影响。若时间片很小,将有利于短作业,其能够在这个时间片内完成。时间片过小意味着会进行频繁的进程切换,这将增大系统的开销。若时间片选择太长,时间片轮转调度算法将退化为先来先服务的进程调度算法。

    下面通过一个例题来解释下如何来计算RR调度算法中的完成时间、周转时间、带权周转时间

     

    进程名

    A

    B

    C

    D

    平均

    到达时间

    0

    1

    2

    3

     

    服务时间

    30

    5

    25

    10

    RR

    Q=5

    完成时间

     70

     10

     65

     35

     

    周转时间

     70

     9

     63

     32

     

    带权周转时间

     2.3

     1.8

     2.55

     3.2

     

    RR

    Q=10

    完成时间

     65

     15

     70

     35

     

    周转时间

     65

     14

     68

     32

     

    带权周转时间

     2.2

     2.8

     2.75

     3.2

     

    对于时间片为Q=5我们画一个坐标轴来计算他们的完成时间,那么我们从这4个进程知道这个坐标轴的大小为30+5+25+10=70

    0      5     10     15     20      25    30    35   40    45     50    55     60     65     70

         A     B     C    D        A       C     D    A      C     A     C       A          C             A

    (1)因为RR首先要按照FCFS算法来一次进行调度,所以首先是ABCD,由于B的服务时间是5所以在第一个时间片就可以完成,所以在第二个时间片中只有ACD三个进程在执行,由于D服务时间为10所以在第二个时间片完成的时候D也执行完成,剩下的就剩下AC二个进程,所以一次按照这个顺序下去,便可以得到它们的完成时间。

    知道了完成时间接下来我们就可以求周转时间和带权周转时间
    周转时间=完成时间-到达时间

    带权周转时间=周转时间/服务时间

    (2)对于时间片Q=10我们同样可以算出各进程的完成时间

    0    10    15     25    35   45   55   65    70

        A     B      C       D     A     C     A     C


     




    展开全文
  • 时间片轮转调度算法 a.在时间片轮转调度算法中,系统根据先来先服务的原则,将所有的就绪进程排成一个就绪队列,并且每隔一段时间产生一次中断,激活系统中的进程调度程序,完成一次处理机调度,把处理机分配给就绪...

    **

    1.算法原理

    **
    时间片轮转调度算法

    1. a.在时间片轮转调度算法中,系统根据先来先服务的原则,将所有的就绪进程排成一个就绪队列,并且每隔一段时间产生一次中断,激活系统中的进程调度程序,完成一次处理机调度,把处理机分配给就绪队列队首进程,让其执行指令。当时间片结束或进程执行结束,系统再次将cpu分配给队首进程。
    2. b.时间片尚未结束,进程已经执行结束,立即激活调度程序,将其从就绪队列中删除,在调度就绪队列的队首进程执行,开启新的时间片(计数器置0)。时间片已经结束,进程尚未结束,立即激活进程调度程序,未执行完的进程放到就绪队列的队尾。
    3. c.在轮转调度算法中时间片的大小对系统的性能有很大的影响。若时间片很小,将有利于短作业,其能够在这个时间片内完成。时间片过小意味着会进行频繁的进程切换,这将增大系统的开销。若时间片选择太长,时间片轮转调度算法将退化为先来先服务的进程调度算法。

    优先权调度算法

    1. a.N进程采用动态优先权算法的进程调度;
    2. b.每个用来标识进程的进程控制块PCB用结构描述,包括以下字段:进程标识数ID,进程优先数PRIORITY,进程以占用的CPU时间CPUTIME,进程还需占用的CPU时间ALLTIME,进程状态STATE等。
    3. c.优先数改变的原则:进程在就绪队列中呆一个时间片,优先数增加1,进程每运行一个时间片优先数减3。
    4. d.设置调度前的初始状态。
    5. e.将每个时间片内的进程情况显示出来

    c语言实现

    //时间片轮转法
    #include<stdio.h>
    #include<stdlib.h>
    #include<iostream>
    using namespace std;
    struct Node {
    	char name;
    	int Tarrive;//到达时间
    	int Tservice;//服务时间
    	int Tsurplus;//剩余时间
    	int Tstart;//开始时间
    	int Taccomplish;//完成时间
    	int prio;//优先级---数字越大优先级越高
    	int if_finish;//进程是否完成
    	int num;//进程个数
    }job[10];
    //按到达时间排序
    void Arrive_sort(int num)
    {
    	int temp1, temp2, temp3;
    	for (int i = 0; i < num; i++)
    	{
    		for (int j = i + 1; j < num; j++)
    		{
    			if (job[i].Tarrive > job[j].Tarrive)
    			{
    				temp1 = job[j].name;
    				job[j].name = job[i].name;
    				job[i].name = temp1;
    				temp2 = job[j].Tarrive;
    				job[j].Tarrive = job[i].Tarrive;
    				job[i].Tarrive = temp2;
    				temp3 = job[j].Tservice;
    				job[j].Tservice = job[i].Tservice;
    				job[i].Tservice = temp3;
    			}
    		}
    	}
    }
    
    void RR(int num)//RR算法
    {
    	int q;
    	cout << "请输入时间片长度:" << endl;
    	cin >> q;
    	int flag = 1;//标志队列中是否还有进程
    	int finish_pro = 0;//完成的进程数
    	cout << "进程名称\t" << "开始时间\t" << "运行时间\t" << "剩余服务时间\t" << "结束时间\t" << endl;
    	int time;//记录当前时刻时间
    	int c = 0;
    	while (finish_pro < num)
    	{
    		flag = 0;//就绪队列里没进程
    		for (int i = c; i < num; i++)
    		{
    			Arrive_sort(num);
    			job[i].Tsurplus = job[i].Tservice;
    			job[i].Tstart = job[i - 1].Taccomplish;//上一个作业结束时间
    			if (job[i].Tstart < job[i].Tarrive)//该作业的开始时间小于到达时间
    			{
    				job[i].Tstart = job[i].Tarrive;
    			}
    			else
    			{
    				job[i].Tstart = job[i - 1].Taccomplish;
    			}
    			time = job[i].Tstart;
    			if (job[i].if_finish == 1) continue;//该进程已完成
    			else
    			{
    				if (job[i].Tsurplus <= q && time >= job[i].Tarrive)//未完成且少于一个时间片
    				{
    					flag = 1;
    					time = time + job[i].Tsurplus;
    					job[i].if_finish = 1;//该进程完成
    					job[i].Taccomplish = time;
    					cout  << job[i].name << "\t\t" << job[i].Taccomplish - job[i].Tsurplus << "\t\t" << job[i].Tsurplus << "\t\t" << 0 << "\t\t" << job[i].Taccomplish << endl;
    					job[i].Tsurplus = 0;
    				}
    				else if (job[i].Tsurplus > q && time >= job[i].Tarrive)
    				{
    					flag = 1;
    					time = time + q;
    					job[i].Tsurplus -= q;
    					job[i].Taccomplish = time;
    					cout << job[i].name << "\t\t" << time - q << "\t\t" << q << "\t\t" << job[i].Tsurplus << "\t\t" << job[i].Taccomplish << endl;
    					job[num].name = job[i].name;
    					job[num].Tarrive = time;
    					job[num].Tservice = job[i].Tsurplus;
    					num++;
    				}
    				if (job[i].if_finish == 1) finish_pro++;//一个进程完成加一
    			}
    			c++;
    		}break;
    		if (flag == 0 && finish_pro < num)//没执行完且没进入就绪队列
    		{
    			for (int i = 0; i < num; i++)
    			{
    				if (job[i].if_finish == 0)
    				{
    					time = job[i].Tarrive;
    					break;
    				}
    			}
    		}
    	}	
    }
    //输出
    void print(int num)
    {
    	cout << "进程名" << "\t" << "到达时间" << "\t" << "服务时间" << "\t" << "完成时间" << endl;
     
    	for (int i = 0; i < num; i++)
    	{
    		cout << job[i].name << "\t" << job[i].Tarrive << "\t\t" << job[i].Tservice << "\t\t" << job[i].Taccomplish << endl;
    	}
    }
    void display(int num)
    {
    		
    			RR(num);
    }
    int main()
    {
    	int num;
    	char jname;
    	int arrive;
    	int service;
    	int accomplish;
    	cout << "请输入进程个数:" << endl;
    	cin >> num;
    	for (int i = 0; i < num; i++)
    	{
    		cout << "请输入进程名、到达时间、服务时间" << endl;
    		cin >> jname;
    		job[i].name = jname;
    		cin >> arrive;
    		job[i].Tarrive = arrive;
    		cin >> service;
    		job[i].Tservice = service;
    	}
    	display(num);
    	return 0;
    }
    //动态优先级算法
    #include<stdio.h>
    #include<stdlib.h>
    
    typedef struct PCB{
        int PID;
        char state;
        int priority;
        int runTime;
        int workTime;
        struct PCB *next;
    }*process,ptr;
    
    PCB *ready=NULL,*p;
    int num;
    
    void PCBsort(){
        PCB *first,*second;
        int flag=0;
        if((ready==NULL)||((p->priority)<(ready->priority))){
            p->next=ready;
            ready = p;
        }else{
            first=ready;
            second=first->next;
            while(second!=NULL){
                if((p->priority)<(second->priority)){
                    p->next=second;
                    first->next=p;
                    second=NULL;
                    flag=1;
                }else{
                    first=first->next;
                    second=second->next;
                }
            }
            if(flag==0)first->next=p;
        }
    }
    
    void inputProcess()
    {
        int i;
        printf("输入%d个进程的信息(PID、优先级、运行时间)\n",num);
        for(i=0;i<num;i++){
            p=(PCB*)malloc(sizeof(PCB));
            scanf("%d %d %d",&p->PID,&p->priority,&p->runTime);
            p->workTime=0;
            p->state='w';
            p->next=NULL;
            PCBsort();
        }
    }
    
    int space()
    {
        int k=0;
        PCB* pr=ready;
        while(pr!=NULL){
            k++;
            pr=pr->next;
        }
        return k;
    }
    
    void showInfo(ptr *pr){
        printf("\nPID\t状态\t优先级\t运行时间\t剩余时间\n");
        printf("————————————————————————————\n");
        printf(" %d\t",pr->PID);
        printf(" %c\t",pr->state);
        printf("%d\t",pr->priority);
        printf("%d\t\t",pr->runTime);
        printf("%d\t",pr->runTime-pr->workTime);
        printf("\n");
    }
    
    void priorityRun()
    {
        int len,h=0;
        char ch;
        inputProcess();
        len=space();
        while((len!=0)&&(ready!=NULL))
        {
            ch=getchar();
            h++;
            printf("\n 运行次数:%d \n",h);
            p=ready;
            ready=p->next;
            p->next=NULL;
            p->state='R';
            PCB* pr;
            showInfo(p);
            pr=ready;
            while(pr!=NULL){
                showInfo(pr);
                pr=pr->next;
            }
            (p->workTime)++;
            if(p->workTime==p->runTime){
                printf("\n 进程%d 已结束。\n",p->PID);
                free(p);
            }
            else{
                (p->priority)++;
                p->state='w';
                PCBsort();
            }
            printf("\n 按任一键继续 ......");
        }
        printf("\n\n 进程已经完成 .\n");
        ch=getchar();
    }
    
    int main()
    {
        printf("—————————————————优先级调度算法—————————————————\n");
        printf("输入进程数目:");
        scanf("%d",&num);
        priorityRun();
    }
    
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 【操作系统】时间片轮转调度

    千次阅读 2020-12-21 10:40:02
    操作系统——时间片轮转调度法 同义词:时间片轮转法一般指时间片轮转调度算法,时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一时间段,称作它的时间片,即该进程允许运行的时间。 ...

    操作系统——时间片轮转调度法


    同义词:时间片轮转法一般指时间片轮转调度算法,时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一时间段,称作它的时间片,即该进程允许运行的时间。

    中文名时间片轮转调度算法
    释义每个进程被分配一时间段
    定义该进程允许运行的时间
    合理时间时间片设为100毫秒

    在这里插入图片描述

    时间片轮转调度算法含义

    时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间。如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束,则CPU当即进行切换。调度程序所要做的就是维护一张就绪进程列表,当进程用完它的时间片后,它被移到队列的末尾。
    时间片轮转调度中唯一有趣的一点是时间片的长度。从一个进程切换到另一个进程是需要一定时间的--保存和装入 寄存器值及内存映像,更新各种表格和队列等。假如 进程切换(process switch) - 有时称为 上下文切换(context switch),需要5毫秒,再假设时间片设为20毫秒,则在做完20毫秒有用的工作之后,CPU将花费5毫秒来进行进程切换。CPU时间的20%被浪费在了管理开销上。
    为了提高CPU效率,我们可以将时间片设为500毫秒。这时浪费的时间只有1%。但考虑在一个分时系统中,如果有十个交互用户几乎同时按下回车键,将发生什么情况?假设所有其他进程都用足它们的时间片的话,最后一个不幸的进程不得不等待5秒钟才获得运行机会。多数用户无法忍受一条简短命令要5秒钟才能做出响应。同样的问题在一台支持多道程序的个人计算机上也会发生。
    结论可以归结如下:时间片设得太短会导致过多的进程切换,降低了CPU效率;而设得太长又可能引起对短的交互请求的响应变差。将时间片设为100毫秒通常是一个比较合理的折中。

    时间片轮转调度算法基本原理

    在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.

    时间片轮转调度算法时间片

    时间片大小的确定
    1.系统对响应时间的要求
    2.就绪队列中进程的数目
    3.系统的处理能力

    时间片轮转调度算法算法

    时间片轮转调度算法多级反馈

    多级反馈队列调度算法
    (1) 设置多个就绪队列,并为各个队列赋予不同的优先级. 第一个队列的优先级最高,第二个队列次之,其余各队列的优先权逐个降低.
    该算法赋予各个队列中进程执行时间片的大小也各不相同:
    在优先权愈高的队列中,为每个进程所规定的执行时间片就愈小.
    例如:第二个队列的时间片要比第一个队列的时间片长一倍,……,第i+1个队列的时间片要比第i个队列的时间片长一倍.
    (2) 当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度.当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行;如果它在第二队列中运行一个时间片后仍未完成,再依次将它放入第三队列,……,如此下去,当一个长作业(进程)从第一队列依次降到第n队列后,在第n队列中便采取按时间片轮转的方式运行.
    (3) 仅当第一队列空闲时,调度程序才调度第二队列中的进程运行; 仅当第1~(i-1) 队列均空时,才会调度第i队列中的进程运行.如果处理机正在第i队列中为某进程服务时,又有新进程进入优先权较高的队列(第1~(i-1)中的任何一个队列),则此时新进程将抢占正在运行进程的处理机,即由调度程序把正在运行的进程放回到第i队列的末尾,把处理机分配给新到的高优先权进程.?
    性能
    (1)终端型作业用户
    (2) 短批处理作业用户
    (3) 长批处理作业用户
    满足了多数用户的需求

    时间片轮转调度算法优先权

    优先权调度算法
    1,优先权调度算法的类型
    非抢占式优先权算法
    在这种方式下,系统一旦把处理机分配给就绪队列中优先权最高的进程后,该进程便一直执行下去,直至完成; 或因发生某事件使该进程放弃处理机时,系统方可再将处理机重新分配给另一优先权最高的进程.这种调度算法主要用于批处理系统中;也可用于某些对实时性要求不严的实时系统中.
    抢占式优先权调度算法
    系统同样把处理机分配给优先权最高的进程,使之执行.但在其执行期间,只要又出现了另一个其优先权更高的进程,进程调度程序就立即停止当前进程(原优先权最高的进程)的执行,重新将处理机分配给新到的优先权最高的进程.
    这种抢占式的优先权调度算法,能更好地满足紧迫作业的要求,常用于要求比较严格的实时系统中, 以及对性能要求较高的批处理和分时系统中.
    2,优先权的类型
    (1) 静态优先权
    静态优先权是在创建进程时确定的,且在进程的整个运行期间保持不变.
    一般地,优先权是利用某一范围内的一个整数来表示的,例如,0~7或0~255中的某一整数, 又把该整数称为优先数.只是具体用法各异:有的系统用"0"表示最高优先权,当数值愈大时,其优先权愈低;而有的系统恰恰相反.
    确定进程优先权的依据有如下三个方面:
    1.进程类型.(系统进程/用户进程)
    2.进程对资源的需求.(需求量的大小)
    3.用户要求.(用户进程紧迫程度)
    (2) 动态优先权
    动态优先权是指在创建进程时所赋予的优先权,可以随进程的推进或随其等待时间的增加而改变的,以便获得更好的调度性能.
    例如,我们可以规定,在就绪队列中的进程,随其等待时间的增长,其优先权以速率a提高.若所有的进程都具有相同的优先权初值,则显然是最先进入就绪队列的进程,将因其动态优先权变得最高而优先获得处理机,此即FCFS算法.
    优先权的变化规律可描述为:
    由于等待时间与服务时间之和,就是系统对该作业的响应时间,故该优先权又相当于响应比RP.据此,又可表示为:
    3,高响应比优先调度算法
    由上面的式子可以得到以下结论:
    (1) 如果作业的等待时间相同,则要求服务的时间愈短,其优先权愈高,因而该算法有利于短作业.
    (2) 当要求服务的时间相同时,作业的优先权决定于其等待时间,等待时间愈长,其优先权愈高,因而它实现的是先来先服务.
    (3) 对于长作业,作业的优先级可以随等待时间的增加而提高,当其等待时间足够长时,其优先级便可升到很高, 从而也可获得处理机.
    该算法照顾了短作业,且不会使长作业长期得不到服务

    时间片轮转调度算法抢占式

    1. 非抢占式调度算法
    为每一个被控对象建立一个实时任务并将它们排列成一轮转队列,调度程序每次选择队列中的第一个任务投入运行.该任务完成后便把它挂在轮转队列的队尾等待下次调度运行.
    2. 非抢占式优先调度算法.
    实时任务到达时,把他们安排在就绪队列的队首,等待当前任务自我终止或运行完成后才能被调度执行.
    3. 抢占式调度算法
    1)基于时钟中断的抢占式优先权调度算法.
    实时任务到达后,如果该任务的优先级别高于当前任务的优先级并不立即抢占当前任务的处理机,而是等到时钟中断到来时,调度程序才剥夺当前任务的执行,将处理机分配给新到的高优先权任务.
    2)立即抢占的优先权调度算法.
    在这种调度策略中,要求操作系统具有快速响应外部时间中断的能力.一旦出现 外部中断,只要当前任务未处于 临界区便立即剥夺当前任务的执行,把处理机分配给请求中断的紧迫任务,实时进程调度,实时进程抢占当前。

    时间片轮转调度算法实时系统

    1 实现实时调度的基本条件
    1-1. 提供必要的信息-就绪时间.
    1-2. 开始截止时间和完成截止时间.
    1-3. 处理时间.
    1-4. 资源要求.
    1-5. 优先级.
    2. 系统处理能力强
    在实时系统中,通常都有着多个实时任务.若处理机的处理能力不够强,则有可能因处理机忙不过来而使某些实时任务不能得到及时处理, 从而导致发生难以预料的后果.假定系统中有m个周期性的硬实时任务,它们的处理时间可表示为Ci,周期时间表示为Pi,则在单处理机情况下,系统可调度必须满足下面的限制条件:
    当系统不可调度时解决的方法是提高系统的处理能力,其途径有二:
    其一仍是采用 单处理机系统,但须增强其处理能力, 以显著地减少对每一个任务的处理时间;
    其二是采用 多处理机系统.假定系统中的处理机数为N,则应将上述的限制条件改为:
    3. 采用抢占式调度机制
    当一个优先权更高的任务到达时,允许将当前任务暂时挂起,而令高优先权任务立即投入运行.采用这种方式去满足那些开始截止时间即将到来的任务.?
    4. 具有快速切换机制
    应具有的能力:
    (1) 对外部中断的快速响应能力.为使在紧迫的外部事件请求中断时系统能及时响应,要求系统具有快速硬件中断机构,还应使禁止中断的时间间隔尽量短,以免耽误时机(其它紧迫任务).?
    (2) 快速的任务分派能力.在完成任务调度后,便应进行任务切换.为了提高分派程序进行任务切换时的速度, 应使系统中的每个运行功能单位适当的小,以减少任务切换的时间开销. 实时调度实例
    一, 最早截止时间优先算法(EDF)
    EDF算法用于非抢占调度方式
    优先级:根据任务的开始截止时间来确定任务的优先级.
    二,最低松弛优先算法(LLF)
    例如:系统中有两个周期性实时任务A和B,任务A要求每20ms执行一次,执行时间为10ms;任务B要求每50ms执行一次,执行时间为25ms.这样可知A和B每次必须完成的时间和开始截止时间如图所示
    优先级:根据任务紧急程度来确定任务优先级
    A和B任务每次必须完成的时间
    A1 (10) A2 (30) A3(50) A4 (70) A5(90) A6 (110) A7(130) A8(150)
    0 、10、 20、 30 、40、 50 、60、 70、 80 、90 、100 、110、 120、130、 140、 150
    B1(25) B2(75) B3(125)
    A和B任务每次必须开始的时间
    时间(ms) A截止时间 B截止时间 调度对象
    0 A1(10) B1(25) A1
    10 A2(20) B1(15) B1
    30 A2(0) B1(15) A2
    40 A3(10) B1(5) B1
    45 A3(5) B2(30) A3
    55 A4(15) B2(20) B2
    70 A4(0) B2(20) A4
    松弛度
    松弛度
    ( 20-10-0 ) ( 50-25-0 )
    (40-10-10 ) ( 50-25-10 )
    (40-10-30) (50-5-30)
    (60-10-40) (50-5-40)
    (60-10-45) (100-25-45)
    (80-10-55) (100-25-55)
    (80-10-70) (100-10-70 )
    3.4.1 多处理器系统 的类型
    (1) 紧密耦合(Tightly Coupted)MPS.
    这通常是通过高速总线或高速 交叉开关,来实现多个处理器之间的互连的.它们共享 主存储器系统和I/O设备,并要求将主存储器划分为若干个能独立访问的存储器模块,以便多个处理机能同时对主存进行访问.系统中的所有资源和进程,都由操作系统实施统一的控制和管理.
    3.4 多处理机系统中的调度
    从处理器之间耦合的紧密程度上划分:
    松散耦合(Loosely Coupled)MPS.
    在松散耦合MPS中,通常是通过通道或 通信线路,来实现多台计算机之间的互连.每台计算机都有自己的 存储器和I/O设备,并配置了OS来管理本地资源和在本地运行的进程.因此,每一台计算机都能独立地工作, 必要时可通过通信线路与其它计算机交换信息,以及协调它们之间的工作.
    根据系统中所用处理器的相同与否划分:
    (1) 对称多处理器系统SMPS. 在系统中所包含的各处理器单元,在功能和结构上都是相同的,当前的绝大多数MPS都属于SMP系统.例如,IBM公司的SR/6000 Model F50, 便是利用4片Power PC处理器构成的.?
    (2) 非对称多处理器系统.在系统中有多种类型的处理单元,它们的功能和结构各不相同,其中只有一个主处理器,有多个从处理器:
    1. 对称多处理器系统中的进程分配方式
    在SMP系统中,所有的处理器都是相同的,因而可把所有的处理器作为一个处理器池(Processor pool),由调度程序或基于处理器的请求,将任何一个进程分配给池中的任何一个处理器去处理.在进行进程分配时,可采用以下两种方式之一.
    1) 静态分配(Static Assigenment)方式
    2) 动态分配(Dynamic Assgement)方式?
    3.4.2 进程分配方式
    静态分配(Static Assigenment)方式
    一个进程从开始执行直到完成,都被固定分配到一个处理器上去执行.
    2) 动态分配(Dynamic Assgement)方式
    系统中设置有公共的就绪队列.分配进程时,可以将进程分配到任何一个处理器上.
    动态分配方式的主要优点是消除了各处理器忙闲不均的现象
    2. 非对称MPS中的进程分配方式?
    对于非对称MPS,其OS大多采用主—从(Master-Slave)式OS,即OS的核心部分驻留在一台主机上(Master),而从机(Slave)上只是用户程序,进程调度只由主机执行.每当从机空闲时,便向主机发送一索求进程的信号,然后,便等待主机为它分配进程.在主机中保持有一个就绪队列,只要就绪队列不空,主机便从其队首摘下一进程分配给请求的从机.从机接收到分配的进程后便运行该进程,该进程结束后从机又向主机发出请求.
    缺点:对主机要求高,出现故障导致整个系统瘫痪
    1. 自调度(Self-Scheduling)方式
    1) 自调度机制?
    在系统中设置有一个公共的进程或线程就绪队列, 所有的处理器在空闲时,都可自己到该队列中取得一进程(或线程)来运行.在自调度方式中,可采用在单处理机环境下所用的调度算法,如先来先服务(FCFS)调度算法,最高优先权优先(FPF)调度算法和抢占式最高优先权优先调度算法等.
    3.4.3 进程(线程)调度方式
    2) 自调度方式的优点?
    1,系统中的公共就绪队列可按照单处理机系统中所采用的各种方式加以组织;其调度算法也可沿用单处理机系统所用的算法,即很容易将单处理机环境下的调度机制移植到多处理机系统中
    2,只要系统中有任务(公共就绪队列不空)就不会出现处理机空闲的情况,也不会发生处理器忙闲不均的现象,因而有利于提高处理器的利用率.
    3)自调度方式的缺点
    3.4.4进程调度过程
    1、进程名:作为进程的标识。
    指针:进程按顺序排成循环链表,用指针指出下一个进程的进程控制块首地址,最后一个进程中的指针指出第一个进程的进程控制块首地址。
    2、要求运行时间:假设进程需要运行的单位时间数。
    已运行时间:假设进程已经运行的单位时间数,初值为0。
    状态:可假设有两种状态,就绪状态和结束状态。进程的初始状态都为就绪状态。
    3、每次运行所设计的处理器调度程序调度进程之前,为每个进程任意确定它的要求运行时间。
    4、此程序是模拟处理器调度,因此,被选中的进程并不实际启动运行,而是执行
    已运行时间+1
    来模拟进程的一次运行,表示进程已经运行过一个单位时间。
    .5、在所设计的程序中应有显示或打印语句,能显示或打印每次被选中的进程名以及运行一次后进程队列的变化。
    6、为进程任意确定要求运行时间,运行所设计的处理器调度程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
    7、设有一个就绪队列,就绪进程按优先数(优先数范围0-100)由小到大排列(优先数越小,级别越高)。当某一进程运行完一个时间片后,其优先级应下调(如优先数加2或3)。
    8、例如一组进程如下表:
    进程名
    A
    B
    C
    D
    E
    F
    G
    H
    J
    K
    L
    M
    到达时间
    0
    1
    2
    3
    6
    8
    12
    12
    12
    18
    25
    25
    服务时间
    6
    4
    10
    5
    1
    2
    5
    10
    4
    3
    15
    8

    时间片轮转调度算法瓶颈问题

    1. 整个系统中只有一个就绪队列供多个处理器共享.
    (2)低效性.
    线程在其生命周期内多次更换处理器使得高速缓存的使用率很低
    (3)线程切换频繁.
    2. 成组调度(Gang Scheduling)方式
    3.专用处理器分配方式
    展开全文
  • 4UCOS时间片轮转调度算法详解,非常不错的一本书籍!
  • FreeRTOS-时间片轮转调度

    千次阅读 2020-06-23 15:36:28
    一、时间片轮转调度配置 使用时间片轮转调度,首先将FreeROTSConfig.h中的以下两个宏置1 #define configUSE_PREEMPTION 1 //1使用抢占式内核,0使用协程 #define configUSE_TIME_SLICING 1 //1使能时间片调度...

    一、时间片轮转调度配置

    使用时间片轮转调度,首先将FreeROTSConfig.h中的以下两个宏置1

    #define configUSE_PREEMPTION		1        //1使用抢占式内核,0使用协程
    #define configUSE_TIME_SLICING		1        //1使能时间片调度(默认式使能的)

    配置时间片长度宏参数

    #define configTICK_RATE_HZ	(20)      //时钟节拍频率,这里设置为20,周期就是1000ms/20ms=50ms

    二、时间片轮转调度的任务模型

    Task1、Task2、Task3处于同一优先级下

    三、实例(task1和task2任务优先级相同)

    展开全文
  • 操作系统【时间片轮转调度算法 课本例题】
  • 在分时系统中,最简单最常用的就是基于时间片轮转调度算法,时间片轮转调度算法是非常公平的处理机分配方式,让就绪队列的每个进程每次仅运行一个时间片。 1.时间片轮转调度算法的基本原理  在时间片轮转调度算法中...
  • VxWorks时间片轮转调度

    千次阅读 2017-07-29 11:58:18
    VxWorks时间片轮转调度任务调度是基于某种规则约束,给一个任务集合中每个任务分配开始和结束的时间。约束方式一般分为时间片约束和资源约束。在VxWorks中,系统按照时间片依次轮流执行每个任务,从而造成多个任务在...
  • 第11讲 UCOSIII时间片轮转调度ppt,ALIENTEK UCOS学习视频(课件)
  • 时间片轮转调度算法.txt,信息系统 时间片轮转调度算法.txt
  • 一、实验目的 在采用多道程序设计的系统中,同时处于就绪态的进程往往有多个,当就绪态的进程数大于...本次设计模拟在单处理器情况下采用基于优先数的时间片轮转调度算法进行处理器调度,加深了解处理器调度工作过程。
  • 时间片轮转调度算法模拟 1. 实验目的 了解时间片轮转调度算法的工作原理,通过编写调度算法的程序,加深对Linux进程时间片调度的理解。 2. 实验内容 在Linux上编写C语言,实现从键盘输入时间片长度、任务个数、每...
  • 时间片轮转调度算法模拟C语言

    千次阅读 多人点赞 2020-01-02 14:37:25
    时间片轮转调度算法模拟C语言 本来要做这么一个作业,准备用C语言写,然后参考网上的一些代码,发现很多都有错误,用课本的例子代入都不对,后来我发现是错在对时间片调度算法的理解。所以在别人的基础上写了以下...
  • 本压缩包包含简单的软件,实现操作系统中调度算法的时间片轮转调度,含代码,有注释。
  • :操作系统实验3:模拟时间片轮转调度程序 * * TODO 要更改此生成的类型注释的模板,请转至 * 窗口 - 首选项 - Java - 代码样式 - 代码模板 */
  • 7、UCOSIII时间片轮转调度

    千次阅读 2018-08-17 12:58:46
    时间片轮转调度器用于时间片轮转调度为函数OS_SchedRoundRobin(), 此函数由OSTimeTick或者OS_IntQTask()调用,函数在文件os_core.c中定义。 一、OSSchedRoundRobinCfg()函数 使能或失能时间片轮转调度功能 如果...
  • 时间片轮转调度算法实现进程调度,绝对能用。本人第一次上传代码,还请大家多多支持
  • 按照时间片轮转调度进程| 动态地输入进程(key,run_time,message),按照输入次序建立就绪队列l 输入CPU运行的单位时间片(cpu_base_time)l 按照时间片轮转方式模拟进程逐个被调度并执行单位时间片(运行结束进程结束,...
  • uC/OS-II改为基于兼容优先级抢占调度与时间片轮转调度. 保证了系统原有的实时性,又对于分时任务提供了时间片轮转调度.
  • 实验1 进程调度 一、实验目的 通过实验加强对进程调度算法的理解和掌握。 二、实验内容 编写程序实现基于优先级的时间片轮转调度算法。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,320
精华内容 8,128
关键字:

时间片轮转调度