操作系统实验报告(进程调度算法)

合集下载

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

进程调度算法实验报告

进程调度算法实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

操作系统实验二报告-时间片轮转进程调度算法1

操作系统实验二报告-时间片轮转进程调度算法1

操作系统实验报告实验二时间片轮转进程调度算法学号:班级:姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。

【实验内容】问题描述:设计程序模拟进程的时间片轮转RR 调度过程。

假设有n 个进程分别在T1, … ,Tn 时刻到达系统, 它们需要的服务时间分别为S1, … ,Sn 。

分别利用不同的时间片大小q, 采用时间片轮转RR 进程调度算法进行调度, 计算每个进程的完成时间, 周转时间和带权周转时间, 并且统计n 个进程的平均周转时间和平均带权周转时间。

程序要求如下:1)进程个数n ;每个进程的到达时间T 1, … ,T n 和服务时间S 1, … ,S n ;输入时间片大小q 。

2)要求时间片轮转法RR 调度进程运行, 计算每个进程的周转时间, 带权周转时间, 并且计算所有进程的平均周转时间, 带权平均周转时间;3)输出: 要求模拟整个调度过程, 输出每个时刻的进程运行状态, 如“时刻3: 进程B开始运行”等等;4)输出:要求输出计算出来的每个进程的周转时间, 带权周转时间, 所有进程的平均周转时间, 带权平均周转时间。

实现提示:用C++语言实现提示:1)程序中进程调度时间变量描述如下:int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];➢2)进程调度的实现过程如下:➢变量初始化;➢接收用户输入n, T1, … ,Tn, S1, … ,Sn;时间片大小q;➢按照时间片轮转RR算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间;➢计算所有进程的平均周转时间和平均带权周转时间;➢按格式输出调度结果。

操作系统进程调度算法模拟实验报告

操作系统进程调度算法模拟实验报告

操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法,并通过模拟实验来探究不同调度算法之间的差异和优劣。

二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。

常见的调度算法有先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)、轮转法(Round Robin)和多级反馈队列调度(Multilevel Feedback Queue Scheduling)等。

1.先来先服务(FCFS)算法:按照进程到达的先后顺序进行调度,被调度的进程一直执行直到结束或主动阻塞。

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

3. 优先级调度(Priority Scheduling)算法:为每个进程分配一个优先级,按照优先级从高到低进行调度。

4. 轮转法(Round Robin)算法:将进程按照到达顺序排列成一个队列,每个进程被分配一个时间片(时间量度),当时间片结束时,将进程从队列头取出放置到队列尾。

5.多级反馈队列调度算法:将进程队列分为多个优先级队列,每个队列时间片大小依次递减。

当一个队列中的进程全部执行完毕或者发生阻塞时,将其转移到下一个优先级队列。

三、实验步骤与结果1.实验环境:- 操作系统:Windows 10- 编译器:gcc2.实验过程:(1)首先,设计一组测试数据,包括进程到达时间、需要的执行时间和优先级等参数。

(2)根据不同的调度算法编写相应的调度函数,实现对测试数据的调度操作。

(3)通过模拟实验,观察不同调度算法之间的区别,比较平均等待时间、完成时间和响应时间的差异。

(4)将实验过程和结果进行记录整理,撰写实验报告。

3.实验结果:这里列举了一组测试数据和不同调度算法的结果,以便对比分析:进程,到达时间,执行时间,优先------,----------,----------,-------P1,0,10,P2,1,1,P3,2,2,P4,3,1,P5,4,5,a.先来先服务(FCFS)算法:平均等待时间:3.8完成时间:15b.最短作业优先(SJF)算法:平均等待时间:1.6完成时间:11c. 优先级调度(Priority Scheduling)算法:平均等待时间:2.8完成时间:14d. 轮转法(Round Robin)算法:时间片大小:2平均等待时间:4.8完成时间:17e.多级反馈队列调度算法:第一级队列时间片大小:2第二级队列时间片大小:4平均等待时间:3.8完成时间:17四、实验总结通过上述的实验结果可以得出以下结论:1.在上述测试数据中,最短作业优先(SJF)算法的平均等待时间最短,说明该算法在短作业的情况下能够有效地减少等待时间。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

操作系统实验报告——调度算法

操作系统实验报告——调度算法

操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法,通过编写代码模拟不同的调度算法,了解它们的特点和应用场景。

2. 实验环境本次实验使用的操作系统环境为Linux,并采用C语言进行编码。

3. 实验内容3.1 调度算法1:先来先服务(FCFS)FCFS调度算法是一种简单且常见的调度算法。

该算法按照进程到达的先后顺序进行调度。

在本实验中,我们使用C语言编写代码模拟FCFS算法的调度过程,并记录每个进程的等待时间、周转时间和响应时间。

3.2 调度算法2:最短作业优先(SJF)SJF调度算法是一种非抢占式的调度算法,根据进程的执行时间来选择下一个要执行的进程。

在本实验中,我们使用C语言编写代码模拟SJF算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。

3.3 调度算法3:轮转调度(Round Robin)Round Robin调度算法是一种经典的时间片轮转算法,每个进程在给定的时间片内依次执行一定数量的时间。

如果进程的执行时间超过时间片,进程将被暂时挂起,等待下一次轮转。

在本实验中,我们使用C语言编写代码模拟Round Robin算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。

4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析,可以得出以下结论:- FCFS算法适用于任务到达的先后顺序不重要的场景,但对于执行时间较长的进程可能会导致下一个进程需要等待较久。

- SJF算法适用于任务的执行时间差异较大的场景,能够提高整体执行效率。

- Round Robin算法适用于时间片相对较小的情况,能够公平地为每个进程提供执行时间。

5. 实验总结本次实验通过模拟不同调度算法的实际执行过程,深入了解了各种调度算法的原理、特点和适用场景。

通过对实验结果的分析,我们可以更好地选择合适的调度算法来满足实际应用的需求。

在后续的学习中,我们将进一步探索更多操作系统相关的实验和算法。

实验进程调度的实验报告

实验进程调度的实验报告

一、实验目的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算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。

进程的调度实验报告(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("无效的调度算法选择。

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

操作系统实验报告
实验1 进程调度算法
报告日期:2016-6-10
姓名:
学号:
班级:
任课教师:
实验1 进程调度算法
一、实验内容
按优先数调度算法实现处理器调度。

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

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

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

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

(1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:
P1,P2,P3,P4,P5。

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

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

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

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

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

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

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

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

例:
K2K3K4K5
PCB1 PCB2 PCB3 PCB4 PCB5
(4) 处理器调度总是选队首进程运行。

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

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

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

在这里省去了这些工作。

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

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

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

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

四、实验内容
1.画出算法流程图
2. 程序中使用的数据结构及符号说明。

1>结构体
typedef struct PCB rior_num == N) {
pos = i;
break;
}
}
head = &arr[pos];
for (i = N - 1; i > 0; i--) rior_num == i)
{
pos1 = j;
break;
}
}
arr[pos].next = &arr[pos1];
pos = pos1;
}
return head; 源程序
#define_CRT_SECURE_NO_WARNINGS 1
#ifndef _SCHEDULING_H__
#define_SCHEDULIHG_H__
#define N 5
#include<>
#include<>
#include<>
#include<>
typedef struct PCB rior_num == N)
{
pos = i;
break;
}
}
head = &arr[pos];
for (i = N - 1; i > 0; i--) rior_num == i)
{
pos1 = j;
break;
}
}
arr[pos].next = &arr[pos1];
pos = pos1;
}
return head; ame, str[i]);
arr[i].prior_num = a[i];
arr[i].state = 'R';
arr[i].next = NULL;
arr[i].time = (rand() % 4) + 1; ame);
printf("进程优先级:%d\n", arr[i].prior_num);
printf("进程所需运行时间:%d\n", arr[i].time);
printf("进程当前状态:%c\n", arr[i].state);
printf("\n");
}
}
pPCB runPCB(pPCB head, pPCB pcb) 程序运行时的初值和运行结果初始状态:
运行一次:
运行两次:
运行三次:
五、实验小结
在用程序模拟实现进程的优先数调度过程中,我对操作系统的进程调度理解也越来越深刻,不断的调试BUG让我很有成就感,同时,这个实验花费了我大量时间让我觉得我还需要有进一步的提升。

相关文档
最新文档