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

合集下载

实验一处理器调度实验报告

实验一处理器调度实验报告

实验一处理器调度一、实验容选择一个调度算法,实现处理器调度。

二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

当就绪状态进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下处理器调度,帮助学生加深了解处理器调度的工作。

三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示:(1)假定系统有五个进程,每一个进程用一个进程控制块PCB 来代表。

进程控制块的格式为:其中,进程名----作为进程的标识,假设五个进程的进程名分别是P1,P2,P3,P4,P5。

指针----按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块首地址,最后一个进程中的指针为“0”。

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

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

状态----可假设有两种状态,“就绪”状态和“结束“状态,五个进程的初始状态都为“就绪“状态,用“R”表示,当一个进程运行结束后,它的状态变为“结束”,用“E”表示。

(2)在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。

(3)为了调度方便,把五个进程按给定的优先数从大到小连成队列,用一单元指出队首进程,用指针指出队列的连接情况。

例:队首标志(4)处理器调度总是选队首进程运行。

采用动态改变优先数的办法,进程每运行一次优先数就减“1”。

由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:优先数-1要求运行时间-1来模拟进程的一次运行。

提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,它占有处理器运行,直到出现等待事件或运行结束。

在这里省去了这些工作。

(5)进程运行一次后,若要求运行时间≠0,则再将它加入队列(按优先数大小插入,且置队首标志);若要求运行时间=0,则把它的状态修改为“结束”(),且退出队列。

时间片轮转法cpu调度

时间片轮转法cpu调度

昆明理工大学理学院信息与计算科学专业操作性实验报告年级: 09级姓名:学号:指导教师:实验课程名称:操作系统原理开课实验室:理学院机房实验内容:1.实验/作业题目: 时间片轮转法cpu调度2.实验/作业课时:4学时3.实验过程(包括实验环境、实验内容的描述、完成实验要求的知识或技能):实验环境:windowsXP;vc++;visual studio 2008,MyEclipse6.5实验内容:编写程序模拟时间片轮转法cpu调度。

a、运行编写的程序,写出程序中使用的数据结构及符合说明;b、画出程序的流程图,程序中附有详细的注释;c、运行程序,输入运行时的初值,输出运行结果;d、写出对时间片轮转法cpu调度的认识及它的适应环境;e、改写下面的程序,改成java代码。

4.程序结构(程序中的函数调用关系图)#include "stdio.h"#include "stdlib.h"#include "string.h"typedef struct node{char name[10]; /*进程标识符*/int prio; /*进程优先数*/int round; /*进程时间轮转时间片*/int cputime; /*进程占用CPU时间*/int needtime; /*进程到完成还要的时间*/int count; /*计数器*/char state; /*进程的状态*/struct node *next; /*链指针*/}PCB;PCB *finish,*ready,*tail,*run; /*队列指针*/int N; /*进程数*//*将就绪队列中的第一个进程投入运行*/firstin(){run=ready; /*就绪队列头指针赋值给运行头指针*/run->state='R'; /*进程状态变为运行态*/ready=ready->next; /*就绪对列头指针后移到下一进程*/}/*标题输出函数*/void prt1(char a){if(toupper(a)=='P') /*优先数法*/printf(" 进程号 cpu时间所需时间优先数状态\n");elseprintf(" 进程号 cpu时间所需时间记数时间片状态\n"); }/*进程PCB输出*/void prt2(char a,PCB *q){if(toupper(a)=='P') /*优先数法的输出*/printf(" %-10s%-10d%-10d%-10d %c\n",q->name,q->cputime,q->needtime,q->prio,q->state);else/*轮转法的输出*/printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);}/*输出函数*/void prt(char algo){PCB *p;prt1(algo); /*输出标题*/if(run!=NULL) /*如果运行指针不空*/prt2(algo,run); /*输出当前正在运行的PCB*/p=ready; /*输出就绪队列PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}p=finish; /*输出完成队列的PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}getchar(); /*压任意键继续*/}/*优先数的插入算法*/insert1(PCB *q){PCB *p1,*s,*r;int b;s=q; /*待插入的PCB指针*/p1=ready; /*就绪队列头指针*/r=p1; /*r做p1的前驱指针*/b=1;while((p1!=NULL)&&b) /*根据优先数确定插入位置*/ if(p1->prio>=s->prio){r=p1;p1=p1->next;}elseb=0;if(r!=p1) /*如果条件成立说明插入在r与p1之间*/ {r->next=s;s->next=p1;}else{s->next=p1; /*否则插入在就绪队列的头*/ready=s;}}/*优先数创建初始PCB信息*/void create1(char alg){PCB *p;int i,time;char na[10];ready=NULL; /*就绪队列头指针*/finish=NULL; /*完成队列头指针*/run=NULL; /*运行队列指针*/printf("输入进程号和运行时间:\n"); /*输入进程标识和所需时间创建PCB*/ for(i=1;i<=N;i++){p=(PCB *)malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='w';p->prio=50-time;if(ready!=NULL) /*就绪队列不空调用插入函数插入*/insert1(p);else{p->next=ready; /*创建就绪队列的第一个PCB*/ready=p;}}//clrscr();printf(" 优先数算法输出信息:\n");printf("************************************************\n");prt(alg); /*输出进程PCB信息*/run=ready; /*将就绪队列的第一个进程投入运行*/ready=ready->next;run->state='R';}/*优先数调度算法*/priority(char alg){while(run!=NULL) /*当运行队列不空时,有进程正在运行*/{run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/if(run->needtime==0) /*如所需时间为0将其插入完成队列*/{run->next=finish;finish=run;run->state='F'; /*置状态为完成态*/run=NULL; /*运行队列头指针为空*/if(ready!=NULL) /*如就绪队列不空*/firstin(); /*将就绪对列的第一个进程投入运行*/}else /*没有运行完同时优先数不是最大,则将其变为就绪态插入到就绪队列*/ if((ready!=NULL)&&(run->prio<ready->prio)){run->state='W';insert1(run);firstin(); /*将就绪队列的第一个进程投入运行*/}prt(alg); /*输出进程PCB信息*/}}/*主函数*/main(){char algo; /*算法标记*///clrscr();//printf("选择算法:P/R(优先数算法/时间片轮转算法)\n");//scanf("%c",&algo); /*输入字符确定算法*/algo='p';printf("输入进程数:\n");scanf("%d",&N); /*输入进程数*/if(algo=='P'||algo=='p'){create1(algo); /*优先数法*/priority(algo);}elseif(algo=='R'||algo=='r'){//create2(algo); /*轮转法*///roundrun(algo);}}Java代码:import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.util.Scanner;public class Time{private ArrayList<course> list = new ArrayList<course>();private void input() {System.out.println("输入进程的数量:");Scanner scan = new Scanner(System.in);int num = scan.nextInt();for (int i = 1; i <= num; i++) {course cou = new course();System.out.println("输入进程"+ i + "的进程名,优先级,运行时间"); cou.setName(scan.next());cou.setPower(scan.nextInt());cou.setTime(scan.nextInt());cou.setStatus("W");list.add(cou);}}public int getMax(List<course> list) {Iterator<course> iter = list.iterator();int max = 100;int i = 0, k = 0;while (iter.hasNext()) {course course = (course) iter.next();// max=course.getPower();if (course.getPower()< max) {max = course.getPower();k = i;}i++;}return k;}private void run() {ArrayList<course> list1 = (ArrayList<course>) list.clone(); Time czxt = new Time();int rn = 1;//第几次运行while (list1.size() != 0) {int flag = 0;//作为标志。

实验一单处理器调度算法的实现

实验一单处理器调度算法的实现

实验一单处理器调度算法的实现班级:计算机04-1班学号: 04034040112姓名:汀芷约成绩:___ ________日期:_ 2006-11-02实验一单处理器调度算法的实现一、实验目的在多道程序或多任务系统中,系统同时处于就绪态的进程有若干个。

为了使系统中的各进程能有条不紊地运行,必须选择某种调度策略,以选择占用处理机。

要求学生设计一个模拟单处理机调度的算法,以巩固和加深处理机调度的概念。

二、实验内容设计一个按时间片轮转法调度的算法。

提示:1、假设系统有5个进程,每个进程用一个进程控制块PCB来代表。

PCB 的格式如图所示。

其中,进程名即是进程标识。

链接指针:指出下一个到达进程的进程控制块首地址。

按照进程到达的顺序排队。

系统设置一个队头和队尾指针分别指向第一个和最后一个进程。

新生成的进程放队尾。

2、为每个进程任意确定一个要求运行时间和到达时间。

3、按照进程到达的先后顺序排成一个循环队列。

再设一个队首指针指向第一个到达进程的首地址。

4、执行处理机调度时,开始选择队首的第一个进程运行。

另外再设一个当前运行进程指针,指向当前正运行的进程。

5、由于本实验是模拟实验,所以对被选中进程并不实际启动运行,而是执行:一是估计运行时间减1;二是输出当前运行进程的名字。

用这两个操作来模拟进程的一次执行。

6、进程运行一次后,以后的调度则将当前指针依次下移一个位置,指向下一个进程,即调整当前运行指针指向该进程的链接指针所指进程,以指示应运行进程。

同时还应该判断该进程的剩余运行是否为0。

若不为0,则等待下一轮的运行;若该进程的剩余时间为0,则将该进程的状态置为C,并退出循环队列。

7、若就绪队列不空,则重复上述的(5)和(6)步骤直到所有进程都运行为止。

8、在所设计的调度程序中,应包含显示或打印语句。

以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。

三、实验说明1、程序中使用的数据结构及符号说明:数据结构:数组data[][]符号说明:每个进程的状态是就绪 W(Wait)、运行R(Run)、或完成C(Complete)三种状态之一。

操作系统--时间片轮转法进行CPU调度[1]

操作系统--时间片轮转法进行CPU调度[1]

目录一、设计目的 (1)二、设计内容 (2)三、设计原理 (3)四、算法实现 (4)五、流程图 (5)六、源程序 (6)七、运行示例及结果分析 (11)八、心得体会 (13)九、参考资料 (14)时间片轮转法进行CPU调度一、设计目的进程调度是处理机管理的核心内容。

本设计要求用高级语言编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念,并体会和了解优先权调度算法和时间片轮转调度算法的具体实施办法。

并通过课程设计,让我们更好的掌握操作系统的原理以及实现方法,加深对操作系统基础理论和重要算法的理解,加强我们自身的动手能力。

在多道程序或多任务系统中,系统同时处于就绪状态的进程有若干个,为了使系统中的各进程能有条不紊的进行,选择某种调度策略,以选择一进程占用处理机因此使用时间片轮转算法模拟单处理机调度。

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

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

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

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

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

四、算法实现每个程序用一个进程控制块PCB来代表。

PCB代表:进程名、链接指针、到达时间、估计运行时间和进程状态。

其中进程名既进程标识。

链接指针之处下一个到达进程的进程控制块地址,按照进程到达的顺序排队,统设置一个队头和队尾指针分别指向第一个和最后一个进程,新生成的进程放队尾。

设计者任意指定一个运行时间,进程创建时用户指定到达时间,调度时,总是选择到达时间最早的进程。

进程有就绪和完成状态,进程一创建就处于就绪状态,用R表示,一个程序运行结束时,就将其设置为完成状态,用C表示。

【最新精选】操作系统时间片轮转法进程CPU调度

【最新精选】操作系统时间片轮转法进程CPU调度

东莞理工学院操作系统课程设计报告学院:计算机学院专业班级:软件工程(2)班组成员:提交时间:2014年1月11日指导教师评阅意见:.项目名称:设计一个按时间片轮转法进程CPU调度的程序一、设计目的操作系统课程设计是计算机专业重要的课程,它为学生提供了一个既动手又动脑,将课本上的理论知识和实际游记结合起来,独立分析和解决实际问题的机会。

处理机调度是操作系统中非常重要的部分。

为深入理解进程管理部分的功能,设计调度算法,模拟实现处理机的调度。

本课程设计是用时间片轮转算法模拟单处理机调度。

(1)进一步巩固和复习操作系统的基础知识。

(2)培养结构化程序、模块话程序的方法和能力。

(3)提高学生调试程序的技巧和软件设计的能力。

(4)提高学生分析问题、解决问题以及综合利用编程语言进行程序设计的能力。

二、环境条件Windows系统、VMware Workstation、Ubuntu三、设计内容1. 项目背景操作系统(OS)是计算机系统的重要组成部分,是一个重要的系统软件,它负责管理计算机系统的硬、软件资源和整个计算机的工作流程,协调系统部件之间,系统与用户之间、用户与用户之间的关系。

随着操作系统的新技术的不断出现功能不断增加。

操作系统作为一个标准的套装软件必须满足尽可能多用户的需要,于是系统不断膨胀,功能不断增加,并逐渐形成从开发工具到系统工具再到应用软件的一个平台环境。

更能满足用户的需求。

随着计算机技术的不断发展,人们对于计算机系统性能的要求也越来越高,对于操作系统所使用的算法也在不断地发展。

OS对调度分配实质是一种资源分配,因而调度算法要根据不同的系统资源分配策略所规定的来分配算法。

对于不同的系统目标,又必须采用不同的调度算法。

有的算法适合长作业,有的适合短作业,有的适合作业调度,有的适合进程调度。

操作系统对于各个方面的要求都不得不提到效率的问题,计算机系统的处理机调度便变得尤为重要。

处理机调度的效率甚至可能成为提高计算机处理速度的瓶颈。

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

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

实验一处理器调度一、实习内容选择一个调度算法,实现处理器调度。

二、实习目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。

本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。

三、实习题目本实习有两个题,学生可选择其中的一题做实习。

第二题:设计一个按时间片轮转法实现处理器调度的程序。

[提示]:(1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为:Q1,Q2,Q3,Q4,Q5。

指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程的指针指出第一个进程的进程控制块首地址。

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

已运行时间——假设进程已经运行的单位时间数,初始值为“0”。

状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R”表示。

当一个进程运行结束后,它的状态为“结束”,用“E”表示。

(2) 每次运行所设计的处理器调度程序前,为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列,用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如,当前轮到P2执行,则有:标志单元,K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选择标志单元指示的进程运行。

由于本实习是模拟处理器调度的功能,所以,对被选中的进程并不实际的启动运行,而是执行:已运行时间+1来模拟进程的一次运行,表示进程已经运行过一个单位的时间。

请同学注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片。

在这时省去了这些工作,仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5) 进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运行的进程。

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

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

东莞理工学院操作系统课程设计报告学院:计算机学院专业班级:软件工程(2)班组成员:提交时间:2014年1月11日指导教师评阅意见:.项目名称:设计一个按时间片轮转法进程CPU调度的程序一、设计目的操作系统课程设计是计算机专业重要的课程,它为学生提供了一个既动手又动脑,将课本上的理论知识和实际游记结合起来,独立分析和解决实际问题的机会。

处理机调度是操作系统中非常重要的部分。

为深入理解进程管理部分的功能,设计调度算法,模拟实现处理机的调度。

本课程设计是用时间片轮转算法模拟单处理机调度。

(1)进一步巩固和复习操作系统的基础知识。

(2)培养结构化程序、模块话程序的方法和能力。

(3)提高学生调试程序的技巧和软件设计的能力。

(4)提高学生分析问题、解决问题以及综合利用编程语言进行程序设计的能力。

二、环境条件Windows系统、VMware Workstation、Ubuntu三、设计内容1. 项目背景操作系统(OS)是计算机系统的重要组成部分,是一个重要的系统软件,它负责管理计算机系统的硬、软件资源和整个计算机的工作流程,协调系统部件之间,系统与用户之间、用户与用户之间的关系。

随着操作系统的新技术的不断出现功能不断增加。

操作系统作为一个标准的套装软件必须满足尽可能多用户的需要,于是系统不断膨胀,功能不断增加,并逐渐形成从开发工具到系统工具再到应用软件的一个平台环境。

更能满足用户的需求。

随着计算机技术的不断发展,人们对于计算机系统性能的要求也越来越高,对于操作系统所使用的算法也在不断地发展。

OS对调度分配实质是一种资源分配,因而调度算法要根据不同的系统资源分配策略所规定的来分配算法。

对于不同的系统目标,又必须采用不同的调度算法。

有的算法适合长作业,有的适合短作业,有的适合作业调度,有的适合进程调度。

操作系统对于各个方面的要求都不得不提到效率的问题,计算机系统的处理机调度便变得尤为重要。

处理机调度的效率甚至可能成为提高计算机处理速度的瓶颈。

操作系统实验一:处理器调度算法的实现

操作系统实验一:处理器调度算法的实现

操作系统实验⼀:处理器调度算法的实现⼀、实验⽬的(1)加深对处理机调度的作⽤和⼯作原理的理解。

(2)进⼀步认识并发执⾏的实质。

⼆、实验要求:本实验要求⽤⾼级语⾔,模拟在单处理器情况下,采⽤多个调度算法,对N个进程进⾏进程调度。

语⾔⾃选。

并完成实验报告。

三、实验内容:在采⽤多道程序设计的系统中,往往有若⼲个进程同时处于就绪状态。

当就绪状态进程个数⼤于处理器数时,就必须依照某种策略来决定哪些进程优先占⽤处理器。

1. 进程及进程队列的表⽰。

2. 处理器调度算法:FCFS,SJF,RR,HRRN,MLFQ等3. 跟踪进程状态的转化4. 输出:系统中进程的调度次序,计算CPU利⽤率,平均周转时间和平均带权周转时间四、实验过程与结果1. RR:1.1 算法思想:CPU时间划分为时间⽚,例如100ms时间⽚调度:调度程序每次把CPU分配给就绪队列⾸进程使⽤⼀个时间⽚,就绪队列中的每个进程轮流地运⾏⼀个时间⽚。

当这个时间⽚结束时,强迫⼀个进程让出处理器,让它排列到就绪队列的尾部,等候下⼀轮调度1.2 算法设计:(采⽤描述或程序流程图)Ø进程排序Ø队列不为空时循环:Ø到达?Ø剩余服务时间>时间⽚Ø运⾏时间Ø剩余服务时间Ø剩余服务时间<=时间⽚Ø运⾏时间Ø剩余服务时间、完成时间、周转时间、加权周转时间Ø保存Ø从队列删除进程1.3 算法实现代码package ss;public class Model {private String ProcessName;private int startTime;private int needTime;private int leftTime;private int finishTime;private int cyclingTime;private int QuanTime;public String getProcessName() {return ProcessName;}public void setProcessName(String processName) { ProcessName = processName;}public int getStartTime() {return startTime;}public void setStartTime(int startTime) {this.startTime = startTime;}public int getNeedTime() {return needTime;}public void setNeedTime(int needTime) {this.needTime = needTime;}public int getLeftTime() {return leftTime;}public void setLeftTime(int leftTime) {this.leftTime = leftTime;}public int getFinishTime() {return finishTime;}public void setFinishTime(int finishTime) {this.finishTime = finishTime;}public int getCyclingTime() {return cyclingTime;}public void setCyclingTime(int cyclingTime) {this.cyclingTime = cyclingTime;}public int getQuanTime() {return QuanTime;}public void setQuanTime(int quanTime) {QuanTime = quanTime;}public Model(String name, int start, int need, int left, int finish,int cycle, int quan) {// TODO Auto-generated constructor stubthis.ProcessName=name;this.startTime=start;this.needTime=need;this.leftTime=left;this.finishTime=finish;this.cyclingTime=cycle;this.QuanTime=quan;}public Model() {// TODO Auto-generated constructor stubthis.ProcessName="name";this.startTime=0;this.needTime=0;this.leftTime=0;this.finishTime=0;this.cyclingTime=0;this.QuanTime=0;}}package ss;import java.util.Scanner;public class Test {public static void main(String[] args) {// 动态输⼊信息到控制台 Scanner java.util// Scanner in=new Scanner(System.in);//通过new关键字创建了⼀个Scanner对象 // 类似于扫描仪// System.out.println("请输⼊⼀个进程数:");// int number=in.nextInt();// TODO Auto-generated method stub@SuppressWarnings("unused")// Model process=new Model("A",12.10,12.00,);// System.out.println(process.getProcessName());int num=5;Model arrayName[] = new Model[num];arrayName[0] = new Model("A", 0, 4, 4, 0, 0, 0);arrayName[1] = new Model("B", 1, 3, 3, 0, 0, 0);arrayName[2] = new Model("C", 2, 4, 4, 0, 0, 0);arrayName[3] = new Model("D", 3, 2, 2, 0, 0, 0);arrayName[4] = new Model("E", 4, 4, 4, 0, 0, 0);for (int i = 0; i < 5; i++) {System.out.println(arrayName[i].getProcessName() + ","+ arrayName[i].getStartTime() + ","+ arrayName[i].getNeedTime() + ","+ arrayName[i].getLeftTime() + ","+ arrayName[i].getFinishTime() + ","+ arrayName[i].getCyclingTime() + ","+ arrayName[i].getQuanTime());System.out.print("\n");// 这也是换⼀⾏}// System.out.println(arrayName[0].getProcessName());// for(int i=0;i<number;i++){//// System.out.println("请输⼊第"+i+"个进程名:");// String processName=in.next();// System.out.println("请输⼊第"+i+"个进程到达时间:");// double starTime=in.nextFloat();//// }int index = 0;int runningTime = 0;int q = 2;Model processArrayName[] = new Model[5];while (arrayName.length > 0) {int i = 0;Model p = new Model();p = arrayName[index];if (p.getStartTime() > runningTime)runningTime = p.getStartTime();if (p.getLeftTime() > q) {System.out.printf(p.getProcessName() + "," + q);System.out.print("\n");// 这也是换⼀⾏runningTime += q;int term = p.getLeftTime();term = term - q;p.setLeftTime(term);} else {System.out.printf(p.getProcessName() + "," + p.getLeftTime());System.out.print("\n");// 这也是换⼀⾏runningTime += p.getLeftTime();p.setLeftTime(0);p.setFinishTime(runningTime);p.setCyclingTime(p.getFinishTime() - p.getStartTime());p.setQuanTime(p.getCyclingTime() / p.getNeedTime());System.out.printf("--" + p.getProcessName() + ","+ p.getStartTime() + "," + p.getNeedTime() + ","+ p.getLeftTime() + "," + p.getFinishTime() + ","+ p.getCyclingTime() + "," + p.getQuanTime());System.out.print("\n");// 这也是换⼀⾏processArrayName[i] = p;for (int j = i; j < arrayName.length - 1; j++) {arrayName[j] = arrayName[j + 1];}// arrayName[arrayName.length - 1] = null;num--;}index += 1;if (index > arrayName.length || index == arrayName.length) {index = 0;}i++;}}}2.FCFS算法2. 1算法思想:先来先服务算法按照作业进⼊系统后备作业对列的先后次序来挑选作业,先进⼊系统的作业将优先被挑选进⼊内存,创建⽤户进程,分配所需资源,然后移⼊就绪队列。

操作系统 实验一 CPU调度

操作系统 实验一 CPU调度

实验一CPU调度一、实验内容选择一个调度算法,实现处理机调度。

二、实验目的多道系统中,当就绪进程数大于处理机数时,须按照某种策略决定哪些进程优先占用处理机。

本实验模拟实现处理机调度,以加深了解处理机调度的工作。

三、实验题目1、设计一个按优先权调度算法实现处理机调度的程序;2、设计按时间片轮转实现处理机调度的程序。

四、实验要求PCB内容:进程名/PID;要求运行时间(单位时间);优先权;状态:PCB指针;1、可随机输入若干进程,并按优先权排序;2、从就绪队首选进程运行:优先权-1/要求运行时间-1要求运行时间=0时,撤销该进程3、重新排序,进行下轮调度;4、最好采用图形界面;5、可随时增加进程;6、规定道数,设置后备队列和挂起状态。

若内存中进程少于规定道数,可自动从后备队列调度一作业进入。

被挂起进程入挂起队列,设置解挂功能用于将指定挂起进程解挂入就绪队列。

7、每次调度后,显示各进程状态。

五、实验源码/*** @(#)CPUScheduling.java*** @author Liang Jiabin* @version 1.00 2010/11/5*/import java.awt.*;import javax.swing.*;import java.awt.event.ActionListener;import java.awt.event.ActionEvent;import java.util.Vector;public class CPUScheduling extends Thread{private JFrame frame;private JScrollPane reserveSp,waitingSp,finishSp;private JList reserveList, readyList, waitingList, finishList;private DefaultListModel reserveLm, readyLm, waitingLm, finishLm;private JLabel reserveLbl, readyLbl, CPULbl, waitingLbl, finishLbl;private JTextField CPUTf;private JLabel needTimeLbl, priorityLbl;private JComboBox needTimeCb, priorityCb;private JButton newBtn, suspendBtn, unsuspendBtn, exitBtn;private JLabel rToRLbl,rToCPULbl,CPUToRLbl,CPUToWLbl,wToRLbl;private JLabel CPUToFLbl,warningLbl, explainLbl;private int number = 1; //进程名序号private String CPUProcess = "";private String CPUProcessId = "";private String CPUProcessPriority = "0"; private String CPUProcessTime = "0";private String maxPriorityProcess = "";private String maxPriorityProcessId = ""; private String maxPriorityProcessTime = ""; private String maxPriorityProcessPriority = "0";private Vector waitingReadyV = new Vector(1,1);public CPUScheduling(){frame = new JFrame("CPU Scheduling");Container c = frame.getContentPane();c.setBackground(Color.pink);c.setLayout(null);reserveLbl = new JLabel("后备队列");reserveLbl.setBounds(50,20,60,30);c.add(reserveLbl);reserveLm = new DefaultListModel(); reserveList = new JList(reserveLm);reserveSp = new JScrollPane(reserveList); reserveSp.setBounds(30,50,100,200);c.add(reserveSp);rToRLbl = new JLabel(">>>>>"); rToRLbl.setBounds(145,100,60,30);c.add(rToRLbl);readyLbl = new JLabel("就绪队列"); readyLbl.setBounds(220,20,60,30);c.add(readyLbl);readyLm = new DefaultListModel(); readyList = new JList(readyLm); readyList.setFixedCellHeight(30); readyList.setBounds(200,50,100,200);c.add(readyList);rToCPULbl = new JLabel(">>>>>"); rToCPULbl.setBounds(320,50,50,30);c.add(rToCPULbl);CPUToRLbl = new JLabel("<<<<<"); CPUToRLbl.setBounds(320,65,50,30);c.add(CPUToRLbl);CPULbl = new JLabel("CPU"); CPULbl.setBounds(410,20,50,30);c.add(CPULbl);CPUTf = new JTextField(20); CPUTf.setEditable(false);CPUTf.setBounds(370,55,100,30);c.add(CPUTf);CPUToWLbl = new JLabel("||"); CPUToWLbl.setBounds(415,80,20,50);c.add(CPUToWLbl);wToRLbl = new JLabel("<<<<<"); wToRLbl.setBounds(320,160,50,30);c.add(wToRLbl);waitingLbl = new JLabel("挂起队列"); waitingLbl.setBounds(390,110,60,30);c.add(waitingLbl);waitingLm = new DefaultListModel(); waitingList = new JList(waitingLm);waitingSp = new JScrollPane(waitingList); waitingSp.setBounds(370,140,100,200); c.add(waitingSp);CPUToFLbl = new JLabel(">>>>>"); CPUToFLbl.setBounds(480,55,50,30);c.add(CPUToFLbl);finishLbl = new JLabel("完成队列"); finishLbl.setBounds(560,20,60,30);c.add(finishLbl);finishLm = new DefaultListModel();finishList = new JList(finishLm);finishSp = new JScrollPane(finishList);finishSp.setBounds(540,50,100,200);c.add(finishSp);needTimeLbl = new JLabel("要求运行时间"); needTimeLbl.setBounds(10,330,100,30);c.add(needTimeLbl);String[] time = {"1","2","3","4","5","6","7","8","9"}; needTimeCb = new JComboBox(time); needTimeCb.setEditable(true);needTimeCb.setBounds(95,330,60,30);c.add(needTimeCb);priorityLbl = new JLabel("优先权");priorityLbl.setBounds(175,330,50,30);c.add(priorityLbl);String[] priority = {"1","2","3","4","5","6","7","8","9"}; priorityCb = new JComboBox(priority);priorityCb.setBounds(220,330,60,30);c.add(priorityCb);newBtn = new JButton("增加");newBtn.setBounds(120,380,60,30);c.add(newBtn);warningLbl = new JLabel();warningLbl.setForeground(Color.RED);warningLbl.setBounds(360,350,200,30);c.add(warningLbl);suspendBtn = new JButton("挂起");suspendBtn.setBounds(340,380,60,30);c.add(suspendBtn);unsuspendBtn = new JButton("解挂");unsuspendBtn.setBounds(440,380,60,30);c.add(unsuspendBtn);exitBtn = new JButton("退出");exitBtn.setBounds(560,380,60,30);c.add(exitBtn);explainLbl = new JLabel("注:进程信息表示为“进程名,需要运行时间,优先权”");explainLbl.setBounds(10,420,500,30);c.add(explainLbl);//Button事件注册ButtonListener btnListener = new ButtonListener();newBtn.addActionListener(btnListener);suspendBtn.addActionListener(btnListener);unsuspendBtn.addActionListener(btnListener);exitBtn.addActionListener(btnListener);//调度器线程开启this.start();frame.setSize(720,520);frame.setVisible(true);frame.setLocationRelativeTo(null);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}/** 开启线程*/public synchronized void run(){try{while (true){//判断waiting队列是否有进程在等待进ready队列while (readyLm.size()<4 && waitingReadyV.size() != 0){String s = waitingReadyV.get(0).toString();readyLm.addElement(s);wToRLbl.setForeground(Color.RED);this.sleep(500);wToRLbl.setForeground(Color.BLACK);waitingReadyV.remove(0);waitingLm.removeElement(s);}//判断后备队列进程能否进就绪队列while (readyLm.size()<4 && !reserveLm.isEmpty()){readyLm.addElement(reserveLm.getElementAt(0));rToRLbl.setForeground(Color.RED);this.sleep(500);rToRLbl.setForeground(Color.BLACK);reserveLm.removeElementAt(0);}//对就绪队列中的进程按优先级排序,找出优先级最大的进入CPU运行if (!readyLm.isEmpty()){String[] s;int index = -1;for (int i=readyLm.size()-1; i>=0; i--){s = readyLm.getElementAt(i).toString().split(",");if (Integer.parseInt(s[2]) >= Integer.parseInt(CPUProcessPriority)){maxPriorityProcess = readyLm.getElementAt(i).toString();maxPriorityProcessId = s[0];maxPriorityProcessTime = s[1];maxPriorityProcessPriority = s[2];index = i;CPUProcessPriority = maxPriorityProcessPriority;}}if (!maxPriorityProcessId.equals(CPUProcessId)){CPUProcess = maxPriorityProcess;CPUProcessId = maxPriorityProcessId;CPUProcessTime = maxPriorityProcessTime;CPUProcessPriority = maxPriorityProcessPriority;}rToCPULbl.setForeground(Color.RED);CPUTf.setText(CPUProcessId);this.sleep(500);readyLm.removeElement(CPUProcess);rToCPULbl.setForeground(Color.BLACK);}this.sleep(1000); //在CPU上运行一秒//时间片到了,CPU上的进程转到就绪队列或完成队列if (!CPUTf.getText().equals("")){CPUTf.setText("");int time = Integer.parseInt(CPUProcessTime);CPUProcessTime = String.valueOf(--time);if (Integer.parseInt(CPUProcessPriority) > 1) //若优先级不为1则减1{int priority = Integer.parseInt(CPUProcessPriority);CPUProcessPriority = String.valueOf(--priority);}if (Integer.parseInt(CPUProcessTime) != 0) //要求运行时间不为0则进入ready队列{CPUProcess = CPUProcessId + "," + CPUProcessTime + "," + CPUProcessPriority;readyLm.addElement(CPUProcess);CPUToRLbl.setForeground(Color.RED);this.sleep(500);CPUTf.setText("");CPUToRLbl.setForeground(Color.BLACK);}else //要求运行时间为0则转到完成队列{CPUToFLbl.setForeground(Color.RED);CPUProcessTime = String.valueOf(0);CPUProcessPriority = String.valueOf(0);CPUProcess = CPUProcessId + "," + CPUProcessTime + "," + CPUProcessPriority;finishLm.addElement(CPUProcess);CPUProcessId = "";this.sleep(500);CPUToFLbl.setForeground(Color.BLACK);}}}}catch (Exception e){e.printStackTrace();}}/** 按钮监听器*/class ButtonListener implements ActionListener{public synchronized void actionPerformed(ActionEvent ae) {JButton source = (JButton)ae.getSource();if (source == newBtn) //增加进程{String time = "1";time = needTimeCb.getSelectedItem().toString();String priority = "1";priority = priorityCb.getSelectedItem().toString();String pid = String.valueOf(number);String reserveItem = "";reserveItem = "P" + pid + "," + time + "," + priority;reserveLm.addElement(reserveItem);number++;}else if (source == suspendBtn) //挂起进程{System.out.println("点击挂起" ); /////if (!CPUTf.getText().equals("")){CPUToWLbl.setForeground(Color.RED);CPUTf.setText("");CPUProcessId = "";waitingLm.addElement(CPUProcess);System.out.println("挂起成功" ); /////try{sleep(500);}catch (Exception e){}CPUToWLbl.setForeground(Color.BLACK);}}else if (source == unsuspendBtn) //解挂进程{System.out.println("点击解挂" ); /////String unsuspendProcess = "";if (waitingList.getSelectedValue()!= null){unsuspendProcess = waitingList.getSelectedValue().toString();waitingReadyV.add(unsuspendProcess);warningLbl.setText("");System.out.println("解挂成功" ); /////}else{warningLbl.setText("请选要择解挂的进程");}}else if (source == exitBtn) //退出程序{System.exit(0);}}}/** main函数*/public static void main(String args[]){new CPUScheduling();}}六、实验结果。

操作系统实验报告时间片轮转调度算法

操作系统实验报告时间片轮转调度算法

操作系统实验报告时间片轮转调度算法“网络协议分析”实验4实验名称:用Ethereal研究DNS和HTTP协议实验目的:通过对捕获分组的分析和研究,加深对DNS协议和HTTP协议的工作原理和实现过程的理解。

实验环境:连网PC机,Ethereal网络协议分析软件实验步骤:1.安装Ethereal网络协议分析器。

2.打开Ethereal软件菜单中的Help->Contents,可学习Ethereal的使用方法。

3.开始捕获分组之前,清空客户端Web浏览器的高速缓存和DNS的高速缓存(命令为:ipconfig /flushdns)。

(想一想,为什么?)4.在Capture->Option里选择网卡类型;取消捕获分组的“混杂模式”;设置捕获过滤器为:“host 本机IP”,这样Ethereal就会只捕获从本机发出的和发往本机的分组。

5.点击Start启动协议分析器,用Ethereal捕获从本机发出和发往本机的分组。

6.在Web浏览器中输入URL(如.cn, 等,网页较简单)。

网页显示出来后,过一会儿停止捕获。

将跟踪文件保存在一个文件中。

实验结果分析:1.在跟踪列表框中找出请求网页时发出的DNS查询报文和回答报文,找出发起TCP连接的三次握手报文,找出HTTP请求报文和响应报文。

2.在协议框中找出各层协议,观察各层协议,并对照教材中DNS查询/回答报文结构和HTTP请求/响应报文结构对这些应用层报文进行分析,找出报文中各字段相应的内容,解释其含义和用途。

3.你的主机所用的DNS服务器的IP地址是多少?你的浏览器与DNS服务器之间使用传输层的什么协议进行通信?202.196.0.1DNS请求报文和应答报文的ID号一样吗?是什么?一样,0xc4a6你所请求网站的规范名是什么?mail.DNS服务器对你的域名解析请求在应答中给出了几个可用的IP地址?都是什么?2个,202.196.0.16,202.196.0.17和DNS服务器通信时,你的客户机使用的端口号是多少?DNS服务器使用的端口号是多少?64384,53你所请求Web服务器的IP地址是什么?其域名有几个层次(参看教材127页)?202.196.0.16 4个如果请求一个存在/不存在的网页,Web服务器分别会应答什么? ??等等。

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

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

实验一时间片轮转进程调度算法时间片轮转是一种常用的进程调度算法,它的基本思想是将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调度的示例

时间片轮转法进行CPU调度的示例
{ printf(“time slice is %8d(time %4d);process %s start,\n”,current,(current+500)/1000,p3->pname);
fprintf(f,“time slice is %8d(time %4d);process %s start,\n”,current,(current+500)/1000,p3->pname);
return ;
else
{cur=pcb_input;
pre=cur->next;
while (pre->next!=cur) //find the last node in the list
{ pre=pre->next;
}
scanf(“%s”,p1->pname);
fprintf(f, “%s\n”,p1->pname);
printf(“ runtime:”);
fprintf(f, “ runtime:”);
while ((cur->runtime>=0)|| (cur->next!=cur))
// while(1)
// if p1->next!=p1,it means that there are more than one pcb jobs
// if p1->next= =p1 and p1->runtime<=0 means all jobs have done;
/*定义判断就绪队列是否有进程函数*/
int readydata()
{ if (head_input.next= =NULL)

处理机调度时间片轮转调度算法

处理机调度时间片轮转调度算法
charቤተ መጻሕፍቲ ባይዱtemp1 = name[j];
int temp2 = time[j];
priority[j] = priority[j + 1];
name[j] = name[j + 1];
time[j] = time[j + 1];
priority[j + 1] = temp;
name[j + 1] = temp1;
cout << endl << "没有排序的进程:" << endl;
showData();
for (int i = 0; i < Num; i++)
{
for (int j = 0; i + j < Num - 1; j++)
{
if (priority[j] < priority[j + 1])
{
int temp = priority[j];
{
int flag = Num;//记录剩余进程数
int round = 0; //轮转数
while(time[0]>0)
{
cout << "\n正在运行进程" << name[0] << endl;
showData();
time[0]--;
if (time[0] == 0)
{
cout << "\n*********************进程 " << name[0] << " 时间为0销毁***************************\n";

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

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

实验一时间片轮转进程调度算法时间片轮转(Round Robin)是一种常见的进程调度算法,其核心思想是每个进程被分配一个时间片,当时间片用完时,CPU会切换到下一个进程。

这种算法简单高效,能够保证每个进程都能获得公平的CPU时间。

在时间片轮转算法中,每个进程被分配一个相同大小的时间片,通常为几十毫秒到几百毫秒不等。

当一个进程占用完了其时间片,CPU会将其放入就绪队列的末尾,并将CPU分配给队列中的下一个进程。

这种方式可以确保每个进程都有机会运行,并且不会出现某个进程长时间占用CPU,导致其他进程饥饿的情况。

时间片轮转算法的优点之一是简单易实现,只需要设置一个固定的时间片大小和一个就绪队列即可。

另外,由于每个进程都有相同的时间片,因此可以较好地保证公平性,避免某个进程长时间占用CPU而导致其他进程无法运行的情况。

然而,时间片轮转算法也存在一些缺点。

首先,如果时间片设置过小,会导致频繁的进程切换,增加了系统的开销。

而如果时间片设置过大,可能会出现某些进程长时间占用CPU的情况,降低了系统的响应速度。

因此,选择合适的时间片大小对系统的性能至关重要。

另外,时间片轮转算法对I/O密集型的进程并不友好。

由于I/O操作需要等待外部设备的响应,进程可能会在I/O操作期间主动放弃CPU,这样会导致进程在等待I/O时浪费了部分时间片。

为了解决这个问题,可以考虑将I/O操作的等待时间纳入时间片,或者采用其他更适合I/O密集型进程的调度算法。

总的来说,时间片轮转算法是一种简单高效的进程调度算法,适用于大多数情况下。

在实际应用中,需要根据系统的特点和需求选择合适的时间片大小,以提高系统的性能和响应速度。

同时,针对不同类型的进程可以结合其他调度算法,以达到更好的效果。

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

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

实验概述:【实验目的及要求】用C 语言编程实现时间片轮转调度算法【实验原理】基于时间片轮转调度算法思想用C 语言编程实现【实验环境】(使用的软件)Visual C++6.0 实验内容:本实验模拟在单处理机情况下处理机调度,用C 语言编程实现先来先服务和最短作业优先调度算法。

【实验方案设计】时间片大小固定,由用户输入。

进程个数由用户输入。

a. 每个进程用一个PCB 表示。

PCB 包括进程名,到达时间,运行时间,剩余时间,进程状态,链接指针。

其中,进程名,到达时间和运行时间由用户输入,剩余时间的初值等于运行时间。

为简单起见,进程状态设为三种:就绪,运行和完成。

链接指针指向下一个进程的PCB ;b. 按照进程到达的先后顺序排成一个队列。

设置一个队头指针指向队列中第一个进程,并设置一个队尾指针指向队列中的最后一个进程;c. 执行调度时,先选择队首的第一个进程运行。

另外设置一个指向当前运行进程的指针;d. 由于本实验是模拟实验,所以对选中进程并不实际启动运行,而只是执行:被选中进程的状态置为运行态;被选中进程的剩余时间减去时间片大小;按照队列的顺序依次输出每个进程的进程名,到达时间,运行时间,剩余时间,进程状态。

用这三个操作来模拟进程的一次运行;e. 进程运行一次后,以后的调度则将当前指针依次下移一个位置,指向下一个进程,即调整当前运行指针,以指示应运行进程。

同时还应判断该进程的剩余时间是否为0。

如果不为0,则等待下一轮的运行;如果该进程的剩余时间为0,则将该进程的状态置为完成态,并退出队列;f. 若处于就绪态的进程不为空,则重复第d步和第e步直到所有进程都运行完为止。

【实验过程】(实验步骤、记录、数据、分析)测试用例1:屏幕显示:Please input the process name, arrive time and run time 输入:1 2 1<enter>2 3 2<enter>3 4 3<enter>屏幕显示:Please input the slice1<enter>屏幕输出结果:name arrive run rest state1 2 1 0 running2 3 2 2 ready3 4 3 3 readyname arrive run rest state2 3 2 1 running3 4 3 3 readyname arrive run rest state2 3 2 1 ready3 4 3 2 runningname arrive run rest state2 3 2 0 running3 4 3 2 readyname arrive run rest state3 4 3 1 runningname arrive run rest state3 4 3 0 running测试数据2:2 3 11 2 35 4 2 测试数据3:【结论】(结果)测试数据1 的运行结果(截图):测试数据2 的运行结果:幸* 斗 ********* 承*3∣C* ******** 承*** ********** name arrive run rest State1 2 3 2 ready2 3 1 O runningL 4 2 2 Ieady**************************************running**3fα}c*********************************D ∖wi∩c201O4∖CYuYan ,∙bin ∖;VwtemPeXePIeaSe input the PrOCeSS number:3PIeaSe input example: 132FOr 2 1 1 the 1 2 PrOCeSS name, arrive time and run time :1 name arrive run rest State1 2 3 2 running2 3 1 L ready1 42 2 readyslice :1PIeaSe inpUt **⅛*********************************** amethe LJname arrive run 2 3 rest 2 Statereadyname arrive run 2 3 4 2 rest Staterunningreadyarrive 24 run rest Statereadyrunningame arrive run2 rest StaterunningPreSS any continue.to测试数据3 的运行结果:源程序代码:#include "stdio.h"#include "stdlib.h"struct stud{int name;int arrive;int run; intrest;char *state;}void output( struct stud *head){ struct stud *p, *t, *r; int slice;printf( "Please input the slice:" ); scanf( "%d" ,&slice); while (head != NULL){ r=p=head;while (p!= NULL){t =head;p-> rest =p-> rest - slice; p-> state = "running" ; if (p -> rest < 0)p-> rest =0;printf( "\n **************************************\n)";printf( "name\tarrive\trun\trest\tstate\n" ); while (t != NULL){printf( "%d\t%d\t%d\t%d\t%s\n" ,t-> name,t -> arrive,t -> run,t -> rest,t -> t=t -> next;state);}if(p-> rest == 0)/* 判断是否删除结点*/{ if (p== head){head =p-> next;free(p);p=head; }/* 删除头结点*/else{r-> next =p-> next; p=r-> next; r=p;}}else{r=p;p-> state = "ready" ; p=p-> next;}}}}void main(){struct stud *head; head =create(); output(head) ;}【小结】实验中产生的错误及原因分析:1、程序运行不下去:错误分析:链表初始化排序过程中:指针p=Null 时,不能执行q->arrive 等命令;错误解决方法:将while(q-> arrive <p-> arrive &&q){t=q;q=q-> next; }改为:while (q&& q-> arrive < p-> arrive){t=q;q=q-> next; }2、进程运行时间大于时间片时,程序进入死循环:当进程所需时间等于时间片时,运行结果正确:进程运行时间大于时间片时,程序进入死循环:错误分析:进程所需剩余时间计算错误;错误修改:将while(p!=NULL) {t =head;p-> rest =p ->run- slice;p-> state ="running" ;修改为:while (p!= NULL){t =head;p-> rest =p ->rest- slice;p-> state ="running" ; 错误3:测试数据:1 2 1 3 1 3 Slice=2 结果为:实验的体会及收获:通过这次试验,我对处理机的调度算法---基于时间片轮转调度算法思想有了更深的理解;另外使我对链表的知识有了更深的理解,而且锻炼了我的思维能力,使我能更全面地思考问题,以后还需要多做些这方面的练习。

处理器调度实验报告汇编

处理器调度实验报告汇编

处理器调度班级:10网工三班学生姓名:谢昊天学号:1215134046实验目的和要求:选择一个调度算法,实现处理器调度。

在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。

实验内容与分析设计:本实验有两个题,学生可选择其中的一题做实验。

第一题:设计一个按优先数调度算法实现处理器调度的程序。

[提示]:(1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:进程名,指针,要求运行时间,优先数,状态(2) 在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。

(3) 为了调度方便,把五个进程按给定的优先数从大到小连成队列。

用一单元指出队首进程,用指针指出队列的连接情况。

(4) 处理器调度总是选队首进程运行。

采用动态改变优先数的办法,进程每运行一次优先数就减“1”。

由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:优先数-1要求运行时间-1来模拟进程的一次运行。

提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行结束。

在这里省去了这些工作。

(5) 进程运行一次后,若要求运行时间,则再将它加入队列(按优先数大小插入,且置队首标志);若要求运行时间=0,则把它的状态修改成“结束”(E),且退出队列。

(6) 若“就绪”状态的进程队列不为空,则重复上面(4)和(5)的步骤,直到所有进程都成为“结束”状态。

(7) 在所设计的程序中应有显示或打印语句,能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。

(8) 为五个进程任意确定一组“优先数”和“要求运行时间”,启动所设计的处理器调度程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

实验一单处理器调度算法的实现

实验一单处理器调度算法的实现

实验一单处理器调度算法的实现班级:计算机04-1班学号: 04034040112姓名:汀芷约成绩:___ ________日期:_ 2006-11-02实验一单处理器调度算法的实现一、实验目的在多道程序或多任务系统中,系统同时处于就绪态的进程有若干个。

为了使系统中的各进程能有条不紊地运行,必须选择某种调度策略,以选择占用处理机。

要求学生设计一个模拟单处理机调度的算法,以巩固和加深处理机调度的概念。

二、实验内容设计一个按时间片轮转法调度的算法。

提示:1、假设系统有5个进程,每个进程用一个进程控制块PCB来代表。

PCB 的格式如图所示。

其中,进程名即是进程标识。

链接指针:指出下一个到达进程的进程控制块首地址。

按照进程到达的顺序排队。

系统设置一个队头和队尾指针分别指向第一个和最后一个进程。

新生成的进程放队尾。

2、为每个进程任意确定一个要求运行时间和到达时间。

3、按照进程到达的先后顺序排成一个循环队列。

再设一个队首指针指向第一个到达进程的首地址。

4、执行处理机调度时,开始选择队首的第一个进程运行。

另外再设一个当前运行进程指针,指向当前正运行的进程。

5、由于本实验是模拟实验,所以对被选中进程并不实际启动运行,而是执行:一是估计运行时间减1;二是输出当前运行进程的名字。

用这两个操作来模拟进程的一次执行。

6、进程运行一次后,以后的调度则将当前指针依次下移一个位置,指向下一个进程,即调整当前运行指针指向该进程的链接指针所指进程,以指示应运行进程。

同时还应该判断该进程的剩余运行是否为0。

若不为0,则等待下一轮的运行;若该进程的剩余时间为0,则将该进程的状态置为C,并退出循环队列。

7、若就绪队列不空,则重复上述的(5)和(6)步骤直到所有进程都运行为止。

8、在所设计的调度程序中,应包含显示或打印语句。

以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。

三、实验说明1、程序中使用的数据结构及符号说明:数据结构:数组data[][]符号说明:每个进程的状态是就绪 W(Wait)、运行R(Run)、或完成C(Complete)三种状态之一。

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

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

实验一处理器调度一、实验内容选择一个调度算法,实现处理器调度。

二、实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。

本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。

三、实验题目第二题:设计一个按时间片轮转法实现处理器调度的程序。

[提示]:(1)假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为:其中,Q1,Q2,Q3,Q4,Q5。

指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。

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

已运行时间——假设进程已经运行的单位时间数,初始值为“0”。

状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R”表示。

当一个进程运行结束后,它的状态为“结束”,用“E”表示。

(2) 每次运行所设计的处理器调度程序前,为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列,用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如,当前轮到P2执行,则有:标志单元K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4)处理器调度总是选择标志单元指示的进程运行。

由于本实习是模拟处理器调度的功能,所以,对被选中的进程并不实际的启动运行,而是执行:已运行时间+1来模拟进程的一次运行,表示进程已经运行过一个单位的时间。

请同学注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片。

在这时省去了这些工作,仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5)进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运行的进程。

实验一处理器调度实验报告

实验一处理器调度实验报告

实验一处理器调度之五兆芳芳创作一、实验内容选择一个调度算法,实现处理器调度.二、实验目的在采取多道程序设计的系统中,往往有若干个进程同时处于就绪状态.当就绪状态进程个数大于处理器数时,就必须依照某种战略来决定哪些进程优先占用处理器.本实验模拟在单处理器情况下处理器调度,帮忙学生加深了解处理器调度的任务.三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示:(1)假定系统有五个进程,每一个进程用一个进程控制块PCB 来代表.进程控制块的格式为:其中,进程名----作为进程的标识,假定五个进程的进程名辨别是P1,P2,P3,P4,P5.指针----按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块首地址,最后一个进程中的指针为“0”.要求运行时间----假定进程需要运行的单位时间数.优先数----付与进程的优先数,调度时总是选取优先数大的进程先执行.状态----可假定有两种状态,“就绪”状态和“结束“状态,五个进程的初始状态都为“就绪“状态,用“R”暗示,当一个进程运行结束后,它的状态变成“结束”,用“E”暗示.(2)在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”.(3)为了调度便利,把五个进程按给定的优先数从大到小连成队列,用一单元指出队首进程,用指针指出队列的连接情况.例:队首标记(4)处理器调度总是选队首进程运行.采取动态改动优先数的方法,进程每运行一次优先数就减“1”.由于本实验是模拟处理器调度,所以,对被选中的进程其实不实际的启动运行,而是执行:优先数-1要求运行时间-1来模拟进程的一次运行.提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,它占有处理器运行,直到出现等待事件或运行结束.在这里省去了这些任务.(5)进程运行一次后,若要求运行时间≠0,则再将它参加队列(按优先数大小拔出,且置队首标记);若要求运行时间=0,则把它的状态修改成“结束”(),且退出队列.(6)若“就绪”状态的进程队列不为空,则重复上面(4)和(5)的步调,直到所有进程都成为“结束”状态.(7)在所设计的称序中应有显示或打印语句,能显示或打印每次被选中进程的进程名以及运行一次落后称对列的变更.(8)为五个进程任意确定一组“优先数”和“要求运行时间”,启动所设计的处理器调度程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变更进程.四、程序中使用的数据结构及符号说明:#define num 5//假定系统中进程个数为5struct PCB{char ID;//进程名int runtime;//要求运行时间int pri;//优先数char state; //状态,R-就绪,F-结束};struct PCB pcblist[num];//定义进程控制块数组五、流程图:(1)(2)子程序init()(3) 子程序max_pri_process()流程图:(4)子程序show()流程图:(5)子程序run()流程图://按优先数调度算法实现处理器调度的程序#include "stdio.h"#include "string.h"#define num 5//假定系统中进程个数为5struct PCB{char ID;//进程名int runtime;//要求运行时间int pri;//优先数char state; //状态,R-就绪,F-结束};struct PCB pcblist[num];//定义进程控制块数组void init()//PCB初始化子程序{int i;for(i=0;i<num;i++){printf("PCB[%d]:ID pri runtime \n",i+1);//为每个进程任意指定pri和runtimescanf("%s%d%d",&pcblist[i].ID,&pcblist[i].pri,&pcblist[i].runti me);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=='F')//具有最大优先数的进程若已运行完毕return -1;//则前往-1else//不然return key;//将key作为前往值前往}void show()//显示子程序{int i;printf("\n ID pri runtime state\n");printf("-------------------------------------------------\n");for(i=0;i<num;i++)//依次显示每个进程的名、优先数、要求运行时间和状态{printf("%s%6d%8d %s\n",&pcblist[i].ID,pcblist[i].pri,pcblist [i].runtime,&pcblist[i].state);}printf(" press any key to continue...\n");}void run()//进程运行子程序{int i,j;int t=0;//t为运行次数for(j=0;j<num;j++){t+=pcblist[j].runtime;}//运行次数即为各个进程运行时间之和printf("\nbefore run,the conditon is:\n");show(); //调用show()子程序显示运行前PCB的情况getchar();//等待输入回车符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'){ pcblist[i].pri-=1;//将当前运行进程的优先数减1 pcblist[i].runtime--;//要求运行时间减1{if(pcblist[i].runtime==0)pcblist[i].state='F';//运行完则将该进程状态置为结束elsepcblist[i].state='R';//未运行完将其状态置为就绪}show();//显示每次运行后各PCB的情况getchar();//等待回车进入下一次运行} } }}void main()//按动态优先数调度主程序{init();//初始化各个进程PCBrun();//进程调度模拟}七、实验总结本次实验通过课本处理器调度的进程的初步认识和实验按优先数调度算法实现处理器调度的实现,了解到进程与进程控制块之间的联系,进程运行进程中状态以及已运行时间的判断和计较,选中运行的进程名以及选中进程运行后的各进程控制块状态.。

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

实验一处理器调度
一、实习内容
选择一个调度算法,实现处理器调度。

二、实习目的
在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。

本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。

三、实习题目
本实习有两个题,学生可选择其中的一题做实习。

第二题:设计一个按时间片轮转法实现处理器调度的程序。

[提示]:
(1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为:
Q1,Q2,Q3,Q4,Q5。

指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程的指针指出第一个进程的进程控制块首地址。

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

已运行时间——假设进程已经运行的单位时间数,初始值为“0”。

状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R”表示。

当一个进程运行结束后,它的状态为“结束”,用“E”表示。

(2) 每次运行所设计的处理器调度程序前,为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列,用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如,当前轮到P2执行,则有:
标志单元

K1K2K3K4K5
PCB1 PCB2 PCB3 PCB4 PCB5
(4) 处理器调度总是选择标志单元指示的进程运行。

由于本实习是模拟处理器调度的功能,所以,对被选中的进程并不实际的启动运行,而是执行:
已运行时间+1
来模拟进程的一次运行,表示进程已经运行过一个单位的时间。

请同学注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片。

在这时省去了这些工作,仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5) 进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运行的进程。

同时,应判断该进程的要求运行时间与已运行时间,若该进程的要求运行时间 已运行时间,则表示它尚未执行结束,应待到下一轮时再运行。

若该进程的要求运行时间=已运行时间,则表示它已经执行结束,应指导它的状态修改成“结束”(E)且退出队列。

此时,应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。

(6) 若“就绪”状态的进程队列不为空,则重复上面的(4)和(5)的步骤,直到所有的进程都成为“结束”状态。

(7) 在所设计的程序中应有显示或打印语句,能显示或打印每次选中进程的进程名以及运行一次后进程队列的变化。

(8) 为五个进程任意确定一组“要求运行时间”,启动所设计的处理器调度程序,显示或打印逐次被选中的进程名以及进程控制块的动态变化过程。

2.所用数据结构及符号说明
typedef struct PNode { // PCB
struct PNode *next; // 定义指向下一个节点的指针
char name[10]; // 定义进程名,并分配空间
int All_Time; // 定义总运行时间
int Runed_Time; // 定义已运行时间
char state; // 定义进程状态 Ready / End
}* Proc; // 指向该PCB的指针
int ProcNum; // 总进程个数
3.流程图与源程序
int Runed_Time; // 定义已运行时间
char state; // 定义进程状态 Ready / End
}* Proc; // 指向该PCB的指针
int ProcNum; // 总进程个数
// 初始化就绪队列
void InitPCB(Proc &H) {
cout<<"请输入总进程个数: ";
cin>>ProcNum; // 进程总个数
int Num=ProcNum;
H=(Proc)malloc(sizeof(PNode)); // 建立头节点
H->next=NULL;
Proc p=H; //定义一个指针
cout<<"总进程个数为 "<<ProcNum<<" 个,请依次输入相应信息\n\n";
while (Num--) {
p=p->next=(Proc)malloc(sizeof(PNode));
cout<<"进程名总运行时间已运行时间 :";
cin>>p->name>>p->All_Time>>p->Runed_Time;
p->state='R';
p->next=NULL;
}
p->next=H->next;
}
//输出运行中的进程信息
void DispInfo(Proc H) {
Proc p=H->next;
do {
if (p->state != 'E') //如果该进程的状态不是End的话
{
cout<<"进程名:"<<p->name<<"\t总运行时间:"<<p->All_Time <<"\t已运行时间:"<<p->Runed_Time
<<"\t状态:"<<p->state<<endl;
p=p->next;
}
else p=p->next;
} while (p != H->next); // 整个进程链条始终完整,只是状态位有差异}
// 时间片轮转法
void SJP_Simulator(Proc &H) {
cout<<endl<<"-------------------START--------------------\n";
int flag=ProcNum; // 记录剩余进程数
int round=0; // 记录轮转数
Proc p=H->next;
while (p->All_Time > p->Runed_Time) { // 即未结束的进程
round++;
cout<<endl<<"Round "<<round<<"--正在运行"<<p->name<<" 进程"<<endl;
p->Runed_Time++; // 更改正在运行的进程的已运行时间
DispInfo(H); // 输出此时为就绪状态的进程的信息
if (p->All_Time == p->Runed_Time) { // 并判断该进程是否结束 p->state='E';
flag--;
cout<<p->name<<" 进程已运行结束,进程被删除!\n";
}
p=p->next;
while (flag && p->All_Time == p->Runed_Time)
p=p->next; // 跳过先前已结束的进程
}
cout<<endl<<"--------------------END---------------------\n";
}
void main() {
Proc H;
InitPCB(H); // 数据初始化
DispInfo(H); // 输出此刻的进程状态
SJP_Simulator(H); // 时间片轮转法
system("pause");
}
五、测试数据与实验结果
六、结果分析与实验体会
时间片轮转算法中,系统将所有的就绪程序按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。

当执行的时间片用完时,调度程序停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。

相关文档
最新文档