精华内容
下载资源
问答
  • 磁盘调度算法课程设计
    2021-07-10 16:03:27

    1、实验目的

    (1) 了解磁盘结构以及磁盘上数据的组织方式。
    (2) 掌握磁盘访问时间的计算方式。
    (3) 掌握常用磁盘调度算法及其相关特性。

    2、实验基本知识及原理

    (1)磁盘数据的组织
    磁盘上每一条物理记录都有唯一的地址,该地址包括三个部分:磁头号(盘面号)、柱面号(磁
    道号)和扇区号。给定这三个量就可以唯一地确定一个地址。
    (2)磁盘访问时间的计算方式
    磁盘在工作时以恒定的速率旋转。为保证读或写,磁头必须移动到所要求的磁道上,当所要求
    的扇区的开始位置旋转到磁头下时,开始读或写数据。对磁盘的访问时间包括:寻道时间、旋转延
    迟时间和传输时间。
    (3)磁盘调度算法
    磁盘调度的目的是要尽可能降低磁盘的寻道时间,以提高磁盘 I/O 系统的性能。
    先进先出算法 FIFO:按访问请求到达的先后次序进行调度。
    最短服务时间优先算法 SSTF:优先选择使磁头臂从当前位置开始移动最少的磁盘 I/O 请求进
    行调度。
    SCAN(电梯算法):要求磁头臂先沿一个方向移动,并在途中满足所有未完成的请求,直到它
    到达这个方向上的最后一个磁道,或者在这个方向上没有别的请求为止,后一种改进有时候称作
    LOOK 策略。然后倒转服务方向,沿相反方向扫描,同样按顺序完成所有请求。
    C-SCAN(循环扫描)算法:在磁盘调度时,把扫描限定在一个方向,当沿某个方向访问到最
    后一个磁道时,磁头臂返回到磁盘的另一端,并再次开始扫描。

    3、实验内容

    本实验通过编程模拟实现几种常见的磁盘调度算法。
    (1)测试数据:参见教材 P305,测试结果参见表 11.2。
    (2)使用 C 语言编程实现 FIFO、SSTF、SCAN、C-SCAN 算法。

    4、 源代码

    #include <stdio.h>
    #include <math.h>
    void menu();
    void fifo();
    void sstf();
    void scan();
    void cscan();
    int n;//磁道数 
    int m;// 初始磁道 
    int a[100];//磁道序列 
    int main(){
    	printf("请输入磁道数目:\n");
    	scanf("%d",&n); 
    	printf("请输入初始磁道序列:\n");
    	for(int i=0;i<n;i++)
    	scanf("%d",&a[i]);
    	printf("请输入磁道起始位置:\n");
    	scanf("%d",&m);
    	menu();
    }
    
    void menu(){
    	int op;
    	printf("请输入算法操作序号\n1.fifo 2.sstf 3.scan 4.cscan 5.break\n");
    	scanf("%d",&op);
    	switch(op){
    		case 1:fifo();break;
    		case 2:sstf();break;
    		case 3:scan();break;
    		case 4:cscan();break;
    		default :printf("error");break; 
    	}
    }
    
    void fifo(){
    	int b[100];
    	for(int i=0;i<n;i++)
    		b[i]=a[i];
    	int num=0;//磁道总长度 
    	int r=m;//初始磁道 
    	for(int i=0;i<n;i++)
    	{
    		num=num+abs(r-b[i]);
    		r=b[i];
    	}
    	for(int i=0;i<n;i++)
    	{
    		printf("%d\n",b[i]);
    	}
    	double ave=(double)num/n;//平均长度 
    	printf("总寻道长度:%d\n",num);
    	printf("平均寻道长度:%f\n",ave);
    	menu();
    }
    void sstf(){
    	int b[100];//序列数组 
    	int c[100];//结果数组 
    	int r=m; //初始磁道 
    	for(int i=0;i<n;i++)
    		b[i]=a[i];
    	for(int i=0;i<n;i++){
    		int min=200; 
    		int flag;
    		for(int j=0;j<n;j++)
    		{
    			if(abs(b[j]-r)<min)
    			{
    				min=abs(b[j]-r);
    				flag=j;
    			}
    		}
    		r=b[flag];
    		c[i]=b[flag];
    		for(int x=flag;x<n-i;x++)
    		b[x]=b[x+1];
    	}
    	int	num=0;
    	r=m;
    	for(int i=0;i<n;i++)
    	{
    		num=num+abs(r-c[i]);
    		r=c[i];
    	}
    	for(int i=0;i<n;i++)
    	printf("%d\n",c[i]);
    	double ave=(double)num/n;//平均长度 
    	printf("总寻道长度:%d\n",num);
    	printf("平均寻道长度:%f\n",ave);
    	menu();
    }
    void scan(){
    	int b[100];
    	int r=m;
    	for(int i=0;i<n;i++)
    	b[i]=a[i];
    	int t;
    	for(int i=0;i<n-1;i++)
    	{
    		for(int j=0;j<n-1-i;j++)
    		{
    			if(b[j]>b[j+1])
    			{
    				t=b[j];
    				b[j]=b[j+1];
    				b[j+1]=t;
    			}
    		}
    	}
    	printf("请输入扫描方向:\n1.磁盘增大2.磁盘减小\n");
    	int op;
    	scanf("%d",&op);
    	if(op==1)
    	{
    		int flag;
    		int c[100];
    		for(int i=0;i<n;i++)
    		{
    			if(b[i]>100)
    			{
    				flag=i;
    				break;
    			}
    		}
    		int j=0;
    		for(int i=flag;i<n;i++)
    		{
    			c[j]=b[i];
    			j++;
    		}
    		for(int i=flag-1;i>-1;i--)
    		{
    			c[j]=b[i];
    			j++;
    		}
    		for(int i=0;i<n;i++) 
    			printf("%d\n",c[i]);
    		int num=0;
    		for(int i=0;i<n;i++)
    		{
    			num=num+abs(r-c[i]);
    			r=c[i];
    		}
    		double ave=(double)num/n;//平均长度 
    		printf("总寻道长度:%d\n",num);
    		printf("平均寻道长度:%f\n",ave);
    		menu();
    	 } 
    	 else
    	 {
    	 	int flag;
    		int c[100];
    		for(int i=0;i<n;i++)
    		{
    			if(b[i]>100)
    			{
    				flag=i;
    				break;
    			}
    		}
    		int j=0;
    		for(int i=flag-1;i>-1;i--)
    		{
    			c[j]=b[i];
    			j++;
    		}
    		for(int i=flag;i<n;i++)
    		{
    			c[j]=b[i];
    			j++;
    		}
    		for(int i=0;i<n;i++) 
    			printf("%d\n",c[i]);
    		int num=0;
    		for(int i=0;i<n;i++)
    		{
    			num=num+abs(r-c[i]);
    			r=c[i];
    		}
    		double ave=(double)num/n;//平均长度 
    		printf("总寻道长度:%d\n",num);
    		printf("平均寻道长度:%f\n",ave);
    		menu();
    	 } 
    
    }
    void cscan(){
    	int b[100];
    	int r=m;
    	for(int i=0;i<n;i++)
    	b[i]=a[i];
    	int t;
    	for(int i=0;i<n-1;i++)
    	{
    		for(int j=0;j<n-1-i;j++)
    		{
    			if(b[j]>b[j+1])
    			{
    				t=b[j];
    				b[j]=b[j+1];
    				b[j+1]=t;
    			}
    		}
    	}
    	printf("请输入扫描方向:\n1.磁盘增大2.磁盘减小\n");
    	int op;
    	scanf("%d",&op);
    	if(op==1)
    	{
    		int flag;
    		int c[100];
    		for(int i=0;i<n;i++)
    		{
    			if(b[i]>100)
    			{
    				flag=i;
    				break;
    			}	
    		}
    		int j=0;
    		for(int i=flag;i<n;i++)
    		{
    			c[j]=b[i];
    			j++;	
    		}
    		for(int i=0;i<flag;i++)
    		{
    			c[j]=b[i];
    			j++;
    		} 
    		for(int i=0;i<n;i++) 
    		printf("%d\n",c[i]);
    		int num=0;
    		for(int i=0;i<n;i++)
    		{
    			num=num+abs(r-c[i]);
    			r=c[i];
    		}
    		double ave=(double)num/n;//平均长度 
    		printf("总寻道长度:%d\n",num);
    		printf("平均寻道长度:%f\n",ave);
    		menu();
    	}
    	else
    	{
    		int flag;
    		int c[100];
    		for(int i=0;i<n;i++)
    		{
    			if(b[i]>100)
    			{
    				flag=i;
    				break;
    			}	
    		}
    		int j=0;
    		for(int i=flag-1;i>-1;i--)
    		{
    			c[j]=b[i];
    			j++;	
    		}
    		for(int i=n-1;i>=flag;i--)
    		{
    			c[j]=b[i];
    			j++;
    		} 
    		for(int i=0;i<n;i++) 
    		printf("%d\n",c[i]);
    		int num=0;
    		for(int i=0;i<n;i++)
    		{
    			num=num+abs(r-c[i]);
    			r=c[i];
    		}
    		double ave=(double)num/n;//平均长度 
    		printf("总寻道长度:%d\n",num);
    		printf("平均寻道长度:%f\n",ave);
    		menu();
    	}
    }
    
    
    更多相关内容
  • 目录 目录 1 1课程设计目的 2 1.1 编写目的 2 2课程设计内容 2 2.1 设计内容 2 3课程设计方案 3 3.1 模块划分 3 3.2 模块调用关系图 6 3.3 子模块程序流程图 6 4测试数据和结果 10 4.1 测试数据 10 4.2 测试结果 11 ...
  • 磁盘调度算法程序课程设计报告.pdf
  • 操作系统磁盘调度算法实验报告
  • 操作系统课程设计磁盘调度算法
  • 操作系统磁盘调度算法课程设计.doc
  • 磁盘调度算法课程设计(附源代码)

    千次阅读 多人点赞 2020-03-26 19:46:43
    磁盘驱动器,满足这一要求一位着要有较快的访问速度和较宽的磁盘宽带。磁盘宽带是指所传递的总字节数除以从服务请求开始到最后传递结束时的总时间。访问时间有寻道时间和旋转延迟两个主要部分。寻道时间是磁臂将...

    操作系统的任务之一就是有效地使用硬件。

    对磁盘驱动器,满足这一要求意味着要有较快的访问速度和较宽的磁盘宽带。

    磁盘宽带是指所传递的总字节数除以从服务请求开始到最后传递结束时的总时间。

    访问时间有寻道时间和旋转延迟两个主要部分。

    • 寻道时间是磁臂将磁头移动到包含目标扇区的柱面的时间。
    • 旋转延迟是磁盘需要将目标扇区转动到磁头下的时间。
      通常,最小寻道时间可以用最短寻道距离来表示。

    一、最常用的磁盘调度算法

    1)先来先服务(FCFS)算法:根据进程请求访问磁盘的先后次序进行调度。算法的实现简单、公平;缺点:效率不高,相临两次请求可能会造成最内到最外的柱面寻道,使磁头反复移动,增加了服务时间,对机械也不利。

    2)最短寻道时间优先(SSTF)算法:优先选择距当前磁头最近的访问请求进行服务,主要考虑寻道优先。优点:改善了磁盘平均服务时间;缺点:造成某些访问请求长期等待得不到服务。

    3)扫描(SCAN)算法:当设备无访问请求时,磁头不动;当有访问请求时,磁头按一个方向移动,在移动过程中对遇到的访问请求进行服务,然后判断该方向上是否还有访问请求,如果有则继续扫描;否则改变移动方向,并为经过的访问请求服务,如此反复。克服了最短寻道优先的缺点,既考虑了距离,同时又考虑了方向。

    4)循环扫描(C-SCAN)算法:总是从0号柱面开始向里扫描,按照各自所要访问的柱面位置的次序去选择访问者,移动臂到达最后一个柱面后,立即带动读写磁头快速返回到最小的需要访问的柱面,返回时不为任何的等待访问者服务,返回后可再次进行扫描。

    二、调度算法的选择原则

    1)SSTF较为普遍且很有吸引力。
    2)SCAN和C-SCAN对磁盘负荷较大的系统会执行得更好,这是因为它不可能产生饥饿问题。
    3)对于任何调度算法,性能依赖于请求的类型和数量。
    4)磁盘服务请求很大程度上收文件分配方法所影响。
    5)磁盘调度算法应作为一个操作系统的独立模块。因为,如果有必要,可以方便替换成另外一种不同的算法。
    6)SSTF或SCAN是比较合理地默认算法。

    三、实验问题及实现

    1.现有8个进程先后提出的磁盘I/O请求 :98 138 37 122 14 124 65 67,当前磁头位置为53号磁道,磁头向内移动。分别采用FCFS算法、SSTF算法、SCAN算法以及C-SCAN算法,画出磁头移动的轨迹,计算平均寻道长度。
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    2.打开“Microsoft Visual C++ 6.0”,输入相关代码,对程序行进编译运行。在与源程序在同一目录下新建一个“cidao.txt”文件,内容为上述8个进程先后提出的磁盘I/O请求 :98 138 37 122 14 124 65 67。
    在这里插入图片描述

    运行界面如下:
    在这里插入图片描述

    下面我们根据提示信息分别测试三种算法的最短寻道时间(假设当前磁头位置为53号磁道,磁头向内移动):

    1)FCFS算法的测试结果是:
    在这里插入图片描述
    2)SSTF算法的测试结果是:
    在这里插入图片描述

    3)SCAN算法的测试结果是:
    在这里插入图片描述

    4.试模仿SCAN算法部分代码,在程序中再添加C-SCAN算法的实现,并对该算法进行测试。
    (1)所添加的C-SCAN算法的代码:

    #include<iostream>
    #include<cmath>
    using namespace std;
    #define maxsize 100
    //电梯调度算法
    void CSCAN(int array[],int m){
    	int sum=0,index=0,now,order;
    	cout<<"请输入当前的的磁道号:";
    	cin>>now;
    	cout<<endl<<"请输入磁头移动的方向(0向左,1向右)";
    	cin>>order;
    	int arr[m];//新建一个arr数组复制array的所有元素 
    	//先进行选择排序,元将素由大到小排列
    	for(int i=0;i<m;i++){
    		arr[i]=array[i];
    	}
    	for(int i=0;i<m;i++){ 
    		int k=i;
    		for(int j=i;j<m;j++){
    			if(arr[j]<arr[k]){
    				k=j;
    			}
    		}
    		int temp=arr[i];
    		arr[i]=arr[k];
    		arr[k]=temp;
    	} 
    //	for(int i=0;i<m;i++){
    //		cout<<array[i]<<"";
    //	}
    	//找到距离最近的磁道下标index,肯定与now相邻 
    	int min=abs(now-arr[0]);
    	for (int i=0;i<m;i++){
    		if(abs(now-arr[i])<min){
    			min=abs(now-arr[i]);
    			index=i;
    		}
    	} 
    	int left,right;
    	if(arr[index]>now){
    		right=index;
    		left=index-1;
    	}else{
    		left=index;
    		right=index+1;
    	}
    	cout<<endl<<"访问的磁道顺序为:";//换行 
    	if(order==0){
    		sum+=abs(now-arr[left]);
    		for(int i=left;i>=0;i--){
    			cout<<arr[i]<<" ";
    		}
    		//直接移动到最右端,然后才继续向左处理 
    		for(int i=m-1;i>=right;i--){
    			cout<<arr[i]<<" ";
    		}
    		sum+=abs(arr[left]-arr[0])+abs(arr[m-1]-arr[0])+abs(arr[m-1]-arr[right]);
    	}else if(order==1){
    		sum+=abs(now-arr[right]);
    		for(int i=right;i<m;i++){
    			cout<<arr[i]<<" ";
    		}
    	    for(int i=0;i<=left;i++){
    			cout<<arr[i]<<" ";
    		}
    		sum+=abs(arr[m-1]-arr[right])+abs(arr[m-1]-arr[0])+abs(arr[left]-arr[0]);	
    	}else{
    		cout<<"输入磁头移动的方向有误"<<endl;
    	}
    	
    	cout<<"移动的总道数: "<<sum<<endl;
    }
    int main(){
    	FILE *fp;
    	int cidao[maxsize];
    	int i=0,count;
    	fp=fopen("cidao.txt","r+");
    	if(fp==NULL){
    		cout<<"文件打不开!"<<endl;
    		exit(0);
    	}
    	while(!feof(fp)){
    		fscanf(fp,"%d",&cidao[i]);
    		i++;
    	}
    	count=i;
    	//count就是文件中待访问的磁道数 
    	cout<<"磁盘I/O请求序列为:";
    	for(i=0;i<count;i++){
    		cout<<cidao[i]<<" ";
    	}
    	cout<<endl;
    	while(1){
    		cout<<"————————CSCAN算法系统————————"<<endl;
    		CSCAN(cidao,count);
    	}
    	return 0;
    }
    
    

    (2)C-SCAN算法的测试结果是:
    在这里插入图片描述

    完整源代码如下:

    #include<iostream>
    #include<cmath> 
    #include<vector>
    using namespace std;
    #define maxsize 100
    
    //先来先服务调度算法
    void FCFS(int array[],int m){
    	int sum=0,i,now;
    	cout<<"请输入当前的的磁道号:";
    	cin>>now;
    	cout<<endl<<"访问的磁道顺序为:";//换行 
    	for(i=0;i<m;i++){
    		cout<<array[i]<<' ';
    		//计算访问每个磁道的绝对值 
    		sum+=abs(now-array[i]);
    		//更新当前磁道 
    		now=array[i];
    	}
    	cout<<"移动的总道数: "<<sum<<endl;
    }
    //最短距离优先调度算法
    void SSTF(int array[],int m){
    	int sum=0,now;
    	cout<<"请输入当前的的磁道号:";
    	cin>>now;
    
    	//定义进行操作的变长数组dic
    	vector<int> dic;
    	//定义保存数据的变长数组data 
    	vector<int> data; 
    	for(int i=0;i<m;i++){
    		dic.push_back(array[i]);
    	}
    	//有多少磁道号执行多少次
    	for(int i=0;i<m;i++){
    		//先默认最短距离是now到第一个磁道
    		int min=abs(now-dic[0]),index=0; 
    		for(int j=0;j<dic.size();j++){
    			if(abs(dic[j]-now)<min){
    				//更新当前最短距离和下标 
    				min=abs(dic[j]-now);
    				index=j;
    			}	
    		} 
    		sum+=min;//加上每次的移动距离 
    		data.push_back(dic[index]);
    		now=dic[index];
    		dic.erase(dic.begin()+index);
    		
    	}
    	cout<<endl<<"访问的磁道顺序为:";//换行 
    	for(int i=0;i<data.size();i++){
    		cout<<data[i]<<" ";
    	}
    	cout<<"移动的总道数: "<<sum<<endl;
    }
    //电梯调度算法
    void SCAN(int array[],int m){
    	int sum=0,index=0,now,order;
    	cout<<"请输入当前的的磁道号:";
    	cin>>now;
    	cout<<endl<<"请输入磁头移动的方向(0向左,1向右)";
    	cin>>order;
    	int arr[m];//新建一个arr数组复制array的所有元素 
    	//先进行选择排序,元将素由大到小排列
    	for(int i=0;i<m;i++){
    		arr[i]=array[i];
    	}
    	for(int i=0;i<m;i++){ 
    		int k=i;
    		for(int j=i;j<m;j++){
    			if(arr[j]<arr[k]){
    				k=j;
    			}
    		}
    		int temp=arr[i];
    		arr[i]=arr[k];
    		arr[k]=temp;
    	} 
    //	for(int i=0;i<m;i++){
    //		cout<<array[i]<<"";
    //	}
    	//找到距离最近的磁道下标index,肯定与now相邻 
    	int min=abs(now-arr[0]);
    	for (int i=0;i<m;i++){
    		if(abs(now-arr[i])<min){
    			min=abs(now-arr[i]);
    			index=i;
    		}
    	} 
    	int left,right;
    	if(arr[index]>now){
    		right=index;
    		left=index-1;
    	}else{
    		left=index;
    		right=index+1;
    	}
    	cout<<endl<<"访问的磁道顺序为:";//换行 
    	if(order==0){
    		sum+=abs(now-arr[left]);
    		for(int i=left;i>=0;i--){
    			cout<<arr[i]<<" ";
    		}
    		for(int i=right;i<m;i++){
    			cout<<arr[i]<<" ";
    		}
    		sum+=abs(arr[m-1]-arr[0])+abs(arr[left]-arr[0]);
    	}else if(order==1){
    		sum+=abs(now-arr[right]);
    		for(int i=right;i<m;i++){
    			cout<<arr[i]<<" ";
    		}
    	    for(int i=left;i>=0;i--){
    			cout<<arr[i]<<" ";
    		}
    		sum+=abs(arr[m-1]-arr[right])+abs(arr[m-1]-arr[0]);	
    	}else{
    		cout<<"输入磁头移动的方向有误"<<endl;
    	}
    	
    	cout<<"移动的总道数: "<<sum<<endl;
    }
    int main(){
    	int c,i=0,count;
    	FILE *fp;
    	int cidao[maxsize];
    	fp=fopen("cidao.txt","r+");
    	if(fp==NULL){
    		cout<<"文件打不开!"<<endl;
    		exit(0);
    	}
    	while(!feof(fp)){
    		fscanf(fp,"%d",&cidao[i]);
    		i++;
    	}
    	//count就是文件中待访问的磁道数 
    	cout<<"磁盘I/O请求序列为:";
    	count=i;
    	for(i=0;i<count;i++){
    		cout<<cidao[i]<<" ";
    	}
    	cout<<endl;
    	while(1){
    		cout<<endl<<"系统的菜单如下:"<<endl;
    		cout<<"1.先来先服务 2.最短寻道时间优先 \n3.电梯调度   4.退出"<<endl;
    		cout<<"请选择服务:";
    		cin>>c;
    		if(c>3)
    			break;
    		switch(c){
    			case 1:
    				FCFS(cidao,count);
    				break;
    			case 2:
    				SSTF(cidao,count);
    				break;
    			case 3:
    				SCAN(cidao,count);
    				break;
    		}
    	}
    	return 0;
    }
    
    

    学会在阴霾的日子里找光,未来才会更可期。

    展开全文
  • 操作系统 磁盘调度算法课程设计.doc
  • 磁盘调度算法 学生姓名: 学生学号: 专业班级: 指导老师 2013 年6月20日 1实验目的 通过这次实验加深对磁盘调度算法的理解进一步掌握先来先 服务 FCFS最短寻道时间优先 SSTFSCAN和循环 SCAN算法的实现 方法 2问题描述...
  • 目 录 1 前言 2 2 系统功能简介 2 ...3设计主要内容 2 3.1设计分析 2 3.1.1需求分析 2 3.1.2总体设计 2 3.2 详细设计 3 3.3系统调试 6 3.4 结论 7 3.5参考文献 7 4 使用说明 7 5 心得体会 7 6 源代码 8
  • 操作系统--磁盘调度算法课程设计.doc
  • 操作系统__磁盘调度算法课程设计.pdf
  • 操作系统磁盘调度 算法课程设计 FCFSB法流程图 SSTFW法流程图 SCAN#法流程图: 选择移动臂 cscaN!法流程图: SSTF: SCAN
  • 淮 阴 工 学 院 操作系统课程设计报告 选题名称 : 磁盘调度算法的模拟实现 系院 : 经济管理学院 专 业: 信息管理与信息系统 班 级: 姓 名: 学 号: 指导教师 : 学年学期 : 2014 ~ 2015 学年 第 1 学期 2014 年 12 月 ...
  • 淮 阴 工 学 院 操作系统课程设计报告 选题名称 : 磁盘调度算法的模拟实现 系院 : 经济管理学院 专 业 : 信息管理与信息系统 班 级 : 姓 名 : 学 号 : 指导教师 : 学年学期 : 2014 ~ 2015 学年 第 1 学期 2014 年 12...
  • FCFS算法流程图:输入当前磁道号now 输入当前磁道号now 磁头移动距离 sum=abs(now-array[0]) 磁头移动总距离Sum+=abs(array[j]-array[i]) 输出磁盘调度序列array[j] 目前的位置变为当前的位置j++ j输出平均寻道长度 ...
  • 未定义书签 1课程设计目的 错误 !未定义书签 编写目的 错误 !未定义书签 2课程设计内容 错误 !未定义书签 设计内容 错误 !未定义书签 3课程设计方案 错误 !未定义书签 模块划分 错误 !未定义书签 模块调用关系图 ...
  • (1)先来先服务算法(FCFS) (2)最短寻道时间优先算法(SSTF) (3)扫描算法(SCAN) (4)循环扫描算法(CSCAN)
  • 广东工业大学操作系统课程设计报告,关于磁盘算法的,设计主界面以灵活选择某算法,且以下算法都要实现 1、先来先服务算法( FCFS) 2、最短寻道时间优先算法( SSTF) 3、扫描算法( SCAN ) 4、循环扫描算法( ...
  • 个人资料整理 仅限学习使用 实验七磁盘调度算法 目 录 一实验目的 加深对磁盘的工作原理和调度效率的理解掌握各种磁盘调度算法模拟实现一种磁盘调度算法 等 b5E2RGbCAP 二实验属性 该实验为设计性实验 个人资料整理 ...
  • 武汉理工大学计算机科学与技术学院操作系统磁盘调度算法
  • 实验七 磁盘调度算法的模拟与实现 1、实验目的 (1) 了解磁盘结构以及磁盘上数据的组织方式。 (2) 掌握磁盘访问时间的计算方式。 (3) 掌握常用磁盘调度算法及其相关特性。 2、实验基本知识及原理 (1)磁盘数据的组织...

    实验七 磁盘调度算法的模拟与实现

    完整课程设计源码及其报告查看陈陈的操作系统课程设计

    1、实验目的

    (1) 了解磁盘结构以及磁盘上数据的组织方式。

    (2) 掌握磁盘访问时间的计算方式。

    (3) 掌握常用磁盘调度算法及其相关特性。

    2、实验基本知识及原理

    (1)磁盘数据的组织

    磁盘上每一条物理记录都有唯一的地址,该地址包括三个部分:磁头号(盘面号)、柱面号(磁

    道号)和扇区号。给定这三个量就可以唯一地确定一个地址。

    (2)磁盘访问时间的计算方式

    磁盘在工作时以恒定的速率旋转。为保证读或写,磁头必须移动到所要求的磁道上,当所要求

    的扇区的开始位置旋转到磁头下时,开始读或写数据。对磁盘的访问时间包括:寻道时间、旋转延

    迟时间和传输时间。

    (3)磁盘调度算法

    磁盘调度的目的是要尽可能降低磁盘的寻道时间,以提高磁盘 I/O 系统的性能。

    先进先出算法FIFO:按访问请求到达的先后次序进行调度。

    最短服务时间优先算法SSTF:优先选择使磁头臂从当前位置开始移动最少的磁盘 I/O 请求进行调度。

    SCAN(电梯算法):要求磁头臂先沿一个方向移动,并在途中满足所有未完成的请求,直到它到达这个方向上的最后一个磁道,或者在这个方向上没有别的请求为止,后一种改进有时候称作LOOK 策略。然后倒转服务方向,沿相反方向扫描,同样按顺序完成所有请求。

    C-SCAN(循环扫描)算法:在磁盘调度时,把扫描限定在一个方向,当沿某个方向访问到最后一个磁道时,磁头臂返回到磁盘的另一端,并再次开始扫描。

    3、实验内容

    本实验通过编程模拟实现几种常见的磁盘调度算法。

    (1)测试数据:参见教材 P305,测试结果参见表 11.2。

    (2)使用 C 语言编程实现 FIFO、SSTF、SCAN、C-SCAN 算法。

    4、 实验结果与分析

    5、 实验总结

    实验源码如下:

    #include"stdio.h"
    #include"stdlib.h"
    #define maxsize 1000 //定义最大数组域
    
    void sort(int *a, int left, int right)//二分法排序
    {
        if(left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
        {
            return ;
        }
        int i = left;
        int j = right;
        int key = a[left];
         
        while(i < j)                               /*控制在当组内寻找一遍*/
        {
            while(i < j && key <= a[j])//找到从右边开始第一个大于key的值
            /*而寻找结束的条件就是,1,找到一个小于或者大于key的数(大于或小于取决于你想升
            序还是降序)2,没有符合条件1的,并且i与j的大小没有反转*/ 
            {
                j--;/*向前寻找*/
            }
             
            a[i] = a[j];
            /*找到一个这样的数后就把它赋给前面的被拿走的i的值(如果第一次循环且key是
            a[left],那么就是给key)*/
             
            while(i < j && key >= a[i])
            /*这是i在当组内向前寻找,同上,不过注意与key的大小关系停止循环和上面相反,
            因为排序思想是把数往两边扔,所以左右两边的数大小与key的关系相反*/
            {
                i++;
            }
             
            a[j] = a[i];
        }
         
        a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
        sort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
        sort(a, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
                           /*当然最后可能会出现很多分左右,直到每一组的i = j 为止*/
    }
    //先进先出调度算法
    void FIFO(int array[],int m)
    {
    	int sum=0,j,i,now;
    	float avg;
    	printf("\n 请输入当前的磁道号: ");
    		scanf("%d",&now);
    	printf("\n FIFO 调度结果: ");
    	printf("%d ",now);
    	for(i=0;i<m;i++) printf("%d ",array[i]);
    	sum=abs(now-array[0]);
    	for(j=1;j<m;j++) sum+=abs(array[j]-array[j-1]);//累计总的移动距离
    	avg=(float)sum/m;//计算平均寻道长度
    	printf("\n 移动的总道数: %d \n",sum);
    	printf(" 平均寻道长度: %f \n",avg);
    }
    
    //最短服务时间优先算法
    void SSTF(int array[],int m)
    {
    	int sum=0,j,i,now,c=maxsize,k;
    	int flag[maxsize]={0};
    	float avg;
    	printf("\n 请输入当前的磁道号: ");
    	scanf("%d",&now);
    	printf("\n SSTF 调度结果: ");
    	printf("%d ",now);
    	for(j = 0;j < m;j++)
    	{
    		for(i = 0;i < m;i++)//循环寻找离现在迟道的最小迟道距离
    		{
    			if(abs(array[i]-now) < c && flag[i]==0)
    			{
    				k = i;
    				c = abs(array[i]-now);//迟道距离
    			}
    		}
    		sum += c;
    		c = maxsize;
    		printf("%d ",array[k]);
    		flag[k] = 1;
    		now = array[k];
    	}
    	printf("\n 移动的总道数: %d \n",sum);
    	avg=(float)sum/m;//计算平均寻道长度
    	printf(" 平均寻道长度: %f \n",avg);
    }
    
    //扫描算法,采用look策略
    void SCAN(int array[],int m)
    {
    	int sum=0,i,now,k;
    	int flag[maxsize]={0};
    	float avg;
        int array2[maxsize];
    	for(i = 0; i < m ;i++)
    	{
    		array2[i] = array[i];
    	}
    	sort(array2,0,m-1);
    	
    	printf("\n 请输入当前的磁道号: ");
    	scanf("%d",&now);
    	printf("\n SCAN 调度结果: ");
    	printf("%d ",now);
    	for(i = 0 ; i < m ; i++)//从比现在大的磁道递增开始
    	{
    		if(array2[i] < now)//找出第一个比现磁道大的磁道
    		{
    			k = i;
    			continue;
    		}
    		sum += array2[i]-now;
    		now = array2[i];
            printf("%d ",array2[i]);
    	}
    	for(i = k ; i >= 0 ; i--)//从比现在小的磁道递减开始
    	{
    		sum +=abs(array2[i]-now);
    		now = array2[i];
            printf("%d ",array2[i]);
    	}
    	printf("\n 移动的总道数: %d \n",sum);
    	avg=(float)sum/m;//计算平均寻道长度
    	printf(" 平均寻道长度: %f \n",avg);
    }
    //循环扫描算法,采用look策略
    void CSCAN(int array[],int m)
    {
    	int sum=0,i,now,k;
    	int flag[maxsize]={0};
    	float avg;
    	int array2[maxsize];
    	for(i = 0; i < m ;i++)
    	{
    		array2[i] = array[i];
    	}
    	sort(array2,0,m-1);
    	printf("\n 请输入当前的磁道号: ");
    	scanf("%d",&now);
    	printf("\n SCAN 调度结果: ");
    	printf("%d ",now);
    	for(i = 0 ; i < m ; i++)
    	{
    		if(array2[i] < now)
    		{
    			k = i;
    			continue;
    		}
    		sum += array2[i]-now;
    		now = array2[i];
            printf("%d ",array2[i]);
    	}
    	for(i = 0 ; i <= k ; i++)//从比现在小的磁道递增开始
    	{
    		sum +=abs(array2[i]-now);
    		now = array2[i];
            printf("%d ",array2[i]);
    	}
    	printf("\n 移动的总道数: %d \n",sum);
    	avg=(float)sum/m;//计算平均寻道长度
    	printf(" 平均寻道长度: %f \n",avg);
    }
    
    
    // 操作界面
    int main()
    {
    	int c;
    	int count;
    	//int m=0;
    	int cidao[maxsize];//定义磁道号数组
    	int i=0;
    	int b;
    	printf("\n --------------------------------------------------\n");
    	printf("                 磁盘调度算法模拟");
    	printf("\n --------------------------------------------------\n\n");
    	printf("----请先输入磁道数量:------- \n");
    	scanf("%d",&b);
    	printf("----请先输入磁道序列:------- \n");
    	for(i=0;i<b;i++){
    		scanf("%d",&cidao[i]);
    	}
    	printf("\n 磁道读取结果: \n");
    	for(i=0;i<b;i++)
    	{
    		printf("%d ",cidao[i]);//输出读取的磁道的磁道号
    	}
    	count=b;
    	printf("\n ");
    	while(1)
    	{
    		printf("\n -----------------------------------\n");
    		printf("              算法选择                \n");
    		printf(" -----------------------------------\n");
    		printf("|1、先进先出算法(FIFO)            | \n");
    		printf("|2、最短服务时间优先算法(SSTF)    |\n");
    		printf("|3、扫描算法(SCAN)(LOOK策略)      |\n");
    		printf("|4、循环扫描算法(C-SCAN)(LOOK策略)|\n");
    		printf("|5. 退出                            |\n");
    		printf(" -----------------------------------\n");
    		printf("\n");
    		printf("请选择你想要操作的算法编号(输入数字1-4): ");
    		scanf("%d",&c);
    		if(c>7)
    			break;
    		switch(c)//算法选择
    		{
    		case 1:
    			FIFO(cidao,count);//先进先出算法
    			printf("\n");
    			break;
    		case 2:
    			SSTF(cidao,count);//最短服务时间优先算法
    			printf("\n");
    			break;
    		case 3:
    			SCAN(cidao,count);//扫描算法,采用look策略
    			printf("\n");
    			break;
    		case 4:
    			CSCAN(cidao,count);//循环扫描算法,采用look策略
    			printf("\n");
    			break;
    		case 5:
    			exit(0);
    		}
    	}
    	return 0;
    }
    

    实验结果截图分析:

    更多课程设计源码请进主页查看搜索陈陈不会敲代码

    完整课程设计报告请下载陈陈的操作系统课程设计源码及其报告

    完整报告包含以下内容的源码以及实验报告:
    image-20211209141046247
    资源展示如下:
    image-20211209111320397
    image-20211209111500829
    image-20211209111433497

    展开全文
  • 操作系统实验三磁盘调度算法的实现
  • 操作系统课程设计 磁盘调度算法 ,操作系统课程设计 磁盘调度算法 ~~~希望对大家有用
  • 操作系统课程设计——磁盘调度,Java写的,有图形界面,实现FCFS、SCAN等四种调度算法
  • 操作系统上机实验,要求使用C语言实现FCFS/SSTF/SCAN/CSCAN四种磁盘调度算法 本程序界面清晰,运行结果与教材一致,可以修改最大磁道号和初始磁道号(SSTF,SCAN,CSCAN算法中从哪个磁道号开始搜索),交互性较好 欢迎...
  • 如何使用代码: ... 磁盘调度算法 磁盘调度是由操作系统完成的,以调度到达磁盘的I / O请求。 磁盘调度也称为I / O调度。 磁盘调度很重要,因为: Multiple I/O requests may arrive by different processe
  • NULL 博文链接:https://bosshida.iteye.com/blog/620814
  • 磁盘调度算法java实现

    热门讨论 2013-05-30 20:54:38
    随机生成磁盘序列 用java实现了FIFO、SSTF、SCAN和C-SCAN算法模拟磁盘调度 有用户界面,有序列结果记录,有计算移动磁道数
  • 1.了解UNIX的命令及使用格式,熟悉UNIX/LINUX...2.设计一个磁盘工作区,并使用先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)和循环扫描算法(C-SCAN)计算磁头移动的总磁道数。 平均磁道数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,198
精华内容 28,879
关键字:

磁盘调度算法课程设计