操作系统实验报告:设计一若干并发进程的进程调度程序

合集下载

计算机操作系统进程调度实验报告

计算机操作系统进程调度实验报告

计算机操作系统进程调度实验报告实验报告:计算机操作系统进程调度1.实验背景与目的计算机操作系统是一种负责管理和协调计算机硬件和软件资源的系统。

进程调度作为操作系统的重要功能之一,主要负责决定哪些进程可以运行、何时运行以及运行多长时间等问题。

本实验旨在通过实践学习进程调度的原理和实现细节,加深对操作系统的理解。

2.实验原理与步骤(1)实验原理:进程调度的目标是充分利用计算机资源,提高系统的吞吐率和响应时间。

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

在本实验中,我们将实现时间片轮转调度算法,并对比不同算法的性能差异。

(2)实验步骤:1)设计进程数据结构:创建进程控制块(PCB)结构体,包含进程的标识符、到达时间、服务时间、剩余时间、等待时间等信息。

2)生成进程:根据指定的进程个数和服务时间范围,生成随机的进程并初始化进程控制块。

3)时间片轮转调度算法:根据时间片大小,按照轮转调度的方式进行进程调度。

4)性能评估:通过记录进程的等待时间和周转时间,比较不同调度算法的性能差异。

3.实验结果与分析通过实验我们生成了10个进程,并使用时间片大小为2进行轮转调度。

下表列出了各个进程的信息及调度结果。

进程到达时间服务时间剩余时间等待时间周转时间P108068P214004P3291310P4350115P542032P6570147P763063P8761714P981071P1093104从实验结果可以看出,时间片轮转调度算法相对公平地分配了CPU给各个进程,减少了等待时间和周转时间。

但是,对于长时间服务的进程,可能出现饥饿问题,即一些耗时较长的进程无法得到充分的CPU时间。

与时间片轮转算法相比,先来先服务(FCFS)算法对于短作业具有更好的响应时间,但可能导致长作业等待时间过长。

最短作业优先(SJF)算法能够最大化短作业的优先级,提高整体性能。

4.实验总结与体会本次实验通过实践了解了进程调度的原理与实现细节,加深了对操作系统的理解。

操作系统实验报告进程调度

操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。

其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。

实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。

实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。

在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。

实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。

在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。

2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。

在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。

3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。

在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。

实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。

在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。

因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。

结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。

同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。

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

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

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。

操作系统实验报告进程调度

操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言操作系统是计算机系统中最核心的软件之一,它负责管理和调度计算机的资源,提供良好的用户体验。

在操作系统中,进程调度是其中一个重要的功能,它决定了进程的执行顺序和时间片分配,对于提高计算机系统的效率和响应能力至关重要。

本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。

一、进程调度的概念进程调度是操作系统中的一个重要组成部分,它负责决定哪个进程可以使用CPU,并为其分配执行时间。

进程调度的目标是提高系统的吞吐量、响应时间和公平性。

在多道程序设计环境下,进程调度需要考虑多个进程之间的竞争和协作,以实现资源的合理利用。

二、进程调度算法1. 先来先服务调度(FCFS)先来先服务调度算法是最简单的进程调度算法之一,它按照进程到达的顺序进行调度,即先到达的进程先执行。

这种算法的优点是公平性高,缺点是无法适应长作业和短作业混合的情况,容易产生"饥饿"现象。

2. 最短作业优先调度(SJF)最短作业优先调度算法是根据进程的执行时间来进行调度的,即执行时间最短的进程先执行。

这种算法的优点是能够最大程度地减少平均等待时间,缺点是无法适应实时系统和长作业的情况。

3. 时间片轮转调度(RR)时间片轮转调度算法是一种抢占式调度算法,它将CPU的执行时间划分为固定大小的时间片,并按照轮转的方式分配给各个进程。

当一个进程的时间片用完后,它将被挂起,等待下一次调度。

这种算法的优点是能够保证每个进程都能够获得一定的执行时间,缺点是无法适应长作业和短作业混合的情况。

4. 优先级调度(Priority Scheduling)优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程先执行。

这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度,缺点是可能会导致低优先级的进程长时间等待。

三、实验结果与分析在实验中,我们使用了不同的进程调度算法,并对其进行了性能测试。

进程调度操作系统实验报告

进程调度操作系统实验报告

进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理,通过实际编程和模拟,观察不同调度算法对系统性能的影响,并掌握进程调度的实现方法。

二、实验环境操作系统:Windows 10编程语言:C++开发工具:Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一,它负责决定哪个进程在何时获得 CPU 资源进行执行。

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

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

这种算法简单直观,但可能导致短作业等待时间过长。

短作业优先算法优先调度执行时间短的进程,能有效减少平均等待时间,但可能导致长作业饥饿。

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

如果进程在时间片内未完成,则被放回就绪队列等待下一轮调度。

优先级调度根据进程的优先级来决定调度顺序,优先级高的进程先获得 CPU 资源。

四、实验步骤1、设计进程结构体定义进程的标识号(PID)、到达时间、服务时间、剩余时间、优先级等属性。

2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。

从就绪队列中取出第一个进程进行调度执行,直到其完成。

3、实现短作业优先算法计算每个进程的剩余服务时间。

将进程按照剩余服务时间从小到大排序,放入就绪队列。

从就绪队列中取出剩余服务时间最短的进程进行调度执行。

4、实现时间片轮转算法设定时间片大小。

将进程放入就绪队列,按照先来先服务的原则依次分配时间片执行。

进程在时间片内未完成的,放回就绪队列末尾。

5、实现优先级调度算法为每个进程设置优先级。

将进程按照优先级从高到低排序,放入就绪队列。

从就绪队列中取出优先级最高的进程进行调度执行。

6、计算平均周转时间和平均带权周转时间周转时间=完成时间到达时间带权周转时间=周转时间/服务时间平均周转时间=总周转时间/进程数平均带权周转时间=总带权周转时间/进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。

实验进程调度的实验报告

实验进程调度的实验报告

一、实验目的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. 实现进程调度模拟程序,包括进程的创建、调度、挂起、恢复和销毁等基本操作。

2. 实现三种常用的调度算法:先来先服务(FCFS)、最短作业优先(SJF)和时间片轮转(RR)。

3. 对比不同调度算法的性能,包括平均等待时间、平均周转时间和平均响应时间等指标。

实验步骤:1. 首先定义进程类Process,包括进程的ID、到达时间、执行时间和优先级等属性。

2. 实现创建进程的函数create_process,通过用户输入的方式创建多个进程,并保存到一个进程队列中。

3. 根据选择的调度算法,实现调度函数schedule,按照对应的算法对进程进行调度,并记录每个进程的执行时间和等待时间等信息。

4. 对于FCFS算法,按照进程的到达时间进行排序,然后按顺序执行。

5. 对于SJF算法,按照进程的执行时间进行排序,然后按顺序执行。

6. 对于RR算法,设定一个时间片大小,每个进程执行一个时间片后,将其放回队列末尾,然后继续执行下一个进程,直到所有进程都执行完毕。

7. 在各个调度算法中计算平均等待时间、平均周转时间和平均响应时间等指标,并输出结果。

实验结果:通过对不同进程和不同调度算法的模拟,可以得到如下结果:1. FCFS调度算法的平均等待时间较长,不适用于执行时间较长的任务。

2. SJF调度算法的平均等待时间和平均周转时间较短,适用于执行时间较短的任务。

3. RR调度算法能够平均分配CPU时间,适用于执行时间较长的任务。

实验总结:通过本次实验,我们进一步加深了对操作系统进程调度的理解和认识。

通过编写模拟程序,我们能够清楚地了解不同调度算法的工作原理和对应的性能表现。

在实际应用中,根据任务的特点和需求选择合适的调度算法,能够提高系统的性能和效率。

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

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

第1篇一、实验目的通过本次实验,加深对操作系统进程调度原理的理解,掌握先来先服务(FCFS)、时间片轮转(RR)和动态优先级(DP)三种常见调度算法的实现,并能够分析这些算法的优缺点,提高程序设计能力。

二、实验环境- 编程语言:C语言- 操作系统:Linux- 编译器:GCC三、实验内容本实验主要实现以下内容:1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、优先级、状态等信息。

2. 实现三种调度算法:FCFS、RR和DP。

3. 创建一个进程队列,用于存储所有进程。

4. 实现调度函数,根据所选算法选择下一个执行的进程。

5. 模拟进程执行过程,打印进程执行状态和就绪队列。

四、实验步骤1. 定义PCB结构体:```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待,1: 运行,2: 完成} PCB;```2. 创建进程队列:```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法:(1)FCFS调度算法:```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(2)RR调度算法:```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(3)DP调度算法:```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程:```cvoid simulateProcess() {printf("请选择调度算法(1:FCFS,2:RR,3:DP):");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。

操作系统进程调度实验报告

操作系统进程调度实验报告

操作系统进程调度实验报告操作系统进程调度实验报告引言:操作系统是计算机系统中的核心软件之一,负责管理计算机的硬件资源并提供用户与计算机硬件之间的接口。

进程调度作为操作系统的重要功能之一,负责决定哪个进程可以获得处理器的使用权,以及进程如何在处理器上运行。

本实验旨在通过设计和实现一个简单的进程调度算法,加深对操作系统进程调度原理的理解。

一、实验目的本实验的主要目的是通过编写代码模拟操作系统的进程调度过程,掌握进程调度算法的实现方法,深入理解不同调度算法的特点和适用场景。

二、实验环境本实验使用C语言进行编程实现,可在Linux或Windows系统下进行。

三、实验内容1. 进程调度算法的选择在本实验中,我们选择了最简单的先来先服务(FCFS)调度算法作为实现对象。

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

这种调度算法的优点是简单易实现,但缺点是无法适应不同进程的执行时间差异,可能导致长作业效应。

2. 进程调度的数据结构在实现进程调度算法时,我们需要定义进程的数据结构。

一个进程通常包含进程ID、到达时间、执行时间等信息。

我们可以使用结构体来表示一个进程,例如:```struct Process {int pid; // 进程IDint arrival_time; // 到达时间int burst_time; // 执行时间};```3. 进程调度算法的实现在FCFS调度算法中,我们需要按照进程到达的先后顺序进行调度。

具体实现时,可以使用一个队列来保存待调度的进程,并按照到达时间的先后顺序将进程入队。

然后,按照队列中的顺序依次执行进程,直到所有进程执行完毕。

4. 实验结果分析通过实现FCFS调度算法,我们可以观察到进程调度的过程和结果。

可以通过输出每个进程的执行顺序、等待时间和周转时间等指标来分析调度算法的效果。

通过比较不同调度算法的指标,可以得出不同算法的优缺点。

四、实验步骤1. 定义进程的数据结构,包括进程ID、到达时间和执行时间等信息。

设计一个若干并发进程的进程调度程序

设计一个若干并发进程的进程调度程序

操作系统实验报告指导:琚耀操作系统实验题1:设计一个若干并发进程的进程调度程序一、实验目的二、实验要求用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.三、实验内容进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。

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

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

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

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

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

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

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

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

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

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查重复以上过程,直到所要进程都完成为止。

四、实验算法流程:调度算法的流程图如下 :2011 信管专业C:\iknow\docshare\data\cur_work\199703291.doc 日期:2013 -11-25五、实验程序清单:(参考某资料)#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];char state; 状态int super; 优先级int ntime; 运行时间int rtime; 已运行时间struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;char 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;}}char input() /* 建立进程控制块函数*/{ int i,num;//clrscr(); /*清屏*/printf("\n 请输入被调度的进程数目:");scanf("%d",&num);for(i=0;i<num;i++){ printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/ } }int space(){ int l=0; PCB* pr=ready;while(pr!=NULL){ l++;pr=pr->link; }return(l); }char disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{ printf("\n qname \t state \t super \t ndtime \t runtime \n"); printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}char check() /* 建立进程查看函数 */{ PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){ disp(pr);pr=pr->link;}}char destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{ printf("\n 进程 [%s] 已完成.\n",p->name);free(p);}char running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ { (p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/ }}main() /*主函数*/{ int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ ch=getchar();h++;printf("\n The execute number:%d \n",h); p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}六、运行结果分析结果分析:根据上述输入的三个进程的信息可以得到:优先级最高的是进程mhy,所以最先调度进程mhy,它的状态为运行态,需要执行的时间为2。

操作系统C-进程调度算法实验报告

操作系统C-进程调度算法实验报告

操作系统C-进程调度算法实验报告1. 实验背景操作系统涉及到的进程调度算法是操作系统中的核心知识之一,这也是操作系统中较为重要的内容之一。

进程调度算法可以直接影响到操作系统的性能和系统的响应时间,因此这一方面是操作系统学习中不可避免的。

为了更好的理解和掌握进程调度算法,本次实验选用了比较经典的进程调度算法——SJF算法和RR算法,并对其进行详细的实验和分析。

2. 实验环境•操作系统:Windows 10•编译器:Dev-C++3. 实验内容本次实验分为两部分,第一部分为SJF算法的实验,第二部分为RR算法的实验。

3.1 实验一:SJF算法本实验中,我们首先编写了一个随机生成进程的程序,并为每个进程随机分配一个运行时间。

然后,我们用SJF算法对这些进程进行调度,记录下调度过程和每个进程的运行情况,最后统计出SJF算法的平均等待时间、平均周转时间和吞吐量。

3.1.1 实验步骤以下是我们在SJF算法实验中采取的步骤和操作:•首先编写程序生成随机进程•对每个进程分配随机运行时间•对进程按照时间长度进行排序•模拟SJF算法进行调度•计算平均等待时间、平均周转时间和吞吐量3.1.2 实验结果经过实验,得到以下结果:•平均等待时间:13.97•平均周转时间:18.53•吞吐量:4.763.2 实验二:RR算法本实验中,我们使用Round Robin调度算法,对进程进行调度,并记录下调度过程和每个进程的运行情况,最后统计出RR算法的平均等待时间、平均周转时间和吞吐量。

3.2.1 实验步骤以下是我们在RR算法实验中采取的步骤和操作:•首先编写程序生成随机进程•对每个进程分配随机运行时间•设定时间片大小•模拟RR算法进行调度•计算平均等待时间、平均周转时间和吞吐量3.2.2 实验结果经过实验,得到以下结果:•平均等待时间:25.63•平均周转时间:30.18•吞吐量:1.094. 实验分析4.1 SJF算法分析从SJF算法的实验结果可以看出,该算法能够在大多数情况下有效地减少进程的平均等待时间和平均周转时间,但是也存在一些问题,比如会导致优先级反转等情况,需要进一步考虑如何避免这些问题。

操作系统:实验3进程并发与调度(实验报告)

操作系统:实验3进程并发与调度(实验报告)

操作系统:实验3进程并发与调度(实验报告)班级:姓名:学号:3.1 Windows 同步在本节实验中,通过对事件和互斥体的了解,来加深对Windows 同步的理解。

1) 回顾系统进程、线程的有关概念,加深对Windows 进程、线程的理解。

2) 了解事件和互斥体。

3) 通过分析实验程序,了解管理事件的API 。

4) 了解在进程中如何使用事件。

5) 了解在进程中如何使用互斥体。

6) 了解父进程创建子进程的程序设计方法。

1. 工具/准备工作在开始本节实验之前,请回顾教科书的相关内容。

需要准备一台运行Windows 系统的计算机,且安装了C/C++编译器。

2. 实验内容与步骤(1) 事件对象步骤1:找到“labReportCode ”文件夹并打开源程序3-1.cpp 。

步骤2:对3-1.cpp 进行编译、链接,生成可执行文件3-1.exe 。

操作能否正常进行?__________________________________________________步骤3:运行3-1.exe 。

请记录:运行结果(分行书写):1)__________________________________________________________________2)__________________________________________________________________3)__________________________________________________________________4)__________________________________________________________________5)__________________________________________________________________6)__________________________________________________________________7)__________________________________________________________________ 分析程序3-1,请回答:实验3 进程并发与调度1) 程序中,创建一个事件使用了哪个函数?创建时设置的初始信号状态是什么?a.__________________________________________________________________b.__________________________________________________________________2) 创建一个进程(子进程)使用了哪个函数?________________________________________________________________ ____3) 根据运行结果,可以看出程序运行的流程吗?请简单描述:________________________________________________________________ ____________________________________________________________________ ________________________________________________________________________ ________(2) 互斥体步骤1:找到“labReportCode”文件夹并打开源程序3-2.cpp。

操作系统实验进程调度报告

操作系统实验进程调度报告

实验一进程调度小组成员:侯飞080806110024王卫党080806110018陈德080806110021杨民岱080806110026一、实习内容1、模拟多批道处理多操作系统的进程调度;2、模拟实现同步机构避免并发进程执行时可能与时间相关的错误。

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

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

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

模拟系统,对进程调度、进程运行状态及PV操作原理加深理解和掌握。

三、实习题目采用剥夺式优先算法,对3个进程进行模拟调度。

模拟PV操作同步机构,用PV操作解决进程进入临界区的问题。

【设计思想】(1)对三个进程进行模拟调度时,对各进程的静态数进行设置,设进程P1、P2、P3的优先级数分别为1,、2、3,优先级数越大,表示优先级越低。

每个进程都处于执行态“e”、就绪态“r”和等待态“w”三种状态之一,并假定初始状态为“r”。

(2)每一个进程都用一个PCB表来表示,PCB表的具体内容根据具体情况来定。

本进程调度模拟中,为每个PCB表定义四项内容:进程块号id、进程所处状态status、优先级数priority以及等待原因waiter1。

系统在运行时,能够显示和打印各进程和系统参数的变化情况,以便于观察各进程的调度。

(3)完成必要的初始化操作后便进入进程调度程序,首先由进程P1进入执行,当进程因等待某个事件被阻塞或唤醒某个等待进程时,转进程调度模块。

(4)进程进入临界区前后,调用PV操作。

(5)如果唤醒的进程的优先级高于正在执行进程的优先级,则剥夺现行进程的执行权。

(6)当三进程都处于等待状态时,则退出本模拟系统。

四、进程模块示例1.数据结构struct{int id;int waiter1;int priority;char status;}pcb[5];2.信号量struct{int value; //互斥信号量,临界区数,初值为1int waiter2; //同步信号量,初值为0}sem[3];3.现场保护栈char stack[11][5];//每个进程都有一个大小为10个字的现场保护栈,用来保护中断时的断点地址等信息。

操作系统综合性实验报告~进程调度(含代码)

操作系统综合性实验报告~进程调度(含代码)

XXXXXX计算机系综合性实验实验报告课程名称操作系统B实验学期XXXX 至XXXX 学年第X 学期学生所在系部计算机系年级XXXX 专业班级XXXXXX学生姓名XXXX 学号XXXXXXXXXXXX任课教师XXX实验成绩计算机系制《操作系统B 》课程综合性实验报告开课实验室:年月日附代码:#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[10]; //进程的名字int round; //一次分配CPU的时间片int cputime; //CPU已执行时间int needtime; //进程执行所需要的时间char state; //进程的状态,W-就绪态,R-执行态,F-完成态int count; //记录进程执行的次数struct node *next; //队列指针}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; //定义三个队列,就绪队列,执行队列和完成队列int num;void GetFirst(); //从就绪队列取得第一个节点void Output(); //输出各队列信息void InsertTime(PCB *in); //插入就绪片队列void InsertFinish(PCB *in); //插入完成队列void TimeCreate(); //时间片输入函数void RoundRun(); //时间片轮转调度void main(){printf("\n****** 欢迎光临指导******\n");printf("\n****** 时间片轮转进程调度算法******\n");printf("\n****** 计科B082 韩友******\n");printf("\n****** 200807014225 ******\n");printf("\n****** 2011年5月15日******\n");printf("\n请输入要创建的进程数目:\n");scanf("%d",&num);getchar(); //吸收回车符号TimeCreate();RoundRun();Output();}void GetFirst() //取得第一个就绪队列节点{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() //输出队列信息{PCB *p;p = ready;printf("进程轮数cpu时间需要时间进程状态计数器\n");while(p!=NULL){printf("%s\t%d\t%d\t%d\t%c\t%d\n",p->name,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%c\t%d\n",p->name,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%c\t%d\n",p->name,p->round,p->cputime,p->needtime,p->state,p->count);p = p->next;}}void InsertTime(PCB *in) //将进程插入到就绪队列尾部{PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) //将进程插入到完成队列尾部{PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL)fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void TimeCreate() //时间片轮转输入函数{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间:\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->round = 2; //假设每个进程所分配的时间片是2tmp ->count = 0;InsertTime(tmp);}}void RoundRun() //时间片轮转调度算法{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) //进程执行完毕{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)//时间片用完{run->state = 'W';run->count = 0; //计数器清零,为下次做准备InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}。

计算机操作系统进程调度实验报告

计算机操作系统进程调度实验报告

操作系统实验题:设计一若干并发进程的进程调度程序一、实验目的无论是批处理系统、分时系统还是实时系统,用户进程数一般都大于处理机数,这将导致用户进程互相争夺处理机。

这就要求进程调度程序按一定的策略,动态地把处理及分配给处于就绪队列中的某一进程,以使之执行。

进程调度是处理机管理的核心内容。

本实验要求采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念。

并体会了优先数和先来先服务调度算法的具体实施办法。

二、实验要求用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.三、实验内容进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法(将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理)。

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

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

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

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

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

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

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

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

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

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

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

进程调度实验报告

进程调度实验报告

操作系统实验 报告实验项目: 进程调度学 院: 计算机学院专 业:班 级:学 号:姓 名:1. 实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。

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

本实验模拟在单处理机情况下的进程调度,加深了解进程调度的工作。

2. 实验内容设计一个按时间片轮转法实现进程调度的程序。

(1)假定系统有五个进程,每一个进程用一个进程控制块PCB 来代表,进程控制块的格式为:其中,进程名——作为进程的标识,假设五个进程的进程名分别为Q 1,Q 2,Q 3,Q 4,Q 5。

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

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

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

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

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

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

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

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

例如,当前轮到Q 2执行,则有:进程名 指针 要求运行时间 已运行时间 状态标志单元(4)进程调度总是选择标志单元指示的进程运行。

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

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

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

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

进程调度实验报告范文

进程调度实验报告范文

进程调度实验报告范文i快鬲紳狡犬爹整芦SHAAN某IUNIVERSITYOFSCIENCE&TECHNOLOG¥操作系统实验报告实验1进程调度算法报告日期:2022-6-10姓名:学号:班级:任课教师:实验1进程调度算法一、实验内容按优先数调度算法实现处理器调度。

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

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

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

三、实验原理设计一个按优先数调度算法实现处理器调度的程序。

假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:进程名指针要求运行时间优先数状态其中,进程名一一作为进程的标识,假设五个进程的进程名分别为Pi,P2,P3,P4,P5。

指针一一按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”要求运行时间一一假设进程需要运行的单位时间数。

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

状态——可假设有两种状态,“就绪”状态和“结束”状态。

五个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。

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

为了调度方便,把五个进程按给定的优先数从大到小连成队列。

用一单元指出队首进程,用指针指出队列的连接情况。

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

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

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

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

操作系统实验报告操作系统实验题:设计一若干并发进程的进程调度程序一、实验目的无论是批处理系统、分时系统还是实时系统,用户进程数一般都大于处理机数,这将导致用户进程互相争夺处理机。

这就要求进程调度程序按一定的策略,动态地把处理及分配给处于就绪队列中的某一进程,以使之执行。

进程调度是处理机管理的核心内容。

本实验要求采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念。

并体会了优先数和先来先服务调度算法的具体实施办法。

二、实验要求用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.三、实验内容进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法(将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理)。

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

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

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

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

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

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

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

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

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

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

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

四、实验算法流程调度算法的流程图如下:五、实验程序清单#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;char 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;}}char input() /* 建立进程控制块函数*/{int i,num;//clrscr(); /*清屏*/printf("\n 请输入被调度的进程数目:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程号No.%d:\n",i);p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}char disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n qname \t state \t super \t ndtime \t runtime \n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}char check() /* 建立进程查看函数*/{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}char destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/printf("\n 进程[%s] 已完成.\n",p->name);free(p);}char running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}六、运行结果分析结果分析:根据上述输入的三个进程的信息可以得到:优先级最高的是进程ping,所以最先调度进程ping,它的状态为运行态,需要执行的时间为5。

而当前就绪队列状态为:进程xu的优先级比较高,处于就绪队列前面,而进程gui的优先级是三者中最低的,所以处于就绪队列的最后。

而此时这两个进程的状态都为就绪态。

结果分析:当进程ping执行了一个时间片之后而它已占用CPU时间已达到所需要的运行时间,则将它的优先级减1之后,再将三个进程按优先级的大小排列,从中选择优先级大的进程进入运行状态,则该次进入运行态的是进程xu。

按照这种方式一直运行下去,直到:结果分析:当进程ping的CPU占用时间等于它需要的执行时间时,进程ping调度完成。

则这时进程调度中还有两个进程:进程gui和进程xu。

结果分析:当调度进程中只剩下进程gui和进程xu时,这时根据进程优先级的大小,进程gui将进入运行态。

结果分析:当进程xu完成调度时,进程调度程序中直剩下进程gui了,这时进程gui将进入运行态,而当前就绪队列将为空。

结果分析:当进程gui的CPU占用时间等于所需要的执行时间时,进程gui调度完成,则这时进程调度中已经没有需要调度的进程了,则整个进程调度完成。

七、总结与体会该实验利用进程调度中的优先级算法调度进程,开始给每一个进程设定一个优先级数,对于优先级高的进程先调度,优先级低的进程后调度,在调度一个进程时,其他进程将处于就绪态,而正在被调度的进程应处于运行态。

一开始在做这个实验的时候,我感觉大脑一片空白,不知道该从哪里动笔。

后来根据书上的内容和从网上下载的资料,我慢慢地了解了大致的流程。

通过这次实验,首先加深了我对进程调度方法和功能的认识,其次让我更加深刻地理解了操作系统中进程调度中优先级调度的基本原理。

优先级调度算法只是进程调度算法的一种,我们还应依照书本去学习进程调度的其它算法,以便更好地了解进程调度C:\iknow\docshare\data\cur_work\156075210.doc。

相关文档
最新文档