操作系统实验报告（通用5篇）
在生活中，大家逐渐认识到报告的重要性，我们在写报告的时候要注意语言要准确、简洁。其实写报告并没有想象中那么难，以下是小编精心整理的操作系统实验报告，仅供参考，希望能够帮助到大家。
操作系统实验报告 1
一、实验目的
用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验内容和要求
编写并调试一个模拟的进程调度程序，采用“简单时间片轮转法”调度算法对五个进程进行调度。
每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已运行时间、进程状态等等。
进程的到达时间及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪 W（Wait）、运行R（Run）两种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。用运行时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应分配时间片给就绪队列中排在该进程之后的进程，并将它插入就绪队列队尾。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
三、实验主要仪器设备和材料
硬件环境：IBM-PC或兼容机
软件环境：C语言编程环境
四、实验原理及设计方案
1、进程调度算法：采用多级反馈队列调度算法。其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS原则排队等待高度。当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行，以此类推。
2、实验步骤:
（1）按先来先服务算法将进程排成就绪队列。
（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。
（3）检查该运行进程是否运行完毕，若运行完毕，则撤消进程，否则，将该进程插入到下一个逻辑队列的队尾。
（4）是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。
（5）重复步骤（2）、（3）、（4），直到就绪队列为空。
五、流程图
六、结果过程及截图 初始化队列
按Y键继续运行进程：
按Y键继续运行进程：
运行若干次后的状态：
添加新的进程：
七、所遇困难的解决以及心得体会
在这个多级反馈的实验中，我采取了用一条实际上的链表队列来模拟多个逻辑上的队列，通过维护几个链表的状态信息来找到每个进程运行完后应该插入的地方，还有一个标志位Fend用来表明新插入的队列的位置。虽然实验原理很简单，但是在编写代码的过程中遇到了不少的问题，在两个小时之内已经完成的大体代码的编写，但是之中存在不少的问题，导致了用了差不多四个小时的时间去调试才把它弄好，这主要归咎于在开始设计代码的.不太合理，在后期使得代码结构有些混乱，使得调试更加的麻烦，以及对编程的不熟悉。通过这个实验不仅使我对进程的调度算法有了更深的认识，使得理论知识得到的实践，也使我的编程能力得到了进一步提高。
七、思考题
1、 分析不同调度算法的调度策略，比较不同调度算法的优缺点，总结它们的适用范围。
答：动态有限权算法：动态优先权是指在创建进程时所创建的优先权，会随进程的推进或者等待时间的增加而改变，以便获得更好的调度性能。处理机为每个进程分配一定的时间片，在就绪队列中，优先权高的进程将优先获得处理机，进程在进去运行完响应的时间片后，如没完成，优先权减1，从新回到就绪队列等待分配处理机。
时间片的轮转法：系统将所有进程排成一个队列，按照先来先服务的原则，对队列首的进程进行处理，每个进程在用完自己的时间片后，从新回到队尾进行排队。每运行一次，进程的需要时间减1，直到就绪队列为空！
八、源代码
#include #include
#include
#define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0
#define TIME 2//时间片长度
typedef struct pcb{//进程管理块 char name[10];//进程名字 char state; //进程状态
int queue; int ntime; int rtime; int etime;
//进程所在的队列
//进程需要运行的时间
//进程已经运行的时间
//进程在本队列可运行的时间片
struct pcb *link;
}PCB;
PCB *ready = NULL, *p = NULL, *pfend = NULL,*p =NULL; 位置的变量
int geti() //使用户仅能输入整数 {
char ch; int i = 0; fflush(stdin); ch = get); while(ch ==){
//就绪队列，进程插入
printf(
fflush(stdin); ch = get); }
while(ch !=){
if(ch > 9 || ch
fflush(stdin); i = 0; ch = get);
}else{ i = i*10 + (ch - 0); }
ch = get);
}
return i;
}
void findpos()//更新状态量 {
PCB *ps = pfend;
if(!ps || !ps -> link || (ps-> link->queue - ps->queue) > 1) p = ps; else{ while (ps->link && ps ->link->queue != (pfend ->queue +2)) }
ps = ps->link; p = ps;
}
void ()//插入进程 {
if(!ready ){
ready = p;
pfend = p; p = p;
}else if(ready ->queue == 1){//第一队列存在
p->link = pfend->link; pfend->link = p; pfend = p; findpos();
}
void input()/*建立进程控制块函数*/ {
int i,num;
printf(
for(i=0; i
p=getpch(PCB);
printf(
printf(
p->queue =1;
p->etime = TIME; p->link=NULL;
();/*调用函数*/ } else{ p->link = ready; ready = p; }
findpos();
}
void disp(PCB *pr)/*建立进程现实函数，用于显示当前进程*/ {
printf(
}
void check()/*建立进程查看函数*/
{
}
void sort()//调整进程队列
{
} if(!ready->link ||ready->queue link->queue) return; p = ready ->link; ready ->link = p ->link; p ->link = ready; p = ready; ready = p; if (ready && ready -> queue == p ->queue){ findpos(); } PCB *pr; printf(
void addnew()//添加新的进程
{
if(ready ->queue != 1){ (ready -> queue)++; ready->etime *= 2; ready -> state=w; sort();/*调用sort函数*/ input(); } else{ input();
}
}
void destroy()/*建立进程撤销函数(进程运行结束，撤销进程)*/
{
}
void running()/*建立进程就绪函数(进程运行时间到，置就绪状态)*/
{
}
void main()
{
char ch; input(); while(ready != NULL) { printf(
}
ready ->state = R; check(); running(); printf(
操作系统实验报告 2
一、实验目的
本实验要求学生模拟作业调度的实现，用高级语言编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。
二、实验内容和要求
1、编写并调度一个多道程序系统的作业调度模拟程序。
作业调度算法：采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。 对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。
三、实验主要仪器设备和材料
硬件环境：IBM-PC或兼容机
软件环境：C语言编程环境
四、实验原理及设计方案
采用多道程序设计方法的操作系统，在系统中要经常保留多个运行的作业，以提高系统效率。作业调度从系统已接纳的暂存在输入井中的一批作业中挑选出若干个可运行的作业，并为这些被选中的作业分配所需的系统资源。对被选中运行的作业必须按照它们各自的作业说明书规定的步骤进行控制。
采用先来先服务算法算法模拟设计作业调度程序。
（1）、作业调度程序负责从输入井选择若干个作业进入主存，为它们分配必要的资源，当它们能够被进程调度选中时，就可占用处理器运行。作业调度选择一个作业的必要条件是系统中现有的尚未分配的资源可满足该作业的资源要求。但有时系统中现有的尚未分配的资源既可满足某个作业的要求也可满足其它一些作业的'要求，那么，作业调度必须按一定的算法在这些作业中作出选择。先来先服务算法是按照作业进入输入井的先后次序来挑选作业，先进入输入井的作业优先被挑选，当系统中现有的尚未分配的资源不能满足先进入输入井的作业时，那么顺序挑选后面的作业。
(2) 假定某系统可供用户使用的主存空间共100k，并有5台磁带机。
（3)流程图:
五、结果过程及截图
读取文件jobs.txt来初始化主存，磁带机的个数，并打印出来。
初始时间是9:00：
按Y运行5分钟：
按Y运行5分钟：
按Y运行5分钟：
多次运行后最后状态：
六、所遇困难的解决以及心得体会
这个实验是花的时间最多的一个实验，第一次做的时候由于理解有些问题，所以做错了。之后重新做了一遍，收获还是很多的，遇到了很多的细节问题，例如像是时间化成浮点数和浮点数化成时间等一些问题，从中也暴露了自己的编程能力欠缺，之后要多多的写程序。
七、思考题
1、 写出每种算法的调度策略，最后比较各种算法的优缺点。
答：先来先服务算法是根据作业的进入时间来排序,到达时间短的先运行，优点是实现简单，缺点是运行时间慢。
短作业优先算法是根椐作业的估计运行时间来排序，估计运行时间短的先运行，优点是运行时间快,缺点是实现起来比较复杂。
2、 选择调度算法的依据是什么？
答：如果作业要求的速度不高，而且作业比较小型，那就最好用先来先服务算法。
如果作业要求的速度高，作业流程复杂，那就最好用短作业优先算法。
八、源代码
#include
#include
#include
#include
#define getjcb() (JCB*)malloc(sizeof(JCB))
typedef struct {//资源的总量
int memory; int tape;
}RESOURCE;
typedef struct JCB {//作业控制块
char username[20];//用户名
char jobname[10];//作业名
char state;//作业状态 char atime[5];//到达时间 float rtime;//运行时间 RESOURCE resource;//资源数量 struct JCB*link; }JCB;
RESOURCE source = {100,5};
JCB *pjcb =getjcb();//作业链表头
char nowtime[5];//现在时间,初始时间为9：00
FILE* ignore(FILE *fp)//忽略文件中的空白符
{
if(feof(fp)) return fp; char ch = fgetc(fp); while (!feof(fp) && (ch ==|| ch ==)){ ch = fgetc(fp); } //if(!feof(fp)) return fp; fseek(fp, -1, SEEK_CUR);
return fp;
}
FILE* findFILE *fp,char c)//在文件中找到一个字符的位置(读取文件时用) {
if(feof(fp)) return fp; char ch = fgetc(fp); while (!feof(fp) && (ch != c)){ } ch = fgetc(fp); fseek(fp, -1, SEEK_CUR); return fp;
}
void destory()//释放链表所占的内存
{
JCB *p = pjcb->link; while(pjcb){ free(pjcb); pjcb = p; if(p) p = p->link;
}
}
float stof(char *time)//把时间转化为浮点型数
{
float h = 0, m = 0; int i = 0; while(time[i] != :){ h = h*10 + time[i] - 0; } i++; while(time[i] != ){ m = m*10 + time[i] - 0; } i++; i++;
return (h + m/60);
}
char* ftos(double ftime)//把浮点型数值转化为时间
{
}
float timesub(char *time1, char *time2)//两个时间相减，得到时间差
{
}
void print()//打印输出
{
JCB *p = pjcb->link; printf(
p->atime, p->rtime, p->resource.memory,p->resource.tape);
}
void sendsource()//为作业分配资源
{
JCB *p; p = pjcb->link; while(p){//为到达的作业调度 p = p->link; }
if(p->state == W && source.memory - p->resource.memory >=0 && source.tape - p->resource.tape >=0){
} } p = p->link; p->state = R; source.memory -= p->resource.memory; source.tape -= p->resource.tape; printf(
}
void init()//初始化，读取文件中的作业信息
{
FILE *fp; JCB *p= NULL,*q = pjcb ; if((fp = fopen(
} } fp = ignore(fp); p->rtime = 0;//不初始化则会发生错误，？？？？？ fscanf(fp,
int checkend() //检查是否所有的作业都已经运行完了
{
JCB *p = pjcb ->link; while(p){ if(p ->state != F){ return 0; } p = p->link; } return 1;
}
void run()//运行作业
{
if(checkend()){//检查是否所有的作业都已经运行完了 printf(
}
} p = p->link; } p = pjcb ->link; while(p){//计算到达的作业 if( strcmp(nowtime, p->atime) ==0 && p->state == N){ p->state = W; printf(
int main()
{
char ch;
double time =9.00;
}
double step = float(5)/60+0.00001; ftos(9.0); init(); do{ run(); puts(
操作系统实验报告 3
一、实验目的
模拟文件系统实现的基本功能,了解文件系统的基本结构和文件的各种管理方法,加深理解文件系统的内部功能及内部实现。通过用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。
二、实验内容和要求
编程模拟一个简单的文件系统，实现文件系统的管理和控制功能。要求本文件系统采用两级目录，即设置主文件目录[MFD]和用户文件目录[UED]。另外，为打开文件设置运行文件目录[AFD]。设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件，并对文件必须设置保护措施。在用户程序中通过使用文件系统提供的Create、open、read、write、close、等文件命令，对文件进行操作
三、实验主要仪器设备和材料
硬件环境：IBM-PC或兼容机
软件环境：C语言编程环境
四、实验原理及设计方案
1、实验原理
运用二级目录思想来模拟文件系统。
为每个用户建立一个单独的用户文件目录UFD。这些文件目录具有相似的结构，它由用户文件的文件块组成。此外，在系统再建立一个主文件目录MFD；在主文件目录中，每个用户目录都占有一个目录项，其目录项中包含文件名和指向该文件目录文件的指针。
3、程序流程图
五、结果过程及截图
系统的使用简要说明：
登陆：
create命令新建文件
file5
Create失败
命令删除文件
Delete失败：
open打开命令，及write命令来追加文件
Read命令和close命令关闭
对没打开的文件读写：
六、所遇困难的解决以及心得体会
本实验的代码长度的最常的，但是原理很简单，并且实验要求的是模拟，所以大大降低了实验的难度，在操作系统课中我们还有一个课程设计，也是文件管理系统，但是要比这个难很多，通过这个实验，我对文件管理系统的运行机制有了深入的了解，因为要做好这个实验必须要懂得文件管理系统的'架构，这也迫使我认认真真的研究了操作系统中关于文件管理这一章的内容。同时这个程序也为以后的课程设计奠定了基础，并且很多的代码也是可以重用的。
七、思考题
1、文件系统要解决哪些问题？
答：要解决文件和用户是否同名，文件创建数是否超额，所要求文件是否存在等问题。
2、什么是文件目录？什么是文件目录中包含哪些信息？目前广泛采用的目录结构形式是哪种？
答：文件目录就是用来展示一个用户的所有文件的一个表格，文件目录应包含文件名，保密码,文件大小，目前广泛采用的目录结构形式是多级目录形式。
八、源代码
#include
#include
#include
#include
#define NULL 0
typedef struct mdf{//MDF结构体
char username[20];//用户名 char filename[20];//文件名
struct mdf *next;
}MDF;
typedef struct ufd{//UFD结构体
char filename[20];//文件名
int protect;//文件保护码 unsigned int length;//文件长度
struct ufd *next;
}UFD;
typedef struct afd{//AFD结构体
char filename[20];//文件名 int protect;//文件保护码 unsigned int point;//文件读写指针
struct afd *next;
}AFD;
MDF *pmdf;//全局链表头指针
UFD *pufd;
AFD *pafd;
char UserUFD[20];//已经登陆成功的用户名
void initMDF()//初始化MDF表
{
FILE *fp; pmdf= (MDF*)malloc(sizeof(MDF)); MDF *p = pmdf; if((fp = fopen(
} exit(1); } while (!feof(fp)){//把MDF文件中的内容装入链表 } p->next = (MDF*)malloc(sizeof(MDF)); p = p->next; fscanf(fp,
void printUFD()//打印MDF表 {
UFD *p = pufd->next; puts(
}
void initUFD(char *name)//初始化UFD表 {
FILE *fp; pufd= (UFD*)malloc(sizeof(UFD)); UFD *p = pufd; if((fp = fopen(name,
} p->next = NULL; fclose(fp);
int checkuser()//检测登陆的用户名 {
} char username[20]; while(1){ puts(
void initAFD()//初始化AFD {
pafd = (AFD*)malloc(sizeof(AFD)); pafd->next = NULL; }
bool create()//创建文件命令 {
char filename[20]; UFD *p = pufd->next; AFD *pa = pafd; puts(
} } if(!p->next) break; p= p->next; p->next = (UFD*)malloc(sizeof(UFD)); p=p->next; strcpy(p->filename, filename); p->protect = 2; p->length = 0; p->next = NULL; while(pa->next){//创建文件后加入到AFD } pa=pa->next; pa->next = (AFD*)malloc(sizeof(AFD)); pa = pa->next; strcpy(pa->filename ,filename); pa->protect = 2; pa->point = 0; pa->next = NULL; return 1;
}
bool _()//删除文件命令 {
char filename[20]; puts(
puts(
return 0;
}
bool open()//打开文件命令
{
char filename[20]; unsigned int protect; puts(
} } puts(
void close()//关闭文件命令
{
char filename[20]; UFD *pu = pufd->next; puts(
int read()//读文件命令
{
char filename[20]; unsigned int length; AFD *p = pafd->next;
} puts(
int write()//写文件命令
{
}
char filename[20]; unsigned int length; AFD *p = pafd->next; puts(
void destroy()//释放内存
{
}
void saveUFD()//保存UFD文件
{
}
void bye()//推出系统
{ FILE *fp; UFD *p = pufd->next; if((fp = fopen(UserUFD,
UFD *pu = pufd->next; while(pa){ if(pa->protect == 2){ while(pu){ } saveUFD(); printUFD(); destroy(); } } if(strcmp(pa->filename, pu->filename) == 0){ } pu->length = pa->point; break; pu = pu->next; pa =pa->next;
}
void operate()//命令识别
{
while(1){ char command[20]; char name[][8] = {
}
} return; }else puts(
void print()
{
puts(
int main()
{
}
print(); initMDF(); checkuser(); initAFD(); operate();)//命令识别 return 0;
操作系统实验报告 4
1.实习目的
(一).通过综合实训进一步巩固、深化和扩展学生的专业技能。
1.熟练掌握Linux操作系统的安装及基本配置。
2.熟练掌握Linux系统管理。
3.掌握Linux下用户和组的管理。
4.掌握Linux下FTP服务器的管理。
(二)训练和培养学生获取信息和处理信息的能力，充分培养和提高学生的动手能力，学会通过网站、书籍等方式收集所需的.资料。
(三)培养学生运用所学的知识和技能解决Linux使用、管理过程中所遇到的实际问题的能力及其基本工作素质。
(四)培养学生理论联系实际的工作作风、严肃认真的科学态度以及独立工作的能力，树立自信心。
(五)训练和培养学上的团队协作精神与合作能力。
2 实习概况
2.1 实习要求
具体来讲，《linux操作系统》课程包括以下实习内容：
(一)独立完成实训。
(二)要求熟练掌握Linux操作系统的安装与基本配置。
(三)熟练掌握Linux系统管理基本方法。
(四)掌握Linux下用户和组的管理。。
(五)掌握Linux下的FTP服务器的管理。
2.2 实习时间
20XX年12月16日至20XX年12月20日
2.3 实习基本情况
实习地点：四教学楼 4112、4212、4312、4412
实习环境 :RedHat9软件
实习内容:掌握linux操作系统
2.4 硬件环境
3 实习内容
3.1 linux安装 Linux是一类Unix计算机操作系统的统称。Linux 是以Unix 操作系统为原型的多任务、多用户的系统。可运行于多种硬件平台：PC、Alpha、SPARC、
POWER PC。 今天实习的主要内容是学习了解Linux的安装过程;Linux登录和退出 ，熟悉Linux操作系统的图形界面
(一)Linux的安装过程
1)VMware软件的安装
因为我用的是机房的电脑，所以不用安装VMware软件。如果要安装，过程十分简单，下载完毕，直接“Next”即可完成安装。
2)虚拟机的安装。打开VMware软件，单击“新建虚拟机”命令根据提示选择一种要安装的操作系统，一般选择典型设置，然后直接按“下一步”即可。需要注意的就是在分区的时候需按要求建立合适的分区，如下图所示。
图3-1-1 选择分区
3)Red Hat Linux 9.0安装
首先单击“编辑虚拟机设置”，改写镜像为“linux9cd1”，然后返回初始界面。点击“启动该虚拟机”，便进入到软件的安装过程。开始是“欢迎使Red Hat Linux”界面，然后经历语言选择、键盘配置、鼠标配置、磁盘分区设置、选择软件包组、安装软件包等操作后，然后是虚拟机安装完第一张盘后要进行第二张盘的安装，如图3-2经过老师的指点，按住“Ctrl+Alt”，将鼠标调出，双击右下方任务栏第一个按钮，依次选择第二、三镜像，继续安装，便安装成功了。如图3-3。
操作系统实验报告 5
一、课程设计任务划分
二、基本原理
（一）页面置换算法定义
在地址映射过程中，若在页面中发现所要访问的页面不再内存中，则产生缺页中断。当发生缺页中断时操作系统必须在内存选择一个页面将其移出内 存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做页面置换算法。
（二）所使用的算法
1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内 不再被访问的页面换出。
2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即 选择在内存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用 的页面。
（三）设计思想
选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换：
OPT基本思想：
是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。数组next[mSIZE]记录物理块中对应页面的最后访问时间。每当发生缺页时，就从物理块中找出最后访问时间最大的页面，调出该页，换入所缺的页面。
FIFO基本思想：
是用队列存储内存中的页面，队列的特点是先进先出，与该算法是一致的，所以每当发生缺页时，就从队头删除一页，而从队尾加入缺页。或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间，每次需要置换时换出进入时间最小的页面。
LRU基本思想：
是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。数组flag[10]标记页面的访问时间。每当使用页面时，刷新访问时间。发生缺页时，就从物理块中页面标记最小的一页，调出该页，换入所缺的页面。
三、基本思路
实验环境：vc++，编程语言：c语言 #include #include /*全局变量*/
int mSIZE; /*物理块数*/
int pSIZE; /*页面号引用串个数*/
static int memery[10]={0}; /*物理块中的页号*/ static int page[100]={0}; /*页面号引用串*/ static int temp[100][10]={0}; /*辅助数组*/ /*置换算法函数*/ void FIFO(); void LRU(); void OPT(); /*辅助函数*/
void print(unsigned int t); void designBy(); void download();
void mDelay(unsigned int Delay); /*主函数*/ void main() {
int i,k,code; system("color 0A"); designBy(); printf("┃请按任意键进行初始化操作... ┃ "); printf("┗━━━━━━━━━━━━━━━━━━━━━┛ "); printf(" >>>"); getch(); system("cls"); system("color 0B"); printf("请输入物理块的个数(M<=10)："); scanf("%d",&mSIZE); printf("请输入页面号引用串的个数(P<=100)："); scanf("%d",&pSIZE); puts("请依次输入页面号引用串(连续输入，无需隔开)："); for(i=0;i
scanf("%1d",&page[i]); download(); system("cls"); system("color 0E"); do{ puts("输入的页面号引用串为："); for(k=0;k<=(pSIZE-1)/20;k++)
{ for(i=20*k;(i
(i==pSIZE-1))) printf("%d ",page[i]); else printf("%d ",page[i]); } } printf("* * * * * * * * * * * * * * * * * * * * * * *"); printf("* 请选择页面置换算法： *"); printf("* ----------------------------------------- *");
printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *"); printf("* 3.最佳(OPT) 4.退出 *"); printf("* * * * * * * * * * * * * * * * * * * * * * *"); printf("请选择操作：[ ]"); scanf("%d",&code); switch(code) {
case 1:
FIFO(); break; case 2:
LRU(); break; case 3:
OPT(); break; case 4: system("cls"); system("color 0A"); designBy(); /*显示设计者信息后退出*/ printf("┃谢谢使用页面置换算法演示器!
┃ "); printf("┗━━━━━━━━━━━━━━━━━━┛ "); exit(0); default: printf("输入错误，请重新输入："); } printf("按任意键重新选择置换算法：>>>"); getch();
system("cls"); }while (code!=4); getch(); }
/*载入数据*/ void download() { int i; system("color 0D"); printf("╔════════════╗ "); printf("║正在载入数据，请稍候 !!!║ "); printf("╚════════════╝ "); printf("Loading... "); printf(" for(i=0;i<51;i++) printf(""); for(i=0;i<50;i++) { mDelay((pSIZE+mSIZE)/2); printf(">"); } printf(" Finish. 载入成功，按任意键进入置换算法选择界面：
>>>"); getch(); }
/*设置延迟*/
void mDelay(unsigned int Delay) {
unsigned int i;
for(;Delay>0;Delay--) { for(i=0;i<124;i++) { printf(" "); } } }
/*显示设计者信息*/ void designBy() { printf("┏━━━━━━━━━━━━━━━━━━━━┓ "); printf("┃ 页面置换算法 ┃ "); printf("┃ 12级1班 ┃ ");
O");
printf("┃ 姓名：张海洋，李奔 ┃ "); printf("┣━━━━━━━━━━━━━━━━━━━━┫ "); }
void print(unsigned int t) { int i,j,k,l; int flag; for(k=0;k<=(pSIZE-1)/20;k++) { for(i=20*k;(i
printf("置换次数：%d ",t); printf("访问命中率：%d%% ",(pSIZE-(t+mSIZE))*100/pSIZE); printf("---------------------------------------- "); }
/*计算过程延迟*/ void compute() { int i; printf("正在进行相关计算，请稍候"); for(i=1;i<20;i++) { mDelay(15); if(i%4==0) printf(" "); else printf("Θ"); } for(i=0;i++<30;printf("")); for(i=0;i++<30;printf(" ")); for(i=0;i++<30;printf("")); }
/*先进先出页面置换算法*/ void FIFO() {
int memery[10]={0};
int time[10]={0}; /*记录进入物理块的时间*/ int i,j,k,m;
int max=0; /*记录换出页*/ int count=0; /*记录置换次数*/ /*前mSIZE个数直接放入*/ for(i=0;i
memery[i]=page[i]; time[i]=i;
for(j=0;j
for(i=mSIZE;i
if(memery[j]!=page[i]) k++;
}
if(k==mSIZE) /*如果不在物理块中*/ {
count++; /*计算换出页*/
max=time[0]
time[max]=i; /*记录该页进入物理块的时间*/ for(j=0;j
for(j=0;j
/*最近最久未使用置换算法*/ void LRU() {
int memery[10]={0};
int flag[10]={0}; /*记录页面的访问时间*/ int i,j,k,m;
int max=0; /*记录换出页*/ int count=0; /*记录置换次数*/ /*前mSIZE个数直接放入*/ for(i=0;i
memery[i]=page[i]; flag[i]=i;
for(j=0;j
for(i=mSIZE;i
if(memery[j]!=page[i]) k++; else flag[j]=i; /*刷新该页的访问时间*/ }
if(k==mSIZE) /*如果不在物理块中*/ {
count++; /*计算换出页*/
max=flag[0]
flag[max]=i; /*记录该页的访问时间*/ for(j=0;j
for(j=0;j
/*最佳置换算法*/ void OPT() {
int memery[10]={0};
int next[10]={0}; /*记录下一次访问时间*/ int i,j,k,l,m;
int max; /*记录换出页*/
int count=0; /*记录置换次数*/ /*前mSIZE个数直接放入*/ for(i=0;i
memery[i]=page[i]; for(j=0;j
for(i=mSIZE;i
/*判断新页面号是否在物理块中*/ for(j=0,k=0;j
if(memery[j]!=page[i]) k++; }
if(k==mSIZE) /*如果不在物理块中*/ { count++; /*得到物理快中各页下一次访问时间*/ for(m=0;m=next[1]?0:1; for(m=2;mnext[max]) max=m; /*下一次访问时间都为pSIZE,则置换物理块中第一个 */ memery[max]=page[i]; for(j=0;j
for(j=0;j
四、调试及实验结果
第一组数据：
1.运行结果
2. 按任意键进行初始化：
3. 载入数据：
4. 进入置换算法选择界面：
5.运算中延迟操作：
6.三种算法演示结果
7.退出算法
第二组数据：
1.运行结果
2．按任意键进行初始化：
3.载入数据：
4.进入置换算法选择界面：
5.运算中延迟操作：
6. 三种算法演示结果
7.退出算法
五、个人体会
由于时间有限，本次设计完成的'并不是很完美，下面从以下几点来说明本次课程设计的个人体会：
1.本次课程设计中做的比较好的地方：
做的好的地方就是在于对题目意思的正确理解，以及在此基础上的模型设计。最开始一看题目的时候感觉很迷茫，有点不知道如何着手，等静下心来仔细分析了程序，明确了目标，明确了思路，才对程序有了一个较为完整的实现。
2.做得不太好的地方，以及以后如何改正：
做得不太好的地方就是不能把自己所学的C知识和本次课程设计的相关知识很好的结合起来，以至于没有很好的表达出本次课程设计的细节。在以后的过程中，我会运用本次课程设计中所学的知识，以及思考问题的方式和方法，争取能够发扬优点，尽量克服不细心，不严谨等缺点。
3.从本次设计中得到的收获：
通过本次课程设计，我学会了综合运用所学相关知识的能力，动手能力以及独立思考问题的能力。下面具体的收一个边学程序是遇到的困难，首先就是如何把想法变为做法的问题，最开始一拿到题目，我就觉得无从下手，因为我的阅历，不知道如何把这样一个问题变成程序，变成能够让人一目了然的东西，于是，我就先写下了p,v操作的实现过程，因为这个对我来说简单一些，然后，在此基础之上，就好办了，结果最后用了2个函数就解决问题了，所以，我觉得有时候思考问题不要太死脑筋，换一个角度的话，也许会更好，说不定就能达到事半功倍的效果。
由小编花开半夏时整理的文章操作系统实验报告（通用5篇）分享结束了，希望给你学习生活工作带来帮助。