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

    2019-05-02 12:41:06
    操作系统用时间片轮转调度算法实现进程块的调度,按进程调度顺序打印进程执行信息
  • 时间片轮转调度算法的计算

    万次阅读 多人点赞 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


     




    展开全文
  • 时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual C++时间片轮转调度算法 Visual ...
  • 一、 实验目的和要求1. 了解进程调度算法的特点2.... 二、 实验内容设计模拟实现FCFS、SJF、时间片轮转调度算法的C语言程序1. FCFS算法:按照作业/进程进入队列的先后顺序进行挑选,先进入的将先进行...

    一、  实验目的和要求

    1.  了解进程调度算法的特点

    2.  掌握进程调度算法,如先来先服务调度算法(first come first served,FCFS)、短作业优先调度算法(shotjob first,SJF)、时间片轮转调度算法。

     

    二、    实验内容

    设计模拟实现FCFS、SJF、时间片轮转调度算法的C语言程序

    1.  FCFS算法:按照作业/进程进入队列的先后顺序进行挑选,先进入的将先进行后续步骤的处理。

    2.  SJF算法:以进入系统的作业所要求的CPU运行时间的长短为挑选依据,优先选取预计所需服务时间最短的作业进行调度,可以分别用于高级调度和低级调度。

    3.  时间片轮转算法:将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把处理机分配给队首进程,并令其执行一个时间片。

     

    三、  实验步骤

    1.  使用C++语言编译程序。

    2.  完成算法代码。

    3.  运行程序,算出结果。

     

    四、     实验源程序

    代码:

    #include <stdio.h>

    #include <iostream>

    #include <queue>

    #include <stack>

    #include <set>

    #include <string>

    #include <cstring>

    #include <cmath>

    #define MAX 1111

    const double Max = 11111.0;

    using namespace std;

    typedef struct FCFS

    {

        int mark;

        string name;

        doublearrivetime;

        doubleservetime;

        doublestarttime;

        doublefinishtime;

        doubleroundtime;

        doubledaiquantime;

        bool operator< (const FCFS &a)const{

            returnarrivetime > a.arrivetime;

        }

    }FCFS;

     

    typedef struct SJF

    {

        int mark;

        string name;

        doublearrivetime;

        doubleservetime;

        doublestarttime;

        doublefinishtime;

        doubleroundtime;

        doubledaiquantime;

        bool operator< (const SJF &a)const{

            returnservetime > a.servetime;

        }

    }SJF;

     

    typedef struct RDRN

    {

        int mark;

        bool flag =true;

        string name;

        double Count =0.0;

        doublearrivetime;

        doubleservetime;

        doublestarttime;

        doublefinishtime;

        doubleroundtime;

        doubledaiquantime;

        double running= 0.0;

        bool operator< (const RDRN &a)const{

            returnCount > a.Count;

        }

    }RDRN;

     

     

    void FCFS_arithmetic()

    {

        FCFS f[MAX];

        FCFS ff;

        int n;

        doubleaveragedaiquantime = 0.0;

       priority_queue<FCFS> q1;

        printf("请输入作业数(整数)\n");

       scanf("%d",&n);

        printf("请输入n组数据,每组数据包括作业名字(字符串)、作业到达时间(浮点数)、作业服务时间(浮点数)(每组数据的给元素之间用空格隔开!):\n");

        for(int i=0;i<n; i++){

            f[i].mark =i;

           cin>>f[i].name;

            scanf("%lf%lf",&f[i].arrivetime,&f[i].servetime);

           q1.push(f[i]);

        }

        doublestarttime = 0.0;

        ff = q1.top();

        q1.pop();

       f[ff.mark].starttime = ff.arrivetime;

       f[ff.mark].finishtime = f[ff.mark].starttime + ff.servetime;

       f[ff.mark].roundtime = f[ff.mark].finishtime - f[ff.mark].arrivetime;

       f[ff.mark].daiquantime = f[ff.mark].roundtime / f[ff.mark].servetime;

        starttime =f[ff.mark].finishtime;

        printf("先来先服务调度算法的作用时间表:\n\n");

        printf("作业名字 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");

       cout<<"  "<<f[ff.mark].name;

    printf("%10.2f %8.2f %8.2f %8.2f %8.2f%8.2f\n",f[ff.mark].arrivetime,f[ff.mark].servetime,f[ff.mark].starttime,f[ff.mark].finishtime,f[ff.mark].roundtime,f[ff.mark].daiquantime);

       while(!q1.empty()){

            ff =q1.top();

            q1.pop();

           f[ff.mark].starttime = starttime;

           f[ff.mark].finishtime = f[ff.mark].starttime + ff.servetime;

           f[ff.mark].roundtime = f[ff.mark].finishtime - f[ff.mark].arrivetime;

           f[ff.mark].daiquantime = f[ff.mark].roundtime / f[ff.mark].servetime;

           averagedaiquantime += f[ff.mark].daiquantime;

            starttime =f[ff.mark].finishtime;

           cout<<"  "<<f[ff.mark].name;

    printf("%10.2f %8.2f %8.2f %8.2f %8.2f%8.2f\n",f[ff.mark].arrivetime,f[ff.mark].servetime,f[ff.mark].starttime,f[ff.mark].finishtime,f[ff.mark].roundtime,f[ff.mark].daiquantime);

        }

        printf("\n平均代权周转时间:\n");

       printf("%.2f\n",averagedaiquantime/n);

    }

     

    void SJF_arithmetic()

    {

        SJF f[MAX];

        SJF ff;

        int n;

        doublestarttime = Max;

        doubleaveragedaiquantime = 0.0;

       priority_queue<SJF> q1;

        printf("请输入作业数(整数)\n");

       scanf("%d",&n);

        printf("请输入n组数据,每组数据包括作业名字(字符串)、作业到达时间(浮点数)、作业服务时间(浮点数)(每组数据的给元素之间用空格隔开!):\n");

        for(int i=0;i<n; i++){

            f[i].mark =i;

           cin>>f[i].name;

           scanf("%lf %lf",&f[i].arrivetime,&f[i].servetime);

           if(f[i].arrivetime < starttime) starttime = f[i].arrivetime;

           q1.push(f[i]);

        }

        printf("短作业优先调度算法的作用时间表:\n\n");

        int cnt = 0;

       while(!q1.empty()){

            SJFtemp[MAX];

            ff =q1.top();

            q1.pop();

           if(f[ff.mark].arrivetime <= starttime){

                for(inti=0; i<cnt; i++) q1.push(temp[i]);

                cnt =0;

               f[ff.mark].starttime = starttime;

               f[ff.mark].finishtime = f[ff.mark].starttime + ff.servetime;

               f[ff.mark].roundtime = f[ff.mark].finishtime - f[ff.mark].arrivetime;

               f[ff.mark].daiquantime = f[ff.mark].roundtime / f[ff.mark].servetime;

               averagedaiquantime += f[ff.mark].daiquantime;

               starttime = f[ff.mark].finishtime;

            }

            elsetemp[cnt++] = ff;

        }

        printf("作业名字 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");

        for(int i=0;i<n; i++){

           cout<<"  "<<f[i].name;

           printf("%10.2f %8.2f %8.2f %8.2f %8.2f%8.2f\n",f[i].arrivetime,f[i].servetime,f[i].starttime,f[i].finishtime,f[i].roundtime,f[i].daiquantime);

        }

        printf("\n平均代权周转时间:\n");

       printf("%.2f\n",averagedaiquantime/n);

    }

     

    void RDRN_arithmetic()

    {

        doubletimeslice;

        RDRN f[MAX];

        RDRN temp[MAX];

        int cnt = 0;

        RDRN ff;

        int n;

        doubleaveragedaiquantime = 0.0;

       priority_queue<RDRN> q1;

        printf("请输入作业数和时间片长度(作业数为整数,时间片长度可为浮点数,中间用空格隔开!):\n");

        scanf("%d%lf",&n,&timeslice);

        int tot = n;

        printf("请输入n组数据,每组数据包括作业名字(字符串)、作业到达时间(浮点数)、作业服务时间(浮点数)(每组数据的给元素之间用空格隔开!):\n");

        for(int i=0;i<n; i++){

            f[i].mark =i;

           cin>>f[i].name;

           scanf("%lf %lf",&f[i].arrivetime,&f[i].servetime);

            f[i].Count= f[i].arrivetime;

           q1.push(f[i]);

        }

        double clock =q1.top().arrivetime;

        int t = 0;

        while(t != n){

            ff =q1.top();

           if(f[ff.mark].arrivetime <= clock && tot-- > 0){

               q1.pop();

               if(f[ff.mark].flag){

                   f[ff.mark].starttime = clock;

                   f[ff.mark].flag = false;

                }

     

               if(f[ff.mark].running != f[ff.mark].servetime){

                   double newtime = f[ff.mark].servetime - f[ff.mark].running;

                   if(newtime >= timeslice){

                       clock += timeslice;

                       f[ff.mark].running += timeslice;

                       f[ff.mark].Count += timeslice;

                    }

                   else{

                       clock += newtime;

                       f[ff.mark].running += newtime;

                       f[ff.mark].Count += newtime;

                    }

                   if(f[ff.mark].running != f[ff.mark].servetime) temp[cnt++] = f[ff.mark];

                }

     

               if(f[ff.mark].running == f[ff.mark].servetime){

                   t++;

                   f[ff.mark].finishtime = clock;

                   f[ff.mark].roundtime = f[ff.mark].finishtime - f[ff.mark].arrivetime;

                   f[ff.mark].daiquantime = f[ff.mark].roundtime / f[ff.mark].servetime;

                   averagedaiquantime += f[ff.mark].daiquantime;

                }

            }

     

            else{

                for(inti=0; i<cnt; i++) q1.push(temp[i]);

                cnt =0;

                tot =q1.size();

            }

        }

     

        printf("时间轮转调度算法的作用时间表:\n\n");

        printf("作业名字 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");

        for(int i=0;i<n; i++){

           cout<<"  "<<f[i].name;

    printf("%10.2f %8.2f %8.2f %8.2f %8.2f %8.2f\n",f[i].arrivetime,f[i].servetime,f[i].starttime,f[i].finishtime,f[i].roundtime,f[i].daiquantime);

        }

        printf("\n平均代权周转时间:\n");

       printf("%.2f\n",averagedaiquantime/n);

    }

     

    int main()

    {

       printf("********************************************************欢迎您!***********************************************************\n");

        int ca = 0;

        do{

           printf("\n请选择调度算法或结束程序:\n");

           printf("0、结束程序\n1、先来先服务\n2、短作业优先\n3、时间片轮转\n");

           scanf("%d",&ca);

            if(ca == 1)FCFS_arithmetic();

            if(ca == 2)SJF_arithmetic();

            if(ca == 3) RDRN_arithmetic();

        }while(ca);

        return 0;

    }

     

    五、  实验结果

    先来先服务调度算法:

    短作业优先调度算法:

     

    时间片轮转调度算法:

     


     

     


    展开全文
  • 时间片轮转调度算法 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();
    }
    
    

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

    展开全文
  • 时间片轮转调度算法.txt,信息系统 时间片轮转调度算法.txt
  • 内容:南邮实验周,时间片轮转调度算法模拟实验完整代码 时间:2018/5/31 说明:该代码实现功能的完整描述见我空间的“南邮实验周_时间片轮转调度算法模拟_报告”
  • 时间片轮转调度算法模拟 1. 实验目的 了解时间片轮转调度算法的工作原理,通过编写调度算法的程序,加深对Linux进程时间片调度的理解。 2. 实验内容 在Linux上编写C语言,实现从键盘输入时间片长度、任务个数、每...

    时间片轮转调度算法模拟

    1. 实验目的

    了解时间片轮转调度算法的工作原理,通过编写调度算法的程序,加深对Linux进程时间片调度的理解。

    2. 实验内容

    • Linux上编写C语言,实现从键盘输入时间片长度、任务个数、每一个任务的到达时间及服务时间;

    • 构造相应的进程并按时间片轮转调度算法对所有进程进行调度,进程运行情况可以输出到终端,从而深入理解时间片轮转调度算法的原理。

    2.1 程序流程图

    ​ 程序中就绪队列用int型的数组表示,并用readyIndex表示下一个要插入就绪队列的位置,该数组中存放进程数组的下标,方便进程调度时进行使用。

    ​ 程序中进程状态用枚举类型表示如下,其中NOT_COME表示进程还未到来,READY表示进程在就绪队列中等待,RUNNINGFINISH表示正在运行和运行结束。程序中进程块PCB结构体如下。

    typedef enum PROCESS_STATE{     
        NOT_COME,     
     	READY,     
        RUNNING,     
        FINISH 
    } PROCESS_STATE;
    
    typedef struct{    
        char process_name[10];     
        int arrive_time;     
        int service_time;     
        int start_time;     
        int end_time;     //已经运行的时间     
        int cpu_time;     
        PROCESS_STATE state; 
    } PCB;
    
    • 程序流程图如下:

    在这里插入图片描述

    2.2 程序源码

    #include <stdio.h>
    #include <unistd.h>
    #include <malloc.h>
    typedef enum PROCESS_STATE
    {
        NOT_COME,
        READY,
        RUNNING,
        FINISH
    } PROCESS_STATE;
    
    
    typedef struct
    {
        char process_name[10];
        int arrive_time;
        int service_time;
        int start_time;
        int end_time;
        //已经运行的时间
        int cpu_time;
        PROCESS_STATE state;
    } PCB;
    
    
    int processs_num;
    PCB *process_list;
    int *ready_list;
    int readyIndex = 0;
    int current_time = 0;                                                                                                                                            
    //时间片大小
    int quantum;
    
    
    void SortList();
    void InitList();
    //判断所有进程是否运行结束
    int isEnd();
    //判断当前时间是否有进程到达,若有但返回index,反之返回0
    int isProcessArrive();
    int isProcessEnd(int index);
    void MoveReadyList();
    void showState();
    int haveRunningProcess();
    
    int main() {
        printf("进程个数:");
        scanf("%d", &processs_num);
        process_list = (PCB *)malloc(sizeof(PCB) * (processs_num + 1));
        ready_list = (int *)malloc(sizeof(int) * (processs_num + 1));
        
        printf("时间片长度:(>=1):");
        scanf("%d", &quantum);
        //初始化进程列表,并按到达时间排序
        InitList();
        printf("进程名称\t到达时间\t服务时间:\n");
        for (int i = 1; i <= processs_num; i++) {
            printf("%s\t\t%d\t\t%d\n", process_list[i].process_name, 
                process_list[i].arrive_time, process_list[i].service_time);
        }
        while(!isEnd()){
            int runningIndex;
            int index = isProcessArrive();
            //有进程到来
            if(index != 0){
                ready_list[readyIndex] = index;
                process_list[index].state = READY;
                readyIndex++;      
            }
            runningIndex = haveRunningProcess();
            PCB temp = process_list[runningIndex];
            //有正在运行的进程
            if(runningIndex != 0){
                //判断是否应该进行进程调度(根据时间片)
                if((temp.start_time + temp.cpu_time) % quantum == 0){
                    process_list[runningIndex].state = READY;
                    ready_list[readyIndex] = runningIndex;
                    readyIndex++;
                }
                 
            }
            //取出就绪队列队头进行运行
            //printf("index %d\n",readyIndex);
            if(readyIndex > 0 && (temp.start_time + temp.cpu_time) % quantum == 0){
                int num =  ready_list[0];
                process_list[num].state = RUNNING;
                if(process_list[num].start_time == -1)
                    process_list[num].start_time = current_time;    
                //就读队列向前移动一位
                MoveReadyList();
            }  
            
    
            //延时1s
            sleep(1);
            current_time++;
            
            //重新获取当前正在运行的进程
            runningIndex = haveRunningProcess();
            process_list[runningIndex].cpu_time++;
            if(isProcessEnd(runningIndex)){
                process_list[runningIndex].state = FINISH;
                process_list[runningIndex].end_time = current_time;
            }
            
            
            printf("%d~%d运行的进程为:%s\n", current_time-1, current_time, process_list[runningIndex].process_name);
            printf("%d时刻:\n", current_time);
            showState();
        }
        return 0;
    }
    
    
    void InitList(){
        printf("输入进程名称,到达时间以及服务时间:\n");
        for (int i = 1; i <= processs_num; i++) {
            scanf("%s %d %d", process_list[i].process_name, 
                &process_list[i].arrive_time, &process_list[i].service_time);
            process_list[i].cpu_time = 0;
            process_list[i].state = NOT_COME;
            process_list[i].start_time = -1;
            process_list[i].end_time = -1;
            process_list[i].cpu_time = 0;
        }
        //按照到达时间排序
        SortList();
    }
    void SortList(){
        for(int i = 1; i< processs_num; i++){
            for(int j = 1; j < processs_num - i + 1; j++){
                if(process_list[j].arrive_time > process_list[j+1].arrive_time){
                    PCB temp = process_list[j];
                    process_list[j] = process_list[j+1];
                    process_list[j+1] = temp;
                }
            }
            
        }
    }
    
    int isEnd(){
        for(int i = 1; i <= processs_num; i++){
            if(process_list[i].state != FINISH)
                return 0;
        }
        return 1;
    }
    
    int isProcessArrive(){
        for(int i = 1; i <= processs_num; i++){
            if(process_list[i].arrive_time == current_time)
                return i;
        }
        return 0;
    }
    
    int haveRunningProcess(){
        for(int i = 1; i <= processs_num; i++){
            if(process_list[i].state == RUNNING)
                return i;
        }
        return 0;
    }
    
    int isProcessEnd(int index){
        if(process_list[index].cpu_time == process_list[index].service_time){
            return 1;
        }
        else{
            return 0;
        }
    }
    
    void MoveReadyList(){
        for(int i = 0; i < readyIndex - 1; i++){
            ready_list[i] = ready_list[i+1];
        }
        readyIndex--;
    }
    
    void showState(){
        printf("进程名称\t开始时间\t结束时间\t运行时间\t到达时间\t服务时间\n");
        for (int i = 1; i <= processs_num; i++) {
            printf("%s\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t", process_list[i].process_name, 
                process_list[i].start_time, process_list[i].end_time, process_list[i].cpu_time, 
                process_list[i].arrive_time, process_list[i].service_time);
            switch (process_list[i].state)
            {
            case NOT_COME:
                printf("not come");
                break;
            case READY:
                printf("ready");
                break;
            case RUNNING:
                printf("running");
                break;
            case FINISH:
                printf("finish");
                break;
            default:
                break;
            }
            printf("\n");
        }
        printf("\n");
    }
    

    运行测试如下:
    在这里插入图片描述
    在这里插入图片描述

    经逐步验证,程序结果无误。

    3. 实验总结

    ​ 通过编写程序模拟时间片轮转调度算法

    • 深入了解了无优先级时进程调度的原理
    • 对操作系统如何实现多进程调度有了进一步的理解
    展开全文
  • 时间片轮转调度算法模拟C语言

    千次阅读 多人点赞 2020-01-02 14:37:25
    时间片轮转调度算法模拟C语言 本来要做这么一个作业,准备用C语言写,然后参考网上的一些代码,发现很多都有错误,用课本的例子代入都不对,后来我发现是错在对时间片调度算法的理解。所以在别人的基础上写了以下...
  • java语言实现的时间片轮转调度算法和动态优先级调度算法一、代码:二、程序运行演示总结 贪方便用java实现老师的作业,虽然写的乱七八糟的,但是也想发出来给人看看,评论喷我吧!。 一、代码: 作业要求是:...
  • 4UCOS时间片轮转调度算法详解,非常不错的一本书籍!
  • 时间片轮转调度算法、优先级调度算法、多级反馈队列调度算法 1.先了解下算法的评估 cpu 利用率 = 忙碌时间 / 总时间 系统吞吐量 = 总共完成多少道作业 / 总共花了多少时间 周转时间 周转时间:(作业提交到 操作系统...
  • 操作系统课程设计_时间片轮转调度算法_Java版
  • 在分时系统中,最简单最常用的就是基于时间片轮转调度算法时间片轮转调度算法是非常公平的处理机分配方式,让就绪队列的每个进程每次仅运行一个时间片。 1.时间片轮转调度算法的基本原理  在时间片轮转调度算法中...
  • 实现短进程优先调度算法(SPF)和时间片轮转调度算法(RR)。

空空如也

空空如也

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

时间片轮转调度算法