进程控制和调度实验报告

合集下载

进程控制实验报告

进程控制实验报告

一、实验目的本次实验旨在通过Linux操作系统的实践操作,加深对进程控制概念的理解。

通过学习进程的创建、调度、同步、通信等基本操作,掌握进程控制的基本方法,并了解进程间通信的机制。

二、实验环境1. 硬件环境:Intel(R) Core(TM) i5-3210M CPU2.50GHz,4.00GB内存。

2. 软件环境:64位Linux操作系统。

三、实验内容1. 进程的创建与终止2. 进程的调度与优先级3. 进程同步与互斥4. 进程间通信四、实验步骤1. 进程的创建与终止(1)使用`fork()`函数创建子进程,通过比较返回值判断创建是否成功。

```cpid_t pid = fork();if (pid < 0) {perror("fork failed");exit(1);}```(2)使用`exit()`函数终止进程。

```cexit(0);```2. 进程的调度与优先级(1)使用`nice()`函数调整进程优先级。

```cnice(10); // 降低进程优先级```(2)使用`priority_seta()`函数设置进程优先级。

```cstruct sched_param param;param.sched_priority = 10;if (sched_setscheduler(pid, SCHED_RR, &param) == -1) { perror("sched_setscheduler failed");exit(1);}```3. 进程同步与互斥(1)使用`semaphore_t`类型的信号量实现进程同步。

```csemaphore_t sem;sem_init(&sem, 0, 1);sem_wait(&sem);// 执行临界区代码sem_post(&sem);sem_destroy(&sem);```(2)使用`mutex_t`类型的互斥锁实现进程互斥。

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

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

计算机操作系统进程调度实验报告实验报告:计算机操作系统进程调度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 上执行;阻塞态表示进程因等待某个事件而暂停执行。

(三)进程控制的基本操作1、进程创建:通过系统调用创建新的进程,为其分配资源并初始化。

2、进程终止:当进程完成任务或出现异常时,结束其执行并回收资源。

3、进程阻塞:进程在等待某个事件时,主动进入阻塞态。

4、进程唤醒:当等待的事件发生时,将阻塞的进程唤醒,使其进入就绪态。

四、实验内容与步骤(一)进程创建1、编写 C++程序,使用系统提供的函数创建新的进程。

2、在新进程中执行特定的任务,例如打印输出信息。

```cppinclude <windowsh>include <iostream>int main(){STARTUPINFO si;PROCESS_INFORMATION pi;ZeroMemory(&si, sizeof(si));sicb = sizeof(si);ZeroMemory(&pi, sizeof(pi));//创建新进程if (!CreateProcess(NULL, //应用程序名称"C:\\Path\\To\\Your\\ChildProcessexe",//命令行参数NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)){std::cerr <<"CreateProcess failed Error code: "<<GetLastError()<< std::endl;return 1;}//等待子进程结束WaitForSingleObject(pihProcess, INFINITE);//关闭进程和线程句柄CloseHandle(pihProcess);CloseHandle(pihThread);return 0;}```(二)进程终止1、在创建的进程中设置条件,当满足条件时主动终止进程。

进程调度实验报告

进程调度实验报告

进程调度实验报告这篇文章将讨论进程调度的相关实验及其结果。

进程调度是指计算机在多任务环境下对进程进行管理和调度,以便最大化系统的效率和可靠性。

在进程调度实验中,我们使用了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算法是最好的选择,它能够抵消系统中不同进程需要不同时间的差异,确保每个进程都能获得相应的时间来完成任务。

实验进程调度的实验报告

实验进程调度的实验报告

一、实验目的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)。
//定义状态量
int Min(PCB *head)//挑选出队列中的拥有最小alltime值的块,返回块号,用于sjf算法
{
PCB *p;//q用来记录这个块的地址
int min,id;//记录最小值和块号
p=head->next;
if(p)
{
min=p->Alltime;
id=p->ID;
while(p->next)









创建和显示进程状态算法:PCB *CreatPCB(int n)
FCFS调度算法
功能:根据进程到达的顺序进行调度,先到达的进程先执行。在就绪队列中排的越靠前越先执行
算法:void FCFS(PCB *head,PCB *over)
SJ调度算法
功能:从就绪队列中选出剩余执行时间最短的就绪进程进行执行。执行结束后继续从就绪队列中选出剩余执行时间最短的。直到所有进程都被执行完。
p=p->next;
}
else
{
p=p->next;
}
}
}
return id;
}
PCB *CreatPCB(int n)
{
int i;
PCB *p,*q;
head=(PCB*)malloc(sizeof(PCB));
head->next=NULL;
p=head;
for(i=1;i<=n;i++)
{
q=(PCB*)malloc(sizeof(PCB));
q->ID=i;
q->CPUtime=0;
q->Alltime=rand()%200;
q->Pri
q->Arrivetime=0;
p->next=q;
p=q;
q->next=NULL;
}
head->next->Priority=0;
return head;
{
PCB *p;//q用来记录这个块的地址
int max,id;//记录最大和块号
p=head->next;
if(p)
{
max=p->Priority;
id=p->ID;
while(p->next)
{
if(max<=p->next->Priority)
{
max=p->next->Priority;
id=p->next->ID;
缺点:程序仍然存在很多地方可以改进。比如输出界面,可以做的更漂亮。部分地方可以采用其他的方法。


#include<stdio.h>
#include<stdlib.h>
#define Ready 0
#define Running 1
#define Block 3
#define Over 4
typedef struct PCBNode
算法:void RR(PCB *head,PCB *over,int t,int k)//时间片轮转法









先来先服务算法(FCFS调度法):
短作业(进程)优先调度算法(SJ调度算法):
最高优先权优先调度算法(优先调度算法):
时间片轮转算法(RR调度算法):


优点:程序中的数组采用了动态开辟的方法,有效地减少了对于空间的占用。提高了空间的利用率。输出的界面比较的简洁,直接给出了分配资源的顺序。资源请求算法则直接给出了请求后造成的情况,比较的明了。
课程名称
操作系统
班级
1120542
实验日期
2013-12-04
姓名
聂建建
学号
06
实验成绩
实验名称
进程控制和调度
实验
目的
以及
要求
用高级语言编写和调试进程调度的模拟程序,以加深对进程调度算法的理解。




Microsoft Visual Studio




1、自定义进程相关的数据结构;
2、利用MFC类库中的栈(queue),链表(list),向量(vector)等模板模拟进程控制块队列、进程控制块优先级队列、统计信息链表及其指令集合;
3、利用MSDN和MFC API编程实现常见的进程控制和调度策略(先来先服务算法(FCFS调度法)、短作业(进程)优先调度算法(SJ调度算法)、最高优先权优先调度算法(优先调度算法)、时间片轮转算法(RR调度算法));
4、测试以上进程调度策略的周转时间、带权周转时间、平均周转时间和平均带权周转时间,并定性评价它们的性能。
算法:void SJF(PCB *head,PCB *over)//sjf算法
优先调度算法(Prio):
功能:从就绪队列中选出优先级别最高的进程进行执行。重复进行。直到所有的所有的进程执行完毕。
算法:void Prio(PCB *head,PCB *over)
RR调度算法:
功能:根据时间片的大小,对每个进程依次执行。时间片用完之后进程进入阻塞的状态,重新得到时间片后接着执行。直到完成。
printf("%d ",p->CPUtime);
printf("%d ",p->Alltime);
printf("%d ",p->Priority);
printf("%d \n",p->state);
p=p->next;
}
}//显示PCB块
void FCFS(PCB *head,PCB *over)
}//创建pcb块
void Display(PCB *head)
{
PCB *p;
p=head->next;
printf("ID Arrivetime CPUtime(已占用) Alltime Priority state \n");
while(p)
{
printf("%d ",p->ID);
printf("%d ",p->Arrivetime);
{
if(min>p->next->Alltime)
{
min=p->next->Alltime;
id=p->next->ID;
p=p->next;
}
else
{
p=p->next;
}
}
}
return id;
}
int Max(PCB *head)//挑选出队列中的拥有最大优先级的块,返回块号,用于prio算法
{
PCB *p,*q;
int j=0;
int n=0,s=0;
double m;
{
int ID;
int Priority;
int CPUtime;
int Alltime;
int Arrivetime;
int state;
int counter;
struct PCBNode *next;
}PCB;//定义数据结构
PCB *run;
PCB *ready;
PCB *over;
PCB *head;
相关文档
最新文档