实验二 单处理器系统的进程调度
操作系统实验报告进程调度
五邑大学实验报告操作系统课程2016~2017年度第1学期实验题目:进程调度院系:计算机学院班级: 140801学号: 3114002472姓名:黄凯鑫任课教师:白明成绩评定:实验二题目:进程调度完成日期:2016年12 月11 日1、实验目的(1)设计一个有n个进程工行的进程调度程序。
每个进程由一个进程控制块(PCB)表示。
进程控制块通常应包含下述信息:进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等,且可按调度算法的不同而增删。
(2)调度程序应包含2~3种不同的调度算法,运行时可任意选一种,以利于各种算法的分析比较。
(3)系统应能显示或打印各进程状态和参数的变化情况,便于观察诸进程的调度过程2、实验内容(1)编制和调试示例给出的进程调度程序,并使其投入运行。
(2)自行设计或改写一个进程调度程序,在相应机器上调试和运行该程序,其功能应该不亚于示例。
(3)直观地评测各种调度算法的性能。
3、算法设计算法:(1) 优先数法。
进程就绪链按优先数大小从高到低排列,链首进程首先投入运行。
每过一个时间片,运行进程所需运行的时间片数减1,说明它已运行了一个时间片,优先数也减3,理由是该进程如果在一个时间片中完成不了,优先级应该降低一级。
接着比较现行进程和就绪链链首进程的优先数,如果仍是现行进程高或者相同,就让现行进程继续进行,否则,调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链,且改变它们对应的进程状态,直至所有进程都运行完各自的时间片数。
(2) 简单轮转法。
进程就绪链按各进程进入的先后次序排列,进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项(相当于优先数法的优先数记录项位置)。
每过一个时间片,运行进程占用处理机的时间片数加1,然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等,若相等说明已到达轮转时间,应将现运行进程排到就绪链末尾,调度链首进程占用处理机,且改变它们的进程状态,直至所有进程完成各自的时间片。
操作系统实验报告(进程调度)
华中师范大学计算机科学系《操作系统》实验报告实验题目:进程调度学生姓名:日期:2011-12-9实验2进程调度进程完成,撤消该进程就绪队列首进程投入运行 时间片到,运行进程已占用CPU 时间+1 运行进程已占用CPU 时间已达到所需的运行时间 把运行进程插入到下一个队列的队尾插入新的进程开始 初始化PCB,输入进程信息 所有队列都为空 各进程按FCFS 原则排队等待调度 【实验目的】(1)通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法,使学生进一步掌握进程调度的概念和算法,加深对处理机分配的理解。
(2)了解Windows2000/XP 中进程(线程)的调度机制。
(3)学习使用Windows2000/XP 中进程(线程)调度算法,掌握相应的与调度有关的Win32 API 函数。
【实验内容】在Windows XP 、Windows 2000等操作系统下,使用的VC 、VB 、java 或C 等编程语言,利用相应的WIN32 API 函数,编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。
【实验步骤、过程】(含原理图、流程图、关键代码,或实验过程中的记录、数据等)1、进程调度算法:采用多级反馈队列调度算法。
其基本思想是:当一个新进程进入内在后,首先将它放入第一个队列的末尾,按FCFS 原则排队等待高度。
当轮到该进程执行时,如能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚为完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS 原则等待调度执行,以此类推。
2、实验步骤:(1)按先来先服务算法将进程排成就绪队列。
(2)检查所有队列是否为空,若空则退出,否则将队首进程调入执行。
(3)检查该运行进程是否运行完毕,若运行完毕,则撤消进程,否则,将该进程插入到下一个逻辑队列的队尾。
(4)是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。
(5)重复步骤(2)、(3)、(4),直到就绪队列为空。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。
其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。
在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。
2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。
3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。
实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。
因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。
同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告:进程调度引言操作系统是计算机系统中最核心的软件之一,它负责管理和调度计算机的资源,提供良好的用户体验。
在操作系统中,进程调度是其中一个重要的功能,它决定了进程的执行顺序和时间片分配,对于提高计算机系统的效率和响应能力至关重要。
本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念进程调度是操作系统中的一个重要组成部分,它负责决定哪个进程可以使用CPU,并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下,进程调度需要考虑多个进程之间的竞争和协作,以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度(FCFS)先来先服务调度算法是最简单的进程调度算法之一,它按照进程到达的顺序进行调度,即先到达的进程先执行。
这种算法的优点是公平性高,缺点是无法适应长作业和短作业混合的情况,容易产生"饥饿"现象。
2. 最短作业优先调度(SJF)最短作业优先调度算法是根据进程的执行时间来进行调度的,即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间,缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度(RR)时间片轮转调度算法是一种抢占式调度算法,它将CPU的执行时间划分为固定大小的时间片,并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后,它将被挂起,等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间,缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度(Priority Scheduling)优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度,缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中,我们使用了不同的进程调度算法,并对其进行了性能测试。
操作系统实验进程调度
实验二进程调度⒈实验内容进程调度模拟实验。
⒉实验目的通过模拟进程调度算法,了解进程调度的过程并比较不同的调度算法的区别。
⒊实验题目设计一段程序来模拟优先级调度算法和时间片轮转算法。
要求可以指定进程的数量、各进程需要CPU的时间和各进程的优先级。
⒋实验提示⑴进程调度算法是指处理机的分配策略。
优先数调度算法是指对每个进程确定一个优先数,进程调度总是让具有最高优先数的进程先使用处理机。
如果进程具有相同的优先数,再按先来先服务的次序分配处理机。
在本实例中采用动态优先数算法。
时间片轮转算法是指就绪进程按就绪的先后次序排成队列,每次总是选择就绪队列中的第一个进程占用处理机,但规定只能使用一个“时间片”。
⑵系统中的进程可以用进程控制块PCB来表示,PCB的结构定义如表5-8所示:表5-8 PCB结构⑶在进程调度时进程会交替的出现在运行、就绪和完成三种状态。
可以定义三个链表来存放三种状态的进程。
当进程运行时就把进程放入到运行链表中;当进程处于就绪状态时就将进程放入到就绪链表中;当进程运行完毕时就将进程放入到完成链表中。
由于同一时刻运行的进程只能有一个,所以运行链表只能有一个结点。
在实例程序中为了使程序更简洁忽略了进程的等待状态,仅运行了优先数调度算法,由于篇幅有限,仅显示部分结果,对于时间片轮转调度算法,请读者自行运行。
⑷主要变量及函数说明如表5-9所示:表5-9 主要变量及函数说明⒌实例代码//进程调度算法proc.c//运行环境Redhad9.0 gcc 4.0#include <stdio.h>#include <string.h>typedef struct pcb //定义PCB结构{char name[20]; /*进程标识符*/int cputime; /*进程占用CPU时间*/int prio; /*进程优先数*/int needtime; /*进程到完成还需要的CPU时间*/struct pcb *next;/*链指针*/}PCB;PCB *RUN,*READY,*RTAIL,*FINSH,*FTAIL;void PRINTLINK(int t)/*输出3个队列*/{PCB *p;printf("CPU运行次数:___%d___\n",t);printf("______________________\n");printf("进程名\t运行状态\t运行次数\t还需要运行次数\n");if(RUN!=NULL){printf("%s\t运行\t%d\t%d\n",RUN->name,RUN->cputime,RUN->needtime);}elseprintf("*运行状态为空\n");p=READY;if(p!=NULL){while(p!=NULL){printf("%s\t就绪\t%d\t%d\n",p->name,p->cputime,p->needtime);p=p->next;}}elseprintf("*就绪队列为空\n");p=FINSH;if (p!=NULL){while(p!=NULL){//printf(" 进程名字为:%s\n",p->name);printf("%s\t完成\t%d\t%d\n",p->name,p->cputime,p->needtime);p=p->next;}}elseprintf("*完成队列为空\n");getchar();}PCB *CPCBLINK()/*建立就绪队列*/{printf("建立就绪队列\n\n");int i,n,nt,pr;PCB *p,*q,*head;n=0;while(1){printf("请输入进程的个数(有效范围1-100):");scanf("%d",&n);printf("\n");if (n>=1&&n<=100)break;elseprintf("输入有误。
实验二--单处理器系统的进程调度
实验二–单处理器系统的进程调度
简介
在操作系统中,进程调度是非常重要的一项工作。
进程调度负责将CPU分配
给各个进程,使得每个进程都能够有机会占用CPU资源。
在单处理器系统中,CPU只有一个,因此进程调度是非常重要的。
本次实验将会探究单处理器系统的进程调度,了解各种进程调度算法的实现和
比较,利用模拟操作系统的实验平台进行实验。
实验目的
1.了解进程调度的基本概念和实现方法;
2.学习多种进程调度算法,并比较其优缺点;
3.熟悉模拟操作系统的实验环境,学习如何将算法实现到具体的系统中。
实验内容
进程调度的基本概念
进程调度是指将CPU资源分配给各个进程的过程。
在单处理器系统中,当有
多个进程需要使用CPU时,操作系统需要进行进程调度,使得每个进程都能够得
到CPU资源。
在进程调度中,需要考虑各个进程的优先级、进程的状态和进程的等待时间等
因素。
根据不同的调度算法,可以根据这些因素来确定哪个进程应该先占用CPU。
进程调度算法比较
常见的进程调度算法包括:
1.先来先服务算法(FCFS)
2.短作业优先算法(SJF)
3.优先级调度算法
4.时间片轮转算法(RR)
下面将对这些算法进行比较和介绍。
先来先服务算法(FCFS)
先来先服务算法是最简单的一种进程调度算法。
该算法将按照进程的到达时间
的先后顺序进行调度,先到达的进程先得到CPU资源。
这种算法的优点是实现简单,适用于短作业和计算密集型进程。
缺点是无法充分利用CPU资源,导致长作业需要等待较长时间才能被调度,容易产生。
操作系统实验 单处理器系统的进程调度
操作系统实验单处理器系统的进程调度一、实验目的1、加深进程概念理解,明确进程与程序区别。
2、理解操作系统中进程的组织、创建和调度等方法。
二、实验内容编写程序完成单处理器系统的进程调度,要求采用时间片轮转法调度策略。
具体内容:1、确定PCB内容及其组织方式;2、要求模拟进程空闲(新)、就绪、运行、阻塞和完成5个状态;3、实现进程创建、进程调度、进程阻塞和进程唤醒4个功能(原语);4、编写主函数对整个系统进程测试。
三、提示关键三点:(1)如何组织进程:●确定PCB内容:标识信息、状态和运行时间与存储地址等信息、现场信息、管理信息●PCB组织方式:相同状态的进程PCB构成一个队列(即有空闲、就绪、运行、阻塞和完成5个队列)(2)如何创建进程:●申请PCB(从空闲队列)—> 申请资源—> 填写PCB—>挂就绪队列(3)如何实现处理机调度及进程状态切换:●采用先来先服务(FCFS)调度策略实现进程调度;●从就绪队列选择一个进程;摘取PCB,挂运行队列;修改状态等PCB内容;保存现场、恢复现场;●模拟运行--可以按照两种场景模拟进程运行:(1)可以预先设置好各进程的运行时间、I/O时间、I/O发生的时刻等信息(可以放在一个文件中,创建进程时置入PCB),之后操作系统控制进程运行,实现状态切换,直到全部进程完成。
(2)亦可以采用人工干预方式控制进程状态切换(运行时间已预先设置),比如输入“Esc”进入“阻塞”状态,输入“Enter”则选择(新)进程运行(进程调度),当前进程回到就绪状态;输入“wakeup”,再选择阻塞进程,则被选中的阻塞进程回到就绪状态;输入“finished”,当前进程运行结束,回到完成状态;●修改(剩余)运行时间。
四、测试输出●从文件输入创建进程所需信息,创建进程的数目可控(手工输入);●进行进程调度。
被调度上的进程(正在运行)输出:(1)退出CPU的进程名及其PCB内容。
实验二 进程调度实验
实验二进程调度实验(2学时)一、实验目的用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。
二、实验内容:任务:设计一个有N个进程并行的进程调度程序进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和同优先级条件下先来先服务算法。
每个进程有一个进程控制块(PCB)表示。
进程控制块可以包含如下信息:进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
调度算法的流程图2如下:图2调度算法的流程图三、实验步骤(1) 打开VC,选择菜单项file->new,选择projects选项卡并建立一个名为" ry2"的win32 console applicatoin工程;创建时注意指定创建该工程的目录;(2) 在工程中创建源文件" ry2.cpp":选择菜单项project->add to project->files,在选择框中输入自己想要创建的文件名,这里是" ry2.cpp";在接下来询问是否创建新文件时回答"yes";然后通过Workspace->FileView->Source Files打开该文件,在其中编辑源文件并保存.(3) 通过调用菜单命令项build->build all进行编译连接,可以在指定的工程目录下得到debug-> sy2.exe程序,运行sy2.exe。
实验二 进程调度 实验报告
(1)输入进程数、进程名、要求运行时间、已运行时间以及进程状态,初
始状态都为“就绪”,用“R”表示。当一个进程运行结束后,它的状态为“结束”,用“E”表示。
(2)把所有进程按顺序排成循环队列,用指针进行连接。
(3)运行队列中的队首进程,执行一个时间片,同时将该进程的“已运行
时间”+1,同时判断“要求运行时间”和“已运行时间”是否相等,如果相等,则将该进程状态修改为“E”,并退出循环队列,指针指向下一个进程;若不相等,则指针直接指向下一个进程,执行下一个时间片。
3.流程图
五、实验结果和分析(运行结果截图)
问题一
问题二
2.问题二
本题采用的是动态改变响应比的办法。首先根据公式
计算每个进程的响应比即优先数,根据响应比的大小降序排列,响应比大
的进程优先得到服务,每次执行一个时间片。由于本实验是模拟操作系统调
度进程的过程,被选中的进程并不实际的启动运行,而是执行: 要求运行
时间-1、等待时间为0,其它进程等待时间+1。进入下一轮运行时进程重
实验目的如下:
1.利用高级语言模拟进程的时间片轮转调度算法,并熟练掌握。
2.利用高级语言模拟进程的响应比高者优先调度算法,并熟练掌握。
二、实验原理
1.问题一
针对系统的所有进程,首先确定所有进程的要求运行时间(已运行时间初始值为0);将所有进程按顺序排成循环队列,用指针指出队列连接情况,同时另用一个标志单元记录轮到运行的进程,此时以轮转法进行调度;先将CPU分配给队首进程,并令其执行一个时间片,当它运行完毕后,将CPU分配给就绪队列中新的队首进程,让其执行一个时间片,进程每被调度一次,该进程已运行时间+1,同时,判断该进程的要求运行时间与已运行时间,若该进程的要求运行时间已运行时间,则表示它尚未执行结束,应待到下一轮时再运行,若该进程的要求运行时间=已运行时间,则表示它已经执行结束,应指导它的状态修改成“结束”,并退出队列。此时,把该进程的进程控制块中的指针值送到前面一个进程的指针位置,直到所有的进程都成为“结束”状态。
操作系统 单处理器的进程调度实验报告
操作系统单处理器的进程调度实验报告实验二单处理器系统的进程调度年级 2009级学号 2009443004 姓名郭占强成绩专业生物信息学实验地点生科楼409 指导教师王硕实验项目单处理器系统的进程调度实验日期 2011年11月25日一、实验目的加深对进程概念的理解,明确进程和程序的区别;深入了解系统如何组织进程、创建进程;进一步认识如何实现处理器调度。
二、实验要求编写程序完成单处理机系统中的进程调度,要求采用时间片轮转调度算法。
实验具体包括:首先确定进程控制块的内容,进程控制块的组成方式;然后完成进程创建原语和进程调度原语;最后编写主函数对所作工作进程测试。
三、实验原理:单处理器系统的进程调度四、实验程序设计#include<stdio.h>#include<stdlib.h>#define RUNNING 1//用RUNNING 表示进程处于运行态 #define WAIT 2//用wait表示进程处于就绪态#define FINISH 3//用FINISH表示进程已经执行完毕 #define TIME_PIECE 5//用TIME_PIECE表示时间片大小 #define MAX_PROCESS_NUM 10//假定系统允许进程个数为10int AX,BX,CX,DX,PC,PSW,TIME;//模拟寄存器int run;//定义指向正在运行进程的进程控制块的指针 int pfree;//定义指向空闲进程控制块队列的指针struct{int head;int tail;}ready;//定义指向就绪队列的头指针head和尾指针tailstruct{- 1 -int name;//进程标识符int status;//进程状态int ax, bx, cx,dx;//进程现场信息,通用寄存器内容 int pc;//进程现场信息,程序计数器内容int psw;//进程现场信息,程序状态字寄存器内容 int time;//进程每次申请的时间片大小int totalTime;//执行进程需要的总时间int remainingTime;//进程剩余的执行时间int next;//下一个进程控制块的位置}pcbarea[MAX_PROCESS_NUM];//定义模拟进程控制块区域的数组//进程控制块初始化void Init(){int i;run=ready.head=ready.tail=-1;//运行指针、就绪指针清空 pfree=0;//空闲指针指向第一个进程for(i=0;i<MAX_PROCESS_NUM-1;++i)pcbarea[i].next=i+1; pcbarea[MAX_PROCESS_NUM-1].next=-1;}//创建进程void Create(int process_name,int ax,int bx,int cx,int dx,int pc,int psw,int totalTime){int i;if(pfree==-1){//空闲进程控制块队列为空printf("无空闲进程控制块,进程创建失败\n");return;}i=pfree;//取空闲进程控制块队列的第一个pfree=pcbarea[pfree].next;//pfree后移//填写该进程控制块内容pcbarea[i].name=process_name; pcbarea[i].status=WAIT;pcbarea[i].ax=ax;pcbarea[i].bx=bx;pcbarea[i].cx=cx;pcbarea[i].dx=dx;pcbarea[i].pc=pc;pcbarea[i].psw=psw;pcbarea[i].time=TIME_PIECE;- 2 -pcbarea[i].totalTime=totalTime; pcbarea[i].remainingTime=totalTime; if(ready.head!=-1){//就绪队列不空时,置入就绪队列pcbarea[ready.tail].next=i;ready.tail=i;pcbarea[ready.tail].next=-1; }else{//就绪队列空时,置入就绪队列ready.head=i;ready.tail=i;pcbarea[ready.tail].next=-1; }printf("\n");}//进程调度函数void Sheduling(){getchar();if(ready.head==-1){//空闲进程控制块队列为空,退出printf("进程调度完毕~\n\n\n");return;}run=ready.head;//就绪队列头指针赋给run,即让就绪队列的队头运行ready.head=pcbarea[ready.head].next;//就绪队列头指针后移if(ready.head==-1)ready.tail=-1;//就绪队列为空,修正尾指针ready.tailpcbarea[run].status=RUNNING;//修改进程控制块状态//恢复该进程现场信息AX=pcbarea[run].ax;BX=pcbarea[run].bx;CX=pcbarea[run].cx;DX=pcbarea[run].dx;PC=pcbarea[run].pc;PSW=pcbarea[run].psw;TIME=pcbarea[run].time;//设置相对时钟寄存器的时间片//打印进程以及系统的状态信息printf("\n进程编号:%d\n",pcbarea[run].name); printf("进程状态:运行\n");printf("寄存器内容:\n");printf("AX: %d\n",AX);- 3 -printf("BX: %d\n",BX);printf("CX: %d\n",CX);printf("DX: %d\n",DX);printf("PC: %d\n",PC);printf("PSW: %d\n",PSW);printf("TIME:%d\n\n",TIME);printf("\n**时间片用完**\n");AX=BX=CX=DX=PC=PSW=TIME=0;//时间片用完立即归还CPU资源//若进程执行完毕,则回收进程控制块if(pcbarea[run].remainingTime<=TIME_PIECE){getchar();pcbarea[run].remainingTime=0;pcbarea[run].status=FINISH;ready.head=pcbarea[run].next;//打印进程以及系统的状态信息printf("\n进程编号:%d\n",pcbarea[run].name);printf("进程状态:完成\n");printf("寄存器内容:\n");printf("AX: %d\n",AX);printf("BX: %d\n",BX);printf("CX: %d\n",CX);printf("DX: %d\n",DX);printf("PC: %d\n",PC);printf("PSW: %d\n",PSW);printf("TIME:%d\n\n",TIME);//将该进程控制块置入空闲队列if(pfree==-1){pfree=run;pcbarea[pfree].next=-1;}else{pcbarea[pfree].next=run;pfree=run;pcbarea[run].next=-1;}}//若进程还没执行完毕,则将其置入就绪队列,等待下次的时间片到来 else{ getchar();pcbarea[run].remainingTime-=TIME_PIECE;pcbarea[run].status=WAIT;- 4 -//将进程置入就绪队列中if(ready.tail!=-1)pcbarea[ready.tail].next=run;elseready.head=ready.tail=run;pcbarea[run].next=-1;ready.tail=run;//打印进程以及系统的状态信息printf("\n进程编号:%d\n",pcbarea[run].name);printf("进程状态:等待\n");printf("寄存器内容:\n");printf("AX: %d\n",AX);printf("BX: %d\n",BX);printf("CX: %d\n",CX);printf("DX: %d\n",DX);printf("PC: %d\n",PC);printf("PSW: %d\n",PSW);printf("TIME:%d\n\n",TIME);}Sheduling();//如果还有进程没有执行完毕,则继续递归调度}void main(){int process_name,ax,bx,cx,dx,pc,psw,totalTime;int i;char quit;//用于选择退出进程模拟系统do {i=MAX_PROCESS_NUM;printf("==========================模拟单处理器系统的进程调度==========================\n\n\n");Init();printf("**创建进程,输入负数可结束创建**\n\n");printf("输入一个进程的编号(现在还可以创建%d个进程):",i);scanf("%d",&process_name);while(process_name>0){printf("请输入该进程中ax、bx、cx、dx、pc、psw的初始现场信息:");scanf("%d%d%d%d%d%d",&ax,&bx,&cx,&dx,&pc,&psw);printf("请输入该进程运行所需的总时间:");scanf("%d",&totalTime);Create(process_name,ax,bx,cx,dx,pc,psw,totalTime);if(i>0)--i;- 5 -printf("输入一个进程的编号(现在还可以创建%d个进程):",i); scanf("%d",&process_name);}system("cls");printf("请按回车开始调度……");getchar();Sheduling();printf("退出请按0,重新测试请按任意键:");quit=getchar();system("cls");} while(quit!='0');printf("\n\n");}五、实验结果与分析测试样本数据如下:1 123456 102 234 3 4 6 153 4 2 5 3 2 3 204 3 2 2 3 3 2 10 -1- 6 -调度结果 1 4 2 3 - 7 -。
进程的调度实验报告(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. 设计进程调度算法,进程数不定2. 包含几种调度算法,并加以实现3. 输出进程的调度过程——进程的状态、链表等。
三、 参考例1.题目——优先权法、轮转法简化假设1) 进程为计算型的(无I/O )2) 进程状态:ready 、running 、finish3) 进程需要的CPU 时间以时间片为单位确定2.算法描述1) 优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。
2) 轮转法四、 实验流程图 开始 键盘输入进程数n ,和调度方法的选择 优先权法? 轮转法产生n 个进程,对每个进程产生一个PCB ,并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小,把n 个进程拉成一个就绪队列撤销进程就绪队列为空?结束 N YY注意:1.产生的各种随机数的取值范围加以限制,如所需的CPU 时间限制在1~20之间。
2.进程数n 不要太大通常取4~8个3.使用动态数据结构4.独立编程5.至少三种调度算法6.若有可能请在图形方式下,将PCB 的调度用图形成动画显示。
五.实验过程:要求:读懂下面给出的程序,然后将其改写成由用户选择调度方式,例如:1、 FIFO2、 优先权调度3、 时间片轮转4、 退出对于每一种调度算法,由用户确定进程数,数据可以从文件读取,也可由用户手动输入。
(1)输入:进程流文件(1.txt ),其中存储的是一系列要执行的进程, 每个作业包括四个数据项:进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1 产生n需的时间片数,已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0? 撤销该进程就绪队列为空吗? =轮转时间片数?NY YY 结束 N进程5 3 8 7输出: 进程执行流等待时间,平均等待时间本程序包括:FIFO算法,优先数调度算法,时间片轮转调度算法(2)程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time;}pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" \t"<<pcbs[i].status<<" \t"<<pcbs[i].time<<" \t"<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0;pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){pcbs[j].wait_time+=pcbs[i].time;}}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<< endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl; }//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){number++; j=i;}}if(number==1){queue[total]=j;total++;pcbs[j].finished=1;}if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){total--;}cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl;}//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){FIFO();init();privilege();init();timer();}}(3)运行结果:输入进程流文件名1.txt即可得出以下输出结果:。
大作业2_单处理器系统的进程调度
实验二单处理器系统的进程调度-编程实现采用优先数调度算法的进程调度1.实验目的加深对进程概念的理解,明确进程和程序的区别;深入了解系统如何组织进程、创建进程;进一步认识如何实现处理器调度。
2.实验预备知识进程的概念;进程的组织方式;进程的创建;进程的调度。
3.实验内容编写程序完成单处理机系统中的进程调度,要求采用时间片轮转调度算法。
实验具体包括:首先确定进程控制块的内容,进程控制块的组成方式;然后完成进程创建原语和进程调度原语;最后编写主函数对所作工作进程测试。
4.提示与讲解这个实验主要要考虑三个问题:如何组织进程、如何创建进程和如何实现处理器调度。
考虑如何组织进程,首先就要设定进程控制块的内容。
进程控制块PCB记录各个进程执行时的情况。
不同的操作系统,进程控制块记录的信息内容不一样。
操作系统功能越强,软件也越庞大,进程控制块记录的内容也就越多。
这里的实验只使用了必不可少的信息。
一般操作系统中,无论进程控制块中信息量多少,信息都可以大致分为以下四类:①标识信息每个进程都要有一个惟一的标识符,用来标识进程的存在和区别于其他进程。
这个标识符是必不可少的,可以用符号或编号实现,它必须是操作系统分配的。
在后面给出的参考程序中,采用编号方式,也就是为每个进程依次分配一个不相同的正整数。
②说明信息用于记录进程的基本情况,例如进程的状态、等待原因、进程程序存放位置、进程数据存放位置等等。
实验中,因为进程没有数据和程序,仅使用进程控制块模拟进程,所以这部分内容仅包括进程状态。
③现场信息现场信息记录各个寄存器的内容。
当进程由于某种原因让出处理器时,需要将现场信息记录在进程控制块中,当进行进程调度时,从选中进程的进程控制块中读取现场信息进行现场恢复。
现场信息就是处理器的相关寄存器内容,包括通用寄存器、程序计数器和程序状态字寄存器等。
在实验中,可选取几个寄存器作为代表。
用大写的全局变量AX、BX、CX、DX模拟通用寄存器、大写的全局变量PC模拟程序计数器、大写的全局变量PSW模拟程序状态字寄存器。
实验二-实验报告(进程管理)
实验二模拟实现进程管理组长:李和林软件1402一、实验目的1.理解进程的概念,明确进程和程序的区别。
2.理解并发执行的实质。
3.掌握进程的创建,睡眠,撤销等进程控制方法。
二、实验内容用C语言,JAVA语言,C++语言编写程序,模拟实现创建新的进程;查看运行进程,换出某个进程;杀死运行进程。
三、实验准备1.进程的定义进程是程序在一个数据集合上的运行过程,是系统资源分配和调度的一个独立单位。
一个程序在不同的数据集合上运行,乃至一个程序在同样数据集合上的多次运行都是不同的进程。
2.进程的状态通常情况下,一个进程必须具有就绪,执行和阻塞三种基本情况。
1)就绪状态当进程已分配到除处理器外的所有必要资源后,只要再获得处理器就可以立即执行,这时进程的状态就为就绪状态。
在一个系统里,可以有多个进程同时处于就绪状态,通常把这些就绪进程排成一个或多个队列,称为就绪队列。
2)执行状态处于就绪状态的进程一旦获得处理器,就可以运行,进程状态也就处于执行状态,在单处理器系统中,只能有一个进程处于执行状态,在多处理器系统中,则可能有多个进程处于执行状态3)阻塞状态正在执行的进程因为发生某些事件而暂停运行,这种受阻暂停的状态称为阻塞状态,也可称为等待状态。
通常将处于阻塞状态的进程拍成一个队列,称为阻塞队列,在有些系统中,也会按阻塞原因的不同将阻塞状态的进程排成多个队列。
3.进程状态之间的转换4.进程控制块1)进程控制块的作用进程控制块是进程实体的重要组成部分,主要包含下述四个方面的信息:a)进程标示信息b)说明信息c)现场信息d)管理信息5.进程控制块的组织方式1)链接方式2)索引方式6.进程控制原语1)创建原语2)撤销原语3)阻塞原语4)唤醒原语7.程序代码#include<stdio.h>#include<iostream>using namespace std;void clrscr();void create();void run( );void exchange( );//唤出void kill( );void wakeUp( );//唤醒struct process_type{int pid;int priority;//优先次序int size;int state;//状态char info[10];};struct process_type internalMemory[20];int amount=0,hangUp=0,pid,flag=0;//数目,挂起void main( ){int n;int a;n=1;clrscr( );while(n==1){cout<<"\n********************************************";cout<<"\n* 进程演示系统 *";cout<<"\n********************************************";cout<<"\n 1.创建新的进程 2.查看运行进程 ";cout<<"\n 3.换出某个进程 4.杀死运行进程 ";cout<<"\n 5.唤醒某个进程¨ 6.退出系统 ";cout<<"\n*********************************************"<<endl;cout<<"请选择 ";cin>>a;switch(a){case 1:create( );break;case 2:run( );break;case 3:exchange();//换出break;case 4:kill();break;case 5:wakeUp();break;case 6:exit(0);default:n=0;}}}void create(){ //创建进程int i=0;if (amount>=20){cout<<" 内存已满,请先结束或换出进程";}else{for (i=0;i<20;i++){if (internalMemory[i].state==0){break;}}cout<<"请输入新进程的pid: "<<endl;cin>>internalMemory[ i ].pid;cout<<"请输入新进程的优先级: "<<endl;cin>>internalMemory[amount].priority;cout<<"请输入新进程的大小: "<<endl;cin>>internalMemory[amount].size;cout<<"请输入新进程的内容: "<<endl;cin>>internalMemory[amount].info;internalMemory[i].state=1;amount++;}}void clrscr()//清除内存空间{for (int i=0;i<19;i++){internalMemory[i].pid=0;internalMemory[i].priority=0;internalMemory[i].size=0;internalMemory[i].state=0;}amount=0;}void run(){for (int i=0;i<20;i++){if (internalMemory[i].state==1){cout<<"当前内存中的进程:\n"<<endl;cout<<"当前运行的进程: ";cout<<internalMemory[i].pid<<endl;cout<<"当前运行进程的优先级: ";cout<<internalMemory[i].priority<<endl;cout<<"当前运行进程占用的空间大小: ";cout<<internalMemory[i].size;}}}void exchange( ){//唤出优先级最小的进程if (!amount){cout<<"当前没有运行进程\n";return;}cout<<"\n输入换出进程的ID值: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){if (internalMemory[i].state==1){internalMemory[i].state=2;hangUp++;cout<<"\n已经成功换出进程\n";}else if (internalMemory[i].state==0){cout<<"\n要换出的进程不存在";}else{cout<<"\n要换出的进程已被挂起\n";}flag=1;break;}}if (flag==0){cout<<"\n要换出的进程不存在";}}void kill( ){if (!amount){cout<<"当前没有运行进程\n";return;}cout<<"请输入要杀死的进程: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){if (internalMemory[i].state==1){internalMemory[i].state=0;amount--;cout<<"此进程被杀死"<<pid;}else if (internalMemory[i].state==0){cout<<"\n要杀死的进程不存在\n";}else{cout<<"\n要杀死的进程已被挂起\n";}flag=1;break;}}if (!flag){cout<<"\n要杀死的进程不存在\n";}}void wakeUp(){if (!amount){cout<<"当前没有运行进程"<<endl;return;}if (!hangUp){cout<<"当前没有挂起进程";return;}cout<<"请输入pid: ";cin>>pid;for (int i=0;i<20;i++){if (pid==internalMemory[i].pid){flag=0;if (internalMemory[i].state==2){internalMemory[i].state=1;hangUp--;cout<<"已经成功唤醒进程\n";}else if (internalMemory[i].state==0){cout<<"\n要换醒的进程不存在\n";}else{cout<<"\n要唤醒的进程已被挂起\n";}break;}}if (flag){cout<<"\n要唤醒的进程已被挂起\n"<<endl;}}8.实现的结果。
操作系统实验报告-单处理机系统的进程调度
实验二单处理机系统的进程调度一.实验目的(1)加深对进程概念的理解,明确进程与程序的区别。
(2)深入了解系统如何组织进程、创建进程。
(3)进一步认识如何实现处理机调度。
二.实验内容编写程序完成单处理机系统中的进程调度,要求采用时间片轮转调度算法。
三.实验原理在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.四.实验部分源程序#include<stdio.h>#include<time.h>#include<stdlib.h>/*********************以下是全局数据结构和变量***********************//*PCB 结构*/struct PCB{int pname;int pri;int runtime;int waittime;struct PCB *next;}pcb[7];struct PCB *running; /* 运行指针*/struct PCB *Hready; /*高优先级就绪队列头指针*/struct PCB *Lready; /*低优先级队列头指针*/struct PCB*wait; /*等待队列头指针*/int A=0;/**************************以下是函数说明****************************/ void delay(); /*利用循环实现延迟*/void proc(struct PCB *running); /*模拟进程3-9*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node); /*将node插入到head所指示的队列的尾部*/int proc_switch(); /*进程调度函数*/void proc_wait(); /*进程等待函数*/int proc_wakeup(); /*进程唤醒函数*//************************以下是函数定义及注释************************/ main() /*主函数*/{ int i;/*初始化,创建进程3-9,置低优先级,等待时间为0,依次插入低优先级队列*/for(i=0;i<3;i++){pcb[i].pname=i+3;pcb[i].pri=0;pcb[i].waittime=0;InsertIntoQueueTail(&Lready,&pcb[i]);}wait=NULL;Hready=NULL; /*等待队列和高优先级队列为空*/printf("\n模拟进程调度开始:\n"); /*模拟进程调度开始*/for(;;){ switch(A){case 0:/*无进程等待调度,打印信息并返回*/if(!proc_switch()){printf("/n没有进程在运行返回:\n");getchar(); }break;case 1:proc_wait();break;case 3:case 4:case 5:case 6:proc(running); break;default:printf("\nerror!");exit(-1); }}}/*功能:延迟一个时间片*//*入口参数:无*//*出口参数:无*/void delay(){ int i,j;for(i=0;i<20000;i++)for(j=0;j<10000;j++){}}/*功能:进程3-9*//*入口参数:运行指针*//*出口参数:无*/void proc(struct PCB * running){ int i;srand( (unsigned)time( NULL ) );/*显示当前运行的进程的id*/printf("\n现在进程%d 正在运行\n",running->pname);/*当前进程执行running->runtime个时间片*/for(i=running->runtime;i>0;i--){/*显示剩余的时间片*/printf("剩余的时间片为%d\n",i);/*延迟*/delay();proc_wakeup();/*产生一个1到1000的随机数,若该随机数小余300,当前进程等待,*/ if((rand()%1000+1)<300){printf("进程%d开始等待.\n",running->pname);A=1;return; }}/*显示时间片耗尽,进程转为低优先级就绪状态*/printf("进程%d时间片耗尽\n",running->pname);InsertIntoQueueTail(&Lready,running);A=0;return; }/*功能:将一个节点插入队列尾部*//*入口参数:队列头指针地址head,待插入结点node*//*出口参数:无*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node){ struct PCB *p;node->next=NULL;/*被插入队列为空*/if(*head==NULL){*head=node;return; }/*被插入队列不为空*/else{p=*head;/*找到队列的最后一个结点*/while(p->next!=NULL)p=p->next; p->next=node; }}/*功能:进程调度*//*入口参数:无*//*出口参数:若调度成功,返回1,否则返回0*/int proc_switch() {/*若高优先级就绪队列和低优先级就绪队列均为空,则循环执行进程唤醒*/while(Hready == NULL && Lready == NULL)if(!proc_wakeup()) return 0;/*若高优先级就绪队列非空,则执行其第一个进程,分配2个时间片*/if(Hready!=NULL){running=Hready;Hready=Hready->next;running->runtime=2; }/*若高优先级就绪队列为空,则执行低优先级就绪队列的第一个进程,分配5个时间片*/else{running=Lready;Lready=Lready->next;running->runtime=5; }/*把调度进程的id赋给A*/A=running->pname;return 1; }/*功能:进程等待。
进程调度实验报告
实验项目:进程调度学院:计算机学院专业:班级:学号:姓名: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)进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运行的进程。
操作系统实验二进程调度
操作系统实验二进程调度摘要:进程调度是操作系统中重要的功能之一,可以决定进程的优先级和执行顺序。
本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。
一、概念介绍进程调度是操作系统中的一项重要功能,用于决定哪个进程能够在处理器上运行。
在操作系统中存在多个进程需要同时运行,而处理器资源有限,因此需要通过进程调度来合理地安排进程的执行顺序,提高系统的效率。
进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。
常见的调度策略包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转、优先级调度等。
二、调度算法介绍1.先来先服务(FCFS)先来先服务(FCFS)是最简单的调度算法,按照进程到达的顺序进行调度,先到达的进程先执行。
FCFS算法不考虑进程的优先级和执行时间,容易导致平均等待时间长。
2.最短作业优先(SJF)最短作业优先(SJF)调度算法按照进程所需的CPU时间进行排序,优先调度所需时间最短的进程。
SJF算法可以减少平均等待时间,但可能会导致长作业等待时间过长。
3.时间片轮转时间片轮转是一种抢占式调度策略,将处理器的使用权分割为若干个时间片,每个进程在一个时间片内运行,如果时间片用完仍未运行完,则将该进程放到队列的末尾,并让下一个进程运行。
时间片轮转算法保证了公平性和响应时间,但可能会导致上下文切换次数过多。
4.优先级调度优先级调度是根据进程的优先级进行调度,优先级高的进程先执行。
优先级可以根据进程类型、实时性等因素确定,不同的操作系统可能有不同的优先级范围和策略。
三、实验步骤1.定义进程结构:定义进程结构体,包含进程ID、进程状态、优先级、执行时间等信息。
2.初始化进程队列:将所有进程按照到达的先后顺序加入到进程队列中。
3.实现调度算法:根据不同的调度算法,实现相应的进程调度算法代码。
可以使用循环遍历进程队列,并根据不同的调度策略决定下一个要执行的进程。
4.执行进程调度:在每个时间片结束后,根据调度算法选取下一个要执行的进程,并更新进程的状态和执行时间。
实验二 单处理器系统的进程调度
实验二单处理器系统的进程调度(附实验报告)1.实验目的加深对进程概念的理解,明确进程和程序的区别;深入了解系统如何组织进程、创建进程;进一步认识如何实现处理器调度。
2.实验预备知识进程的概念;进程的组织方式;进程的创建;进程的调度。
3.实验内容编写程序完成单处理机系统中的进程调度,要求采用时间片轮转调度算法。
实验具体包括:首先确定进程控制块的内容,进程控制块的组成方式;然后完成进程创建原语和进程调度原语;最后编写主函数对所作工作进程测试。
4.提示与讲解这个实验主要要考虑三个问题:如何组织进程、如何创建进程和如何实现处理器调度。
考虑如何组织进程,首先就要设定进程控制块的内容。
进程控制块PCB 记录各个进程执行时的情况。
不同的操作系统,进程控制块记录的信息内容不一样。
操作系统功能越强,软件也越庞大,进程控制块记录的内容也就越多。
这里的实验只使用了必不可少的信息。
一般操作系统中,无论进程控制块中信息量多少,信息都可以大致分为以下四类:①标识信息每个进程都要有一个惟一的标识符,用来标识进程的存在和区别于其他进程。
这个标识符是必不可少的,可以用符号或编号实现,它必须是操作系统分配的。
在后面给出的参考程序中,采用编号方式,也就是为每个进程依次分配一个不相同的正整数。
②说明信息用于记录进程的基本情况,例如进程的状态、等待原因、进程程序存放位置、进程数据存放位置等等。
实验中,因为进程没有数据和程序,仅使用进程控制块模拟进程,所以这部分内容仅包括进程状态。
③现场信息现场信息记录各个寄存器的内容。
当进程由于某种原因让出处理器时,需要将现场信息记录在进程控制块中,当进行进程调度时,从选中进程的进程控制块中读取现场信息进行现场恢复。
现场信息就是处理器的相关寄存器内容,包括通用寄存器、程序计数器和程序状态字寄存器等。
在实验中,可选取几个寄存器作为代表。
用大写的全局变量AX、BX、CX、DX模拟通用寄存器、大写的全局变量PC模拟程序计数器、大写的全局变量PSW模拟程序状态字寄存器。
单处理器系统的进程调度
一.一、单处理器系统的进程调度1.实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。
2.实验内容与要求(1)设计多个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
(2)模拟调度程序可任选两种调度算法之一实现。
(3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
3.实验说明设计一个按优先数调度算法实现处理器调度的程序。
(1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:其中,进程名——作为进程的标识,假设五个进程的进程名分别为P1,P2,P3,P4,P5。
指针——按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态,“就绪”状态和“结束”状态。
五个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。
(3) 为了调度方便,把五个进程按给定的优先数从大到小连成队列。
用一单元指出队首进程,用指针指出队列的连接情况。
例:队首标志K2K 1K2K3K4 K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选队首进程运行。
采用动态改变优先数的办法,进程每运行一次优先数就减“1”。
由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:优先数-1要求运行时间-1来模拟进程的一次运行。
提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行结束。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验二单处理器系统的进程调度(附实验报告)1.实验目的加深对进程概念的理解,明确进程和程序的区别;深入了解系统如何组织进程、创建进程;进一步认识如何实现处理器调度。
2.实验预备知识进程的概念;进程的组织方式;进程的创建;进程的调度。
3.实验内容编写程序完成单处理机系统中的进程调度,要求采用时间片轮转调度算法。
实验具体包括:首先确定进程控制块的内容,进程控制块的组成方式;然后完成进程创建原语和进程调度原语;最后编写主函数对所作工作进程测试。
4.提示与讲解这个实验主要要考虑三个问题:如何组织进程、如何创建进程和如何实现处理器调度。
考虑如何组织进程,首先就要设定进程控制块的内容。
进程控制块PCB 记录各个进程执行时的情况。
不同的操作系统,进程控制块记录的信息内容不一样。
操作系统功能越强,软件也越庞大,进程控制块记录的内容也就越多。
这里的实验只使用了必不可少的信息。
一般操作系统中,无论进程控制块中信息量多少,信息都可以大致分为以下四类:①标识信息每个进程都要有一个惟一的标识符,用来标识进程的存在和区别于其他进程。
这个标识符是必不可少的,可以用符号或编号实现,它必须是操作系统分配的。
在后面给出的参考程序中,采用编号方式,也就是为每个进程依次分配一个不相同的正整数。
②说明信息用于记录进程的基本情况,例如进程的状态、等待原因、进程程序存放位置、进程数据存放位置等等。
实验中,因为进程没有数据和程序,仅使用进程控制块模拟进程,所以这部分内容仅包括进程状态。
③现场信息现场信息记录各个寄存器的内容。
当进程由于某种原因让出处理器时,需要将现场信息记录在进程控制块中,当进行进程调度时,从选中进程的进程控制块中读取现场信息进行现场恢复。
现场信息就是处理器的相关寄存器内容,包括通用寄存器、程序计数器和程序状态字寄存器等。
在实验中,可选取几个寄存器作为代表。
用大写的全局变量AX、BX、CX、DX模拟通用寄存器、大写的全局变量PC模拟程序计数器、大写的全局变量PSW模拟程序状态字寄存器。
④管理信息管理信息记录进程管理和调度的信息。
例如进程优先数、进程队列指针等。
实验中,仅包括队列指针。
因此可将进程控制块结构定义如下:struct pcb{int name;int status;int ax, bx, cx,dx;int pc;int psw;int next;}确定进程控制块内容后,要考虑的就是如何将进程控制块组织在一起。
多道程序设计系统中,往往同时创建多个进程。
在单处理器的情况下,每次只能有一个进程处于运行态,其他的进程处于就绪状态或等待状态。
为了便于管理,通常把处于相同状态的进程的进程控制块链接在一起。
单处理器系统中,正在运行的进程只有一个。
因此,单处理器系统中进程控制块分成一个正在运行进程的进程控制块、就绪进程的进程控制块组织成的就绪队列和等待进程的进程控制块组成的等待队列。
由于实验模拟的是进程调度,没有对等待队列的操作,所以实验中只有一个指向正在运行进程的进程控制块指针和一个就绪进程的进程控制块队列指针。
操作系统的实现中,系统往往在主存中划分出一个连续的专门区域存放系统的进程控制块,实验中应该用数组模拟这个专门的进程控制块区域,定义如下:#define n 10struct pcb pcbarea[n];这样,进程控制块的链表实际上是数据结构中使用的静态链表。
进程控制块的链接方式可以采用单向和双向链表,实验中,进程控制块队列采用单向不循环静态链表。
为了管理空闲进程控制块,还应该将空闲控制块链接成一个队列。
实验中采用时间片轮转调度算法,这种算法是将进程控制块按照进入就绪队列的先后次序排成队列。
关于就绪队列的操作就是从队头摘下一个进程控制块和从队尾挂入一个进程控制块。
因此为就绪队列定义两个指针,一个头指针,指向就绪队列的第一个进程控制块;一个尾指针,指向就绪队列的最后一个进程控制块。
实验中指向运行进程的进程控制块指针、就绪队列指针和空闲进程控制块队列指针定义如下:int run;struct{int head;int tail;}ready;int pfree;以上是如何组织进程,下面考虑如何创建进程。
进程创建是一个原语,因此在实验中应该用一个函数实现,进程创建的过程应该包括:①申请进程控制块:进程控制块的数量是有限的,如果没有空闲进程控制块,则进程不能创建,如果申请成功才可以执行第②步;②申请资源:除了进程控制块外,还需要有必要的资源才能创建进程,如果申请资源不成功,则不能创建进程,并且归还已申请的进程控制块;如果申请成功,则执行第三步,实验无法申请资源,所以模拟程序忽略了申请资源这一步;③填写进程控制块:将该进程信息写入进程控制块内,实验中只有进程标识符、进程状态可以填写,每个进程现场信息中的寄存器内容由于没有具体数据而使用进程(模拟进程创建时,需输入进程标识符字,进程标识符本应系统建立,并且是惟一的,输入时注意不要冲突),刚刚创建的进程应该为就绪态,然后转去执行第四步;④挂入就绪队列:如果原来就绪队列不为空,则将该进程控制块挂入就绪队列尾部,并修改就绪队列尾部指针;如果原来就绪队列为空,则将就绪队列的头指针、尾指针均指向该进程控制块,进程创建完成。
进程创建流程图如图2.2所示。
多道程序设计的系统中,处于就绪态的进程往往是多个,它们都要求占用处理器,可是单处理器系统的处理器只有一个,进程调度就是解决这个处理器竞争问题的。
进程调度的任务就是按照某种算法从就绪进程队列中选择一个进程,让它占有处理器。
因此进程调度程序就应该包括两部分,一部分是在进程就绪队列中选择一个进程,并将其进程控制块从进程就绪队列中摘下来,另一部分工作就是分配处理器给选中的进程,也就是将指向正在运行进程的进程控制块指针指向该进程的进程控制块,并将该进程的进程控制块信息写入处理器的各个寄存器中。
图2.2 进程创建流程图实验中采用时间片轮转调度算法。
时间片轮转调度算法让就绪进程按就绪的先后次序排成队列,每次总是选择就绪队列中的第一个进程占有处理器,但是规定只能使用一个“时间片”。
时间片就是规定进程一次使用处理器的最长时间。
实验中采用每个进程都使用相同的不变的时间片。
采用时间片轮转调度算法的进程调度流程图如图2.3所示。
完成上述功能后,编写主函数进行测试:首先建立一个就绪队列,手工输入信息建立几个进程;然后进行进程调度;最后将指向正在运行进程的指针指向的进程控制块的内容输出,察看结果。
图2.3 进程调度流程图5.课外题编程实现采用优先数调度算法的进程调度。
我的实现代码(C语言):#include <stdio.h>#define N 10 //系统中所允许的最大进程数量#define SLOT 5 //时间片大小//进程状态枚举typedef enum{Running, //运行状态Aready, //就绪状态Blocking //阻塞状态} ProStatus;//进程控制块typedef struct{int name; //进程标识符ProStatus status; //进程状态int ax,bx,cx,dx; //通用寄存器int pc; //程序计数器寄存器int psw; //程序状态字寄存器int next; //指向下一个进程的指针} PCB;//就绪队列指针typedef struct{int head; //头指针int tail; //尾指针} Ready;//模拟寄存器int PSW,AX,BX,CX,DX,PC,TIME;//PCB的静态链表PCB pcbArea[N]; //模拟PCB区域的数组int run; //运行状态程序的指针Ready ready; //就绪队列指针int pfree; //空闲队列的指针//初始化运行状态进程指针void InitRun(){run=-1;}//初始化就绪状态队列void InitReady(){ready.head=ready.tail=-1;}//初始化空闲队列void InitFree(){int temp;for(temp=0;temp<N-1;temp++)pcbArea[temp].next=temp+1;}pcbArea[temp].next=-1;pfree=0;}//就绪队列出队int PopReady() //返回结点在PCB区域数组的编号{int temp;if(ready.head==-1){printf("就绪队列为空,不能出队。
\n");return -1;}temp=ready.head;ready.head=pcbArea[temp].next;if(ready.head==-1)ready.tail=-1;pcbArea[temp].next=-1;return temp;}//空闲队列出队int PopFree() //返回结点在PCB区域数组的编号{int temp;if(pfree==-1)printf("空闲队列为空,不能出队。
\n");return -1;}temp=pfree;pfree=pcbArea[temp].next;pcbArea[temp].next=-1;return temp;}//就绪队列入队void PushReady(int x) //x为入队结点的编号{int temp;if(ready.head==-1){ready.head=x;ready.tail=x;}else{temp=ready.tail;ready.tail=x;}pcbArea[ready.tail].next=-1;}//创建PCBvoid CreatePCB(int x,PCB pcb) //x为要创建PCB在PCB区域数组的编号pcbArea[x].ax=pcb.ax;pcbArea[x].bx=pcb.bx;pcbArea[x].cx=pcb.cx;pcbArea[x].dx=pcb.dx;pcbArea[x].name=;pcbArea[x].next=-1;pcbArea[x].pc=pcb.pc;pcbArea[x].psw=pcb.psw;pcbArea[x].status=pcb.status;}//创建进程函数void Create(PCB pcb){int temp;if(pfree==-1){printf("空闲队列为空,不能创建进程。
\n"); return;}temp=PopFree();pcb.status=Aready;CreatePCB(temp,pcb);PushReady(temp);}//进程调度函数void Schedule(){int temp;if(ready.head==-1){printf("系统内没有进程可以调度。