实验三 进程调度(实验报告格式)
进程调度实验报告
进程调度实验报告
实验名称实验三进程调度
⼀.实验⽬的
了解进程的调度机制,掌握短作业优先算法、时间⽚轮转算法(RR)和优先数算法,并理解响应时间和周转时间的意义。
⼆.实验内容
模拟短作业优先算法、时间⽚轮转算法(RR)和优先数算法的执⾏情况,并动态画出其进程执⾏的 Gantt 图,计算以上算法的每个进程的响应时间和周转时间。
三.实验步骤和结果
1、需要模拟执⾏的进程序列如下:
进程名到达时间运⾏时间优先数
P1 0 7 5
P2 1 1 1
P3 1 3 4
P4 2 5 3
P5 4 4 2
假设:优先数越⼩优先级越⾼;所有进程都是纯 CPU 型进程。
请把上表的数据按照你⾃⼰设计的格式存为⼀个⽂本⽂件 JOB1.TXT。
2、编写⼀个模拟程序,可以读⼊⽂本⽂件 JOB1.TXT 中描述的进程序列,然后模拟短作业优先算法、时间⽚轮转算法(RR)和优先数算法的执⾏情况,并动态画出其进程执⾏的 Gantt 图,计算以上算法的每个进程的响应时间和周转时间。
3、读⼊⽂本⽂件 JOB1.TXT 中描述的进程序列,按照短作业优先算法执⾏程序。
4、按照时间⽚轮转算法执⾏程序时间⽚⼤⼩分布为 1、2 和 3。
5、按照优先数算法执⾏程序。
程序执⾏结果见下图:
第1页,共2页
教务处制
四.实验总结
通过这次试验,我们更加深刻地理解了有关于进程调度的内容,响应时间就是进程刚开始被执⾏的时间,等待时间就是进程在就绪队列中等待的时间,周转时间就是进程被执⾏完毕的时间(包括等待进⼊内存的时间,在就绪队列中的等待时间,执⾏时间,I/O时间)。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告:进程调度引言操作系统是计算机系统中最核心的软件之一,它负责管理和调度计算机的资源,提供良好的用户体验。
在操作系统中,进程调度是其中一个重要的功能,它决定了进程的执行顺序和时间片分配,对于提高计算机系统的效率和响应能力至关重要。
本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念进程调度是操作系统中的一个重要组成部分,它负责决定哪个进程可以使用CPU,并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下,进程调度需要考虑多个进程之间的竞争和协作,以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度(FCFS)先来先服务调度算法是最简单的进程调度算法之一,它按照进程到达的顺序进行调度,即先到达的进程先执行。
这种算法的优点是公平性高,缺点是无法适应长作业和短作业混合的情况,容易产生"饥饿"现象。
2. 最短作业优先调度(SJF)最短作业优先调度算法是根据进程的执行时间来进行调度的,即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间,缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度(RR)时间片轮转调度算法是一种抢占式调度算法,它将CPU的执行时间划分为固定大小的时间片,并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后,它将被挂起,等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间,缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度(Priority Scheduling)优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度,缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中,我们使用了不同的进程调度算法,并对其进行了性能测试。
进程调度算法实验报告doc
进程调度算法实验报告篇一:操作系统进程调度算法模拟实验报告进程调度算法模拟专业:XXXXX 学号:XXXXX 姓名:XXX实验日期:20XX年XX月XX日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟,要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法内容1. 算法设计思路将每个进程抽象成一个控制块PCB, PCB用一个结构体描述。
构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器,一个保存正在或未进入就绪队列的进程,一个保存就绪的进程,另一个保存已完成的进程。
还有一个PCB实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。
主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。
当程序启动时,用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息,这些信息保存到进程容器中。
进程信息输入完毕后,就开始了进程调度,每调度一次判断就绪队列是否为空,若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2. 算法流程图主程序的框架:();//先来先服务();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息();.m_WaitQueue.empty()||.m_ProcessQueue.empt() ();();进程调度过程:;3. 算法中用到的数据结构struct fcfs{//先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;floatdqzztime;};//定义一个结构体,里面包含的有一个进程相关的信息4. 主要的常量变量vectorm_ProcessQueue;//进程输入队列vectorm_WaitQueue;//进程就绪队列vectorm_FinishQueue;//完成队列vector::iterator m_iter;//迭代器 PCB m_runProcess;//运行中的进程int m_ProcessCount;//进程数 float m_RunTime;//运行时间int m_tagIsRun;//是否在运行标志。
进程调度实验报告
进程调度实验报告这篇文章将讨论进程调度的相关实验及其结果。
进程调度是指计算机在多任务环境下对进程进行管理和调度,以便最大化系统的效率和可靠性。
在进程调度实验中,我们使用了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算法是最好的选择,它能够抵消系统中不同进程需要不同时间的差异,确保每个进程都能获得相应的时间来完成任务。
进程调度实验报告
进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。
三、实验过程。
1. 先来先服务(FCFS)调度算法。
先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。
在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。
实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。
2. 最短作业优先(SJF)调度算法。
最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。
在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。
实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。
3. 时间片轮转(RR)调度算法。
时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。
在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。
实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。
4. 多级反馈队列(MFQ)调度算法。
多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。
在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。
实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。
四、实验总结。
通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。
进程调度操作系统实验报告
进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理,通过实际编程和模拟,观察不同调度算法对系统性能的影响,并掌握进程调度的实现方法。
二、实验环境操作系统: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算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。
进程调度 实验报告
进程调度实验报告进程调度实验报告概述:进程调度是操作系统中一个重要的组成部分,它负责决定在多个进程同时运行时,每个进程分配到的CPU时间片以及切换进程的时机。
合理的进程调度算法能够提高系统的性能和资源利用率,因此对进程调度的研究和优化具有重要意义。
1. 背景介绍进程调度是操作系统中的一个关键任务,它负责管理和控制多个进程的执行顺序,以实现对CPU的合理分配。
在多道程序设计环境下,进程调度的作用尤为重要。
进程调度算法的好坏直接影响着系统的性能和响应速度。
2. 进程调度算法2.1 先来先服务(FCFS)先来先服务是最简单的调度算法之一,它按照进程到达的先后顺序进行调度,即先到达的进程先执行,直到该进程执行完成或者发生I/O操作。
FCFS算法的优点是公平且易于实现,但是它无法适应不同进程的执行时间差异,可能导致长作业效应。
2.2 最短作业优先(SJF)最短作业优先调度算法是根据进程的执行时间长度来进行调度,执行时间越短的进程越优先执行。
SJF算法能够最大程度地减少平均等待时间,但是它需要预先知道进程的执行时间,这在实际应用中往往是不可行的。
2.3 时间片轮转(RR)时间片轮转是一种经典的调度算法,它将CPU的执行时间划分为若干个时间片,每个进程在一个时间片内执行,如果时间片用完还没有执行完,则将该进程放入就绪队列的末尾,继续执行下一个进程。
RR算法能够保证每个进程都能获得公平的CPU时间,但是对于长时间执行的进程,会导致较大的上下文切换开销。
3. 实验设计与结果分析为了评估不同进程调度算法的性能,我们设计了一系列实验。
首先,我们使用不同的进程到达时间和执行时间生成一组测试数据。
然后,分别使用FCFS、SJF和RR算法进行调度,并记录每个进程的等待时间和周转时间。
最后,我们对实验结果进行分析。
实验结果显示,FCFS算法对于执行时间较长的进程会出现较长的平均等待时间,而SJF算法能够有效减少平均等待时间。
进程的调度实验报告(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("无效的调度算法选择。
进程调度算法 实验报告
进程调度算法实验报告
《进程调度算法实验报告》
一、实验目的
本实验旨在通过对进程调度算法的实验研究,探究不同调度算法对系统性能的影响,进一步加深对操作系统进程调度的理解。
二、实验内容
本次实验选择了三种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)和轮转调度(RR),并通过模拟不同进程的到达时间和执行时间,分别对这三种算法进行实验比较。
三、实验步骤
1. 设计实验用例:确定不同进程的到达时间和执行时间,以及不同调度算法的时间片大小。
2. 模拟执行:根据设计的实验用例,使用模拟工具模拟不同调度算法的执行过程,并记录每个进程的执行情况和系统的运行情况。
3. 数据分析:根据实验结果,对比不同调度算法的平均等待时间、平均周转时间等指标,分析各算法的优缺点。
四、实验结果
通过实验比较,得出以下结论:
1. 先来先服务(FCFS)算法:适用于执行时间较短的进程,但容易导致长作业等待时间过长。
2. 最短作业优先(SJF)算法:能够最大程度地减少平均等待时间和平均周转时间,但无法处理长作业优先的情况。
3. 轮转调度(RR)算法:能够保证每个进程都能及时得到执行,但可能导致部分进程的等待时间过长。
五、实验结论
根据实验结果,不同的进程调度算法适用于不同的场景。
在实际应用中,需要根据系统的实际情况和需求选择合适的调度算法,以最大程度地提高系统的性能和效率。
六、实验总结
通过本次实验,加深了对进程调度算法的理解,同时也了解了不同算法在实际应用中的优缺点。
希望通过本次实验,能够为进程调度算法的研究和应用提供一定的参考和借鉴。
模拟调度实验报告(3篇)
第1篇一、实验背景进程调度是操作系统核心功能之一,它负责在多道程序环境下,按照一定的策略对进程进行调度,以确保系统资源的合理分配和高效利用。
为了加深对进程调度算法的理解,本次实验采用模拟的方式,实现了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种算法,并对实验过程进行了详细记录和分析。
二、实验目的1. 理解进程调度的基本原理和不同调度算法的特点。
2. 掌握进程控制块(PCB)的设计与实现。
3. 通过模拟实验,验证三种调度算法的执行效果。
三、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019四、实验内容1. 定义进程控制块(PCB)进程控制块是操作系统用于描述和管理进程的实体,它包含了进程的基本信息。
本实验中,PCB包含以下字段:- 进程ID:唯一标识一个进程。
- 到达时间:进程进入就绪队列的时间。
- 需要运行时间:进程完成所需的时间。
- 已运行时间:进程已运行的时间。
- 状态:进程当前的状态(就绪、运行、阻塞、完成)。
2. 实现三种调度算法(1)先来先服务(FCFS)算法FCFS算法按照进程到达就绪队列的顺序进行调度,先到先服务。
具体实现如下:- 将进程按照到达时间排序,形成就绪队列。
- 遍历就绪队列,依次执行进程,直到进程完成或被阻塞。
(2)时间片轮转(RR)算法RR算法将CPU时间划分为时间片,每个进程运行一个时间片后,让出CPU,等待下一个时间片。
具体实现如下:- 设置一个时间片大小。
- 将进程按照到达时间排序,形成就绪队列。
- 遍历就绪队列,每个进程执行一个时间片,如果进程未完成,则将其加入就绪队列队尾。
(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度,优先级高的进程优先执行。
具体实现如下:- 设置一个优先级阈值,当进程的优先级高于阈值时,将其加入就绪队列。
- 遍历就绪队列,选择优先级最高的进程执行,直到进程完成或被阻塞。
进程调度模拟程序实验实验报告
实验三、进程调度模拟程序实验一、实验目的用高级语言完成一个进程调度程序,以加深对进程的概念及进程调度算法的理解。
二、实验内容和要求设计一个有 N个进程并发执行的进程调度模拟程序。
用C++模拟基于时间片的轮转算法、静态优先算法、动态优先算法、多级反馈队列调度算法。
三、实验方法、步骤及结果测试1.原理分析及流程图(1). 每个进程有一个进程控制块(PCB)表示。
进程控制块包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
(2). 进程的优先数及需要的运行时间可以事先人为地指定,进程的运行时间以时间片为单位进行计算。
(3). 每个进程的状态可以是就绪 r(ready)、运行R(Running)、或完成F(Finished)三种状态之一。
(4). 就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
(5). 如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待调度。
(6). 每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB,以便进行检查。
(7). 重复以上过程,直到所要进程都完成为止。
2.主要程序段及其解释:动态优先调度:#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 24struct jcb{char name[10];int reqtime;int runtime;int startime;int fintime;int prio;char status;};typedef struct jcb JCB;void input(JCB job[],int *pnum){int num;int i;printf("process 数:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个process:\n",i+1);printf("输入proc名:");scanf("%s",job[i].name);printf("Priority:");scanf("%d",&job[i].prio);printf("要求服务时间:");scanf("%d",&job[i].reqtime);job[i].status='r';job[i].runtime=0;}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;if (n==0){printf("the queue is null!!\n");return;}printf("\tname\tprio\trqtime\truntime\tstatus");for(i=0;i<n;i++){printf("\nN %d",i+1);printf("\t&s",jcbp[i].name);printf("\t&d",jcbp[i].prio);printf("\t&d",jcbp[i].reqtime);printf("\t&d",jcbp[i].runtime);printf("\t&c",jcbp[i].status);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++)for(i=0;i<n-j;i++)if(btjcb[i].prio<btjcb[i+1].prio){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}main(){JCB jobarrived[MAX],jobfinished[MAX];int numarr, numfin;int systime=0;int i,j,n;JCB jcbrunning;input(jobarrived,&numarr);numfin=0;systime=0;btsort (jobarrived,numarr);printf("经按priority排序后,read queue是\n");jcbprintf(jobarrived,numarr);do{btsort(jobarrived,numarr);printf("\n\n\t\t现在系统时间%d:\n\n",systime);printf("ready queue 有\n");jcbprintf(jobarrived,numarr);jcbrunning=jobarrived[0];numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jcbrunning.status='R';jcbrunning.startime=systime;printf("\n\n\t\t处于运行态的作业名%s\n",);systime++;jcbrunning.runtime++;if (jcbrunning.runtime==jcbrunning.reqtime){jobfinished[numfin]=jcbrunning;jobfinished[numfin].status='F';numfin++;}else{jcbrunning.prio--;jcbrunning.status='r';jobarrived[numarr]=jcbrunning;numarr++;}printf("\n\n\t\t系统时间:%d已经完成的有\n\n",systime);jcbprintf(jobfinished,numfin);getchar();getchar();}while((numarr!=0));printf("\nCompleted!! ByeBye!!");getchar();getchar();}2、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1); printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t运行时间");for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].reqtime); }}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d\n",job[i].name,job[i].reqtime,job[i].ru ntime);}}void main(){JCB jobarrived[MAX];int numarr,i;JCB jcbrunning;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后,就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");while(numarr>0){jcbrunning=jobarrived[0];jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");if(jcbrunning.reqtime>0){for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];jobarrived[numarr-1]=jcbrunning;}else{numarr--;for(i=0;i<numarr;i++)jobarrived[i]=jobarrived[i+1];}printf("\n.............就绪队列是.................\n");Printf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3、#include<stdio.h>#include<conio.h>#include<string.h>#define MAX 100struct jcb{char name[10];int firsttime;int arritime;int runtime;int reqtime;};typedef struct jcb JCB;void input(JCB jcb[],int*pnum){int num;int i;printf("进程调度程序数目:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n第%d个进程: \n",i);printf("请输入进程名:");scanf("%s",&jcb[i].name);printf("到达时间:");scanf("%d",&jcb[i].arritime);printf("运行时间:");scanf("%d",&jcb[i].reqtime);printf("优先级:");scanf("%d",&jcb[i].firsttime);}for(i=0;i<num;i++){printf("\n现在输出%d个进程",i+1);printf("\t%s",jcb[i].name);printf("\t%d",jcb[i].arritime);printf("\t%d",jcb[i].firsttime);printf("\t%d",jcb[i].reqtime);}*pnum=num;}void jcbprintf(JCB jcbp[],int n){int i;printf("\t进程名称\t优先级\t运行时间"); for(i=0;i<n;i++){printf("\nN %d",i+1);printf(" %s",jcbp[i].name);printf(" %d",jcbp[i].firsttime); printf(" %d",jcbp[i].reqtime);}}void btsort(JCB btjcb[],int n){int i,j;JCB jcbtemp;for(j=1;j<n;j++){for(i=0;i<n-1;i++){if(btjcb[i].arritime>btjcb[i+1].arritime){jcbtemp=btjcb[i];btjcb[i]=btjcb[i+1];btjcb[i+1]=jcbtemp;}}}}void Printf(JCB job[],int n){int i;printf("进程名称优先级运行时间运行时间片\n");for(i=0;i<n;i++){printf(" %s %d %d %d\n",job[i].name,job[i].firstti me,job[i].reqtime,job[i].runtime);}}void main(){JCBjobarrived1[MAX],jobarrived2[MAX],jobarrived3[MAX],jobarrived[MAX]; int numarr1,numarr2,numarr3,numarr,i;JCB jcbrunning;numarr2=0;numarr1=0;numarr3=0;input(jobarrived,&numarr);printf("\n请按任意键继续.............");getchar();getchar();btsort(jobarrived,numarr);printf("\n按到达时间排序后,就绪队列是\n");jcbprintf(jobarrived,numarr);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();for(i=0;i<numarr;i++){jobarrived[i].runtime=0;}for(i=0;i<numarr;i++){jobarrived3[i]=jobarrived[i];numarr3++;}printf("\n.............就绪队列3是..........\n");jcbprintf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");jcbprintf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");jcbprintf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();while(numarr3>0){jcbrunning=jobarrived3[0];if(jcbrunning.firsttime==3){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1; jcbrunning.reqtime=jcbrunning.reqtime-1;jcbrunning.runtime=jcbrunning.runtime+1;printf("\n正在执行的进程名称是%s\n",); printf("\n");printf("\n");}jobarrived3[0]=jcbrunning;}if(jobarrived3[0].reqtime>0){jobarrived2[numarr2]=jobarrived3[0];numarr2++;}numarr3--;for(i=0;i<numarr3;i++){jobarrived3[i]=jobarrived3[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr2>0){jcbrunning=jobarrived2[0];if(jcbrunning.firsttime==2){if(jcbrunning.reqtime>2){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-2;jcbrunning.runtime=jcbrunning.runtime+2;printf("\n正在执行的进程名称是%s\n",);}else{jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime;jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime;printf("\n正在执行的进程名称是%s\n",); }jobarrived2[0]=jcbrunning;}if(jobarrived2[0].reqtime>0){jobarrived1[numarr1]=jobarrived2[0];numarr1++;}numarr2--;for(i=0;i<numarr2;i++){jobarrived2[i]=jobarrived2[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}while(numarr1>0){jcbrunning=jobarrived1[0];if(jcbrunning.firsttime==1){if(jcbrunning.reqtime>0){jcbrunning.firsttime=jcbrunning.firsttime-1;jcbrunning.reqtime=jcbrunning.reqtime-jcbrunning.reqtime; jcbrunning.runtime=jcbrunning.runtime+jcbrunning.reqtime; printf("\n正在执行的进程名称是%s\n",); }}numarr1--;for(i=0;i<numarr1;i++){jobarrived1[i]=jobarrived1[i+1];}printf("\n.............就绪队列3是..........\n");Printf(jobarrived3,numarr3);printf("\n");printf("\n");printf("\n.............就绪队列2是..........\n");Printf(jobarrived2,numarr2);printf("\n");printf("\n");printf("\n...........就绪队列1是.............\n");Printf(jobarrived1,numarr1);printf("\n");printf("\n");printf("\n请按任意键继续.............");getchar();getchar();}printf("\n请按任意键继续.............");getchar();getchar();}3.运行结果及分析四、 实验总结这次的实验是我们这门课第一次以个人为单位来完成的实验,然后这次实验用了三个星期去完成,虽然每次上机课老师都会先讲,可是我还是不太懂,到自己做的时候又不会,都是照样画葫芦。
进程调度实验报告
进程调度实验报告进程调度实验报告一、引言进程调度是操作系统中重要的一个组成部分,它负责管理和分配系统资源给不同的进程,以实现系统的高效运行。
本次实验旨在通过实际操作和观察,深入理解进程调度算法的原理和应用。
二、实验目的1. 理解进程调度的概念和作用;2. 掌握常见的进程调度算法;3. 分析不同调度算法的优缺点。
三、实验环境本次实验使用的是Linux操作系统,并通过编写C语言程序来模拟进程的创建和调度过程。
四、实验过程1. 创建进程在实验开始时,我们首先编写了一个简单的C程序,用于创建多个进程。
通过调用系统函数fork(),我们可以实现进程的复制和创建。
在实验中,我们创建了5个子进程,并分别给它们设置了不同的优先级。
2. 进程调度算法的实现为了模拟不同的进程调度算法,我们在程序中实现了以下几种常见的调度算法:- 先来先服务(FCFS):按照进程到达的先后顺序进行调度,即先到先服务。
- 短作业优先(SJF):按照进程的执行时间进行排序,优先调度执行时间最短的进程。
- 优先级调度:按照进程的优先级进行排序,优先调度优先级最高的进程。
- 时间片轮转调度:将CPU时间分成若干个时间片,每个进程在一个时间片内执行,超过时间片后,将CPU让给下一个进程。
3. 实验结果分析通过运行程序,我们观察到不同调度算法下进程的执行情况,并进行了分析。
- 在先来先服务算法下,进程按照到达的先后顺序进行调度,执行时间较长的进程可能会导致其他进程的等待时间增加。
- 在短作业优先算法下,执行时间短的进程会被优先调度,可以减少平均等待时间,但可能会导致长作业的饥饿。
- 在优先级调度算法下,优先级高的进程会被优先调度,但如果优先级设置不合理,可能会导致低优先级进程长时间等待。
- 在时间片轮转调度算法下,每个进程被分配一个时间片,可以保证每个进程公平地获得执行机会,但如果时间片过小,会导致频繁的上下文切换。
五、实验总结通过本次实验,我们深入了解了进程调度的原理和应用。
黄天实验三进程调度实验报告
操作系统实验实验三进程调度学号 1415251011 姓名黄天班级 14集成1班华侨大学电子工程系实验目的1、理解有关进程控制块、进程队列的概念。
2、掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。
实验内容与基本要求1、设计进程控制块PCB的结构,分别适用于优先权调度算法和时间片轮转调度算法。
2、建立进程就绪队列。
3、编制两种进程调度算法:优先权调度算法和时间片轮转调度算法。
实验报告内容1、优先权调度算法和时间片轮转调度算法原理。
优先权调度算法原理:(此处为静态优先权)当该算法用于作业调度时,系统从后备作业队列中选择若干个优先级最高的,且系统能满足资源要求的作业装入内存运行。
当该算法用于进程调度时,将把处理机分配给就绪进程队列中优先级最高的进程。
在这种调度方式下,系统一旦把处理机分配给就绪队列中优先级最高的进程后,该进程就能一直执行下去,直至完成;或因等待某事件的发生使该进程不得不放弃处理机时,系统才能将处理机分配给另一个优先级高的就绪进程。
时间片轮转调度算法原理:在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.4、运行结果以及结论。
1.优先权调度算法:这里采取的是短时间优先算法运行结果结果表明,占用时间最少得程序,最先运行,依次进行。
结论:程序很好的完成了实验要求所要达到的目标,进行短时间优先运行。
2.时间片轮转算法:每个时间片大小为1.每个程序轮转一次程序运行结果结论:程序运行结果表明,所有程序按照时间片来轮转,每个程序运行一个时间片后轮到下一个程序,直到所有程序运行完。
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程(作业)调度算法。
1)熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转;2)结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。
二. 实验属性该实验为设计性实验。
三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。
1)本实验要求完成如下任务:2)编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个;3)最后编写主函数对所做工作进行测试。
实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告(参见附录A), 并要求用正规的实验报告纸和封面装订整齐, 按时上交。
五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为:进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。
1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
进程调度实验报告
进程调度实验报告引言:进程调度是操作系统中一个重要的概念,它决定了一个进程何时开始执行、何时暂停、何时唤醒等等。
一个良好的进程调度算法可以提高系统的效率和响应时间。
在这次实验中,我们将对不同的进程调度算法进行测试和对比分析,旨在探究不同算法对系统性能的影响。
实验步骤:1. 实验准备在实验开始前,我们需要准备一个充分复杂的测试环境,包括不同类型的进程、不同进程的优先级、进程执行时间等参数。
这些参数的设置将影响我们对不同调度算法的评估。
2. 先来先服务调度算法(FCFS)先来先服务调度算法是最简单的一种调度算法,按照进程到达CPU的顺序依次执行。
在这个实验中,我们首先对先来先服务调度算法进行测试。
结果显示,对于短时进程,FCFS算法效果较好,但在遇到长时进程时,会出现“饥饿”现象,易导致优先级较低的进程无法获得CPU时间。
3. 短作业优先调度算法(SJF)短作业优先调度算法根据进程执行时间的长短来进行调度。
在实验中,我们通过设置不同长度的进程来对SJF算法进行测试。
结果显示,SJF算法能够较好地避免“饥饿”现象,但如果长作业在一个时间片内到达,就会导致短作业等待时间过长。
4. 优先级调度算法(Priority)优先级调度算法通过为每个进程指定一个优先级来进行调度,优先级高的进程先执行。
在实验中,我们设置不同优先级的进程,测试Priority算法的效果。
结果显示,Priority算法能够合理地根据优先级分配CPU时间,但如果优先级的划分不合理,可能导致某些进程优先级一直很低,影响整体系统性能。
5. 时间片轮转调度算法(Round Robin)时间片轮转调度算法是一种较为公平的调度算法,每个进程被分配一个时间片,在时间片用完后,进程暂停执行,并被放置于“就绪队列”尾部,等待下一个时间片。
在测试中,我们可以通过设置不同的时间片长度来观察时间片轮转算法的效果。
结果显示,时间片轮转算法能够较好地平衡进程的等待时间和执行时间。
进程调度实验报告
进程调度实验报告进程调度实验报告一、实验目的本实验旨在通过模拟进程调度算法,加深对操作系统进程调度的理解,掌握进程调度算法的实现方法。
二、实验环境操作系统:Windows 10编程语言:C++开发工具:Visual Studio 2019三、实验内容1. 实现进程调度算法本实验实现了三种进程调度算法:先来先服务(FCFS)、短作业优先(SJF)和时间片轮转(RR)。
其中,FCFS算法按照进程到达的先后顺序进行调度,SJF算法按照进程执行时间的长短进行调度,RR算法则按照时间片轮转的方式进行调度。
2. 模拟进程调度过程本实验模拟了多个进程的调度过程,包括进程的创建、调度、执行和结束。
在模拟过程中,每个进程都有自己的进程ID、到达时间、执行时间和优先级等属性。
通过模拟进程调度过程,可以更好地理解进程调度算法的实现原理。
3. 统计调度结果本实验统计了每种进程调度算法的平均等待时间、平均周转时间和平均带权周转时间。
通过统计调度结果,可以比较不同进程调度算法的优劣,为实际应用提供参考。
四、实验结果1. 进程调度算法的实现本实验实现了三种进程调度算法,分别是FCFS、SJF和RR。
其中,FCFS算法的实现比较简单,只需要按照进程到达的先后顺序进行调度即可。
SJF算法则需要根据进程的执行时间进行排序,然后按照排序后的顺序进行调度。
RR算法则需要设置时间片大小,每个进程执行一个时间片后,将其放入就绪队列的末尾,然后轮到下一个进程执行。
2. 模拟进程调度过程本实验模拟了多个进程的调度过程,包括进程的创建、调度、执行和结束。
在模拟过程中,每个进程都有自己的进程ID、到达时间、执行时间和优先级等属性。
通过模拟进程调度过程,可以更好地理解进程调度算法的实现原理。
3. 统计调度结果本实验统计了每种进程调度算法的平均等待时间、平均周转时间和平均带权周转时间。
通过统计调度结果,可以比较不同进程调度算法的优劣,为实际应用提供参考。
操作系统原理---进程调度实验报告
一、实验目的通过对进程调度算法的设计,深入理解进程调度的原理。
进程是程序在一个数据集合上运行的过程,它是系统进行资源分配和调度的一个独立单位。
进程调度分配处理机,是控制协调进程对CPU的竞争,即按一定的调度算法从就绪队列中选中一个进程,把CPU的使用权交给被选中的进程。
进程通过定义一个进程控制块的数据结构(PCB)来表示;每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性;在RR中,以1为时间片单位;运行时,输入若干个进程序列,按照时间片输出其执行序列。
二、实验环境VC++6.0三、实验内容实现短进程优先调度算法(SPF)和时间片轮转调度算法(RR)[提示]:(1) 先来先服务(FCFS)调度算法原理:每次调度是从就绪队列中,选择一个最先进入就绪队列的进程,把处理器分配给该进程,使之得到执行。
该进程一旦占有了处理器,它就一直运行下去,直到该进程完成或因发生事件而阻塞,才退出处理器。
将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理,是一种最普遍和最简单的方法。
它优先考虑在系统中等待时间最长的作业,而不管要求运行时间的长短。
按照就绪进程进入就绪队列的先后次序进行调度,简单易实现,利于长进程,CPU繁忙型作业,不利于短进程,排队时间相对过长。
(2) 时间片轮转调度算法RR原理:时间片轮转法主要用于进程调度。
采用此算法的系统,其程序就绪队列往往按进程到达的时间来排序。
进程调度按一定时间片(q)轮番运行各个进程.进程按到达时间在就绪队列中排队,调度程序每次把CPU分配给就绪队列首进程使用一个时间片,运行完一个时间片释放CPU,排到就绪队列末尾参加下一轮调度,CPU分配给就绪队列的首进程。
固定时间片轮转法:1 所有就绪进程按FCFS 规则排队。
2 处理机总是分配给就绪队列的队首进程。
3 如果运行的进程用完时间片,则系统就把该进程送回就绪队列的队尾,重新排队。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验三:进程调度
一、实验目的
(1)理解进程控制块和进程组织方式;
(2)掌握时间片轮转调度算法实现处理机调度。
二、实验环境
微型计算机,Ubuntu Linux10.04 ,gedit,gcc
三、实验内容
1建立合理的PCB数据结构,建立含有8个进程结点的就绪队列,每个进程的要求运行时间随机产生,要求每个进程的要求运行时间不大于15。
2 设置时间片大小(3~6),使用时间片轮转调度算法实现处理机调度。
四、实验结果
五、源代码
#include<stdio.h>
#include<time.h>
#include<malloc.h>
#define T 8
#define NUM 10
typedef struct PCB{
int name;
int runtime;
int runedtime;
int killtime;
struct PCB *next;
}PCB;
PCB *creat_jiuxu(PCB *top)
{
PCB *temp;
int i;
srand((int)time(0));
for(i=0;i<NUM;i++){
temp=(PCB *)malloc(sizeof(PCB));
temp->name=i;
temp->runtime=rand()%15;
temp->runedtime=0;
temp->next=NULL;
temp->killtime=0;
if(i==0) top=temp;
else{
temp->next=top;
top=temp;
}
}return top;
}
void run(PCB *top)
{
PCB *tail=top;
if(tail->next!=NULL)
tail=tail->next;
PCB *rq=NULL;
while(top!=NULL){
rq=top;
if(rq->runtime<=rq->runedtime+T){
printf("process_name:%d,runtime:%d,killtime:%d\n",rq->name,rq->runtime,rq->killtime);
/*if(rq!=NULL) free(rq);*/
top=top->next;
}else{
top=top->next;
rq->runedtime+=T;
rq->killtime++;
tail->next=rq;
tail=rq;
rq->next=NULL;
}
}return;
}
int main()
{
PCB *top=NULL;
top=creat_jiuxu(top);
run(top);
return 0;
}。