实验4-进程调度算法的实现
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。
其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。
在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。
2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。
3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。
实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。
因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。
同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。
进程调度算法的实现实验报告记录
进程调度算法的实现实验报告记录————————————————————————————————作者:————————————————————————————————日期:南昌大学实验报告---(4)进程调度算法的实现学生姓名:学号:专业班级:实验类型:□验证□综合■设计□创新实验日期:实验成绩:一、实验目的通过实验加强对进程调度算法的理解和掌握。
二、实验内容编写程序实现进程调度算法,具体可以编写程序实现先来先服务算法或优先度高者调度算法。
三、实验要求1、需写出设计说明;2、设计实现代码及说明;3、运行结果;四、主要实验步骤1、分析实验内容,画出算法流程图;2、根据流程图写出实验代码;3、编译代码,验证结果正确与否;4、对程序进行修改,得到最后结果。
流程图如下:开始系统随机产生数据将数据按照到达时间从小到大排序用户输入数据进程到达时前一个进程是否已经完成完成时间=服务时间+前一个进程完成时间完成时间=服务时间+到达时间周转时间=完成时间-到达时间带权周转时间=完成时间/服务时间是否所有进程已完成计算输出结果结束YN YN YN五、实验数据及处理结果六、实验体会或对改进实验的建议在做这个实验的时候,一开始以为很简单,只要做简单的加减乘除就行了,但是仔细做过以后发现需要考虑很多情况。
比如说输入进程到达时间的时候,要是乱序的该怎么办?还有到达时间和服务时间等等定义的都是整型变量,但是带权周转时间确会得到小数,此时就需要用到强制转换。
在做系统产生随机数的时候也要考虑随机数的范围,如到达时间可以为0,但是服务时间却不能为0,否则带权周转时间的计算会出错。
七、参考资料《计算机操作系统》《计算机操作系统实验指导书》《C程序设计》《C语言程序设计_现代方法》八、实验代码#include <stdio.h>#include <stdlib.h>#include <time.h>#define N 5 //进程个数,可改变int rt[N]; //到达时间int st[N]; //服务时间int ct[N]; //完成时间int cyt[N]; //周转时间float rct[N]; //带权周转时间float av[2];int n,m,c=1,which;void line() //美化程序,使程序运行时更加明朗美观{printf("------------------------------------------------------------------\n");}void start() //表示FCFS算法开始{line();printf(" FCFS算法开始\n");printf(" ——Designed by Zhang Hong\n"); line();}void end() //表示FCFS算法结束{line();printf(" FCFS算法结束,谢谢使用\n");line();}void input(){printf("请输入%d个进程的到达时间:",N);for (n=0;n<N;n++)scanf("%d",&rt[n]);printf("请输入%d个进程对应的服务时间:",N);for (n=0;n<N;n++)scanf("%d",&st[n]);}void random(){srand((unsigned)time(NULL));for (n=0;n<N;n++){rt[n]=rand()%100;for (m=0;m<n;m++)if (n!=0 && rt[n]==rt[m]){rt[n]=rand()%100;m=0;}st[n]=rand()%98+1;for (m=0;m<n;m++)if (n!=0 && st[n]==st[m]){st[n]=rand()%98+1;m=0;}}}void ordination() //重新排序,应对出现输入的到达时间为乱序的情况{int temp;for (n=0;n<N;n++)for (m=0;m<N-n-1;m++)if (rt[m+1]<rt[m]){temp=rt[m+1];rt[m+1]=rt[m];rt[m]=temp;temp=st[m+1];st[m+1]=st[m];st[m]=temp;}}void fcfs() //执行fcfs算法{av[0]=0;av[1]=0;ct[0]=rt[0]+st[0];for (n=1;n<N;n++){if (ct[n-1]>=rt[n]) //考虑当前一个进程完成而后一个进程还没有到达的情况ct[n]=ct[n-1]+st[n];elsect[n]=rt[n]+st[n];}for (n=0;n<N;n++)cyt[n]=ct[n]-rt[n];for (n=0;n<N;n++)rct[n]=(float)cyt[n]/(float)st[n];for (n=0;n<N;n++){av[0]+=(float)cyt[n]/N;av[1]+=rct[n]/N;}}void output() //输出结果{line();printf("进程名\t");for (n=0;n<N;n++)printf("\t%c",65+n);printf("\t平均\n到达时间");for (n=0;n<N;n++)printf("\t%d",rt[n]);printf("\n服务时间");for (n=0;n<N;n++)printf("\t%d",st[n]);printf("\n完成时间");for (n=0;n<N;n++)printf("\t%d",ct[n]);printf("\n周转时间");for (n=0;n<N;n++)printf("\t%d",cyt[n]);printf("\t%0.1f",av[0]);printf("\n带权周转时间");for (n=0;n<N;n++)printf("\t%0.1f",rct[n]);printf("\t%0.1f",av[1]);printf("\n");line();}void main(){start();for (;c==1;){for (;;){printf("输入数据还是由系统随机产生数据?\n1、输入数据\t2、系统随机产生数据\n请输入:");scanf("%d",&which);if (which==1){input();break;}elseif (which==2){random();break;}printf("输入错误,请重新输入!");}ordination(); //进程按照到达时间进行排序fcfs();output();printf("继续输入,退出输入。
进程调度算法实验报告
一、实验目的多道程序系统中,当就绪进程数大于处理机数时,须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现进程调度,以加深对进程概念和不同进程调度算法的理解。
二、实验环境1.PC微机。
2.Windows 操作系统。
3.C/C++/VB等开发集成环境。
三、实验内容与步骤编程实现如下进程调度算法:1)时间片轮转调度算法:时间片长度在运行时可从键盘输入。
2)多级反馈队列调度算法:至少要有三个队列,第i+1队列进程运行的时间片是第i队列的2倍。
3)高响应比优先调度算法:当调度响应比高的进程运行时,仍然是运行一个时间片,而不是完全结束,刚运行的进程,其以前的等待时间清零。
实现提示:(1)PCB数据结构(参考)PCB 至少包括:进程标识符、进程名、到达时间、服务时间、等待时间、完成时间、响应比等(可根据不同的算法增减)。
假设多个PCB 利用链接方式进行组织。
(2)主要功能模块(参考)●进程初始化;●显示初始化后进程的基本信息;●时间片轮转调度算法;●多级反馈队列调度算法;●高响应比优先调度算法;输入要求:可将进程初始化信息事先存入文件中,程序运行从文件中读取信息,避免从键盘输入速度慢且易出错。
输出要求:每种调度算法每次调度后应直观显示,进程调度的依据、各进程的各项参数。
每种调度算法运行结束后,输出各个进程对应的完成时间、周转时间和带权周转时间,以及整体的平均带权周转时间。
四、实验结果与分析(1)程序的框架说明(2)各调度算法的设计思想1、时间片轮转算法该算法采取了非常公平的方式,即让就绪队列上的每个进程每次仅运行一个时间片。
如果就绪队列上有N个进程,则每个进程每次大约都可获得1/N的处理机时间。
时间片的大小对于系统性能有很大的影响。
若选择很小的时间片,将有利于短作业,但意味着会频繁地执行进程调度和进程上下文的切换,这无疑会增加系统的开销。
反之,若时间片选择得太长,且为使每个进程都能在一个时间片内完成,RR算法便退化为FCFS算法,无法满足短作业和交互式用户的需求。
实验进程调度的实验报告
一、实验目的1. 加深对进程概念和进程调度算法的理解。
2. 掌握进程调度算法的基本原理和实现方法。
3. 培养编程能力和系统分析能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块(PCB)3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一,负责将CPU分配给就绪队列中的进程。
常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、优先级调度、时间片轮转(RR)等。
1. 先来先服务(FCFS)算法:按照进程到达就绪队列的顺序进行调度。
2. 短作业优先(SJF)算法:优先调度运行时间最短的进程。
3. 优先级调度算法:根据进程的优先级进行调度,优先级高的进程优先执行。
4. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行,时间片结束后进行调度。
五、实验步骤1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、运行时间、优先级、状态等信息。
2. 创建进程队列,用于存储就绪队列、等待队列和完成队列。
3. 实现进程调度算法:a. FCFS算法:按照进程到达就绪队列的顺序进行调度。
b. SJF算法:优先调度运行时间最短的进程。
c. 优先级调度算法:根据进程的优先级进行调度。
d. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行。
4. 模拟进程调度过程:a. 初始化进程队列,将进程添加到就绪队列。
b. 循环执行调度算法,将CPU分配给就绪队列中的进程。
c. 更新进程状态,统计进程执行时间、等待时间等指标。
d. 当进程完成时,将其移至完成队列。
六、实验结果与分析1. FCFS算法:按照进程到达就绪队列的顺序进行调度,简单易实现,但可能导致短作业等待时间过长。
2. SJF算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。
进程调度 实验报告
进程调度实验报告进程调度实验报告概述:进程调度是操作系统中一个重要的组成部分,它负责决定在多个进程同时运行时,每个进程分配到的CPU时间片以及切换进程的时机。
合理的进程调度算法能够提高系统的性能和资源利用率,因此对进程调度的研究和优化具有重要意义。
1. 背景介绍进程调度是操作系统中的一个关键任务,它负责管理和控制多个进程的执行顺序,以实现对CPU的合理分配。
在多道程序设计环境下,进程调度的作用尤为重要。
进程调度算法的好坏直接影响着系统的性能和响应速度。
2. 进程调度算法2.1 先来先服务(FCFS)先来先服务是最简单的调度算法之一,它按照进程到达的先后顺序进行调度,即先到达的进程先执行,直到该进程执行完成或者发生I/O操作。
FCFS算法的优点是公平且易于实现,但是它无法适应不同进程的执行时间差异,可能导致长作业效应。
2.2 最短作业优先(SJF)最短作业优先调度算法是根据进程的执行时间长度来进行调度,执行时间越短的进程越优先执行。
SJF算法能够最大程度地减少平均等待时间,但是它需要预先知道进程的执行时间,这在实际应用中往往是不可行的。
2.3 时间片轮转(RR)时间片轮转是一种经典的调度算法,它将CPU的执行时间划分为若干个时间片,每个进程在一个时间片内执行,如果时间片用完还没有执行完,则将该进程放入就绪队列的末尾,继续执行下一个进程。
RR算法能够保证每个进程都能获得公平的CPU时间,但是对于长时间执行的进程,会导致较大的上下文切换开销。
3. 实验设计与结果分析为了评估不同进程调度算法的性能,我们设计了一系列实验。
首先,我们使用不同的进程到达时间和执行时间生成一组测试数据。
然后,分别使用FCFS、SJF和RR算法进行调度,并记录每个进程的等待时间和周转时间。
最后,我们对实验结果进行分析。
实验结果显示,FCFS算法对于执行时间较长的进程会出现较长的平均等待时间,而SJF算法能够有效减少平均等待时间。
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验,加深对操作系统进程调度原理的理解,掌握先来先服务(FCFS)、时间片轮转(RR)和动态优先级(DP)三种常见调度算法的实现,并能够分析这些算法的优缺点,提高程序设计能力。
二、实验环境- 编程语言:C语言- 操作系统:Linux- 编译器:GCC三、实验内容本实验主要实现以下内容:1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法:FCFS、RR和DP。
3. 创建一个进程队列,用于存储所有进程。
4. 实现调度函数,根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程,打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体:```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待,1: 运行,2: 完成} PCB;```2. 创建进程队列:```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法:(1)FCFS调度算法:```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(2)RR调度算法:```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(3)DP调度算法:```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程:```cvoid simulateProcess() {printf("请选择调度算法(1:FCFS,2:RR,3:DP):");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
进程调度算法的实现
第5部分、进程调度算法的实现:●基本要求:在1、2、3阶段实验基础上实现按先来先服务FCFS、短作业优先SJF以及时间片轮转算法调度进程的模拟过程。
●参考学时:8学时●实验提示:1、程序开始运行时选择调度算法,创建进程时输入进程所需服务时间以及到达时间。
2、根据当前所设定调度算法,连续调度所有进程,并计算每个进程的周转时间和带权周转时间、所有进程的平均周转时间和平均带权周转时间。
3、调度时应适当输出调度过程中各进程状态队列的变化情况以及进程的已执行时间、还需服务时间(针对时间片轮转算法)。
//package osDe;import java.util.V ector;import java.io.*;class Process{String name;int ArriveTime;int ServeTime;int startWorking;int []finish=new int[3];int []working=new int [3];double poweringWorking;int worktime;int moreServeTime;int id;public void setArriveTime(int ArriveTime) {this.ArriveTime=ArriveTime;}public int getArriveTime() {return ArriveTime;}public void setServeTime(int ServeTime) {this.ServeTime=ServeTime;}public int getServeTime() {return ServeTime;}public String getName() {return name;}Process(String name){=name;}Process(String name,int ArriveTime,int ServeTime,int id) {=name;this.ArriveTime=ArriveTime;this.ServeTime=ServeTime;this.id=id;this.moreServeTime=ServeTime;}public String toString(){return name;}}public class OS1 {public static V ector<Process> ready,blocked;public static Process running;public static BufferedReader br;public static V ector<Process>p;public static int count=0;public OS1() {ready=new V ector<Process>();blocked=new V ector<Process>();br=new BufferedReader(new InputStreamReader(System.in));p=new V ector<Process>();init();}public static void go() {while(true){System.out.println("==================================================== ===================");System.out.println("1:进程创建");System.out.println("2:进程到时");System.out.println("3:进程阻塞");System.out.println("4:进程唤醒");System.out.println("5:进程结束");// System.out.println("6:选择调度算法(1 FCFS 2 SJF 3 RR)");System.out.println("6:按先来先服务调度");System.out.println("7:按短作业优先调度");System.out.println("8:按时间片调度");//System.out.println("7:显示进程调度结果");System.out.println("0:退出-->");try{int i=Integer.parseInt(br.readLine());switch(i){case 0:System.exit(0);case 1:createNewProcess();break;case 2:switchCurrentProcess();break;case 3:blockCurrentProcess();break;case 4:wakeupBlockedProcess();break;case 5:terminateCurrentProcess();break;case 6:FCFS(p);break;case 7:SJF(p);break;case 8:RR(p);break;}}catch(Exception e){System.out.println(e);}//// System.out.println("执行进程:"+(running==null?"none":running)); // System.out.print("就绪进程:");// printList(ready);// System.out.print("阻塞进程:");// printList(blocked);}}public static void printList(V ector v){for(int i=0;i<v.size();i++)System.out.print(v.elementAt(i)+"\t");System.out.println();}public static void createNewProcess(){try{System.out.print("进程名称:");String name=br.readLine();//Process process=new Process(name);// ready.add(new Process(name));System.out.print("进程到达时间:");int ArriveTime=Integer.parseInt(br.readLine());//process.setArriveTime(ArriveTime);System.out.print("进程服务时间:");int ServeTime=Integer.parseInt(br.readLine());//process.setServeTime(ServeTime);Process process=new Process(name,ArriveTime,ServeTime,++count);ready.add(process);p.add(process);if(running==null){running=(Process)ready.elementAt(0);ready.removeElementAt(0);}}catch(Exception e){System.out.println(e);}}public static void switchCurrentProcess(){if(running!=null)ready.add(running);if(ready.size()>0){running=(Process)ready.elementAt(0);ready.removeElementAt(0);}elserunning=null;}public static void blockCurrentProcess(){if(running!=null) {blocked.add(running);}if(ready.size()>0) {running=(Process)ready.elementAt(0);ready.removeElementAt(0);}else {running=null;}}public static void wakeupBlockedProcess() {if(blocked.size()>0){//running=(Process)blocked.elementAt(0);ready.add((Process)blocked.elementAt(0));blocked.removeElementAt(0);if(running==null) {running=(Process)ready.elementAt(0);ready.removeElementAt(0);}}else {//blocked=null;}}public static void terminateCurrentProcess() { if(running!=null) {running=null;}if(ready.size()>0) {running=(Process)ready.elementAt(0);ready.removeElementAt(0);}else if(blocked.size()>0){running=(Process)blocked.elementAt(0);blocked.removeElementAt(0);}else {running=null;}}public static void init() {Process p1=new Process("A",0,4,count++);Process p2=new Process("B",1,3,count++);Process p3=new Process("C",2,5,count++);Process p4=new Process("D",3,2,count++);Process p5=new Process("E",4,4,count++);// Process p1=new Process("A",0,1);// Process p2=new Process("B",1,100);// Process p3=new Process("C",2,1);// Process p4=new Process("D",3,100);//Process p5=new Process("E",4,4);p.add(p1); p.add(p2);p.add(p3); p.add(p4);p.add(p5);ready.add(p1); ready.add(p2); ready.add(p3); ready.add(p4); ready.add(p5);if(running==null){running=(Process)ready.elementAt(0);ready.removeElementAt(0);}}public static void FCFS(V ector<Process>p1) {showFCFSProcess();double averoundTime=0;double aveweightroundTime=0;if(p1.elementAt(0)!=null) {p1.elementAt(0).startWorking=p1.elementAt(0).ArriveTime;}for(int i=0;i<p1.size();) {if(p1.elementAt(i)!=null) {p1.elementAt(i).finish[0]=p1.elementAt(i).startWorking+p1.elementAt(i).ServeTime;p1.elementAt(i).working[0]=p1.elementAt(i).finish[0]-p1.elementAt(i).ArriveTime;p1.elementAt(i).poweringWorking=p1.elementAt(i).working[0]/(double)p1.elementAt(i).Ser veTime;int b=i;++b;//System.out.println("b="+b);if(b<p1.size()) {int Temp=p1.elementAt(i).finish[0];++i;// System.out.println("i="+i);if(Temp<p1.elementAt(i).ArriveTime) {p1.elementAt(i).startWorking=p1.elementAt(i).ArriveTime;}else {p1.elementAt(i).startWorking=Temp;}}else {++i;}}else {break;}}System.out.println("进程名"+"\t"+"到达时间"+"\t"+"服务时间"+"\t"+"开始执行时间"+"\t"+"完成时间"+"\t"+"周转时间"+"\t"+"带权周转时间");for(int i=0;i<p.size();i++) {if(p1.elementAt(i)!=null) {System.out.println(p1.elementAt(i).getName()+"\t"+p1.elementAt(i).ArriveTime+"\t"+p1.ele mentAt(i).ServeTime+"\t"+p1.elementAt(i).startWorking+"\t"+p1.elementAt(i).finish[0]+"\t"+p1.elementAt(i).working[ 0]+"\t"+p1.elementAt(i).poweringWorking);averoundTime+=p1.elementAt(i).working[0];aveweightroundTime+=p1.elementAt(i).poweringWorking;}else {break;}}System.out.println("平均周转时间"+averoundTime/(float)p1.size()+" "+"平均带权周转时间"+aveweightroundTime/(float)p1.size());}public static void SJF(V ector<Process>p1) {showSJFProces();double averoundTime=0;double aveweightroundTime=0;int minServiceTime=0;int index=0;int preFinish=0;if(p1.size()>0) {p1.elementAt(0).startWorking=p1.elementAt(0).ArriveTime;p1.elementAt(0).finish[1]=p1.elementAt(0).startWorking+p1.elementAt(0).ServeTime;p1.elementAt(0).working[1]=p1.elementAt(0).finish[1]-p1.elementAt(0).ArriveTime;p1.elementAt(0).poweringWorking=p1.elementAt(0).working[1]/(double)p1.elementAt(0).ServeT ime;preFinish=p1.elementAt(0).finish[1];}for(int i=1;i<p1.size();i++) {minServiceTime=1000;for(int j=1;j<p1.size();j++) {if(minServiceTime>p1.elementAt(j).ServeTime&&p1.elementAt(j).finish[1]==0&&preFinis h>=p1.elementAt(j).ArriveTime) {minServiceTime=p1.elementAt(j).ServeTime;index=j;}}if(p1.elementAt(index).ArriveTime<=preFinish) {p1.elementAt(index).startWorking=preFinish;}else {p1.elementAt(index).startWorking=p1.elementAt(index).ArriveTime;}p1.elementAt(index).finish[1]=p1.elementAt(index).startWorking+p1.elementAt(index).ServeTime;p1.elementAt(index).working[1]=p1.elementAt(index).finish[1]-p1.elementAt(index).ArriveTime;p1.elementAt(index).poweringWorking=p1.elementAt(index).working[1]/(double)p1.elementAt(i ndex).ServeTime;preFinish=p1.elementAt(index).finish[1];}System.out.println("进程名"+"\t"+"到达时间"+"\t" +"服务时间"+"\t"+"开始执行时间"+"\t"+"完成时间"+"\t"+"周转时间"+"\t"+"带权周转时间");for(int i=0;i<p.size();i++) {if(p1.elementAt(i)!=null) {System.out.println(p1.elementAt(i).getName()+"\t"+p1.elementAt(i).ArriveTime+"\t"+p1.ele mentAt(i).ServeTime+"\t"+p1.elementAt(i).startWorking+"\t"+p1.elementAt(i).finish[1]+"\t"+p1.elementAt(i).working[ 1]+"\t"+p1.elementAt(i).poweringWorking);averoundTime+=p1.elementAt(i).working[1];aveweightroundTime+=p1.elementAt(i).poweringWorking;}else {break;}}System.out.println("平均周转时间"+averoundTime/(float)p1.size()+" "+"平均带权周转时间"+aveweightroundTime/(float)p1.size());}public static void RR(V ector<Process>p1) {int finishTime=0;double averoundTime=0;double aveweightroundTime=0;try {int q=0;System.out.print("请输入时间片大小:");q=Integer.parseInt(br.readLine());if(q<=0) {System.out.println("输入不合法");return;}showRRProcess(q,p1);for(int j=0;j<p1.size();j++) {p1.elementAt(j).working[2]=p1.elementAt(j).finish[2]-p1.elementAt(j).ArriveTime;p1.elementAt(j).poweringWorking=p1.elementAt(j).working[2]/(double)p1.elementAt(j).Ser veTime;}System.out.println("进程名"+"\t"+"到达时间"+"\t" +"服务时间"+"\t"+"完成时间"+"\t"+"周转时间"+"\t"+"带权周转时间");for(int i=0;i<p.size();i++) {if(p1.elementAt(i)!=null) {System.out.println(p1.elementAt(i).getName()+"\t"+p1.elementAt(i).ArriveTime+"\t"+p1.ele mentAt(i).ServeTime+"\t"+p1.elementAt(i).finish[2]+"\t"+p1.elementAt(i).working[2]+"\t"+p1.elementAt(i).poweringWorking);averoundTime+=p1.elementAt(i).working[2];aveweightroundTime+=p1.elementAt(i).poweringWorking;}else {break;}}System.out.println("平均周转时间"+averoundTime/(float)p1.size()+" "+"平均带权周转时间"+aveweightroundTime/(float)p1.size());}catch(Exception e) {System.out.println(e);}}public static void showFCFSProcess() {int i=0;while(true) {if(running!=null) {if(i!=running.ServeTime) {System.out.println("执行进程:"+running);System.out.println("到达时间:"+running.ArriveTime+","+"服务时间:"+running.ServeTime+","+"执行时间:"+(++i));System.out.println("就绪进程:");for(int j=0;j<ready.size();j++) {System.out.println(ready.elementAt(j)+","+"到达时间:"+ready.elementAt(j).ArriveTime+","+"服务时间:"+ready.elementAt(j).ServeTime+","+"执行时间:"+0);}System.out.println("阻塞进程:");printList(blocked);}else {terminateCurrentProcess();i=0;}}else {System.out.println("执行进程:"+"none");System.out.println("执行进程:");System.out.println("阻塞进程:");return;}}}public static void showSJFProces() {int i=0;while(true) {if(running!=null) {if(i!=running.ServeTime) {System.out.println("执行进程:"+running);System.out.println("到达时间:"+running.ArriveTime+","+"服务时间:"+running.ServeTime+","+"执行时间:"+(++i));System.out.println("就绪进程:");for(int j=0;j<ready.size();j++) {System.out.println(ready.elementAt(j)+","+"到达时间:"+ready.elementAt(j).ArriveTime+","+"服务时间:"+ready.elementAt(j).ServeTime+","+"执行时间:"+0);}System.out.println("阻塞进程:");printList(blocked);}else {terminateCurrentProcess();int index=findServeTime();System.out.println("index="+index);for(int j=0;j<index+1;j++) {switchCurrentProcess();}i=0;}}else {System.out.println("执行进程:"+"none");System.out.println("执行进程:");System.out.println("阻塞进程:");return;}}}public static int findServeTime() {int index=0;int minServeTime=0;if(ready.size()>0) {minServeTime=ready.elementAt(0).ServeTime;}for(int j=1;j<ready.size();j++) {if(ready.elementAt(j).ServeTime<minServeTime) {//System.out.println("minServeTime="+minServeTime);//System.out.println("ready.elementAt(j).ServeTime="+ready.elementAt(j).ServeTime);minServeTime=ready.elementAt(j).ServeTime;index=j;}}return index;}public static void showRRProcess(int q,V ector<Process>p1) {int i=0;while(true) {if(running!=null) {if(running.worktime!=q) {if(running.worktime!=running.ServeTime&&running.moreServeTime>0) {++i;++running.worktime;System.out.println("执行进程:"+running);System.out.println("到达时间:"+running.ArriveTime+","+"服务时间:"+running.ServeTime+","+"还需服务时间:"+(--running.moreServeTime)+"执行时间:"+(running.ServeTime-running.moreServeTime));System.out.println("就绪进程:");for(int j=0;j<ready.size();j++) {System.out.println(ready.elementAt(j)+","+"到达时间:"+ready.elementAt(j).ArriveTime+","+"服务时间:"+ready.elementAt(j).ServeTime+","+"执行时间:"+0);}System.out.println("阻塞进程:");printList(blocked);}else {// running.finish[2]=p1.elementAt(running.id).finish[2]=i;terminateCurrentProcess();}}else {if(running.moreServeTime!=0) {running.worktime=0;switchCurrentProcess();}else {// System.out.println("heloffffff");p1.elementAt(running.id).finish[2]=i;//System.out.println("p1.elementAt(running.id).finish[2]="+p1.elementAt(running.id).finish[2] );terminateCurrentProcess();}}}else {System.out.println("执行进程:"+"none");System.out.println("执行进程:");System.out.println("阻塞进程:");return;}}}public static void main(String[]args) {new OS1().go();}}。
进程调度算法 实验报告
进程调度算法实验报告
《进程调度算法实验报告》
一、实验目的
本实验旨在通过对进程调度算法的实验研究,探究不同调度算法对系统性能的影响,进一步加深对操作系统进程调度的理解。
二、实验内容
本次实验选择了三种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)和轮转调度(RR),并通过模拟不同进程的到达时间和执行时间,分别对这三种算法进行实验比较。
三、实验步骤
1. 设计实验用例:确定不同进程的到达时间和执行时间,以及不同调度算法的时间片大小。
2. 模拟执行:根据设计的实验用例,使用模拟工具模拟不同调度算法的执行过程,并记录每个进程的执行情况和系统的运行情况。
3. 数据分析:根据实验结果,对比不同调度算法的平均等待时间、平均周转时间等指标,分析各算法的优缺点。
四、实验结果
通过实验比较,得出以下结论:
1. 先来先服务(FCFS)算法:适用于执行时间较短的进程,但容易导致长作业等待时间过长。
2. 最短作业优先(SJF)算法:能够最大程度地减少平均等待时间和平均周转时间,但无法处理长作业优先的情况。
3. 轮转调度(RR)算法:能够保证每个进程都能及时得到执行,但可能导致部分进程的等待时间过长。
五、实验结论
根据实验结果,不同的进程调度算法适用于不同的场景。
在实际应用中,需要根据系统的实际情况和需求选择合适的调度算法,以最大程度地提高系统的性能和效率。
六、实验总结
通过本次实验,加深了对进程调度算法的理解,同时也了解了不同算法在实际应用中的优缺点。
希望通过本次实验,能够为进程调度算法的研究和应用提供一定的参考和借鉴。
进程调度算法 实验报告
进程调度算法实验报告实验目的:本实验的主要目的是为了通过实践来理解进程调度算法,学习模拟进程调度算法的过程,增强对进程调度的理解。
实验内容:本实验分为两部分,第一部分是了解不同的进程调度算法,第二部分是使用模拟的方式来实现进程调度。
第一部分:本部分要求学生了解常用的几种进程调度算法,包括以下几种:1、先来先服务算法(FCFS)FCFS就是按照队列的先来先服务原则来选择执行的进程。
当一个进程退出CPU之后,下一个处在等待队列最前面的进程会被执行。
2、短作业优先算法(SJF)SJF是通过判断正在等待CPU的进程所需要的执行时间来进行排序,按照需要执行时间最短的进程先执行,以此提高CPU的利用率和系统的运行效率。
3、优先级调度算法优先级调度算法是指根据进程的优先级选择下一个要执行的进程。
通常情况下,每个进程都被赋予一个优先级,优先级高的进程得到CPU时间的概率也就更大。
在实现上,根据优先级来进行排序以选择下一个要执行的进程。
4、时间片轮转算法(RR)时间片轮转算法是指每个进程被分配一定时间片,一旦该时间片用完了,进程就被放弃执行,会被放到等待队列最后面,选择下一个要执行的进程。
该算法主要用于CPU分时系统中,可以在不同进程之间切换,实现多任务。
本部分要求学生使用模拟的方式来实现进程调度。
具体步骤如下:1、编写程序代码通过编写程序模拟进程调度算法,根据不同的算法来实现进程的调度。
在程序运行过程中,要能够动态展示当前进程的执行情况,包括当前进程执行的时间、当前队列中的进程等信息。
2、测试功能通过测试程序的功能来掌握进程调度算法的应用和实现过程。
要能够通过模拟的方式来测试不同算法下的CPU利用率、平均等待时间和响应时间等指标。
优化算法是指不断调整和改进算法,提高调度程序的效率和性能,进一步提高系统的可靠性和稳定性。
优化算法主要包括调整时间片大小、优化队列中进程的排序方式等措施。
实验结果:通过本次实验,我们了解了不同的进程调度算法,并掌握了通过模拟进行进程调度的方法。
操作系统实验报告-进程调度实验
进程调度实验一.实验目的及要求:进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
二 . 实验环境:操作系统:Windows XP编译环境:Visual C++ 6.0三.算法描述进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
四. 实验步骤:1.、进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间。
2、程序源码结构:struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;sort(){…} /* 建立对进程进行优先级排列函数*/ check(){…} /* 建立进程查看函数*/input(){…} /* 建立进程控制块函数*/main() /*主函数*/{...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 resume......");ch=getchar();}printf("\n\n finished.\n");ch=getchar();}3.、实验截图:简单轮转法4、实验结果的分析及说明在操作系统中,由于进程总数多于处理机,它们必然竞争处理机。
操作系统实验报告-进程调度法的实现
操作系统实验报告进程调度算法的实现1.实验目的进程是操作系统最重要的概念之一,本实验通过对进程调度模拟程序的运行,学习运用时间片轮转法进行进程调度,加深对进程的基本调度状态以及进程调度算法的理解。
2.算法思想进程调度算法:采用多级反馈队列调度算法。
其基本思想是:当一个新进程进入内在后,首先将它放入第一个队列的末尾,按FCFS原则排队等待高度。
当轮到该进程执行时,如能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚为完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行,以此类推。
4.算法。
5.程序代码程序的主要代码如下:#include<iostream.h>#include<stdlib.h>#include<time.h>#include<stdio.h>#include<string.h>const int MAXCOMMANDLEN =50;///////////////////////////////////////////////////////////////////////////////////////// PROCESS///////////////////////////////////////////////////////////////////////////////////////class Process{friend class CPU; //友元类protected:static int init_ID; //静态初始IDint ID; //进程IDchar runText[MAXCOMMANDLEN]; //进程指令数组int IP; //进程指令指针,保存进程指令执行到的具体位置bool ISuseSource; //进程是否使用资源(是或者否)bool ISblocked; //进程是否被阻塞(是或者否)int unitTime; //进程被cpu执行单位时间, 默认 1int blockTime; //进程被阻塞时间public:static void RandID(); //静态随机生成进程ID的函数Process(); //进程类的构造函数int getID(); //得到进程IDint getIP(); //获取进程指令指针IPvoid setIP(int); //设置IPvoid Runed(); //进程被执行int getUnittime(); //得到进程的单位执行时间2int getBlcoktime(); //得到进程被阻塞的时间void setBlocktime(int); //设置进程被阻塞的时间void setUnittime(int); //设置进程的单位执行时间char getResult(int); //得到进程被执行的结果char* getRuntext(); //得到进程执行的指令void setBlockstate(bool); //设置进程阻塞状态bool getBlockstate(); //得到进程阻塞状态bool getISusesource(); //得到资源的使用状态void setISusesource(bool); //设置资源的使用状态};int Process::init_ID; //初始化静态变量void Process::RandID() //随机产生一个进程ID{srand((unsigned)time(NULL)); //调用srand随机生成函数init_ID=rand();}Process::Process() //进程的构造函数{ID=init_ID++; //进程ID的初值为静态初始ID的值int commandLen; //命令行长度IP=0;cout<<"Please input the text which process runed by CPU [#command#] :>\\ ";cin>>runText; //输入命令if( (commandLen=strlen(runText) ) > MAXCOMMANDLEN )exit(0); //输入长度超出最大长度时退出,特殊情况处理3runText[commandLen]='#'; //初始指令结束标志 '#' runText[commandLen+1]='\0'; //字符串结束标志ISuseSource=false; //设置资源的使用状态为未使用ISblocked=false; //进程的初始状态-》未被阻塞unitTime=1; //进程被执行的单位时间为1 blockTime=0; //阻塞时间为0}void Process::Runed() //进程被CPU执行{cout<<getResult(IP++); //输出得到的进程执行结果}int Process::getID() //得到进程ID {return ID;}int Process::getIP() //得到进行IP {return IP;}void Process::setIP(int ip) //设置进程IP {IP=ip;}bool Process::getISusesource() //得到资源的使用状态{return ISuseSource;4}void Process::setISusesource(bool s) //设置资源的使用状态{ISuseSource=s;}char* Process::getRuntext() //得到进程执行的指令{return runText;}int Process::getUnittime() //得到进程的单位执行时间{return unitTime;}int Process::getBlcoktime() //得到进程阻塞状态{return blockTime;}void Process::setBlocktime(int BT) //设置进程阻塞时间{blockTime=BT;}void Process::setUnittime(int UT) //设置进程的单位执行时间{unitTime=UT;}5void Process::setBlockstate(bool state) //设置进程阻塞状态{ISblocked=state;}bool Process::getBlockstate() //得到进程阻塞状态{return ISblocked;}char Process::getResult(int k) //得到程序的运行结果{return runText[k];}///////////////////////////////////////////////////////////////////////////////////////// SOURCE///////////////////////////////////////////////////////////////////////////////////////class Source //资源类{protected:int ID; //资源 IDbool state; //资源是否被占用状态int pro_ID; //使用资源的进程id Process *pro; //使用资源的进程指针int time; //进程使用资源的时间6public:Source(int); //资源类构造函数bool getState(); //得到资源被使用状态void setState(bool); //设置资源被使用状态void setTime(int); //设置进程使用资源的时间void setPro(Process *); //设置使用该资源的进程int getID(); //得到资源idint getPorID(); //得到使用资源的进程id void setProID(int); //设置使用资源的进程id void runned(); //资源被cpu调用};Source::Source(int id) //资源类构造函数{ID=id; //资源ID初值为idpro=NULL; //指针赋为空值state=true; //状态为被使用状态}void Source::setProID(int id) //设置使用资源的进程id{pro_ID=id;}void Source::setTime(int t) //设置进程使用资源的时间{time=t;}void Source::setState(bool s) //设置资源使用状态{7state=s;}bool Source::getState() //得到资源使用状态{return state;}void Source::setPro(Process *p) //设置使用该资源的进程{pro=p;}void Source::runned() //资源被CPU调用{if(time>0) //时间充足继续运行输出资源信息并使时间减一{cout<<"( Source :"<<ID<<")";time--;}if(time<=0) //时间用完{pro->setISusesource(false); //资源的使用状态为未使用int ip=pro->getIP(); //得到进程的IPpro->setIP(++ip); //设置到下一个ipSource::setState(true); //设置资源的使用状态为正在使用cout<<endl<<"The process "<<pro->getID()<<" relase the source!"<<endl;pro=NULL; //输出资源被释放指针值赋值为空值}8}//////////////////////////////////////////////////////////// ///////////////////////////// CPU////////////////////////////////////////////////////////////// /////////////////////////typedef struct Block //阻塞队列结构{Process *p_BlockProcess; //被阻塞的进程队列int index; //被阻塞的进程在就绪队列中的位置}Block;class CPU{protected:Process *p_Process; //进程队列Process **pp_Process; //进程就绪队列Block *blockQueue ; //进程阻塞队列Source *p_Source; //资源指针int numOfprocess; //进程数量int numOfblock; //被阻塞的进程数int PC; //程序计数器int allTime; //cpu运行的总时间public :CPU(int); //cpu构造函数void Run(); //cpu运行进程bool _IC(Process&); //虚拟IC,进行进程指令翻译void useSource(Process&); //进程申请资源9void blockProcess(Process&); //阻塞进程void releaseBlockPro(); //释放阻塞进程int getAlltime(); //得到进程运行的总时间void displayPro(); //显示进程的基本信息,id,指令,运行时间等void blockTimeADD(); //阻塞时间加1 };CPU::CPU(int num){p_Source=new Source(379857);//创建一个id号为379857的资源numOfprocess=num; //进程数numOfblock=0; //阻塞数allTime=0; //cpu运行的总时间初始化为0p_Process=new Process[numOfprocess];//进程队列申请空间pp_Process=new Process*[numOfprocess];//进程就绪队列申请空间blockQueue=new Block[numOfprocess]; //阻塞队列申请空间for(int i=0;i<numOfprocess;i++){pp_Process[i]=&p_Process[i]; //用二维数组存放进程指针数组头指针blockQueue->p_BlockProcess=NULL; //阻塞队列的阻塞进程赋值为空blockQueue->index=-1; //阻塞队列的索引值置为1 }}int CPU::getAlltime() //得到进程运行的总时间{return allTime;}10void CPU::displayPro() //显示进程的基本信息{for(int i=0;i<numOfprocess;i++)//循环输出被执行的进程的信息{cout<<"\tProcess ID : "<<p_Process[i].getID()<<endl;cout<<" text of runned :"<<p_Process[i].getRuntext()<<endl;}}void CPU::Run() //cpu运行进程{int numPro=numOfprocess; //记录未被运行的进程个数do{for(int num=0;num < numOfprocess;num++){if(!pp_Process[num]) //就绪队列不空继续执行continue;for(int t=0;t<p_Process[num].getUnittime();t++){PC=p_Process[num].getIP();//得到进程Ipif(_IC(p_Process[num]))//判断进程的状态TURE进入{if(t==0) //时间为0运行完输出进程信息cout<<"the process ["<<p_Process[num].getID()<<"] runed : ";if(!p_Process[num].getISusesource())//如果该进程未被运行过,则调用run运行{p_Process[num].Runed();//}else{p_Source->runned(); //if( p_Source->getState() && numOfblock>0 ){releaseBlockPro();////如果进程运行过,现在但未运行,说明为阻塞。
进程调度算法实验报告
一、实验目的多道程序系统中,当就绪进程数大于处理机数时,须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现进程调度,以加深对进程概念和不同进程调度算法的理解。
二、实验环境1.PC微机。
2.Windows 操作系统。
3.C/C++/VB等开发集成环境。
@三、实验内容与步骤编程实现如下进程调度算法:1)时间片轮转调度算法:时间片长度在运行时可从键盘输入。
2)多级反馈队列调度算法:至少要有三个队列,第i+1队列进程运行的时间片是第i队列的2倍。
3)高响应比优先调度算法:当调度响应比高的进程运行时,仍然是运行一个时间片,而不是完全结束,刚运行的进程,其以前的等待时间清零。
实现提示:(1)PCB数据结构(参考)PCB 至少包括:进程标识符、进程名、到达时间、服务时间、等待时间、完成时间、响应比等(可根据不同的算法增减)。
假设多个 PCB 利用链接方式进行组织。
(2)主要功能模块(参考)进程初始化;~显示初始化后进程的基本信息;时间片轮转调度算法;多级反馈队列调度算法;高响应比优先调度算法;输入要求:可将进程初始化信息事先存入文件中,程序运行从文件中读取信息,避免从键盘输入速度慢且易出错。
输出要求:每种调度算法每次调度后应直观显示,进程调度的依据、各进程的各项参数。
每种调度算法运行结束后,输出各个进程对应的完成时间、周转时间和带权周转时间,以及整体的平均带权周转时间。
四、实验结果与分析(1)程序的框架说明—(2)各调度算法的设计思想1、时间片轮转算法该算法采取了非常公平的方式,即让就绪队列上的每个进程每次仅运行一个时间片。
如果就绪队列上有N个进程,则每个进程每次大约都可获得1/N的处理机时间。
时间片的大小对于系统性能有很大的影响。
若选择很小的时间片,将有利于短作业,但意味着会频繁地执行进程调度和进程上下文的切换,这无疑会增加系统的开销。
反之,若时间片选择得太长,且为使每个进程都能在一个时间片内完成,RR算法便退化为FCFS算法,无法满足短作业和交互式用户的需求。
进程调度实验报告
进程调度实验报告进程调度实验报告一、实验目的本实验旨在通过模拟进程调度算法,加深对操作系统进程调度的理解,掌握进程调度算法的实现方法。
二、实验环境操作系统:Windows 10编程语言:C++开发工具:Visual Studio 2019三、实验内容1. 实现进程调度算法本实验实现了三种进程调度算法:先来先服务(FCFS)、短作业优先(SJF)和时间片轮转(RR)。
其中,FCFS算法按照进程到达的先后顺序进行调度,SJF算法按照进程执行时间的长短进行调度,RR算法则按照时间片轮转的方式进行调度。
2. 模拟进程调度过程本实验模拟了多个进程的调度过程,包括进程的创建、调度、执行和结束。
在模拟过程中,每个进程都有自己的进程ID、到达时间、执行时间和优先级等属性。
通过模拟进程调度过程,可以更好地理解进程调度算法的实现原理。
3. 统计调度结果本实验统计了每种进程调度算法的平均等待时间、平均周转时间和平均带权周转时间。
通过统计调度结果,可以比较不同进程调度算法的优劣,为实际应用提供参考。
四、实验结果1. 进程调度算法的实现本实验实现了三种进程调度算法,分别是FCFS、SJF和RR。
其中,FCFS算法的实现比较简单,只需要按照进程到达的先后顺序进行调度即可。
SJF算法则需要根据进程的执行时间进行排序,然后按照排序后的顺序进行调度。
RR算法则需要设置时间片大小,每个进程执行一个时间片后,将其放入就绪队列的末尾,然后轮到下一个进程执行。
2. 模拟进程调度过程本实验模拟了多个进程的调度过程,包括进程的创建、调度、执行和结束。
在模拟过程中,每个进程都有自己的进程ID、到达时间、执行时间和优先级等属性。
通过模拟进程调度过程,可以更好地理解进程调度算法的实现原理。
3. 统计调度结果本实验统计了每种进程调度算法的平均等待时间、平均周转时间和平均带权周转时间。
通过统计调度结果,可以比较不同进程调度算法的优劣,为实际应用提供参考。
进程调度算法
进程调度算法1.实验目的调度的实质是操作系统按照某种预定的策略来分配资源。
进程调度的目的是分配CPU资源。
由于进程调度程序执行的频率很高,因此调度算法的好坏直接影响到操作系统的性能。
本实验的目的是编程模拟实现几种常用的进程调度算法,通过对几组进程分别使用不同的调度算法,计算进程的平均周转时间和平均带权周转时间,比较各种算法的性能优劣。
2.实验原理1.进程调度算法描述进程调度算法包括先来先服务调度算法、优先数调度算法、时间片轮转算法和分级调度算法4种。
先来先服务(FCFS)调度算法本算法在进行调度时,总是把处理机分配给最先进入就绪队列的进程,一个进程一旦分得处理机,便一直执行下去,直到该进程完成或阻塞时,才释放处理机。
优先数调度算法基于优先级的调度算法给每个进程分配一个优先级,在每次进程调度时,调度器总是调度那个具有最高优先级的任务来执行。
如果就绪队列中出现优先数相同的进程,则对这些有相同优先数的进程采用FCFS算法调度。
对于占有处理机的进程,系统可以使用“抢占式”或“非抢占式”的策略。
“非抢占式”指进程一旦占用处理机,除非自己愿意,否则操作系统不能将处理机强行夺走,即使该进程的优先数已经小于就绪队列中的某个进程。
“抢占式”则相反,一旦就绪队列中的某个进程优先数大于正在执行的进程,立刻进行进程切换。
基于优先级的调度算法可以分为如下两种类型:静态优先级调度算法,这种调度算法给那些系统中得到运行的所有进程都静态地分配一个优先级;动态优先级调度算法,这种调度算法根据任务的资源需求来动态地分配任务的优先级,其目的就是在资源分配和调度时有更大的灵活性。
本实验的基本要求是实现固定优先数的调度算法,实验者可以在这个基础上添加动态优先数功能。
时间片轮转(RR )调度算法前几种算法主要用于批处理系统中,不能作为分时系统中的主调度算法,在分时系统中,都采用时间片轮转法。
简单轮转法:系统将所有就绪进程按FIFO 规则排队,按一定的时间间隔把处理机分配给队列中的进程。
进程调度算法的实现实验报告
进程调度算法的实现实验报告南昌大学实验报告---(4)进程调度算法的实现学生姓名:学号:专业班级:实验类型:□验证□综合■设计□创新实验日期:实验成绩:一、实验目的通过实验加强对进程调度算法的理解和掌握。
二、实验内容编写程序实现进程调度算法,具体可以编写程序实现先来先服务算法或优先度高者调度算法。
三、实验要求1、需写出设计说明;2、设计实现代码及说明;3、运行结果;四、主要实验步骤1、分析实验内容,画出算法流程图;2、根据流程图写出实验代码;3、编译代码,验证结果正确与否;4、对程序进行修改,得到最后结果。
流程图如下: 开始系统随机产生数据将数据按照到达时间从小到大排序用户输入数据进程到达时前一个进程是否已经完成完成时间=服务时间+前一个进程完成时间完成时间=服务时间+到达时间周转时间=完成时间-到达时间带权周转时间=完成时间/服务时间是否所有进程已完成计算输出结果结束YN YN YN五、实验数据及处理结果六、实验体会或对改进实验的建议在做这个实验的时候,一开始以为很简单,只要做简单的加减乘除就行了,但是仔细做过以后发现需要考虑很多情况。
比如说输入进程到达时间的时候,要是乱序的该怎么办?还有到达时间和服务时间等等定义的都是整型变量,但是带权周转时间确会得到小数,此时就需要用到强制转换。
在做系统产生随机数的时候也要考虑随机数的范围,如到达时间可以为0,但是服务时间却不能为0,否则带权周转时间的计算会出错。
七、参考资料《计算机操作系统》《计算机操作系统实验指导书》《C程序设计》《C语言程序设计_现代方法》八、实验代码#include <stdio.h>#include <stdlib.h>#include <time.h>#define N 5 //进程个数,可改变int rt[N]; //到达时间int st[N]; //服务时间int ct[N]; //完成时间int cyt[N]; //周转时间float rct[N]; //带权周转时间float av[2];int n,m,c=1,which;void line() //美化程序,使程序运行时更加明朗美观{p rintf("------------------------------------------------------------------\n");}void start() //表示FCFS算法开始{l ine();p rintf(" FCFS 算法开始\n");p rintf("——Designed by Zhang Hong\n");l ine();}void end() //表示FCFS算法结束{l ine();p rintf(" FCFS算法结束,谢谢使用\n");l ine();}void input(){p rintf("请输入%d个进程的到达时间:",N);f or (n=0;n<N;n++)scanf("%d",&rt[n]);p rintf("请输入%d个进程对应的服务时间:",N);f or (n=0;n<N;n++)scanf("%d",&st[n]);}void random(){s rand((unsigned)time(NULL));f or (n=0;n<N;n++){rt[n]=rand()%100;for (m=0;m<n;m++)if (n!=0 && rt[n]==rt[m]){rt[n]=rand()%100;m=0;}st[n]=rand()%98+1;for (m=0;m<n;m++)if (n!=0 && st[n]==st[m]){st[n]=rand()%98+1;m=0;}}}void ordination() //重新排序,应对出现输入的到达时间为乱序的情况{i nt temp;f or (n=0;n<N;n++)for (m=0;m<N-n-1;m++)if (rt[m+1]<rt[m]){temp=rt[m+1];rt[m+1]=rt[m];rt[m]=temp;temp=st[m+1];st[m+1]=st[m];st[m]=temp;}}void fcfs() //执行fcfs算法{a v[0]=0;a v[1]=0;c t[0]=rt[0]+st[0];f or (n=1;n<N;n++){if (ct[n-1]>=rt[n]) //考虑当前一个进程完成而后一个进程还没有到达的情况ct[n]=ct[n-1]+st[n];elsect[n]=rt[n]+st[n];}f or (n=0;n<N;n++)cyt[n]=ct[n]-rt[n];f or (n=0;n<N;n++)rct[n]=(float)cyt[n]/(float)st[n];f or (n=0;n<N;n++){av[0]+=(float)cyt[n]/N;av[1]+=rct[n]/N;}}void output() //输出结果{l ine();p rintf("进程名\t");f or (n=0;n<N;n++)printf("\t%c",65+n);p rintf("\t平均\n到达时间");f or (n=0;n<N;n++)printf("\t%d",rt[n]);p rintf("\n服务时间");f or (n=0;n<N;n++)printf("\t%d",st[n]);p rintf("\n完成时间");f or (n=0;n<N;n++)printf("\t%d",ct[n]);p rintf("\n周转时间");f or (n=0;n<N;n++)printf("\t%d",cyt[n]);p rintf("\t%0.1f",av[0]);p rintf("\n带权周转时间");f or (n=0;n<N;n++)printf("\t%0.1f",rct[n]);p rintf("\t%0.1f",av[1]);p rintf("\n");l ine();}void main(){s tart();f or (;c==1;){for (;;){printf("输入数据还是由系统随机产生数据?\n1、输入数据\t2、系统随机产生数据\n请输入:");scanf("%d",&which);if (which==1){input();break;}elseif (which==2){random();break;}printf("输入错误,请重新输入!");}ordination(); //进程按照到达时间进行排序fcfs();output();printf("继续输入,退出输入。
实验四.进程调度doc
实验四.进程调度doc实验四、进程调度1、实验目的进程是操作系统中最基本、最重要的概念,进程调度是操作系统的核心模块。
本实验要求学生独立地用 C 或C++语言编写一个简单的进程管理程序,其主要部分是进程调度。
调度算法可由学生自行选择,如基于先进先出调度算法、时间片轮转调度算法、动态优先级的调度算法或多级反馈队列调度算法。
通过本实验进一步了解系统如何组织、创建进程。
2、实验内容:(1,2必做)以链式结构组成空闲PCB 栈,以双向链式结构组成进程的就绪队列和睡眠队列,模拟LINUX的进程管理程序,实现以下操作(可用键盘命令或由产生的随机数决定操作和参数)。
1).创建一个新进程:如pid=newp(pri,size,time),申请空闲PCB和所需内存,填写PCB的各项初始数据,将该PCB 送入就绪队列。
2).调度和执行:自己设计调度算法,在就绪队列中选择一个进程,使其运行若干个单位时间。
要求在运行期间进程的p_cpu、p_pri 和p_time 要变化,并在适当的时机重新调度。
3).进程睡眠:进程运行时可调用自编的睡眠函数,主动进入睡眠状态,并转调度程序。
也可由操作使进程强迫挂起,睡眠适当时间。
进程睡眠时要在PCB 中记录睡眠原因和优先数。
4).进程的唤醒:根据睡眠原因,将相应的进程从睡眠队列中调出,转入就绪队列。
如该进程优先级比现运行进程优先级高,转调度程序。
5).进程的终止:如一个进程运行完作业所需的时间,或者用操作杀死该进程,该进程就终止,释放所占用的内存和PCB资源,转调度程序。
3、实验报告要求:要说明调度算法和程序主要的数据结构,画出系统的总体框图。
在执行了每一种操作后,记录输出进程状态和参数的变化情况,以便于观察进程的调度过程。
一、设计思想实现多级犯规队列调度算法,多级调度队列分别高优先级(H或h)队列、中优先级(M或m)队列和低优先级的(L或l)队列。
(1)当一个进程在一次运行中用完了时间片(100单位时间)还未完成任务或没有进入阻塞状态,降低其优先级,进入低一级的调度队列。
进程调度算法实验报告
作业调度一、实验名称作业调度算法二、实验目标在单道环境下编写作业调度的模拟程序,以加深对作业调度的理解。
单道环境的特点使被调度的作业占有所有的资源。
实现的算法有先来先服务,最短作业优先,最高响应比三种作业调度算法。
三、实验环境要求:1.PC机。
2.Windows;3.CodeBlocks四、实验基本原理1.本实验设计一个可指定作业个数的作业调度系统。
可以输出先来先服务,最短作业优先,最高响应比三种作业调度算法的结果。
2.先来先服务就是按照各个作业进入系统的自然次序进行调度。
最短作业优先就是优先调度并且处理短作业。
最高响应比优先就是根据在程序运行过程中的最高响应比对应的作业先进行调度处理。
3.在设计程序过程中,将time相关的内容封装到类中,重载了加减乘除和输入输出以及比较运算符,方便12:00这种形式的数据的加减乘除运算和比较运算,五、数据结构设计1.时间类class time {public:time(int x = 0, int y = 0) {time::hour = x;time::minute = y;}time& operator = (const time &t1){this->hour=t1.hour;this->minute=t1.minute;return *this;}time operator + (time t2){int minutes,hours;minutes = (minute + t2.minute) % 60;hours=hour+t2.hour+ (minute + t2.minute) /60;return time(hours,minutes);}time operator -(time t2){int minutes,hours;minutes =minute - t2.minute;if (minute<0) {minutes += 60;hour--;}hours = hour - t2.hour;return time(hours,minutes);}friend bool operator <(time t1, time t2){if (t1.hour < t2.hour) {return true;}else if(t1.hour==t2.hour){if (t1.minute <= t2.minute) {return true;}}return false;}friend ostream& operator <<(ostream& out, const time &t1) { return out << t1.hour << ":" << t1.minute*1.00 ;}friend istream& operator >>(istream &in, time &t1) { int h, m;scanf("%d:%d", &h,&m);t1.hour = h;t1.minute = m;return in;}public:int hour;int minute;};2.作业内容typedef struct JOB{char name[20];//Job nametime in_time;int run_time;time st_time;time end_time;int round_time;//周转时间int wait_time;double rounds_time;//带权周转double reson_radio;//响应比}job;六、流程图七、源代码#include<stdio.h>#include<stdlib.h>#include<string.h>#include<iostream>using namespace std;class time {public:time(int x = 0, int y = 0) {time::hour = x;time::minute = y;}time& operator = (const time &t1){this->hour=t1.hour;this->minute=t1.minute;return *this;}time operator + (time t2){int minutes,hours;minutes = (minute + t2.minute) % 60;hours=hour+t2.hour+ (minute + t2.minute) /60;return time(hours,minutes);}time operator -(time t2){int minutes,hours;minutes =minute - t2.minute;if (minute<0) {minutes += 60;hour--;}hours = hour - t2.hour;return time(hours,minutes);}friend bool operator <(time t1, time t2){if (t1.hour < t2.hour) {return true;}else if(t1.hour==t2.hour){if (t1.minute <= t2.minute) {return true;}}return false;}friend ostream& operator <<(ostream& out, const time &t1) { return out << t1.hour << ":" << t1.minute*1.00 ;}friend istream& operator >>(istream &in, time &t1) {int h, m;scanf("%d:%d", &h,&m);t1.hour = h;t1.minute = m;return in;}public:int hour;int minute;};typedef struct JOB{char name[20];//Job nametime in_time;int run_time;time st_time;time end_time;int round_time;//周转时间int wait_time;double rounds_time;//带权周转double reson_radio;//响应比}job;double sum_time;//全部作业周转时间和double sums_time;//全部作业带权周转时间和int n;//job counts//重载maxtime maxn(time t1, time t2) {if(t1.hour>t2.hour){return t1;}else if(t1.hour==t2.hour){if (t1.minute > t2.hour) {return t1;}}return t2;}//eg:120转化成2:0time m_exchange_h(int run_time) {time run;run.hour = run_time / 60;run.minute = run_time % 60;return run;}//eg: 2:0 转化成120int h_exchange_m(time t1) {return t1.hour * 60 + t1.minute;}//先来先服务;void job_input(job *x) {cout << "作业\t进入时间\t估计运行时间(分钟)\t开始时间\t结束时间\t周转时间(分钟)\t 带权周转时间" << endl;for (int i = 0; i < n; i++) {cout << x[i].name <<"\t"<< x[i].in_time<<"\t\t"<< x[i].run_time <<"\t\t\t"<< x[i].st_time << "\t\t"<<x[i].end_time <<"\t\t"<<x[i].round_time <<"\t\t"<< x[i].rounds_time << endl;}cout << "作业平均周转时间T=" << sum_time/n<< endl;cout << "作业平均带权周转时间T=" << sums_time / n << endl;}void FCFS(job *x) {sum_time = 0;sums_time = 0;time run = m_exchange_h(x[0].run_time);x[0].st_time = x[0].in_time;x[0].end_time = x[0].st_time + run;x[0].round_time = h_exchange_m(x[0].end_time - x[0].in_time);sum_time += x[0].round_time;x[0].rounds_time = x[0].round_time*1.0 / x[0].run_time;sums_time += x[0].rounds_time;for (int i = 1; i < n; i++) {x[i].st_time = maxn(x[i].in_time, x[i - 1].end_time);x[i].end_time = x[i].st_time + m_exchange_h(x[i].run_time);x[i].round_time = h_exchange_m(x[i].end_time - x[i].in_time);x[i].rounds_time = x[i].round_time*1.0 / x[i].run_time;sum_time += x[i].round_time;sums_time += x[i].rounds_time;}cout << "\n【先来先服务作业调度算法计算结果】\n" << endl;job_input(x);}//短作业优先;void SJF(job *x) {int flag[100000] ;memset(flag, 0, sizeof(flag));sum_time = 0;sums_time = 0;time run = m_exchange_h(x[0].run_time);x[0].st_time = x[0].in_time;x[0].end_time = x[0].st_time + run;x[0].round_time = h_exchange_m(x[0].end_time - x[0].in_time);sum_time += x[0].round_time;x[0].rounds_time = x[0].round_time*1.0 / x[0].run_time;int i = 1;//已经运行的程序int e = 0;//上一个运行的程序flag[0] = 1;while (i <n) {int temp = -1;int time_min = 99999999;for (int j = 1; j < n; j++) {if (x[j].in_time<x[e].end_time&&flag[j]!=1&&x[j].run_time<time_min) { //cout<<"小于:"<<x[j].name<<endl;time_min = x[j].run_time;temp = j;}}if (temp != -1) {x[temp].st_time = x[e].end_time;e = temp;}else {e++;x[e].st_time = x[e].in_time;}x[e].end_time = x[e].st_time + m_exchange_h(x[e].run_time);x[e].round_time = h_exchange_m(x[e].end_time - x[e].in_time);x[e].rounds_time = x[e].round_time*1.0 / x[e].run_time;sum_time += x[e].round_time;sums_time += x[e].rounds_time;flag[e] = 1;i++;}cout << "\n【短作业优先调度算法计算结果】\n" << endl;job_input(x);}//最高响应比优先;void HRN(job *x) {int flag[100000];memset(flag, 0, sizeof(flag));sum_time = 0;sums_time = 0;time run = m_exchange_h(x[0].run_time);x[0].st_time = x[0].in_time;x[0].end_time = x[0].st_time + run;x[0].round_time = h_exchange_m(x[0].end_time - x[0].in_time);x[0].rounds_time = x[0].round_time*1.0 / x[0].run_time;sums_time += x[0].rounds_time;int i = 1;//已经运行的程序int e = 0;//上一个运行的程序flag[0] = 1;while (i <n) {int temp = -1;double radio_max = 0;for (int j = 1; j < n; j++) {if (x[j].in_time<x[e].end_time&&flag[j] != 1) {x[j].reson_radio=h_exchange_m(x[e].end_time-x[j].in_time)*1.0/ x[j].run_time;if (x[j].reson_radio > radio_max) {temp = j;radio_max=x[j].reson_radio;}}}if (temp != -1) {x[temp].st_time = x[e].end_time;e = temp;}else {e++;x[e].st_time = x[e].in_time;}x[e].end_time = x[e].st_time + m_exchange_h(x[e].run_time);x[e].round_time = h_exchange_m(x[e].end_time - x[e].in_time);x[e].rounds_time = x[e].round_time*1.0 / x[e].run_time;sum_time += x[e].round_time;sums_time += x[e].rounds_time;flag[e] = 1;i++;}cout << "\n【最高响应比调度算法计算结果】\n" << endl;job_input(x);}int main(){cout << "作业总数: " ;cin >> n;cout<<endl;job *jobs = new job[n];cout << "作业信息输入(请按照进入时间先后顺序输入):" << endl;for (int i = 0; i < n; i++) {cout<<endl;cout << "正在读入第" << i + 1 << "个作业:" << endl;cout<<endl;cout << "作业名称: ";cin >> jobs[i].name;cout << "作业进入时间: ";cin >> jobs[i].in_time;cout << "作业估计运行时间(分钟): ";cin >> jobs[i].run_time;}//先来先服务;FCFS(jobs);//短作业优先;SJF(jobs);//最高响应比优先;HRN(jobs);return 0;}八、运行结果九、结果分析三种算法根据输入得出的输出和书上的结果相符,证明算法实现正确。
实验四_进程调度(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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
南昌大学实验报告
---(4)进程调度算法的实现一、实验目的
通过实验加强对进程调度算法的理解和掌握。
二、实验内容
编写程序实现进程调度算法,具体可以编写程序实现先来先服务算法。
三、实验要求
1、需写出设计说明;
2、设计实现代码及说明
3、运行结果;
四、主要实验步骤
1、设计原理与说明。
改模拟程序用C语言编写,通过定义一个结构体struct process,其中包含该进程的各种信息,包括进程名称,到达时间,开始时间,服务时间,结束时间,周转时间,带权周转时间。
通过各个名称的定义计算出来。
2、程序源代码及注释。
// 先来先服务.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}
#include <stdio.h>
void main()
{
struct process
{
char pro_name[10]; //定义进程名
float arrivetime; //定义进程到达时间
float servetime; //定义进程服务时间
float starttime; //定义进程开始时间
float finishtime; //定义进程完成时间
float circle_time; //定义进程周转时间
float d_circle_time; //定义进程带权周转时间
}a[100]; //用结构体存放各进程的相关信息
int i,j,k,N;
float pz,pd,s=0;
process temp;
printf("请输入进程数(0—100):");
scanf("%d",&N); //进程数
for(i=0;i<N;i++)
{
printf("请输入第 %d个进程的名称:\n)",i+1);
scanf("%s",&a[i].pro_name);
printf("请输入该个进程的到达时间,服务时间:\n)");
scanf("%f,%f",&a[i].arrivetime,&a[i].servetime);
}
for(i=0;i<N;i++){
for(j=0;j<=i;j++)
{
if(a[i].arrivetime<a[j].arrivetime)
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}// 按照FCFS算法对进程进行排序
printf("\nFCFS进程调度顺序为:\n");
for(k=0;k<N;k++)
printf("%5s ",a[k].pro_name);
printf("\n");
//计算第一个进程的相关信息
a[0].starttime=a[0].arrivetime;
a[0].finishtime=a[0].servetime+a[0].starttime;
a[0].circle_time=a[0].finishtime-a[0].arrivetime;
a[0].d_circle_time=a[0].circle_time/a[0].servetime;
//计算其他进程的相关信息
for(i=1;i<N;i++) {
a[i].starttime=a[i-1].servetime+a[i-1].starttime;
a[i].finishtime=a[i].servetime+a[i].starttime;
a[i].circle_time=a[i].finishtime-a[i].arrivetime;
a[i].d_circle_time=a[i].circle_time/a[i].servetime;
}
//计算平均周转时间和平均带权周转时间
for(i=0;i<N;i++)
s=s+a[i].circle_time;
pz=s/i;
for(i=0;i<N;i++)
s=s+a[i].d_circle_time;
pd=s/i;
printf("\n进程调度列表:\n");
printf("**********************************************************\n");
printf("进程名 ");
for(i=0;i<N;i++)
printf("\t%s",a[i].pro_name);
printf("\n进程到达时间");
for(i=0;i<N;i++)
printf("\t%.2f",a[i].arrivetime);
printf("\n进程服务时间");
for(i=0;i<N;i++)
printf("\t%.2f",a[i].servetime);
printf("\n进程开始时间");
for(i=0;i<N;i++)
printf("\t%.2f",a[i].starttime);
printf("\n进程完成时间");
for(i=0;i<N;i++)
printf("\t%.2f",a[i].finishtime);
printf("\n进程周转时间");
for(i=0;i<N;i++)
printf("\t%.2f",a[i].circle_time);
printf("\n带权周转时间");
for(i=0;i<N;i++)
printf("\t%.2f",a[i].d_circle_time);
printf("\n");
printf("**********************************************************\n");
printf("平均周转时间:%f\t\t平均带权周转时间:%f\n",pz,pd);
printf("**********************************************\n调度结束!\n");
}
五、实验数据及处理结果
1、我们用以下的数据进行模拟。
如表二
以下是程序运行结果
六、实验体会或对改进实验的建议
该实验是模拟处理机的调度,通过该实验我更加深刻的了解了处理机调度的实现。
也让我体会到了在计算机专业上机实践是非常重要的,光靠书本是很难真正的学懂的。
只有不断地通
过亲自上机,才能体会到其中的乐趣。
七、参考资料
《计算机操作系统(第三版)》汤小丹、梁红兵等编著。