实验1进程调度算法2015

合集下载

实验一进程调度实验

实验一进程调度实验

实验一,进程调度实验一、实验目的用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.二、实验内容及要求1.编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对五个进程进行调度。

可以采用静态或动态最高优先数优先的算法。

2、编写并调试一个模拟的进程调度程序,采用简单轮转法和多队列轮转法的“轮转法”调度算法对五个进程进行调度。

三、实验主要仪器设备和材料硬件环境:LBM-PC或兼容机软件坏境:C语言编程环境四、实验设计方案及原理每个进程有一个进程控制块(PCB)表示。

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

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

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

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

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

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

“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

(静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变;动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数。

例如:在进程获得一次CPU后就将其优先数减少1或者,进程等待的时间超过某一时限时增加其优先数的值,等等。

) 简单轮转法的基本思想是:所有就绪进程按FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片相同。

如果运行进程用完它的时间片后还为完成,就把它送回到就绪队列的末尾,把处理机重新分配给队首的进程。

直至所有的进程运行完毕。

多队列轮转法的基本思想是:设置多个就绪队列,每个队列的优先级不同,每个队列的CPU 时间片人小不等:一个新的进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度:仅当第一队列空闲时,调度程序才调度第二队列中的进程运行,后面的队列同理。

进程调度算法的实现实验报告

进程调度算法的实现实验报告

进程调度算法的实现实验报告南昌大学实验报告---(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("继续输入,退出输入。

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

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

《计算机操作系统》课程实验报告题目实验一进程调度学院: 计算机学院专业: 计算机科学与技术姓名班级学号2015年10月21日实验一进程调度1.实验目的:通过对进程调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度过程、调度算法的理解。

2.实验内容:用C语言实现对N个进程采用某种进程调度算法先来先服务调度、短作业优先调度的调度。

3.设计实现:要求给出设计源码,设计源码要有详细注释,#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/int atime; /*到达时间*/int stime; /*服务时间*/int ftime; /*完成时间*/int rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("根据到达时间重新排序:\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=0;i<n-1-j;i++)if(a[i].atime>a[i+1].atime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %d %d |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void fcfs(struct program a[],int n){int i;int time=0;for(i=0;i<n;i++){time=time+a[i].stime;a[i].ftime=a[0].atime+time;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=(float)a[i].rtime/a[i].stime;}printf("\nFCFS算法:\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %d %.2d %.2d %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******先来先服务算法****** \n");printf("请输入进程的数目:\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名,到达时间,服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);fcfs(pro,m);getchar();}#include <stdio.h>#include<iostream>using namespace std;struct program{char name; /*进程名*/float atime; /*到达时间*/float stime; /*服务时间*/float ftime; /*完成时间*/float rtime; /*周转时间*/float qrtime; /*带权周转时间*/};void xianshi(struct program a[],int n){int i,j;struct program t;/*将进程按时间排序*/printf("重新排序:\n");printf("*****进程*************到达时间***************服务时间*****\n");for(j=0;j<n-1;j++)for(i=1;i<n-1-j;i++)if(a[i].stime>a[i+1].stime){t.atime=a[i].atime;a[i].atime=a[i+1].atime;a[i+1].atime=t.atime;=a[i].name;a[i].name=a[i+1].name;a[i+1].name=;t.stime=a[i].stime;a[i].stime=a[i+1].stime;a[i+1].stime=t.stime;}for(i=0;i<n;i++)printf(" %c %f %f |\n",a[i].name,a[i].atime,a[i].stime);printf("----------------------------------------------------\n"); }void SJF(struct program a[],int n){int i;a[0].ftime=a[0].atime+a[0].stime;a[0].rtime=a[0].ftime-a[0].atime;a[0].qrtime=a[0].rtime/a[0].stime;for(i=1;i<n;i++){a[i].ftime=a[i-1].ftime+a[i].stime;a[i].rtime=a[i].ftime-a[i].atime;a[i].qrtime=a[i].rtime/a[i].stime;}printf("\nSJF算法:\n");printf("*****进程****到达时间****完成时间******周转时间*******带权周转时间*****\n");for(i=0;i<n;i++){printf(" %c %.2f %.2f %.2f %.2f |\n",a[i].name,a[i].atime,a[i].ftime,a[i].rtime,a[i].qrtime);}printf("-----------------------------------------------------------------------\n");}void main(){int i,m;struct program pro[4];/*创建进程 */printf(" ******短作业优先算法****** \n");printf("请输入进程的数目:\n");scanf("%d",&m);i=m;for(i=0;i<m;i++){printf("请输入进程%d的进程名,到达时间,服务时间\n",i+1);cin>>pro[i].name>>pro[i].atime>>pro[i].stime;}xianshi(pro,m);SJF(pro,m); getchar(); }4.实验结果5.实验过程中出现的问题及解决办法先来先服务调度算法就是根据进程达到的时间为依据,哪一个进程先来那么该进程就会先执行;最短进程优先调度算法则是以每个进程执行所需时间长短为依据,某一个进程执行所需花的时间要短些那么该进程就先执行。

进程调度算法实验报告

进程调度算法实验报告

计算机操作系统实验报告实验二进程调度算法一、实验名称:进程调度算法二、实验内容:编程实现如下算法:1.先来先服务算法;2.短进程优先算法;3.时间片轮转调度算法。

三、问题分析与设计:1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法,该算法既可以用于作业调度,也可用于进程调度。

当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将他们调入内存,为它们分配资源、创建进程,然后放入就绪队列。

在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行。

该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

FCFS算法比较有利于长作业(进程),2.短作业(进程)优先调度算法短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。

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

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

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

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

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

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

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

这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。

换言之,系统能在给定的时间内响应所有用户的请求。

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

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

操作系统单处理机系统的进程调度第一篇:操作系统单处理机系统的进程调度一.实验内容描述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知道该进程页目录的位置。

进程调度算法 进程管理实验

进程调度算法 进程管理实验

实验一进程管理及进程调度试验1.目的和要求通过本实验可以加深理解有关进程控制块、进程队列的概念,并体会进程调度算法的具体实施过程。

2.实验内容进程管理功能至少要有:创建新的进程;查看运行进程;换出某个进程;撤销运行进程等功能。

进程调度至少实现下列四种调度算法中的两种:进程调度算法有FIFO,优先数调度算法,时间片轮转调度算法,分级调度算法。

3.实验环境Windows系统,语言自选(建议C++)4、学时数:10个学时5、试验提示:进程管理部分:从理论(用操作系统来控制进程)到实践(编程来实现队列或数组的插入删除,只不过队列中的元素不再是普通的数值或字符,而是结构struct形式的值)进程调度部分:①本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。

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

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

③在优先数算法中,优先数可以先取值为98,进程每执行一次,优先数减3,CPU时间片数加1,进程还需要的时间片数减1。

在轮转算法中,采用固定时间片(即:每执行一次进程,该进程的执行时间片数为已执行了2个单位),这时,CPU时间片数加2,进程还需要的时间片数减2,并排列到就绪队列的尾上。

④对于遇到优先数一致的情况,采用FIFS策略解决。

#include<stdio.h>#include<stdlib.h>#include<math.h>int J=0,flag=0;void process1(){if(flag!=1){if(J==0){J=1;flag=1;printf("进程A可以使用临界资源\n");return;}elseprintf("临界资源忙进程A等待!\n");}{J=0;flag=0;printf("进程A释放临界资源\n");}}void process2(){if(flag!=2){if(J==1) printf("临界资源忙进程B等待!\n"); else{J=1;flag=2;printf("进程B可以使用临界资源\n"); return;}}else{J=0;flag=0;printf("进程B释放临界资源\n");}}void process3(){if(flag!=3){if(J==1)printf("临界资源忙进程C等待!\n");else{J=1;flag=3;printf("进程C可以使用临界资源\n"); return;}}else{J=0;flag=0;printf("进程C释放临界资源\n");}void main(){int x,N,i;printf("请输入循环次数N:\n"); scanf("%d",&N);for(i=0;i<N;i++){x=rand()%3+1;if(x==1)process1();if(x==2)process2();if(x==3)process3();}}。

进程调度算法设计实验报告

进程调度算法设计实验报告

进程调度算法的设计一、实验题目:实现先来先服务调度算法(FCFS)实现时间片轮转调度算法(RR)二、实验目的:通过对进程调度算法的设计,深入理解进程调度的原理。

进程是程序在一个数据集合上运行的过程,它是系统进行资源分配和调度的一个独立单位。

进程调度分配处理机,是控制协调进程对CPU的竞争,即按一定的调度算法从就绪队列中选中一个进程,把CPU的使用权交给被选中的进程。

三、实验原理:1.先来先服务(FCFS)调度算法每次调度是从就绪队列中,选择一个最先进入就绪队列的进程,把处理器分配给该进程,使之得到执行。

该进程一旦占有了处理器,它就一直运行下去,直到该进程完成或因发生事件而阻塞,才退出处理器。

将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理,是一种最普遍和最简单的方法。

它优先考虑在系统中等待时间最长的作业,而不管要求运行时间的长短按照就绪进程进入就绪队列的先后次序进行调度,简单易实现,利于长进程,CPU繁忙型作业,不利于短进程,排队时间相对过长2.时间片轮转调度算法RR时间片轮转法主要用于进程调度。

采用此算法的系统,其程序就绪队列往往按进程到达的时间来排序。

进程调度按一定时间片(q)轮番运行各个进程.进程按到达时间在就绪队列中排队,调度程序每次把CPU分配给就绪队列首进程使用一个时间片,运行完一个时间片释放CPU,排到就绪队列末尾参加下一轮调度,CPU 分配给就绪队列的首进程。

四、数据结构:数组五、程序代码:package sufa;import java.util.Arrays;import java.util.Scanner;public class Dispatch {public static void main(String[] args){int slice = 1; //时间片System.out.println("请输入要创建的进程数目:");Scanner reader = new Scanner(System.in);int num = reader.nextInt(); //用户要输入的进程数Process1 arr[] = new Process1[num]; //创建多个进程System.out.println("请分别输入进程的名称、到达时间以及区间时间");for(int i=0; i<arr.length; i++){arr[i] = new Process1(); //得到用户输入的各值}Arrays.sort(arr); //根据到达时间对进程数组排序int time =arr[0].arrtime; //赋值为最先到达的进程的到达时间System.out.println("-----开始进入FCFS算法-----");System.out.println(" "+"arrtime"+" "+"burstime"+" "+"overtime"+" "+"周转时间");for(int i =0; i<arr.length; i++){arr[i].overtime = arr[i].bursttime+time; //计算进程的结束时间time = time +arr[i].bursttime;arr[i].turnovertime = arr[i].overtime - arr[i].arrtime; //计算进程的周转时间System.out.println("进程"+arr[i].id+"开始运行"+"\t"+arr[i].arrtime+"\t"+arr[i].bursttime+"\t"+arr[i].overtime+"\t"+arr[i ].turnovertime);}int count = arr.length;System.out.println("-----开始进入RR算法-----");System.out.println(" "+"lasttime");while(count>0){for(int i=0; i<arr.length; i++){if(arr[i].bursttime>0){ //如果剩余区间还有时间 arr[i].bursttime=arr[i].bursttime-slice; //每循环运行一次就减去时间片,并打印下面语句System.out.println("进程"+arr[i].id+"开始运行"+"\t"+arr[i].bursttime);}if(arr[i].bursttime==0)count --; //当有某个进程的剩余时间为0的时候,count进行减1,当count减到等于0时,即每个进程都没有剩余时间了,就不再运行了}}}}class Process1 implements Comparable{int id; //进程名称int arrtime; //到达时间int bursttime; //区间时间int overtime; //结束时间double turnovertime; //周转时间public Process1(){ //读取用户输入的各个值Scanner reader = new Scanner(System.in);this.id = reader.nextInt();this.arrtime = reader.nextInt();this.bursttime = reader.nextInt();}@Overridepublic int compareTo(Object o) {// TODO Auto-generated method stubProcess1 pcb = (Process1)o;if(this.arrtime>= pcb.arrtime) //重写方法实现Comparable接口,按照到达时间的大小进行排序return 1;elsereturn -1;}}六、运行结果:七、实验心得:这次的实验实现FCFS算法和RR算法虽然用程序算法实现了模拟进程调度的整个过程,但是并未能考虑深入到操作系统的根本上用不同的队列存储不同状态下的进程来实现算法调度,但通过这次对进程调度算法设计的实现,还是对进程调度有了更深入更清楚的了解,以后的程序编写不论是实验还是项目开发,无论大小,都应该把程序的整体框架构建好,提高重用性。

操作系统实验一进程调度

操作系统实验一进程调度

操作系统实验一进程调度在计算机科学中,操作系统是管理计算机硬件与软件资源的程序,是计算机系统的内核与基石。

而进程调度作为操作系统的核心功能之一,对于系统的性能和资源利用率起着至关重要的作用。

本次操作系统实验一,我们将深入探讨进程调度的原理和实现。

进程,简单来说,是正在运行的程序的实例。

在多道程序环境下,多个进程可能同时竞争计算机系统的资源,如 CPU、内存、I/O 设备等。

进程调度的任务就是从就绪队列中选择一个合适的进程,并将 CPU 分配给它,以实现资源的合理分配和系统的高效运行。

常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)、优先级调度等。

先来先服务算法按照进程到达就绪队列的先后顺序进行调度,这种算法简单直观,但可能导致短作业等待时间过长,从而影响系统的整体性能。

短作业优先算法则优先调度运行时间短的进程,能够有效降低平均等待时间,但可能对长作业不利,容易造成“饥饿”现象。

时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片的 CPU 使用权。

这种算法能够保证每个进程都能得到及时响应,但时间片的大小选择需要权衡系统的开销和响应时间。

优先级调度算法为每个进程赋予一个优先级,优先级高的进程优先获得 CPU 资源。

然而,确定合理的优先级以及避免低优先级进程“饥饿”是该算法需要解决的问题。

在实验中,我们通过模拟实现这些调度算法,来深入理解它们的工作原理和性能特点。

以时间片轮转算法为例,我们首先需要创建一个就绪队列来存放等待调度的进程。

每个进程包含进程 ID、所需运行时间、已运行时间等信息。

在调度过程中,从就绪队列头部取出一个进程,判断其剩余运行时间是否小于等于时间片。

如果是,则该进程运行完毕,从队列中删除;否则,将其已运行时间增加时间片大小,剩余运行时间减少时间片大小,然后将其移到队列尾部,等待下一轮调度。

通过对不同调度算法的模拟实验,我们可以观察到它们在不同场景下的表现。

实验一 进程调度模拟算法

实验一 进程调度模拟算法

实验一进程调度模拟算法
进程调度模拟算法是操作系统中的重要概念,它是指操作系统如何安排进程的执行顺序,以达到最优的系统性能。

常见的进程调度算法包括先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)等。

下面将分别介绍这些算法的原理和特点。

1. 先来先服务(FCFS)
先来先服务是最简单的进程调度算法,它按照进程到达的先后顺序进行调度,即先到达的进程先执行。

这种算法的优点是实现简单,适用于长作业,但是它存在一个致命的缺陷,即无法处理短作业的情况,因为长作业可能会占用大量的CPU 时间,导致短作业等待时间过长。

2. 短作业优先(SJF)
短作业优先是一种非抢占式的调度算法,它按照进程的执行时间长短进行调度,即执行时间短的进程先执行。

这种算法的优点是可以减少平均等待时间,但是它存在一个问题,即可能会导致长作业一直等待,因为短作业总是可以插队执行。

3. 时间片轮转(RR)
时间片轮转是一种抢占式的调度算法,它将CPU时间划分为若干个时间片,每个进程在一个时间片内执行一定的时间,然后被挂起,让其他进程执行,直到所有进程都执行完毕。

这种算法的优点是可以保证所有进程都能得到执行,但是它存在一个问题,即时间片的长度会影响系统性能,如果时间片太短,会增加上下文切换的开销,如果时间片太长,会导致长作业等待时间过长。

实验一介绍了三种常见的进程调度算法,它们各有优缺点,需要根据具体的应用场景选择合适的算法。

进程调度算法实验报告

进程调度算法实验报告

操作系统实验报告(二)实验题目:进程调度算法实验环境:C++实验目得:编程模拟实现几种常见得进程调度算法,通过对几组进程分别使用不同得调度算法,计算进程得平均周转时间与平均带权周转时间,比较各种算法得性能优劣.实验内容:编程实现如下算法:1、先来先服务算法;2、短进程优先算法;3、时间片轮转调度算法。

设计分析:程序流程图:1、先来先服务算法2、短进程优先算法3、时间片轮转调度算法实验代码:1.先来先服务算法#include <iostream、h〉#definen20typedef struct{int id;//进程名int atime; //进程到达时间intruntime; //进程运行时间}fcs;voidmain(){intamount,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<<”之前结束。

实验一 时间片轮转进程调度算法

实验一 时间片轮转进程调度算法

实验一时间片轮转进程调度算法时间片轮转是一种常用的进程调度算法,它的基本思想是将CPU的使用时间分成若干个时间片,每个进程在一个时间片内运行一段时间。

当一个时间片用完后,就将当前进程放入就绪队列的末尾,然后选择就绪队列中的下一个进程来执行。

下面是一个简单的时间片轮转算法的实验:1. 首先,定义一个进程结构体,包括进程ID、执行时间、剩余时间等属性。

```c++struct Process {int id; // 进程IDint executionTime; // 执行时间int remainingTime; // 剩余时间Process(int id, int executionTime) {this->id = id;this->executionTime = executionTime;this->remainingTime = executionTime;}};```2. 定义一个就绪队列,用于存放所有待执行的进程。

```c++queue<Process> readyQueue;```3. 定义一个时间片大小,例如设为1。

```c++int timeSlice = 1;```4. 创建一些进程,并将它们加入就绪队列。

```c++Process p1(1, 5);Process p2(2, 3);Process p3(3, 2);Process p4(4, 4);readyQueue.push(p1);readyQueue.push(p2);readyQueue.push(p3);readyQueue.push(p4);```5. 开始执行进程调度。

```c++while (!readyQueue.empty()) {Process currentProcess = readyQueue.front(); // 获取当前要执行的进程readyQueue.pop(); // 从就绪队列中移除当前进程// 执行当前进程,更新剩余时间if (currentProcess.remainingTime > timeSlice) {currentProcess.remainingTime -= timeSlice;readyQueue.push(currentProcess); // 将剩余时间不为0的进程重新放入就绪队列} else {currentProcess.remainingTime = 0;cout << "进程" << currentProcess.id << "执行完毕。

操作系统实验一进程调度模拟算法

操作系统实验一进程调度模拟算法

操作系统实验一进程调度模拟算法进程调度是操作系统中的一个重要功能,它负责为计算机系统中的各个进程分配CPU时间,使得所有进程都能够得到公平的执行机会。

进程调度算法的选择对于系统的性能和响应时间有着重要影响。

本文将介绍几种常见的进程调度算法,并进行模拟实验,分析它们的优缺点。

FCFS算法是最简单的调度算法之一,在该算法中,按照进程到达的先后顺序分配CPU时间。

FCFS算法的优点是简单易懂,公平性高,但其缺点是无法有效处理短作业和长作业混合的情况。

长作业会导致其他短作业等待时间过长,从而影响系统的响应时间。

2. 最短作业优先调度算法(Shortest Job First,SJF)SJF算法是一种非抢占式的调度算法,它会根据每个进程的执行时间来选择下一个执行的进程。

该算法的优点是可以最小化平均等待时间,但其缺点是无法预测进程的执行时间,如果估计不准确,会导致长作业等待时间过长。

3. 最高响应比优先调度算法(Highest Response Ratio Next,HRRN)HRRN算法是一种动态优先级调度算法,它根据每个进程的等待时间和服务时间的比值来选择最优的进程。

该算法考虑了进程的等待时间和服务时间的关系,能够相对公平地分配CPU时间,并且能够避免长作业的垄断。

4. 时间片轮转调度算法(Round Robin,RR)RR算法是一种抢占式的调度算法,它将所有进程按照到达顺序分配一个时间片,每个进程得到执行的时间是固定的。

当一个进程的时间片用完后,它会被放到就绪队列的末尾,等待下一次调度。

RR算法的优点是实现简单,能够保证所有进程能够得到公平的执行机会,但其缺点是当进程数量较大时,调度开销会增加。

在进程调度的模拟实验中,首先需要定义进程的数据结构,包括进程ID、到达时间、优先级、执行时间等属性。

然后,模拟进程的到达过程,可以使用随机数生成器模拟进程的到达时间和执行时间。

接下来,根据选择的调度算法,模拟进程的执行过程。

进程调度算法实验报告

进程调度算法实验报告

实验报告实验一:进程调度算法一、实验目的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(),这三个函数分别实现先来先服务算法,时间片轮转算法和优先级算法,最后分别打印。

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

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

实验报告课程名称计算机操作系统实验名称进程及其管理班级学号姓名成绩指导教师赵安科实验日期2015年5月21日一.实验题目:进程及其管理二.实验内容:设计一个简单的进程调度算法,模拟OS 中的进程调度过程 三.实验要求:① 进程数不少于5个;② 进程调度算法任选;最好选用动态优先数法,每运行一个时间片优先数减3 ③ 用C++(或C )语言编程; ④ 程序运行时显示进程调度过程。

四.实验步骤:① 设计PCB 及其数据结构: 进程标识数:ID进程优先数:PRIORITY (优先数越大,优先级越高) 进程已占用时间片:CPUTIME进程尚需时间片:ALLTIME (一旦运行完毕,ALLTIME 为0) 进程队列指针:NEXT ,用来将PCB 排成队列 进程状态:STATE (一般为就绪,不用) ② 设计进程就绪队列及数据结构;③ 设计进程调度算法,并画出程序流程图; ④ 设计输入数据和输出格式; 结构格式:当前正运行的进程:0 当前就绪队列:2,1,3,4 ⑤ 编程上机,验证结果。

五.实验说明:假设调度前,系统中有5个进程,其初始状态如下: ID 0 1 2 3 4 可否考虑用二维数组去实现PRIORITY 9 38 30 29 0 CPUTIME 0 0 0 0 0 ALLTIME 3 3 6 3 4 STATE readyreadyreadyreadyready① 以时间片为单位调度运行;② 每次总是从ALLTIME 中不为0,且PRIORITY 最大的进程调度运行一个时间片;③上述进程运行后其优先数减3,再修改其CPUTIME和ALLTIME,重复②,③④直到所有进程的ALLTIME均变为0。

六.程序中所用数据结构及说明:程序中定义了一个二维数组pc用于存储5个进程对应的属性,在程序动态执行的过程中随时修改各个进程对应的属性,直到所有进程消耗完时间片为止,同时为了更方便的了解进程执行的过程,添加了一个priority函数,用于动态的显示就绪队列进程的优先数(由大到小排列),以及对应的进程ID号,这样在程序执行的过程中,能清楚下一步该运行的就绪队列中的进程,更方便检查程序执行的过程中进程的调度是否有错误。

进程调度算法 实验报告

进程调度算法 实验报告

进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中非常重要的一部分,它决定了系统中各个进程的执行顺序和时间分配。

在本次实验中,我们将研究和比较几种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、轮转法(RR)和优先级调度算法。

二、实验目的本次实验的目的是通过模拟不同的进程调度算法,观察它们在不同情况下的表现,并比较它们的优缺点,以便更好地理解和应用这些算法。

三、实验过程1. 实验环境准备我们使用C语言编写了一个简单的进程调度模拟程序,该程序可以模拟不同的进程调度算法,并输出每个进程的执行顺序和等待时间等信息。

2. 实验步骤(1)先来先服务(FCFS)算法FCFS算法是最简单的一种进程调度算法,它按照进程的到达顺序来执行。

我们通过模拟多个进程的到达时间和执行时间,观察它们的执行顺序和等待时间。

(2)最短作业优先(SJF)算法SJF算法是根据进程的执行时间来进行调度的,执行时间越短的进程优先执行。

我们通过模拟多个进程的执行时间,观察它们的执行顺序和等待时间。

(3)轮转法(RR)算法RR算法是一种时间片轮转的调度算法,每个进程被分配一个时间片,当时间片用完后,进程被挂起,等待下一次调度。

我们通过模拟不同的时间片大小,观察进程的执行顺序和等待时间。

(4)优先级调度算法优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程优先执行。

我们通过模拟不同的进程优先级,观察进程的执行顺序和等待时间。

四、实验结果与分析1. 先来先服务(FCFS)算法当进程的执行时间相差不大时,FCFS算法的等待时间较长,因为后到达的进程需要等待前面的进程执行完毕。

但如果有一个进程的执行时间很长,其他进程的等待时间就会很短。

2. 最短作业优先(SJF)算法SJF算法能够保证最短执行时间的进程先执行,因此平均等待时间较短。

但如果有一个执行时间很长的进程到达,其他进程的等待时间就会变长。

实验1进程调度算法2015

实验1进程调度算法2015
(3)进程调度算法 进程调度算法用于确定就绪队列中的哪一个进程即将获得 CPU。常用的进
程调度算法有先来先服务法、时间片轮转法、优先数法等。 ①先来先服务调度算法
先来先服务调度算法的基本思想是:以到达就绪队列的先后次序为标准来选 择占用处理机的进程。一个进程一旦占有处理机,就一直使用下去,直至正常结 束或因等待某事件的发生而让出处理机。采用这种算法时,应该这样来管理就绪 队列:到达的进程的 PCB 总是排在就绪队列末尾;调度程序总是把 CPU 分配给 就绪队列中的第一个进程使用。
全局变量名称
作用
MAX_PROCESS 程序最多能处理的进程数
process_number 存放下一个被创建进程的 进程号
pcb_table
进程控制块表
pcb_run
进程运行队列头指针
pcb_free
进程空闲队列头指针
pcb_ready
进程就绪队列头指针
pcb_ready_rear 进程就绪队列尾指针
②时间片轮转法 时间片轮转调度算法的基本思想是:为就绪队列中的每一个进程分配一个称 为“时间片”的时间段,它是允许该进程运行的时间长度。在使用完一个时间片后, 即使进程还没有运行完毕,也要强迫其释放处理机,让给另一个进程使用。它自 己则返回到就绪队列末尾,排队等待下一次调度的到来。采用这种调度算法时, 对就绪队列的管理与先来先服务完全相同。主要区别是进程每次占用处理机的时 间由时间片决定,而不是只要占用处理机就一直运行下去,直到运行完毕或为等 待某一事件的发生而自动放弃。 ③优先数调度算法 优先数调度算法的基本思想是:为每一个进程确定一个优先数,进程就绪队 列按照优先数排序。 如何确定进程的优先数(也就是进程的优先级)?可以从如下几个方面考虑。 ⅰ)根据进程的类型。系统中既有系统进程,又有用户进程。系统进程完成 的任务是提供系统服务,分配系统资源,因此,给予系统进程较高的优先数能够 提高系统的工作效率。 ⅱ)根据进程执行任务的重要性。重要性和紧迫性高的进程应当被赋予较高 的优先级。 ⅲ)根据进程程序的性质。一个 CPU 繁忙的进程,由于需要占用较长的运 行时间,影响系统整体效率的发挥,因此只能给予较低的优先数。一个 I/O 繁忙 的进程,给予它较高的优先数后,就能充分发挥 CPU 和外部设备之间的并行工 作能力。 ⅳ)根据对资源的要求。系统资源有处理机、内存储器和外部设备等。可以 按照一个进程所需资源的类型和数量,确定它的优先数。比如给予占用 CPU 时 间短或内存容量少的进程以较高的优先数,这样可以提高系统的吞吐量。 ⅴ)根据用户的请求。系统可以根据用户的请求,给予它的进程很高的优先 数,作“加急”处理。 ④多级队列调度算法 多级队列调度算法也称多级反馈队列调度算法,它是时间片调度算法与优先 数调度算法的结合。实行这种调度算法时,系统中将维持多个就绪队列,每个就 绪队列具有不同的调度级别,可以获得不同长度的时间片。例如,系统维持 N 个就绪队列,第 1 级就绪队列中进程的调度级别最高,可获得的时间片最短,第 N 级就绪队列中进程的调度级别最低,可获得的时间片最长。 具体的调度方法是:创建一个新进程时,它的 PCB 将进入第 1 级就绪队列 的末尾。对于在第 1 级到第 N-1 级队列中的进程,如果在分配给它的时间片内完 成了全部工作,那么就撤离系统;如果在时间片没有用完时提出了输入/输出请 求或要等待某事件发生,那么就进入相应的阻塞队列里等待。在所等待的事件出 现时,仍回到原队列末尾,参与下一轮调度(也就是每个队列实行先来先服务调 度算法);如果用完了时间片还没有完成自己的工作,那么只能放弃对 CPU 的使 用,降到低一级队列的末尾,参与那个队列的调度。对位于最后一个队列里的进

1进程调度算法

1进程调度算法

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

【实验内容】
设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。

假设有n个进程分别在T1, … ,T n时刻到达系统,它们需要的服务时间分别为S1, … ,S n。

分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度,计算每个进程的完成时间,周转时间和带权周转时间,并且统计n个进程的平均周转时间和平均带权周转时间。

【实验要求】
1)进程个数n;每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n;选择算法1-FCFS,2-SJF。

2)要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行,计算每个进程的周转时间,带权周转时间,并且计算所有进程的平均周转时间,带权平均周转时间;
3)输出:要求模拟整个调度过程,输出每个时刻的进程运行状态,如“时刻3:进程B开始运行”等等;
4)输出:要求输出计算出来的每个进程的周转时间,带权周转时间,所有进程的平均周转时间,带权平均周转时间。

【程序代码】
【实例截图】
【实验体会】。

进程调度

进程调度

实验一 进程调度算法1.实验目的调度的实质是操作系统按照某种特定的分配策略来分配资源。

进程调度的目的是分配CPU 资源。

由于进程调度程序执行的频率很高,因此调度算法的好坏将直接影响到操作系统的性能。

本实验的目的是编程模拟实现几种常见的进程调度算法,通过对几组进程分别使用不同的调度算法,计算进程的平均周转时间和平均带权周转时间,比较各种算法的性能优劣。

2.实验原理(1) 进程调度算法进程调度算法包括先来先服务调度算法、优先权调度算法、时间片轮转算法和分级调度算法等4种。

本实验包括前3种算法,先对前3种算法做一简单介绍。

<1>.先来先服务(FCFS )调度算法本算法在进行调度时,总是选择一个最先进入进程就绪队列的进程,把处理器分配给它,使之开始运行。

该进程一直运行到完成或发生阻塞事件时,才放弃处理器。

<2>优先权调度算法对每个进程确定一个优先权,进程调度总是让具有最高优先权的进程先使用处理器。

如果就绪队列中出现优先权相同的进程,则对这些有相同优先权的进程采用先来先服务算法进行调度。

对于占用处理器的进程,系统可以使用“抢占式”或“非抢占式”的策略。

“非抢占式”指进程一旦占用处理器,除非自己愿意,否则操作系统不能将处理器强行夺走,即使该进程的优先权已经小于就绪队列中的某个进程,“抢占式”则相反,一旦就绪队列中的某个进程优先权大于正在进行的进程,立刻进行进程切换。

进程的优先权可以发生变化。

本实验的基本要求是实现固定优先权的调度算法,读者可以在这个基础上添加动态优先权功能。

<3>时间片轮转调度算法在需要保证响应时间的场合通常采用时间片轮转算法来分配处理器。

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

时间片用完,调度程序自动停止该进程的执行,将它放到进程就绪队列的末尾,等待下一次执行,然后将CPU 分配给就绪队列中新的队首进程,也让它执行一个时间片。

操作系统进程调度算法

操作系统进程调度算法

郑州xxx 学院实验报告课程名称:先来先服务调度算法模拟姓名:xxx学号:xxx专业班级:xxx任课教师:xxx2015 年04 月12 日实验报告成绩评定表实验一作业调度一、目的与任务目的:了解并掌握作业调度的功能,熟悉并掌握各种作业调度算法。

任务:模拟实现先来先服务或者短作业优先调度算法。

二、内容、要求与安排1、实验内容模拟实现FCFS/SJF调度。

设置作业体:作业名,作业的到达时间,服务时间,作业状态(W——等待,R——运行,F——完成),作业间的链接指针;作业初始化:由用户输入作业名、服务时间、到达时间进行初始化,同时,初始化作业的状态为W。

显示函数:在作业调度前、调度中和调度后进行显示。

排序函数:对等待状态的作业按照调度算法排序(不同的调度算法排序方式不同),注意考虑到达时间。

调度函数:每次从等待队列队首调度已到达的适合的作业执行,状态变化。

当服务结束时,状态变为F。

删除函数:撤销状态为F的作业。

2、实验要求(1)测试数据可以随即输入或从文件中读入;(2)必须要考虑到作业的到达时间;(3)最终能够计算每一个作业的周转时间、带权周转。

三、测试1.实验设计说明本次实验采用C语言模拟对N个进程采用先来先服务进程调度算法调度。

每个用来标识进程的进程控制块PCB用结构来描述,包括以下字段:进程标识数ID[3]、进程名name[10]、进程状态state、进程到达时间arrivetime、进程开始执行时间starttime、进程执行结束时间finishtime、服务时间servicetime、周转时间turnaroundtime、带权周转时间weightedturnaroundtime、队列指针next用来将PCB排成队列。

主要程序流程图(进程的执行过程):2.实验代码#include"stdio.h"#include"stdlib.h"typedef struct PCB //定义进程控制块 {char ID[3]; //进程号char name[10]; //进程名char state; //运行状态int arrivetime; //到达时间int starttime; //进程开始时间int finishtime; //进程结束时间int servicetime //服务时间float turnaroundtime;//周转时间float weightedturnaroundtime;//带权周转时间struct PCB *next; //指向下个进程 }pcb;int time; //计时器 int n; //进程个数pcb *head=NULL,*p,*q; //进程链表指针void run_fcfs(pcb *p1) //运行未完成的进程 {time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间是%d,开始运行作业%s\n",time,p1->name);time+=p1->servicetime; p1->state='T';p1->finishtime=time;p1->turnaroundtime=p1->finishtime-p1->arrivetime;p1->weightedturnaroundtime=p1->turnaroundtime/p1->servicetime;printf("ID 到达时间开始时间服务时间完成时间周转时间带权周转时间 \n");printf("%s%6d%10d%10d%8d%10.1f%10.2f\n",p1->ID,p1->arrivetime,p1->starttim e,p1->servicetime,p1->finishtime,p1->turnaroundtime,p1->weightedturnaroundtime) ; }void fcfs() //找到当前未完成的进程 {int i,j;p=head;for(i=0;i<n;i++){if(p->state=='F') {q=p; //标记当前未完成的进程 run_fcfs(q); } p=p->next; } }void getInfo() //获得进程信息并创建进程 {int num;printf("\n作业个数:"); scanf("%d",&n);for(num=0;num<n;num++) {p=(pcb *)malloc(sizeof(pcb));printf("依次输入:\nID 进程名到达时间服务时间\n");scanf("%s\t%s\t%d\t%d",&p->ID,&p->name,&p->arrivetime,&p->servicetime); if(head==NULL) {head=p;q=p;time=p->arrivetime;} if(p->arrivetime < time) time=p->arrivetime; q->next=p; p->starttime=0; p->finishtime=0;p->turnaroundtime=0;p->weightedturnaroundtime=0; p->next=NULL; p->state='F'; q=p; } }void main(){printf("先来先服务算法模拟"); getInfo(); p=head; fcfs(); }3.实验结果4.实验结果分析先来先服务算法顾名思义先到的先参与调度,本利中按照A、B、C的顺序。

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

//进程运行队列头指针 //进程空闲队列头指针 //进程就绪队列头指针 //进程就绪队列尾指针 //阻塞队列头指针 //阻塞队列尾指针
void init_pcb_table( );
//初始化进程控制块表
void print_space(int num);
//显示若干个空格
void display_process_queue(PCB *queue);
2、实验内容 选择两个调度算法作为两个实验题目,实现处理器调度。
3、实验要求 要求完成以下功能:运行处理器调度算法,显示就绪进程队列、显示运行进
程队列、显示阻塞进程队列、创建新进程、阻塞进程、唤醒进程、删除进程、退 出程序。
4、实验预习内容 (1)进程控制块
为了管理和控制进程,系统在创建每一个进程时,都为其开辟一个专用的存储区,用以 随时记录它在系统中的动态特性。而当一个进程被撤消时,系统就收回分配给它的存储区。 通常,把这一存储区称为该进程的“进程控制块”(Process Control Block)。 由于 PCB 是随着进程的创建而建立,随着进程的撤消而取消的,因此系统是通过 PCB 来“感 知”一个个进程的,PCB 是进程存在的唯一标志。
作用 初始化进程队列,并管理主菜 单命令 初始化进程空闲队列 以表格的形式显示进程队列 创建进程 阻塞进程 唤醒进程 先进先出进程调度算法 时间片轮转进程调度算法 优先数进程调度算法 多级反馈队列进程调度算法
图 2-4 函数名称及作用
6.2 详细设计及实现
1). 头文件
头文件中含有图 2-2、图 2-3 和图 2-4 的内容。
#include <conio.h> #include <stdlib.h> #include <stdio.h> #include <io.h> #include <string.h>
#define MAX_PROCESS 10 int process_number=0;
//下一个可用的进程编号
typedef struct pcb{ struct pcb *next; char process_name[20]; int process_number; int process_start_moment; int process_need_time; int process_time_slice; int process_priority;
6 实验步骤 6.1 总体设计
确定程序包含多少个模块,每个模块有哪些功能、包括哪些函数,模块之间
的调用关系如何。由于本实验并不复杂,所以只用一个模块实现。要求宏、数据 结构、全局变量和函数原型放在头文件中,而函数实现放在源文件中。假设头文 件名为 process_schedule.h,源程序文件名为 process_schedule.cpp。实验中用到的 主要数据结构是进程控制块,其结构如图 2-2 所示。实验中用到 1 个宏和 8 个全 局变量,如图 2-3 所示。实验中用到的主要函数有 10 个,如图 2-4 所示。
全局变量名称
作用
MAX_PROCESS 程序最多能处理的进程数
process_number 存放下一个被创建进程的 进程号
pcb_table
进程控制块表
pcb_run
进程运行队列头指针
pcb_free
进程空闲队列头指针
pcb_ready
进程就绪队列头指针
pcb_ready_rear 进程就绪队列尾指针
}PCB; PCB pcb_table[MAX_PROCESS];
//下一个进程控制块指针 //进程名 //进程编号 //进程启动时刻 //要求运行时间 //时间片 //优先数
//自定义数据类型:进程控制块 //进程控制块表
PCB *pcb_run=NULL; PCB *pcb_free=NULL; PCB *pcb_ready=NULL; PCB *pcb_ready_rear=NULL; PCB *pcb_blocked=NULL; PCB *pcb_blocked_rear=NULL;
实验 1 进程调度算法 1、实验目的
进程管理是操作系统中的重要功能,用来创建进程、撤消进程、实现进程 状态转换,它提供了在可运行的进程之间复用 CPU 的方法。在进程管理中,进 程调度是核心,因为在采用多道程序设计的系统中,往往有若干个进程同时处于 就绪状态,当就绪进程个数大于处理器数目时,就必须依照某种策略决定哪些进 程优先占用处理器。本实验模拟在单处理器情况下的进程调度,目的是加深对进 程调度工作的理解,掌握不同调度算法的优缺点。
程,实行时间片轮转调度算法。 整个系统最先调度 1 级就绪队列;只有在上一级就绪队列为空时,才去下一
级队列调度。当比运行进程更高级别的队列中到达一个进程(可以肯定,在此之 前比运行进程级别高的所有队列全为空)时,系统将立即停止当前运行进程的运 行,让它回到自己队列的末尾,转去运行级别高的那个进程。
(2)进程控制块队列
在多道程序设计环境里,同时会创建多个进程。当计算机系统只有一个 CPU 时,每次 只能让一个进程运行,其他的进程或处于就绪状态,或处于阻塞状态。为了对这些进程进行 管理,操作系统要做三件事。
①把处于相同状态的进程的 PCB,通过各自的队列指针链接在一起,形成一个个队列。 通常有运行队列、就绪队列、阻塞队列。
//先来先服务进程调度算法
void RR( );
//时间片轮转进程调度算法
void HPF( );
//优先数进程调度算法
pcb_blocked
进程阻塞队列头指针
pcb_blocked_rear 进程阻塞队列尾指针
图 2-3 宏和全局变量
函数名称 main
init_pcb_table display_process_queue create_process block_process_by_name wakeup_process FCFS RR HPF MFBQ
(3)进程调度算法 进程调度算法用于确定就绪队列中的哪一个进程即将获得 CPU。常用的进
程调度算法有先来先服务法、时间片轮转法、优先数法等。 ①先来先服务调度算法
先来先服务调度算法的基本思想是:以到达就绪队列的先后次序为标准来选 择占用处理机的进程。一个进程一旦占有处理机,就一直使用下去,直至正常结 束或因等待某事件的发生而让出处理机。采用这种算法时,应该这样来管理就绪 队列:到达的进程的 PCB 总是排在就绪队列末尾;调度程序总是把 CPU 分配给 就绪队列中的第一个进程使用。
②时间片轮转法 时间片轮转调度算法的基本思想是:为就绪队列中的每一个进程分配一个称 为“时间片”的时间段,它是允许该进程运行的时间长度。在使用完一个时间片后, 即使进程还没有运行完毕,也要强迫其释放处理机,让给另一个进程使用。它自 己则返回到就绪队列末尾,排队等待下一次调度的到来。采用这种调度算法时, 对就绪队列的管理与先来先服务完全相同。主要区别是进程每次占用处理机的时 间由时间片决定,而不是只要占用处理机就一直运行下去,直到运行完毕或为等 待某一事件的发生而自动放弃。 ③优先数调度算法 优先数调度算法的基本思想是:为每一个进程确定一个优先数,进程就绪队 列按照优先数排序。 如何确定进程的优先数(也就是进程的优先级)?可以从如下几个方面考虑。 ⅰ)根据进程的类型。系统中既有系统进程,又有用户进程。系统进程完成 的任务是提供系统服务,分配系统资源,因此,给予系统进程较高的优先数能够 提高系统的工作效率。 ⅱ)根据进程执行任务的重要性。重要性和紧迫性高的进程应当被赋予较高 的优先级。 ⅲ)根据进程程序的性质。一个 CPU 繁忙的进程,由于需要占用较长的运 行时间,影响系统整体效率的发挥,因此只能给予较低的优先数。一个 I/O 繁忙 的进程,给予它较高的优先数后,就能充分发挥 CPU 和外部设备之间的并行工 作能力。 ⅳ)根据对资源的要求。系统资源有处理机、内存储器和外部设备等。可以 按照一个进程所需资源的类型和数量,确定它的优先数。比如给予占用 CPU 时 间短或内存容量少的进程以较高的优先数,这样可以提高系统的吞吐量。 ⅴ)根据用户的请求。系统可以根据用户的请求,给予它的进程很高的优先 数,作“加急”处理。 ④多级队列调度算法 多级队列调度算法也称多级反馈队列调度算法,它是时间片调度算法与优先 数调度算法的结合。实行这种调度算法时,系统中将维持多个就绪队列,每个就 绪队列具有不同的调度级别,可以获得不同长度的时间片。例如,系统维持 N 个就绪队列,第 1 级就绪队列中进程的调度级别最高,可获得的时间片最短,第 N 级就绪队列中进程的调度级别最低,可获得的时间片最长。 具体的调度方法是:创建一个新进程时,它的 PCB 将进入第 1 级就绪队列 的末尾。对于在第 1 级到第 N-1 级队列中的进程,如果在分配给它的时间片内完 成了全部工作,那么就撤离系统;如果在时间片没有用完时提出了输入/输出请 求或要等待某事件发生,那么就进入相应的阻塞队列里等待。在所等待的事件出 现时,仍回到原队列末尾,参与下一轮调度(也就是每个队列实行先来先服务调 度算法);如果用完了时间片还没有完成自己的工作,那么只能放弃对 CPU 的使 用,降到低一级队列的末尾,参与那个队列的调度。对位于最后一个队列里的进
数据项 next
process_name process_number
process_start_moment process_need_time process_time_slice process_priority
作用 前向指针,指向下一个进程控制块,用来构 成进程队列 进程名称 进程号,当进程有相同名称时,用来区分进 程 进程启动时刻 进程要求运行时间 时间片 优先数 图 2-2 进程控制块
//显示进程队列
PCB *create_process( );
//创建进程函数,成功时返回新创建进程
相关文档
最新文档