基于优先数的时间片轮转调度算法调度处理器

短作业优先调度和时间片轮转调度算法

短作业优先调度和时间 片轮转调度算法 Company Document number：WUUT-WUUY-WBBGB-BWYTT-1982GT

电子科技大学 实验报告 学生姓名：胡钟文学号：指导教师：罗惠琼 一、实验室名称：主楼A2-412 二、实验项目名称：进程调度算法的设计 三、实验原理： 短作业（进程）优先调度算法：短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或者发生某事件而被阻塞放弃处理机时再重新调度。 时间片轮转法：系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的队尾；然后，再把处理机分配给就绪队列中的新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一个给定的时间内均能获得一时间片的处理机执行时间。 四、实验目的： 通过对进程调度算法的设计，深入理解进程调度的原理 五、实验内容： 1．编写程序实现SJ（P）F算法

2．编写程序实现RR算法 六、实验器材（设备、元器件）： 装有VC++的PC机一台 七、实验步骤： 1．打开VC，设计编写程序的源代码 2．编译运行程序的源代码 3．分析检验程序的结果是否正确 4．总结实验结果及结论 短进程优先调度源代码： #include "" struct sjf{ char name[10]; float arrivetime; float servicetime; float starttime; float finishtime; float zztime; float dqzztime; }; sjf a[100]; void input(sjf *p,int N) { int i; printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n"); for(i=0;i<=N-1;i++) { printf("input the %dth process's information:\n",i+1); scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime); } } void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N) {int k; printf("run order:"); printf("%s",p[0].name); for(k=1;k%s",p[k].name);

时间片轮转调度算法资料

《操作系统》课程实验报告实验名称：时间片轮转调度算法 班级：**************** 学号：************* 姓名：************** 指导老师：*************** 成绩：

一、实验目的： 1、测试数据可以随即输入或从文件中读入。 2、必须要考虑到进程的到达时间 3、最终能够计算每一个进程的周转时间的带权周转时间。 4、时间片大小可以不为1，但至少实现时间片大小为1的RR调度。 二、实验内容： 模拟实现时间片轮转调度算法，具体如下： 设置进程体：进程名，进程的到达时间，服务时间，，进程状态（W——等待,R ——运行,F——完成），进程间的链接指针 进程初始化：由用户输入进程名、服务时间进行初始化，同时，初始化进程的状态为W。 显示函数：在进程调度前、调度中和调度后进行显示。 排序函数：对就绪状态的进程按照进入就绪队列的时间排序，新到达的进行应优先于刚刚执行过的进程进入就绪队列的队尾。 调度函数：每次从就绪队列队首调度优一个进程执行，状态变化。并在执行一个时间片后化，服务时间变化，状态变化。当服务时间为0时，状态 变为F。 删除函数：撤销状态为F的进行。 三、实验代码 #include #include #include typedefstruct PCB2 { char name[10];//进程名 int runtime;//要求运行时间 intfrist;//定义优先数 char zhuangtai; //定义状态，R为就绪，F为完成 }; structshijian {//定义时间片的结构体 char name; //定义进程名 intdaodatime;// 到达时间 intfuwutime; //服务时间 intshengyutime;//剩余时间 char *state;//所处状态 structshijian *next; }; structshijian *time() { inta,i;

处理器调度(设计一个按时间片轮转法实现处理器调度的程序)

实验一处理器调度 一、实验容 选择一个调度算法，实现处理器调度。 二、实验目的 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。 三、实验题目 设计一个按时间片轮转法实现处理器调度的程序。 [提示]： (1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。进程控制块的 格式为： 其中，Q1，Q2，Q3，Q4，Q5。 指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。 要求运行时间——假设进程需要运行的单位时间数。 已运行时间——假设进程已经运行的单位时间数，初始值为“0”。 状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。 当一个进程运行结束后，它的状态为“结束”，用“E”表示。 (2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。 (3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如，当前轮到P2执行，则有： 标志单元 K1 K2 K 3 K4 K5

(4)处理器调度总是选择标志单元指示的进程运行。由于本实习是模拟处理器调度的 功能，所以，对被选中的进程并不实际的启动运行，而是执行： 已运行时间+1 来模拟进程的一次运行，表示进程已经运行过一个单位的时间。 请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。在这时省去了这些工作，仅用“已运行时间+1”来表示进程已 经运行满一个时间片。 (5)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一 个轮到运行的进程。同时，应判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间 已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。若该进程的要求运行时间=已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”（E）且退出队列。此时，应把该进程的进程控制块中的指针值送到前 面一个进程的指针位置。 (6)若“就绪”状态的进程队列不为空，则重复上面的（4）和（5）的步骤，直到所有 的进程都成为“结束”状态。 (7)在所设计的程序中应有显示或打印语句，能显示或打印每次选中进程的进程名以及 运行一次后进程队列的变化。 (8)为五个进程任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示 或打印逐次被选中的进程名以及进程控制块的动态变化过程。 四. 所用数据结构及符号说明 typedef struct PNode//PCB { struct PNode *next; //定义指向下一个节点的指针 char name[10]; //定义进程名，并分配空间 int All_time; //定义总运行时间 int Runed_Time; //定义已运行时间 char state; //定义进程状态Ready/End } *Proc; //指向该PCB的指针 int ProcNum; //总进程数

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

时间片轮转法模拟进程调度 一、基本原理 在时间片轮转法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，中断请求，将该程序送往就绪队列的队尾，并把处理机分配给新的队首进程，同时让它也执行一个时间片。这样就保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。 二、设计思路 首先，创建进程3-5，置低优先级，并依次插入低优先级队列，每次调度时，把处理器分配给队首进程，并给其一个随机数作为时间片的大小，当随机数小于300时令其等待，插入等待队列。当随机数大于300时，进程执行，并令其执行五个时间片。时间片耗尽时由一个计时器发出时钟中断请求，该进程转为低优先级就绪状态，插入到低优先级就绪队列的队尾，并将处理器分配给下一个进程。当高优先级队列和低优先级队列都为空时，则循环执行进程唤醒，执行等待队列里的进程。 三、运行结果（不唯一） 在运行结果中，按进程插入就绪队列的先后顺序进行调度，进程3先运行，其时间片耗尽后让其插入低优先级就绪队列的队尾，然后进程4开始运行，时间片耗尽后进程5开始运行，在进程5运行完第四个时间片后，分配给它的第五个时间片大小小于300，所以进程5

等待，插入等待队列。继续调度进程3，直到就绪队列里的进程都由于时间片大小小于300被插入等待队列后，开始唤醒进程5，并将其插入高优先级就绪队列，分配两个时间片，如此循环。

三、源代码： #include #include #include /*********************以下是全局数据结构和变量***********************/ /*PCB 结构*/ struct PCB{ int pname; int pri; int runtime; int waittime; struct PCB *next; }pcb[7]; /* 运行指针*/ struct PCB *running; /*高优先级就绪队列头指针*/ struct PCB *Hready; /*低优先级队列头指针*/ struct PCB *Lready; /*等待队列头指针*/ struct PCB*wait; int A=0; /**************************以下是函数说明****************************/ /*利用循环实现延迟*/ void delay(); /*模拟进程3－9*/ void proc(struct PCB *running); /*将node插入到head所指示的队列的尾部*/ void InsertIntoQueueTail(struct PCB **head,struct PCB *node); /*进程调度函数*/

时间片轮转调度算法

#include #include #include #include /*进程控制块数据结构*/ typedef struct node { char name[10];/*进程名*/ int prio; /*进程优先级*/ int round; /*循环轮转法进程每次轮转的时间片*/ int cputime; /*进程累计消耗的CUP时间*/ int needtime; /*进程到完成还需要的CUP时间*/ int count; /*循环轮转法一个时间片内进程运行时间*/ char state; /*进程的状态：'R':运行,'W'：等待,'F'：结束*/ struct node *next;/*指向下一个进程的链指针*/ }PCB; PCB *finish,*ready,*tail,*run;/*指向三个队列的队首的指针， finish为完成队列头指针， ready为就绪队列头指针， tail为就绪队列的队尾指针， run为当前运行进程头指针*/ int N;/*定义进程的数目*/ void firstin(void); //调度就绪队列的第一个进程投入运行； void print1(char a); //打印表头行信息 void print2(char chose,PCB *p); //打印每一行的状态信息 void print(char chose); //打印每执行一次算法后所有的进程的状态信息 void insert_prio(PCB *q); //在优先数算法中,将尚未完成的PCB按优先数顺序插入到就绪队列中； void prior_init(char chose); //进程优先级法初始化将进程按优先级插入到就绪队列里 void priority(char chose); //进程优先级算法总函数 void insert_rr(PCB *q); //在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾； void roundrun_init(char chose); //循环轮转法初始化将就绪队列保存为FIFO队列 void roundrun(char chose); //循环轮转法总算法 void main()//主函数 {

实验一___处理器调度(设计一个按时间片轮转法实现处理器调度的程序)

实验一处理器调度 一、实验内容 选择一个调度算法，实现处理器调度。 二、实验目的 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。 三、实验题目 第二题：设计一个按时间片轮转法实现处理器调度的程序。 [提示]： (1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。进程控制块的 格式为： 其中，Q1，Q2，Q3，Q4，Q5。 指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。 要求运行时间——假设进程需要运行的单位时间数。 已运行时间——假设进程已经运行的单位时间数，初始值为“0”。 状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。 当一个进程运行结束后，它的状态为“结束”，用“E”表示。 (2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。 (3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如，当前轮到P2执行，则有： 标志单元 K1 K2 K 3 K4 K5 (4)处理器调度总是选择标志单元指示的进程运行。由于本实习是模拟处理器调度的 功能，所以，对被选中的进程并不实际的启动运行，而是执行： 已运行时间+1 来模拟进程的一次运行，表示进程已经运行过一个单位的时间。 请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。在这时省去了这些工作，仅用“已运行时间+1”来表示进程已

时间片轮转算法

一、实验目的 （1）在单处理器情况下按时间片轮转算法实现处理器调度，输出运行动态变化过程。 （2）通过算法的实现加深了解处理器调度的工作。 二、实验内容 输入实现处理器调度的几个进程信息，任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示逐次被选中进程的进程名以及进程控制块的动态变化过程。 三、实验步骤 1、任务分析： 时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块，定义数据结构，说明进程控制块所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。实现的过程即运用指针指向某一个进程，判断当前的进程是否是就绪状态“r”，如果是，则为该进程分配一个时间片，同时，已运行时间加一且要求运行的时间减一，如此循环执行，当某一个进程的所需要运行的时间减少至0时，则将该进程的状态设置为“e”。然后，将指针指向下一个未运行完成的进程，重复判断，直至所有的进程都运行结束。 2、概要设计： （1）所用数据结构及符号说明 typedef struct PCB{ char name[10]; //进程名 struct PCB *next; //循环链指针 int need_time; //要求运行时间 int worked_time; //已运行时间，初始为0 char condition; //进程状态，只有“就绪”和“结束”两种状态 int flag; //进程结束标志，用于输出 }PCB; PCB *front,*rear; //循环链队列的头指针和尾指针 int N; //N为进程数 （2）主程序的流程图：

时间片轮转进程调度模拟算法的实现

武汉理工大学华夏学院课程设计报告书 课程名称：操作系统原理 题目：时间片轮转进程调度模拟算法的实现系名：信息工程系 专业班级：计算机1132班 姓名：李杰 学号： 10210413209 指导教师: 司晓梅 2015年 6 月 26日

武汉理工大学华夏学院信息工程系 课程设计任务书 课程名称：操作系统原理课程设计指导教师：司晓梅 班级名称：计算机1131-2 开课系、教研室：自动化与计算机 一、课程设计目的与任务 操作系统课程设计是《操作系统原理》课程的后续实践课程，旨在通过一周的实践训练， 加深学生对理论课程中操作系统概念，原理和方法的理解，加强学生综合运用操作系统原理、 Linux系统、C语言程序设计技术进行实际问题处理的能力，进一步提高学生进行分析问题 和解决问题的能力，包含系统分析、系统设计、系统实现和系统测试的能力。 学生将在指导老师的指导下，完成从需求分析，系统设计，编码到测试的全过程。 二、课程设计的内容与基本要求 1、课程设计题目 时间片轮转进程调度模拟算法的实现 2、课程设计内容 用c/c++语言实现时间片轮转的进程调度模拟算法。要求： 1．至少要有5个以上进程 2．进程被调度占有CPU后，打印出该进程正在运行的相关信息 提示: 时间片轮转调度算法中，进程调度程序总是选择就绪队列中的第一个进程，也就是说按照先来先服务原则调度，但一旦进程占用处理机则仅使用一个时间片。在使用完一个时间片后，进程还没有完成其运行，它必须释放出处理机给下一个就绪的进程，而被抢占的进程返回到就绪队列的末尾重新排队等待再次运行。 1）进程运行时，只打印出相关提示信息，同时将它已经运行的时间片加1就可以了。 2）为进程设计出PCB结构。PCB结构所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息等。 3、设计报告撰写格式要求： 1设计题目与要求 2 设计思想 3系统结构 4 数据结构的说明和模块的算法流程图 5 使用说明书（即用户手册）：内容包含如何登录、退出、读、写等操作说明 6 运行结果和结果分析（其中包括实验的检查结果、程序的运行情况）

采用时间片轮转算法调度程序

采用时间片轮转算法调度程序 学号： 姓名： 专业： 指导教师： 日期： 目录 一、需求分析 (3)

1、设计要求： (3) 2、解决方案： (3) 二、课程设计简介 (4) 1、课程设计题目 (4) 2、课程设计目的 (4) 3、课程设计内容 (4) 4、时间安排 (4) 三、概要设计 (4) 1、基本原理 (4) 2、算法思想设计 (5) 3、数据结构及模块说明： (5) 四、主要函数及其说明 (6) 五、调试分析 (7) 1、调试过程及步骤 (7) 2、结果分析（以三个进程数为例） (8) 六、总结及参考文献 (9) 1、总结： (9) 2、参考文献 (9) 附录：程序源代码 (9)

一、需求分析 1、设计要求： 在多道程序或多任务系统中，系统同时处于就绪状态的进程有若干个。为了使系统中各进程能有条不紊地进行，必须选择某种调度策略，以选择一进程占用处理机。要求用时间片轮转算法模拟单处理机调度，以巩固和加深处理机调度的概念。 2、解决方案： （1）、假设系统有5个进程，每个进程用一个进程控制块PCB来表示。PCB包括：进程名、链接指针、到达时间、估计运行时间和进程状态。其中，进程名即进程标识。链接指针指出下一个到达进程的进程控制块地址，按照进程到达的顺序排队，统设置一个队头和队尾指针分别指向第一个和最后一个进程，新生成的进程放队尾。估计运行时间：可由设计者任意指定一个时间值。到达时间：进程创建时的系统时间或由用户指定，调度时，总是选择到达时间最早的进程。进程状态：为简单起见，假定进程有三种状态，就绪、等待和完成，并假定进程一创建就处于就绪状态，用R表示，当一个进程运行结束时，就将其置成完成状态，用F表示。当一个进程未运行完成并且时间片不足时，就将其置成等待状态，用W表示。 （2）、为每个进程任意确定一个要求运行时间和到达时间。 （3）、按照进程到达的先后顺序排成一个循环队列。再设一队首指针指向第一个到达进程的首址。 （4）、执行处理机调度时，开始选择队首的第一个进程运行。另外再设一个当前运行进程的指针，指向当前正运行进程。 （5）、由于本实验是模拟实验，所以对被选中进程并不实际启动运行，而只是执行： a）、估计运行时间减时间片长度； b）、输出当前运行进程的名字。用这两个操作来模拟进程的一次运行（即一个时间片）。 （6）、进程运行一次后，以后的调度则将当前指针依次下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的链接指针所指进程，以指示应运行进程。同时还应判断该进程的剩余运行时间是否为零。若不为零，则等待下一轮的运行；若该进程的剩余运行时间为零，则将该进程的状态置为完成状态F，并退出循环队列插入完成队列。 （7）、若就绪队列不空，则重复上述（5）和（6）步骤直到所有进程都运行完为止。 （8）、在所有设计的调度程序中，应包含显示或打印语句，以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。

时间片轮转调度算法实验报告

xx大学操作系统实验报告 姓名：学号：班级： 实验日期： 实验名称：时间片轮转RR进程调度算法 实验二时间片轮转RR进程调度算法 1.实验目的：通过这次实验，理解时间片轮转RR进程调度算法的运行原理，进一步 掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。 2.需求分析 (1) 输入的形式和输入值的范围； 输入：进程个数n 范围：0

(4) 测试数据，包括正确的输入及其输出结果和含有错误的输入及其输出结果。正确输入： 错误输入：

2、概要设计 所有抽象数据类型的定义： static int MaxNum=100 int ArrivalTime //到达时间 int ServiceTime //服务时间 int FinishedTime //结束时间 int WholeTime //周转时间 double WeightWholeTime //带权周转时间double AverageWT //平均周转时间double AverageWWT //平均带权周转时间主程序的流程: 变量初始化

时间片轮转算法和优先级调度算法 C语言模拟实现

一、目得与要求?进程调度就是处理机管理得核心内容。本实验要求用高级语言编写模拟进程调度程序,以便加深理解有关进程控制快、进程队列等概念，并体会与了解优先数算法与时间片轮转算法得具体实施办法。 二、实验内容 1、设计进程控制块PCB得结构,通常应包括如下信息: 进程名、进程优先数(或轮转时间片数）、进程已占用得CPＵ时间、进程到完成还需要得时间、进程得状态、当前队列指针等。 2、编写两种调度算法程序: 优先数调度算法程序?循环轮转调度算法程序 3、按要求输出结果。?三、提示与说明 分别用两种调度算法对伍个进程进行调度。每个进程可有三种状态;执行状态(ＲUN)、就绪状态(ＲEＡDY,包括等待状态)与完成状态(ＦＩＮＩSH）,并假定初始状态为就绪状态。?(一）进程控制块结构如下：?ＮAＭE——进程标示符ＰRIO／ＲＯＵNＤ——进程优先数／进程每次轮转得时间片数（设为常数2)? CPUTIME——进程累计占用CPU得时间片数? NEEDTＩME——进程到完成还需要得时间片数 SＴＡTE——进程状态?ＮEXT——链指针?注: １、为了便于处理，程序中进程得得运行时间以时间片为单位进行计算; 2、各进程得优先数或轮转时间片数,以及进程运行时间片数得初值,均由用户在程序运行时给定。?(二)进程得就绪态与等待态均为链表结构，共有四个指针如下:? RUＮ——当前运行进程指针 RＥADY——就需队列头指针 TAIＬ——就需队列尾指针 FINISＨ——完成队列头指针 1、在优先数算法中,进程优先数得初值设为： (三)程序说明? 50－NEEDＴIME?每执行一次,优先数减1，CＰU时间片数加１,进程还需要得时间片数减1。 在轮转法中,采用固定时间片单位（两个时间片为一个单位),进程每轮转一次,CP

基于时间片轮转法调度算法模拟

操作系统课程设计报告课程设计题目：基于时间片轮转法调度算法模拟 姓名： 学号： 专业：计算机科学与技术 班级： 指导教师：小辉 2013 年1月11日

目录 一.课程设计目的与内容 (1) 二.任务分析 (2) 三.概要分析 (3) 四.详细设计 (4) 五.运行结果 (6) 六.总结 (7) 七.附录 (8) 八.评分表 (11)

一.课程设计目的与内容 1.课程设计目的 （1）在单处理器情况下按时间片轮转算法实现处理器调度，输出运行动态变化过程。 （2）通过算法的实现加深了解处理器调度的工作。 2.课程设计内容 输入实现处理器调度的几个进程信息，任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示逐次被选中进程的进程名以及进程控制块的动态变化过程。 二、任务分析 时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块，定义数据结构，说明进程控制块所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。实现的过程即运用指针指向某一个进程，判断当前的进程是否是就绪状态“r”，如果是，则为该进程分配一个时间片，同时，已运行时间加一且要求运行的时间减一，如此循环执行，当某一个进程的所需要运行的时间减少至0时，则将该进程的状态设置为“e”。然后，将指针指向下一个未运行完成的进程，重复判断，直至所有的进程都运行结束。

三、概要设计 （1）所用数据结构及符号说明 #include"stdio.h" #include"conio.h" #include"malloc.h" #include"string.h" #define NULL 0 typedef struct PCB{ char name[10]; //进程名 struct PCB *next; //链指针 int need_time; //要求运行时间 int worked_time; //已运行时间 char condition; //进程状态，只有“就绪”和“结束”两种状态int flag; //进程结束标志 }PCB; PCB *front,*rear; int N; //N为进程数

优先级和时间片轮转调度

实验4 优先级和时间片轮转调度 一、实验要求 通过编写程序实现进程高优先权和按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。 二、实验内容 进程调度算法有优先数调度算法，时间片轮转调度算法，分级调度算法。选两种种算法实现。进程调度算法的数据结构主要有：进程函数定义，建立进程函数，进程调度函数。源程序代码部分： #include "stdio.h" #include #define max 100 #define etime 4 #define pfree 0 #define running 1 #define aready 2 #define blocking 3 typedef struct node { char name; int status; int pri; int ptime; int ax,bx,cx,dx; int pc; int psw; }pcb; pcb *processarray[max]; static int processnum; pcb *createprocess(pcb *processarray[]) 组 { pcb *p,*q; int a,b,c,d,m,n,r,t; char ID; q=NULL;

printf("input the first nine status pcb:"); scanf("\n%c%d%d%d%d%d%d%d%d",&ID,&a,&b,&c,&d,&m,&n,&r,&t); for(int i=0;iname=ID; p->ax=a; p->bx=b; p->cx=c; p->dx=d; p->pc=m; p->psw=n; p->pri=r; p->ptime=t; p->status=aready; processnum++; processarray[i]=p; printf("input the next seven status pcb: "); scanf("\n%c",&ID); if (ID == '*') break; scanf("%d%d%d%d%d%d%d%d",&a,&b,&c,&d,&m,&n,&r,&t); } for(int j=0;jname,q->status,q->ax,q->bx,q->c x,q->dx,q->pc,q->psw,q->pri,q->ptime); } return *processarray; } void processRR(pcb *processarray[]) {int i; int j; pcb *q; int totaltime=0; for(i=0;i

时间片轮转调度

《操作系统》实验报告 实验题目时间片轮转调度 学生姓名lee 学号 专业班级 指导教师 院系名称计算机与信息学院 2017 年10 月30 日

实验6 时间片轮转调度 1.实验目的与要求 ● 调试EOS的线程调度程序，熟悉基于优先级的抢先式调度。 ● 为EOS添加时间片轮转调度，了解其它常用的调度算法。 2.实验原理 阅读本书第5章中的第5.4节。重点理解EOS当前使用的基于优先级的抢先式调度，调度程序执行的时机和流程，以及实现时间片轮转调度的细节。 3.实验内容 3.1 准备实验 按照下面的步骤准备实验： 1. 启动OS Lab。 2. 新建一个EOS Kernel项目。 3.2 阅读控制台命令“rr”相关的源代码 阅读ke/sysproc.c文件中第690行的ConsoleCmdRoundRobin函数，及该函数用到的第649行的ThreadFunction函数和第642行的THREAD_PARAMETER结构体，学习“rr”命令是如何测试时间片轮转调度的。在阅读的过程中需要特别注意下面几点： ● 在ConsoleCmdRoundRobin函数中使用ThreadFunction函数做为线程函数，新建了20个优先级为8的线程，做为测试时间片轮转调度用的线程。 ● 在新建的线程中，只有正在执行的线程才会在控制台的对应行（第0个线程对应第0行，第1个线程对应第1行）增加其计数，这样就可以很方便的观察到各个线程执行的情况。● 控制台对于新建的线程来说是一种临界资源，所以，新建的线程在向控制台输出时，必须使用“关中断”和“开中断”进行互斥（参见ThreadFunction函数的源代码）。 ● 由于控制台线程的优先级是24，高于新建线程的优先级 8，所以只有在控制台线程进入“阻塞”状态后，新建的线程才能执行。 ● 新建的线程会一直运行，原因是在ThreadFunction函数中使用了死循环，所以只能在ConsoleCmdRoundRobin函数的最后调用TerminateThread函数来强制结束这些新建的线程。 按照下面的步骤执行控制台命令“rr”，查看其在没有时间片轮转调度时的执行效果： 1. 按F7生成在本实验3.1中创建的EOS Kernel项目。 2. 按F5启动调试。 3. 待EOS启动完毕，在EOS控制台中输入命令“rr”后按回车。 命令开始执行后，观察其执行效果（如图1），会发现并没有体现“rr”命令相关源代码的设计意图。通过之前对这些源代码的学习，20个新建的线程应该在控制台对应的行中轮流地显示它们的计数在增加，而现在只有第0个新建的线程在第0行显示其计数在增加，说明只有

操作系统时间片轮转算法与优先级调度算法

#include "stdio.h" #include "stdlib.h" #include "string.h" typedef struct node { char name[10]; /*进程标识符*/ int prio; /*进程优先数*/ int round; /*进程时间轮转时间片*/ int cputime; /*进程占用CPU时间*/ int needtime; /*进程到完成还要的时间*/ int count; /*计数器*/ char state; /*进程的状态*/ struct node *next; /*链指针*/ }PCB; PCB *finish,*ready,*tail,*run; /*队列指针*/ int N; /*进程数*/ /*将就绪队列中的第一个进程投入运行*/ firstin() { run=ready; /*就绪队列头指针赋值给运行头指针*/ run->state='R'; /*进程状态变为运行态*/ ready=ready->next; /*就绪对列头指针后移到下一进程*/ } /*标题输出函数*/ void prt1(char a)

if(toupper(a)=='P') /*优先数法*/ printf(" name cputime needtime priority state\n"); else printf(" name cputime needtime count round state\n"); } /*进程PCB输出*/ void prt2(char a,PCB *q) { if(toupper(a)=='P') /*优先数法的输出*/ printf(" %-10s%-10d%-10d%-10d %c\n",q->name, q->cputime,q->needtime,q->prio,q->state); else/*轮转法的输出*/ printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name, q->cputime,q->needtime,q->count,q->round,q->state); } /*输出函数*/ void prt(char algo) { PCB *p; prt1(algo); /*输出标题*/ if(run!=NULL) /*如果运行指针不空*/ prt2(algo,run); /*输出当前正在运行的PCB*/ p=ready; /*输出就绪队列PCB*/ while(p!=NULL) { prt2(algo,p); p=p->next;

实验一_处理器调度____(设计一个按时间片轮转法实现处理器调度的程序)

实验一处理器调度 一、实习内容 选择一个调度算法，实现处理器调度。 二、实习目的 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。 三、实习题目 本实习有两个题，学生可选择其中的一题做实习。 第二题：设计一个按时间片轮转法实现处理器调度的程序。 [提示]： (1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。进程控制块的格式为： Q1，Q2，Q3，Q4，Q5。 指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。 要求运行时间——假设进程需要运行的单位时间数。 已运行时间——假设进程已经运行的单位时间数，初始值为“0”。 状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。当一个进程运行结束后，它的状态为“结束”，用“E”表示。 (2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。 (3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如，当前轮到P2执行，则有： 标志单元 ， K1K2K3K4K5 PCB1 PCB2 PCB3 PCB4 PCB5 (4) 处理器调度总是选择标志单元指示的进程运行。由于本实习是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行： 已运行时间+1 来模拟进程的一次运行，表示进程已经运行过一个单位的时间。 请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

时间片轮转算法和优先级调度算法 C语言模拟实现 收藏精编版

时间片轮转算法和优先级调度算法C语言模拟实现收藏 一、目的和要求 进程调度是处理机管理的核心内容。本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。 二、实验内容 1.设计进程控制块PCB的结构，通常应包括如下信息： 进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。 2.编写两种调度算法程序： 优先数调度算法程序 循环轮转调度算法程序 3.按要求输出结果。 三、提示和说明 分别用两种调度算法对伍个进程进行调度。每个进程可有三种状态；执行状态（R UN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。 （一）进程控制块结构如下： NAME——进程标示符 PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2） CPUTIME——进程累计占用CPU的时间片数 NEEDTIME——进程到完成还需要的时间片数 STATE——进程状态 NEXT——链指针 注： 1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算； 2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。 （二）进程的就绪态和等待态均为链表结构，共有四个指针如下：

RUN——当前运行进程指针 READY——就需队列头指针 TAIL——就需队列尾指针 FINISH——完成队列头指针 （三）程序说明 1. 在优先数算法中，进程优先数的初值设为： 50-NEEDTIME 每执行一次，优先数减1，CPU时间片数加1，进程还需要的时间片数减1。 在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2，进程还需要的时间片数减2，并退出CPU，排到就绪队列尾，等待下一次调度。 2. 程序的模块结构提示如下： 整个程序可由主程序和如下7个过程组成： （1）INSERT1——在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中； （2）INSERT2——在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾； （3）FIRSTIN——调度就绪队列的第一个进程投入运行； （4）PRINT——显示每执行一次后所有进程的状态及有关信息。 （5）CREATE——创建新进程，并将它的PCB插入就绪队列； （6）PRISCH——按优先数算法调度进程； （7）ROUNDSCH——按时间片轮转法调度进程。 主程序定义PCB结构和其他有关变量。 （四）运行和显示 程序开始运行后，首先提示：请用户选择算法，输入进程名和相应的NEEDTIM E值。 每次显示结果均为如下5个字段： name cputime needtime priority state 注：

进程调度(2)循环时间片轮转调度算法

实验六进程调度（2）循环时间片轮转调度算法 实验目的 进程调度是处理器管理的核心内容。本实验要求用高级语言编写和调试一个简单的进程调度程序，通过本实验加深对进程控制块、进程队列等概念的了解，掌握时间片调度算法的具体实施方法。 实验类型 设计性实验 预习要求 已完成进程管理理论课程的学习，了解进程、进程调度的基本概念以及典型进程调度算法的基本思想。 实验设备与环境 PII以上电脑一台，已经安装VC++、GCC或其他C语言编译环境 实验原理 操作系统是计算机系统中必不可少的系统软件。它是计算机系统中各种资源的管理者和各种活动的组织者、指挥者。进程调度解决了竞争处理器的问题。进程调度程序按照某种调度算法从就绪队列中选择一个进程，让它占用处理器。或者说，进程调度程序把处理器分配给了一个被选中的进程。所以，有时也把进程调度程序称为“处理器调度”程序。 在时间片轮转调度算法方面：时间片取值的大小关系到计算机系统的效率和用户的满意度，所以，时间片的值应根据进程要求系统给出应答时间和进入系统的进程数来决定。如果要求系统快速应答则时间片小一些，这样使轮转一遍的总时间减少而可对进程尽快回答。如果进程数少，则时间片可以大一些，这样可减少进程调度的次数，提高系统效率。对每个进程可规定相同的时间片，也可对不同的进程规定不同的时间片。 实验任务 设计一个程序,根据不同的调度算法模拟操作系统对进程的调度。

调度算法: 时间片循环法 1、设计进程控制块PBC表结构，适用循环时间片轮转算法。 2、 PBC结构通常包括以下信息：进程名、进程优先数、轮转时间片、进程的CPU时间，进程状态等。根据调度算法不同，PCB结构可作适当的调整。 3、建立进程队列。对不同的算法编制不同的入链程序。 程序要求达到的运行效果：在设置好进程数量、调度算法后，系统能按设定的参数运行，并在屏幕上交替显示就绪队列和完成队列的进程名等信息。 实验步骤和方法 编制调度算法：循环时间轮转调度 1、数据结构设计： PCB结构： name 进程名 round 进程轮转时间片 cputime 进程占用的CPU时间 needtime 进程到完成还要的时间 state 进程状态（假设状态为Ready、Run、Finish） next 链指针 2、算法设计 时间以时间片为计量单位。 循环时间片轮转算法 1）系统初始化时给每一个进程赋以一个needtime，并将所有进程按进入的次序排成一个队列。 2）取队头进程,并投入运行。 3）采用相对固定时间片（round），进程每执行一次，进程占用的CPU时间加ROUND，进程到完成还要的CPU时间减round。并排到就绪队列的尾部。 4）如果当前进程的needtime>0,那么将它排到队尾。 5）如果尚有进程在队列中,那么转入2）。