使用动态优先权的进程调度算法的模拟实验

合集下载

进程管理实验报告

进程管理实验报告

实验名称: 进程管理实验要求:阅读后面的C语言实例,修改程序,使其优先数在运行期间可以变化(动态优先数)。

例如,当某进程被时间片中断次数增加到一定数目时,提高其优先权。

关键问题:读懂源程序代码,了解进程管理的方式,并设计一个算法使程序能在运行过程中修改进程优先级。

设计思路:在进程控制块中定义一个记录进程中断次数的变量,在block函数中设置跟踪并记录进程中断次数,在调度函数schedule中设置算法,在进程中断3次后将该进程的优先级提升至最高。

改动后的代码:#include <stdio.h>#define TRUE 1#define FALSE 0#define MAXPRI 100#define NIL -1//进程控制块struct {int id; //进程号char status; //进程状态,'e'-执行态'r'-高就绪态't'-低就绪态'w'-等待态'c'-完成态int nextwr; //等待链指针,指示在同一信号量上等待的下一个等待进程的进程号。

int priority; //进程优先数,值越小,优先级越高。

int c;//进程中断次数}pcb[3];//共3个进程//s1、s2为三个进程共享的变量;seed为随机值;registeri模拟寄存器值,存放计算的重复次数。

int registeri,s1,s2,seed,exe=NIL;//exe为当前运行(占有cpu)的进程号//2个信号量sem[0]、sem[1],分别与共享变量s1、s2相联系。

//对应信号量sem[0]、sem[1]分别有两个阻塞队列,队列首由sem[].firstwr指定,队列链指针是pcb[].nextwrstruct{int value;//信号量值int firstwr;//等待该信号量的阻塞队列的首个进程号}sem[2];//三个进程的现场保留区,其中savearea[][0]为寄存器内容,savearea[][1]为下一条指令地址。

操作系统 实验 进程调度 银行家算法 多线程编程 存储管理 磁盘调度

操作系统 实验 进程调度 银行家算法 多线程编程  存储管理 磁盘调度

实验一进程调度实验学时:2学时实验类型:设计实验要求:必修一、实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。

因而引起进程调度。

本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。

二、实验内容1.优先权法、轮转法简化假设1)进程为计算型的(无I/O)2)进程状态:ready、running、finish3)进程需要的CPU时间以时间片为单位确定2.算法描述1)优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。

2)轮转法三、流程图四、实验程序代码package进程调度;/***@author**/public class CPCB {private String name;private int time;private int count;public int getCount() {return count;}public void setCount(int count) { this.count = count;}public String getName() {return name;}public void setName(String name) { = name;}public int getTime() {return time;}public void setTime(int time) {this.time = time;}}package进程调度;/***@author**/class PCB{private String name;private int time ;private int priority ;public int getTime(){return time;}public void setTime(int time){this.time = time;}public int getPriority(){return priority;}public void setPriority(int priority){ this.priority = priority;}public String getName() {return name;}public void setName(String name) { = name;}}package进程调度;import java.util.LinkedList;/***@author**/class process{private final static int nap_time = 500;private LinkedList<PCB> queue = new LinkedList<PCB>();private LinkedList<CPCB> cqueue = new LinkedList<CPCB>();//优先权算法public void go(int p_Num) throws Exception{for(int i = 0;i<p_Num;i++){PCB pcb = new PCB();int time = (int)(Math.random()*20+1);int pri = (int)(Math.random()*20+4);pcb.setName("进程"+i);pcb.setTime(time);pcb.setPriority(pri);queue.add(pcb);}queue = this.sort(queue);int i=0;while(queue.size()!=0){PCB pcb = (PCB)queue.getFirst();System.out.println(i+"\t\t"+pcb.getName()+"运行\t"+"优先级:"+pcb.getPriority()+"---所需时间:"+pcb.getTime());// Thread.sleep(nap_time);int pre = pcb.getPriority() - 3;int time = pcb.getTime() - 1;if(time<=0){System.out.println(pcb.getName()+"\t\t进程运行结束");PCB p = (PCB)queue.removeFirst();System.out.println("移除队列的进程是\t\t"+p.getName()+"\n队列中还有"+queue.size()+"个进程\n");}else{queue.remove();pcb.setPriority(pre);pcb.setTime(time);// System.out.println("运行后:"+i+"----"+pcb.getName()+"---优先级:"+pcb.getPriority()+"---所需时间:"+pcb.getTime());queue.add(pcb);queue = this.sort(queue);}i++;}}//时间片轮转调度算法public void cycle(int p_Num) throws Exception{final int time = 3; //定义轮转时间片数for(int i = 0;i<p_Num;i++){CPCB cpcb = new CPCB();cpcb.setTime((int)(Math.random()*20)+1);cpcb.setName("进程"+i);cpcb.setCount(0);cqueue.add(cpcb);}while(cqueue.size()!=0){CPCB cpcb = (CPCB)cqueue.getFirst();while(cpcb.getCount()!=time){// Thread.sleep(nap_time);cpcb.setTime(cpcb.getTime() - 1);cpcb.setCount(cpcb.getCount()+1);for(int i=0;i<cqueue.size();i++)//输出进程运行情况{CPCB cpcb1 = (CPCB)cqueue.get(i);System.out.println(cpcb1.getName()+"\t\t所需时间片数"+cpcb1.getTime()+"\t\t已占用CPU时间片数"+cpcb1.getCount());}if(cpcb.getTime()==0){System.out.println(cpcb.getName()+"运行结束\n"+"-------------移除队列的是"+cpcb.getName()+"-------------");cqueue.removeFirst();System.out.println("-------------队列中还有"+cqueue.size()+"个进程--------------");break;}if(cpcb.getCount()==time){// cqueue.remove();System.out.println("----因为"+cpcb.getName()+"占用CPU时间片数"+cpcb.getCount()+"="+time);System.out.println(cpcb.getName()+"时间片运行结束"+cpcb.getCount()+cpcb.getTime());CPCB p = (CPCB)cqueue.removeFirst();cqueue.add(p);cpcb.setCount(0);break;}}}}public LinkedList<PCB> sort(LinkedList<PCB> processes){for(int i=0;i<processes.size();i++){PCB thread = new PCB();thread = processes.get(i);for(int j=i+1;j<processes.size();j++){if(thread.getPriority() < processes.get(j).getPriority()){PCB mythread = new PCB();mythread = thread;//thread = processes.get(j);processes.set(i, processes.get(j));processes.set(j, mythread);}}}return processes;}}package 进程调度;import java.io.BufferedReader;import java.io.InputStreamReader;/**** @author 邱福文**/public class MainFun{public void FPF(){}public static void main (String[] args) throws Exception{Integer n2;do{System.out.print("请输入进程数:");BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));String str = sin.readLine();Integer n = Integer.parseInt(str);System.out.print("请输入调度算法:\n"+"1为优先权\n"+"2为轮转法\n"+"0 退出\n");BufferedReader sin2 = new BufferedReader(new InputStreamReader(System.in));String str2 = sin2.readLine();process p = new process();// do{n2 = Integer.parseInt(str2);switch(n2){case 0:break;case 1:p.go(n);break;case 2:p.cycle(n);break;default:System.out.print("输入有误请重新输入");break;}}while(n2!=0);}}五、实验结果请输入进程数:3请输入调度算法:1为优先权2为轮转法0 退出10 进程0运行优先级:19---所需时间:181 进程1运行优先级:19---所需时间:152 进程0运行优先级:16---所需时间:173 进程1运行优先级:16---所需时间:144 进程0运行优先级:13---所需时间:165 进程1运行优先级:13---所需时间:136 进程2运行优先级:10---所需时间:87 进程0运行优先级:10---所需时间:158 进程1运行优先级:10---所需时间:129 进程2运行优先级:7---所需时间:710 进程0运行优先级:7---所需时间:1411 进程1运行优先级:7---所需时间:1112 进程2运行优先级:4---所需时间:613 进程0运行优先级:4---所需时间:1314 进程1运行优先级:4---所需时间:1015 进程2运行优先级:1---所需时间:516 进程0运行优先级:1---所需时间:1217 进程1运行优先级:1---所需时间:918 进程2运行优先级:-2---所需时间:419 进程0运行优先级:-2---所需时间:1120 进程1运行优先级:-2---所需时间:821 进程2运行优先级:-5---所需时间:322 进程0运行优先级:-5---所需时间:1023 进程1运行优先级:-5---所需时间:724 进程2运行优先级:-8---所需时间:225 进程0运行优先级:-8---所需时间:926 进程1运行优先级:-8---所需时间:627 进程2运行优先级:-11---所需时间:1 进程2 进程运行结束移除队列的进程是进程2队列中还有2个进程28 进程0运行优先级:-11---所需时间:829 进程1运行优先级:-11---所需时间:530 进程0运行优先级:-14---所需时间:731 进程1运行优先级:-14---所需时间:432 进程0运行优先级:-17---所需时间:633 进程1运行优先级:-17---所需时间:334 进程0运行优先级:-20---所需时间:535 进程1运行优先级:-20---所需时间:236 进程0运行优先级:-23---所需时间:437 进程1运行优先级:-23---所需时间:1 进程1 进程运行结束移除队列的进程是进程1队列中还有1个进程38 进程0运行优先级:-26---所需时间:339 进程0运行优先级:-29---所需时间:240 进程0运行优先级:-32---所需时间:1进程0 进程运行结束移除队列的进程是进程0队列中还有0个进程请输入进程数:3请输入调度算法:1为优先权2为轮转法0 退出2进程0 所需时间片数8 已占用CPU时间片数1 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数7 已占用CPU时间片数2 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数3 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 ----因为进程0占用CPU时间片数3=3进程0时间片运行结束36进程1 所需时间片数5 已占用CPU时间片数1 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数4 已占用CPU时间片数2 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数3 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 ----因为进程1占用CPU时间片数3=3进程1时间片运行结束33进程2 所需时间片数12 已占用CPU时间片数1 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数11 已占用CPU时间片数2 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数3 进程0 所需时间片数6 已占用CPU时间片数0----因为进程2占用CPU时间片数3=3进程2时间片运行结束310进程0 所需时间片数5 已占用CPU时间片数1 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数4 已占用CPU时间片数2 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数3 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 ----因为进程0占用CPU时间片数3=3进程0时间片运行结束33进程1 所需时间片数2 已占用CPU时间片数1 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1 所需时间片数1 已占用CPU时间片数2 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1 所需时间片数0 已占用CPU时间片数3 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1运行结束-------------移除队列的是进程1--------------------------队列中还有2个进程--------------进程2 所需时间片数9 已占用CPU时间片数1 进程0 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数8 已占用CPU时间片数2 进程0 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数7 已占用CPU时间片数3 进程0 所需时间片数3 已占用CPU时间片数0 ----因为进程2占用CPU时间片数3=3进程2时间片运行结束37进程0 所需时间片数2 已占用CPU时间片数1 进程2 所需时间片数7 已占用CPU时间片数0 进程0 所需时间片数1 已占用CPU时间片数2 进程2 所需时间片数7 已占用CPU时间片数0 进程0 所需时间片数0 已占用CPU时间片数3 进程2 所需时间片数7 已占用CPU时间片数0 进程0运行结束-------------移除队列的是进程0--------------------------队列中还有1个进程--------------进程2 所需时间片数6 已占用CPU时间片数1进程2 所需时间片数4 已占用CPU时间片数3----因为进程2占用CPU时间片数3=3进程2时间片运行结束34进程2 所需时间片数3 已占用CPU时间片数1进程2 所需时间片数2 已占用CPU时间片数2进程2 所需时间片数1 已占用CPU时间片数3----因为进程2占用CPU时间片数3=3进程2时间片运行结束31进程2 所需时间片数0 已占用CPU时间片数1进程2运行结束-------------移除队列的是进程2--------------------------队列中还有0个进程--------------请输入进程数:实验二银行家算法一、实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。

操作系统课程设计报告-进程调度算法模拟

操作系统课程设计报告-进程调度算法模拟

1.课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一,是学习完《操作系统原理》课程后进行的一次较全面的综合练习。

其目的在于加深对操作系统的理论、方法和基础知识的理解,掌握操作系统结构、实现机理和各种典型算法,系统地了解操作系统的设计和实现思路,培养学生的系统设计能力,并了解操作系统的发展动向和趋势。

2.课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度,基于高响应比优先的动态优先级调度算法实现,能够输出调度情况,并计算周转时间和平均周转时间。

要求使用链表,进程个数由用户提供,按照进程的实际个数生成PCB,程序能够让用户选择使用哪种调度算法,能够在Linux环境运行并验证结果。

程序要考虑用户界面的友好性和使用方便性。

进程基本信息可从文件读入,也可手动输入。

3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源创建进程,然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。

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

时间片的大小从几ms到几百ms。

当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。

3.4静态优先级调度算法把处理机分配给优先级最高的进程,使之执行。

但在其执行期间,只要出现了另一个比其优先级更高的进程,调度程序就将处理机分配给新到的优先级最高的进程。

这样就可以保证紧迫性作业优先运行。

3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业,使之在进入系统后便获得优先处理,引入最高优先权优先调度算法。

电子科技大学计算机操作系统—操作系统实验

电子科技大学计算机操作系统—操作系统实验

附件1操作系统上机实验进程调度实验时间:16 机时实验验收时间:17~18周实验成绩:占总成绩的20%一、实验目的和要求1.目的进程是操作系统最重要的概念之一,进程调度又是操作系统核心的主要内容。

本实习要求学生独立地用高级语言编写和调试一个进程调度程序,模拟各种调度算法。

调度算法可任意选择或自行设计,例如,简单轮转法和优先数法等。

本实验可加深对于进程调度和各种调度算法的理解。

2.要求(1)设计一个有n(n≥8)个进程并行的进程调度程序。

每个进程由一个进程控制块(PCB)表示。

进程控制块通常应包含下述信息:进程名(或序号)、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等(要求包括4种基本状态:运行、就绪、阻塞、完成),PCB块的内容应根据调度算法的不同特点而增删。

(2)调度程序应包含3种或3种以上不同的调度算法,运行时可任意选一种,以利于各种算法的分析比较。

其中至少有一种为综合调度算法,并要求是自己设计的算法。

(3)系统应能直观、准确地动态显示(用动态的表或图)各进程状态和参数的变化情况,便于观察诸进程调度的动态显示过程。

(4)要求完成一个完整的软件系统,用户界面友好,操作简便,可采用菜单选择或图形用户界面(GUI)实现。

说明:在windows 环境下开发,也可用其它工具或软件实现进程调度过程的模拟。

要求画出至少一个综合调度算法的实现流程图。

二、调度算法1.算法本程序可选用来先服务(FCFS)算法、最短CPU运行期优先(SCBF)算法、最高优先权(HPF)算法、时间片轮转(RR)算法及多级反馈队列算法等对多个进程进行调度。

同时注意对自己设计的综合调度算法要认真分析其特点。

每个进程处于运行、就绪、等待、完成四种状态,并假定起始状态都是就绪状态。

为了便于处理,程序中进程的运行时间以时间片为单位计算。

各进程的优先数或轮转时间片数、以及进程需要运行的时间片数,均由伪随机数发生器产生。

进程控制块结构如下图所示:2.算法举例以两种典型算法为例说明实现的算法:⑴优先数法(动态优先数)系统中各进程的初始优先级与进程类型(前台或后台,交互或批处理,计算或I/O)有关。

使用动态优先权的进程调度算法的模拟

使用动态优先权的进程调度算法的模拟

使用动态优先权的进程调度算法的模拟动态优先权(Dynamic Priority)调度算法是一种根据进程的行为动态调整其优先级的调度算法。

它是对静态优先权调度算法的一种改进,能够更加灵活和有效地调度进程。

下面我将通过模拟的方式详细介绍动态优先权调度算法。

在动态优先权调度算法中,每个进程都有一个初始优先级,等待时间越长,优先级越高。

当进程开始执行时,系统根据其行为调整它的优先级。

假设有五个进程ReadyQueue={P1, P2, P3, P4, P5},它们的初始优先级分别为{10, 20, 30, 40, 50}。

每个进程的服务时间分别为{6, 7, 8, 9, 10}。

1.初始化阶段:-进程P1开始执行,系统将其优先级设置为初始优先级减去正在运行的时间。

-正在运行的时间是指进程执行过程中已经消耗的时间。

2.执行阶段:-进程P1运行6个时间单位后,它已经完成了自己的服务时间。

这时,系统将调度下一个优先级最高的进程P5运行。

-进程P5开始执行,系统将其优先级设置为初始优先级减去正在运行的时间。

因为P5执行是第一次运行,所以其正在运行的时间为0。

-进程P5运行10个时间单位后,它也完成了自己的服务时间。

3.更新优先级阶段:-进程P5完成后,进程P2开始执行,系统将其优先级设置为初始优先级减去正在运行的时间。

-进程P2运行7个时间单位后,它完成了自己的服务时间。

4.重新排序阶段:-进程P3开始执行,系统将其优先级设置为初始优先级减去正在运行的时间。

-进程P3运行8个时间单位后,它也完成了自己的服务时间。

5.最后的执行阶段:-进程P4开始执行,系统将其优先级设置为初始优先级减去正在运行的时间。

-进程P4运行9个时间单位后,完成了自己的服务时间。

至此,所有的进程都已经完成了它们的服务时间。

动态优先权调度算法的核心思想是,等待时间越长,优先级越高。

这样做的原因是为了避免饥饿的产生,即一些低优先级的进程因为等待时间太长而无法得到运行。

动态优先权进程调度算法模拟实验报告

动态优先权进程调度算法模拟实验报告

动态优先权进程调度算法模拟实验报告动态优先权调度算法是一种动态调度算法,根据进程的优先级来决定下一个要执行的进程。

进程的优先级可以根据其紧迫性、重要性和资源需求等因素来确定。

本实验利用模拟算法来模拟动态优先权调度算法,并通过实例来说明该调度算法的工作原理和优缺点。

一、实验目的通过本实验,我们可以了解动态优先权调度算法的工作原理,掌握如何使用模拟算法来模拟进程的调度过程,进一步了解该调度算法的优缺点。

二、实验环境本实验使用C++编程语言来实现动态优先权调度算法的模拟。

编译器使用Dev-C++。

三、实验步骤1.设计进程控制块(PCB)的数据结构,包括进程优先级、进程标识、进程状态等信息。

2.设计模拟算法来模拟动态优先权调度算法。

具体算法如下:a.初始化就绪队列,将所有的进程按照优先级插入到就绪队列中。

b.选择优先级最高的进程执行,并更新该进程的优先级。

c.执行完毕后更新进程的状态,并将其从就绪队列中删除。

d.如果新的进程到达,将其插入到就绪队列中。

3.实现主函数,模拟进程的创建、调度和执行过程。

4.进行多个实例的测试,观察进程的调度顺序和执行结果。

5.总结实验结果,分析动态优先权调度算法的优缺点。

四、实验结果与分析通过多个实例的测试,我们可以观察到动态优先权调度算法的工作过程和效果。

该算法可以根据进程的优先级来确定下一个要执行的进程,从而可以更好地满足不同进程的需求。

同时,动态优先权调度算法可以确保优先级高的进程能够及时得到执行,提高系统的响应速度。

然而,动态优先权调度算法存在一些缺点。

首先,该算法对进程的优先级要求较高,需要合理设置进程的优先级。

如果优先级设置不合理,可能导致优先级高的进程一直占用CPU资源,而优先级低的进程无法得到执行,造成资源浪费。

其次,该算法没有考虑进程的等待时间和执行时间,容易导致饥饿现象的发生,即一些进程无法得到执行。

五、实验总结通过本实验,我们了解了动态优先权调度算法的工作原理和模拟方法。

进程调度模拟设计——时间片轮转、优先级法

进程调度模拟设计——时间片轮转、优先级法

学号:课程设计课程名字系统软件开发实训A题目进程调度模拟设计——时间片轮转、优先级法学院专业班级姓名指导教师2014 年01 月17 日课程设计任务书学生姓名:专业班级:指导教师:工作单位:题目: 进程调度模拟设计——时间片轮转、优先级法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。

2.实践准备:掌握一种计算机高级语言的使用。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。

2.设计报告内容应说明:⑴课程设计目的与功能;⑵需求分析,数据结构或模块说明(功能与框图);⑶源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结。

时间安排:设计安排3周:查阅、分析资料 1天系统软件的分析与建模 4天系统软件的设计 5天系统软件的实现 3天撰写文档 1天课程设计验收答辩 1天设计验收安排:设计周的第三周的指定时间到实验室进行上机验收。

设计报告书收取时间:课程设计验收答辩完结时。

(注意事项:严禁抄袭,一旦发现,抄与被抄的一律按0分记)指导教师签名: 2013 年 12 月 10日系主任(或责任教师)签名: 2013 年 12 月 10日进程调度模拟设计——时间片轮转、优先级法1设计目的1.1 阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解,能够使用其中的方法来进行进程调度模拟设计。

1.2 练掌握并运用时间片轮转和优先级法,掌握一种计算机高级语言的使用。

2 设计要求2.1 能够选择不同的调度算法(要求中给出的调度算法);2.2 能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;2.3 根据选择的调度算法显示进程调度队列;2.4 根据选择的调度算法计算平均周转时间和平均带权周转时间。

使用动态优先权的进程调度算法的模拟实验

使用动态优先权的进程调度算法的模拟实验

使用动态优先权的进程调度算法的模拟实验进程调度算法是操作系统中对进程进行调度的一种策略,动态优先权调度算法是其中一种常用的调度算法。

下面将对动态优先权调度算法进行模拟实验,并对实验结果进行分析。

首先,我们定义进程的属性包括进程编号、到达时间、服务时间、优先权和完成时间等。

动态优先权调度算法的基本思想是根据进程的优先权决定下一个被调度的进程,优先权越高,被调度的机会越大。

实验过程如下:1.创建一个进程队列,用来存放待调度的进程。

2.输入进程的个数,并依次输入每个进程的到达时间、服务时间和优先权。

3.将所有进程按照到达时间进行排序。

4.从排好序的进程队列中选择优先权最高的进程,即优先权最大的进程。

5.通过执行该进程进行模拟,更新进程队列中的进程信息。

6.根据更新后的进程信息,重新选择下一个被调度的进程。

7.重复步骤5和6,直到所有进程执行完毕。

对于每个进程,我们可以记录其等待时间、周转时间和带权周转时间。

等待时间即为该进程在就绪队列中等待的时间,周转时间是指从进程提交到完成的时间,即完成时间减去到达时间,带权周转时间是指每个进程的周转时间除以服务时间,用来评估进程的调度效果。

下面是一个动态优先权调度算法的模拟实验示例:```pythonclass Process:self.id = idself.priority = prioritydef __lt__(self, other):return self.priority < other.prioritydef dynamic_priority_scheduling(processes):queue = []while processes or queue:for process in processes:queue.append(process)processes.remove(process)queue.sort(reverse=True) # 根据进程的优先权进行排序if queue:process = queue.pop(0)for p in queue:if __name__ == '__main__':n = int(input("Enter the number of processes: "))processes = []for i in range(n):priority = int(input("Enter priority for process {}:".format(i+1)))dynamic_priority_scheduling(processes)```以上代码定义了一个Process类来表示进程,并使用动态优先权调度算法对进程进行调度。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
if(head==NULL) //如果就绪队列为空
{
head=run;
head->next=NULL;
}
else if(head->priority < run->priority) //如果插入结点中所保存的数比头结点所保存的数要大,则直接把该结点插入到头结点之前
{
run->next=head;
head=run;
if(i==0) //如果创建的是第一个结点
{
head=temp1;
head->next=NULL;
continue;
}
if(head->priority < temp1->priority) //如果创建结点中所保存的数比头结点所保存的数要大,则直接把该结点插入到头结点之前
{
temp1->next=head;
STARTBLOCK2-1-1-1-1
BLOCKTIME30000
STATEREADYREADYREADYREADYREADY
(5)为了清楚地观察诸进程的调度过程,程序应将每个时间片内的进程的情况显示出来,参照的具体格式如下:
RUNNING PROG:i
READY_QUEUE:->id1->id2
BLOCK_QUEUE:->id3->id4
temp3=temp2->next;
}
temp2->next=temp1;
temp1->next=tFra bibliotekmp3;}
return head;
}
PCB *InsertQueue(PCB *head,PCB *run) //在就绪队列中插入一个结点
{
PCB *temp1,*temp2; //temp1和temp2分别为比较结点的前驱和比较结点
}PCB;
PCB *CreatQueue(int num) //创建一个就绪队列
{
int i; //i为循环计数器
PCB *head, *temp1, *temp2, *temp3; //head为就绪队列的头指针,temp1为创建进程结点的指针,temp2、temp3分别为比较结点的前驱结点和比较结点
BLOCKTIMEB0B1B2B3B4
STATES0S1S2S3S4
3.过程(流程图)
4.代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node
{
int id; //进程标识数
int priority; //进程优先数,优先数越大优先级越高
进程状态state;
队列指针next,用来将PCB排成队列。
(3)优先数改变的原则:
进程在就绪队列中呆一个时间片,优先数增加1.
进程每运行一个时间片,优先数减3。
(4)假设在调度前,系统中有5个进程,它们得初始状态如下:
ID01234
PRIORITY9 38 30290
CPUTIME 00000
ALLTIME33634
int cputime; //进程已占用的CPU时间
int alltime; //进程还需占用的CPU时间
int startblock; //进程的阻塞时间
int blocktime; //进程被阻塞的时间
char state[10]; //进程状态
struct node *next; //队列指针
======================================================================
ID01234
PRIORITYP0 P1 P2P3 P4
CPUTIME C0C1C3C4C5
ALLTIMEA0A1A2A3A4
STARTBLOCKT0T1T2T3T4
head=temp1;
continue;
}
temp2=head; //temp2为比较结点的直接前驱结点
temp3=temp2->next; //temp3为比较的结点
while(temp3!=NULL && temp3->priority>=temp1->priority) //实现查找的功能
{
temp2=temp3;
进程已占用的CPU时间cputime;
进程还需占用的CPU时间alltime,当进程运行完毕时,alltime变为0;
进程的阻塞时间startblock,表示当进程再运行startblock个时间片后,进程将进入阻塞状态;
进程被阻塞的时间blicktime,表示已阻塞的进程再等待blocktime个时间片后,将转换为就绪态;
}
temp1->next=run;
run->next=temp2;
}
return head;
}
main()
{
int num; //num为进程的个数
int alltime=0; //用来保存所有进程需要占用的CPU时间
PCB *head; //head为就绪队列的头指针
PCB *run=NULL; //run为执行进程结点的指针
使用动态优先权的进程调度算法的模拟实验
1.实验目的
通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。
2.实验内容
(1)用C语言实现对N个进程采用动态优先权优先算法的进程调度;
(2)每个用来标识进程的进程控制块PCB用结构来描述,包括以下字段:
进程标识数;
进程优先数priority,并规定优先数越大的进程,其优先权越高;
for(i=0; i<num; i++) //根据进程的个数创建结点并按从大到小的顺序进行排序
{
temp1=(PCB *)malloc(sizeof(PCB));
printf("输入第%d个进程的(id…state)\n",i);
scanf("%d%d%d%d%d%d%s",&temp1->id,&temp1->priority,&temp1->cputime,&temp1->alltime,&temp1->startblock,&temp1->blocktime,temp1->state);
}
else
{
temp1=head; //temp1为比较结点的直接前驱结点
temp2=temp1->next; //temp2为比较的结点
while(temp2!=NULL && temp2->priority>=run->priority) //实现查找的功能
{
temp1=temp2;
temp2=temp1->next;
相关文档
最新文档