进程调度算法流程图

合集下载

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

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

实验一进程调度实验学时: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实验一先来先服务FCFS和短作业优先SJF进程调度算法

1实验一先来先服务FCFS和短作业优先SJF进程调度算法

实验一先来先服务FCFS和短作业优先SJF进程调度算法一:需求分析程序设计的任务:设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。

假设有n个x进程分别在T1,… ,Tn时刻到达系统,它们需要的服务时间分别为S1,… ,Sn.分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度,计算每个进程的完成时间、周转时间和带权周转时间,并且统计n个进程的平均周转时间和平均带权周转时间。

通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

(1)输入的形式和输入值的范围为免去测试时候需要逐步输入数据的麻烦,输入时采用输入文件流方式将数据放在。

txt 文件中,第一行为进程个数,第二行为进程到达时间(各个进程的到达时间之间用空格隔开),第三行为进程的服务时间(每个服务时间之间用空格隔开)。

(2)输出的形式模拟整个调度过程,输出每个时刻的进程运行状态,同时输出了每个进程的完成时间,并且按要求输出了计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

(3)程序所能达到的功能能够模拟出进程的先来先服务FCFS算法和短作业优先SJF算法的调度过程,输入进程个数n;每个进程的到达时间T1, … ,Tn和服务时间S1, … ,Sn;选择算法1-FCFS,2-SJF,3—退出,用户做出选择即可输出对应的算法调度过程或者退出程序。

(4)测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果测试数据及其输出结果:二:概要设计程序包括主函数、FCFS算法函数、SJF算法函数、输出函数;主函数流程:输入文件中的数据—显示各进程数据-选择算法-调用相应算法的函数-输出结果三:详细设计算法流程图:调用结束四:调试分析(1):调试过程中遇到的问题以及解决方法,设计与实现的回顾讨论和分析;开始的时候没有判断进程是否到达,导致短进程优先算法运行结果错误,后来加上了判断语句后就解决了改问题。

进程调度算法实验报告

进程调度算法实验报告

实验报告实验一:进程调度算法一、实验目的1.利用高级语言实现三种不同及进程调度算法:短作业优先算法、时间片轮转调度算法和优先级调度算法。

2.通过实验理解有关进程控制块,进程队列等的概念。

二、实验原理各调度算法思想:1.先来先服务算法(FCFS):按照进程进入就绪队列的先后次序来分配CPU,一旦一个进程占有CPU,就一直运行下去,知道该进程完成工作,才释放CPU。

2.时间片轮转算法:系统将所有就绪进程按到达时间的先后次序排成一个队列,进程调度程序总是选择队列中的第一个进程执行,且仅能执行一个时间片,在使用完一个时间片后,即使进程并未完成其运行,也必须将CPU交给下一个进程;如果一个时间片未使用完就完成了该进程,则剩下的时间分配给下一个进程。

3.优先权调度算法;在创建进程时就确定优先权,确定之后在整个程序运行期间不再改变,根据优先级排列,系统会把CPU分配给优先权最高的进程。

三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义:PCB块结构体类型struct PCB{int name;int arrivetime; // 到达时间int servicetime; // 服务时间//int starttime[max]; // 开始时间int finishtime; // 完成/ 结束时间int turntime; // 周转时间int average_turntime; // 带权周转时间int sign; // 标志进程是否完成int remain_time; // 剩余时间int priority; // 优先级}pcb[max];主程序的流程以及各程序模块之间的层次( 调用) 关系:主程序中从键盘得到进程的数量,创建PCB,调用layout ()函数显示选择界面。

Layout ()函数中选择相应的算法并调用相关函数如:FCFS()、time_segment(); Priority() ,这三个函数分别实现先来先服务算法,时间片轮转算法和优先级算法,最后分别打印。

第05讲进程调度PPT课件

第05讲进程调度PPT课件
2. 当一个进程运行完毕时; 3. 当一个进程由于I/O、信号量或其他的某个原
因被阻塞时; 4. 当一个I/O中断发生时,表明某个I/O操作已经
完成,而等待该I/O操作的进程转入就绪状态; 5. 在分时系统中,当一个时钟中断发生时。
11
两种调度方式
不可抢占调度方式:一个进程若被选中,就 一直运行下去,直到它被阻塞(I/O,或正在 等待其他的进程),或主动地交出CPU。以 上的情形1-3均可发生调度;
CPU
I/O
作业A
作业B
作业A 作业B
t0
t1 t2 t3 t4
时间
20
2. 短作业优先
短作业优先(Shortest Job First,SJF),设计 目标是改进FCFS算法,减少平均周转时间;
SJF算法要求作业在开始执行时预计执行时间, 对预计执行时间短的作业优先分派处理器;
两种实现方案:
• I/O设备的运行速度较慢,CPU的运行速度较 快,而且更新换代的速度快,将来进程都趋向 于I/O繁忙。
9
CPU繁忙还是I/O繁忙?(续)
• VCD播放软件; • WORD文字编辑器; • 磁盘碎片整理工具defrag。
10
3. 何时调度?
1. 当一个新的进程被创建时,是执行新进程还 是继续执行父进程?
如何知道作业的运行时间?
该时间只可能是一个估计值; 让提交该作业的用户来提供。不太实用; 使用前面的CPU运行时间来预测后面的CPU运
行时间,通过过去的行为来预测将来的行为。 如果一个作业已经运行很长时间了,那它可能
还会运行更长的时间; 使用指数平均值函数来预测下一段CPU时间;
25
指数平均值函数方法
8

操作系统实验二进程调度

操作系统实验二进程调度

实验二:进程调度一、目的要求:用C或C++语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.二、进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。

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

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪 W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。

就绪进程获得 CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。

重复以上过程,直到所要进程都完成为止。

三调度算法的流程图如下 :四、程序代码:#include<iostream>using namespace std;#define MAX 10struct task_struct{char name[10]; /*进程名称*/ int number; /*进程编号*/ float come_time; /*到达时间*/float run_begin_time; /*开始运行时间*/ float run_time; /*运行时间*/float run_end_time; /*运行结束时间*/ int priority; /*优先级*/int order; /*运行次序*/int run_flag; /*调度标志*/}tasks[MAX];int counter; /*实际进程个数*/int fcfs(); /*先来先服务*/int ps(); /*优先级调度*/int sjf(); /*短作业优先*/int hrrn(); /*响应比高优先*/int pinput(); /*进程参数输入*/int poutput(); /*调度结果输出*/void main(){int option;pinput();printf("请选择调度算法(0~4):\n");printf("1.先来先服务\n");printf("2.优先级调度\n");printf(" 3.短作业优先\n");printf(" 4.响应比高优先\n");printf(" 0.退出\n");scanf("%d",&option);switch (option){ case 0:printf("运行结束。

进程调度

进程调度

摘要进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程状态转换,它提供了在可运行的进程之间复用CPU的方法。

在进程管理中,进程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进程优先占用处理器。

本文通过两种算法模拟实现了进程之间的调度。

关键词:创建进程;先来先服务;优先级调度目录1.绪论 (1)2.模块伪码算法 (2)2.1结构类型定义和结构变量说明 (2)2.2函数定义 (2)2.3封装CPU调度与分配程序模块 (2)2.4cpu模拟运行函数 (3)2.5可强占的优先进程调度模式 (4)3.函数调用关系图 (7)3.1总体流程图 (7)3.2可强占优先调度算法实现过程流程图 (8)3.3先来先服务调度算法实现过程流程图 (9)4.测试结果及分析 (10)5.总结 (13)参考文献 (14)致谢 (15)附录 (16)1.绪论无论是批处理系统、分时系统还是实时系统,用户进程数一般都大于处理机数,这将导致用户进程互相争夺处理机。

这就要求进程调度程序按一定的策略,动态地把处理及分配给处于就绪队列中的某一进程,以使之执行。

进程调度是处理机管理的核心内容。

本实验要求采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念。

并体会了优先数和先来先服务调度算法的具体实施办法。

本程序采用两种算法(最高优先级数优先的调度算法和先来先服务算法)对多个进程进行调度,每个进程有三个状态,初始状态为就绪状态。

最高优先级数优先的调度算法中,程序的某进程运行时间以时间片为单位计算。

各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。

在优先级数优先的调度算法中,优先级数的值设计为100与运行时间的差值,即Pro_time-process->needtime。

进程调度算法实验报告

进程调度算法实验报告

操作系统实验报告(二)实验题目:进程调度算法实验环境:C++实验目的:编程模拟实现几种常见的进程调度算法,通过对几组进程分别使用不同的调度算法,计算进程的平均周转时间和平均带权周转时间,比较各种算法的性能优劣。

实验内容:编程实现如下算法:1.先来先服务算法;2.短进程优先算法;3.时间片轮转调度算法。

设计分析:程序流程图:1.先来先服务算法2.短进程优先算法3.时间片轮转调度算法实验代码:1.先来先服务算法#include <iostream.h>#define n 20typedef struct{int id; //进程名int atime; //进程到达时间int runtime; //进程运行时间}fcs;void main(){int amount,i,j,diao,huan;fcs f[n];cout<<"请输入进程个数:"<<endl;cin>>amount;for(i=0;i<amount;i++){cout<<"请输入进程名,进程到达时间,进程运行时间:"<<endl; cin>>f[i].id;cin>>f[i].atime;cin>>f[i].runtime;}for(i=0;i<amount;i++) //按进程到达时间的先后排序{ //如果两个进程同时到达,按在屏幕先输入的先运行for(j=0;j<amount-i-1;j++){ if(f[j].atime>f[j+1].atime){diao=f[j].atime;f[j].atime=f[j+1].atime;f[j+1].atime=diao;huan=f[j].id;f[j].id=f[j+1].id;f[j+1].id=huan;}}}for(i=0;i<amount;i++){cout<<"进程:"<<f[i].id<<"从"<<f[i].atime<<"开始"<<","<<"在"<<f[i].atime+f[i].runtime<<"之前结束。

第8章 进程调度

第8章 进程调度
❖ 假定当前系统中没有两个进程具有相同的优先权以及其后 也没有其他进程进入就绪队列,如果prit(pk)< prit(pi),pk运 行,pi等待,则有
Tw(pi) = ∑Ω 。
▪ 显然一个进程的期望等待时间是指一个
进程花在就绪队列中的平均等待服务的 时间。
4
4.0
1
5.0
4
P3
P2
P4
78
12
16
▪平均等待时间 = (0 + 6 + 3 + 7)/4 = 4
强占SJF的实例
▪ 强占SJF调度算法
进程 P1 P2 P3 P4
▪ Gantt 图表如下 :
到达时间 0.0 2.0 4.0 5.0
需要服务时间 7 4 1 4
P1
P2 P3 P2
P4
时间 0 2
FCFS 和SJF例题
[例8.1]: 试分别计算图8.2(a)和(b)所示的就绪队列中 进程的期望周转时间和期望等待时间。 假定就绪
队列中有4个进程,如下图所示:
进程 服务时间
p0
30
p1
10
p2
40
p3
20
▪ 下面分别计算图8.2(a)和(b)中所示的就绪队列中进程的期望
周转时间和期望等待时间。
列,因为它要求进程的抵达速度和CPU 的运行速度一样快,目前系统还不能长 期这样运行。
8.2 非强占方式调度算法
▪ 非强占调度算法是不强迫一个已经分配到CPU的进
程改变就绪状态。
▪ 在非强占调度算法的系统中不存在从CPU直接返回
到就绪队列的路径。见附图1。
返回就绪队列的路径
就绪队列

调度程序

操作系统单处理机系统的进程调度

操作系统单处理机系统的进程调度

操作系统单处理机系统的进程调度第一篇:操作系统单处理机系统的进程调度一.实验内容描述1.目的(1)了解Windows内存管理器(2)理解Windows的地址过程2.内容任意给出一个虚拟地址,通过WinDbg观察相关数据并找到其物理地址二.理论分析Windows采用页式虚拟存储管理技术管理内存,页面是硬件级别上的最小保护单位 1.Windows内存管理器Windows的内存管理主要由Windows执行体中的虚存管理程序负责,并由环境子系统负责,并由环境子系统负责与具体API相关的一些用户态特性的实现。

虚存管理程序是Windows中负责内存管理的那些子程序和数据结构的集合内存管理器的主要任务是:地址变换:将一个进程的虚拟地址空间转译为物理内存地址交换:当内存不足时,将内存中的有些内容转移到磁盘上,并且以后还要再次将这些内容读回2.Windows内存管理策略Windows采用页式虚拟存储管理技术管理内存,页面是硬件级别上最小的保护单位。

根据硬件的体系结构不同,页面尺寸被分为两种,大页面和小页面。

X86系统下小页面为4KB,大页面为4MB。

大页面的优点是:当引用同一页面内其他数据时,地址转移的速度会很快。

不过使用大页面通常要较大的内存空间,而且必须用一个单独的保护项来映射,因此可能会造成出现错误而不引发内存访问违例的情况。

通常PC机都为小页面 3.Windows虚拟地址空间布局 x86结构下的布局方式:默认情况下,32位Windows系统中每个用户进程可以占有2GB 的私有地址空间。

操作系统占有另外的2GB 2GB用户的进程地址空间布局如表:2GB的系统地址空间布局如同:3.虚拟地址转译地址转译是指将进程的虚拟地址空间映射到实际物理页面的过程。

x86系统中地址转译过程如图:关键数据结构如下:页目录:每个进程都有一个页目录,它是内存管理器为了映射进程中所有的页表位置而创建的一个页面。

进程也目录的地址被保存在内核进程快KPROCESS中,在x86系统上,它被映射到虚拟地址0xC0300000,当一个进程正在执行时,CPU可以通过寄存器CR3知道该进程页目录的位置。

操作系统第13讲:第4章 处理机调度调度算法.ppt

操作系统第13讲:第4章 处理机调度调度算法.ppt
(4) 尽力而为调度算法类:这一类算法不进行可能性分析,只 对到达的事件和相关任务指定相应的优先级,并进行调度。 尽力而为调度方式开销较小,实现容易。但是,该算法不一 定满足用户要求的处理时限。
2019/10/31
18
4.6 实时系统调度方算法简介
四、时限调度算法
导语:基本思想是:按用户的时限要求顺序设置优先级,优先
●实时系统所处理的外部任务可分为周期性的与非周期性的两大类。非周期性 任务,存在有一个完成或开始进行处理时限;而周期性任务要求在周期T内 完成或开始进行处理。
2019/10/31
13
4.6 实时系统调度算法简介
一、实时系统的特点
1.有限等待和响应时间(决定性) 2.可靠性高 3.用户可以控制 4.系统纠错能力强,实时系统要求很高的可靠性。
导语:
●实时系统广泛用在移动通信、网络计算、航空航天等领域。os是实时系统中 最重要的部分之一,它负责在用户要求的时限内进行事件处理和控制。
●实时系统与其他系统的最大区别:处理和控制的正确性不仅取决于计算的逻 辑结果,而且取决于计算和处理结果产生的时间。因此,实时系统的调度, 即把给定的任务,按所要求的时限调配到相应的设备上处理完成。根据实 时系统对处理外部事件的时限要求,分为硬、软实时任务。 ◆硬实时任务要求系统必须完全满足任务的时限要求。 ◆软实时任务允许时限要求有一定的延迟,时限要求只是一个相对条件。
注意P90: 周转T、完成T、提交T、带权周转T等概念在公式中的含义。 ●分析结论:P3 执行的时间非常短,但等待时间过长,显然是不合理的。
2019/10/31
3
4.4 调度算法
二、短作业或短进程调度算法(SJF)
1. 适应范围:作业或进程 2. 原则:选取最短作业或进程进行执行 3. 优点:当短作业或短进程较多时,系统效率较高 4. 缺陷:对长作业不利,设有考虑优先级

设计一个有N个进程共行的进程调度程序

设计一个有N个进程共行的进程调度程序

一、目的要求用高级语言‎编写和调试‎一个进程调‎度程序,以加深对进‎程的概念及‎进程调度算‎法的理解.二、实验题:设计一个有‎N个进程共‎行的进程调‎度程序。

进程调度算‎法:采用最高优‎先数优先的‎调度算法(即把处理机‎分配给优先‎数最高的进‎程)和先来先服‎务算法。

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

进程控制块‎可以包含如‎下信息:进程名、优先数、到达时间、需要运行时‎间、已用CPU‎时间、进程状态等‎等。

进程的优先‎数及需要的‎运行时间可‎以事先人为‎地指定(也可以由随‎机数产生)。

进程的到达‎时间为进程‎输入的时间‎。

进程的运行‎时间以时间‎片为单位进‎行计算。

每个进程的‎状态可以是‎就绪 W(Wait)、运行R(Run)、或完成F(Finis‎h)三种状态之‎一。

就绪进程获‎得 CPU后都‎只能运行一‎个时间片。

用已占用C‎P U时间加‎1来表示。

如果运行一‎个时间片后‎,进程的已占‎用 CPU时间‎已达到所需‎要的运行时‎间,则撤消该进‎程,如果运行一‎个时间片后‎进程的已占‎用CPU时‎间还未达所‎需要的运行‎时间,也就是进程‎还需要继续‎运行,此时应将进‎程的优先数‎减1(即降低一级‎),然后把它插‎入就绪队列‎等待CPU‎。

每进行一次‎调度程序都‎打印一次运‎行进程、就绪队列、以及各个进‎程的 PCB,以便进行检‎查。

重复以上过‎程,直到所要进‎程都完成为‎止。

三、实验参考:调度算法的‎流程图如下‎:进程调度源‎程序如下:jingc‎h endi‎a odu.cpp#inclu‎d e "stdio‎.h"#inclu‎d e <stdli‎b.h>#inclu‎d e <conio‎.h>#defin‎e getpc‎h(type) (type*)mallo‎c(sizeo‎f(type)) #defin‎e NULL 0struc‎t pcb { /* 定义进程控‎制块PCB‎*/char name[10];char state‎;int super‎;int ntime‎;int rtime‎;struc‎t pcb* link;}*ready‎=NULL,*p;typed‎e f struc‎t pcb PCB;sort() /* 建立对进程‎进行优先级‎排列函数*/{PCB *first‎, *secon‎d;int inser‎t=0;if((ready‎==NULL)||((p->super‎)>(ready‎->super‎))) /*优先级最大‎者,插入队首*/{p->link=ready‎;ready‎=p;}else /* 进程比较优‎先级,插入适当的‎位置中*/{first‎=ready‎;secon‎d=first‎->link;while‎(secon‎d!=NULL){if((p->super‎)>(secon‎d->super‎)) /*若插入进程‎比当前进程‎优先数大,*/ { /*插入到当前‎进程前面*/p->link=secon‎d;first‎->link=p;secon‎d=NULL;inser‎t=1;}else /* 插入进程优‎先数最低,则插入到队‎尾*/{first‎=first‎->link;secon‎d=secon‎d->link;}}if(inser‎t==0) first‎->link=p;}}input‎() /* 建立进程控‎制块函数*/{int i,num;clrsc‎r(); /*清屏*/print‎f("\n 请输入进程‎号?");scanf‎("%d",&num);for(i=0;i<num;i++){print‎f("\n 进程号No‎.%d:\n",i);p=getpc‎h(PCB);print‎f("\n 输入进程名‎:");scanf‎("%s",p->name);print‎f("\n 输入进程优‎先数:");scanf‎("%d",&p->super‎);print‎f("\n 输入进程运‎行时间:");scanf‎("%d",&p->ntime‎);print‎f("\n");p->rtime‎=0;p->state‎='w';p->link=NULL;sort(); /* 调用sor‎t函数*/}}int space‎(){int l=0; PCB* pr=ready‎;while‎(pr!=NULL){l++;pr=pr->link;}retur‎n(l);}disp(PCB * pr) /*建立进程显‎示函数,用于显示当‎前进程*/{print‎f("\n qname‎\t state‎\t super‎\t ndtim‎e \t runti‎m e \n"); print‎f("|%s\t",pr->name);print‎f("|%c\t",pr->state‎);print‎f("|%d\t",pr->super‎);print‎f("|%d\t",pr->ntime‎);print‎f("|%d\t",pr->rtime‎);print‎f("\n");}check‎() /* 建立进程查‎看函数 */{PCB* pr;print‎f("\n **** 当前正在运‎行的进程是‎:%s",p->name); /*显示当前运‎行进程*/disp(p);pr=ready‎;print‎f("\n ****当前就绪队‎列状态为:\n"); /*显示就绪队‎列状态*/ while‎(pr!=NULL){disp(pr);pr=pr->link;}}destr‎o y() /*建立进程撤‎消函数(进程运行结‎束,撤消进程)*/ {print‎f("\n 进程 [%s] 已完成.\n",p->name);free(p);}runni‎n g() /* 建立进程就‎绪函数(进程运行时‎间到,置就绪状态‎*/ {(p->rtime‎)++;if(p->rtime‎==p->ntime‎)destr‎o y(); /* 调用des‎t roy函‎数*/else{(p->super‎)--;p->state‎='w';sort(); /*调用sor‎t函数*/}}main() /*主函数*/{int len,h=0;char ch;input‎();len=space‎();while‎((len!=0)&&(ready‎!=NULL)){ch=getch‎a r();h++;print‎f("\n The execu‎t e numbe‎r:%d \n",h);p=ready‎;ready‎=p->link;p->link=NULL;p->state‎='R';check‎();runni‎n g();print‎f("\n 按任一键继‎续......");ch=getch‎a r();}print‎f("\n\n 进程已经完‎成.\n");ch=getch‎a r();}四.选做题:.编写并调试‎一个模拟的‎进程调度程‎序,采用“最高优先数‎优先”调度算法对‎五个进程进‎行调度。

短作业优先算法

短作业优先算法

短作业(进程)优先调度算法1.短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。

它们可以分别用于作业调度和进程调度。

短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。

而短进程(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机再重新调度。

SJ(P)F调度算法能有效地降低作业(进程)的平均等待时间,提高系统吞吐量。

该算法对长作业不利,完全未考虑作业的紧迫程度。

2.流程图3.代码#include<iostream.h>#include<string.h>#include<stdlib.h>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<N;k++){printf("-->%s",p[k].name);}printf("\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].na me,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime, p[k].zztime,p[k].dqzztime);}}//pai xuvoid sort(sjf *p,int N){for(int i=0;i<=N-1;i++)for(int j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//yun xing jieduanvoid deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N) { int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void sjff(sjf *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dq zztime=0;sort(p,N);for(int m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}float min=p[m+1].servicetime;int next=m+1;//m+1=nfor(int k=m+1;k<m+i;k++){if(p[k+1].servicetime<min){min=p[k+1].servicetime;next=k+1;}}sjf temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime, N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime ,N);}int main(){ int N;printf("------短作业优先调度算法------\n");printf("input the process's number:\n");scanf("%d",&N);input(a,N);sjf *b=a;sjf *c=a;sjff(b,N);system("PAUSE");}4.运行结果5.心得体会课程设计结束了,在这次的课程设计中不仅检验了我所学习的知识,也培养了我如何去做一件事情,又如何完成一件事情的能力。

Java实现进程调度算法(二)RR(时间片轮转)

Java实现进程调度算法(二)RR(时间片轮转)

Java实现进程调度算法(⼆)RR(时间⽚轮转)⼀、概述 因为这次os作业对⽤户在控制台的输⼊输出有要求,所以我花了挺多的代码来完善控制台的显⽰。

也因为我这次要实现多个类似算法,所以将⼀些共性单独提取出来作为⼀个类。

如果只想要和算法有关的核⼼代码,看RR类的calc()即可。

实现思路:每运⾏⼀个进程,则将所有进程的remainServiceTime减去⼀个时间⽚的长度。

⼆、运⾏结果 1. 测试数据: 2. 运⾏结果:三、流程图四、实现代码 1. RR类(主类)只有calc()中涉及了算法,init()和printResult()只有简单的输⼊输出操作。

1package xqy.algorithm;23import java.util.*;45import xqy.Util.Tools;6import xqy.been.Process;78/**9 * @author xqy10 * @date 2018年12⽉19⽇19:14:4911*/12public class RR {13private int processNumber;14private ArrayList<Process> processList;15private int timeSlice;1617public RR() {18 init();19 calc();20 Tools.printResult(processList);21 }2223private void init() {24 Scanner sc = new Scanner(System.in);2526 System.out.print("<RR> Please enter the slice time:");27 timeSlice = sc.nextInt();28 System.out.print("<RR> please enter the process num:");29 processNumber = sc.nextInt();3031 processList = new ArrayList<Process>();32for (int i = 0; i < processNumber; i++) {33 processList.add(new Process());34 }3536 System.out.println("<RR> Please enter each process arrival time:");37for (int i = 0; i < processNumber; i++) {38 System.out.print(" Process" + (i + 1) + ":");39 processList.get(i).setArrivalTime(sc.nextInt());40 }4142 System.out.println("<RR> Please enter each process service time:");43for (int i = 0; i < processNumber; i++) {44 System.out.print(" Process" + (i + 1) + ":");45int servicesTime = sc.nextInt();4647 processList.get(i).setServicesTime(servicesTime);48 processList.get(i).setRemainServiceTime(servicesTime);49 }50 }5152private void calc() {53int timeNow = 0;54int processRemain = processNumber;55boolean noProcessRunInThisTurn;56 Process opProcess;5758while (processRemain != 0) {59 noProcessRunInThisTurn = true;6061for (int i = 0; i < processNumber; i++) {62 opProcess = processList.get(i);6364if ((opProcess.getRemainServiceTime() > 0)65 && (timeNow >= opProcess.getArrivalTime())) {66// First time67if (opProcess.getServicesTime() == opProcess68 .getRemainServiceTime()) {69int waitTime = timeNow - opProcess.getArrivalTime();7071 opProcess.setStartTime(timeNow);72 opProcess.setWaitTime(waitTime);73 }7475// Calculating remain service time76int remainServiceTime = opProcess.getRemainServiceTime()77 - timeSlice;78 opProcess.setRemainServiceTime(remainServiceTime);7980// Last time81if (remainServiceTime <= 0) {82int completionTime = timeNow + timeSlice; // The process ends when the current slice is completed. 83int turnAroundTime = completionTime84 - opProcess.getArrivalTime();85double turnAroundTimeWithWeight = 1.0 * turnAroundTime86 / opProcess.getServicesTime();8788 opProcess.setCompletionTime(completionTime);89 opProcess.setTurnAroundTime(turnAroundTime);90 opProcess91 .setTurnAroundTimeWithWeight(turnAroundTimeWithWeight);92 processRemain--;93 }9495 timeNow += timeSlice;96 noProcessRunInThisTurn = false;9798 System.out.println(" #STEP# Process" + (i + 1)99 + " remain service time:"100 + opProcess.getRemainServiceTime()101 + " , timeBefore:" + (timeNow - 1) + ", timeNow:"102 + timeNow103 + ((remainServiceTime <= 0) ? " Finish" : ""));104 } else {105// do noting, because this process has been completed or hasn`t arrived.106 }107 }108109// Means no process could run, because they have arrived.110if ((processRemain > 0) && noProcessRunInThisTurn) {111 timeNow += timeSlice;112 }113 }114 }115 } 2. Process类模拟了进程,对属性进⾏了封装。

《进程调度》PPT课件

《进程调度》PPT课件

4 Linux中的进程管理
– 4.1 Linux进程概述 • 1.进程实体的组成
• Linux进程由3部分组成:正文段、用户数 据段和系统数据段。

进 程
统 数 据

正文段 用户数据段
图 Linux进程组成
• 2.进程的状态 • 进程是一个动态的概念,在其运行的整个生
命周期中可根据具体情况不断改变其状态。 Linux进程主要有如下几种状态。
wait_interruptible
申请资源未成功 sleep_on() schedule()
拥有CPU
申请资源未成功 interruptible_sleep_on() schedule()
跟踪系统调用 执行syscall_trace() sys_exit() schedule()
Linux内核功能
进程调度与内存管理之间的关系:这两个子系统互 相依赖。在多道程序环境下,程序要运行必须为之 创建进程,而创建进程的第一件事情,就是将程序 和数据装入内存。
进程间通信与内存管理的关系:进程间通信子系统 要依赖内存管理支持共享内存通信机制,这种机制 允许两个进程除了拥有自己的私有空间,还可以存 取共同的内存区域 。
这种暂停状态被称为阻塞状态。
• 2.进程的状态转换 图1 进程的3种基本状态及其转换
1.4 进程的结构
• 进程结构 PCB
进程控制块
程序段 数据段
动态特征的集中反映 描述要完成的功能 操作对象及工作区
2.进程控制块
• 进程控制块是进程实体的一部分,是操作
系统中最重要的记录型数据结构。PCB中记录 了操作系统所需的,用于描述进程进展情况及 控制进程运行所需的全部信息。
在一个系统中,通常拥有数十个、数百 个乃至数千个PCB。为了对PCB进行有 效地管理,系统应把所有的PCB用适当 的方式组织起来。

设计一个按优先数调度算法实现处理器调度的程序可以输入进程的数量

设计一个按优先数调度算法实现处理器调度的程序可以输入进程的数量

题目:设计一个按优先数调度算法实现处理器调度的程序(可以自己定义进程的数量)提示:(1)假定系统有5个进程,每个进程用一个PCB来代表。

PCB的格式为:进程名、指针、要求运行时间、优先数、状态。

进程名——P1~P5。

指针——按优先数的大小把5个进程连成队列,用指针指出下一个进程PCB的首地址。

要求运行时间——假设进程需要运行的单位时间数。

优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。

状态——假设两种状态,就绪,用R表示,和结束,用E表示。

初始状态都为就绪状态。

(2) 每次运行之前,为每个进程任意确定它的“优先数”和“要求运行时间”。

(3) 处理器总是选队首进程运行。

采用动态改变优先数的办法,进程每运行1次,优先数减1,要求运行时间减1。

(4) 进程运行一次后,若要求运行时间不等于0,则将它加入队列,否则,将状态改为“结束”,退出队列。

(5) 若就绪队列为空,结束,否则,重复(3)。

2.流程图:(1)主程序流程图:始开调用初始化子程序调用运行子程序束结init()流程图:(2)子程序始开i定i=0i<num输出操作提ID,pri,runtime输stategetchar()i=i+1结束流程图:max_pri_process()子程序(3)开始i,key,max=100定i=0i<numpcblist[i].state=return -1max<pcblist[i].pri&&cblist[i].state=='R'key=imax=pcblist[i].prii=i+1pcblist[key].state=='F' keyreturnreturn -1结流程图:show()子程序(4).开i定输出提i=0i<numpcblist[iID,pri,runtime,state 提示按键继i=i+1结(5)子程序run()流程图:开始i,j,t定j=0j<numt+=pcblist[j].runtimej=j+1输出提(shogetchar()j=0j<tmax_pri_process()!=-1pcblist[max_pri_process()].state='r'i=0i<numpcblist[i].state=='pcblist[i].runtime-- pcblist[i].pri-=1pcblist[i].runtime==0pcblist[i].state='pcblist[i].state='getchar()show()i=i+1j=j+13.源程序清单///按优先数调度算法实现处理器调度的程序#include stdio.h#include string.hint num;struct PCB{char name;//进程名int runtime;//要求运行时间int pri;//优先数char state;//状态,R-就绪,F-结束};struct PCB pcblist[100];//定义进程控制块数组void init()//PCB初始化子程序{int i;for(i=0;i<num;i++){printf(PCB[%d]:进程名优先级运行时间\n,i+1);//为每个进程任意指定pri和runtime scanf(%s%d%d, &pcblist[i].name, &pcblist[i].pri, &pcblist[i].runtime);pcblist[i].state='R';//进程初始状态均为就绪getchar();//接收回车符}}int max_pri_process()//确定最大优先级进程子程序{int max=-100;//max为最大优先数,初始化为-100int i;int key;for(i=0;i<num;i++){if(pcblist[i].state=='r')//r为辅助状态标志,表示正在运行return -1;//返回-1elseif(max<pcblist[i].pri&&pcblist[i].state=='R')//从就绪进程中选取优先数最大的进程{max=pcblist[i].pri;//max存放每次循环中的最大优先数key=i;//将进程号赋给key}}具有最大优先数的进程若已运行完毕if(pcblist[key].state=='E')//return -1;//则返回-1elsereturn key;//将key作为返回值返回}void show()//显示子程序{int i;printf(\***进程名优先级运行时间状态***\n);printf(-------------------------------------------------\n);for(i=0;i<num;i++)//依次显示每个进程的名、优先数、要求运行时间和状态{printf(*** %s m ? %s***\n, &pcblist[i].name, pcblist[i].pri,pcblist[i].runtime, &pcblist[i].state);}牰湩晴尨按任意键继续...\n);}void run()//进程运行子程序{int i,j;int f;int h;int g;int t=0;//t为运行次数for(j=0;j<num;j++){t+=pcblist[j].runtime;}//运行次数即为各个进程运行时间之和printf(\处理之前的状态:\n);show(); //调用show()子程序显示运行前PCB的情况getchar();//等待输入回车符f=t;g=t;for(j=0;j<t;j++){while(max_pri_process()!=-1)//具有最大优先数的进程没有运行完,让其运行{pcblist[max_pri_process()].state='r';//将其状态置为r,表示其正在运行}for(i=0;i<num;i++){if(pcblist[i].state=='r'){ if(pcblist[i].pri>=1) pcblist[i].pri-=1;//将当前运行进程的优先数减1 pcblist[i].runtime--;{if(pcblist[i].runtime==0)pcblist[i].state='E';//运行完则将该进程状态置为结束elsepcblist[i].state='R';//未运行完将其状态置为就绪}h=f-(--g);,h);运行%d这是第牰湩晴尨show();//显示每次运行后各PCB的情况getchar();//等待回车进入下一次运行}}}}void main()//按动态优先数调度主程序{ 牰湩晴尨请输入要运行进程的数目:);scanf(%d,&num);//输入进程数init();//初始化各个进程PCBrun(); //进程调度模拟}。

实验报告操作系统实验一进程调度.doc

实验报告操作系统实验一进程调度.doc

计算机电子信息工程学院实验报告成绩________ 课程名称操作系统指导教师杨秀华实验日期 2011年9月15、22、29,10月12院(系)计算机学院专业班级09计算机应用实验地点 B-4009学生姓名学号实验项目名称实验一模拟设计进程调度一、实验目的和要求用C或C++语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.二、实验原理进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。

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

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪 W(Wait)、运行R(Run)状态之一。

就绪进程获得 CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。

重复以上过程,直到所要进程都完成为止。

三、主要仪器设备或材料PC机,C++环境四、实验方法与步骤(可加附页)1、主要数据结构:struct pcb { /* 定义进程控制块PCB */char name[10]; //进程名字char state; //进程状态int super; //进程的优先级int ntime; //进程需要运行的时间int rtime; //进程已经运行的时间struct pcb* link; }2、调度算法的流程图如上图 :五、实验数据记录、处理及结果分析六、讨论、心得计算机电子信息工程学院实验报告(附页)程序参考代码:参考代码:#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct 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;printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;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 qname \t state \t super \t ndtime \t runtime \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); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}Void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{3 / 4printf("\n 进程 [%s] 已完成.\n",p->name);free(p);}Void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}Void main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}知识改变命运。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
相关文档
最新文档