操作系统实验报告(读者写着问题,时间片轮转算法,内存的分配,进程的调度)[范文大全]

第一篇：操作系统实验报告(读者写着问题,时间片轮转算法,内存的分配,进程的调度)

小心

计算机专业类课程

实验报告 课程名称：操作系统 学

院：软件学院 专

业：软件工程 学生姓名：李 希

学

号：2010231020018 指导教师：丁老师

日

期： 2012年5月5日

电子科技大学计算机学院实验中心

电 子 科 技 大 学

实

验

报

告

实验一

一、实验名称： 进程管理

二、实验学时：4

三、实验内容和目的： 实验内容：（1）进程的创建

写一段源程序，创建两个进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示字符。观察纪录屏幕上的显示结果，然后分析原因。（2）进程的控制

修改编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕出现的现象，并分析原因。实验目的：

（1）加深对进程概念的理解，明确进程和程序的区别。

（2）进一步认识并发执行的实质。

（3）分析进程竞争资源现象，学习解决进程互斥的方法。

四、实验原理：

利用fork函数来创建子进程，并返回子进程的ID号。

利用lockf函数来实现信号量对进程的资源竞争的调度，和互斥的方法。

五、实验器材（设备、元器件）:

一台装有VS2010的电脑，操作系统为WIN7.六、实验步骤：

（1）先写好2个子进程程序，并且让2个子程序在屏幕上分别打印出A,B（2）父进程创建2个子进程，并在屏幕上打印出C。（3）观察进程竞争资源的现象。

七、实验数据及结果分析：

电子科技大学计算机学院实验中心 子进程A的代码：

#include #include using namespace std;int main(){

cout<<“I'm Process A/n”<

} 子进程B的代码：

#include using namespace std;int main(){

cout<<“I'm Process B”<

//#include “stdafx.h” #include #include using namespace std;

void print_error(){ DWORD nErrorNo = GetLastError();LPSTR lpBuffer;

FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER

FORMAT_MESSAGE_IGNORE_INSERTS |

FORMAT_MESSAGE_FROM_SYSTEM，NULL，nErrorNo，LANG_NEUTRAL，(LPTSTR)& lpBuffer，0 , NULL);if(lpBuffer == NULL)

|

} { } printf(“%s(%d).n”, lpBuffer, nErrorNo);lpBuffer = “Sorry, cannot find this error info.”;int fork(const char* pszApplication,HANDLE& hProcess)

{

STARTUPINFO si={sizeof(si)};

} void lockf(HANDLE hObj){

} int main(int argc, char* argv[]){

HANDLE hProcess1,hProcess2;int child1=fork(“C:操¨´作Á¡Â系¦Ì统ª3实º¦Ì验¨¦ProcessADebugProcessA.exe”,hProcess1);if(-1==child1)

} lockf(hProcess1);cout << “fork error!n”;return-1;{ case WAIT_OBJECT_0:

} printf(“nProcess exit.n”);break;printf(“nTime out.n”);break;printf(“nWait Failed.n”);print_error();break;DWORD state = WaitForSingleObject(hObj,INFINITE);switch(state)PROCESS_INFORMATION pi;if(!CreateProcess(pszApplication,NULL,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi)){

} hProcess=pi.hProcess;return pi.dwProcessId;return-1;else

case WAIT_TIMEOUT: case WAIT_FAILED:

{

电子科技大学计算机学院实验中心

} int child2=fork(“C:操¨´作Á¡Â系¦Ì统ª3实º¦Ì验¨¦ProcessBDebugProcessB.exe”,hProcess2);if(-1==child2){

} cout<<“This is Process Cn”;lockf(hProcess2);return 0;cout << “fork error!n”;return-1;程序运行的结果：

八、实验结论、心得体会和改进建议：

实验结论：成功的通过了父进程C来创建了2个子进程A,B，并成功的对子进程进行了调度与管理。

心得体会：通过对进程的创建，调度，更加深了我们对操作系统这门课的进程的了解，而且也锻炼了我们写代码的能力，和解决问题的能力。

改进建议：对于我们大二没有接触过Windows编程的学生来说，可能一些Windows的API函数不够了解，以至于比较难理解老师给出的参考代码。所以我希望，老师以后可以先给我们大家简单的讲解，介绍一下比较实用的Windows编程的API的函数。

实验二

一、实验名称： 处理器调度

二、实验学时：4

三、实验内容和目的： 实验内容：

(1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

电子科技大学计算机学院实验中心 PCB的格式为：

其中，进程名——作为进程的标识，假设五个进程的进程名分别为1,2,3,4,5指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。要求运行时间——假设进程需要运行的单位时间数。已运行时间——假设进程已经运行的单位时间数，初始值为“0”。状态——有两种状态，“ready”和“end”，初始状态都为“ready”，用“ready”表示。当一个进程运行结束后，它的状态为“end”，用“end”表示。

(2)每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。

(3)把五个进程按顺序排成循环队列，用指针指出队列连接情况。另用一标志单元记录轮到运行的进程。例如，当前轮到2执行，则有：

(4)处理器调度总是选择标志单元指示的进程运行。由于本实验是模拟处理器调度的功能，对被选中的进程并不实际的启动运行，而 是执行：已运行时间+1来模拟进程的一次运行，表示进程运行过一个单位的时间。

(5)进程运行一次后，把该进程的进程控制块中的指针值送到标志单元，指示下一个轮到运行的进程。同时应判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。若该进程的要求运行时间等于已运行时间，则表示它已经执行结束，应把它的状态修改成“结束”（end）且退出队列。此时，应把该进程的进程控制块中的指针值送到前面一个进程的指针位置。

(6)若“ready”状态的进程队列不为空，则重复上面的（4）和（5）

电子科技大学计算机学院实验中心 的步骤，直到所有的进程都成为“ready”状态。

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

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

在用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。所以当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用CPU。本实验模拟在单处理器情况下的处理器调度，加深了解处理器调度的工作。

四、实验原理：

定义进程PCB结构体。并用采用C++中的指针形成循环链表，并对链表中的结构进行操作。来模仿时间片轮转的进程调度。

五、实验器材（设备、元器件）: 一台装有VS2010的电脑，操作系统为WIN7.六、实验步骤：（1）定义结构体PCB：里面有进程的编号，执行需要的时间，和已经运行时间，还有进程的状态信息。

（2）定义循环的单链表，来使结构都串联起来。

（3）使用时间片轮转的方法来动态地进行进程模拟的调度。（4）如果所有的进程都执行完毕，则退出程序。

七、实验数据及结果分析： 实验程序的代码如下：

#include #include using namespace std;

struct Process{

};

struct Process *CreateList(int n)//初始化链表，并返回指向链表头的指针 {

struct Process *head=NULL,*tail=NULL;for(int i=1;i<=n;i++){

if(i==1){

head=new Process;tail=head;head->Name=i;head->RunTime=0;int Name;string Statu;int NeedTime;int RunTime;Process *Next;

电子科技大学计算机学院实验中心

}

} head->Statu=“Ready”;cout<<“请输入”<>tail->NeedTime;} if(i!=1&&i!=n){

tail->Next=new Process;tail=tail->Next;tail->Name=i;tail->RunTime=0;tail->Statu=“Ready”;cout<<“请输入¨²”<>tail->NeedTime;} if(i==n){

} tail->Next=new Process;tail=tail->Next;tail->Next=head;tail->Name=i;tail->RunTime=0;tail->Statu=“Ready”;cout<<“请输入¨²”<>tail->NeedTime;tail=head;return tail;void Run(struct Process *tail,int ProcessNum)//时间片轮转 {

while(ProcessNum!=0){ if((tail->RunTime!=tail->NeedTime))

{

cout<<“进程”<Name<<“ 正在运行n”;cout<<“需要运行时间”<NeedTime<<“n”;cout<<“已经运行时间”<RunTime<<“n”;cout<<“进程的状态”<Statu<<“n”;cout<<“******************************”<<“n”;cout<<“******************************”<<“n”;cout<<“******************************”<<“n”;

if(tail->RunTime==tail->NeedTime)

{

tail->RunTime++;

if(tail->Statu==“Ready”){ tail->Statu=“End”;

ProcessNum--;

}

}

tail=tail->Next;

}

else

{

tail=tail->Next;

} }

}

int main(){ struct Process * runtail;runtail=NULL;int n;int ProcessNum;cout<<“请输入进程的个数”;cin>>n;ProcessNum=n;runtail=CreateList(n);Run(runtail,ProcessNum);getchar();getchar();} 实验结果：

电子科技大学计算机学院实验中心

八、实验结论、心得体会和改进建议：

实验结论：成功的采用链表的形式，用指针，模仿了时间片轮转算法，完成了实验的要求，达到了实验的目的。

心得体会：通过本次实验加深了我们对时间轮转算法的印象，并且锻炼了我们的动手能力，还温习了一下C++中一些编程的知识。

改进建议：我觉得时间片算法可能过于简单了，其实我们可以在时间片算法的基础上再增加一些功能，比如在时间片算法上增加优先级这个属性，这样不仅加大了实验的难度，还可以让同学们对优先级调度有一种更直观，更深刻的了解。

实验三

一、实验名称：主存储器空间的分配与回收

二、实验学时：4

三、实验内容和目的：

实验内容：

电子科技大学计算机学院实验中心 分页式管理方式采用位示图来表示主存分配情况，实现主存空间的分配和回收。

实验目的：

一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。

当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的情况，找出足够的空闲区域分配给申请者。当作业撤离或主动归还主存资源时，则存储 管理要收回作业占用的主存空间或归还部分主存空间。主存的分配和回收的实现虽与主存储器的管理方式有关的。

通过本实验帮助学生理解在不同的存储管理方式下应怎样实现主存空间的回收和分配。

四、实验原理：

(1)分页式存储器把主存分成大小相等的若干块，作业的信息也按块的大小分页，作业装入主存时可把作业的信息按页分散存放在主存的空闲块中，为了说明主存中哪些块已经被占用，哪些块是尚未分配的空闲块，可用一张位示图来指出。位示图可由若干存储单元来构成，其中每一位与一个物理块对应，用0/1表示对应块为空闲/已占用。(2)设某系统主存被分成大小相等的64块，则位示图可用8*8个字节来构成，另用一单元记录当前空闲块数。若已有第0，1，4，5，6，9，11，13，24，31，共10个主存块被占用了，那么位示图情况如下：

(3)当装入一个作业时，根据作业对主存的需要量，先查当前空闲块数是否能满足作业要求，若不能满足则输出分配不成功。若能满足，则查位示图，找出为“0”的一些位，置上占用标志“1”，并且从“当前空闲块数”中减去本次任务占用块数。然后按找到的计算出对应的块号： 其计算公式为： 块号= j*8+i 其中，j表示找到的是第n个字节，i表示对应的是第n位。根据分配给作业的块号，为作业建立一张页表，页表格式：

(4)当作业执行结束，归还主存时，根据该作业的页表可以知道应归还的块号。

电子科技大学计算机学院实验中心 由块号可计算出在位示图中的对应位置，把对应位的占用标志清成“0”，表示对应的块已成为空闲块。归还的块数加入到当前空闲块数中。由块号计算在位示图中的位置的公式如下：

字节号 j=[块号/8]（[ ]表示取整）

位数 i={块号/8}（{ }表示取余）

(5)设计实现主存分配和回收的程序。假定位示图的初始状态如（2）所述，现

有一信息量为N页的作业要装入，运行你所设计的分配程序，为作业分配主存且建立页表（格式如（3）所述）。

五、实验器材（设备、元器件）: 一台装有VS2010的电脑，操作系统为WIN7.六、实验步骤：

(1)先创建一个8*8的数组，用来保存内存的信息。并初始化好值，用1来表示已经分配，用0来表示还没有分配。

(2)创建一个Sum函数，来对内存中没有分配的内存个数进行统计，并返回一个int类型的数值，来表示没有分配的内存的大小、(3)创建一个分配内存的函数，先判断需求的内存的大小是否小于内存空闲的大小。如果能够满足要求，则将相应的内存空间修改为1，表示已经分配。(4)创建一个打印内存页表的函数，根据内存的实际情况，如果为1，则打印输出，最后在屏幕上打印出所有的空闲页表。

(5)创建主函数，并对相应的函数进行调用，便可成功的模仿内存的调度。

七、实验数据及结果分析： 具体的代码如下：

#include using namespace std;

void Print(int Table[8][8])//显示内存

}

int Sum(int Table[8][8])//计算内存的剩余量 {

int n=0;for(int j=0;j<8;j++)

{

} {

cout<<“分配内存后最新的内存情况如下表”<

cout<<“ ”<<0<<“ ”<<1<<“ ”<<2<<“ ”<<3<<“ ”<<4<<“ ”<<5<<“ ”<<6<<“ ”<<7<<“n”;

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

cout<

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

{

cout<<“ ”<

}

cout<<“n”;

{

电子科技大学计算机学院实验中心

}

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

{

if(Table[j][k]==0)

{

n++;

}

}

} return n;void Manage(int Table [8][8],int Need)//分配内存 {

}

void YeBiao(int Table [8][8])//打印空闲页表 {

cout<<“分配后空闲内存的页表”<

”<<“块号”<

{

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

{

if(Table [j][k]==0)

{

h=8*j+k;

cout<

”<

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

{

}

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

{

if(Table [j][k]==0&&Need!=0)

{

}

Table [j][k]=1;

Need--;

}

}

}

}

}

} int main(){

cout<<“请输入你要分配的块数”;cin>>Need;while(Need>Va){

} Manage(Table,Need);Print(Table);cout<<“对不起没有足够内存，请重新输入n”;cin>>Need;int Table[8][8];int Va,Need;for(int i=0;i<8;i++)//初始化页表 {

} Table[0][0]=1;Table[0][1]=1;Table[0][4]=1;Table[0][5]=1;Table[0][6]=1;Table[1][1]=1;Table[1][3]=1;Table[1][5]=1;Table[3][0]=1;Table[3][7]=1;Print(Table);Va=Sum(Table);cout<<“n”<<“现在有”<

电子科技大学计算机学院实验中心

YeBiao(Table);

} getchar();getchar();（1）若申请的内存数过大。

（2）申请的内存为45：

八、实验结论、心得体会和改进建议：

实验结论：达到了实验的要求与目的，完成了对内存分配的模拟。

心得体会：通过本次实验，我加深了采用页表的方式来管理内存的印象，锻炼了自己C++的编程能力，和独立解决问题的能力。

改进建议：实验中并没有要求对内存空间清理，删除的功能，我希望老师能加上对内存紧凑，清理，删除这些功能的模拟，这样可以使我们所学的知识更有用武之地。

电子科技大学计算机学院实验中心

实验四

一、实验名称： 读者写者问题

二、实验学时：4

三、实验内容和目的： 实验内容：

可用于解决多个进程共享一个数据区（文件、内存区、一组寄存器等），其中若干读进程只能读数据，若干写进程只能写数据等实际问题 读者和写者应满足的条件:（1）允许多个读者可以同时读文件

（2）不允许多个写者同时写文件,只能互斥写文件（3）当写进程在写时不能读

（4）读者优先: 指一旦有读者正在读数据，允许多个读者同时进入读数据，只有当全部读者退出，才允许写者进入写数据。

（5）写者优先:指只要有一个写者申请写数据，则不再允许新的读者进入读数据

实验目的： 通过本实验对读者写者的模拟，让我们对操作系统中读者写着问题的解决有一个加深的影响，并学会使用一些模拟简单的信号量的方法，来解决一些比较经典的读者写着的问题。

四、实验原理：

（1）为了模拟读者写着的问题，因为自己的C++技术不够深厚，于是用Java中的线程来进行模拟、采用输入输出流来对文本文件Test.txt进行操作。（2）要实现写着互斥的写文件，这里只需要将线程中的Run方法定义为synchronized，就可以实现写着互斥的写文件、（3）引入一个couter类，并对counter类中的成员进行维护，若有读者读数据，则对counter内的reader++，写者同理。

（4）读者写着不同的优先级，可以通过依赖counter类来实现。在进行文件读写操作时，先判断是否有读者/写者。

五、实验器材（设备、元器件）: 一台装有eclipse，和Win7的个人PC。

六、实验步骤：

电子科技大学计算机学院实验中心(1)定义读者，写者类并继承Thread类，在其中的Run方法中调用输入输出流来，读写文件

(2)创建counter类，来对读者，写者进行计数。

(3)在主函数中创建读者写者，并调用相应的Run方法，并观察实验的结果。

七、实验数据及结果分析：

实验的具体代码：

import java.util.Scanner;

public class ReadAndWrite { public static void main(String []arg){ Scanner in= new Scanner(System.in);System.out.println(“请选择模拟的情况：1为读者优先。2为写者优先”);int Situation;Situation = in.nextInt();if(Situation==2)//写者优先 { Writer w1=new Writer(1);w1.start();Reader r2=new Reader(2);r2.start();Writer w2=new Writer(2);w2.start();

} else//读者优先 { Reader1 r1=new Reader1(1);r1.start();Reader1 r2=new Reader1(2);r2.start();Writer1 w2=new Writer1(2);w2.start();

} }

} class Counter { static int WriterCounter=0;static int ReaderCounter=0;}

class Writer extends Thread//写者优先 {

int WriteNum;Writer(int WriteNum){

this.WriteNum=WriteNum;}

synchronized public void run(){

Counter.WriterCounter++;

System.out.println(“now Writer”+“ ”+WriteNum+“ ”+“is Writing”);

for(int i=0;i<10;i++){

System.out.println(“********************************”);

}

Counter.WriterCounter--;} }

class Writer1 extends Thread {

int WriteNum;Writer1(int WriteNum){

this.WriteNum=WriteNum;}

synchronized public void run(){

if(Counter.ReaderCounter==0)

{

Counter.WriterCounter++;

System.out.println(“now Writer”+“ ”+WriteNum+“ ”+“is Writing”);

for(int i=0;i<10;i++){

System.out.println(“********************************”);

}

电子科技大学计算机学院实验中心

Counter.WriterCounter--;

}

else

{

System.out.println(“Now File is Reading,Writer can't Write”);

try{

sleep(1000);

}catch(Exception ex)

{

ex.printStackTrace();

}

System.out.println(“********************************”);

System.out.println(“Writer is Writing”);

} } } class Reader extends Thread {

int ReadNum;Reader(int ReadNum){

this.ReadNum=ReadNum;}

public void run(){

if(Counter.WriterCounter==0)

{

Counter.ReaderCounter++;

System.out.println(“now Reader”+“ ”+ReadNum+“ ”+“is Reading”);

for(int i=0;i<10;i++){

System.out.println(“********************************”);

}

Counter.ReaderCounter--;

}

else

{

System.out.println(“now File is Writing,Reader can't Read”);

try{

sleep(1000);

}catch(Exception ex)

{

ex.printStackTrace();

}

System.out.println(“********************************”);

System.out.println(“Reader is Reading”);

} } } class Reader1 extends Thread//读者优先 {

int ReadNum;Reader1(int ReadNum){

this.ReadNum=ReadNum;}

public void run(){

Counter.ReaderCounter++;

System.out.println(“now Reader”+“ ”+ReadNum+“ ”+“is Reading”);

for(int i=0;i<10;i++){

System.out.println(“********************************”);

}

Counter.ReaderCounter--;

} } 实验的结果：（1）读者优先：

电子科技大学计算机学院实验中心（2）写者优先：

八、实验结论、心得体会和改进建议：

实验结论：基本完成了实验的要求，实现了对经典的读者写着问题的解决。心得体会：通过本次实验，加深了我对读者写着问题的理解，学会了用软件模拟的办法来实现一些简单的信号量对读者写者的控制，并且锻炼了自己Java编程的能力，和独立解决问题的能力

改进建议：实际上，对于读者写者的问题，我们有多种解决办法，在这里我们只是模拟了一下软件编程的方法，还有一些方法，比如信号量，中断屏蔽等方法，还没有模拟，所以希望在以后的实验中可以增加一些对这些方法的模拟，以加深我们对读者写者问题的理解。

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

进程调度算法模拟

专业：XXXXX 学号：XXXXX 姓名：XXX 实验日期：20XX年XX月XX日

一、实验目的

通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。

二、实验要求

编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。

三、实验方法内容

1.算法设计思路

将每个进程抽象成一个控制块PCB，PCB用一个结构体描述。

构建一个进程调度类。将进程调度的各种算法分装在一个类中。类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。还有一个PCB实例。主要保存正在运行的进程。类中其他方法都是围绕这三个容器可以这个运行中的PCB展开。

主要用到的技术是STL中的vector以维护和保存进程容器、就绪容器、完成容器。

当程序启动时，用户可以选择不同的调度算法。然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。判断进程容器中是否有新的进程可以加入就绪队列。2.算法流程图 主程序的框架：

开始void FCFS();//先来先服务void SJF();//最短进程优先调度void RR();//简单时间片轮转void PD();//最高优先数优先void PCBInput();//输入进程信息选择调度算法输入进程信息将输入容器中以满足进入条件的进程调入就绪队列void ProcessQueueProcess();//查看当前时间下，有无进程加入。若有则把该进程调入就绪队列按照选择的算法开始选择就绪队列的进程开始执行void ProcessSelect();//若当前就绪队列不为空则根据选择的调度算法开始调度,否则，系统时间加一个时间片.以等待新的进程到判断就绪容器和输入容器是否为空!processScheduler.m_WaitQueue.empty()||!processScheduler.m_ProcessQueue.empt()Y打印各进程信息进行统计计算周转时间等结束void PCBDisplay();//打印当前状况下。就绪队列、完成队列、运行中的进程信息void SchedulerStatistics();//调度统计，计算周转时间等进程调度过程：

开始为空判断就绪队列是否为空if(m_WaitQueue.empty())非空让系统等待一个时间片TimePast()根据设定的调度算法从就绪队列中调入一个进程并执行（此时进程从就绪队列中删除，赋值到表示运行中的成员变量中）void FCFS();//先来先服务void SJF();//最短进程优先调度void RR();//简单时间片轮转void PD();//最高优先数优先进程运行一个时间片N是否达到该进程停止运行的条件Y选入的进程状态是否为“完成”如进程已完成，或者分得的时间片个数已到ProcessRun()Yvector

m_WaitQueue;//进程就绪队列进程未完成，将进程优先数减一，并放回到就绪队列中设置进程完成时间，将该进程放入完成队列vector

m_FinishQueue;//完成队列结束

3.算法中用到的数据结构

struct fcfs{

//先来先服务算法从这里开始

char name[10];

float arrivetime;

float servicetime;

float starttime;

float finishtime;

float zztime;

float dqzztime;

};

//定义一个结构体，里面包含的有一个进程相关的信息

4.主要的常量变量

vector

m_ProcessQueue;//进程输入队列

vector

m_WaitQueue;//进程就绪队列 vector

m_FinishQueue;//完成队列 vector

::iterator m_iter;//迭代器 PCB m_runProcess;//运行中的进程

int m_ProcessCount;//进程数 float m_RunTime;//运行时间

int m_tagIsRun;//是否在运行标志。表示正在运行，表示没有 float m_TimeSlice;//时间片大小

int m_TimeSliceCount;//指时间片轮转中一次分到的时间片个数 char m_SchedulerAlgorithm;//调度算法

5.主要模块

void PCBInput();//输入进程信息

void PCBSort();//对进程控制块按照优先级排序(采用冒泡排序)void ProcessSelect();//若当前就绪队列不为空则根据选择的调度算法开始调度。否则，系统时间void PCBDisplay();//打印当前状况下。就绪队列、完成队列、运行中的进程信息

void ProcessRun();//进程运行一次。运行时间加个时间片。并判断进程是否达到完成条件。若是则void ProcessQueueProcess();//查看当前时间下，有无进程加入。若有则把该进程调入就绪队列 void ProcessDispatch();//进程分派，进程执行完成后决定进程该进入哪个队列(就绪、完成)void TimePast(){ m_RunTime +=m_TimeSlice;ProcessQueueProcess();}//当前系统时间加个时间void SchedulerStatistics();//调度统计，计算周转时间等 void FCFS();//先来先服务 void SJF();//最短进程优先调度 void RR();//简单时间片轮转 void PD();//最高优先数优先 加.以等待新的进程到来

ProcessStatus='f'.否则为'w';片，并检查是否有新的进程加入

四、实验代码

#include #include #include

using namespace std;

struct fcfs{

//先来先服务算法从这里开始

char name[10];

float arrivetime;

float servicetime;

float starttime;

float finishtime;

float zztime;

float dqzztime;

};

//定义一个结构体，里面包含的有一个进程相关的信息

fcfs a[100];

void input(fcfs *p,int N)

{

int i;

cout<

printf(“

请您输入进程的名字

到达时间

服务时间:(例如: a 0 100)nn”);

for(i=0;i<=N-1;i++)

{

printf(“

请您输入进程%d的信息:t”,i+1);

scanf(“ttt%s%f%f”,&p[i].name,&p[i].arrivetime,&p[i].servicetime);

}

}

void Print(fcfs *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N)

{ int k;

printf(“nn调用先来先服务算法以后进程运行的顺序是: ”);

printf(“%s”,p[0].name);

for(k=1;k

{

printf(“-->%s”,p[k].name);

}

cout<

printf(“n

具体进程调度信息:n”);

printf(“t进程名

到达时间

服务时间

开始时间

结束时间

周转时间

带权周转时间n”);

for(k=0;k<=N-1;k++)

{

printf(“t%st%-.2ft %-.2ft

%-.2ft

%-.2ft %-.2ft %-.2fn”,p[k].name,p[k].arrivetime，p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);

}

getchar();

//此处必须要有这个函数，否则就看不到显示器上面的输出，可以看到的结果只是一闪而过的一个框剪

}

void sort(fcfs *p,int N)//排序

{

for(int i=0;i<=N-1;i++)

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

if(p[i].arrivetime

{

fcfs temp;

temp=p[i];

p[i]=p[j];

p[j]=temp;

}

}

void deal(fcfs *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N)

//运行阶段

{ int k;

for(k=0;k<=N-1;k++)

{

if(k==0)

{

p[k].starttime=p[k].arrivetime;

p[k].finishtime=p[k].arrivetime+p[k].servicetime;}

else

{

p[k].starttime=p[k-1].finishtime;

p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}

}

for(k=0;k<=N-1;k++)

{

p[k].zztime=p[k].finishtime-p[k].arrivetime;

p[k].dqzztime=p[k].zztime/p[k].servicetime;

}

}

void FCFS(fcfs *p,int N)

{

float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;

sort(p,N);

deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);

Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);

getchar();

} //先来先服务算法到此结束 struct sjf{//最短进程优先调度算法从这里开始

char name[10];float arrivetime;//到达时间

float servicetime;//运行时间

float starttime;

//开始时间

float finishtime;

//完成时间

};sjf a1[100];

void input(sjf *p,int N1)//进程信息输入 {

int i;cout<

printf(“

请您输入进程的名字

到达时间

服务时间:(例如: a 0 100)n”);

for(i=0;i<=N1-1;i++){

printf(“

请您输入进程%d的信息:t”,i+1);

scanf(“ttt%s%f%f”,&p[i].name,&p[i].arrivetime,&p[i].servicetime);} }

void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,int N1)//最终结果输出

{

int k;

printf(“nt调用最短进程优先调度算法以后进程的调度顺序为:”);

printf(“%s”,p[0].name);

for(k=1;k

{printf(“-->%s”,p[k].name);}

cout<

printf(“n给个进程具体调度信息如下:n”);

printf(“nt进程名t到达时间t运行时间t开始时间t完成时间n”);

for(k=0;k<=N1-1;k++)

{

printf(“ t%st %-.2ftt %-.2ftt %-.2ftt %-.2ftn”,p[k].name,p[k].arrivetime，p[k].servicetime,p[k].starttime,p[k].finishtime);

}

getchar();

} void sort(sjf *p,int N1)//排序 {

for(int i=0;i<=N1-1;i++)

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

if(p[i].arrivetime

{

sjf temp;

temp=p[i];

p[i]=p[j];

p[j]=temp;

} } void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,int N1)//运行阶段

{ int k;

for(k=0;k<=N1-1;k++)

{

if(k==0)

{

p[k].starttime=p[k].arrivetime;

p[k].finishtime=p[k].arrivetime+float(p[k].servicetime)/60;}

else

{

p[k].starttime=p[k-1].finishtime;

p[k].finishtime=p[k-1].finishtime+float(p[k].servicetime)/60;}

}

}

void sjff(sjf *p,int N1){

float arrivetime=0,servicetime=0,starttime=0,finishtime=0;

sort(p,N1);

for(int m=0;m

{if(m==0)

p[m].finishtime=p[m].arrivetime+float(p[m].servicetime)/60;

else

p[m].finishtime=p[m-1].finishtime+float(p[m].servicetime)/60;

int i=0;

for(int n=m+1;n<=N1-1;n++)

{

if(p[n].arrivetime<=p[m].finishtime)

i++;

}

float min=p[m+1].servicetime;

int next=m+1;

for(int k=m+1;k

{

if(p[k+1].servicetime

{min=p[k+1].servicetime;

next=k+1;}

}

sjf temp;

temp=p[m+1];

p[m+1]=p[next];

p[next]=temp;

}

deal(p,arrivetime,servicetime,starttime,finishtime,N1);

Print(p,arrivetime,servicetime,starttime,finishtime,N1);

getchar();}//最短进程优先调度算法到这里结束

char menu()//用来输出相关信息的函数

{

char cse1;

while(1)

{

system(“cls”);

fflush(stdin);

cout<

cout<

cout<<“t”<<“|| <<<<<<<<<<<<欢<<<<<<<<<<< >>>>>>>>>>>>迎>>>>>>>>>>> ||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“||”<<“t 进程调度算法模拟”<<“tt”<<“||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“||”<<“tt 1.先来先服务调度算法 ”<<“tt”<<“||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“||”<<“tt 2.最短进程优先调度算法”<<“tt”<<“||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“|| <<<<<<<<<<<<<<<<<<<<<<<<<您>>>>>>>>>>>>>>>>>>>>>>>>> ||”<

cout<

cout<

cout<<“tt

请输入您的选择（1/2）：”;

cse1=getchar();

if(cse1<'1'||cse1>'2')

cout<<“你的输入有错！”<

else

break;

}

return cse1;} int main(int argc, char *argv[]){

while(1)

{

switch(menu())

{

case '1':

int N;

cout<

cout<

printf(“tt<<---！!@@@先来先服务调度算法@@@！!--->>n”);

cout<

printf(“输入进程数目:”);

scanf(“%d”,&N);

input(a,N);

FCFS(a,N);

case '2':

int N1;

cout<

cout<

printf(“tt<<---！!@@@最短进程优先调度算法@@@！!--->>n”);

cout<

printf(“输入进程数目: ”);

scanf(“%d”,&N1);

input(a1,N1);

sjf *b=a1;

sjf *c=a1;

sjff(b,N1);

getchar();

}

}

system(“PAUSE”);

return EXIT_SUCCESS;}

五、实验结果

1.执行结果

2.结果分析

先来先服务调度算法就是根据进程达到的时间为依据，哪一个进程先来那么该进程就会先执行；最短进程优先调度算法则是以每个进程执行所需时间长短为依据，某一个进程执行所需花的时间要短些那么该进程就先执行。以上就是本次进程调度实验的依据。

六、实验总结

通过本次实验了解到算法很重要，又更加明白算法本身可以节约时间，而且不同的函数之间在调用的时候要注意很多的问题。

第三篇：短作业优先调度和时间片轮转调度算法

实

验

报

告

学生姓名：

学 号：

指导教师：

一、实验室名称：

二、实验项目名称：进程调度算法的设计

三、实验原理：

短作业（进程）优先调度算法：短作业调度算法是从后备队列中选择一个或者若干个估计运行时间最短的作业，将他们调入内存运行。而短进程优先调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或者发生某事件而被阻塞放弃处理机时再重新调度。

时间片轮转法：系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的队尾；然后，再把处理机分配给就绪队列中的新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一个给定的时间内均能获得一时间片的处理机执行时间。

四、实验目的：

通过对进程调度算法的设计，深入理解进程调度的原理

五、实验内容：

1．编写程序实现SJ（P）F算法 2．编写程序实现RR算法

六、实验器材（设备、元器件）：

装有VC++6.0的PC机一台

七、实验步骤：

1．打开VC，设计编写程序的源代码 2．编译运行程序的源代码

3．分析检验程序的结果是否正确 4．总结实验结果及结论

短进程优先调度源代码： #include “stdio.h” struct sjf{ char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;};sjf a[100];void input(sjf *p,int N){ int i;printf(“intput the process's name & arrivetime & servicetime:nfor exmple: a 0 100n”);for(i=0;i<=N-1;i++){ printf(“input the %dth process's information:n”,i+1);scanf(“%s%f%f”,&p[i].name,&p[i].arrivetime,&p[i].servicetime);} } void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N){int k;

printf(“run order:”);

printf(“%s”,p[0].name);for(k=1;k%s”,p[k].name);}

printf(“nthe process's information:n”);

printf(“nnametarrivetservicetstarttfinishtzztdqzzn”);

for(k=0;k<=N-1;k++){ printf(“%st%-.2ft%-.2ft%-.2ft%-.2ft%-.2ft%-.2ftn”,p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);} } //排序

void sort(sjf *p,int N){

for(int i=0;i<=N-1;i++)

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

if(p[i].arrivetime

{

sjf temp;

temp=p[i];

p[i]=p[j];

p[j]=temp;

} } //运行阶段

void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N){ int k;

for(k=0;k<=N-1;k++)

{

if(k==0)

{

p[k].starttime=p[k].arrivetime;

p[k].finishtime=p[k].arrivetime+p[k].servicetime;}

else

{

p[k].starttime=p[k-1].finishtime;

p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}

}

for(k=0;k<=N-1;k++)

{

p[k].zztime=p[k].finishtime-p[k].arrivetime;

p[k].dqzztime=p[k].zztime/p[k].servicetime;

} } void sjff(sjf *p,int N){float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;//对结构进行初始化 sort(p,N);

for(int m=0;m

{if(m==0)

p[m].finishtime=p[m].arrivetime+p[m].servicetime;

else

p[m].finishtime=p[m-1].finishtime+p[m].servicetime;

int i=0;

for(int n=m+1;n<=N-1;n++)

{if(p[n].arrivetime<=p[m].finishtime)//判断内存中每次完成之后有多少到达的进程

i++;

}

float min=p[m+1].servicetime;

int next=m+1;//m+1=n

for(int k=m+1;k

{

if(p[k+1].servicetime

{min=p[k+1].servicetime;

next=k+1;}

}

sjf temp;

temp=p[m+1];

p[m+1]=p[next];

p[next]=temp;

}

deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);

Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);} void main(){ int N;

printf(“------短作业优先调度算法------n”);

printf(“input the process's number:n”);

scanf(“%d”,&N);

input(a,N);

sjf *b=a;

sjf *c=a;

sjff(b,N);}

时间片轮转法源代码： #include #define M 5

//物理页数 #define printf(“|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|n”)typedef struct PCB { int ID;int ReachTime;int TotalTime;}PCB;//进程号，到达时间和服务时间 typedef struct NOTE //备份 {

Myprintf int ID;int TotalTime;}NOTE;

PCB A[M];//5个进程 PCB a[M];NOTE temp;int queue[50];//记录调度的进程 int K=0;//调度进程数组的标识 void INIT()//初始化 { int i;for(i=0;i

A[i].ID=-1;} } int GetNum()//计算进程数 { int i,j=0;for(i=0;i

if(A[i].ID!=-1)

{

j++;

} } return j;} int GetReach(int time)//找出到达进程号 { int i;for(i=0;i

if(a[i].ReachTime<=time)

{

a[i].ReachTime=100;

return i;

} } return-1;} int GetInsert()//找出插入位置 { int i;for(i=0;i

if(A[i].ID==-1)

return i;} return-1;} void Forward(int num)//前移 { int i;for(i=0;i

A[i].ID=A[i+1].ID;

A[i].TotalTime=A[i+1].TotalTime;} A[num-1].ID=-1;} void Process()//执行进程 { queue[K]=A[0].ID;K++;A[0].TotalTime--;temp.ID=A[0].ID;temp.TotalTime=A[0].TotalTime;} void main(){ int i;int time;int t=0;int reach;int insert;int num;printf(“RR算法nn”);INIT();for(i=0;i

printf(“请输入进程ID：”);

scanf(“%d”,&a[i].ID);

printf(“请输入到达时间：”);

scanf(“%d”,&a[i].ReachTime);

printf(“请输入服务时间：”);

scanf(“%d”,&a[i].TotalTime);

} for(i=0;i

{

insert=GetInsert();

A[insert].ID=a[reach].ID;

A[insert].TotalTime=a[reach].TotalTime;

num=GetNum();

if(num==1)

continue;//进程数为1

else

{

//进程数不为1

Process();

Forward(num);

if(temp.TotalTime!=0)

{

A[num-1].ID=temp.ID;

A[num-1].TotalTime=temp.TotalTime;

}

} } else//没有进程到达

{

num=GetNum();

if(num==1)

{//进程数为1

Process();

if(temp.TotalTime==0)

{

A[0].ID=-1;

}

}

else if(num==0)

}

continue;//进程数为0

else

{

Process();

Forward(num);

if(temp.TotalTime!=0)

{

A[num-1].ID=temp.ID;

A[num-1].TotalTime=temp.TotalTime;

}

} } } printf(“n”);printf(“调度顺序为：n”);Myprintf;for(i=0;i<50;i++){ if(queue[i]!=-1)

printf(“|%2d ”,queue[i]);} printf(“|n”);Myprintf;printf(“n”);

八、实验数据及结果分析：

短作业优先调度算法的实验结果：

时间片轮转调度算法结果：

九、实验结论：

本次实验成功的完成了短作业优先调度算法和轮转时间片调度算法的模拟，通过本次实验我们了解到短作业优先调度算法不利于长作业的处理，因为长作业将长期得不到处理，而轮转时间片调度算法则解决了这一问题。短长作业均能在每一个周期内分得一个时间片处理自己的任务。

十、总结及心得体会：

通过本次实验对短作业优先调度算法和时间片轮转调度算法有了更深入的理解，同时，对程序算法能力有了进一步的提高，同时对模块化编程有了更深入得理解，代码的模块化会使程序的代码复用率提高，提高编程的效率。

十一、对本实验过程及方法、手段的改进建议：

本次实验的时间片轮转调度算法由于教材版本不一样有两种结果，本次实验本人采取的新教材的版本，新版本的难度较老教材要大很多，实验时候可以根据具体情况选择一个适合自己的来做。

报告评分：

指导教师签字：