进程调度实验三

合集下载

进程调度实验报告

进程调度实验报告

进程调度实验报告
实验名称实验三进程调度
⼀.实验⽬的
了解进程的调度机制,掌握短作业优先算法、时间⽚轮转算法(RR)和优先数算法,并理解响应时间和周转时间的意义。

⼆.实验内容
模拟短作业优先算法、时间⽚轮转算法(RR)和优先数算法的执⾏情况,并动态画出其进程执⾏的 Gantt 图,计算以上算法的每个进程的响应时间和周转时间。

三.实验步骤和结果
1、需要模拟执⾏的进程序列如下:
进程名到达时间运⾏时间优先数
P1 0 7 5
P2 1 1 1
P3 1 3 4
P4 2 5 3
P5 4 4 2
假设:优先数越⼩优先级越⾼;所有进程都是纯 CPU 型进程。

请把上表的数据按照你⾃⼰设计的格式存为⼀个⽂本⽂件 JOB1.TXT。

2、编写⼀个模拟程序,可以读⼊⽂本⽂件 JOB1.TXT 中描述的进程序列,然后模拟短作业优先算法、时间⽚轮转算法(RR)和优先数算法的执⾏情况,并动态画出其进程执⾏的 Gantt 图,计算以上算法的每个进程的响应时间和周转时间。

3、读⼊⽂本⽂件 JOB1.TXT 中描述的进程序列,按照短作业优先算法执⾏程序。

4、按照时间⽚轮转算法执⾏程序时间⽚⼤⼩分布为 1、2 和 3。

5、按照优先数算法执⾏程序。

程序执⾏结果见下图:
第1页,共2页
教务处制
四.实验总结
通过这次试验,我们更加深刻地理解了有关于进程调度的内容,响应时间就是进程刚开始被执⾏的时间,等待时间就是进程在就绪队列中等待的时间,周转时间就是进程被执⾏完毕的时间(包括等待进⼊内存的时间,在就绪队列中的等待时间,执⾏时间,I/O时间)。

实验三 模拟进程调度

实验三   模拟进程调度

实验三模拟进程调度一实验目的理解操作系统进程管理中进行进程调度的过程和编程方法,掌握先来先服务调度算法和最高优先数优先的调度算法,创建进程控制块PCB。

理解进程的状态及变化,动态显示每个进程的当前状态及进程的调度情况二实验要求编写一个允许多个进程并发执行的进程调度程序。

1)进程调度算法:进程的调度采用最高优先数优先的调度算法和先来先服务调度算法相结合的算法,并且采用动态优先数策略,选择进程占用处理器后该进程仅能使用一个时间片,运行完后优先数减1。

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

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等.3)进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

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

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

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

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

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

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

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

重复以上过程,直到所要进程都完成为止三概要设计进程控制块:描述进程的状态信息,用结构体定义typedef struct process{ char name[10]; //进程名int priority; //优先数Time ReachTime; //到达时间Time NeedTime; //需要运行时间Time UsedTime; //已用时间char state; //进程状态}PCB; //进程控制块图1.进程调度模拟程序模块图算法思想:定义结构体PCB描述进程的进程控制块,定义数组PCB pcb[Max]存放进程。

进程调度程序实验报告

进程调度程序实验报告

一、实验目的通过本次实验,加深对进程调度原理和算法的理解,掌握进程调度程序的设计与实现方法。

实验要求我们使用高级编程语言编写一个简单的进程调度程序,实现不同调度算法的模拟,并通过实验验证算法的性能。

二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法:1. 先来先服务(FCFS)2. 最短作业优先(SJF)3. 时间片轮转(RR)四、实验步骤1. 定义进程类(Process):```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类(Scheduler):```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序:```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果:");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果:");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果(时间片为2):");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验,我们可以观察到以下结果:1. FCFS调度算法简单,但可能导致长作业等待时间过长。

实验三 进程调度(实验报告格式)

实验三 进程调度(实验报告格式)

实验三:进程调度一、实验目的(1)理解进程控制块和进程组织方式;(2)掌握时间片轮转调度算法实现处理机调度。

二、实验环境微型计算机,Ubuntu Linux10.04 ,gedit,gcc三、实验内容1建立合理的PCB数据结构,建立含有8个进程结点的就绪队列,每个进程的要求运行时间随机产生,要求每个进程的要求运行时间不大于15。

2 设置时间片大小(3~6),使用时间片轮转调度算法实现处理机调度。

四、实验结果五、源代码#include<stdio.h>#include<time.h>#include<malloc.h>#define T 8#define NUM 10typedef struct PCB{int name;int runtime;int runedtime;int killtime;struct PCB *next;}PCB;PCB *creat_jiuxu(PCB *top){PCB *temp;int i;srand((int)time(0));for(i=0;i<NUM;i++){temp=(PCB *)malloc(sizeof(PCB));temp->name=i;temp->runtime=rand()%15;temp->runedtime=0;temp->next=NULL;temp->killtime=0;if(i==0) top=temp;else{temp->next=top;top=temp;}}return top;}void run(PCB *top){PCB *tail=top;if(tail->next!=NULL)tail=tail->next;PCB *rq=NULL;while(top!=NULL){rq=top;if(rq->runtime<=rq->runedtime+T){printf("process_name:%d,runtime:%d,killtime:%d\n",rq->name,rq->runtime,rq->killtime);/*if(rq!=NULL) free(rq);*/top=top->next;}else{top=top->next;rq->runedtime+=T;rq->killtime++;tail->next=rq;tail=rq;rq->next=NULL;}}return;}int main(){PCB *top=NULL;top=creat_jiuxu(top);run(top);return 0;}。

实验一、进程调度实验报告

实验一、进程调度实验报告

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 CPU 资源给各个进程,以提高系统的整体性能和资源利用率。

通过本次实验,我们旨在深入理解进程调度的原理和算法,掌握进程状态的转换,观察不同调度策略对系统性能的影响,并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。

二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。

三、实验原理1、进程状态进程在其生命周期中会经历不同的状态,包括就绪态、运行态和阻塞态。

就绪态表示进程已经准备好执行,只等待 CPU 分配;运行态表示进程正在 CPU 上执行;阻塞态表示进程由于等待某个事件(如 I/O操作完成)而暂时无法执行。

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

先来先服务算法按照进程到达的先后顺序进行调度。

短作业优先算法优先调度执行时间短的进程。

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

四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体,包含进程 ID、到达时间、执行时间、剩余时间等信息。

实现进程的创建、插入、删除等操作。

实现不同的调度算法。

2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。

分别采用先来先服务、短作业优先和时间片轮转算法进行调度。

记录每个算法下的平均周转时间、平均等待时间等性能指标。

五、实验步骤1、进程结构体的定义```c++struct Process {int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;};```2、进程创建函数```c++void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) {processesnumProcessespid = pid;processesnumProcessesarrivalTime = arrivalTime;processesnumProcessesexecutionTime = executionTime;processesnumProcessesremainingTime = executionTime;numProcesses++;}```3、先来先服务调度算法实现```c++void fcfsScheduling(Process processes, int numProcesses) {int currentTime = 0;for (int i = 0; i < numProcesses; i++){if (currentTime < processesiarrivalTime) {currentTime = processesiarrivalTime;}processesistartTime = currentTime;currentTime += processesiexecutionTime;processesifinishTime = currentTime;processesiwaitingTime = processesistartTime processesiarrivalTime;processesiturnaroundTime = processesifinishTime processesiarrivalTime;}}```4、短作业优先调度算法实现```c++void sjfScheduling(Process processes, int numProcesses) {int currentTime = 0;int minExecutionTime, selectedProcess;bool found;while (true) {found = false;minExecutionTime = INT_MAX;selectedProcess =-1;for (int i = 0; i < numProcesses; i++){if (processesiarrivalTime <= currentTime &&processesiremainingTime < minExecutionTime &&processesiremainingTime > 0) {found = true;minExecutionTime = processesiremainingTime;selectedProcess = i;}}if (!found) {break;}processesselectedProcessstartTime = currentTime;currentTime += processesselectedProcessremainingTime;processesselectedProcessfinishTime = currentTime;processesselectedProcesswaitingTime =processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime =processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime = 0;}}```5、时间片轮转调度算法实现```c++void rrScheduling(Process processes, int numProcesses, int timeSlice) {int currentTime = 0;Queue<int> readyQueue;for (int i = 0; i < numProcesses; i++){readyQueueenqueue(i);}while (!readyQueueisEmpty()){int currentProcess = readyQueuedequeue();if (processescurrentProcessarrivalTime > currentTime) {currentTime = processescurrentProcessarrivalTime;}if (processescurrentProcessremainingTime <= timeSlice) {currentTime += processescurrentProcessremainingTime;processescurrentProcessfinishTime = currentTime;processescurrentProcesswaitingTime =processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime =processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime = 0;} else {currentTime += timeSlice;processescurrentProcessremainingTime = timeSlice;readyQueueenqueue(currentProcess);}}}```6、性能指标计算函数```c++void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) {double totalWaitingTime = 0, totalTurnaroundTime = 0;for (int i = 0; i < numProcesses; i++){totalWaitingTime += processesiwaitingTime;totalTurnaroundTime += processesiturnaroundTime;}averageWaitingTime = totalWaitingTime / numProcesses; averageTurnaroundTime = totalTurnaroundTime / numProcesses;}```7、主函数```c++int main(){Process processes100;int numProcesses = 0;//创建进程createProcess(processes, numProcesses, 1, 0, 5);createProcess(processes, numProcesses, 2, 1, 3);createProcess(processes, numProcesses, 3, 2, 4);createProcess(processes, numProcesses, 4, 3, 2);//先来先服务调度fcfsScheduling(processes, numProcesses);double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime);cout <<"先来先服务调度的平均等待时间:"<<fcfsAverageWaitingTime << endl;cout <<"先来先服务调度的平均周转时间:"<<fcfsAverageTurnaroundTime << endl;//短作业优先调度sjfScheduling(processes, numProcesses);double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime);cout <<"短作业优先调度的平均等待时间:"<<sjfAverageWaitingTime << endl;cout <<"短作业优先调度的平均周转时间:"<<sjfAverageTurnaroundTime << endl;//时间片轮转调度(时间片为 2)rrScheduling(processes, numProcesses, 2);double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime);cout <<"时间片轮转调度(时间片为 2)的平均等待时间:"<< rrAverageWaitingTime << endl;cout <<"时间片轮转调度(时间片为 2)的平均周转时间:"<< rrAverageTurnaroundTime << endl;return 0;}```六、实验结果与分析1、先来先服务调度平均等待时间:40平均周转时间:85分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。

操作系统实验三 时间片轮转法完成进程调度

操作系统实验三 时间片轮转法完成进程调度

实验三:时间片轮转法完成进程调度一、实验目的:(1)加深对进程的理解(2)理解进程控制块的结构(3)理解进程运行的并发性(4)掌握时间片轮转法进程调度算法实验内容:(1)建立进程控制块(2)设计三个链队列,分别表示运行队列、就绪队列和完成队列(3)用户输入进程标识符以及进程所需的时间,申请空间存放进程PCB信息。

(4)每一个时间片结束输出各进程的进程号,CPU时间(即已经占用的CPU时间),所需时间(即还需要的CPU时间),以及状态(即用W表示等待,R表示运行,F表示完成)实验程序:#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,t; //进程数,时间片的大小void firstin(){run=ready;//就绪队列头指针赋值给运行头指针run->state='R'; //进程状态变为运行态ready=ready->next; //就绪队列头指针后移到下一进程}void prt1(char a)//输出标题函数{if(toupper(a)=='P')//优先级法printf("进程名占用CPU时间到完成还要的时间轮转时间片状态\n");} void prt2(char a,PCB *q)//进程PCB输出{if(toupper(a)=='P')//优先级法的输出printf("%4s %8d %12d %14d %8c\n",q->name,q->cputime,q->needtime,q->roun d,q->state);}void prt(char algo)//输出函数二、三、{PCB *p;prt1(algo);//输出标题if(run!=NULL)//如果运行指针不空prt2(algo,run);//输出当前正在运行的PCBp=ready;//输出就绪队列PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}p=finish;//输出完成队列的PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}getchar(); //按住任意键继续}void insert(PCB *q)//时间片轮转的插入算法{PCB *p1,*s,*r;s=q;//待插入的PCB指针p1=ready;//就绪队列头指针r=p1;//*r做pl的前驱指针while(p1!=NULL)if(p1->round<=s->round){r=p1;p1=p1->next;}if(r!=p1){r->next=s;s->next=p1;}else{s->next=p1;//否则插入在就绪队列的头ready=s;}}void create(char alg)//时间片轮转法创建链表进程PCB{PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;printf("输入进程名及其需要运行的时间(中间以空格隔开):\n"); for(i=1;i<=N;i++){p=new PCB;scanf("%s %d",&na,&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='W';//进程的状态p->round=0;if(ready!=NULL)insert(p);else{p->next=ready;ready=p;}}printf("*************时间片轮转法进程调度过程*************\n"); prt(alg);run=ready;ready=ready->next;run->state='R';}void timeslicecycle(char alg)//时间片轮转法{while(run!=NULL){run->cputime=run->cputime+t;//处理时间加trun->needtime=run->needtime-t;//完成需要时间减trun->round=run->round+t;//运行完将其变为完成态,插入完成队列if(run->needtime<=0)//当进程完成时{run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)//就绪队列不空,将第一个进程投入进行firstin();}else{run->state='W';//将进程插入到就绪队列中等待轮转insert(run);//将就绪队列的第一个进程投入运行firstin();}prt(alg);}}void main()//主函数{char algo='P';//算法标记printf("输入进程的个数:");scanf("%d",&N);//输入进程数printf("定义时间片大小:");scanf("%d",&t);//输入时间片大小create(algo);//创建进程timeslicecycle(algo);//时间片轮转法调度}//main()四、实验结果:五、实验小结:时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。

实验三进程调度

实验三进程调度

教师签名: 年


实验步骤: (算法描述、源程序、操作步骤和方法)
实验步骤: (算法描述、源程序、操作步骤和方法)
测试过程: (实验中出现的问题、错误、解决方法) 该实验利用进程调度中的优先级算法调度进程,开始给每一个进程设定一个优先级数,对于优先级高 的进程先调度,优先级低的进程后调度,在调度一个进程时,其他进程将处于就绪态,而正在被调度 的进程应处于运行态。
洛阳师范学院信息技术学院 软件实验报告
专业:__计算机科学与技术____课程:_____操作系统____ 学号:__131114029___姓名:__朱蕊_____班级:___13 级____________________ 实验名称 实验类型 验证性 实验三 进程调度 实验时间 2015-6-5
实验总结:通过这次实验,首先加深了我对进程调度方法和功能的认识,其次让我更加深刻地理解了 操作系统中进程调度中优先级调度的基本原理。优先级调度算法只是进程调度算法的一种,我们还应 依照书本去学习进程调度的其它算法,以便更好地了解进程调度。
实验环境
Microsoft visual c++
实验目的与要求:加深对进程概念的理解,明确进程和程序的区别。深入 理解系统如何组织进程,创建进程。进一步认识如何实现处理机调度。
签名 年 月 日
实验内容:编写程序完成单处理机系统中的进程调度,要求采用“先来先 服务” 、 “短作业优先” 、 “最高优先数优先” 、 “时间片轮转”等调度算法对
评语与成绩:
五个进程进行调度。 实验具体包括: 首先确定进程控制块的内容和组成方 式; 然后完成进程创建原语和进程调度原语; 最后编写主函数对所做Байду номын сангаас作 进行测试。

进程管理实验报告分析(3篇)

进程管理实验报告分析(3篇)

第1篇一、实验背景进程管理是操作系统中的一个重要组成部分,它负责管理计算机系统中所有进程的创建、调度、同步、通信和终止等操作。

为了加深对进程管理的理解,我们进行了一系列实验,以下是对实验的分析和总结。

二、实验目的1. 加深对进程概念的理解,明确进程和程序的区别。

2. 进一步认识并发执行的实质。

3. 分析进程争用资源的现象,学习解决进程互斥的方法。

4. 了解Linux系统中进程通信的基本原理。

三、实验内容1. 使用系统调用fork()创建两个子进程,父进程和子进程分别显示不同的字符。

2. 修改程序,使每个进程循环显示一句话。

3. 使用signal()捕捉键盘中断信号,并通过kill()向子进程发送信号,实现进程的终止。

4. 分析利用软中断通信实现进程同步的机理。

四、实验结果与分析1. 实验一:父进程和子进程分别显示不同的字符在实验一中,我们使用fork()创建了一个父进程和两个子进程。

在父进程中,我们打印了字符'a',而在两个子进程中,我们分别打印了字符'b'和字符'c'。

实验结果显示,父进程和子进程的打印顺序是不确定的,这是因为进程的并发执行。

2. 实验二:每个进程循环显示一句话在实验二中,我们修改了程序,使每个进程循环显示一句话。

实验结果显示,父进程和子进程的打印顺序仍然是随机的。

这是因为并发执行的进程可能会同时占用CPU,导致打印顺序的不确定性。

3. 实验三:使用signal()捕捉键盘中断信号,并通过kill()向子进程发送信号在实验三中,我们使用signal()捕捉键盘中断信号(按c键),然后通过kill()向两个子进程发送信号,实现进程的终止。

实验结果显示,当按下c键时,两个子进程被终止,而父进程继续执行。

这表明signal()和kill()在进程控制方面具有重要作用。

4. 实验四:分析利用软中断通信实现进程同步的机理在实验四中,我们分析了利用软中断通信实现进程同步的机理。

进程的调度实验报告(3篇)

进程的调度实验报告(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("无效的调度算法选择。

实验3 进程调度

实验3 进程调度

实验三:进程调度◆实验目的:设计一个有 N个进程并行的进程调度程序◆实验内容:进程调度算法:采用最高优先级优先的调度算法。

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

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

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

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

进程名、优先级、需要运行时间通过键盘输入。

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

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

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

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

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

测试代码如下:#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type)(type*)malloc(sizeof(type))#define NUll 0struct pcb{ /*定义进程控制块PCB*/char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;sort()/*建立对进程进行优先级排列函数*/{PCB *first,*second;int insert=0;if((ready==NULL)||((p->super)>(ready->super)))/*优先级最大者,插入队首*/{p->link=ready;ready=p;}else/*进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super))/*若插入进程比当前进程优先数大,插入到当前进程前面*/ {p->link=second;first->link=p;second=NULL;insert=1;}else /*插入进程优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if(insert==0)first->link=p;}}input()/*建立进程控制块函数*/{int i,num;system("cls");printf("\n请输入进程号?");scanf("%d",&num);for(i=0;i<num;i++){printf("\n进程号No.%d:\n",i);p=getpch(PCB);printf("\n输入进程名:");scanf("%s",p->name);printf("\n输入进程优先数:");scanf("%d",&p->super);printf("\n输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort();/*调用sort函数*/}}int space(){int l=0;PCB*pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}disp(PCB *pr)/*建立进程现实函数,用于显示当前进程*/{printf("\n qname\t state\t super\t runtimt \n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}check()/*建立进程查看函数*/{PCB *pr;printf("\n ****当前正在运行的进程是:%s",p->name);/*显示当前运行的进程*/ disp(p);pr=ready;printf("\n****当前就绪队列状态为:\n");/*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}destroy()/*建立进程撤销函数(进程运行结束,撤销进程)*/{printf("\n进程[%s]已完成.\n",p->name);free(p);}running()/*建立进程就绪函数(进程运行时间到,置就绪状态)*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy();/*调用destroy函数*/else{(p->super)--;p->state='w';sort();/*调用sort函数*/}}main(){int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\nThe execute number:%d\n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n按任意键继续...");ch=getchar();}printf("\n\n 进程已经完成\n");ch=getchar();}。

模拟调度实验报告(3篇)

模拟调度实验报告(3篇)

第1篇一、实验背景进程调度是操作系统核心功能之一,它负责在多道程序环境下,按照一定的策略对进程进行调度,以确保系统资源的合理分配和高效利用。

为了加深对进程调度算法的理解,本次实验采用模拟的方式,实现了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种算法,并对实验过程进行了详细记录和分析。

二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。

2. 掌握进程控制块(PCB)的设计与实现。

3. 通过模拟实验,验证三种调度算法的执行效果。

三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019四、实验内容1. 定义进程控制块(PCB)进程控制块是操作系统用于描述和管理进程的实体,它包含了进程的基本信息。

本实验中,PCB包含以下字段:- 进程ID:唯一标识一个进程。

- 到达时间:进程进入就绪队列的时间。

- 需要运行时间:进程完成所需的时间。

- 已运行时间:进程已运行的时间。

- 状态:进程当前的状态(就绪、运行、阻塞、完成)。

2. 实现三种调度算法(1)先来先服务(FCFS)算法FCFS算法按照进程到达就绪队列的顺序进行调度,先到先服务。

具体实现如下:- 将进程按照到达时间排序,形成就绪队列。

- 遍历就绪队列,依次执行进程,直到进程完成或被阻塞。

(2)时间片轮转(RR)算法RR算法将CPU时间划分为时间片,每个进程运行一个时间片后,让出CPU,等待下一个时间片。

具体实现如下:- 设置一个时间片大小。

- 将进程按照到达时间排序,形成就绪队列。

- 遍历就绪队列,每个进程执行一个时间片,如果进程未完成,则将其加入就绪队列队尾。

(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度,优先级高的进程优先执行。

具体实现如下:- 设置一个优先级阈值,当进程的优先级高于阈值时,将其加入就绪队列。

- 遍历就绪队列,选择优先级最高的进程执行,直到进程完成或被阻塞。

进程调度模拟程序实验实验报告

进程调度模拟程序实验实验报告

实验三、进程调度模拟程序实验一、实验目的用高级语言完成一个进程调度程序,以加深对进程的概念及进程调度算法的理解。

二、实验内容和要求设计一个有 N个进程并发执行的进程调度模拟程序。

用C++模拟基于时间片的轮转算法、静态优先算法、动态优先算法、多级反馈队列调度算法。

三、实验方法、步骤及结果测试1.原理分析及流程图(1). 每个进程有一个进程控制块(PCB)表示。

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

(2). 进程的优先数及需要的运行时间可以事先人为地指定,进程的运行时间以时间片为单位进行计算。

(3). 每个进程的状态可以是就绪 r(ready)、运行R(Running)、或完成F(Finished)三种状态之一。

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

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

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

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

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

2.主要程序段及其解释:动态优先调度:#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 24struct jcb{char name[10];int reqtime;int runtime;int startime;int fintime;int prio;char status;};typedef struct jcb JCB;void input(JCB job[],int *pnum){int num;int i;printf("process 数:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个process:\n",i+1);printf("输入proc名:");scanf("%s",job[i].name);printf("Priority:");scanf("%d",&job[i].prio);printf("要求服务时间:");scanf("%d",&job[i].reqtime);job[i].status='r';job[i].runtime=0;}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;if (n==0){printf("the queue is null!!\n");return;}printf("\tname\tprio\trqtime\truntime\tstatus");for(i=0;i<n;i++){printf("\nN %d",i+1);printf("\t&s",jcbp[i].name);printf("\t&d",jcbp[i].prio);printf("\t&d",jcbp[i].reqtime);printf("\t&d",jcbp[i].runtime);printf("\t&c",jcbp[i].status);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++)for(i=0;i<n-j;i++)if(btjcb[i].prio<btjcb[i+1].prio){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}main(){JCB jobarrived[MAX],jobfinished[MAX];int numarr, numfin;int systime=0;int i,j,n;JCB jcbrunning;input(jobarrived,&numarr);numfin=0;systime=0;btsort (jobarrived,numarr);printf("经按priority排序后,read queue是\n");jcbprintf(jobarrived,numarr);do{btsort(jobarrived,numarr);printf("\n\n\t\t现在系统时间%d:\n\n",systime);printf("ready queue 有\n");jcbprintf(jobarrived,numarr);jcbrunning=jobarrived[0];numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jcbrunning.status='R';jcbrunning.startime=systime;printf("\n\n\t\t处于运行态的作业名%s\n",);systime++;jcbrunning.runtime++;if (jcbrunning.runtime==jcbrunning.reqtime){jobfinished[numfin]=jcbrunning;jobfinished[numfin].status='F';numfin++;}else{jcbrunning.prio--;jcbrunning.status='r';jobarrived[numarr]=jcbrunning;numarr++;}printf("\n\n\t\t系统时间:%d已经完成的有\n\n",systime);jcbprintf(jobfinished,numfin);getchar();getchar();}while((numarr!=0));printf("\nCompleted!! ByeBye!!");getchar();getchar();}2、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1); printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t运行时间");for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].reqtime); }}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d\n",job[i].name,job[i].reqtime,job[i].ru ntime);}}void main(){JCB jobarrived[MAX];int numarr,i;JCB jcbrunning;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后,就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");while(numarr>0){jcbrunning=jobarrived[0];jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");if(jcbrunning.reqtime>0){for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jobarrived[numarr-1]=jcbrunning;}else{numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int firsttime;int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序数目:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);printf("优先级:");scanf("%d",&jcb[i].firsttime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1);printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].firsttime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t优先级\t运行时间"); for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].firsttime); printf(" %d",jcbp[i].reqtime);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称优先级运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d %d\n",job[i].name,job[i].firstti me,job[i].reqtime,job[i].runtime);}}void main(){JCBjobarrived1[MAX],jobarrived2[MAX],jobarrived3[MAX],jobarrived[MAX]; int numarr1,numarr2,numarr3,numarr,i;JCB jcbrunning;numarr2=0;numarr1=0;numarr3=0;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后,就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}for(i=0;i<numarr;i++){jobarrived3[i]=jobarrived[i];numarr3++;}printf("\n.............就绪队列3是..........\n");jcbprintf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");jcbprintf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");jcbprintf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();while(numarr3>0){jcbrunning=jobarrived3[0];if(jcbrunning.firsttime==3){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1; jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");}jobarrived3[0]=jcbrunning;}if(jobarrived3[0].reqtime>0){jobarrived2[numarr2]=jobarrived3[0];numarr2++;}numarr3--;for(i=0;i<numarr3;i++){jobarrived3[i]=jobarrived3[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr2>0){jcbrunning=jobarrived2[0];if(jcbrunning.firsttime==2){if(jcbrunning.reqtime>2){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-2;jcbrunning.runtime=jcbrunning.runtime+2;printf("\n正在执行的进程名称是%s\n",);}else{jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime;jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime;printf("\n正在执行的进程名称是%s\n",); }jobarrived2[0]=jcbrunning;}if(jobarrived2[0].reqtime>0){jobarrived1[numarr1]=jobarrived2[0];numarr1++;}numarr2--;for(i=0;i<numarr2;i++){jobarrived2[i]=jobarrived2[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr1>0){jcbrunning=jobarrived1[0];if(jcbrunning.firsttime==1){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime; jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime; printf("\n正在执行的进程名称是%s\n",); }}numarr1--;for(i=0;i<numarr1;i++){jobarrived1[i]=jobarrived1[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3.运行结果及分析四、 实验总结这次的实验是我们这门课第一次以个人为单位来完成的实验,然后这次实验用了三个星期去完成,虽然每次上机课老师都会先讲,可是我还是不太懂,到自己做的时候又不会,都是照样画葫芦。

进程调度实验报告答案(3篇)

进程调度实验报告答案(3篇)

第1篇一、实验目的通过本次实验,加深对操作系统进程调度过程的理解,掌握三种基本调度算法(先来先服务(FCFS)、时间片轮转、动态优先级调度)的原理和实现方法,并能够通过编程模拟进程调度过程,分析不同调度算法的性能特点。

二、实验环境1. 操作系统:Linux/Windows2. 编程语言:C/C++3. 开发环境:Visual Studio、Code::Blocks等三、实验内容1. 实现三种基本调度算法:FCFS、时间片轮转、动态优先级调度。

2. 编写代码模拟进程调度过程,包括进程创建、进程调度、进程运行、进程结束等环节。

3. 每次调度后,打印当前运行的进程、就绪队列以及所有进程的PCB信息。

4. 编写实验报告,描述数据结构、算法流程,展示实验结果,并总结心得。

四、实验步骤1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、已用时间、优先数、进程状态等信息。

2. 实现进程调度函数,根据所选调度算法进行进程调度。

3. 编写主函数,初始化进程信息,选择调度算法,并模拟进程调度过程。

4. 每次调度后,打印当前运行的进程、就绪队列以及所有进程的PCB信息。

5. 编写实验报告,描述数据结构、算法流程,展示实验结果,并总结心得。

五、实验结果与分析1. FCFS调度算法实验结果:按照进程到达时间依次调度,每个进程结束后,调度下一个进程。

分析:FCFS调度算法简单,易于实现,但可能会导致进程的响应时间较长,特别是当有大量进程到达时,后到达的进程可能会长时间等待。

2. 时间片轮转调度算法实验结果:每个进程完成一个时间片后,放弃处理机,转到就绪队列队尾。

分析:时间片轮转调度算法能够保证每个进程都能得到一定的运行时间,但可能会出现进程饥饿现象,即某些进程长时间得不到运行。

3. 动态优先级调度算法实验结果:每个进程完成一个时间片后,优先级减1,插入到就绪队列相关位置。

分析:动态优先级调度算法能够根据进程的运行情况动态调整优先级,使得优先级高的进程能够得到更多的运行时间,从而提高系统的响应速度。

黄天实验三进程调度实验报告

黄天实验三进程调度实验报告

操作系统实验实验三进程调度学号 1415251011 姓名黄天班级 14集成1班华侨大学电子工程系实验目的1、理解有关进程控制块、进程队列的概念。

2、掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。

实验内容与基本要求1、设计进程控制块PCB的结构,分别适用于优先权调度算法和时间片轮转调度算法。

2、建立进程就绪队列。

3、编制两种进程调度算法:优先权调度算法和时间片轮转调度算法。

实验报告内容1、优先权调度算法和时间片轮转调度算法原理。

优先权调度算法原理:(此处为静态优先权)当该算法用于作业调度时,系统从后备作业队列中选择若干个优先级最高的,且系统能满足资源要求的作业装入内存运行。

当该算法用于进程调度时,将把处理机分配给就绪进程队列中优先级最高的进程。

在这种调度方式下,系统一旦把处理机分配给就绪队列中优先级最高的进程后,该进程就能一直执行下去,直至完成;或因等待某事件的发生使该进程不得不放弃处理机时,系统才能将处理机分配给另一个优先级高的就绪进程。

时间片轮转调度算法原理:在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.4、运行结果以及结论。

1.优先权调度算法:这里采取的是短时间优先算法运行结果结果表明,占用时间最少得程序,最先运行,依次进行。

结论:程序很好的完成了实验要求所要达到的目标,进行短时间优先运行。

2.时间片轮转算法:每个时间片大小为1.每个程序轮转一次程序运行结果结论:程序运行结果表明,所有程序按照时间片来轮转,每个程序运行一个时间片后轮到下一个程序,直到所有程序运行完。

学生进程调度实验报告(3篇)

学生进程调度实验报告(3篇)

第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程,加深对进程调度算法的理解,提高程序设计能力。

通过实现不同调度算法,学习如何根据进程的优先级、到达时间和服务时间等因素,合理分配CPU资源,提高系统的吞吐量和响应速度。

二、实验内容1. 实验环境:Windows操作系统,C/C++编程环境。

2. 实验内容:(1)设计进程调度算法:FCFS(先来先服务)、SJF(最短作业优先)、RR(轮转法)和优先级调度算法。

(2)实现进程控制块(PCB)数据结构,包括进程名、到达时间、服务时间、优先级、状态等信息。

(3)模拟进程调度过程,根据调度算法选择合适的进程运行。

(4)打印进程调度结果,包括运行进程、就绪队列和完成进程等信息。

三、实验原理1. 进程调度算法(1)FCFS:按照进程到达时间顺序进行调度,先到达的进程先执行。

(2)SJF:优先选择执行时间最短的进程执行。

(3)RR:将CPU时间划分为若干个时间片,每个进程运行一个时间片,然后根据进程优先级重新排队。

(4)优先级调度算法:优先选择优先级最高的进程执行。

2. 进程控制块(PCB)PCB是进程的实体,用于描述进程的状态、控制信息和资源等信息。

PCB主要包括以下内容:(1)进程名:唯一标识进程。

(2)到达时间:进程进入就绪队列的时间。

(3)服务时间:进程执行所需的时间。

(4)优先级:表示进程的优先程度。

(5)状态:表示进程的当前状态,如就绪、运行、阻塞等。

四、实验步骤1. 定义PCB数据结构,包括进程名、到达时间、服务时间、优先级、状态等信息。

2. 设计调度算法,实现进程调度功能。

3. 模拟进程调度过程,包括进程到达、就绪、运行、阻塞和完成等状态转换。

4. 打印进程调度结果,包括运行进程、就绪队列和完成进程等信息。

五、实验结果与分析1. FCFS调度算法:按照进程到达时间顺序进行调度,可能导致短作业等待时间过长。

2. SJF调度算法:优先选择执行时间最短的进程执行,但可能存在饥饿现象。

实验三 进程调度

实验三  进程调度

实验三进程调度1.目的和要求进程调度是处理机管理的核心内容。

本实验要求用C语言编写和调试一个简单的进程调度程序。

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

2.实验内容①设计进程控制块PCB表结构(与实验一的结构相同),分别适用于优先数调度算法和循环轮转调度算法。

②建立进程就绪队列。

对两种不同算法编制入链子程序。

③编制两种进程调度算法:1)优先数调度;2)循环轮转调度3.实验环境装有DOS、 Windows操作系统以及C++语言系统的PC机1台/人。

4.实验提示①本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。

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

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

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

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

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

⑤在实验操作过程中,考虎用户输入的数据量太大且每次用户输入的大多数数据为重复数据,因此可采用文件输入方式,用户只需指定特定的输入文件的文件名来输入数据。

另一方面,程序的输出量较大,可以采用文件输出的方式来储存程序的运行结果。

也可以用实时的输出界面来输出程序结果。

参考程序:#include<stdio.h>#include <dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5#define P_TIME 50enum state{ready,execute,block,finish};struct pcb{char name[4];int priority;int cputime;int needtime;int count;int round;state process;pcb * next;};pcb * get_process();pcb * get_process(){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input name and time"<<endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime;q->cputime=0;q->priority=P_TIME-q->needtime;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}i++;} //whilereturn p;}void display(pcb *p){cout<<"name"<<" "<<"cputime"<<" "<<"needtime"<<" "<<"priority"<<" "<<"state"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->priority;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case block:cout<<"block"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;}}int process_finish(pcb *q){int bl=1;while(bl&&q){}return bl;}void cpuexe(pcb *q){pcb *t=q;int tp=0;while(q){if (q->process!=finish){}if(tp<q->priority&&q->process!=finish){tp=q->priority;t=q;}q=q->next;}if(t->needtime!=0){t->priority-=3;t->needtime--;t->process=execute;t->cputime++;}}void priority_cal(){pcb * p;clrscr();p=get_process();int cpu=0;clrscr();while(!process_finish(p)){cpu++;cout<<"cputime:"<<cpu<<endl;cpuexe(p);display(p);sleep(2);clrscr();}printf("All processes have finished,press any key to exit");getch();}void display_menu(){cout<<"CHOOSE THE ALGORITHM:"<<endl;cout<<"1 PRIORITY"<<endl;cout<<"2 ROUNDROBIN"<<endl;cout<<"3 EXIT"<<endl;}pcb * get_process_round( ){pcb *q;pcb *t;pcb *p;int i=0;cout<<"input name and time"<<endl;while (i<P_NUM){cin>>q->name;cin>>q->needtime;q->cputime=0;q->round=0;q->count=0;q->next=NULL;if (i==0){p=q;t=q;}else{t->next=q;t=q;}i++;} //whilereturn p;}void cpu_round(pcb *q){q->cputime+=2;q->needtime-=2;if(q->needtime<0) {q->needtime=0;}q->process=execute;}pcb * get_next(pcb * k,pcb * head){ pcb * t;t=k;do{t=t->next;}while (t && t->process==finish);if(t==NULL){t=head;while (t->next!=k && t->process==finish){t=t->next;}}return t;}void set_state(pcb *p){while(p){if (p->needtime==0){}if (p->process==execute){}p=p->next;}}void display_round(pcb *p){cout<<"NAME"<<" "<<"CPUTIME"<<" "<<"NEEDTIME"<<" "<<"COUNT"<<" "<<"ROUND"<<" "<<"STA TE"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->count;cout<<" ";cout<<p->round;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;}}void round_cal(){pcb * p;pcb * r;clrscr();p=get_process_round();int cpu=0;clrscr();r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);cout<<"cpu "<<cpu<<endl;display_round(p);set_state(p);sleep(5);clrscr();}}void main(){display_menu();int k;scanf("%d",&k);switch(k){case 1:priority_cal();break;case 2:round_cal();break;case 3:break;display_menu();scanf("%d",&k);}}5.实验运行结果(将调试通过代码及运行结果打印后附于报告后)6.实验体会与收获。

操作系统实验进程调度

操作系统实验进程调度

实验三进程调度一. 实验目的加深理解并模拟实现进程(作业)调度算法。

1)熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转;2)结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。

二. 实验属性该实验为设计性实验。

三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。

1)本实验要求完成如下任务:2)编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个;3)最后编写主函数对所做工作进行测试。

实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。

实验后认真书写符合规范格式的实验报告(参见附录A), 并要求用正规的实验报告纸和封面装订整齐, 按时上交。

五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为:进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。

1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。

实验三 进程调度实验指导

实验三  进程调度实验指导

实验三作业(进程)调度实验指导实验目的与要求本实验的目的是通过作业或进程调度算法模拟设计,进一步加深对作业或进程调度算法的理解,通过计算平均周转时间和带权平均周转时间,进一步加深对算法的评价方法的理解。

实验预备内容(1)掌握作业或进程调度算法。

(2)平均周转时间和带权平均周转时间计算。

实验内容设定一组作业或进程,给定相关参数,对这组进程或作业按调度算法实施调度,输出调度次序,并计算平均周转时间和带权平均周转时间。

使用的调度算法有:①先来先服务调度算法。

②优先级调度算法。

③短作业(或进程)优先调度算法。

④响应比高优先调度算法使用的主要数据结构:1.定义一个结构体,结构体的主要成员有:序号、作业(进程)号或名称、提交时间、运行时间、优先数、进入输入井时间、开始运行时间、尚需运行时间、运行结束时间、周转时间、带权周转时间、运行次序等。

2.利用定义的结构体,定义一个结构体数组,用来记录系统中的作业或进程。

算法描述:1.主控程序算法描述2.数据输入算法3.数据输出算法4.先来先服务调度算法描述5.优先级调度算法6.短作业(或进程)优先调度算法优先级调度算法 在数组中找第一个未运行的作业 Pmin ←该作业的优先数 (当前最小的)k ←该作业的在数组中的下标作业的优先数 与Pnim 比较有未运行的作业未找到找到Pmin ←该作业 的优先数 k ←该作业的 在数组中的下标大小 优先级最高作业的选择算法先来先服务调度算法7.轮转调度算法选择运行时间最短作业的算法 系统中有未运行的作业 在未运行的作业中选择运行时间最短的作业把运行次序填入数组相应位置; 分别计算出该作业进入输入井时间、开始运行时间、运行结束时间、周转时间、带权周转时间,并填入数组相应位置。

调用输出程序,输出结果 短作业(或进程)优先调度算法 轮转调度算法 首次运行运行情况记录开始运行时间 是 否 计算尚需运行时间时间片到 运行结束系统中存在未运行完的作业记录开始时间 计算运行结束时间计算周转时间记录结束次序计算平均周转时间输出结果8.响应比高优先调度算法响应比高优先调度算法用C语言程序实现如下:#include<stdio.h>#include<string.h>#define MAX 10struct task_struct{int number; /*进程编号*/char name[10]; /*进程名称*/float come_time; /*到达时间*/float run_begin_time; /*开始运行时间*/float run_time /*运行时间*/float run_end_time; /*运行结束时间*/int priority; /*优先级*/int order; /*运行次序*/int run_flag; /*调度标志*/}tasks[MAX];int counter; /*实际进程个数*/int fcfs(); /*先来先服务*/int rr(); /*轮转调度*/int ps(); /*优先级调度*//*int mlqs(); /*分级轮转调度*/*//*int mlfqs(); /*分级反馈轮转调度*/*/int sjf(); /*短作业优先*/int hrrn(); /*响应比高优先*/int pinput(); /*进程参数输入*/int poutput(); /*调度结果输出*/void main(){int option;pinput();while(1){printf("请选择调度算法(0~7):\n");printf("1.先来先服务\n");printf("2.轮转调度\n");printf("3.优先级调度\n");printf("4.短作业优先\n");printf("5.响应比高优先\n");printf("6.分级轮转调度\n");printf("7.分级反馈轮转调度\n");printf("0.退出\n");scanf("%d\n",&option);swich (option){case 0:printf("运行结束。

实验三 进程调度实验讲稿

实验三 进程调度实验讲稿

内容一:检查上次进程模拟实验情况;实验三进程调度【实验要求】1、复习进程的状态及其转换;2、深入理解同步与互斥的概念及p、v操作;3、了解进程调度的功能和算法;4、上机前仔细阅读参考程序,并在参考程序的基础上,对程序作相应的修改,修改后进行测试,给出最后的实验数据与测试结果。

【实验目的】进程调度是进程管理的主要内容之一,通过设计编程,调试一个简单的进程调度模拟程序,对进程调度,进程运行状态变换及PV操作加深理解和掌握。

【实验内容】1、模拟批处理多道操作系统的进程调度;采用剥夺式优先算法,对三个进程进行模拟调度2、模拟实现同步机构避免并发进程执行时可能与时间相关的错误;模拟PV操作同步机构,用PV操作解决进程进入临界区的问题。

【需修改的实验内容】这一部分内容要求同学们自己编程完成,并进行调试,给出相应的测试数据和测试结果1、将进程的优先级设为动态的优先数,用设置和计算两种方式实现;设置可以用一个设置函数完成,也可以用随机数;计算给出一个计算公式;2、在不修改优先数的基础上,请同学们将由p1先执行改为p3先执行,并进行测试;测试后与参考程序进行比较;给出比较结果。

3、在修改了优先数之后,请同学们将由p1先执行改为p3先执行,并进行测试;测试后与参考程序进行比较;给出比较结果。

【提示】(1)参考程序对三个进程进行模拟调度,对各进程的优先数静态设置,P1,P2,P3三个进程的优先数为1,2,3,并指定P1的优先数最高,P3的优先数最低,每个进程都处于执行态“e”,就绪态“r”,等待态“w”三种状态之一,并假定初始态为“r”。

(2)每一个进程有一个PCB,PCB的内容根据具体情况设置,这里共设置4个数据域,该系统在运行过程中能显示或打印各进程和参数的变化情况,以便观察各进程的调度;(3)参考程序在完成必要的初始化后,便进入进程调度程序,首先由P1进入执行,当执行进程因等待某各事件被阻塞或唤醒某个进程等待进程时,转进程调度。

调度算法实验报告总结(3篇)

调度算法实验报告总结(3篇)

第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程,加深对进程调度算法的理解。

实验中,我们重点研究了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种常见的调度算法。

通过编写C语言程序模拟这些算法的运行,我们能够直观地观察到不同调度策略对进程调度效果的影响。

二、实验内容1. 数据结构设计在实验中,我们定义了进程控制块(PCB)作为进程的抽象表示。

PCB包含以下信息:- 进程编号- 到达时间- 运行时间- 优先级- 状态(就绪、运行、阻塞、完成)为了方便调度,我们使用链表来存储就绪队列,以便于按照不同的调度策略进行操作。

2. 算法实现与模拟(1)先来先服务(FCFS)调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。

在模拟过程中,我们首先将所有进程按照到达时间排序,然后依次将它们从就绪队列中取出并分配CPU资源。

(2)时间片轮转(RR)调度算法RR算法将CPU时间划分为固定的时间片,并按照进程到达就绪队列的顺序轮流分配CPU资源。

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

(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度。

在模拟过程中,我们为每个进程分配一个优先级,并按照优先级从高到低的顺序进行调度。

3. 输出调度结果在模拟结束后,我们输出每个进程的调度结果,包括:- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时,我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。

三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现,但可能会导致进程的响应时间较长,尤其是在存在大量短作业的情况下。

此外,FCFS算法可能导致某些进程长时间得不到调度,造成饥饿现象。

2. 时间片轮转(RR)调度算法RR算法能够有效地降低进程的响应时间,并提高系统的吞吐量。

然而,RR算法在进程数量较多时,可能会导致调度开销较大。

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

实验项目三进程调度
一、实验目的
1.理解进程控制块和进程组织方式;
2.掌握时间片轮转调度算法实现处理机调度。

二、实验内容
1.建立合理的PCB数据结构,建立含有8个进程结点的就绪队
列,每个进程的要求运行时间随机产生,要求每个进程的要
求运行时间不大于15。

2.设置时间片大小(3~6),使用时间片轮转调度算法实现处理
机调度。

三、源程序及运行结果
源程序:
#include<time.h>
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define NUM 8
#define LEN sizeof(PCB)
struct PCB
{
int name;
int runtime;
int runedtime;
int killtime;
struct PCB *next;
};
typedef struct PCB PCB;
void main(){
int timeslice=5;
PCB *runqueue;
PCB *top,*tail,*temp;
srand((int)time(0));
for(i=0;i<NUM;i++)
{
temp=(PCB*)malloc(LEN);
temp->name=i;
temp->runtime=rand()%15;
temp->runedtime=0;
temp->next=NULL;
temp->killtime=0;
if(i==0)
{
top=temp;
tail=temp;
}
else
{
tail->next=temp;
tail=temp;
}
printf("process name %d, runtime=%d,
runedtime=%d,killtime=%d\n",tail->name,tail->runtime,tail->runedtime,tail->killtime );
}
printf("************************************\n");
while(top!=NULL){
runqueue= top;
top = top->next;
runqueue->next=NULL;
runqueue->runtime =runqueue->runtime-timeslice;
if(runqueue->runtime<=0)
{
runqueue->killtime=runqueue->runtime+timeslice;
runqueue->runedtime=runqueue->killtime+ runqueue->runedtime;
runqueue->runtime=runqueue->runedtime;
printf("process name %d, runtime=%d,
runedtime=%d,killtime=%d(finished)\n",
runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime);
}
{
runqueue->killtime=timeslice;
runqueue->runedtime=runqueue->runedtime+runqueue->killtime;
printf("process
name %d ,runtime=%d,runedtime=%d,killtime=%d\n",runqueue->name,runqueue->r untime,runqueue->runedtime,runqueue->killtime);
tail->next=runqueue;
tail->next=tail;
}
}
}
运行结果:(截图)
四、实验分析与总结
对实验运行结果进行分析:如果时间片设置值过大或过小,会对进程的调度产生何种影响。

1.答:时间片轮转算法调度的过程是首先取就绪队列的队首结点为运行队列的结点,修改就绪队列队首指针后移;然后调度运行队列结
点,即运行队列结点的要求运行时间减去时间片时间;若修改后要求运行时间<=0,则表示该进程结点运行完毕,修改进程结点的PCB信息,记录runtime,runedtime,killtime等信息,并将结点信息输出。

否则,表示该进程结点未完成,记录runtime,runedtime,killtime等信息,将结点信息输出。

并将该结点置于就绪队列的队尾,等待下次调度,同时修改队尾指针。

若就绪队列非空,则继续执行第1步,直至就绪队列为空。

如果时间片设置过大使得每个进程能在一个时间片内完成,时间片轮转算法便退化为FCFS算法,无法满足交互式用户的需求。

时间片设置过小,使得有些进程不能在一个时间片内运行完,会频繁的发生中断、进程上下文的切换,从而增加系统开销,但有利于短作业。

相关文档
最新文档