进程调度算法实验报告
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。
其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。
在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。
2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。
3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。
实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。
因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。
同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。
进程调度程序实验报告
一、实验目的通过本次实验,加深对进程调度原理和算法的理解,掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序,实现不同调度算法的模拟,并通过实验验证算法的性能。
二、实验环境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调度算法简单,但可能导致长作业等待时间过长。
实验一、进程调度实验报告
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。
进程调度算法实验报告doc
进程调度算法实验报告篇一:操作系统进程调度算法模拟实验报告进程调度算法模拟专业: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;//是否在运行标志。
进程调度实验报告
进程调度实验报告这篇文章将讨论进程调度的相关实验及其结果。
进程调度是指计算机在多任务环境下对进程进行管理和调度,以便最大化系统的效率和可靠性。
在进程调度实验中,我们使用了Linux操作系统,并编写了一段程序来模拟具有多个进程的计算机系统。
我们首先定义了三个不同类型的进程:I/O Bound进程、CPU Bound进程和Interactive进程。
I/O Bound进程是一个需要从磁盘读取数据并进行处理的进程,CPU Bound进程则是一个需要使用CPU来完成复杂计算的进程,而Interactive进程是用户与系统交互的进程。
实验中,我们使用了三个不同的进程调度算法:Round Robin、先来先服务(FCFS)和最短作业优先(SJF)。
Round Robin是最简单的进程调度算法,它会将CPU时间分配给每个进程一段时间,然后切换到下一个进程。
FCFS根据队列中进程的顺序分配CPU时间。
SJF则是根据进程执行所需时间的长度进行调度的。
在我们的实验中,我们评估了每个算法的性能,并得出了以下结论:Round Robin算法的结果最好。
我们发现这种算法的表现非常良好,因为它能在繁忙的计算机系统中平均分配CPU时间,并避免长时间运行的进程占用计算机资源。
FCFS算法的性能很糟糕。
我们发现在FCFS算法中,长时间运行的进程会占用系统资源,而短时间运行的进程则需要等待很久才能获得CPU时间。
这样会导致整个计算机系统的效率下降。
SJF算法表现一般。
我们发现,在繁忙的系统中,SJF算法会基于当前进程的下一步行动来调度进程。
但是,如果多个进程具有相似的执行时间,并且它们需要同时运行,则存在一定的竞争和时间分配的缺陷。
总体来说,进程调度算法是计算机系统中非常重要的一部分,因为它会直接影响系统的效率和可靠性。
在我们的实验中,我们发现Round Robin算法是最好的选择,它能够抵消系统中不同进程需要不同时间的差异,确保每个进程都能获得相应的时间来完成任务。
进程调度实验报告
进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了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分配给队首进程,并令其执行一个时间片。
当执行的时间片用完时,由一个计数器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。
这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。
换言之,系统能在给定的时间内响应所有用户的请求。
实验进程调度的实验报告
一、实验目的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算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。
进程调度 实验报告
进程调度实验报告进程调度实验报告概述:进程调度是操作系统中一个重要的组成部分,它负责决定在多个进程同时运行时,每个进程分配到的CPU时间片以及切换进程的时机。
合理的进程调度算法能够提高系统的性能和资源利用率,因此对进程调度的研究和优化具有重要意义。
1. 背景介绍进程调度是操作系统中的一个关键任务,它负责管理和控制多个进程的执行顺序,以实现对CPU的合理分配。
在多道程序设计环境下,进程调度的作用尤为重要。
进程调度算法的好坏直接影响着系统的性能和响应速度。
2. 进程调度算法2.1 先来先服务(FCFS)先来先服务是最简单的调度算法之一,它按照进程到达的先后顺序进行调度,即先到达的进程先执行,直到该进程执行完成或者发生I/O操作。
FCFS算法的优点是公平且易于实现,但是它无法适应不同进程的执行时间差异,可能导致长作业效应。
2.2 最短作业优先(SJF)最短作业优先调度算法是根据进程的执行时间长度来进行调度,执行时间越短的进程越优先执行。
SJF算法能够最大程度地减少平均等待时间,但是它需要预先知道进程的执行时间,这在实际应用中往往是不可行的。
2.3 时间片轮转(RR)时间片轮转是一种经典的调度算法,它将CPU的执行时间划分为若干个时间片,每个进程在一个时间片内执行,如果时间片用完还没有执行完,则将该进程放入就绪队列的末尾,继续执行下一个进程。
RR算法能够保证每个进程都能获得公平的CPU时间,但是对于长时间执行的进程,会导致较大的上下文切换开销。
3. 实验设计与结果分析为了评估不同进程调度算法的性能,我们设计了一系列实验。
首先,我们使用不同的进程到达时间和执行时间生成一组测试数据。
然后,分别使用FCFS、SJF和RR算法进行调度,并记录每个进程的等待时间和周转时间。
最后,我们对实验结果进行分析。
实验结果显示,FCFS算法对于执行时间较长的进程会出现较长的平均等待时间,而SJF算法能够有效减少平均等待时间。
进程的调度实验报告(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("无效的调度算法选择。
进程调度算法 实验报告
进程调度算法实验报告
《进程调度算法实验报告》
一、实验目的
本实验旨在通过对进程调度算法的实验研究,探究不同调度算法对系统性能的影响,进一步加深对操作系统进程调度的理解。
二、实验内容
本次实验选择了三种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)和轮转调度(RR),并通过模拟不同进程的到达时间和执行时间,分别对这三种算法进行实验比较。
三、实验步骤
1. 设计实验用例:确定不同进程的到达时间和执行时间,以及不同调度算法的时间片大小。
2. 模拟执行:根据设计的实验用例,使用模拟工具模拟不同调度算法的执行过程,并记录每个进程的执行情况和系统的运行情况。
3. 数据分析:根据实验结果,对比不同调度算法的平均等待时间、平均周转时间等指标,分析各算法的优缺点。
四、实验结果
通过实验比较,得出以下结论:
1. 先来先服务(FCFS)算法:适用于执行时间较短的进程,但容易导致长作业等待时间过长。
2. 最短作业优先(SJF)算法:能够最大程度地减少平均等待时间和平均周转时间,但无法处理长作业优先的情况。
3. 轮转调度(RR)算法:能够保证每个进程都能及时得到执行,但可能导致部分进程的等待时间过长。
五、实验结论
根据实验结果,不同的进程调度算法适用于不同的场景。
在实际应用中,需要根据系统的实际情况和需求选择合适的调度算法,以最大程度地提高系统的性能和效率。
六、实验总结
通过本次实验,加深了对进程调度算法的理解,同时也了解了不同算法在实际应用中的优缺点。
希望通过本次实验,能够为进程调度算法的研究和应用提供一定的参考和借鉴。
进程的调度算法实验报告-计算机操作系统教程(第三版)
进程的调度算法实验报告-计算机操作系统教程(第三版)进程的调度算法实验报告(完整版)⼀、实验⽬的:⽤⾼级语⾔编写和调试⼀个简单的进程调度程序。
加深了解有关进程控制块,进程队列的概念,并体会和了解优先数和时间⽚调度算法的具体实施⽅法。
⼆、实验内容:根据不同的调度算法模拟操作系统对进程的调度。
调度算法有⼆种:动态优先级法和时间⽚循环法。
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;{void showlist(link,char*,int);//显⽰进程队列void 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<1)){// printf("请输⼊演⽰进程数\n");cout<<"请输⼊演⽰进程数:";// scanf("%d",&num);cin>>num;if (num>MAX) cout<<"输⼊的演⽰进程数太⼤!请输⼊⼩于等于5的数。
进程调度算法 实验报告
进程调度算法实验报告实验目的:本实验的主要目的是为了通过实践来理解进程调度算法,学习模拟进程调度算法的过程,增强对进程调度的理解。
实验内容:本实验分为两部分,第一部分是了解不同的进程调度算法,第二部分是使用模拟的方式来实现进程调度。
第一部分:本部分要求学生了解常用的几种进程调度算法,包括以下几种:1、先来先服务算法(FCFS)FCFS就是按照队列的先来先服务原则来选择执行的进程。
当一个进程退出CPU之后,下一个处在等待队列最前面的进程会被执行。
2、短作业优先算法(SJF)SJF是通过判断正在等待CPU的进程所需要的执行时间来进行排序,按照需要执行时间最短的进程先执行,以此提高CPU的利用率和系统的运行效率。
3、优先级调度算法优先级调度算法是指根据进程的优先级选择下一个要执行的进程。
通常情况下,每个进程都被赋予一个优先级,优先级高的进程得到CPU时间的概率也就更大。
在实现上,根据优先级来进行排序以选择下一个要执行的进程。
4、时间片轮转算法(RR)时间片轮转算法是指每个进程被分配一定时间片,一旦该时间片用完了,进程就被放弃执行,会被放到等待队列最后面,选择下一个要执行的进程。
该算法主要用于CPU分时系统中,可以在不同进程之间切换,实现多任务。
本部分要求学生使用模拟的方式来实现进程调度。
具体步骤如下:1、编写程序代码通过编写程序模拟进程调度算法,根据不同的算法来实现进程的调度。
在程序运行过程中,要能够动态展示当前进程的执行情况,包括当前进程执行的时间、当前队列中的进程等信息。
2、测试功能通过测试程序的功能来掌握进程调度算法的应用和实现过程。
要能够通过模拟的方式来测试不同算法下的CPU利用率、平均等待时间和响应时间等指标。
优化算法是指不断调整和改进算法,提高调度程序的效率和性能,进一步提高系统的可靠性和稳定性。
优化算法主要包括调整时间片大小、优化队列中进程的排序方式等措施。
实验结果:通过本次实验,我们了解了不同的进程调度算法,并掌握了通过模拟进行进程调度的方法。
进程调度实验报告答案(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,插入到就绪队列相关位置。
分析:动态优先级调度算法能够根据进程的运行情况动态调整优先级,使得优先级高的进程能够得到更多的运行时间,从而提高系统的响应速度。
实验报告二 进程调度算法
实验报告二——进程调度算法的设计姓名: xxxx 学号: xxxxx班级: xxxx一、实习内容•实现短进程优先调度算法(SPF)•实现时间片轮转调度算法(RR)二、实习目的•通过对进程调度算法的设计, 深入理解进程调度的原理。
进程是程序在一个数据集合上运行的过程, 它是系统进行资源分配和调度的一个独立单位。
进程调度分配处理机, 是控制协调进程对CPU的竞争, 即按一定的调度算法从就绪队列中选中一个进程, 把CPU的使用权交给被选中的进程。
三、实习题目• 1.先来先服务(FCFS)调度算法原理: 每次调度是从就绪队列中, 选择一个最先进入就绪队列的进程, 把处理器分配给该进程, 使之得到执行。
该进程一旦占有了处理器, 它就一直运行下去, 直到该进程完成或因发生事件而阻塞, 才退出处理器。
将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列, 并按照先来先服务的方式进行调度处理, 是一种最普遍和最简单的方法。
它优先考虑在系统中等待时间最长的作业, 而不管要求运行时间的长短。
按照就绪进程进入就绪队列的先后次序进行调度, 简单易实现, 利于长进程, CPU繁忙型作业, 不利于短进程, 排队时间相对过长。
• 2.时间片轮转调度算法RR原理: 时间片轮转法主要用于进程调度。
采用此算法的系统, 其程序就绪队列往往按进程到达的时间来排序。
进程调度按一定时间片(q)轮番运行各个进程.进程按到达时间在就绪队列中排队, 调度程序每次把CPU分配给就绪队列首进程使用一个时间片, 运行完一个时间片释放CPU, 排到就绪队列末尾参加下一轮调度, CPU分配给就绪队列的首进程。
固定时间片轮转法:1 所有就绪进程按FCFS 规则排队。
2 处理机总是分配给就绪队列的队首进程。
3 如果运行的进程用完时间片, 则系统就把该进程送回就绪队列的队尾, 重新排队。
4 因等待某事件而阻塞的进程送到阻塞队列。
5 系统把被唤醒的进程送到就绪队列的队尾。
进程调度算法实验报告
实验报告实验一:进程调度算法一、实验目的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(),这三个函数分别实现先来先服务算法,时间片轮转算法和优先级算法,最后分别打印。
进程调度算法实验报告(总13页)
进程调度算法实验报告(总13页)本次实验是关于进程调度算法的实验,通过实验我们可以更深入地了解进程调度算法对操作系统的影响,选择合适的算法可以提高操作系统的性能。
在本次实验中,我们实现了三种常见的进程调度算法,分别是先来先服务(FCFS)、优先级调度(Priority Scheduling)和时间片轮转(Round-Robin)。
实验环境本次实验在Ubuntu 20.04 LTS操作系统下进行。
实验原理先来先服务(FCFS)调度算法,也称为先进先出(FIFO)算法。
其原理是按照作业提交的先后顺序进行处理,在操作系统中,每个进程都有一个到达时间和一个运行时间,按照到达时间的先后顺序进行处理。
优先级调度(Priority Scheduling)调度算法是根据进程优先级的高低来确定进程的执行顺序。
每个进程都有一个优先级,并且系统的调度程序会选择优先级最高的进程进行执行。
如果有多个进程的优先级相同,则按照先来先服务的原则进行调度。
时间片轮转(Round-Robin)调度算法是为了解决短进程被长进程“挤掉”的问题而提出的一种算法。
它将等待队列中的进程按照先来先服务的原则排序,并且每个进程被分配一个相同的时间片,当时间片用完后,该进程就被放到等待队列的末尾,等待下次调度。
如果当前运行进程在时间片用完之前就执行完毕了,则当前进程会被直接退出,CPU会在就绪队列中选择下一个进程运行。
实验内容本次实验中,我们实现了一个简单的进程调度器,通过实现不同的调度算法来比较它们的性能差异。
需要实现的函数如下:1. void fcfs(vector<process> processes):实现先来先服务(FCFS)调度算法的函数。
实验流程1. 定义进程结构体为了方便处理进程,我们定义了一个process结构体,包含进程的ID、到达时间、运行时间、优先级等信息。
定义如下:struct process {int id; // 进程IDint arrival_time; // 到达时间int burst_time; // 运行时间int priority; // 优先级}2. 实现进程生成函数为了测试不同调度算法的性能,我们需要生成一些具有不同特征的进程。
进程调度实验报告
进程调度实验报告引言:进程调度是操作系统中一个重要的概念,它决定了一个进程何时开始执行、何时暂停、何时唤醒等等。
一个良好的进程调度算法可以提高系统的效率和响应时间。
在这次实验中,我们将对不同的进程调度算法进行测试和对比分析,旨在探究不同算法对系统性能的影响。
实验步骤:1. 实验准备在实验开始前,我们需要准备一个充分复杂的测试环境,包括不同类型的进程、不同进程的优先级、进程执行时间等参数。
这些参数的设置将影响我们对不同调度算法的评估。
2. 先来先服务调度算法(FCFS)先来先服务调度算法是最简单的一种调度算法,按照进程到达CPU的顺序依次执行。
在这个实验中,我们首先对先来先服务调度算法进行测试。
结果显示,对于短时进程,FCFS算法效果较好,但在遇到长时进程时,会出现“饥饿”现象,易导致优先级较低的进程无法获得CPU时间。
3. 短作业优先调度算法(SJF)短作业优先调度算法根据进程执行时间的长短来进行调度。
在实验中,我们通过设置不同长度的进程来对SJF算法进行测试。
结果显示,SJF算法能够较好地避免“饥饿”现象,但如果长作业在一个时间片内到达,就会导致短作业等待时间过长。
4. 优先级调度算法(Priority)优先级调度算法通过为每个进程指定一个优先级来进行调度,优先级高的进程先执行。
在实验中,我们设置不同优先级的进程,测试Priority算法的效果。
结果显示,Priority算法能够合理地根据优先级分配CPU时间,但如果优先级的划分不合理,可能导致某些进程优先级一直很低,影响整体系统性能。
5. 时间片轮转调度算法(Round Robin)时间片轮转调度算法是一种较为公平的调度算法,每个进程被分配一个时间片,在时间片用完后,进程暂停执行,并被放置于“就绪队列”尾部,等待下一个时间片。
在测试中,我们可以通过设置不同的时间片长度来观察时间片轮转算法的效果。
结果显示,时间片轮转算法能够较好地平衡进程的等待时间和执行时间。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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);篇三:操作系统原理---进程调度实验报告一、实验目的通过对进程调度算法的设计,深入理解进程调度的原理。