第一篇：操作系统课程设计++模拟磁盘文件管理的程序[精选]
中南林业科技大学
操作系统课程设计
课程题目：模拟磁盘文件管理的程序
姓名: 学号:
专业: 计算机科学与技术 年级:
2006
计算机科学学院
2008年11月 模拟磁盘文件管理的程序
一、课程设计内容
⑴ 自定义磁盘文件管理的数据结构； ⑵ 能够自由创建、修改、删除文件； ⑶ 文件具有一定自定义的属性； ⑷ 能够显示当前系统文件的状态。
二、课程设计的数据结构说明
程序中定义了两个类： class file//文件类 {private: char name[10];//文件名 public: int tag;//删除标记 1:已删 0:未删 file(){ } char *getname(){return name;} //获取文件名
int gettag(){return tag;} //获取删除标记
int getlength(){return length;} //获取文件大小
int getblocknum(){return blocknum;} // 磁盘块数
int getblocksum1(){return blocksum1;} //磁盘块号的始点 int getblocksum2(){return blocksum2;} //磁盘块号的终点 int length，blocknum，blocksum1，blocksum2;
void setname(char na[ ]){strcpy(name,na);} //设置文件名 void delwenjian(){ tag=1;}//设置删除标记 1:已删 0:未删
void creatfile(char *na,int L,int num,int s1,int s2)//创建文件 void deltefile(char *na){tag=1;strcpy(name,na);} //删除文件 void disp()//输出文件信息 class fdatabase //文件库类 { private: int top;//文件记录指针 file f[50];public: fdatabase(){top=-1;} //构造函数 int search(char *fname)//按文件名查找
int creatfile(char *na,int L,int num,int s1,int s2)//创建文件时先查找是否存在
int deltefile(char *na)//删除文件时先查找是否存在 void disp()//输出所有文件信息 };
三、课程设计的模板说明
1、初始化，建立文件系统
输入磁盘大小（G），每个盘块大小（M），自动建立位示图，位示图字长定为32位
输出位示图的行数，以及行号、列号与磁盘块号的转换公式（都从0开始编号）。
2、循环选择执行以下功能
1、存储文件
输入建立的文件名和文件大小，如果该文件名已经存在，则输出不能建立的信息否则计算所需的磁盘块数
为其分配足够多的磁盘块，并记录下来 输出所占用的磁盘块号
2、删除文件
输入要删除的文件名，如果该文件名不存在，则输出删除错误信息，否则收回该文件所占用的磁盘块 删除该文件名
3、显示位示图情况
显示位示图的情况 显示剩余磁盘块的数目
4、显示文件列表
显示文件名，文件大小，占用的磁盘块数目和磁盘块号
四、课程设计的源代码
#include
char name[10];//文件名 public: int tag;//删除标记 1:已删 0:未删 file(){ } char *getname(){return name;} //获取姓名
int gettag(){return tag;} //获取删除标记
int getno(){return no;} //获取文件编号
int getlength(){return length;} //获取文件大小
int getblocknum(){return blocknum;} // 磁盘块数 int getblocksum1()//磁盘块号的始点 { return blocksum1;} int getblocksum2()//磁盘块号的终点 { return blocksum2;} int length;//文件大小
int blocknum;//盘块数
int blocksum1;//所占盘块号的始点
int blocksum2;//所占盘块号的终点
void setname(char na[ ])//设置文件名
{strcpy(name,na);} void delwenjian(){ tag=1;}//设置删除标记 1:已删 0:未删
void creatfile(char *na,int L,int num,int s1,int s2)//创建文件 { tag=0;length=L;blocknum=num;blocksum1=s1;blocksum2=s2;strcpy(name,na);blocknum=length/m;//盘块数=文件大小/盘块大小 if(length%m!=0)//盘块数取上整 blocknum=blocknum+1;cout<<“ 所需磁盘块数：”< for(;j<32;j++) a[i][j]=1;i=i+1;for(j=0;j<(sum+blocknum)-32;j++)//再进行剩余项赋值 { a[i][j]=1;} sum=sum+blocknum-32;} tt=tt+blocknum;//输出文件所占用的盘块号 cout<<“ 所占磁盘块号：”< { for(ii=0;ii<=top;ii++) { if(strcmp(f[ii].getname(),fname)==0 && f[ii].tag==0) return 0; } return 1;} int creatfile(char *na,int L,int num,int s1,int s2)//创建文件时先查找是否存在 { int p;p=search(na); if(p==1) { top++; f[top].creatfile(na,L,num,s1,s2); return 1;} else {cout<<“！!该文件已存在,不能创建！!nn”; return 0;} } int deltefile(char *na)//删除文件时先查找是否存在{int b,p,x=0,n1,n2,q1,q2,t;p=search(na);if(p==0)//若文件存在 { //进行删除文件赋值 f[ii].tag=1;b=f[ii].length/m;//盘块数=当前文件大小/盘块大小 if(ii==0)// 对第一个删除文件进行赋值 for(k=0;k a[x][k]=0; else{ n1=(f[ii-1].blocksum2+1)/32;//被查找的文件之前文件所占用的盘块数 /32，//大于0表示跨行 n2=(f[ii].blocksum2+1)/32;//所有文件所占用的盘块数/32，大于0表示跨行 q1=(f[ii-1].blocksum2+1)-n1*32;// 当前文件的开始盘块号 q2=(f[ii].blocksum2+1)-n2*32;// 用于跨行后计算盘块号 t=n2-n1;if(t==0)//若n2与n1相等，表明当前所有被占用盘块在同一行 for(k=q1;k<1+b;k++) a[n2][k]=0; else { if((f[ii-1].blocksum2+1)%32==0)//前面所占用的盘块数是32倍数 { x=x+n1;//当前文件赋值 for(;t-1>=0;t--,x++)//循环进行整行赋值 for(k=0;k<32;k++) a[x][k]=0; x=n2;//对剩余项赋值 for(k=0;k a[x][k]=0; } else //对当前文件前几项赋值 { x=n1; for(k=q1;k<32;k++) a[x][k]=0;x=x+1;int t1=t; for(;t-1>0;t--,x++)//中间整行赋值 for(k=0;k<32;k++) a[x][k]=0; x=n2;//最后剩余项赋值 for(k=0;k<(f[ii].blocksum2+1)-t1*32;k++) a[x][k]=0; } } return 1;} } else {cout<<“该文件不存在”; return 0;} } void disp()//输出所有文件信息 { for(int i=0;i<=top;i++) if(f[i].tag==0) f[i].disp();} };void bit_map(int I){ int s=0;cout<<“-”< cout< out<<“--”< a[i][j]=0; cout<<“ 建立的位示图为：”< cout<<“ 行数：”< cout <<“ttt1 存 储 文 件nnttt2 删 除 文 件 nnttt3 显示位示图情况 nnttt4 显示文件列表”< case '1': cout <<“ 请输入文件名: ”; cin>>fname; cout< if(q==0) { cout<<“！!该文件已存在,不能创建！!nn”; break;} cout <<“ 请输入文件大小MB: ”; cin>>l; cout< if(l>g*1024) {cout<<“！!文件大小超过磁盘最大容量,无法进行分配！!”< break;} p.creatfile(fname,l,b,ss1,ss2); break; case '2': cout <<“ 请输入文件名: ”; cin>>fname; cout< q=p.search(fname); if(!q==0) { cout<<“！!该文件不存在，无法删除！!nn ”; break; } p.deltefile(fname); break;case '3': cout <<“tt**************显示位示图如下*********************n”; bit_map(I); cout< break; case '4': cout <<“tt*************文件列表如下************************n”;cout<<“-”< p.disp(); cout< break;default: cout<<“输入错误，请从新输入： nn”; break;} } } 五、课程设计程序运行结果 1、初始化，建立文件系统 （1）用户根据提示输入磁盘大小（GB）与每个盘块大小（MB）； （2）程序首先根据用户输入的磁盘大小（GB）与每个盘块大小（MB），自动建立位示图，即初始化位示图，位示图每一行长度固定为32位（即列固定为32）；位示图中每一位表示一个盘块，取值0和1分别表示空闲和占用。初始化的位示图应全为0； （3）程序再输出位示图的剩余盘块数，行数，以及行号、列号与磁盘块号的转换公式（行列皆从0开始编号）； 这样，初始化，建立文件系统完成。运行结果： 2、选择执行：存储文件，删除文件，显示位示图情况，显示文件列表 【显示文件管理系统列表】显示文件系统管理列表，并提示输入信息1——4。用户输入文件操作命令1（存储文件），2(删除文件)、3（显示位示图情况）、4（显示文件列表）； 格式如下：键入1，创建文件名为fname，大小为L（MB）的文件； 键入2，删除文件名为fname的文件； 键入3，显示位示图情况； 键入4，显示所有文件信息。 运行结果： 【存储文件】 用户输入文件操作命令是1（存储文件)。系统提示你输入你要建立的文件名和文件大小，如果该文件名已经存在，则系统提示输出不能建立此文件的信息，否则计算所需的磁盘块数和所占用的磁盘块号，并输出结果。相应的在位示图上，因为位示图是矩阵，可以用数组存储，根据所占用的磁盘块号和公式： 磁盘块号＝行号*32+列号 行号＝磁盘块号/32 列号＝磁盘块号％32 计算出文件占用的磁盘块在位示图上的位置，现在是创建文件，所以将位示图该位置上的二进制数置1，表示已分配出去。 分别创建名为ll，zz和mm三个文件，文件大小分别为224MB，320MB和56MB。 此时对应的位示图如下： 文件列表如下： 若再创建一个已经创建过的文件，则显示如下信息： 若创建的文件大小超过磁盘的最大容量，则显示如下信息： 【删除文件】 用户输入文件操作命令是2(删除文件)。系统提示你输入要删除的文件名，如果该文件名不存在，则输出删除出错信息。在位示图上，根据所占用的磁盘块号和公式： 磁盘块号＝行号*32+列号 行号＝磁盘块号/32 列号＝磁盘块号％32 计算出文件占用的磁盘块在位示图上的位置，现在是删除文件，所以将位示图该位置上的二进制数置0，表示收回该文件所占用的磁盘块。删除第二个文件zz，结果如下： 则相应的位示图和文件列表变为： 若删除一个不存在的文件，则显示如下信息： 【显示位示图情况】 如果用户输入文件操作命令是我wst()(显示位示图情况)，系统输出此时位示图的情况，状态位为'0'表示对应盘块空闲，状态位为'1'表示该盘块已被分配出去。系统再显示剩余磁盘块的数目。 以下是删除zz文件,创建xx后和创建xx后，删除ll的位示图： 【显示文件列表】 如果用户输入文件操作命令是disp()（显示所有文件情况)，系统会显示所有文件的文件名，文件大小，占用的盘块数和盘块号。 以下是删除zz文件,创建xx后和创建xx后，删除ll显示的文件列表： 1.实验题目: 磁盘调度算法。 建立相应的数据结构； 在屏幕上显示磁盘请求的服务状况； 将一批磁盘请求的情况存磁盘文件，以后可以读出并重放； 计算磁头移动的总距离及平均移动距离； 支持算法：FIFO、SSTF、SCAN、CSCAN; 2.设计目的: 调度磁盘I/O请求服务，采用好的方式能提高访问时间和带宽。本实验通过编程对磁盘调度算法的实现，加深对算法的理解，同时通过用C++语言编写程序实现这些算法，并在windos平台上实现，更好的掌握操作系统的原理以及实现方法，提高综合运用专业课知识的能力。 3.任务及要求 3.1 设计任务 编程实现下述磁盘调度算法，并求出每种算法的平均寻道长度： 1、先来先服务算法（FCFS） 2、最短寻道时间算法（SSTF） 3、扫描算法（SCAN） 4、循环扫描算法（CSCAN） 3.2 设计要求 对用户指定的磁盘调度请求序列，基于以上四种算法，实现各自的调度顺序并输出，同时计算出各种算法下的平均寻道长度。 4.算法及数据结构 4.1算法的总体思想 queue[n] 为请求调度序列，diskrode为磁盘磁道数，headstarts为正在调度的磁道 ①先来先服务算法（FCFS）按queue[n]数组的顺序进行磁盘调度，将前一个调度磁道与下一个调度磁道的差值累加起来，得到总的寻道长度，再除以n得到平均寻道长度。 ②最短寻道时间优先算法（SSTF）将queue[n]进行由小到大的排序，首先定位当前调度磁headstarts在queue[n]的位置，通过循环语句找出离起始磁头最短的位置。 ③扫描算法（SCAN） 将queue[n]进行由小到大的排序，首先定位当前调度磁headstarts在queue[n]的位置，然后在此位置按给定的方向遍历queue[n]，当道端点（queue[0]或queue[n-1]）时，再在定位处反向遍历到另一端。当调度磁道不在queue端点时，总的寻道长度为为前一个磁道与后一个磁 道差值的累加，当到达端点且queue[n]未全调度时，总寻道长度加上端点值再加上下一个调度磁道的值，再按前面的算法进行，直到磁道全部都调度完毕，得到总的寻道长度，除以n得到平均寻道长度。 ④循环扫描算法（CSCAN）将queue[n]进行由小到大的排序，首先定位当前调度磁headstarts在queue[n]的位置，然后在此位置按给定的方向遍历queue[n]，当道端点（queue[0]或queue[n-1]）时，反向到另一端点再以此方向进行遍历，直到queue[n]中所有都调度完。当调度磁道不在queue端点时，总的寻道长度为为前一个磁道与后一个磁道差值的累加，当到达端点且queue[n]未全调度时，总寻道长度加上端点值再加上磁盘磁道总长度，再加上下一个调度磁道的值，再按前面的算法进行，直到磁道全部都调度完毕，得到总的寻道长度，除以n得到平均寻道长度。 5、源代码： #include 1、先来先服务算法（FCFS)**********”< cout<<“****** 2、最短寻道时间优先算法(SSTF)**********”< cout<<“****** 3、扫描算法(SCAN)**********”< cout<<“****** 4、循环扫描算法(CSCAN)**********”< cout<<“****** 5、退出 **********”< /*======================初始化序列=======================*/ void init(int queue[],int queue_copy[],int n){ int i;for(i=0;i //对当前正在执行的磁道号进行定位，返回磁道号小于当前磁道中最大的一个 int fix(int queue[], int n, int headstarts){ int i =0;while(i /* ====================以下是FCFS算法==================*/ void FCFS(int queue[],int n,int diskrode,int headstarts)//queue是请求调度序列，n为其个数，diskroad为磁盘磁道数，headstarts为正在调度的磁道 { cout<<“************以下为FCFS调度算法***********”< /*=====================SSTF算法====================*/ void SSTF(int queue[], int n, int diskrode, int headstarts){ int k=1;int l,r;int i,j,count=0;queue =bubble(queue,n);cout<<“************以下为SSTF调度算法***********”< -headstarts)){ cout< /*======================以下是SCAN算法====================*/ void SCAN(int queue[], int n, int diskrode, int headstarts){ int direction, i, fixi;cout<<“***********以下是SCAN调度算法*************”< /*======================以下是CSCAN算法====================*/ void CSCAN(int queue[],int n,int diskrode,int headstarts){ int direction,i,fixi;cout<<“***********以下是CSCAN调度算法*************”< void main(){ int n, i, diskrode, headstarts;//n表示调度磁盘请求序列queue的长度，diskrode表示磁盘磁道的个数，headstarts表示目前正在调度的磁道； cout<<“请输入磁盘的总磁道数:”< if(menux ==2)SSTF(queue,n,diskrode,headstarts); if(menux ==3)SCAN(queue,n,diskrode,headstarts);if(menux ==4)CSCAN(queue,n,diskrode,headstarts);if(menux ==5)cout<<“程序结束,谢谢使用！”< 沈阳理工大学课程设计专用纸 Noi 目 录 1 课程设计目的及要求……………………………………………………错误！未定义书签。2 相关知识…………………………………………………………………错误！未定义书签。3 题目分析…………………………………………………………………2 4 概要设计…………………………………………………………………2 4.1 先来先服务（FCFS）的设计思想……………………………….2 4.2 最短寻道时间优先调度（SSTF）的设计思想…………………..2 4.3 扫描算法（SCAN）的设计思想…………………………………2 4.4 循环扫描（CSCAN）的设计思想………………………………..2 5 代码及流程………………………………………………………………3 5.1 流程图……………………………………………………………...3 5.2 源代码……………………………………………………………...8 6 运行结果…………………………………………………………………16 7 设计心得…………………………………………………………………19 参考文献…………………………………………………………………………19 沈阳理工大学 沈阳理工大学课程设计专用纸 No1 1 课程设计目的及要求 设计目的：加深对操作系统原理的进一步认识，加强实践动手能力和程序开发能力的培养，提高分析问题解决问题的能力，培养合作精神，以巩固和加深磁盘调度的概念。操作系统是一门工程性很强的课程，它不仅要求学生掌握操作系统的工作原理和理论知识，也要求学生的实际动手能力，以加深对所学习内容的理解，使学生熟练地掌握计算机的操作方法，使用各种软件工具，加强对课程内容的理解。这次课程设计，就是通过模拟磁臂调度来加深对操作系统中磁臂调度概念的理解。使学生熟悉磁盘管理系统的设计方法；加深对所学各种磁盘调度算法的了解及其算法的特点。 设计要求：编程序实现下述磁盘调度算法,并求出每种算法的平均寻道长度；要求设计主界面可以灵活选择某算法，且以下算法都要实现 1、先来先服务算法（FCFS） 2、最短寻道时间优先算法（SSTF） 3、扫描算法（SCAN） 4、循环扫描算法（CSCAN）相关知识 数据结构：数组 now:当前磁道号; array[]:放置磁道号的数组; void FCFS(int array[],int m)先来先服务算法(FCFS)void SSTF(int array[],int m)最短寻道时间优先算法(SSTF)void SCAN(int array[],int m)扫描算法(SCAN)void CSCAN(int array[],int m)循环扫描算法(CSCAN)磁盘调度：当有多个进程都请求访问磁盘时，采用一种适当的驱动调度算法，使各进程对磁盘的平均访问（主要是寻道）时间最小。目前常用的磁盘调度算法有：1）闲来先服务2）最短寻道时间优先3）扫描算法4）循环扫描算法等 沈阳理工大学 沈阳理工大学课程设计专用纸 No2 3 题目分析 选择一个自己熟悉的计算机系统和程序设计语言模拟操作系统基本功能的设计方法及其实现过程 完成各分项功能。在算法的实现过程中，要求可决定变量应是动态可变的；同时模块应该有一个合理的输出结果。具体可参照实验的程序模拟.各功能程序要求自行编写程序实现，不得调用现有操作系统提供的模块或功能函数。磁盘调度程序模拟。先来先服务调度算法.最短寻道时间优先调度，循环（SCAN）调度算法。程序设计语言自选，最终以软件（含源代码以及执行程序）和设计报告的形式提交课程设计结果.。磁盘调度让有限的资源发挥更大的作用。在多道程序设计的计算机系统中，各个进程可能会不断提出不同的对磁盘进行读/写操作的请求。由于有时候这些进程的发送请求的速度比磁盘响应的还要快，因此我们有必要为每个磁盘设备建立一个等待队列。概要设计 1.先来先服务（FCFS）的设计思想 即先来的请求先被响应。FCFS策略看起来似乎是相当“公平”的，但是当请求的频率过高的时候FCFS策略的响应时间就会大大延长。FCFS策略为我们建立起一个随机访问机制的模型，但是假如用这个策略反复响应从里到外的请求，那么将会消耗大量的时间。为了尽量降低寻道时间，看来我们需要对等待着的请求进行适当的排序，而不是简单的使用FCFS策略。这个过程就叫做磁盘调度管理。有时候fcfs也被看作是最简单的磁盘调度算法。 2.最短寻道时间优先调度（SSTF）的设计思想 最短时间优先算法选择这样的进程。要求访问的磁道，与当前磁头所在的磁道距离最近，以使每次的寻道时间最短。 3.扫描算法（SCAN）的设计思想 扫描（SCAN）调度算法:该算法不仅考虑到欲访问 的磁道与当前磁道间的距离，更优先考虑的是磁头当前的移动方向。例如，当磁头正在自里向外移动时，SCAN算法所考虑的下一个访问对象，应是其欲访问的磁道，既在当前磁道之外，又是距离最近的。这样自里向外的访问，直至再无更外的磁道需要访问时，才将磁道换向自外向里移动。这时，同样也是每次选择这样的进程来调度，也就是要访问的当前位置内距离最近者，这样，磁头又逐步地从外向里移动，直至再无更里面的磁道要访问，从而避免了出现“饥饿”现像。 4.循环扫描（CSACN）的设计思想 循环扫描（CSCAN）算法：当磁头刚从里向外移动而越过了某一磁道时，恰好又有一进程请求访问此磁道，这时，该里程就必须等待，为了减少这种延迟，CSCAN算法规定磁头单向移动，而本实验过程中我们所设计的是磁头从里向外移动，而从外向里移动时只须改方向而已，本实验未实现。但本实验已完全能演示循环扫描的全过程。 沈阳理工大学 沈阳理工大学课程设计专用纸 No3 5 代码及流程 1.先来先服务（FCFS） 图 1—1 FCFS的流程图 沈阳理工大学 沈阳理工大学课程设计专用纸 No4 2.最短寻道时间优先调度（SSTF） 图1—2 SSTF的流程图 沈阳理工大学 沈阳理工大学课程设计专用纸 No5 3.扫描算法（SCAN） 图1—3 SCAN的流程图 沈阳理工大学 沈阳理工大学课程设计专用纸 No6 4.循环扫描（CSCAN） 图1—4 CSCAN的流程图 沈阳理工大学 沈阳理工大学课程设计专用纸 No7 图1—5 主函数的流程图 沈阳理工大学 沈阳理工大学课程设计专用纸 No8 源代码： #include“stdio.h” #include“stdlib.h” //#include“iostream.h” #define maxsize 100 //定义最大数组域 //先来先服务调度算法 void FCFS(int array[],int m){ int sum=0,j,i;int avg;printf(“n FCFS调度结果: ”);for(i=0;i } avg=sum/(m-1);//计算平均寻道长度 printf(“n 移动的总道数： %d n”,sum);printf(“平均寻道长度： %d n”,avg);} //最短寻道时间优先调度算法 void SSTF(int array[],int m){ int temp;int k=1;int now,l,r;int i,j,sum=0;int avg;for(i=0;i 沈阳理工大学 沈阳理工大学课程设计专用纸 No9 array[i]=array[j];array[j]=temp;} } } for(i=0;i for(i=m-1;i>=0;i--)//将数组磁道号从大到小输出 printf(“%d ”,array[i]);sum=now-array[0];//计算移动距离 } else if(array[0]>=now)//判断整个数组里的数是否都大于当前磁道号 { for(i=0;i printf(“%d ”,array[l]);sum+=now-array[l];//计算移动距离 now=array[l];l=l-1;} else 沈阳理工大学 沈阳理工大学课程设计专用纸 No10 { printf(“%d ”,array[r]);sum+=array[r]-now;//计算移动距离 now=array[r];r=r+1;} } if(l=-1){ for(j=r;j printf(“%d ”,array[j]);} sum+=array[m-1]-array[0];//计算移动距离 } else { for(j=l;j>=0;j--){ printf(“%d ”,array[j]);} sum+=array[m-1]-array[0];//计算移动距离 } } avg=sum/m;printf(“n 移动的总道数： %d n”,sum);printf(“平均寻道长度： %d n”,avg);} //扫描算法 void SCAN(int array[],int m)//先要给出当前磁道号和移动臂的移动方向 { int temp;int k=1;int now,l,r,d;int i,j,sum=0;int avg;for(i=0;i 沈阳理工大学 沈阳理工大学课程设计专用纸 No11 { temp=array[i];array[i]=array[j];array[j]=temp;} } } for(i=0;i printf(“n SCAN调度结果: ”);for(i=m-1;i>=0;i--){ printf(“%d ”,array[i]);//将数组磁道号从大到小输出 } sum=now-array[0];//计算移动距离 } else if(array[0]>=now)//判断整个数组里的数是否都大于当前磁道号 { printf(“n SCAN调度结果: ”);for(i=0;i 沈阳理工大学 沈阳理工大学课程设计专用纸 No12 { for(j=l;j>=0;j--){ printf(“%d ”,array[j]);} for(j=r;j //循环扫描算法 void CSCAN(int array[],int m){ int temp;int k=1;int now,l,r,d;int i,j,sum=0;int avg;for(i=0;i 沈阳理工大学 沈阳理工大学课程设计专用纸 No13 { temp=array[i];array[i]=array[j];array[j]=temp;} } } for(i=0;i printf(“n CSCAN调度结果: ”);for(i=0;i printf(“%d ”,array[i]);//将磁道号从小到大输出 } sum=now-array[0]+array[m-1];//计算移动距离 } else if(array[0]>=now)//判断整个数组里的数是否都大于当前磁道号 { printf(“n CSCAN调度结果: ”);for(i=0;i printf(“%d ”,array[i]);//将磁道号从小到大输出 } sum=array[m-1]-now;//计算移动距离 } else { while(array[k] 沈阳理工大学 沈阳理工大学课程设计专用纸 No14 { for(j=l;j>=0;j--){ printf(“%d ”,array[j]);} for(j=m-1;j>=r;j--){ printf(“%d ”,array[j]);} sum=2*(array[m-1]-array[0])-array[r]+now;//计算移动距离 }//磁道号减小方向 else { for(j=r;j // 操作界面 int main(){ int c;FILE *fp;//定义指针文件 int cidao[maxsize];//定义磁道号数组 int i=0,count;fp=fopen(“cidao.txt”,“r+”);//读取cidao.txt文件 if(fp==NULL)//判断文件是否存在 { printf(“n 请 先 设 置 磁 道!n”);exit(0);} while(!feof(fp))//如果磁道文件存在 沈阳理工大学 沈阳理工大学课程设计专用纸 No15 { fscanf(fp,“%d”,&cidao[i]);//调入磁道号 i++;} count=i-1;printf(“n-------------------n”);printf(“ 10-11OS课程设计--磁盘调度算法系统n”);printf(“ 计算机科学与技术二班n”);printf(“ 姓名：宋思扬n”);printf(“ 学号：0803050203n”);printf(“ 电话：************n”);printf(“ 2010年12月29日n”);printf(“n-------------------n”);printf(“n 磁道读取结果：n”);for(i=0;i 1、先来先服务算法（FCFS）n”);printf(“ 2、最短寻道时间优先算法（SSTF）n”);printf(“ 3、扫描算法（SCAN）n”);printf(“ 4、循环扫描算法（CSCAN）n”);printf(“ 5.退出n”);printf(“n”);printf(“请选择：”);scanf(“%d”,&c);if(c>5)break;switch(c)//算法选择 { case 1: FCFS(cidao,count);//先来先服务算法 printf(“n”);break;case 2: SSTF(cidao,count);//最短寻道时间优先算法 printf(“n”);break;case 3: 沈阳理工大学 沈阳理工大学课程设计专用纸 No16 SCAN(cidao,count);//扫描算法 printf(“n”);break;case 4: CSCAN(cidao,count);//循环扫描算法 printf(“n”);break;case 5: exit(0);} } return 0;} 6 运行结果 图2—1 运行界面 沈阳理工大学 沈阳理工大学课程设计专用纸 No17 图2—2 运行FCFS的界面 图2—3 运行SSTF的界面 图2—4 运行SCAN的界面 沈阳理工大学 沈阳理工大学课程设计专用纸 No18 图2—5 运行SCAN的界面 图2—6 运行CSCAN的界面 图2—7 运行CSCAN的界面 沈阳理工大学 沈阳理工大学课程设计专用纸 No19 运行结果： 四种磁盘调度运行结果正确，与预期的相符。设计心得 此次操作系统的课程设计，从理论到实践，在两个星期的日子里，可以说是苦多于甜，但是可以学到很多很多的的东西，同时不仅可以巩固了以前所学过的知识，而且学到了很多在书本上所没有学到过的知识。通过这次课程设计使我懂得了理论与实际相结合是很重要的，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，从理论中得出结论，才能真正为社会服务，从而提高自己的实际动手能力和独立思考的能力。 本次实验首先要了解磁盘调度的工作原理及四种调度方法的工作原理。在课程设计前的准备工作时，先把这部分工作做完了。在设计总的程序框架的时候，要注意各功能模块的位置，尽量做到简洁、有序；各功能模块与主程序要正确衔接。 在设计的过程中遇到许多问题，我设计的是四种调度算法中的后两种。例如：在最初程序设计时主要有两种构思：1）选用数据结构是链表的。2）选用数组。我最初尝试了用链表，觉得方便易懂，但是在循环扫描处出现了些问题，后来又转变了设计思路，选用了数组，直接进行排序，然后再联系到各功能模块。 同时在设计的过程中发现了自己的不足之处，对以前所学过的知识理解得不够深刻，掌握得不够牢固，自身知识的很多漏洞，看到了自己的实践经验还是比较缺乏，理论联系实际的能力还急需提高。比如说编语言掌握得不好，应用程序编写不太会……通过这次课程设计之后，一定把以前所学过的知识重新温故。在此，也感谢在课程设计过程中帮我解惑的老师和同学。参考文献 [1] 《操作系统》 人民邮电出版社 宗大华 宗涛 陈吉人 编著 [2] 《C语言程序设计》 清华大学出版社 马秀丽 刘志妩 李筠 编著 [3] 《操作系统实验指导书》 沈阳理工大学 唐巍 菀勋 编著 沈阳理工大学 大学 操作系统课程综合实践 题目： 磁盘文件操作 班级： 姓名： 学号： 指导教师： 2011年 12 月 23日 磁盘文件操作 摘要： 为了正确地实现文件的存取，文件系统设计了一组与存取文件有关的功能模块，用户可以用“访问指令”调用这些功能模块，以实现文件的存取要求。我们把文件系统设计的这一组功能模块称为“文件操作“，实验就是要模拟实现一些文件操作。文件操作不是独立的，它和文件系统的其他部分密切相关，若要实现文件操作就离不开文件的目录结构、文件的组织结构和磁盘空间的管理。因此，这个实习虽然是文件操作的模拟实现，但还是必须模拟一部分文件的组织结构、目录结构和磁盘空间管理的实现。 关键字：磁盘、文件、目录、分配表。 一、实验内容： 设计一个简单的文件系统，用文件模拟磁盘，用数组模拟缓冲区，要求实现； 1． 2． 3． 4． 支持多级目录结构，支持文件的绝对路径； 文件的逻辑结构采用流式结构，物理结构采用链接结构中的显示链接方式； 采用文件分配表； 实现的命令包括建立目录、列目录、删除空目录、建立文件、删除文件、显示文件内容、打开文件、读文件、写文件（追加方式）、关闭文件、改变文件属性。 最后编写主函数对所做工作进行测试。 二、实验目的：1、2、3、4、文件的操作。 文件的逻辑结构和物理结构 磁盘空间的管理 磁盘目录结构 三、实验环境： Windows XP、VC++ 四、程序运行结果（详图）： 程序运行的主界面：用户运行命令7-建立目录 用户运行命令1-建立文件： 显示目录内容： 打开文件： 写文件： 关闭文件： 再次显示目录内容: 以上为程序的运行的部分截图。 五、程序清单： #define false 0 #define true 1 #include “stdio.h” //#include char name[3];/*文件或目录名*/ char type[2];/*文件类型名*/ char attribute;/*属性*/ char address;/*文件或目录的起始盘块号*/ char length;/*文件长度，以盘块为单位*/ }content;/*目录结构*/ #define n 5 /*模拟实验中系统允许打开文件的最大数量*/ typedef struct { int dnum;/*磁盘盘块号*/ int bnum;/*盘块内第几项*/ }pointer;/*已打开文件表中读写指针的结构*/ typedef struct { char name[20];/*文件绝对路径名*/ char attribute;/*文件的属性，用1个字节表示，所以用了char类型*/ int number;/*文件起始盘块号*/ int length;/*文件长度，文件占用的字节数*/ int flag;/*操作类型，用“0”表示以读操作方式开文件，用“1”表示写操作pointer read;/*读文件的位置，文件刚打开时dnum为文件起始盘块号,bnumpointer write;/*写文件的位置，文件建立时dnum为文件起始盘块号,bnum方式打开文件*/ 为“0”*/ 为“0”，打开时为文件末尾*/ }OFILE;/*已打开文件表项类型定义*/ struct { char buffer1[64];/*模拟缓冲1*/ content buffer2[8];/*模拟缓冲2*/ FILE *fc;/*模拟磁盘的文件指针*/ void copen(OFILE *x1,OFILE *x2)//OFILE *x1,*x2;{ } strcpy(x1->name,x2->name);x1->attribute=x2->attribute;x1->number=x2->number;x1->length=x2->length;x1->flag=x2->flag;x1->read.dnum=x2->read.dnum;x1->read.bnum=x2->read.bnum;x1->write.dnum=x2->write.dnum;x1->write.bnum=x2->write.bnum;OFILE file[n];/*已打开文件表*/ int length;/*已打开文件表中登记的文件数量*/ }openfile;/*已打开文件表定义*/ int sopen(char *name)/*在已打 开 文 件 表 中 查 找 文 件//P172 //char *name;{ void dopen(char *name)/*在已打开文件表中删除文件name*/ //char *name;{ int iopen(content *x)/*在已打开文件表中插入文件name*/ //content *x;{ int i;i=sopen(name);if(i==-1){ } copen(&openfile.file[i],&openfile.file[openfile.length-1]);openfile.length--;printf(“文件未打开n”);else int i;i=0;while(i name*/ 依次查找已打开文件表*/ if(i>=openfile.length)return(i);}/*查找sopen函数结束*/ }/*删除函数结束*/ int i;i=sopen(x->name);if(i!=-1){ } else if(openfile.length==n){ } else { } //copen(&openfile.file[openfile.length],x);openfile.length++;return(true);printf(“已打开文件表已满n”);return(false);printf(“文件已经打开n”);return(false);}/*填写已打开文件表函数结束*/ int allocate()/*分配一个磁盘块，返回块号*/ { */ //P173 int i;fseek(fc,0,SEEK_SET);/*将模拟磁盘的文件指针移至模拟磁盘FAT表*/ fread(buffer1,64L,1,fc);/*将FAT表中第一个磁盘块读入模拟缓冲for(i=3;i<63;i++)if(buffer1[i]==0){ /*FAT中的第i项为0,分配第i块磁盘块,修改FAT表,并且写回磁盘buffer1中*/ buffer1[i]=255; } fseek(fc,0,SEEK_SET);fwrite(buffer1,64L,1,fc);return(i);/*返回磁盘号*/ fread(buffer1,64L,1,fc);/*将FAT表中第二个磁盘块读入模拟缓冲for(i=0;i<63;i++) if(buffer1[i]==0){/*FAT中的第i项为0,分配第i＋64块磁盘块,修改FAT表,并且写 } printf(“已经没有磁盘空间n”);return(false);buffer1[i]=255;fseek(fc,-64L,SEEK_CUR);fwrite(buffer1,64L,1,fc);return(i+64);/*返回磁盘号*/ buffer1中*/ 回磁盘*/ }/*分配磁盘块函数结束*/ int read_file(char *name,int length)/*读文件函数，文件路径名name，读取长度length*/ //char *name;//int length;{ int i,t;//char ch;if((i=sopen(name))==-1){ } if(openfile.file[i].flag==1){ printf(“文件以写方式打开，不能读n”);printf(“文件没有打开或不存在n”);return(false); } return 0;t=0;fseek(fc,openfile.file[i].read.dnum*64L,SEEK_SET);fread(buffer1,64,1,fc);while(t openfile.file[i].read.dnum=buffer1[openfile.file[i].read.dnum%64] } } t++;openfile.file[i].read.bnum=0;fseek(fc,openfile.file[i].read.dnum*64L,SEEK_SET);fread(buffer1,64,1,fc);/*读取下一个*/ putchar(buffer1[openfile.file[i].read.bnum]);/*读出一个字符（这if((t+1)%64==0)putchar('n');/*修改读指针*/ openfile.file[i].read.bnum++;if(openfile.file[i].read.bnum>=64)/*一块读完，读取下一个盘块*/ { fseek(fc,openfile.file[i].read.dnum/64*64, SEEK_SET);fread(buffer1,64,1,fc);里是在屏幕上显示）*/;/*修改读指针*/ }/*读函数结束*/ int write_file(char *name,char *buff,int length)//P174 /*写文件函数*/ //char *name;/*文件路径名*/ //char *buff;/*存放准备写入磁盘的内容*/ //int length;/*写入内容的长度*/ { int i,t,dd;if((i=sopen(name))==-1)/*文件不存在，无法写*/ { } if(openfile.file[i].flag==0){ } t=0;fseek(fc,openfile.file[i].write.dnum*64L, SEEK_SET);fread(buffer1,64,1,fc);while(t buffer1[openfile.file[i].write.bnum]=buff[t];openfile.file[i].write.bnum++;openfile.file[i].length++;if(openfile.file[i].write.bnum>=64){ fseek(fc, openfile.file[i].write.dnum*64L, SEEK_SET);fwrite(buffer1,64,1,fc);/*一块写完，写回磁盘*/ if((dd=allocate())==false){ openfile.file[i].write.bnum--;openfile.file[i].length--;printf(“无磁盘空间,部分信息丢失，写失败n”);return(false);printf(“文件以读方式打开，不能写n”);return(false);printf(“文件没有打开或不存在n”);return(false);}/*if*/ fseek(fc,openfile.file[i].write.dnum/64*64L, SEEK_SET);fread(buffer1,64,1,fc);buffer1[openfile.file[i].write.dnum%64]=dd;fseek(fc,openfile.file[i].write.dnum/64*64L, SEEK_SET); fwrite(buffer1,64,1,fc);openfile.file[i].write.dnum=dd;openfile.file[i].write.bnum=0;}/*if*/ t++;}/*while*/ fseek(fc, openfile.file[i].write.dnum*64L, SEEK_SET);fwrite(buffer1,64,1,fc);/*一块写完，写回磁盘*/ }/*写函数结束*/ int search(char *name,int flag,int *dnum,int *bnum)/*查找路径名为name的文件或目录,返回该目录的起始盘块号 */ //char *name;//int flag;/*flag=8表示查找目录,否则为文件*/ //int *dnum,*bnum;/*返回找到文件或目录的目录项的位置：盘块dnum中第bnum项*/ { for(s=0;name[k]!='.'&&name[k]!='/'&&s<3&&name[k]!=' ';s++,k++) pna[s]=name[k];pna[s]=' ';for(;s<3;s++)/*用空格补全名字长度*/ int k,i,s,j,last=0;char pna[3],type[2];if((strcmp(name,“")==0)||(strcmp(name,”/“)==0))/* return(2); 根 目录 */ //P175 k=0;if(name[0]=='/')k=1;i=2;/*i=根目录的起始盘块号*/ while(last!=1){ /*pna=从name中分离出”/“后一个目录名（或文件名）*/ */ & while(name[k]!='.'&&name[k]!=' '&&name[k]!='/')/*除去多余字符 k++;type[0]=type[1]=' ';if(name[k]=='.')/*取文件类型名type*/ if(flag==8){ } else {/*文件遇到类型名认为结束,后面的字符作废*/ } else if(name[k]!=' ')k++;if(name[k]==' ')last=1;/*查找目录且名字等于pna的目录项*/ fseek(fc,i*64L,SEEK_SET);fread(buffer2,64L,1,fc);j=0;if(last==1&&flag!=8)k++;if(name[k]!=' ')type[0]=name[k];k++;if(name[k]!=' ')type[1]=name[k];if(name[k]!=' '&&name[k+1]!=' '){ } last=1;printf(”文件名错误n“);return(false);printf(”目录不应该有有类型名,查找失败n“);return(false);while(j<8&&!(buffer2[j].attribute!=8&&buffer2[j].name[0]==pna[0]& j++;buffer2[j].name[1]==pna[1]&&buffer2[j].name[2]==pna[2]&& buffer2[j].type[0]==type[0]&&buffer2[j].type[1]==type[1]))else while(j<8&&!(buffer2[j].attribute==8&&buffer2[j].name[0]==pna[0]& &&buffer2[j].name[2]==pna[2]))j++; if(last==1)/*查找结束*/ { *dnum=i;*bnum=j; return(buffer2[j].address);&buffer2[j].name[1]==pna[1] if(j<8)/*找到该目录或文件*/ } else/*查找还未结束*/ i=buffer2[j].address;/*读取下一个盘块*/ return(false);else //P176 }/*while 查找结束*/ }/*search()结束*/ int create_file(char *name,int attribute)/*建立文件函数，路径名name,文件属性attribute*/ //char *name;//int attribute;{ int i,j,k,s,d,t,b,dd,dn,bn;char dname[3],tname[2],pathname[20]; OFILE x;if(attribute%2==1){ } if(openfile.length==n){ } /* 将name分成两部分，目录路径pathname和目录名dname*/ for(j=0;name[j]!=' ';j++)/*查找最后一个“/”*/ if(name[j]=='/')s=j;/*分离目录路径*/ for(j=0;j } for(;k<3;k++)dname[k]=' ';k=0;if(name[j++]=='.')/*分离类型名*/ { } for(;k<2;k++)for(;name[j]!=' '&&k<2&&name[j]!='.';j++,k++)tname[k]=name[j];printf(”错误文件名或目录名n“);return(false);dname[k]=name[j];if(k==0)printf(”已打开表已满,不能建立n“);return(false);printf(”只读文件,无法写,不能建立n“);return(false); tname[k]=' ';if((d=search(pathname,8,&dn,&bn))==false)/*找到目录路径，返回该{ } /*确认该目录不存在的同时查找空目录项*/ printf(”目录不存在，不能建立“);return(false);目录所在块号dn和项数bn*/ b=-1;fseek(fc,d*64L,SEEK_SET);fread(buffer2,64L,1,fc);/*读出dnum盘块的内容*/ for(t=0;t<8;t++){ //P177 if(buffer2[t].name[0]==dname[0]&&buffer2[t].name[1]==dname[1]&&bu {/*找到名字dname的文件，建立失败*/ } if(buffer2[t].name[0]=='$'&&b==-1)b=t;printf(”文件已经存在，不能建立n“);return(false);ffer2[t].name[2]==dname[2] &&buffer2[t].type[0]==tname[0]&&buffer2[t].type[1]==tname[1])}/*for*/ if(b==-1)/*没有空目录项,建立失败*/ { } if((dd=allocate())==false)/*分配给建立目录的磁盘盘块dd*/ { printf(”建立文件失败n“);return(false);printf(”目录无空间n“);return(false); } /*填写目录项*/ for(i=0;i<3;i++)buffer2[b].name[i]=dname[i];buffer2[b].type[i]=tname[i];for(i=0;i<2;i++)buffer2[b].attribute=attribute;buffer2[b].address=dd;buffer2[b].length=0;fseek(fc,d*64L,SEEK_SET);fwrite(buffer2,64L,1,fc);/*填写已打开文件表*/ strcpy(x.name,name);x.attribute=attribute;x.number=dd;x.length=0;x.flag=1;x.read.dnum=x.write.dnum=dd;x.read.bnum=x.write.bnum=0;//iopen(&x);}/*建立文件结束*/ int open_file(char *name,int attribute)/*打开文件函数*/ //char *name;//int attribute;{ OFILE x;int dnum,bnum,last,i,d;if((d=search(name,4,&dnum,&bnum))==false){ } printf(”文件不存在，打开操作失败n“);return(false); } fseek(fc,dnum*64L,SEEK_SET);/*fread(buffer2,64,1,fc); 读出对应目录项*/ //P178 if((buffer2[bnum].attribute%2==1)&& attribute==1)/*对只读文件要求{ } strcpy(x.name,name);x.attribute=buffer2[bnum].attribute;x.number=buffer2[bnum].address;x.read.dnum=x.write.dnum=buffer2[bnum].address;x.read.bnum=x.write.bnum=0;x.flag=attribute;if(attribute==1){ } iopen(&x);/*填写已打开文件表*/ while(d!='xff')/*寻找文件末尾*/ { fseek(fc, d/64*64L, SEEK_SET);fread(buffer1,64L,1,fc);/*读出dnum项所在FAT*/ last=d;d=buffer1[d%64];/*读出dnum块下一块内容赋给dnum*/ printf(”文件不能写，打开失败“);return(false);写*/ }/*while*/ x.write.dnum=last;/*填写写指针*/ fseek(fc, last*64L, SEEK_SET);fread(buffer1,64L,1,fc);for(i=0;i<64&&buffer1[i]!='#';i++);x.write.bnum=i;x.length=(buffer2[bnum].length-1)*64+i;int close_file(char *name)/*关闭文件函数*/ //char *name;{ } int Delete(char *name)/*删除文件*/ //char *name;int i,dnum,bnum;if((i=sopen(name))==-1){ } if(openfile.file[i].flag==1)/*写文件的追加文件结束符*/ { } /*在已打开文件表中删除该文件的登记项*/ fseek(fc,openfile.file[i].write.dnum*64L, SEEK_SET);fread(buffer1,64,1,fc);buffer1[openfile.file[i].write.bnum]='#';fseek(fc,openfile.file[i].write.dnum*64L, SEEK_SET);fwrite(buffer1,64,1,fc);fputc('#',fc);search(name,4,&dnum,&bnum);/*查找该文件目录位置*/ /*修改目录中的文件长度*/ fseek(fc,dnum*64L, SEEK_SET);fread(buffer2,64,1,fc);buffer2[bnum].length=openfile.file[i].length/64+1;fseek(fc, dnum*64L, SEEK_SET);fwrite(buffer2,64,1,fc);printf(”打开的文件中没有该文件,关闭失败n“);return(false);if(openfile.length>1)copen(&openfile.file[i],&openfile.file[openfile.length-1]);//P179 openfile.length--;{ int md(char *name)/*建立目录函数，目录路径名name*/ //char *name;{ int i,j,k,s,d,t,b,dd,dn,bn;int dnum,bnum,t;if((t=search(name,4,&dnum,&bnum))==false){ } if(sopen(name)!=-1){ } fseek(fc,dnum*64L, SEEK_SET);fread(buffer2,64,1,fc);buffer2[bnum].name[0]='$';/*将该文件的目录置成空目录*/ fseek(fc,dnum*64L, SEEK_SET);fwrite(buffer2,64,1,fc);while(t!='xff')/*通过FAT查找每一个盘块号，并依次删除*/ { } dnum=t;fseek(fc, dnum/64*64, SEEK_SET);fread(buffer1,64,1,fc);t=buffer1[dnum%64];buffer1[dnum%64]=0;fseek(fc, dnum/64*64L, SEEK_SET);fwrite(buffer1,64,1,fc);printf(”该文件打开，不能删除n“);return(false);printf(”文件不存在n“);return(false);}/*文件删除结束*/ char dname[3],pathname[20];i=2;/* i=根目录的起始盘块号*/ /* 将name分成两部分，目录路径pathname和目录名dname*/ for(j=0;name[j]!=' ';j++)/*查找最后一个“/”*/ if(buffer2[t].name[0]==dname[0]&&buffer2[t].name[1]==dname[1] &&buffer2[t].name[2]==dname[2]&&buffer2[t].attribute==8)if(name[j]=='/')s=j;/*分离目录路径*/ for(j=0;j } for(;k<3;k++){ } b=-1;/*确认该目录不存在的同时查找空目录项*/ fseek(fc,d*64L,SEEK_SET);fread(buffer2,64L,1,fc);/*读出d盘块的内容*/ for(t=0;t<8;t++){ printf(”目录不存在，不能建立n“);return(false);dname[k]=' ';if((d=search(pathname,8,&dn,&bn))==false)/*找到目录路径*/ printf(”错误文件名或目录名n“);dname[k]=name[j];if(k==0)return(false);//P180 {/*找到名字dname的目录，建立失败*/ } if(buffer2[t].name[0]=='$'&&b==-1)b=t;printf(”目录已经存在，不能建立n“);return(false);}/*for*/ if(b==-1)/*没有空目录项，不能建立*/ { } if((dd=allocate())==false)/*分配给建立目录的磁盘盘块dd*/ { } /*填写目录项*/ for(i=0;i<3;i++)buffer2[b].name[i]=dname[i];buffer2[b].type[0]=buffer2[b].type[1]=' ';buffer2[b].attribute=8;buffer2[b].address=dd;buffer2[b].length=0;fseek(fc,d*64L,SEEK_SET);fwrite(buffer2,64L,1,fc);/*分给新建目录的盘块初始化*/ for(t=0;t<8;t++)buffer2[t].name[0]='$';fseek(fc, dd*64L, SEEK_SET);fwrite(buffer2,64L,1,fc);printf(”目录不能建立n“);return(false);printf(”目录无空间n“);return(false);}/*建立目录结束*/ int dir(char *name)/*显示目录内容*/ //char *name;{ int t,dnum,dn,bn;if((dnum=search(name,8,&dn,&bn))==false)/*找到目录路径，返回该目录{ } printf(”目录不存在n“);return(false);所在块号dn和盘块内项数bn*/ printf(”名称 扩展名 起始盘块 长度n“);/*显示目录内容*/ fseek(fc,dnum*64L, SEEK_SET);fread(buffer2,64L,1,fc);for(t=0;t<8;t++)/*显示该盘块中目录项的内容*/ if(buffer2[t].name[0]!='$')printf(” %c%c%c %c%c %4d%7dn“, buffer2[t].name[0], buffer2[t].name[2]，buffer2[t].type[0], //P181 buffer2[t].name[1], buffer2[t].type[1],buffer2[t].address, buffer2[t].length);}/*显示目录函数结束*/ char typefile(char *name)/*显示文件内容*/ //char *name;{ int dnum,dn,bn,t;if((dnum=search(name,1,&dn,&bn))==false){ } if(sopen(name)!=-1){ printf(”文件不存在n“);return(false); } printf(”该文件打开，不能显示n“);return(false);while(dnum!='xff'){ } fseek(fc,dnum*64L,SEEK_SET);fread(buffer1,64,1,fc);/*读一个盘块到缓冲*/ for(t=0;t<64&&buffer1[t]!='#';t++)/*显示缓冲中内容*/ putchar(buffer1[t]);printf(”n“);/*获得下一个盘块*/ fseek(fc, dnum/64*64L, SEEK_SET);fread(buffer1,64,1,fc);dnum=buffer1[dnum%64];}/*显示文件函数结束*/ int change(char *name,int attribute)/*改变文件name的属性为attribute*/ //char *name;//int attribute;{ int dnum,bnum;if(search(name,1,&dnum,&bnum)==false)/*查找文件目录*/ { } if(sopen(name)!=-1){ } fseek(fc,dnum*64L,SEEK_SET);printf(”该文件打开，不能改变文件属性n“);return(false);printf(”文件不存在n“);return(false);//P182 fread(buffer2,64,1,fc);/*读出该目录所在盘块*/ buffer2[bnum].attribute=attribute;/*修改属性*/ fseek(fc,dnum*64L,SEEK_SET);fwrite(buffer2,64,1,fc);/*写回磁盘*/ }/*改变文件属性函数结束*/ int main(){ char name[20];//FILE*x1,*x2;//errno_t err;//char err;int attribute,type,length,i,a,j;char buffer[64];/*建立文件，模拟磁盘*/ if((fc=fopen(”c:c“,”w+“))==NULL)// { } /*初始化已打开文件表*/ openfile.length=0;/*初始化磁盘*/ /*初始化文件分配表*/ buffer1[0]=buffer1[1]=buffer1[2]=255;/*磁盘第0、1块存放FAT表，第for(i=3;i<64;i++)buffer1[i]=0;buffer1[13]=buffer1[49]=254;/*假定模拟磁盘中有两个坏盘块：第13块fwrite(buffer1,64L,1,fc);for(i=0;i<64;i++)buffer1[i]=0;printf(”无法打开文件n“);exit(0);2块存放跟目录*/ 和49块*/ //P183 fwrite(buffer1,64L,1,fc);/*初始化根目录*/ for(i=0;i<8;i++)buffer2[i].name[0]='$';/*若目录项的第一个字符为“$”表示该目录项为空*/ fwrite(buffer2,64L,1,fc);/*初始化已打开文件表*/ while(1){ printf(”n 0建立文件n“);printf(” 2读文件n“);printf(” 4关闭文件n“);printf(” 6建立目录n“);printf(” 8显示文件内容n“);printf(” 10-改变文件属性n“);printf(” 选择功能项（0~9）:“);scanf(”%d“,&a);switch(a){ case 0: /*a=0程序结束*/ fclose(fc);exit(0);printf(”输入文件路径名和文件属性（1-只读文件，3-只读系统文scanf(“%s%d”,name,&attribute);create_file(name,attribute);/*建立文件*/ break;case 1: /*a=1建立文件*/ 件，4-普通文件）:“);case 2: /*a=2打开文件*/ printf(”输入文件路径名和操作类型（0-读文件，1-写文件）:“); scanf(”%s%d“,name,&type); open_file(name,type);/*打开文件*/ break; case 3: /*a=3读文件*/ printf(”输入文件路径名和读长度“); scanf(”%s%d“,name,&length); read_file(name,length);/*读文件*/ break; case 4: /*a=4写文件*/ printf(”输入文件路径名:“); scanf(”%s“,name); printf(”输入写的内容和和写长度“); scanf(”%s%d“,buffer,&length); write_file(name,buffer,length);/*写文件*/ break; case 5: /*a= 5关 闭 文//P184 printf(”输入文件路径名“); scanf(”%s“,name); close_file(name);/*关闭文件*/ break; case 6: /*a=6删除文件*/ printf(”输入文件路径名“); scanf(”%s“,name); Delete(name);/*删除文件*/ break; case 7: /*a=7建立目录*/ printf(”输入目录路径名“); scanf(”%s“,name); md(name);/*建立目录*/ break; case 8: /*a=8显示目录*/ printf(”输入目录路径名“);scanf(”%s“,name); 件 */ dir(name);/*显示目录*/ break;printf(”输入文件路径名“);scanf(”%s“,name);typefile(name);/*显示文件*/ break;printf(”输入文件路径名和文件属性（1-只读文件，3-只读系统文scanf(“%s%d”,name,&attribute);change(name,attribute);case 9: /*a=9显示文件*/ case 10:/* a=10改变文件属性 */ 件，4-普通文件）：");}/* switch */) 结 束}/* while */ }/*main(//P185 六、结束语： */ 通过对磁盘文件操作，使我了解了基本的磁盘文件的知识，再加上对程序流程的理解，更加明白了Windows对磁盘管理的方式，首先程序查找绝对路径名name，然后从name中分离出“/”后下一个目录（或文件名）；若是文件，分离出类型名type，再进行之后的判断操作。当在已打开的文件表中查找某文件时，首先查找文件路径名为pname的文件，通过一个变量的判断，进行查找。将某文件从已打开的表中删除时，在已打开的文件表中查找路径名为name的登记项i，如果找到该文件登记项i，删除第i项，如果没有找到，提示文件没有打开，删除失败。通过对这些流程的理解，让我深刻的体会到了磁盘文件操作的步骤，达到了实习目的。参考文献： [1] 滕艳平等.计算机操作系统（实验指导书），哈尔滨工业大学出版社.2008年9月 [2] 张明等编.操作系统习题解答与实验指导（第二版）.中国铁道出版社.2007年12月 [3] 张丽芬等编.操作系统实验教程.清华大学出版社.2006年 [4] 张献忠等编.操作系统学习辅导.清华大学出版社.2004年 [5] 汤小丹等编.计算机操作系统.西安电子科技大学出版社.2006年9月 操作系统课程设计 注意事项： 0.请每位同学必须按时提交课程设计报告（包括电子版和纸质版），算入期末成绩 1.在三个题目中选择一个 2.如果选择题目 （一）进程调度算法，要求实现其中2个以上（包括2个）进程调度算法 3.如果选择题目 （二）银行家算法，要求能够判断系统的安全状态 4.如果选择题目 （三）页面调度算法，要求实现其中2个以上（包含2个）进程调度算法 5.报告应包含算法分析、实验截图、核心算法源代码，请各位同学认真对待，独立完成 6.提交要求：电子版（包括实验程序）请发至ropeal@163.com，纸质版请班长收齐，由班长统一在课堂上提交（并提交未交人员名单），截止时间第16周周三(2014.1.31)7.格式要求： 7.1 A4纸10页左右 7.2 封面请注明班级、姓名、学号、所选题目 7.3 电子版发送时，请打包成一个文件，将文件名设置为：学号+姓名+题目名称（如20130000张三进程调度算法课程设计），邮件主题同文件名 一、进程调度算法 1.1 实验目的： a、设计进程控制块PCB表结构，模拟实现进程调度算法：FIFO，静态优先级调度，时间片轮转调度，多级反馈队列调度。（实现其中之二）。* b、建立进程就绪队列。对不同算法编制入链子程序。c、编写一进程调度程序模拟程序。模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。* 由用户输入进程名和进程长度，然后按照短进程优先的进程处理顺序给出进程的排序。 1.2 实验原理 调度算法是指：根据系统的资源分配策略所规定的资源分配算法。1.2.1 先来先服务和短作业（进程）优先调度算法 1.先来先服务调度算法。先来先服务（FCFS）调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。由此可知，本算法适合于CPU繁忙型作业，而不利于I/O繁忙型的作业（进程）。 2.短作业（进程）优先调度算法。短作业（进程）优先调度算法（SJ/PF）是指对短作业或短进程优先调度的算法，该算法既可用于作业调度，也可用于进程调度。但其对长作业不利；不能保证紧迫性作业（进程）被及时处理；作业的长短只是被估算出来的。1.2.2 高优先权优先调度算法 1.优先权调度算法的类型。为了照顾紧迫性作业，使之进入系统后便获得优先处理，引入了最高优先权优先（FPF）调度算法。此算法常被用在批处理系统中，作为作业调度算法，也作为多种操作系统中的进程调度，还可以用于实时系统中。当其用于作业调度，将后备队列中若干个优先权最高的作业装入内存。当其用于进程调度时，把处理机分配给就绪队列中优先权最高的进程，此时，又可以进一步把该算法分成以下两种： 1)非抢占式优先权算法 2)抢占式优先权调度算法（高性能计算机操作系统） 2.优先权类型。对于最高优先权优先调度算法，其核心在于：它是使用静态优先权还是动态优先权，以及如何确定进程的优先权。3．高响应比优先调度算法 为了弥补短作业优先算法的不足，我们引入动态优先权，使作业的优先等级随着等待时间的增加而以速率a提高。该优先权变化规律可描述为：优先权=（等待时间+要求服务时间）/要求服务时间；即 =（响应时间）/要求服务时间 1.2.3 基于时间片的轮转调度算法 1.时间片轮转法。时间片轮转法一般用于进程调度，每次调度，把CPU分配队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个记时器发出一个时钟中断请求，该进程被停止，并被送往就绪队列末尾；依次循环。2.多级反馈队列调度算法 多级反馈队列调度算法多级反馈队列调度算法，不必事先知道各种进程所需要执行的时间，它是目前被公认的一种较好的进程调度算法。其实施过程如下： 1)设置多个就绪队列，并为各个队列赋予不同的优先级。在优先权越高的队列中，为每个进程所规定的执行时间片就越小。 2)当一个新进程进入内存后，首先放入第一队列的末尾，按FCFS原则排队等候调度。如果他能在一个时间片中完成，便可撤离；如果未完成，就转入第二队列的末尾，在同样等待调度„„ 如此下去，当一个长作业（进程）从第一队列依次将到第n队列（最后队列）后，便按第n队列时间片轮转运行。3)仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第1到第（i-1）队列空时，才会调度第i队列中的进程运行，并执行相应的时间片轮转。4)如果处理机正在处理第i队列中某进程，又有新进程进入优先权较高的队列，则此新队列抢占正在运行的处理机，并把正在运行的进程放在第i队列的队尾。 1．3 实验要求 a、使用模块化设计思想来设计； b、给出算法的流程图或伪码说明。c、学生可按照自身条件，随意选择采用的算法，（例如：采用冒泡法编写程序，实现短进程优先调度的算法） d、进程调度程序模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。 1.4 算法简析 a、每个进程可有三个状态，并假设初始状态为就绪状态。b、为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的优先数或轮转时间数以及进程需运行的时间片数的初始值均由用户给定。c、在优先数算法中，优先数可以先取值为（50-该进程所需时间），进程每执行一次，优先数减3，CPU时间片数（CPUtime）加1，* 进程还需要的时间片数（needtime）减1。在时间片轮转算法中，采用固定时间片 （即：每执行一次进程，该进程的执行时间片数为已执行了2个单位），这时，CPU时间片（CPUtime）数加2，* 进程还需要的时间片数（needtime）减2，并排列到就绪队列的尾上。 d、对于遇到优先数一致的情况，采用FIFO策略解决。 二、银行家算法 2.1 概述 2.1.1 设计目的1、了解多道程序系统中，多个进程并发执行的资源分配。 2、掌握死锁的产生的原因、产生死锁的必要条件和处理死锁的基本方法。 3、掌握预防死锁的方法，系统安全状态的基本概念。 4、掌握银行家算法，了解资源在进程并发执行中的资源分配策略。 5、理解死锁避免在当前计算机系统不常使用的原因 2.2 关于死锁 2.2.1 死锁概念： 在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率，提高系统的吞吐量，但可能发生一种危险━━死锁。所谓死锁(Deadlock),是指多个进程在运行中因争夺资源而造成的一种僵局(Deadly_Embrace),当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。一组进程中，每个进程都无限等待被该组进程中另一进程所占有的资源，因而永远无法得到的资源，这种现象称为进程死锁，这一组进程就称为死锁进程。 2.2.2 关于死锁的一些结论： 参与死锁的进程最少是两个（两个以上进程才会出现死锁） 参与死锁的进程至少有两个已经占有资源 参与死锁的所有进程都在等待资源 参与死锁的进程是当前系统中所有进程的子集 注：如果死锁发生，会浪费大量系统资源，甚至导致系统崩溃。 2.2.3 资源分类： 永久性资源： 可以被多个进程多次使用（可再用资源），分为：可抢占资源与不可抢占资源 临时性资源：只可使用一次的资源；如信号量,中断信号，同步信号等（可消耗性资源） “申请--分配--使用--释放”模式 2.2.4 产生死锁的四个必要条件： 1、互斥使用（资源独占） 一个资源每次只能给一个进程使用 2、不可强占（不可剥夺） 资源申请者不能强行的从资源占有者手中夺取资源，资源只能由占有者自愿释放 3、请求和保持（部分分配，占有申请） 一个进程在申请新的资源的同时保持对原有资源的占有（只有这样才是动态申请，动态分配） 4、循环等待 存在一个进程等待队列 {P1 , P2 , „ , Pn}，其中P1等待P2占有的资源，P2等待P3占有的资源，„，Pn等待P1占有的资源，形成一个进程等待环路 2.2.5 死锁的解决方案 1 产生死锁的例子 申请不同类型资源产生死锁 P1： „ 申请打印机 申请扫描仪 使用 释放打印机 释放扫描仪 „ P2： „ 申请扫描仪 申请打印机 使用 释放打印机 释放扫描仪 „ 申请同类资源产生死锁（如内存） 设有资源R，R有m个分配单位，由n个进程P1,P2,„,Pn（n > m）共享。假设每个进程对R的申请和释放符合下列原则： * 一次只能申请一个单位 * 满足总申请后才能使用 * 使用完后一次性释放 m=2，n=3 资源分配不当导致死锁产生 2死锁预防: 定义:在系统设计时确定资源分配算法，保证不发生死锁。具体的做法是破坏产生死锁的四个必要条件之一 ①破坏“不可剥夺”条件 在允许进程动态申请资源前提下规定，一个进程在申请新的资源不能立即得到满足而变为等待状态之前，必须释放已占有的全部资源，若需要再重新申请 ②破坏“请求和保持”条件 要求每个进程在运行前必须一次性申请它所要求的所有资源，且仅当该进程所要资源均可满足时才给予一次性分配 ③破坏“循环等待”条件 采用资源有序分配法： 把系统中所有资源编号，进程在申请资源时必须严格按资源编号的递增次序进行，否则操作系统不予分配。 2.2.6 安全状态与不安全状态 安全状态： 如果存在一个由系统中所有进程构成的安全序列P1，„Pn，则系统处于安全状态。一个进程序列{P1，„，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj(j < i)当前占有资源量之和，系统处于安全状态(安全状态一定是没有死锁发生的)。 不安全状态:不存在一个安全序列，不安全状态一定导致死锁。 2.3 数据结构设计 1.可利用资源向量矩阵AVAILABLE。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果AVAILABLE [j]= K，则表示系统中现有R类资源K个 2.最大需求矩阵MAX。这是一个n*m的矩阵，用以表示每一个进程对m类资源的最大需求。如果MAX [i,j]=K，则表示进程i需要R类资源的数目为K。 3.分配矩阵ALLOCATION。这也是一个n*m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果ALLOCATION [i,j]=K，则表示进程i当前已分得R类资源的数目为K。 4.需求矩阵NEED。这也是一个n*m的矩阵，用以表示每一个进程尚需的各类资源数。如果NEED [i,j]=K，则表示进程i还需要R类资源K个，才能完成其任务。上述矩阵存在下述关系： NEED [i,j]= MAX[i,j]﹣ ALLOCATION[i,j] 2.4 算法的实现 2.4.1 初始化 由用户输入数据，分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。2.4.2 银行家算法 在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。 银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。它是最具有代表性的避免死锁的算法。 设进程cusneed提出请求REQUEST [i]，则银行家算法按如下规则进行判断。(1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i]，则转(2)；否则，出错。 (2)如果REQUEST [cusneed] [i]<= AVAILABLE[cusneed][i]，则转(3)；否则，出错。(3)系统试探分配资源，修改相关数据： AVAILABLE[i]-=REQUEST[cusneed][i];ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];NEED[cusneed][i]-=REQUEST[cusneed][i];(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。 2.4.3 安全性检查算法 (1)设置两个工作向量Work=AVAILABLE;FINISH(2)从进程集合中找到一个满足下述条件的进程，FINISH==false;NEED<=Work;如找到，执行(3)；否则，执行(4)(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。 Work+=ALLOCATION;Finish=true;GOTO 2(4)如所有的进程Finish= true，则表示安全；否则系统不安全。 三、页面调度算法 3.1 实验名称 页式虚拟存储管理：页面调度算法 3.2 实验目的 页式虚拟存储器实现的一个难点是设计页面调度（置换）算法，即将新页面调入内存时，如果内存中所有的物理页都已经分配出去，就要按某种策略来废弃某个页面，将其所占据的物理页释放出来，供新页面使用。本实验的目的是通过编程实现几种常见的页面调度（置换）算法，加深读者对页面思想的理解。3.3 实验原理 页面调度算法 目前有许多页面调度算法，本实验主要涉及先进先出调度算法、最近最少调度算法、最近最不常用调度算法。本实验使用页面调度算法时作如下假设，进程在创建时由操作系统为之分配一个固定数目物理页，执行过程中物理页的数目和位置不会改变。也即进程进行页面调度时只能在分到的几个物理页中进行。 下面对各调度算法的思想作一介绍。 <1> 先进先出调度算法 先进先出调度算法根据页面进入内存的时间先后选择淘汰页面，先进入内存的页面先淘汰，后进入内存的后淘汰。本算法实现时需要将页面按进入内存的时间先后组成一个队列，每次调度队首页面予以淘汰。 <2>最近最少调度算法 先进先出调度算法没有考虑页面的使用情况，大多数情况下性能不佳。根据程序执行的局部性特点，程序一旦访问了某些代码和数据，则在一段时间内会经常访问他们，因此最近最少用调度在选择淘汰页面时会考虑页面最近的使用，总是选择在最近一段时间以来最少使用的页面予以淘汰。算法实现时需要为每个页面设置数据结构记录页面自上次访问以来所经历的时间。 <3>最近最不常用调度算法 由于程序设计中经常使用循环结构，根据程序执行的局部性特点，可以设想在一段时间内经常被访问的代码和数据在将来也会经常被访问，显然这样的页面不应该被淘汰。最近最不常用调度算法总是根据一段时间内页面的访问次数来选择淘汰页面，每次淘汰访问次数最少的页面。算法实现时需要为每个页面设置计数器，记录访问次数。计数器由硬件或操作系统自动定时清零。 缺页调度次数和缺页中断率、缺页置换率计算 缺页中断次数是缺页时发出缺页中断的次数。 缺页中断率=缺页中断次数/总的页面引用次数*100% 缺页调度次数是调入新页时需要进行页面调度的次数 缺页置换率=缺页调度次数/总的页面引用次数*100% 3.4 实验内容 （1）设计程序实现以上三种页面调度算法，要求： ①.可以选择页面调度算法类型； ②.可以为进程设置分到物理页的数目，设置进程的页面引用情况，可以从键盘输入页面序列，也可从文件中读取； ③.随时计算当前的页面调度次数的缺页中断率； ④.使用敲键盘或响应WM-TIMER的形式模仿时间的流逝； ⑤.以直观的的形式将程序的执行情况显示在计算机屏幕上； ⑥.存盘及读盘功能，可以随时将数据存入磁盘文件，供以后重复实验时使用。 （2）假定进程分配到3个物理块，对于下面的页面引用序列：（test.txt） 7-0-1-2-0-3-0-4-2-3-0-3-2-1-2-0-1-7-0-1 请分别用先进和先出调度算法，最近最少用调度算法，最近最不常用调度算法计算缺页中断次数，缺页中断率和缺页调度次数、缺页置换率。 再假定进程分配到4、5个物理块，重复本实验。 （3）假定进程分配到3个物理块，对于下面的页面引用序列：（test2.txt） 4-3-2-1-4-3-5-4-3-2-1-5-0-7-3-8-9-0-2-1-4-7-3-9 请分别用先进先出调度算法、最近最少用调度算法，最近最不常用调度算法计算缺页中断次数，缺页中断率和缺页调度次数、缺页置换率。 再假定进程分配到4、5个物理块，重复本实验。 （4）假定进程分配到3个物理块，使用程序的动态页面序列生成算法，生成一个页面序列，将此序列存入磁盘文件。再从磁盘文件读入该序列，用程序分别计算三种算法下的缺页中断次数、缺页中断率和缺页调度次数、缺页置换率。第二篇：操作系统课程设计-磁盘调度算法
第三篇：操作系统课程设计,磁盘调度算法范文
第四篇：操作系统实习报告(磁盘文件操作)
第五篇：操作系统课程设计
![下载操作系统课程设计++模拟磁盘文件管理的程序[精选]word格式文档](http://static.xiexiebang.com/skin/default/images/icon_word.png){kind=icon}
点击咨询 