实验一进程调度实验报告书
计算机操作系统进程调度实验报告
计算机操作系统进程调度实验报告
实验报告:计算机操作系统进程调度
1.实验背景与目的
计算机操作系统是一种负责管理和协调计算机硬件和软件资源的系统。进程调度作为操作系统的重要功能之一,主要负责决定哪些进程可以运行、何时运行以及运行多长时间等问题。本实验旨在通过实践学习进程调度的
原理和实现细节,加深对操作系统的理解。
2.实验原理与步骤
(1)实验原理:
进程调度的目标是充分利用计算机资源,提高系统的吞吐率和响应时间。常用的调度算法有先来先服务(FCFS)、最短作业优先(SJF)、时
间片轮转(RR)等。在本实验中,我们将实现时间片轮转调度算法,并对
比不同算法的性能差异。
(2)实验步骤:
1)设计进程数据结构:创建进程控制块(PCB)结构体,包含进程的
标识符、到达时间、服务时间、剩余时间、等待时间等信息。
2)生成进程:根据指定的进程个数和服务时间范围,生成随机的进
程并初始化进程控制块。
3)时间片轮转调度算法:根据时间片大小,按照轮转调度的方式进
行进程调度。
4)性能评估:通过记录进程的等待时间和周转时间,比较不同调度算法的性能差异。
3.实验结果与分析
通过实验我们生成了10个进程,并使用时间片大小为2进行轮转调度。下表列出了各个进程的信息及调度结果。
进程到达时间服务时间剩余时间等待时间周转时间
P108068
P214004
P3291310
P4350115
P542032
P6570147
P763063
P8761714
P981071
P1093104
从实验结果可以看出,时间片轮转调度算法相对公平地分配了CPU给各个进程,减少了等待时间和周转时间。但是,对于长时间服务的进程,可能出现饥饿问题,即一些耗时较长的进程无法得到充分的CPU时间。
实验一、进程调度实验报告
实验一、进程调度实验报告
一、实验目的
进程调度是操作系统中的核心功能之一,其目的是合理地分配 CPU 资源给各个进程,以提高系统的整体性能和资源利用率。通过本次实验,我们旨在深入理解进程调度的原理和算法,掌握进程状态的转换,观察不同调度策略对系统性能的影响,并通过实际编程实现来提高我
们的编程能力和对操作系统概念的理解。
二、实验环境
本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发
工具为 Visual Studio 2019。
三、实验原理
1、进程状态
进程在其生命周期中会经历不同的状态,包括就绪态、运行态和阻
塞态。就绪态表示进程已经准备好执行,只等待 CPU 分配;运行态表
示进程正在 CPU 上执行;阻塞态表示进程由于等待某个事件(如 I/O
操作完成)而暂时无法执行。
2、调度算法
常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)等。
先来先服务算法按照进程到达的先后顺序进行调度。
短作业优先算法优先调度执行时间短的进程。
时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片执行。
四、实验内容
1、设计并实现一个简单的进程调度模拟器
定义进程结构体,包含进程 ID、到达时间、执行时间、剩余时间等信息。
实现进程的创建、插入、删除等操作。
实现不同的调度算法。
2、对不同调度算法进行性能测试
生成一组具有不同到达时间和执行时间的进程。
分别采用先来先服务、短作业优先和时间片轮转算法进行调度。
记录每个算法下的平均周转时间、平均等待时间等性能指标。
操作系统实验报告进程调度
操作系统实验报告进程调度
操作系统实验报告:进程调度
引言
操作系统是计算机系统中最核心的软件之一,它负责管理和调度计算机的资源,提供良好的用户体验。在操作系统中,进程调度是其中一个重要的功能,它决
定了进程的执行顺序和时间片分配,对于提高计算机系统的效率和响应能力至
关重要。本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念
进程调度是操作系统中的一个重要组成部分,它负责决定哪个进程可以使用CPU,并为其分配执行时间。进程调度的目标是提高系统的吞吐量、响应时间
和公平性。在多道程序设计环境下,进程调度需要考虑多个进程之间的竞争和
协作,以实现资源的合理利用。
二、进程调度算法
1. 先来先服务调度(FCFS)
先来先服务调度算法是最简单的进程调度算法之一,它按照进程到达的顺序进
行调度,即先到达的进程先执行。这种算法的优点是公平性高,缺点是无法适
应长作业和短作业混合的情况,容易产生"饥饿"现象。
2. 最短作业优先调度(SJF)
最短作业优先调度算法是根据进程的执行时间来进行调度的,即执行时间最短
的进程先执行。这种算法的优点是能够最大程度地减少平均等待时间,缺点是
无法适应实时系统和长作业的情况。
3. 时间片轮转调度(RR)
时间片轮转调度算法是一种抢占式调度算法,它将CPU的执行时间划分为固定
大小的时间片,并按照轮转的方式分配给各个进程。当一个进程的时间片用完后,它将被挂起,等待下一次调度。这种算法的优点是能够保证每个进程都能
够获得一定的执行时间,缺点是无法适应长作业和短作业混合的情况。
进程调度实验报告
进程调度实验报告
这篇文章将讨论进程调度的相关实验及其结果。进程调度是指
计算机在多任务环境下对进程进行管理和调度,以便最大化系统
的效率和可靠性。
在进程调度实验中,我们使用了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算法会基于当前进程的下一步行动来调度进程。但是,如果多个进程具有相似的执行时间,并且它们需要同时运行,则存在一定的竞争和时间分配的缺陷。
进程调度实验报告
进程调度实验报告
一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。
三、实验过程。
1. 先来先服务(FCFS)调度算法。
先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。
2. 最短作业优先(SJF)调度算法。
最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。
3. 时间片轮转(RR)调度算法。
时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。
4. 多级反馈队列(MFQ)调度算法。
进程调度 实验报告
进程调度实验报告
进程调度实验报告
概述:
进程调度是操作系统中一个重要的组成部分,它负责决定在多个进程同时运行时,每个进程分配到的CPU时间片以及切换进程的时机。合理的进程调度算法能够提高系统的性能和资源利用率,因此对进程调度的研究和优化具有重要意义。
1. 背景介绍
进程调度是操作系统中的一个关键任务,它负责管理和控制多个进程的执行顺序,以实现对CPU的合理分配。在多道程序设计环境下,进程调度的作用尤为重要。进程调度算法的好坏直接影响着系统的性能和响应速度。
2. 进程调度算法
2.1 先来先服务(FCFS)
先来先服务是最简单的调度算法之一,它按照进程到达的先后顺序进行调度,即先到达的进程先执行,直到该进程执行完成或者发生I/O操作。FCFS算法的优点是公平且易于实现,但是它无法适应不同进程的执行时间差异,可能导致长作业效应。
2.2 最短作业优先(SJF)
最短作业优先调度算法是根据进程的执行时间长度来进行调度,执行时间越短的进程越优先执行。SJF算法能够最大程度地减少平均等待时间,但是它需要预先知道进程的执行时间,这在实际应用中往往是不可行的。
2.3 时间片轮转(RR)
时间片轮转是一种经典的调度算法,它将CPU的执行时间划分为若干个时间片,每个进程在一个时间片内执行,如果时间片用完还没有执行完,则将该进程放
入就绪队列的末尾,继续执行下一个进程。RR算法能够保证每个进程都能获得
公平的CPU时间,但是对于长时间执行的进程,会导致较大的上下文切换开销。
3. 实验设计与结果分析
为了评估不同进程调度算法的性能,我们设计了一系列实验。首先,我们使用
实验一进程调度实验报告书
淮海工学院计算机工程学院实验报告书
课程名:《操作系统原理A》
题目:进程调度
班级:软件132
学号:2013122907
姓名:孙莹莹
操作系统原理实验——进程调度实验报告
一、目的与要求
1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C 语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。本实验可加深对进程调度算法的理解。
2)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果)
3)于2015年4月18日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。
二、实验内容或题目
1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。
3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。
三、实验步骤与源程序
(1)流程图
(2)实验步骤
1)PCB的结构:优先级算法中,设PCB的结构如下图所示,其中各数据项的含义如下:
Id:进程标识符号,取值1—5。
Priority:优先级,随机产生,范围1—5。
Used:目前已占用的CPU时间数,初值为0;当该进程被调用执行时,每执行一个时间片,Used加1。
Need:进程尚需的CPU时间数,初值表示该进程需要运行的总时间,取值范围为5—10。并随机产生,每运行一个时间片need减1;need为0则进程结束。
进程调度算法 实验报告
进程调度算法实验报告
《进程调度算法实验报告》
一、实验目的
本实验旨在通过对进程调度算法的实验研究,探究不同调度算法对系统性能的影响,进一步加深对操作系统进程调度的理解。
二、实验内容
本次实验选择了三种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)和轮转调度(RR),并通过模拟不同进程的到达时间和执行时间,分别对这三种算法进行实验比较。
三、实验步骤
1. 设计实验用例:确定不同进程的到达时间和执行时间,以及不同调度算法的时间片大小。
2. 模拟执行:根据设计的实验用例,使用模拟工具模拟不同调度算法的执行过程,并记录每个进程的执行情况和系统的运行情况。
3. 数据分析:根据实验结果,对比不同调度算法的平均等待时间、平均周转时间等指标,分析各算法的优缺点。
四、实验结果
通过实验比较,得出以下结论:
1. 先来先服务(FCFS)算法:适用于执行时间较短的进程,但容易导致长作业等待时间过长。
2. 最短作业优先(SJF)算法:能够最大程度地减少平均等待时间和平均周转时间,但无法处理长作业优先的情况。
3. 轮转调度(RR)算法:能够保证每个进程都能及时得到执行,但可能导致部分进程的等待时间过长。
五、实验结论
根据实验结果,不同的进程调度算法适用于不同的场景。在实际应用中,需要根据系统的实际情况和需求选择合适的调度算法,以最大程度地提高系统的性能和效率。
六、实验总结
通过本次实验,加深了对进程调度算法的理解,同时也了解了不同算法在实际应用中的优缺点。希望通过本次实验,能够为进程调度算法的研究和应用提供一定的参考和借鉴。
操作系统(进程调度)实验报告
操作系统原理(进程调度)实验报告
实验一:动态优先权
一.实验目的:
(1).理解进程创建的相关理论;
(2).掌握进程创建方法;
(3).掌握进程相关的数据结构;
(4).了解进程的调度算法;
二.实验内容:
1、最好采用图形界面;
2、可随时增加进程;
3、规定道数,设置后备队列和挂起状态。若内存中进程少于规定道数,可自动从后备队列调度一作业进入。被挂起进程入挂起队列,设置解挂功能用于将指定挂起进程解挂入就绪队列。
4、每次调度后,显示各进程状态。
三.实验步骤
1.创建进程PCB。包括进程ID,优先权,执行时间,占用cpu时间,状态五个部分;
struct Process
{
int id;
int priority;
int cputime;
int alltime;
enum STATE state;
}process[N];
2.初始化进程队列。进程号用ID表示,优先权随机设定,状态均置为ready;
void Init()
{
srand((unsigned)time(NULL));
for(int i=0;i
{
process[i].id = Rseq[i] = i;
process[i].priority = rand()%20;
process[i].cputime = 0;
process[i].alltime = rand()%3+3;
process[i].state = ready;
TIME += process[i].alltime;
}
Sort();
Print();
flag = 1;
}
3.运行进程。首轮按优先权大小排列进程执行顺序,优先权最大的最先执行,首轮执行后,运行程序优先权减2,未执行程序优先权加1.第二轮再按优先权顺序排序执行,以此类推,直到所有程序执行完成。
进程调度实验报告
实验一进程调度实验
小组成员:09信管06班余俭3109005857
曾昭术3109005859
一、实验目的:
用高级语言编写和测试一个进程调度程序,通过本实验可以加深理解有关进程控制块、进程队列的概念,以加深对进程的概念及进程调度算法的理解,并体会和了解优先数调度算法的具体实施方法。
二、实验内容:
设计一个有N个进程并发的进程调度程序。要求采用最高优先数优先算法,时间片轮转算法这两种算法。
每个进程有一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机产生)。进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。当执行进程在工作的时候,就绪队列中的进程优先级都加一。当要进行进程调度的时候,如果排在队列前面的进程优先级相等,则按照需要运行的时间大小来排序,需要时间小的排在前面,符合短作业优先算法。
如果运行一个时间片后,进程的已占用CPU时间已到达所需要的运行时间,则撤销该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
进程调度实验报告
进程调度实验报告
进程调度实验报告
一、引言
进程调度是操作系统中重要的一个组成部分,它负责管理和分配系统资源给不
同的进程,以实现系统的高效运行。本次实验旨在通过实际操作和观察,深入
理解进程调度算法的原理和应用。
二、实验目的
1. 理解进程调度的概念和作用;
2. 掌握常见的进程调度算法;
3. 分析不同调度算法的优缺点。
三、实验环境
本次实验使用的是Linux操作系统,并通过编写C语言程序来模拟进程的创建
和调度过程。
四、实验过程
1. 创建进程
在实验开始时,我们首先编写了一个简单的C程序,用于创建多个进程。通过
调用系统函数fork(),我们可以实现进程的复制和创建。在实验中,我们创建了
5个子进程,并分别给它们设置了不同的优先级。
2. 进程调度算法的实现
为了模拟不同的进程调度算法,我们在程序中实现了以下几种常见的调度算法:- 先来先服务(FCFS):按照进程到达的先后顺序进行调度,即先到先服务。
- 短作业优先(SJF):按照进程的执行时间进行排序,优先调度执行时间最短的
进程。
- 优先级调度:按照进程的优先级进行排序,优先调度优先级最高的进程。
- 时间片轮转调度:将CPU时间分成若干个时间片,每个进程在一个时间片内执行,超过时间片后,将CPU让给下一个进程。
3. 实验结果分析
通过运行程序,我们观察到不同调度算法下进程的执行情况,并进行了分析。- 在先来先服务算法下,进程按照到达的先后顺序进行调度,执行时间较长的进程可能会导致其他进程的等待时间增加。
- 在短作业优先算法下,执行时间短的进程会被优先调度,可以减少平均等待时间,但可能会导致长作业的饥饿。
进程调度算法实验报告
实验报告
实验一:进程调度算法
一、实验目的
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; //优先级
进程调度实验报告
进程调度实验报告
本次实验主要是针对进程调度的学习和实践,通过对进程调度算法的了解和实现,加深对操作系统的理解和掌握。
实验环境
本次实验使用的是Linux操作系统,具体版本为Ubuntu 18.04 LTS。实验中使用了C语言编写程序,并使用了gcc编译器进行编译。
实验内容
本次实验主要包括以下内容:
1. 进程调度算法的了解和实现
进程调度算法是操作系统中非常重要的一部分,它决定了操作系统如何分配CPU时间片给不同的进程。本次实验中,我们学习了三种常见的进程调度算法:先来先服务(FCFS)、最短作业优先(SJF)和时间片轮转(RR)。并且,我们实现了这三种算法的代码,并进行了测试和比较。
2. 进程调度的实现
在实验中,我们使用了C语言编写了一个简单的进程调度程序。该程序可以创建多个进程,并使用不同的调度算法进行调度。我们通过修改程序中的参数,可以测试不同的调度算法和不同的进程数量,
以便更好地理解进程调度的原理和实现。
实验结果
通过本次实验,我们深入了解了进程调度算法的原理和实现,并通过实验测试了不同的调度算法和不同的进程数量。我们发现,不同的调度算法对于不同的进程负载有不同的表现。在进程数量较少的情况下,先来先服务算法表现较好;而在进程数量较多的情况下,时间片轮转算法表现更好。此外,我们还发现,进程调度算法对于系统的响应时间和吞吐量有着重要的影响。
结论
通过本次实验,我们深入了解了进程调度算法的原理和实现,并通过实验测试了不同的调度算法和不同的进程数量。我们发现,进程调度算法对于系统的响应时间和吞吐量有着重要的影响,因此在实际应用中需要根据实际情况选择合适的调度算法。
进程调度实验报告
进程调度实验报告
1. 引言
进程调度是操作系统中一个重要的概念,它决定了各个进程在CPU上运行的次序和时间长度。合理的进程调度能够提高系统的运行效率和响应速度。本实验旨在研究不同的进程调度算法对系统性能的影响,并通过实验结果对比评估各个算法的优劣。
2. 实验过程
2.1 实验环境搭建
在进行实验之前,我们需要搭建一个适合的实验环境。首先,选择一种操作系统作为实验的基础环境,在这个环境上进行后续步骤。其次,选择一种编程语言或工具来实现不同的进程调度算法。最后,准备一组测试用例,包含不同类型的进程和不同长度的时间片等。
2.2 实验步骤
以下是实验的具体步骤: 1. 首先,选择合适的进程调度算法,如FCFS、SJF、RR 等。 2. 实现所选算法,并将其应用于测试用例上。 3. 模拟进程的运行过程,记录每个进程的等待时间、周转时间等指标。 4. 重复步骤1~3,使用不同的进程调
度算法进行对比实验。 5. 分析实验结果,总结每种算法的优缺点。
2.3 实验数据分析
根据实验得到的数据,我们可以对不同的进程调度算法进行分析。可以从以下几个方面对算法的性能进行评估: - 平均等待时间:衡量了进程等待的时间长度,可
以用来评估系统的效率和响应速度。 - 平均周转时间:衡量了进程从被提交到完
成执行所经历的时间长度,可以用来评估系统的性能。 - CPU利用率:衡量了CPU 的利用效率,高CPU利用率意味着系统负载较高,可能导致响应速度下降。 - 算
法复杂度:考虑到实际应用中所需的计算量,评估进程调度算法的复杂度。
进程调度 实验报告
动态优先权调度算法 privilege.h
#ifndef PRIVILEGE_H #define PRIVILEGE_H struct process1 {
int pcb;
//进程号 PCB
int privilege,cpu; //进程优先权,所需 CPU 时间
process1 *next;
};
/*******************优先权调度算法所需函数声明
当前运行进程用完时间片后,其优先权减去一个常数。 2) 轮转法 三、流程图
开始
键盘输入进程数 n,和调度方法的选择
N
优先权法?
轮转法
B
Y
产生 n 个进程,对每个进程产生一个 PCB,并用
进程调度算法 实验报告
进程调度算法实验报告
进程调度算法实验报告
一、引言
进程调度算法是操作系统中非常重要的一部分,它决定了系统中各个进程的执行顺序和时间分配。在本次实验中,我们将研究和比较几种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、轮转法(RR)和优先级调度算法。
二、实验目的
本次实验的目的是通过模拟不同的进程调度算法,观察它们在不同情况下的表现,并比较它们的优缺点,以便更好地理解和应用这些算法。
三、实验过程
1. 实验环境准备
我们使用C语言编写了一个简单的进程调度模拟程序,该程序可以模拟不同的进程调度算法,并输出每个进程的执行顺序和等待时间等信息。
2. 实验步骤
(1)先来先服务(FCFS)算法
FCFS算法是最简单的一种进程调度算法,它按照进程的到达顺序来执行。我们通过模拟多个进程的到达时间和执行时间,观察它们的执行顺序和等待时间。(2)最短作业优先(SJF)算法
SJF算法是根据进程的执行时间来进行调度的,执行时间越短的进程优先执行。我们通过模拟多个进程的执行时间,观察它们的执行顺序和等待时间。
(3)轮转法(RR)算法
RR算法是一种时间片轮转的调度算法,每个进程被分配一个时间片,当时间片
用完后,进程被挂起,等待下一次调度。我们通过模拟不同的时间片大小,观
察进程的执行顺序和等待时间。
(4)优先级调度算法
优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程优先执行。我们通过模拟不同的进程优先级,观察进程的执行顺序和等待时间。
四、实验结果与分析
1. 先来先服务(FCFS)算法
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
淮海工学院计算机工程学院实验报告书
课程名:《操作系统原理A》
题目:进程调度
班级:软件132
学号:2013122907
姓名:孙莹莹
操作系统原理实验——进程调度实验报告
一、目的与要求
1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C 语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。本实验可加深对进程调度算法的理解。
2)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果)
3)于2015年4月18日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。
二、实验内容或题目
1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。
3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。
三、实验步骤与源程序
(1)流程图
(2)实验步骤
1)PCB的结构:优先级算法中,设PCB的结构如下图所示,其中各数据项的含义如下:
Id:进程标识符号,取值1—5。
Priority:优先级,随机产生,范围1—5。
Used:目前已占用的CPU时间数,初值为0;当该进程被调用执行时,每执行一个时间片,Used加1。
Need:进程尚需的CPU时间数,初值表示该进程需要运行的总时间,取值范围为5—10。并随机产生,每运行一个时间片need减1;need为0则进程结束。
Status:进程状态R(运行),W(就绪),F(完成);初始时都处于就绪状态。
Next:指向就绪队列中下一个进程的PCB的指针。
2)初始状态及就绪队列组织:
5个进程初始都处于就绪状态,进程标识1—5,used初值都为0。各进程的优先级随机产生,范围1—5。处于就绪状态的进程,用队列加以组织,队列按优先级由高到低依次排列,队首指针设为head,队尾指针为tail。
3)调度原则以及运行时间的处理:
正在执行的进程每执行一个时间片,其优先级减1(允许优先级为负)。进程调度将在以下情况发生:当正在运行的程序其优先级小于就绪队列队首进程的优先级时。程序中进程的运行时间以逻辑时间片为单位。
RUN ----当前运行进程指针;
HEAD──就绪进程队列的PCB链链首指针;
TAIL──就绪进程队列的PCB链链尾指针;
(3)源程序
#include"stdio.h"
#include"conio.h"
#include"stdlib.h"
#include
typedef struct pcb
{
int id;//进程ID
int prior;//进程优先级
int used;//已使用的时间片
int need;//还需要的时间片
char status;//进程状态
}PCB;
PCB *head,p[5];
//打印显示
void print()
{
printf("--------------------------------------------------\n");
printf("进程ID\t优先级\t已使用时间片\t所需时间片\t状态\n");
for(int j = 0; j < 5; j++)
{
if(p[j].id>p[j+1].id)
{
int temp1;
temp1=p[j].id;
p[j].id=p[j+1].id;
p[j+1].id=temp1;
printf("%d\t %d\t %d\t\t %d\t\t%c\n
",p[j].id,p[j].prior,p[j].used,p[j].need,p[j].status);
}
}
//用冒泡算法,按优先级排序
void sort()
{
for(int i = 0; i < 5; i++)
for(int j = 0; j < 4 - i; j++)
if(p[j].prior < p[j+1].prior)
{
PCB temp = p[j];
p[j] = p[j+1];
p[j+1] = temp;
}
}
//初始化进程队列
void inputprocess()
{
srand(time(0));//为随机数产生种子
//依次为每个P[i]初始化
for(int i=0; i<5; i++)
{
p[i].id = i + 1;
p[i].prior = 5-i;//为优先级随机产生1 - 5 的整数
p[i].used = 0;
p[i].need = 5 + rand()%6;//为总的时间片产生5 - 10 的整数p[i].status = 'W';//各个进程的初始状态为就绪
}
sort();//按优先级排序
head = p;
printf("开始进程的状态:\n");
print();//打印进程状态
}
//按最高优先级优先调用进程队列
void runprocess()