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

合集下载

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

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

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

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

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

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

PCB内容要求:进程名/PID;要求运行时间(单位时间);优先权;状态:PCB指针;1、可随机输入若干进程,并按优先权排序;2、从就绪队首选进程运行:优先权-1要求运行时间-1要求运行时间=0时,撤销该进程3、重新排序,进行下轮调度;源代码:#include <stdio.h>#include <stdlib.h>#include <string.h>#include <windows.h>typedef struct pcb{char PID[50];int needTime;//需要运行时间int priority;//优先权char state[20];//进程状态struct pcb *next;}PCB;typedef struct{PCB* front;PCB* rear;}ProcessQueue;void SelectAlgorithm();void CreateQProcess(ProcessQueue &Q,char*,int time,int pri,char*);void ProcessSchedule();void InitQueue(ProcessQueue &Q);void visitQueue(ProcessQueue &Q);bool RunProcess(PCB* rp,ProcessQueue &Q);bool NonPreemptivePriority(ProcessQueue &Q);//非抢占式优先权调度void delProcess(PCB* delp);bool RunProcessPreem(PCB* rp,ProcessQueue &Q);//抢占式优先执行进程bool PreemptivePriority(ProcessQueue &Q);void RR(ProcessQueue &Q);int main(){int iSel;int i = 0;SelectAlgorithm();ProcessQueue readyQ;//就绪进程队列PCB newpcb;InitQueue(readyQ);printf("请选择调度算法:");do{scanf("%d",&iSel);} while (!(iSel == 1 || iSel == 2 || iSel == 3));while(i < 3){printf("请输入要创建的进程:\n");fflush(stdin);gets(newpcb.PID);fflush(stdin);scanf("%d",&newpcb.needTime);fflush(stdin);scanf("%d",&newpcb.priority);fflush(stdin);gets(newpcb.state);fflush(stdin);CreateQProcess(readyQ,newpcb.PID,newpcb.needTime,newpcb.priority,newpcb.state);printf("创建了一个进程\n");++i;}visitQueue(readyQ);//显示的是各个进程的优先权switch(iSel){case 1:while(NonPreemptivePriority(readyQ));//非抢占优先权调度break;case 2:PreemptivePriority(readyQ);//抢占式优先权调度break;case 3:RR(readyQ);break;}return 0;}void SelectAlgorithm(){printf("1.非抢占式优先权调度\n");printf("2.抢占式优先权调度\n");printf("3.时间片轮转调度\n");}void InitQueue(ProcessQueue &Q)//初始化进程队列{Q.front = Q.rear = (PCB*)malloc(sizeof(PCB));if(!Q.front) exit(-1);Q.front->next = NULL;}void CreateQProcess(ProcessQueue &Q,char* pid,int time,int pri,char* st)//指定进程入就绪队列,将优先权高的插在队列前面{PCB* p = (PCB*)malloc(sizeof(PCB));if(!p) exit(-1);strcpy(p->PID,pid); p->needTime = time;p->priority = pri; strcpy(p->state,st);p->next = NULL;PCB* q = Q.front->next, *old = Q.front;if(!q)//如果原队列为空{Q.rear->next = p;Q.rear = p;//q == NULL}else//如果原队列不为空{for(;q != NULL;){if(p->priority > q->priority){old->next = p;p->next = q;return;}q = q->next;old = old->next;if(q == NULL){Q.rear->next = p;Q.rear = q;//q == NULL}}}}void ProcessSchedule(){}void visitQueue(ProcessQueue &Q)//访问进程队列{PCB* p = (PCB*)malloc(sizeof(PCB));if(!p) exit(-1);p = Q.front->next;while(p != NULL){printf("%d,",p->priority);p = p->next;}printf("\n");int i = 0;}bool PreemptivePriority(ProcessQueue &Q){PCB* rprocess;if(!Q.front->next){printf("就绪队列中没有进程可以调度!\n");return false;}else{rprocess = Q.front->next;//选择优先权最高的进程Q.front->next = Q.front->next->next;//将进程移除就绪队列while(rprocess != NULL)//抢占式优先调度{RunProcessPreem(rprocess,Q);if(rprocess->needTime == 0){delProcess(rprocess);if((rprocess = Q.front->next) == NULL){printf("就绪队列中没有进程可以调度!\n");return false;}else{Q.front->next = Q.front->next->next;continue;}}if(Q.front->next != NULL){if(rprocess->priority < Q.front->next->priority)//判断运行了1个时间后还是否具有最高优先权{/*rprocess->next = Q.front->next->next;//正在运行中的进程因为优先权降低,重新进入就绪队列temp = Q.front->next;Q.front->next = rprocess;rprocess = temp;//rprocess保存运行进程*/CreateQProcess(Q,rprocess->PID,rprocess->needTime,rprocess->priority,rprocess->state);//正在运行中的进程因为优先权降低,重新进入就绪队列rprocess = Q.front->next;Q.front->next = Q.front->next->next;}}}}return true;}bool NonPreemptivePriority(ProcessQueue &Q)//非抢占式优先权调度{PCB* rprocess;//存放要调度运行的进程if(!Q.front->next){printf("就绪队列中没有进程可以调度!\n");return false;}else{rprocess = Q.front->next;Q.front->next = Q.front->next->next;//已经调度,从就绪队列中删除进程if(RunProcess(rprocess,Q)){delProcess(rprocess);printf("就绪队列状态:\n");visitQueue(Q);}return true;}}bool RunProcess(PCB* rp,ProcessQueue &Q)//执行进程{while(rp->needTime){printf("进程%s正在运行...\n",rp->PID);printf("PID[50]\tneedTime\tpriority\tstate[20]\n");printf("%s\t%d\t\t%d\t\t%s\n",rp->PID,rp->needTime,rp->priority,rp->state);Sleep(1000);--rp->needTime;}return true;}bool RunProcessPreem(PCB* rp,ProcessQueue &Q)//抢占式优先,RR执行进程{printf("进程%s正在运行...\n",rp->PID);printf("PID[50]\tneedTime\tpriority\tstate[20]\n");printf("%s\t%d\t\t%d\t\t%s\n",rp->PID,rp->needTime,rp->priority,rp->state);Sleep(1000);--rp->needTime;--rp->priority;return true;}void delProcess(PCB* delp)//撤销进程{free(delp);}void RR(ProcessQueue &Q){PCB* running = Q.front->next;PCB* old = Q.front;while(Q.front->next != NULL){if(running){RunProcessPreem(running,Q);if(running->needTime == 0)//撤销进程{old->next = running->next;delProcess(running);running = old->next;continue;}old = old->next;running = running->next;}else{old = Q.front;running = old->next;}}printf("就绪队列中没有进程可以调度!\n");}以下是使用时间片轮转算法的一次执行:选择算法3:进程输入,此处输入1,1,1,1,2,2,2,2,3,3,3,3测试。

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

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

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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.实验目的:加深对进程概念的理解,熟悉PCB的组织,深入了解创建进程的一般过程,掌握用队列组织进程的方法,掌握进程调度算法。

2.实验内容编程实现创建原语,形成就绪队列,模拟实现进程的调度。

具体内容包括:1)、确定进程控制块的内容,用链表组织进程控制块;2)、完成进程创建原语和进程调度原语;3)、要求采用时间片轮转调度算法;4)、编写主函数对所做工作进程测试。

3、实验具体内容和步骤的说明这个实验主要考虑三个问题:如何组织进程、如何创建进程和如何实现处理器调度。

1)、进程的组织:首先就要设定进程控制块的内容。

进程控制块PCB记录各个进程执行时的情况。

不同的操作系统,进程控制块所记录的信息内容不一样。

操作系统功能越强,软件也越庞大,进程控制块所记录的内容也就越多。

本次实验只使用必不可少的信息。

一般操作系统中,无论进程控制块中信息量多少,信息都可以大致分为以下四类:①标识信息每个进程都要有一个惟一的标识符,用来标识进程的存在和区别于其他进程。

这个标识符是必不可少的,可以用符号或编号实现,它必须是操作系统分配的。

本实验中要求,采用编号方式,也就是为每个进程依次分配一个不相同的正整数。

②说明信息用于记录进程的基本情况,例如进程的状态、等待原因、进程程序存放位置、进程数据存放位置等等。

本模拟实验中,因为进程没有数据和程序,仅使用进程控制块模拟进程,所以这部分内容仅包括进程状态。

③现场信息现场信息记录各个寄存器的内容。

当进程由于某种原因让出处理器时,需要将现场信息记录在进程控制块中,当进行进程调度时,从选中进程的进程控制块中读取现场信息进行现场恢复。

现场信息就是处理器的相关寄存器内容,包括通用寄存器、程序计数器和程序状态字寄存器等。

在实验中,可选取几个寄存器作为代表。

用大写的全局变量AX、BX、CX、DX模拟通用寄存器、大写的全局变量PC模拟程序计数器、大写的全局变量PSW模拟程序状态字寄存器。

操作系统实验之处理机调度实验报告

操作系统实验之处理机调度实验报告

操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一,本次实验的主要目的是通过模拟不同的处理机调度算法,深入理解操作系统对处理机资源的分配和管理策略,比较不同调度算法的性能差异,并观察它们在不同负载情况下的表现。

二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 Python 38。

实验中使用了 Python 的相关库,如`numpy`、`matplotlib`等,用于数据生成、计算和图形绘制。

三、实验原理1、先来先服务(FCFS)调度算法先来先服务算法按照作业到达的先后顺序进行调度。

先到达的作业先被服务,直到完成或阻塞,然后再处理下一个到达的作业。

2、短作业优先(SJF)调度算法短作业优先算法选择预计运行时间最短的作业先执行。

这种算法可以有效地减少作业的平均等待时间,但可能导致长作业长时间等待。

3、时间片轮转(RR)调度算法时间片轮转算法将处理机的时间分成固定长度的时间片,每个作业轮流获得一个时间片的处理时间。

当时间片用完后,如果作业还未完成,则将其放入就绪队列的末尾等待下一轮调度。

4、优先级调度算法优先级调度算法为每个作业分配一个优先级,优先级高的作业先被执行。

优先级可以根据作业的性质、紧急程度等因素来确定。

四、实验内容与步骤1、数据生成首先,生成一组模拟的作业,包括作业的到达时间、预计运行时间和优先级等信息。

为了使实验结果更具代表性,生成了不同规模和特征的作业集合。

2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。

在实现过程中,严格按照算法的定义和规则进行处理机的分配和调度。

3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果:平均等待时间:作业在就绪队列中的等待时间的平均值。

平均周转时间:作业从到达系统到完成的时间间隔的平均值。

系统吞吐量:单位时间内完成的作业数量。

4、实验结果分析对每种调度算法进行多次实验,使用不同的作业集合,并记录相应的性能指标数据。

操作系统试验报告一处理机调度

操作系统试验报告一处理机调度

实验课程名称:实验项目名称处理机调度 实验成绩实验者专业班级名且另IJ同组者实验日期年 月 日第一部分:实验分析与设计(可加页)一、 实验内容描述(问题域描述)实验目的:掌握处理机调度的相关内容,对进程调度算法有深入理解。

实验内容:模拟实现进程调度功能。

实验要求:1、任选一种高级语言实现;2、选择1-2种调度算法;3、能够输入进程的基本信息,如进程名、提交时间、预估运行时间等;4、根据选择的调度算法显示进程调度顺序;5、显示完成调度后每个进程的开始时间、完成时间呢、周转时间,带权周转时间;6、计算平均周转时间和平均带权周转时间。

二、 实验基本原理与设计(包括实验方案设计,实验手段的确定,试验步骤等,用硬件逻辑或者算法描述) 数据结构:一个作业的描述结构: struct WORK {int num;//进程序号startTim;//开始时间 upTim;//提交时间 offTim;//结束时间 costTim;//耗费时间长度 Ti;//周转时间 Tr;//带权周转时间输出模块float floatfloat floatfloat float };功能说明:输入模块、输出模块:负责进程的输入及模拟结果的输出;处理机调度函数调用模块:选择调用算法完成进程调度;先入先出算法模拟模块、短进程优先算法模拟模块:实际完成模拟调度功能;相关时间计算模块:计算开始时间、结束时间,周转时间,带权周转时间。

三、主要仪器设备及耗材硬件:pc机;软件:windows2007旗舰版、VS 2010开发环境。

第二部分:实验调试与结果分析(可加页)一、实验源程序:# include <iostream>using namespace std;struct WORK{int num;//进程序号float startTim;//开始时间float upTimJ/提交时间float offTim;//结束时间float costTim;//耗费时间长度float Ti;〃周转时间float Tr;//带权周转时间};void FIFO(WORK *workspace,int workNum);void SJF(WORK *workspace,int workNum);void SUM(WORK *workspace,int workNum,float *T,float *W);int main(){int num;float upTim;float costTim;int workNum;cout<<"请输入需要被调度的作业的数目:"<<endl;cin>>workNum;WORK *workspace=new WORK[workNum];cout<<"请依次输入需要被调度的作业(输入格式:作业序号作业提交时间(用数字表示) 执行时间):"<<endl;int n=0;while(cin>>num>>upTim>>costTim && n<workNum){workspace[n].num=num;workspace[n].upTim=upTim;workspace[n].costTim=costTim;n++;}cin.clear();cin.sync();cout<<"作业序号\t作业提交时间\t执行时间):"<<endl;for(int i=0;i<workNum;i++) {cout<<workspace[i].num<<"\t\t"<<workspace[i].upTim<<"\t\t<<workspace[i].costTim<<endl;/****************** 选择算法,执行算法,结果输出*****************/int cho=0;float * T=new float[0],* W=new float[0];cout<<"请选择调度算法:"<<endl;cout<<0<<"--->FIFO\n"<<1<<"--->最短优先"<<endl;cin>>cho;switch(cho){case 0:FIFO(workspace,workNum);SUM(workspace,workNum,T,W);break;case 1:SJF(workspace,workNum);SUM(workspace,workNum,T,W);break;}cout<<"执行顺序"<<"\t"<<"提交时间"<<"\t"<<"执行时间"<<"\t"<<"开始时间"<<"\t"<<"结束时间"<<endl;for(int i=0;i<workNum;i++) {cout<<workspace[i].num<<"\t\t"<<workspace[i].upTim<<"\t\t"<<workspace[i].costTim <<"\t\t"<<workspace[i].startTim<<"\t\t"<<workspace[i].offTim<<endl;}cout<<"平均周转时间:"<<(*T)/workNum<<"\t 平均带权周转时间:"<<(*W)/workNum<<endl;system("PAUSE"); return 0;}void FIFO(WORK *workspace,int workNum)for(int i=0;i<workNum-1;i++) 〃按提交时间排序for(int j=0;j<workNum-1;j++)if(workspace[j].upTim>workspace[j+1].upTim) 〃大数沉底{WORK temp;temp=workspace[j+1];workspace[j+1]=workspace[j];workspace[j]=temp;}}void SJF(WORK *workspace,int workNum){float MinUptime=0;//最早的提交时间FIFO(workspace,workNum);//先按提交时间排序MinUptime=workspace[0].upTim+workspace[0].costTim;for(int i=0;i<workNum-1;i++) 〃按照最短的作业时间排序for(int j=1;j<workNum-1;j++){if(workspace[j].upTim<MinUptime&&workspace[j+1].upTim<MinUptime) {if(workspace[j].costTim>workspace[j+1].costTim) 〃提交时间大且耗时多的作业沉底{WORK temp;temp=workspace[j+1];workspace[j+1]=workspace[j]; workspace[j]=temp;}} else {MinUptime=workspace[j].upTim+workspace[j].costTim;//更新}}}void SUM(WORK *workspace,int workNum,float *T,float *W){*T=0;*W=0;for(int i=0;i<workNum;i++)//计算开始时间、结束时间,周转时间,带权周转时间{ if(i==0)//计算第一个作业{workspace[i].startTim=workspace[i].upTim;workspace[i].offTim=workspace[i].upTim+workspace[i].costTim;workspace[i].Ti=workspace[i].offTim-workspace[i].upTim;workspace[i].Tr=workspace[i].Ti/workspace[i].costTim;}else//计算第一个作业基础上的其他作业相关时间{if(workspace[i-1].offTim<workspace[i].upTim)workspace[i].startTim=workspace[i].upTim;elseworkspace[i].startTim=workspace[i-1].offTim;workspace[i].offTim=workspace[i].costTim+workspace[i].startTim; workspace[i].Ti=workspace[i].offTim-workspace[i].upTim; workspace[i].Tr=workspace[i].Ti/workspace[i].costTim; }*T+=workspace[i].Ti;//计算平均周转时间 *W+=workspace[i].Tr;//计算平均带权周转时间 } } 二、 实验结果及分析(包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等)测试用例一结果:请依次前A 需要被洞度的作止:葡人格式;作出序号 执行时间M 1 10 2,眼糟翎要被调度的作业(输入格式:作业序号1 10 2作止提交升间1用道字表示)|2 10.2 1 1? 10a 4 0a 5 L 10a 5 0a 2■(此序]作业提父H J 闫 L 10Z 10.23 10.4k10.5青选择调度算法:0——>FIF0 i-—>最超优先 执行时间), 暨 1 0.5 0.3a 二顺序提交时间 执行时间开始时间结束时间1 10210 12,10.2i 12 13 卜 10.4 8.5 13 13.E 口 1Q.5 0.3平均周转时间.2.8 平均带权周转时间吗.26岛北旺京银继纨 -±3.513.8邛业序与 作北提交时、日h 1M 执行时间)।21«.2 13 10.4 0.5 MIB.E情选区调度算法,同——>FIF0 口一》最短优先 0.3执行顺序 提交时间1 10 执行时间 2开始时间10 结克时间 124IB.E 0.3 12 12.3 10.4 0.5 12.3 12.81M-21句周转时间:2.45平均带权周转时间:3.8512.JS13=8日数据细撷处理机调度废锚纵员或吐理挑洞庭模物n京葡a 需要神话后日作业的数诸输妻萼猫调康的作斗的豹目:2 1M-2 1 □ 10.4 0.5 4 10-5 0,3回作业提交时间(用数字表。

处理机调度实验报告

处理机调度实验报告

处理机调度实验报告处理机调度实验报告一、引言处理机调度是计算机操作系统中一个重要的概念,它涉及到如何合理地分配处理机资源以提高系统的运行效率。

本文将针对处理机调度进行实验,探讨不同调度算法对系统性能的影响。

二、实验目的本实验的目的是通过模拟不同的处理机调度算法,比较它们在不同负载下的性能表现,进而分析其优缺点,为实际操作系统的调度算法选择提供参考。

三、实验方法1. 实验环境本实验使用了一台配置较高的计算机作为实验环境,操作系统为Linux,处理器为Intel Core i7,内存为8GB。

2. 实验设置为了模拟不同的负载情况,我们使用了三个不同的测试程序:程序A、程序B和程序C。

程序A是一个计算密集型任务,程序B是一个I/O密集型任务,程序C是一个混合型任务。

3. 实验步骤首先,我们分别运行程序A、程序B和程序C,并记录它们的运行时间。

然后,我们使用不同的调度算法来调度这些任务,并记录它们的运行时间和系统资源利用率。

四、实验结果与分析1. 调度算法1:先来先服务(First-Come, First-Served,FCFS)FCFS算法按照任务到达的先后顺序进行调度,即先到先服务。

实验结果显示,在计算密集型任务下,FCFS算法表现较好,但在I/O密集型任务和混合型任务下,其性能明显下降。

这是因为在FCFS算法中,任务的执行顺序是固定的,无法根据任务的特性进行灵活调度。

2. 调度算法2:最短作业优先(Shortest Job First,SJF)SJF算法根据任务的执行时间进行调度,即执行时间最短的任务先执行。

实验结果显示,在计算密集型任务和混合型任务下,SJF算法表现较好,但在I/O密集型任务下,其性能较差。

这是因为在I/O密集型任务中,任务的执行时间不仅与计算量有关,还与I/O操作的耗时有关,因此SJF算法无法有效地进行调度。

3. 调度算法3:时间片轮转(Round Robin,RR)RR算法将处理机的运行时间划分为若干个时间片,每个任务在一个时间片内执行一定的时间,然后切换到下一个任务。

处理器调度算法实验报告

处理器调度算法实验报告

处理器调度算法实验报告1. 背景处理器调度算法是操作系统中的重要组成部分,用于优化多道程序在处理器上的执行顺序,提高系统的整体性能和响应时间。

通过合理的调度算法,可以使多个进程公平竞争处理器资源,并满足不同进程的优先级要求。

本次实验旨在探究不同的处理器调度算法在不同场景下的效果,以及调度算法对系统性能的影响。

2. 分析2.1 实验环境本次实验使用模拟器搭建了一个简化的多道程序系统,包含多个进程和一个处理器。

每个进程具有不同的优先级和执行时间。

调度算法的任务是按照一定的规则将进程调度到处理器上执行。

2.2 调度算法本次实验采用了三种常见的调度算法进行比较:先来先服务调度(FCFS)、最短作业优先调度(SJF)和时间片轮转调度(RR)。

•FCFS算法:按照进程到达的先后顺序进行调度,即先到先服务。

该算法简单直观,但无法考虑进程的执行时间,可能导致长作业优先问题。

•SJF算法:按照进程的执行时间进行调度,先执行执行时间较短的进程。

该算法可以减少平均等待时间,但是对长作业不公平。

•RR算法:将进程按照到达顺序排成一个队列,每个进程执行一小段时间片后,切换到下一个进程。

该算法可以公平地分配处理器资源,但是可能导致上下文切换频繁。

2.3 实验设计本次实验设计了多个场景,每个场景包含一组具有不同优先级和执行时间的进程。

在每个场景中,分别使用FCFS、SJF和RR算法进行调度,并记录每个进程的等待时间和周转时间。

2.4 实验结果经过实验统计和数据分析,得到了每个场景下不同调度算法的各项指标,如下表所示:实验场景算法平均等待时间平均周转时间场景1 FCFS 10 20场景1 SJF 5 15场景1 RR 8 18场景2 FCFS 15 25场景2 SJF 5 15场景2 RR 12 22…………2.5 结果分析从上表可以看出,不同的调度算法在不同场景下表现出了不同的性能。

具体分析如下:•FCFS算法在长作业的场景中表现较差,平均等待时间和平均周转时间较长。

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

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

实验一处理机调度实验报告一、实验目的处理机调度是操作系统中的一个重要组成部分,其目的是合理地分配处理机资源,以提高系统的性能和效率。

本次实验的主要目的是通过模拟处理机调度算法,深入理解不同调度算法的工作原理和性能特点,并能够对它们进行比较和分析。

二、实验环境本次实验使用了以下软件和工具:1、操作系统:Windows 102、编程语言:Python3、开发环境:PyCharm三、实验内容1、先来先服务(FCFS)调度算法先来先服务调度算法按照作业或进程到达的先后顺序进行调度。

即先到达的作业或进程先得到处理机的服务。

2、短作业优先(SJF)调度算法短作业优先调度算法优先调度运行时间短的作业或进程。

在实现过程中,需要对作业或进程的运行时间进行预测或已知。

3、高响应比优先(HRRN)调度算法高响应比优先调度算法综合考虑作业或进程的等待时间和运行时间。

响应比的计算公式为:响应比=(等待时间+要求服务时间)/要求服务时间。

4、时间片轮转(RR)调度算法时间片轮转调度算法将处理机的时间分成固定大小的时间片,每个作业或进程在一个时间片内运行,当时间片用完后,切换到下一个作业或进程。

四、实验步骤1、设计数据结构为了表示作业或进程,设计了一个包含作业或进程 ID、到达时间、运行时间和等待时间等属性的数据结构。

2、实现调度算法分别实现了上述四种调度算法。

在实现过程中,根据算法的特点进行相应的处理和计算。

3、模拟调度过程创建一组作业或进程,并按照不同的调度算法进行调度。

在调度过程中,更新作业或进程的状态和相关时间参数。

4、计算性能指标计算了平均周转时间和平均带权周转时间等性能指标,用于评估不同调度算法的性能。

五、实验结果与分析1、先来先服务(FCFS)调度算法平均周转时间:通过计算所有作业或进程的周转时间之和除以作业或进程的数量,得到平均周转时间。

在 FCFS 算法中,由于按照到达顺序进行调度,可能会导致长作业或进程长时间占用处理机,从而使平均周转时间较长。

处理器调度实验报告

处理器调度实验报告

一、实验目的1. 理解处理器调度的基本概念和原理;2. 掌握常用的处理器调度算法,如先来先服务(FCFS)、短作业优先(SJF)、优先级调度等;3. 分析不同调度算法的性能指标,如平均周转时间、平均带权周转时间等;4. 通过实验,提高实际操作和编程能力。

二、实验原理处理器调度是操作系统中的一个重要组成部分,其主要任务是合理分配处理器资源,使系统中的多个进程高效、有序地运行。

常见的处理器调度算法有以下几种:1. 先来先服务(FCFS):按照进程到达就绪队列的顺序进行调度,先到先服务;2. 短作业优先(SJF):优先选择运行时间最短的进程执行;3. 优先级调度:根据进程的优先级进行调度,优先级高的进程先执行;4. 时间片轮转(RR):将每个进程分配一个时间片,按照时间片轮转的方式调度进程。

三、实验内容1. 实验环境:Windows操作系统,Python编程语言;2. 实验工具:Python编程环境,如PyCharm、Spyder等;3. 实验步骤:(1)设计一个进程类,包含进程名、到达时间、运行时间、优先级等属性;(2)编写调度算法,实现FCFS、SJF、优先级调度和时间片轮转算法;(3)模拟进程执行过程,记录各个进程的执行时间、等待时间、周转时间等性能指标;(4)分析不同调度算法的性能,比较其优劣。

四、实验结果与分析1. FCFS调度算法实验结果:平均周转时间为20,平均带权周转时间为1.25。

分析:FCFS调度算法简单易实现,但可能导致进程响应时间长,不利于实时性要求高的系统。

2. SJF调度算法实验结果:平均周转时间为16,平均带权周转时间为1.2。

分析:SJF调度算法可以缩短平均周转时间,提高系统性能,但可能使长作业长时间等待,影响公平性。

3. 优先级调度算法实验结果:平均周转时间为18,平均带权周转时间为1.3。

分析:优先级调度算法可以根据进程的优先级进行调度,提高系统响应速度,但可能导致低优先级进程长时间等待。

处理器调度实验报告

处理器调度实验报告

处理器调度实验报告处理器调度实验报告一、实验目的处理器调度是操作系统中的重要组成部分,它负责决定哪个进程优先执行,以及如何分配处理器资源。

本次实验旨在通过模拟不同的处理器调度算法,深入了解各种算法的工作原理和优缺点。

二、实验背景在多道程序设计环境下,多个进程同时竞争有限的处理器资源。

为了提高系统的吞吐量和响应速度,需要合理地调度进程,使得每个进程都能得到公平的执行机会。

处理器调度算法的选择直接影响到系统的性能和用户体验。

三、实验内容本次实验使用模拟器来模拟不同的处理器调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和优先级调度(Priority Scheduling)。

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

四、实验过程与结果首先,我们设计了一组测试用例,每个测试用例包含若干个进程,每个进程具有不同的执行时间和优先级。

然后,我们分别使用不同的调度算法对这些进程进行调度,并记录下每个进程的等待时间和周转时间。

在FCFS算法下,进程按照到达的先后顺序依次执行。

这种算法简单直观,但是容易造成后面进程的等待时间过长,尤其是当某个进程执行时间较长时。

SJF算法根据进程的执行时间来进行调度,执行时间最短的进程先执行。

这种算法能够最大程度地减少平均等待时间,但是对于长作业来说,可能会出现饥饿现象。

RR算法将处理器的时间划分为若干个时间片,每个进程在一个时间片内执行一定的时间,然后切换到下一个进程。

这种算法能够保证每个进程都能得到执行的机会,但是对于执行时间较长的进程来说,可能会造成较大的上下文切换开销。

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

这种算法可以根据不同的场景进行调整,但是可能会出现优先级反转的问题。

通过实验结果的分析,我们可以看到不同的调度算法在不同场景下的表现。

对于短作业来说,SJF算法能够最大程度地减少等待时间;对于长作业来说,RR算法能够保证公平性;而优先级调度算法则适用于一些需要特定优先级处理的场景。

实验一处理器调度实验报告精编版

实验一处理器调度实验报告精编版

实验一处理器调度实验报告精编版MQS system office room 【MQS16H-TTMS2A-MQSS8Q8-MQSH16898】实验一处理器调度一、实验内容选择一个调度算法,实现处理器调度。

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

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

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

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

进程控制块的格式为:其中,进程名----P1,P2,P3,P4,P5。

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

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

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

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

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

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

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

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

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

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

在这里省去了这些工作。

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

操作系统实验之处理机调度实验报告

操作系统实验之处理机调度实验报告
四、开发工具及主要源代码
1、开发工具
Clion for mac 2016,采用 cmake 编译。
2、主要源码
//先来先服务 void FCFS(List *p, int count) {
List temp; int i, j; //按照到达时间排序 for (i = 1; i < count; i++) {
min = 100; temp = p[k].Finish_time; for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time < 0) continue;
if (min > p[j].Service_time) {
max = 0;
temp = p[k].Finish_time; //找响应比最高任务 for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time <= 0) continue;
if (max < (temp - p[j].Arrival_time) / p[j].Service_time) {
if (temp > p[i].Arrival_time) {
temp = p[i].Arrival_time; k = i; } } //按照响应比大小设置优先级,以及相应参数 for (i = 0; i < count; i++) { p[k].order = ++flag; p[k].Start_time = temp; p[k].Wait_time = temp - p[k].Arrival_time; p[k].Finish_time = temp + p[k].Service_time; p[k].Turnover_time = p[k].Finish_time - p[k].Arrival_time; p[k].WeightedTurn_time = p[k].Turnover_time / p[k].Service_time;

处理器调度算法实验报告

处理器调度算法实验报告

处理器调度算法实验报告一、实验目的本次实验的目的是通过模拟处理器调度算法,了解不同调度算法的优缺点,以及如何根据不同场景选择合适的算法。

二、实验环境本次实验使用C++语言编写程序,在Visual Studio 2019环境下进行开发和测试。

三、实验内容1. 实现FIFO调度算法FIFO(First In First Out)调度算法是最简单的一种调度算法,即先进先出。

在这种算法中,作业按照提交顺序排队等待执行。

当CPU空闲时,选择队列中最早提交的作业进行执行。

这种算法没有考虑作业的优先级和执行时间长短等因素,只关注作业的提交时间。

因此,在一些场景下可能会出现长作业占用CPU资源导致短作业等待时间过长等问题。

2. 实现SJF调度算法SJF(Shortest Job First)调度算法是一种非抢占式的短作业优先算法。

在这种算法中,每个作业都有一个估计运行时间,在CPU空闲时选择估计运行时间最短的作业进行执行。

如果两个作业估计运行时间相同,则按照提交顺序进行排队。

这种算法可以有效地减少平均等待时间和平均周转时间,但是可能会导致长作业等待时间过长。

3. 实现优先级调度算法优先级调度算法是一种抢占式的算法,即当高优先级作业到达时可以抢占正在执行的低优先级作业。

在这种算法中,每个作业都有一个优先级,CPU空闲时选择优先级最高的作业进行执行。

这种算法可以根据不同场景设置不同的作业优先级,但是可能会导致低优先级作业等待时间过长。

4. 实现时间片轮转调度算法时间片轮转调度算法是一种抢占式的循环调度算法。

在这种算法中,每个作业被分配一个固定长度的时间片,在该时间片内执行完毕后,如果该作业还未完成,则将其放入队尾等待下一次调度。

这种算法可以有效地保证每个作业都有机会获得CPU资源,并且能够避免长作业占用CPU资源导致短作业等待时间过长。

四、实验结果通过对以上四种调度算法进行模拟实验,得到了以下结果:1. FIFO调度算法:平均等待时间较长,平均周转时间也较长。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

操作系统实验⼀:处理器调度算法的实现⼀、实验⽬的(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算法思想:先来先服务算法按照作业进⼊系统后备作业对列的先后次序来挑选作业,先进⼊系统的作业将优先被挑选进⼊内存,创建⽤户进程,分配所需资源,然后移⼊就绪队列。

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的
启动运行,而是执行:
优先数- 1 要求运行时间-1
来模拟进程的一次运行提醒注意的是:在实际的系统中,当一个进程被选中运
行时,必须恢复进程的现场,
它占有处理器运行,直到出现等待事件或运行结束。

在这里省去了这些工作。

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

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

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

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

四、程序中使用的数据结构及符号说明:
#define num
输出提 i=0 提示按键继 i=i+1 结・
输出 pcblist[i] 、开始 [n r 定义i
程序清D,&pcblist[i].pri,&pcblist[i].ru
ntime);
pcblist[i].state二
'R';tate==Y')ri&&pcblist[i].state=='R')ri;tate二
='F')D,pcblist[i].pri,pcblist[i].runtime,&pcblist[i].state);
}
printf(" press any key to continue...\n");
}
void run()untime;}tate='r';tate=='r')
{ pcblist[i].pri-=1;untime--;untime==0)
pcblist[i].state='F';tate='R';// 未运行完将其状态置为就绪
}
show();〃显示每次运行后各PCB的情况
getchar();// 等待回车进入下一次运行
} } }
}
void main()// 按动态优先数调度主程序
{
init();// 初始化各个进程PCB
run();// 进程调度模拟
}
七、实验总结本次实验通过课本处理器调度的进程的初步认识和实验按优先数调度算法实现处理器调度的实现,了解到进程与进程控制块之间的联系,进程运行过程中状态以及已运行时间的判断和计算,选中运行的进程名以及选中进程运
行后的各进程控制块状态。

相关文档
最新文档