FIFO页面调度算法处理缺页中断要点

FIFO页面调度算法处理缺页中断要点
FIFO页面调度算法处理缺页中断要点

计算机科学与技术系

实验报告

专业名称网络工程

课程名称操作系统原理

项目名称FIFO页面调度算法处理缺页中断

班级 12网络工程(1)班

学号 1204031030

姓名方彬

同组人员朱佳宝、王卫、凌含涛、胡星瑞

实验日期 2014.12.02

一、实验目的与要求:

(1)熟悉、掌握先进先出FIFO算法,并实现用先进先出FIFO算法页面调度算法处理缺页中断.

(2)理解基于先进先出FIFO的内存管理调度算法,更好的掌握算法的思想,结合实验理解算法更直观,深刻具体。通过对先进先出FIFO的调度算法的模拟实验可以清楚的了解内存管理是如何调度的,以及加深对内存管理的了解。

二、实验内容

1)任务分析:以无歧义的陈述说明实验任务,并明确规定:

(a)输入的形式和输入值的范围;

在输入文本框中输入,输入值的范围在0~6之间

(b) 输出的形式;

输出为缺页序列的表格

(c) 程序所能达到的功能;

输入页号,输出缺页序列,实现先进先出算法的模拟

(d) 测试数据:包括正确的输入及其输出结果和错误的输入及其输出结果。

①输入值为空:

②输入值越界:

③正确的输入值:

2)概要设计:说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。

本程序中定义了一个数组int[] mainstore = {3,2,1,0 };用于模拟主存存放页;此外还定义了一个数组int[] flag = {0,0,0,0,0,0,0 };用于表明页号的修改标志位,便于之后的操作。

该程序的只要流程如下:

3)详细设计:实现概要设计中定义的所有数据类型,对每个操作只需要写出伪码算法;对主程序和其他模块也都需要写出伪码算法(伪码算法达到的详细程度建议为:按照伪码算法可以在计算机键盘直接输入高级程序设计语言程序);画出函数和过程的调用关系图。

using System;

using System.Collections.Generic;

using https://www.360docs.net/doc/7117769725.html,ponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

using lru;

using change;

namespace 操作系统

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}//定义一个窗口类,在类里面定义一个窗口

int[] mainstore = {3,2,1,0 };//定义数组用于存放页

int[] flag = {0,0,0,0,0,0,0 };//定义修改标志位的数组

int blo = 0;//用来控制在表格的哪一列输出页号序列

private void button1_Click(object sender, EventArgs e)//定义一个事件响应,即对输入进行操作

{

if (string.IsNullOrEmpty(txt.Text))

MessageBox.Show("请输入页号!");

else if (int.Parse(txt.Text) > 6 || int.Parse(txt.Text) < 0)

MessageBox.Show("输入页号不合法,请重新输入!");

//判断输入是否合法

else

{

int page = int.Parse(txt.Text);

int i=0;

if (page != mainstore[0] && page != mainstore[1] && page != mainstore[2] && page != mainstore[3])//插入页内存中不存在,进行FIFO算法

{

int lll;

lll = mainstore[0];

if (flag[mainstore[0]] == 0)//修改标志位为0,直接覆盖

{

mainstore[0] = page;

flag[lll] = 1;

}

Else//修改标志位为1,数组执行FIFO

{

for (i = 0; i < 3; i++)

mainstore[i] = mainstore[i + 1];

mainstore[3] = page;

}

MessageBox.Show("当前调走页号"+lll.ToString ()+"\n存入页号为"+page.ToString ());

l0.Text = "0";

l1.Text = "0";

l2.Text = "0";

l3.Text = "0";

l4.Text = "0";

l5.Text = "0";

l6.Text = "0";

//标志位初始化;

for (int j = 0; j < 4; j++)

{

if (mainstore[j] == 0)

l0.Text = "1";

if (mainstore[j] == 1)

l1.Text = "1";

if (mainstore[j] == 2)

l2.Text = "1";

if (mainstore[j] == 3)

l3.Text = "1";

if (mainstore[j] == 4)

l4.Text = "1";

if (mainstore[j] == 5)

l5.Text = "1";

if (mainstore[j] == 6)

l6.Text = "1";

}//根据插入页号,将标志位置1

for (int k = 0;k < 7; k++)

{

if (lll == 0)

ll0.Text = "1";

if (lll == 1)

ll1.Text = "1";

if (lll == 2)

ll2.Text = "1";

if (lll == 3)

ll3.Text = "1";

if (lll == 4)

ll4.Text = "1";

if (lll == 5)

ll5.Text = "1";

if (lll == 6)

ll6.Text = "1";

}//根据情况,将修改标志位置1

}

else

{

MessageBox.Show("该页已在主存中!" );

}

blo++;

if(blo==1){

txt10.Text = mainstore[0].ToString();

txt11.Text = mainstore[1].ToString();

txt12.Text = mainstore[2].ToString();

txt13.Text = mainstore[3].ToString();}

else if(blo==2){

txt20.Text = mainstore[0].ToString();

txt21.Text = mainstore[1].ToString();

txt22.Text = mainstore[2].ToString();

txt23.Text = mainstore[3].ToString();

}

else if(blo==3){

txt30.Text = mainstore[0].ToString();

txt31.Text = mainstore[1].ToString();

txt32.Text = mainstore[2].ToString();

txt33.Text = mainstore[3].ToString();

}

else if(blo==4){

txt40.Text = mainstore[0].ToString();

txt41.Text = mainstore[1].ToString();

txt42.Text = mainstore[2].ToString();

txt43.Text = mainstore[3].ToString();}

else if(blo==5){

txt50.Text = mainstore[0].ToString();

txt51.Text = mainstore[1].ToString();

txt52.Text = mainstore[2].ToString();

txt53.Text = mainstore[3].ToString();}

else if(blo==6){

txt60.Text = mainstore[0].ToString();

txt61.Text = mainstore[1].ToString();

txt62.Text = mainstore[2].ToString();

txt63.Text = mainstore[3].ToString();}

else if(blo==7){

txt70.Text = mainstore[0].ToString();

txt71.Text = mainstore[1].ToString();

txt72.Text = mainstore[2].ToString();

txt73.Text = mainstore[3].ToString();}

else if(blo==8){

txt80.Text = mainstore[0].ToString();

txt81.Text = mainstore[1].ToString();

txt82.Text = mainstore[2].ToString();

txt83.Text = mainstore[3].ToString();}

//根据插入数量,决定在输出表的指定列输出

}

}

private void 刷新ToolStripMenuItem_Click(object sender, EventArgs e)

{

Form1 the_new = new Form1();

the_new.Show();

}

private void 退出ToolStripMenuItem_Click(object sender, EventArgs e)

{

this.Close();

}

4)调试分析:

(a)调试过程中遇到哪些问题,是如何解决的;

Q1:一开始的程序只能输入9个页号序列,超过之后就不能够再显示新的页号序列;(定义了一个变量BLO,用于记录输入页号数量,做求模运算mod 9,这样当超过九个之后又会从第一列开始覆盖)

Q2:考虑到程序的用户友好性,增加了序列刷新功能,刷新输出区域;(定义了一个button,点击后将输出区域初始化)

Q3:开始没有理解修改标志位的作用,所以功能没有实现;(经过与同

学的讨论,定义了一个数组flag[],将页号作为flag[]的下标选择置1或置0)

(b) 算法的时空分析:算法的时间复杂度和空间复杂度分析;

5)测试结果:包括输入和输出,测试数据应该完整和严格。

①输入页号为5,则存入页号为5,调出页号为3

②因为此时3的修改标志为0,所以插入的页直接覆盖;

3被调出到磁盘,则修改标志置1;

③输入页号为3,则存入页号为3,调出页号为5

④因为此时5的修改标志为0,所以插入的页直接覆盖

5被调出到磁盘,则修改标志置1;

⑤输入页号为4,则存入页号为4,调出页号为3

④因为此时3的修改标志为1,所以FIFO,执行出队列,4入队;

6)使用说明:如何使用编写的程序,详细列出每一步的操作步骤。

操作界面如上图所示:

操作步骤如下:

①打开“操作系统.exe”,弹出程序界面

②在页号输入框中输入页号,点击“插入”按钮

③在输出表格中显示执行后的页号序列,同时标志位,修改标志位会相应发

生改变

三、实验分析与小结

请求分页存储管理是目前最常用的一种实现虚拟存储器的方式。每当所要访问的页面不在内存时,便产生一缺页中断,请求OS将所缺之页调入内存。如果内存已无空闲空间,应该将哪个页面调出,须根据一定的算法来确定。先进先出(FIFO)是最早出现的页面置换算法,该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。

本次实验是通过模拟FIFO(先进先出)调度算法处理缺页中断,主要思想是先把进程调入页面,按次序链接成一个队列,并设置指针一直指向相对最先进入主存的页面。然后将该页面调出,调入输入的页面。通过对先进先出FIFO算法的模拟实现,我加深了对内存管理调度的理解,理解了其如何调度分配内存的过程。实验通过c#语言编写完成。因为c#语言是以前没学过的,现在用起来比较生疏,所以在实验的过程中出现了许多错误。面对这些问题,我们小组成员通过查阅资料、询问同学等方式解决各个问题,最终我们编写出了正确的FIFO页面置换算法的模拟程序。

此次实验作业的学习,不仅让我体会到c#语言等此类基础知识的重要性,也让我体会到团队合作的重要性,同时,最重要的收获就是对FIFO页面置换算法有了更直观深刻的认识和了解。在日后的学习中我会记住此次实验的收获,并付诸于行动!

四、其它

(带注释的程序清单)

得分(百分制)

虚拟存储管理器的页面调度算法实现

三、虚拟存储管理器的页面调度 页面调度算法主要有:FIFO,最近最少使用调度算法(LRU),最近最不常用调度算法(LFU),最佳算法(OPT) 1.输入: 页面流文件,其中存储的是一系列页面号(页面号用整数表示,用空格作为分隔符),用来模拟待换入的页面。 下面是一个示意: 1 2 3 4 1 2 5 1 2 3 4 5 2.处理要求: 程序运行时,首先提示“请输入页面流文件的文件名:”,输入一个文件名后,程序将读入该文件中的有关数据。 初始条件:采用三个页框,初始时均为空。 根据第二次机会算法对数据进行处理。 3.输出要求: 每换入一个页面(即:每读入一个页面号),判断是否有页面需要被换出。若有,把被换出的页面号输出到屏幕上; 若没有,则输出一个“*”号。 4.文件名约定 提交的源程序名字:sourceXXX.c或者sourceXXX.cpp(依据所用语言确定) 输入文件名字:可由用户指定 其中:XXX为账号。 5.测试说明:测试教师将事先准备好一组文件(格式为*.txt),从中为每个程序随机指定一至三个作为输入文件 (被测试者需从键盘输入指定文件的文件名),并查看程序输出结果。 6.第二次机会算法:对FIFO算法做如下简单的修改:发生替换时,先检查最老页面的R(访问)位。如果为0, 那么此页面是最早被换入的,而且近期没有被访问,可以立刻被替换掉;如果R位为1,就清除R位,并修改它的装入时间, 使它就像刚被装入的新页面一样,然后继续搜索可替换的最老页面。 我没做出来~~~~ 页面调度算法主要有:FIFO,最近最少使用调度算法(LRU),最近最不常用调度算法(LFU),最佳算法(OPT) 这几种算法的调度都有可能在考试中碰到。 关于这一类型,大家还可以参看书本251页的实验指导。 如2001年考题: 要求: 1。实现三种算法: FIFO,最近最少使用调度算法(LRU),最近最不常用调度算法(LFU) 2。页面序列从指定的文本文件(TXT文件)中取出

处理器调度习题

处理器调度 选择题 当CPU执行操作系统代码时,则处理机处于( )。 A.执行态 B.目态 C.管态 D.就绪态 ( )是机器指令的扩充,是硬件的首次延伸,是加在硬件上的第一层软件。 A.系统调用 B.操作系统 C.内核 D.特权指令 操作系统提供给程序员的接口是( )。 A.进程 B.系统调用 C.库函数 D.B和C 用户程序向系统提出使用外设的请求方式是( )。 A.作业申请 B.原语 C.系统调用 D.I/O指令 当作业正常完成进入完成状态时,操作系统( )。 A.将输出该作业的结果并删除内存中的作业 B.将收回该作业的所占资源并输出结果 C.将收回该作业的所占资源及输出结果,并删除该作业 D.将收回该作业的所占资源及输出结果,并将它的控制块从当前的队列中删除 下列选项是关于作业和进程关系的描述,其中哪一个是不正确的( )。 A.作业的概念主要用在批处理系统中,而进程的概念则用在几乎所有的OS中。 B.作业是比进程低一级的概念。 C.一个作业至少由一个进程组成。 D.作业是用户向计算机提交任务的实体,而进程是完成用户任务的执行实体以及向系统申请分配资源的基本单位。 作业从后备作业到被调度程序选中的时间称为( )。 周转时间B.响应时间C.等待调度时间D.运行时间 设有三个作业J1,J2,J3,它们同时到达,运行时间分别为T1,T2,T3,且T1≤T2≤T3,若它们在一台处理机上按单道运行,采用短作业优先算法,则平均周转时间为( )。 A.T1+T2+T3 B.1/3(T1+T2+T3) C.T1+2/3T2+1/3T3 D.T1+1/3T2+2/3T3 从作业提交给系统到作业完成的时间间隔称为作业的( )。 A.中断时间 B.等待时间 C.周转时间 D.响应时间 设有四个作业同时到达,每个作业执行时间均为2 h,它们在一台处理机上按单道方式运行,则平均周转时间为( )。 A.1 h B.5 h C.2.5 h D.8 h FCFS调度算法有利于( )。 A.长作业和CPU繁忙型作业 B.长作业和I/O繁忙型作业 C.短作业和CPU繁忙型作业 D.短作业和I/O繁忙型作业 下列哪种说法不是SJ(P)F调度算法的缺点( )。 A.对于长作业(进程)不利 B.未考虑作业(进程)的紧迫程度 C.不能有效降低作业(进程)的平均等待时间 D.由于根据的是用户提供的估计执行时间,因此不一定真正做到短而优先。 选择排队进程中等待时间最长的进程被优先调度,该调度算法是( )。 A.先来先服务调度算法B.短进程优先调度算法 C.优先权调度算法D.高响应比优先调度算法 在采用动态优先权的优先权调度算法中,如果所有进程都具有相同优先权初值,则此时的优先权调度算法实际上和( )相同。

模拟请求页式存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断

实验报告 课程名称操作系统原理实验名称虚拟页式管理 姓名学号专业班级网络 实验日期成绩指导教师赵安科 (①实验目的②实验原理③主要仪器设备④实验内容与步骤⑤实验数据记录与处理⑥实验结果与分析⑦问题建议) 实验二模拟请求页式存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断 1.内容:模拟请求页式存储管理中硬件的地址转换和缺页中断处理 2.思想: 装入新页置换旧页时,若旧页在执行中没有被修改过,则不必将该页重写磁盘。因此,页表中增加是否修改过的标志,执行“存”指令和“写”指令时将对应的修改标志置成“1” 3.要求及方法: ①设计一个地址转换程序来模拟硬件的地址转换和缺页中断。当访问的页在主存时则形成绝对地址,但不去模拟指令的执行,可以输出转换后的绝对地址来表示一条指令已执行完成。当访问的页不在主存中时,则输出“*页号”来表示硬件产生了一次缺页中断。模拟地址转换流程见图1。 ②编制一个FIFO页面调度程序;FIFO页面调度算法总是先调出作业中最先进入主存中的哪一页。因此可以用一个数组来表示(或构成)页号队列。数组中每个元素是该作业已在主存中的页面号,假定分配给作业的页架数为m,且该作业开始的m页已装入主存,则数组可由m个元素构成。 P[0],P[1],P[2],…,P[m-1] 它们的初值为P[0]:=0,P[1]:=1,P[2]:=2,…,P[m-1]:=m-1 用一指针K指示当要调入新页时应调出的页在数组中的位置,K的初值为“0”,当产生缺页

中断后,操作系统总是选择P[K]所指出的页面调出,然后执行: P[K]:=要装入的新页页号 K :=(k+1)mod m 在实验中不必实际地启动磁盘执行调出一页和装入一页的工作,而用输出“OUT 调出的页号”和“IN 要装入的新页页号”来模拟一次调出和装入过程,模拟程序的流程图见附图1。 按流程控制过程如下: 提示:输入指令的页号和页内偏移和是否存指令?? ? 0 1非存指令存指令,若d 为-1则结束,否则进 入流程控制过程,得P 1和d ,查表在主存时,绝对地址=P 1×1024+d ③ 假定主存中页架大小为1024个字节,现有一个共7页的作业,其副本已在磁盘上。系统为该作业分配了4个页架,且该作业的第0页至第3页已装入内存,其余3页未装入主 依次执行上述指令调试你所设计的程序(仅模拟指令的执行,不考虑序列中具体操作的执行)。

实验五-页面调度算法模拟实验报告

《计算机操作系统》实验报告 实验五:页面调度算法模拟 学校:╳╳╳ 院系:╳╳╳ 班级:╳╳╳ 姓名:╳╳╳ 学号:╳╳╳

指导教师:╳╳╳ 目录 一、实验题目 (3) 二、实验学时 (4) 三、指导老师 (4) 四、实验日期 (4) 五、实验目的 (4) 六、实验原理 (4) 6.1页面的含义 (4) 6.2 页面置换算法的含义 (4) 6.3 置换算法 (4) 6.3.1最佳置换算法(Optimal) (5) 6.3.2先进先出(FIFO)页面置换算法 (5) 6.3.3 LRU置换算法 (5) 七、实验步骤及结果 (5)

7.1 验证最佳置换算法 (5) 7.1.1 实验截图 (5) 7.1.2 实验分析 (6) 7.2 验证先进先出(FIFO)页面置换算法 (7) 7.2.1 实验截图 (7) 7.2.2 实验分析 (7) 7.3 验证LRU置换算法 (8) 7.3.1 实验截图 (8) 7.3.2 实验分析 (8) 八、报告书写人 (9) 附录一最佳置换算法(Optimal) (9) 附录二先进先出(FIFO)页面置换算法 (15) 附录三LRU置换算法 (20) 实验五:页面调度算法模拟 一、实验题目 页面调度算法模拟

二、实验学时 2学时 三、指导老师 ╳╳╳ 四、实验日期 2018年12月10日星期一 五、实验目的 (1)熟悉操作系统页面调度算法 (2)编写程序模拟先进先出、LRU等页面调度算法,体会页面调度算法原理 六、实验原理 6.1页面的含义 分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片,称为页面或页。 6.2 页面置换算法的含义 在进程运行过程中,若其所要访问的页面不在内存而需把它们调入内存,但内存已无空闲空间时,为了保证该进程能正常运行,系统必须从内存中调出一页程序或数据,送磁盘的对换区中。但应将哪个页面调出,须根据一定的算法来确定。通常,把选择换出页面的算法称为页面置换算法(Page_Replacement Algorithms)。 6.3 置换算法 一个好的页面置换算法,应具有较低的页面更换频率。从理论上讲,应将那些以后不再会访问的页面换出,或将那些在较长时间内不会再访问的页面调出。

C语言模拟CPU调度

C语言模拟CPU调度 C语言模拟CPU调度 CPU在处理多个进程时,要根据各种情况对处理的进程进行调度。这其中就包括对各个进程优先级的处理,和调度算法的处理。下面这个C语言程序,是我在大学期间学习《操作系统》课程的CPU调度时编写的,模拟了CPU的两种调度模式和各种模式所对应的多种调度算法。为了模拟得更为形象,采用了图形屏幕输出。 #include<stdlib.h> #include<stdio.h> #include<conio.h> #include<graphics.h> #include<math.h> #include<dos.h> #define NULL 0 /*-----------------------------------------------------------------*/ struct event /*事件结点结构*/ { int evtype; /*1:进程产生。2:进程执行。3:激

活阻塞进程。 4:进程执行完5:进程阻塞* 6:返回事件*/ int pnum; /*执行该事件的进程号*/ int t; /*事件发生的时间*/ int ifblock; /*如果是执行事件标准其有无阻塞,其它事件时无定义*/ struct event *next; }; struct process /*进程结点结构*/ { int pnum; /*进程号*/ int plong; /*进程长度*/ int prior; /*进程优先级*/ int blocknum; /*进程当前的阻塞数*/ int runtime; /*执行次数*/ struct process *next; }; struct headnod /*队列头结点结构*/ { struct process *head; /*队列头*/ int totalpro; /*队列中的进程数*/

进程调度算法实验报告

操作系统实验报告(二) 实验题目:进程调度算法 实验环境:C++ 实验目的:编程模拟实现几种常见的进程调度算法,通过对几组进程分别使用不同的调度算法,计算进程的平均周转时间和平均带权周转时间,比较 各种算法的性能优劣。 实验内容:编程实现如下算法: 1.先来先服务算法; 2.短进程优先算法; 3.时间片轮转调度算法。 设计分析: 程序流程图: 1.先来先服务算法 开始 初始化PCB,输入进程信息 各进程按先来先到的顺序进入就绪队列 结束 就绪队列? 运行 运行进程所需CPU时间 取消该进程 2.短进程优先算法

3.时间片轮转调度算法 实验代码: 1.先来先服务算法 #include #define n 20 typedef struct { int id; //进程名

int atime; //进程到达时间 int runtime; //进程运行时间 }fcs; void main() { int amount,i,j,diao,huan; fcs f[n]; cout<<"请输入进程个数:"<>amount; for(i=0;i>f[i].id; cin>>f[i].atime; cin>>f[i].runtime; } for(i=0;if[j+1].atime) {diao=f[j].atime; f[j].atime=f[j+1].atime; f[j+1].atime=diao; huan=f[j].id; f[j].id=f[j+1].id; f[j+1].id=huan; } } } for(i=0;i #define n 5 #define num 5 #define max 65535 typedef struct pro { int PRO_ID; int arrive_time;

处理器调度(设计一个按时间片轮转法实现处理器调度的程序)

实验一处理器调度 一、实验容 选择一个调度算法,实现处理器调度。 二、实验目的 在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。本实习模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。 三、实验题目 设计一个按时间片轮转法实现处理器调度的程序。 [提示]: (1)假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。进程控制块的 格式为: 其中,Q1,Q2,Q3,Q4,Q5。 指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。 要求运行时间——假设进程需要运行的单位时间数。 已运行时间——假设进程已经运行的单位时间数,初始值为“0”。 状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R”表示。 当一个进程运行结束后,它的状态为“结束”,用“E”表示。 (2) 每次运行所设计的处理器调度程序前,为每个进程任意确定它的“要求运行时间”。 (3) 把五个进程按顺序排成循环队列,用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如,当前轮到P2执行,则有: 标志单元 K1 K2 K 3 K4 K5

(4)处理器调度总是选择标志单元指示的进程运行。由于本实习是模拟处理器调度的 功能,所以,对被选中的进程并不实际的启动运行,而是执行: 已运行时间+1 来模拟进程的一次运行,表示进程已经运行过一个单位的时间。 请同学注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行满一个时间片。在这时省去了这些工作,仅用“已运行时间+1”来表示进程已 经运行满一个时间片。 (5)进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一 个轮到运行的进程。同时,应判断该进程的要求运行时间与已运行时间,若该进程的要求运行时间 已运行时间,则表示它尚未执行结束,应待到下一轮时再运行。若该进程的要求运行时间=已运行时间,则表示它已经执行结束,应指导它的状态修改成“结束”(E)且退出队列。此时,应把该进程的进程控制块中的指针值送到前 面一个进程的指针位置。 (6)若“就绪”状态的进程队列不为空,则重复上面的(4)和(5)的步骤,直到所有 的进程都成为“结束”状态。 (7)在所设计的程序中应有显示或打印语句,能显示或打印每次选中进程的进程名以及 运行一次后进程队列的变化。 (8)为五个进程任意确定一组“要求运行时间”,启动所设计的处理器调度程序,显示 或打印逐次被选中的进程名以及进程控制块的动态变化过程。 四. 所用数据结构及符号说明 typedef struct PNode//PCB { struct PNode *next; //定义指向下一个节点的指针 char name[10]; //定义进程名,并分配空间 int All_time; //定义总运行时间 int Runed_Time; //定义已运行时间 char state; //定义进程状态Ready/End } *Proc; //指向该PCB的指针 int ProcNum; //总进程数

先来先服务FCFS和短作业优先SJF进程调度算法_实验报告材料

先来先服务FCFS和短作业优先SJF进程调度算法 1、实验目的 通过这次实验,加深对进程概念的理解,进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。 2、需求分析 (1) 输入的形式和输入值的范围 输入值:进程个数Num 范围:0

说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。 4、详细设计 5、调试分析 (1)调试过程中遇到的问题以及解决方法,设计与实现的回顾讨论和分析 ○1开始的时候没有判断进程是否到达,导致短进程优先算法运行结果错误,后来加上了判断语句后就解决了改问题。 ○2 基本完成的设计所要实现的功能,总的来说,FCFS编写容易,SJF 需要先找到已经到达的进程,再从已经到达的进程里找到进程服务时间最短的进程,再进行计算。 (2)算法的改进设想 改进:即使用户输入的进程到达时间没有先后顺序也能准确的计算出结果。(就是再加个循环,判断各个进程的到达时间先后,组成一个有序的序列) (3)经验和体会 通过本次实验,深入理解了先来先服务和短进程优先进程调度算法的思想,培养了自己的动手能力,通过实践加深了记忆。 6、用户使用说明 (1)输入进程个数Num

实验3-页面调度算法

实验报告 院(系): 专业班级: 学号: 姓名: 实验地点: 实验日期:

课程名称实验项目名称实验学时实验类型计算机操作系统页面调度算法 2 验证型 一、实验目的及要求 通过本实验可以加深理解有关虚拟存储器的工作原理,进一步体会和了解页面替换算法的具体实现方法。 二、实验环境 PC /Windows系统/Visual C++6.0 三、实验内容 ①实现三种算法:先进先出;OPT;LRU ②页面序列从指定的文本文件(TXT文件)中取出 ③输出:第一行:每次淘汰的页面号,第二行:显示缺页的总次数 四、实验步骤 1.先进先出(FIFO)置换算法的思路 该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单,只需把一个进程已调入内存的页面,按照先后次序连接成一个队列,并设置一个替换指针,使它总指向最老的页面。 2.最近久未使用(LRU)置换算法的思路 最近久未使用置换算法的替换规则,是根据页面调入内存后的使用情况来进行决策的。该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间,当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。 3.最佳(OPT)置换算法的思路 其所选择的被淘汰的页面,将是以后不使用的,或者是在未来时间内不再被访问的页面,采用最佳算法,通常可保证获得最低的缺页率。

4、流程图如下图所示: 五、调试过程 程序结构分析: 程序共有以下九个部分: int findSpace(void);//查找是否有空闲内存 int findExist(int curpage);//查找内存中是否有该页面 开始 取一条指令 取指令中访问的页号=>L 查 页 表 页标记=1? 形成绝对地址 是“存”指令? 置L 页修改标记“1” 输出绝对地址 输出“*页号” 有后继指令? 取一条指令 结 束 J:=P[k] J 页的修改标记 输出“OUTj ” 输出“INL ” P[k]:=L k:=(k+1) mod m 修改页面 是 否 是 否 否(产生缺页中断) 是 否

模拟一种处理机调度算法讲解

课程设计报告 设计名称:模拟实现一种处理机调度算法 学生姓名: xxx 专业:计算机科学与技术 班别: xxxxxxxx 学号: xxxxxx 指导老师: xxxxx 日期: 2014 年 6 月 20 日

初始条件: 1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。 2.实践准备:掌握一种计算机高级语言的使用。 要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求) 1.模拟进程调度,能够处理以下的情形: ⑴能够选择不同的调度算法(要求中给出的调度算法); ⑵能够输入进程的基本信息,如进程名、优先级、到达 时间和运行时间等; ⑶根据选择的调度算法显示进程调度队列; ⑷根据选择的调度算法计算平均周转时间和平均带权周 转时间。 2.设计报告内容应说明: ⑴需求分析; ⑵功能设计(数据结构及模块说明); ⑶开发平台及源程序的主要部分; ⑷测试用例,运行结果与运行情况分析; ⑸自我评价与总结: i)你认为你完成的设计哪些地方做得比较好或比较出 色; ii)什么地方做得不太好,以后如何改正;

iii)从本设计得到的收获(在编写,调试,执行过程中 的经验和教训); iv)完成本题是否有其他方法(如果有,简要说明该方 法); 进程调度模拟设计——先来先服务、优先级法1、背景: 当计算机系统是多道程序设计系统时,通常会有多个进程或线程同时竞争CPU。只要有两个或更多的进程处于就绪状态,这种情形就会发生。如果只有一个CPU可用,那么就必须选择下一个要运行的进程。在操作系统中,完成选择工作的这一部分称为调度程序,该程序使用的算法成为调度算法。 进程调度的核心问题是采用什么样的算法把处理机分配给进程,好的算法将提高资源利用率,减少处理机的空闲时间,避免有些作业长期得不到相应的情况发生等,从而设计出受欢迎的操作系统。较常见的几种进程调度算法有:先来先服务调度算法;短作业优先调度算法;时间片轮转调度算法;优先级调度算法;高响应比优先算法和多级反馈队列调度算法等。 2.1设计目的 无论是在批处理系统还是分时系统中,用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外,系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略,动态地把处理机

作业调度实验报告

作业调度实验报告 Document number:NOCG-YUNOO-BUYTT-UU986-1986UT

实验二作业调度 一.实验题目 1、编写并调试一个单道处理系统的作业等待模拟程序。 作业调度算法:分别采用先来先服务(FCFS),最短作业优先(SJF)、响应比高者优先(HRN)的调度算法。 (1)先来先服务算法:按照作业提交给系统的先后顺序来挑选作业,先提交的先被挑选。 (2)最短作业优先算法:是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。 (3)响应比高者优先算法:是在每次调度前都要计算所有被选作业(在后备队列中)的响应比,然后选择响应比最高的作业执行。 2、编写并调度一个多道程序系统的作业调度模拟程序。 作业调度算法:采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。 对于多道程序系统,要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。 二.实验目的: 本实验要求用高级语言(C语言实验环境)编写和调试一个或多个作业调度的模拟程序,了解作业调度在操作系统中的作用,以加深对作业调度算法的理解三 .实验过程 <一>单道处理系统作业调度 1)单道处理程序作业调度实验的源程序: 执行程序: 2)实验分析:

1、由于在单道批处理系统中,作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所占用的 CPU 时限等因素。 2、每个作业由一个作业控制块JCB 表示,JCB 可以包含如下信息:作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W 。 3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间,以及这组作业的平均周转时间及带权平均周转时间。 3)流程图: 二.最短作业优先算法 三.高响应比算法 图一.先来先服务流程图 4)源程序: #include <> #include <> #include <> #define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0 int n; float T1=0,T2=0; int times=0; struct jcb .\n",p->name); free(p); .wait...",time); if(times>1000) 代替 代替

页式虚拟存储管理中地址转换和缺页中断实验参考2

页式虚拟存储管理中地址转换和缺页中断 一.实验目的 (1)深入了解存储管理如何实现地址转换。 (2)进一步认识页式虚拟存储管理中如何处理缺页中断。 二.实验内容 编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。 三.实验原理 页式存储管理把内存分割成大小相等位置固定的若干区域,叫内存页面,内存的分配以“页”为单位,一个程序可以占用不连续的页面,逻辑页面的大小和内存页面的大小相同,内外存的交换也以页为单位进行,页面交换时,先查询快表,若快表中找不到所需页面再去查询页表,若页表中仍未找到说明发生了缺页中断,需先将所需页面调入内存再进行存取。 四.实验部分源程序 #define size 1024//定义块的大小,本次模拟设为1024个字节。 #include "stdio.h" #include "string.h" #include struct plist { int number; //页号 int flag; //标志,如为1表示该页已调入主存,如为0则还没调入。 int block; //主存块号,表示该页在主存中的位置。 int modify; //修改标志,如在主存中修改过该页的内容则设为1,反之设为0 int location; //在磁盘上的位置 }; //模拟之前初始化一个页表。 struct plist p1[7]={{0,1,5,0,010},{1,1,8,0,012},{2,1,9,0,013},{3,1,1,0,021},{4,0,-1,0,022},{5,0,-1,0,023},{6, 0,-1,0,125}}; //命令结构,包括操作符,页号,页内偏移地址。 struct ilist { char operation[10]; int pagenumber; int address; }; //在模拟之前初始化一个命令表,通过程序可以让其顺序执行。 struct ilist p2[12]={{"+",0,72},{"5+",1,50},{"*",2,15},{"save",3,26},

LRU页面调度算法实现

LRU页面调度算法实现 学院计算机科学与技术专业计算机科学与技术学号 学生姓名 指导教师姓名 2014年3月16 日

目录 1.实验要求 (2) 2.实验目的 (2) 3.实验内容 (2) 4.相关知识 (2) 5.实验原理 (3) 6.流程图 (4) 7.源代码 (5) 8.运行结果 (9) 9.实验心得 (10) 10.参考文献 (11)

LRU页调度算法实现 一实验要求: 1.不同的功能使用不同的函数实现(模块化),对每个函数的功能和调用接口要注释清 楚。对程序其它部分也进行必要的注释。 2.对系统进行功能模块分析、画出总流程图和各模块流程图。 3.用户界面要求使用方便、简洁明了、美观大方、格式统一。所有功能可以反复使用,最好使用菜单。 4.通过命令行相应选项能直接进入某个相应菜单选项的功能模块。 5.所有程序需调试通过。 二实验目的: 将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。进一步巩固和复习操作系统的基础知识。培养学生结构化程序、模块化程序设计的方法和能力。提高学生调试程序的技巧和软件设计的能力。提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。 三实验内容: 程序应模拟实现LRU 算法思想,对n个页面实现模拟调度。 四相关知识: 1.虚拟存储器的引入: 局部性原理:程序在执行时在一较短时间内仅限于某个部分;相应的,它所访问的存储空间也局限于某个区域,它主要表现在以下两个方面:时间局限性和空间局限性。 2.虚拟存储器的定义:

虚拟存储器是只具有请求调入功能和置换功能,能从逻辑上对内存容量进行扩充的一种存储器系统。 3.虚拟存储器的实现方式: 分页请求系统,它是在分页系统的基础上,增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。 请求分段系统,它是在分段系统的基础上,增加了请求调段及分段置换功能后,所形成的段式虚拟存储系统。 五.实验原理: 目前有许多页面调度算法,本实验主要涉及最近最久未使用调度算法。本实验使用页面调度算法时作如下假设,进程在创建时由操作系统为之分配一个固定数目物理页,执行过程中物理页的数目和位置不会改变。也即进程进行页面调度时只能在分到的几个物理页中进行。 LRU基本思想: LRU是Least Recently Used的缩写,即最近最少使用页面置换算法,是为虚拟页式存储管理服务的。 关于操作系统的内存管理,如何节省利用容量不大的内存为最多的进程提供资源,一直是研究的重要方向。而内存的虚拟存储管理,是现在最通用,最成功的方式——在内存有限的情况下,扩展一部分外存作为虚拟内存,真正的内存只存储当前运行时所用得到信息。这无疑极大地扩充了内存的功能,极大地提高了计算机的并发度。虚拟页式存储管理,则是将进程所需空间划分为多个页面,内存中只存放当前所需页面,其余页面放入外存的管理方式。 LRU算法的提出,是基于这样一个事实:在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。反过来说,已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。这个,就是著名的局部性原理——比内存速度还要快的cache,也是基于同样的原理运行的。因此,我们只需要在每次调换时,找到最近最少使用的那个页面调出内存。这就是LRU算法的全部内容。 实验中是用一维数组page[pSIZE]存储页面号序列,memery[mSIZE]是存储装入物理块中的页面。数组flag[10]标记页面的访问时间。每当使用页面时,刷新访问时间。发生缺页时,就从物理块中页面标记最小的一页,调出该页,换入所缺的页面。

处理器调度习题教学内容

处理器调度习题

处理器调度 选择题 ?当CPU执行操作系统代码时,则处理机处于( )。 ?A.执行态 B.目态 C.管态 D.就绪态 ?( )是机器指令的扩充,是硬件的首次延伸,是加在硬件上的第一层软件。 ?A.系统调用 B.操作系统 C.内核 D.特权指令 ?操作系统提供给程序员的接口是( )。 ?A.进程 B.系统调用 C.库函数 D.B和C ?用户程序向系统提出使用外设的请求方式是( )。 ?A.作业申请 B.原语 C.系统调用 D.I/O指令 ?当作业正常完成进入完成状态时,操作系统( )。 ?A.将输出该作业的结果并删除内存中的作业 ?B.将收回该作业的所占资源并输出结果 ?C.将收回该作业的所占资源及输出结果,并删除该作业 ?D.将收回该作业的所占资源及输出结果,并将它的控制块从当前的队列中删除 ?下列选项是关于作业和进程关系的描述,其中哪一个是不正确的( )。 ?A.作业的概念主要用在批处理系统中,而进程的概念则用在几乎所有的OS中。 ?B.作业是比进程低一级的概念。 ?C.一个作业至少由一个进程组成。 ?D.作业是用户向计算机提交任务的实体,而进程是完成用户任务的执行实体以及向系统申请分配资源的基本单位。 ?作业从后备作业到被调度程序选中的时间称为( )。 ?周转时间B.响应时间C.等待调度时间D.运行时间 ?设有三个作业J1,J2,J3,它们同时到达,运行时间分别为T1,T2,T3,且T1≤T2≤T3,若它们在一台处理机上按单道运行,采用短作业优先算法,则平均周转时间为( )。 ?A.T1+T2+T3 B.1/3(T1+T2+T3) ?C.T1+2/3T2+1/3T3 D.T1+1/3T2+2/3T3 ?从作业提交给系统到作业完成的时间间隔称为作业的( )。 ?A.中断时间 B.等待时间 C.周转时间 D.响应时间 ?设有四个作业同时到达,每个作业执行时间均为2 h,它们在一台处理机上按单道方式运行,则平均周转时间为( )。 ?A.1 h B.5 h C.2.5 h D.8 h ?FCFS调度算法有利于( )。 ?A.长作业和CPU繁忙型作业 B.长作业和I/O繁忙型作业 ?C.短作业和CPU繁忙型作业 D.短作业和I/O繁忙型作业 ?下列哪种说法不是SJ(P)F调度算法的缺点( )。 ?A.对于长作业(进程)不利 ?B.未考虑作业(进程)的紧迫程度 ?C.不能有效降低作业(进程)的平均等待时间 ?D.由于根据的是用户提供的估计执行时间,因此不一定真正做到短而优先。 ?选择排队进程中等待时间最长的进程被优先调度,该调度算法是( )。 ?A.先来先服务调度算法B.短进程优先调度算法 ?C.优先权调度算法D.高响应比优先调度算法 ?在采用动态优先权的优先权调度算法中,如果所有进程都具有相同优先权初值,则此时的优先权调度算法实际上和( )相同。 ?A.先来先服务调度算法B.短进程优先调度算法

操作系统实验报告-作业调度

作业调度 一、实验目的 1、对作业调度的相关内容作进一步的理解。 2、明白作业调度的主要任务。 3、通过编程掌握作业调度的主要算法。 二、实验内容及要求 1、对于给定的一组作业, 给出其到达时间和运行时间,例如下表所示: 2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。 3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。

测试数据 workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8} 运行结果 先来先服务算法 调度顺序:['A', 'B', 'C', 'D', 'E', 'F'] 周转时间: 带权周转时间:

短作业优先算法 调度顺序:['A', 'D', 'F', 'C', 'E', 'B'] 周转时间: 带权周转时间:1. 响应比高者优先算法 调度顺序:['A', 'D', 'F', 'E', 'C', 'B'] 周转时间: 带权周转时间: 五、代码 #encoding=gbk workA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8} list1=[workB,workA,workC,workD,workE,workF] list2=[workB,workA,workC,workD,workE,workF] list3=[workB,workA,workC,workD,workE,workF] #先来先服务算法 def fcfs(list): resultlist = sorted(list, key=lambda s: s['到达时间']) return resultlist #短作业优先算法 def sjf(list): time=0 resultlist=[] for work1 in list: time+=work1['服务时间'] listdd=[] ctime=0 for i in range(time): for work2 in list: if work2['到达时间']<=ctime: (work2) if len(listdd)!=0: li = sorted(listdd, key=lambda s: s['服务时间']) (li[0]) (li[0]) ctime+=li[0]['服务时间'] listdd=[]

模拟请求页式存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断

实验二模拟请求页式存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断 1.内容:模拟请求页式存储管理中硬件的地址转换和缺页中断处理 2.思想: 装入新页置换旧页时,若旧页在执行中没有被修改过,则不必将该页重写磁盘。因此,页表中增加是否修改过的标志,执行“存”指令和“写”指令时将对应的修改标志置成“1” 3.要求及方法: ①设计一个地址转换程序来模拟硬件的地址转换和缺页中断。当访问的页在主存时则形成绝对地址,但不去模拟指令的执行,可以输出转换后的绝对地址来表示一条指令已执行完成。当访问的页不在主存中时,则输出“*页号”来表示硬件产生了一次缺页中断。模拟地址转换流程见图1。 ②编制一个FIFO页面调度程序;FIFO页面调度算法总是先调出作业中最先进入主存中的哪一页。因此可以用一个数组来表示(或构成)页号队列。数组中每个元素是该作业已在主存中的页面号,假定分配给作业的页架数为m,且该作业开始的m页已装入主存,则数组可由m个元素构成。 P[0],P[1],P[2],…,P[m-1] 它们的初值为P[0]:=0,P[1]:=1,P[2]:=2,…,P[m-1]:=m-1 用一指针K指示当要调入新页时应调出的页在数组中的位置,K的初值为“0”,当产生缺页中断后,操作系统总是选择P[K]所指出的页面调出,然后执行: P[K]:=要装入的新页页号 K:=(k+1)mod m 在实验中不必实际地启动磁盘执行调出一页和装入一页的工作,而用输出“OUT调出的页号”和“IN要装入的新页页号”来模拟一次调出和装入过程,模拟程序的流程图见附图1。 按流程控制过程如下:

页面调度算法

#include #include #include #define null 0 #define len sizeof(struct page) struct page { int num; int tag; struct page *next; }; struct page *creat(int n) { int count=1; struct page *p1,*p2,*head; head=p2=p1=(struct page *)malloc(len); p1->tag=-1; p1->num=-1; while(counttag=-1; p1->num=-1; p2->next=p1; p2=p1; } p2->next=null; return(head); } void FIFO(int array[],int n) { int *p; int count=0; struct page *cp,*dp,*head,*newp; head=creat(n); p=array; while(*p!=-1) { cp=dp=head;

for(;cp->num!=*p&&cp->next!=NULL;) cp=cp->next; if(cp->num==*p) printf(" ! "); else { count++; cp=head; for(;cp->tag!=-1&&cp->next!=NULL;) cp=cp->next; if(cp->tag==-1) { cp->num=*p; cp->tag=0; printf(" * "); } else { newp=(struct page*)malloc(len); newp->num=*p; newp->tag=0; newp->next=null; cp->next=newp; head=head->next; printf(" %d ",dp->num); free(dp); } } p++; } printf("\nQueye Zongshu:%d\n",count); } void LRU(int array[],int n) { int count=0,*p=array; struct page *head,*cp,*dp,*rp,*newp,*endp; head=creat(n); while(*p!=-1) { cp=dp=rp=endp=head; //for(;endp->next!=NULL;) endp=endp->next; //for(;cp->num!=*p&&cp->next!=NULL;) {

相关文档
最新文档