进程调度算法实验报告doc

合集下载

(完整word版)操作系统-进程调度算法设计与实现实验报告

(完整word版)操作系统-进程调度算法设计与实现实验报告

实验报告课程名称操作系统实验名称进程调度算法设计与实现姓名学号专业班级实验日期成绩指导教师(①实验目的②实验设备和环境③实验内容与步骤④实验结果与分析⑤总结,问题及建议)一、内容:设计一个简单的进程调度算法,模拟OS中的进程调度过程二、要求:①进程数不少于5个;②进程调度算法任选;最好选用动态优先数法,每运行一个时间片优先数减3③用C++(或C)语言编程;④程序运行时显示进程调度过程。

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

四、分析假设调度前,系统中有5个进程,其初始状态如下:①以时间片为单位调度运行;②每次总是从ALLTIME中不为0,且PRIORITY最大的进程调度运行一个时间片;③上述进程运行后其优先数减3,再修改其CPUTIME和ALLTIME,重复②,③④直到所有进程的ALLTIME均变为0。

五、代码#include〈iostream〉#include〈string〉#include<queue〉using namespace std;typedef struct pcb {string pName;//进程名int priorityNumber;//优先数float serviceTime;//服务时间float estimatedRunningtime;//估计运行时间char state;//状态bool operator〈(const struct pcb &a)const {return priorityNumber > a。

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

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

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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.通过实验理解有关进程控制块,进程队列等的概念。

二、实验原理各调度算法思想:1.先来先服务算法(FCFS):按照进程进入就绪队列的先后次序来分配CPU,一旦一个进程占有CPU,就一直运行下去,知道该进程完成工作,才释放CPU。

2.时间片轮转算法:系统将所有就绪进程按到达时间的先后次序排成一个队列,进程调度程序总是选择队列中的第一个进程执行,且仅能执行一个时间片,在使用完一个时间片后,即使进程并未完成其运行,也必须将CPU交给下一个进程;如果一个时间片未使用完就完成了该进程,则剩下的时间分配给下一个进程。

3.优先权调度算法;在创建进程时就确定优先权,确定之后在整个程序运行期间不再改变,根据优先级排列,系统会把CPU分配给优先权最高的进程。

三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义:PCB块结构体类型struct PCB{int name;int arrivetime; // 到达时间int servicetime; // 服务时间//int starttime[max]; // 开始时间int finishtime; // 完成/ 结束时间int turntime; // 周转时间int average_turntime; // 带权周转时间int sign; // 标志进程是否完成int remain_time; // 剩余时间int priority; // 优先级}pcb[max];主程序的流程以及各程序模块之间的层次( 调用) 关系:主程序中从键盘得到进程的数量,创建PCB,调用layout ()函数显示选择界面。

Layout ()函数中选择相应的算法并调用相关函数如:FCFS()、time_segment(); Priority() ,这三个函数分别实现先来先服务算法,时间片轮转算法和优先级算法,最后分别打印。

进程调度算法实验报告

进程调度算法实验报告

进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中的重要组成部分,它决定了进程在CPU上的执行顺序。

合理的进程调度算法能够提高系统的性能和效率,使得多个进程能够公平地共享CPU资源。

本实验旨在通过实际操作和数据分析,探究不同的进程调度算法对系统性能的影响。

二、实验方法1. 实验环境本次实验使用了一台配置较高的计算机作为实验环境,操作系统为Windows 10。

实验中使用了C语言编写的模拟进程调度程序。

2. 实验步骤(1)编写模拟进程调度程序,实现常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和优先级调度(Priority)。

(2)设计一组测试用例,包括不同执行时间的进程和不同优先级的进程。

(3)运行模拟进程调度程序,记录每个进程的等待时间、周转时间和响应时间。

(4)根据实验结果分析不同进程调度算法的性能差异。

三、实验结果与分析1. 先来先服务(FCFS)调度算法先来先服务调度算法按照进程到达的先后顺序进行调度,即先到达的进程先执行。

实验结果显示,该算法对于执行时间较短的进程表现良好,但对于执行时间较长的进程则存在明显的不公平性。

长作业的等待时间较长,导致整体执行效率较低。

2. 最短作业优先(SJF)调度算法最短作业优先调度算法按照进程执行时间的长度进行调度,即执行时间最短的进程先执行。

实验结果显示,该算法能够最大程度地减少平均等待时间和周转时间,提高系统的执行效率。

然而,该算法对于执行时间较长的进程存在饥饿问题,即长作业可能一直等待短作业的执行,导致长作业的等待时间过长。

3. 时间片轮转(RR)调度算法时间片轮转调度算法将CPU的执行时间划分为固定长度的时间片,每个进程按照轮流执行的方式进行调度。

实验结果显示,该算法能够保证每个进程都能够获得一定的执行时间,提高了系统的公平性。

然而,对于执行时间较长的进程而言,由于需要等待其他进程的轮转,其执行效率相对较低。

进程调度实验报告

进程调度实验报告

进程调度实验报告一、实验目的。

本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。

二、实验环境。

本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。

三、实验过程。

1. 先来先服务(FCFS)调度算法。

先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。

在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。

实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。

2. 最短作业优先(SJF)调度算法。

最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。

在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。

实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。

3. 时间片轮转(RR)调度算法。

时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。

在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。

实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。

4. 多级反馈队列(MFQ)调度算法。

多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。

在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。

实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。

四、实验总结。

通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。

进程调度算法实验报告

进程调度算法实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

【精品】进程调度算法模拟实验报告

【精品】进程调度算法模拟实验报告

【精品】进程调度算法模拟实验报告一、实验目的本实验通过模拟进程的调度算法,使学生掌握多种进程调度算法的实现过程及其优缺点。

二、实验内容本实验实现了三种进程调度算法:先来先服务(First Come First Served,FCFS)、最短作业优先(Shortest Job First,SJF)、时间片轮转(Round Robin,RR)。

(一)FCFS算法FCFS算法是一种非抢占式的进程调度算法,按照进程到达的先后顺序进行执行,即先到达的进程先被执行,后到达的进程后被执行。

当一个进程在执行过程中发生等待时,其他新到达的进程会继续执行。

等待时间长的进程会长时间等待,造成了响应时间长的问题。

SJF算法是一种动态优先级的进程调度算法,按照进程预计运行时间的大小来决定其优先级,预计运行时间短的进程具有高优先级。

当一个新进程到达时,如果其预计运行时间比当前正在运行的所有进程都短,那么这个新进程就可以立即执行。

该算法在保证短作业优先的同时,可能会导致长作业饥饿的问题。

(三)RR算法RR算法是一种抢占式的进程调度算法,每个进程被分配一个时间片,当一个进程的时间片用完时,就被剥夺CPU,然后排到队列的末尾,等待下一次调度。

该算法能够保证每个进程的响应时间比较短,但可能会导致CPU利用率较低。

三、实验步骤(一)编写程序框架首先,根据实验要求,编写完整的程序框架,包括进程类Process和调度器类Scheduler。

Process类中包含了进程需要的属性和方法,如进程ID、进程到达时间、进程执行时间、进程状态等。

Scheduler类中包含了进程调度所需要的方法,如FCFS、SJF、RR 调度算法等。

(二)实现进程调度算法FCFS算法较为简单,只需要按照进程到达时间排序即可。

```pythondef FCFS(self):queue = Queue()process_time = 0while not self.is_finished():ready_process = self.get_arrived_process(process_time)if ready_process:queue.put(ready_process)if not queue.empty():current_process = queue.get()current_process.status = 'running'current_process.start_time = process_timecurrent_process.end_time = current_process.start_time + current_process.run_timeself.finished_processes.append(current_process)process_time += 1```2. SJF算法SJF算法需要进行进程预计运行时间的排序,然后按照排序后的顺序进行执行。

实验进程调度的实验报告

实验进程调度的实验报告

一、实验目的1. 加深对进程概念和进程调度算法的理解。

2. 掌握进程调度算法的基本原理和实现方法。

3. 培养编程能力和系统分析能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块(PCB)3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一,负责将CPU分配给就绪队列中的进程。

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

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

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

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

4. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行,时间片结束后进行调度。

五、实验步骤1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、运行时间、优先级、状态等信息。

2. 创建进程队列,用于存储就绪队列、等待队列和完成队列。

3. 实现进程调度算法:a. FCFS算法:按照进程到达就绪队列的顺序进行调度。

b. SJF算法:优先调度运行时间最短的进程。

c. 优先级调度算法:根据进程的优先级进行调度。

d. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行。

4. 模拟进程调度过程:a. 初始化进程队列,将进程添加到就绪队列。

b. 循环执行调度算法,将CPU分配给就绪队列中的进程。

c. 更新进程状态,统计进程执行时间、等待时间等指标。

d. 当进程完成时,将其移至完成队列。

六、实验结果与分析1. FCFS算法:按照进程到达就绪队列的顺序进行调度,简单易实现,但可能导致短作业等待时间过长。

2. SJF算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。

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

进程调度算法实验报告篇一:操作系统进程调度算法模拟实验报告进程调度算法模拟专业:XXXXX 学号:XXXXX 姓名:XXX实验日期:20XX年XX月XX日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。

二、实验要求编写程序实现对5个进程的调度模拟,要求至少采用两种不同的调度算法分别进行模拟调度。

三、实验方法内容1. 算法设计思路将每个进程抽象成一个控制块PCB, PCB用一个结构体描述。

构建一个进程调度类。

将进程调度的各种算法分装在一个类中。

类中存在三个容器,一个保存正在或未进入就绪队列的进程,一个保存就绪的进程,另一个保存已完成的进程。

还有一个PCB实例。

主要保存正在运行的进程。

类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。

主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。

当程序启动时,用户可以选择不同的调度算法。

然后用户从控制台输入各个进程的信息,这些信息保存到进程容器中。

进程信息输入完毕后,就开始了进程调度,每调度一次判断就绪队列是否为空,若为空则系统时间加一个时间片。

判断进程容器中是否有新的进程可以加入就绪队列。

2. 算法流程图主程序的框架:();//先来先服务();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息();.m_WaitQueue.empty()||.m_ProcessQueue.empt() ();();进程调度过程:;3. 算法中用到的数据结构struct fcfs{//先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;floatdqzztime;};//定义一个结构体,里面包含的有一个进程相关的信息4. 主要的常量变量vectorm_ProcessQueue;//进程输入队列vectorm_WaitQueue;//进程就绪队列vectorm_FinishQueue;//完成队列vector::iterator m_iter;//迭代器 PCB m_runProcess;//运行中的进程int m_ProcessCount;//进程数 float m_RunTime;//运行时间int m_tagIsRun;//是否在运行标志。

表示正在运行,表示没有 float m_TimeSlice;//时间片大小int m_TimeSliceCount;//指时间片轮转中一次分到的时间片个数 char m_SchedulerAlgorithm;//调度算法5. 主要模块void PCBInput();//输入进程信息void PCBSort();//对进程控制块按照优先级排序(采用冒泡排序)void ProcessSelect();//若当前就绪队列不为空则根据选择的调度算法开始调度。

否则,系统时间void PCBDisplay();//打印当前状况下。

就绪队列、完成队列、运行中的进程信息void ProcessRun();//进程运行一次。

运行时间加个时间片。

并判断进程是否达到完成条件。

若是则void ProcessQueueProcess();//查看当前时间下,有无进程加入。

若有则把该进程调入就绪队列 void ProcessDispatch();//进程分派,进程执行完成后决定进程该进入哪个队列(就绪、完成) void TimePast(){ m_RunTime +=m_TimeSlice; ProcessQueueProcess();}//当前系统时间加个时间void SchedulerStatistics();//调度统计,计算周转时间等void FCFS();//先来先服务 void SJF();//最短进程优先调度 void RR();//简单时间片轮转 void PD();//最高优先数优先加.以等待新的进程到来ProcessStatus='f'.否则为'w';片,并检查是否有新的进程加入四、实验代码#include #include #includeusing namespace std;struct fcfs{//先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;};//定义一个结构体,里面包含的有一个进程相关的信fcfs a[100];void input(fcfs *p,int N) {int i;cout for(i=0;i }}void Print(fcfs *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){ int k;printf("\n\n调用先来先服务算法以后进程运行的顺序是: ");printf("%s",p[0].name);for(k=1;k%s",p[k].name);} cout printf("\t进程名到达时间服务时间开始时间结束时间周转时间带权周转时间\n");for(k=0;k printf("\t%s\t%-.2f\t %-.2f\t%-.2f\t %-.2f\t %-.2f \t %-.2f\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k ].zztime,p[k].dqzztime);}getchar(); //此处必须要有这个函数,否则就看不到显示器上面的输出,可以看到的结果只是一闪而过的一个框}void sort(fcfs *p,int N) //排序篇二:进程的调度算法实验报告-计算机操作系统教程(第三版)进程的调度算法实验报告(完整版)一、实验目的:用高级语言编写和调试一个简单的进程调度程序。

加深了解有关进程控制块,进程队列的概念,并体会和了解优先数和时间片调度算法的具体实施方法。

二、实验内容:根据不同的调度算法模拟操作系统对进程的调度。

调度算法有二种:动态优先级法和时间片循环法。

1、设计进程控制块PCB表结构,分别适用优先数调度算法和循环时间片轮转算法。

2、PCB结构通常包括以下信息:进程名、进程优先数、轮转时间片、进程的CPU时间,进程状态等。

根据调度算法不同,PCB结构可作适当的调整。

3、建立进程队列。

对不同的算法编制不同的入链程序编制两种进程调度算法:a、优先数调度;b、循环时间轮转调度三、实验设计1.实验原理:2.算法思想:以时间片为计量单位A:优先数调度算法1)系统初始化时给每一个进程赋一个NEEDTIME和初始PRI。

并按优先数入队。

2)系统每次选定一个优先级最高的进程投入运行,进程每执行一次,优先数减2,并将它的进程占用的CPU时间加10,进程到完成还要的CPU时间减10。

3)每当一个进程运行一个时间片后,系统根据它的CPUTIME来判断它是否已经结束,若CPUTIME>0,那么将它重新排入就绪队列。

4)如果系统中尚有进程没有运行完毕,那么转入2)。

B:循环时间片轮转算法1)系统初始化时给每一个进程赋以一个NEEDTIME,并将所有进程按进入的次序排成一个队列。

2)取队头进程,并投入运行。

3)采用相对固定时间片(ROUND),进程每执行一次,进程占用的CPU时间加ROUND,进程到完成还要的CPU时间减ROUND。

并排到就绪队列的尾部。

4)如果当前进程的NEEDTIME>0,那么将它排到队尾。

5)如果尚有进程在队列中,那么转入2)3.编程语言、主要数据结构和意义使用VC6.0语言PCB结构:name 进程名pri /round 进程优先数/进程轮转时间片cputime 进程占用的CPU时间needtime 进程到完成还要的时间state 进程状态(假设状态为 Ready、Run、Finish)next 链指针void showlist(link,char*,int);//显示进程队列void instlist(link,link);//按优先数插入进程void appenlist(link,link);//按就绪先后加入进程link gethead(link);//取队首进程4.流程图(优先数算法)5. 源程序(含主要注释)#include "stdlib.h"#include "iostream.h"#include "string.h"const int MAX= 5;const int ROUND=2;const char *ITOA[10]={"0","1","2","3","4","5","6","7","8","9"}; typedef enum flag{Ready,Run,Finish};struct pcb{public:char name[10];//进程名int pri; //进程优数int round; //进程轮转时间片int cputime; //进程占用的CPU时间int needtime; //进程到完成还要的CPU时间 flag state; //进程状态struct pcb *next;//链指针};typedef struct pcb plist;typedef plist *link;void main(){void showlist(link,char*,int);//显示进程队列 v oid instlist(link,link);//按优先数插入进程void appenlist(link,link);//按就绪先后加入进程link gethead(link);//取队首进程int num=MAX+1;char str[10];link ptr,head1,head2;int i;int j=0;head1=new plist;head1->next=NULL;//就绪队首指针head2=new plist;head2->next=NULL;//完成队首指针while ((num>MAX)||(num {// printf("请输入演示进程数\n");cout // scanf("%d",&num);篇三:操作系统原理---进程调度实验报告一、实验目的通过对进程调度算法的设计,深入理解进程调度的原理。

相关文档
最新文档