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

合集下载

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

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

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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来代表。

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

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

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

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

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

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

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

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

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

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

在这里省去了这些工作。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

处理机调度实验报告

处理机调度实验报告

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

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

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

三、实验方法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算法能够保证公平性;而优先级调度算法则适用于一些需要特定优先级处理的场景。

操作系统 实验一 CPU调度

操作系统 实验一 CPU调度

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

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

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

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

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

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

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

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

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

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

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

实验一处理器调度实验报告精编版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,则把它的状态修改为“结束”(),且退出队列。

处理器调度算法实验报告

处理器调度算法实验报告

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

二、实验环境本次实验使用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调度算法:平均等待时间较长,平均周转时间也较长。

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

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

实验课程名称:
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;//计算平均带权周转时间
}
}
二、实验结果及分析(包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等)测试用例一结果:
测试用例二结果:
三、实验心得
通过本次实验进一步理解了处理机调度问题的处理算法,学习到算法适用的前提是作业提交成功。

在实验编程过程中由于对一些概念理解不清楚导致实验结果出错,但通过调整修改得出正确结果如上。

在实验过程中代码相对简介,输出界面直观整齐易于分析,但仍有缺陷待改进。

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

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

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

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

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

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

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

[提示]:(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.先来先服务调度算法(FCFS) 1.1算法思想 该算法采⽤⾮剥夺策略,算法按照进程提交或进程变为就绪状态的先后次序,分派 CPU。

当前进程占⽤CPU,直到执⾏完或阻塞,才出让CPU(⾮抢占⽅式)。

在进程唤醒后(如I/O 完成),并不⽴即恢复执⾏,通常等到当前进程出让CPU。

这是最简单的调度算法,⽐较有利于长进程,⽽不利于短进程,有利于CPU 繁忙的进程,⽽不利于I/O 繁忙的进程。

1.2算法设计 1.3算法实现代码class Process:def__init__ (self,name,arrive_time,serve_time):=nameself.arrive_time=arrive_time #进⼊进程顺序self.serve_time=serve_time #服务时间self.finish_time=0 #完成时间self.cycling_time=0 #周转时间self.w_cycling_time=0 #带权周转时间process_list=[]running_time=0A = Process('A',5,4)B = Process('B',4,3)C = Process('C',3,4)D = Process('D',1,2)E = Process('E',2,4)process_list.append(A)process_list.append(B)process_list.append(C)process_list.append(D)process_list.append(E)i=int (0)p=process_list[i]y=len(process_list)print("进程进⾏排序")for j in range(len(process_list)-1):for k in range(len(process_list)-1):if process_list[k].arrive_time>process_list[k+1].arrive_time:text=process_list[k+1]process_list[k+1]=process_list[k]process_list[k]=textprint("进程号到达顺序服务时间")for p in process_list:print(, "\t" ,p.arrive_time,"\t" ,p.serve_time)for p in process_list:running_time +=p.serve_timep.finish_time=running_timep.cycling_time=p.finish_time-p.arrive_timep.w_cycling_time=p.cycling_time/p.serve_timeprint("进程号到达时间完成时间周转时间带权周转时间")for p in process_list:print( ,"\t\t",p.arrive_time,"\t\t\t\t",p.finish_time,"\t\t",p.cycling_time,"\t",p.w_cycling_time) 1.4运⾏结果 2.短作业优先算法(SJF) 2.1算法思想 该算法也采⽤⾮剥夺策略,对预计执⾏时间短的进程优先分派处理机。

实验一——单处理器系统的进程调度

实验一——单处理器系统的进程调度

实验一——单处理器系统的进程调度实验一:进程的建立及调度1.实验目的:加深对进程概念的理解,熟悉PCB的组织,深入了解创建进程的一般过程,掌握用队列组织进程的方法,掌握进程调度算法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实习一处理器调度

实习一处理器调度

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

二.实习目的本实习模拟在单处理器环境下的处理器调度,加深了解处理器调度的工作。

三.实习题目设计一个按优先数调度算法实现处理器调度的程序。

四. 设计思想1.设计思路(1)假定系统有5个进程,每个进程用一个PCB来代表。

(2) 开始运行之前,为每个进程确定它的“优先数”和“要求运行时间”。

通过键盘输入这些参数。

(3) 按进程优先数排列进程,优先数最大的进程插入队首,否者比较进程优先数,插入适当位置。

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

采用动态改变优先数的办法,进程每运行1次,优先数减1,要求运行时间减1。

(5) 进程运行一次后,若要求运行时间不等于0,则将它加入就绪队列,否则,将状态改为“结束”,退出就绪队列。

(6) 若就绪队列为空,结束,否则转到(4)重复。

2.主要数据结构struct pcb { /* 定义进程控制块PCB */char name[10]; /*进程名*/char state; /*状态*/int super; /*优先数*/int ntime; /*要求运行时间*/int rtime; /*周转时间*/struct pcb* link; /*下一个进程pcb首地址*/}3.主要代码结构及代码段分析void input() /* 建立进程控制块函数*/{ int i,num;system("cls"); /*清屏*/for(i=1;i<=5;i++){ printf("\n projectNo.%d:\n",i);p=getpch(PCB);printf("\n please input project name:");scanf("%s",p->name);printf("\n please input project priority:");scanf("%d",&p->super);printf("\n please input project running time:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='W';p->link=NULL;sort(); /* 调用sort函数*/}}void 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;}}int space()/*求队列长度*/{int l=0;PCB* pr=ready;while(pr!=NULL){ l++;pr=pr->link;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n proname\t state\t\t priority\t needtime\t remaintime\n"); printf("| %s\t\t",pr->name);printf("| %c\t\t",pr->state);printf("| %d\t\t",pr->super);printf("| %d\t\t",pr->ntime);printf("| %d\t\t",pr->rtime);printf("\n");}void check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** the running project is:\n"); /*显示当前运行进程*/disp(p);pr=ready;printf("\n **** the ready project state is:\n"); /*显示就绪队列状态*/ while(pr!=NULL){disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{ printf("\n project[%s] has finished.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/{ (p->rtime)++;if(p->rtime==p->ntime){ p->state='E';printf("\n **** the finished project is:\n");disp(p);destroy();} /* 调用destroy函数*/else{(p->super)--;p->state='W';sort(); /*调用sort函数*/}}void main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("-----------------------------------------------------"); printf("\n now is %d rounds. \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n press any key to continue......\n");}printf("\n\n all projects have finished.\n");getch();/*从键盘获得字符*/}五.上机实习所用平台及相关软件本程序在windows xp平台下,TC2.0编译器编译通过。

操作系统实验 单处理器系统的进程调度

操作系统实验  单处理器系统的进程调度

操作系统实验单处理器系统的进程调度一、实验目的1、加深进程概念理解,明确进程与程序区别。

2、理解操作系统中进程的组织、创建和调度等方法。

二、实验内容编写程序完成单处理器系统的进程调度,要求采用时间片轮转法调度策略。

具体内容:1、确定PCB内容及其组织方式;2、要求模拟进程空闲(新)、就绪、运行、阻塞和完成5个状态;3、实现进程创建、进程调度、进程阻塞和进程唤醒4个功能(原语);4、编写主函数对整个系统进程测试。

三、提示关键三点:(1)如何组织进程:●确定PCB内容:标识信息、状态和运行时间与存储地址等信息、现场信息、管理信息●PCB组织方式:相同状态的进程PCB构成一个队列(即有空闲、就绪、运行、阻塞和完成5个队列)(2)如何创建进程:●申请PCB(从空闲队列)—> 申请资源—> 填写PCB—>挂就绪队列(3)如何实现处理机调度及进程状态切换:●采用先来先服务(FCFS)调度策略实现进程调度;●从就绪队列选择一个进程;摘取PCB,挂运行队列;修改状态等PCB内容;保存现场、恢复现场;●模拟运行--可以按照两种场景模拟进程运行:(1)可以预先设置好各进程的运行时间、I/O时间、I/O发生的时刻等信息(可以放在一个文件中,创建进程时置入PCB),之后操作系统控制进程运行,实现状态切换,直到全部进程完成。

(2)亦可以采用人工干预方式控制进程状态切换(运行时间已预先设置),比如输入“Esc”进入“阻塞”状态,输入“Enter”则选择(新)进程运行(进程调度),当前进程回到就绪状态;输入“wakeup”,再选择阻塞进程,则被选中的阻塞进程回到就绪状态;输入“finished”,当前进程运行结束,回到完成状态;●修改(剩余)运行时间。

四、测试输出●从文件输入创建进程所需信息,创建进程的数目可控(手工输入);●进行进程调度。

被调度上的进程(正在运行)输出:(1)退出CPU的进程名及其PCB内容。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

在这里省去了这些工作。

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

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

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

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

四、程序中使用的数据结构及符号说明:
#define num
5
程序清单
D,&pcblist[i].pri,&pcblist[i].runtime);
pcblist[i].state='R';tate=='r')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();//进程调度模拟
}
七、实验总结
本次实验通过课本处理器调度的进程的初步认识和实验按优先数调度算法实现处理器调度的实现,了解到进程与进程控制块之间的联系,进程运行过程中状态以及已运行时间的判断和计算,选中运行的进程名以及选中进程运行后的各进程控制块状态。

相关文档
最新文档