【操作系统 - 6】磁盘调度算法

操作系统系列

  学习至此，发现很多学了但很久没用的知识，久而久之，慢慢遗忘。等哪天还需要的话，却发现已经忘得差不多了，即使整理了文档（word等），还是得从头再学一遍。读研第一学期，发现很多东西都可以从博客上学习到，也有不少博主呕心沥血整理了挺多有用的博文。于是，本人借此契机，也慢慢开始整理一些博文，不断改进完善中。整理博文（IT）有如下目的：

• 首要目的：记录“求学生涯”的所学所悟，不断修改，不断更新！（有读者的互动）
• 其次目的：在这“开源”的时代，整理并分享所学所悟是一种互利的行为！

博文系列：操作系统课程所学相关算法

• 1.先来先服务FCFS和短作业优先SJF进程调度算法
• 2.时间片轮转RR进程调度算法
• 3.预防进程死锁的银行家算法
• 4.动态分区分配算法
• 5.虚拟内存页面置换算法
• 6.磁盘调度算法

分享目的：希望大家能纠正本人的不足，继续完善程序，共同进步。

6个实验相关代码的下载地址：http://download.csdn.net/detail/houchaoqun_xmu/9865648

-------------------------------

磁盘调度算法

一、概念介绍和案例解析

• 先来先服务(FCFS，First Come First Served)：
  

  这是一种最简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。
  此算法的优点是公平、简单，且每个进程的请求都能依次地得到处理，不会出现某一进程的请求长期得不到满足的情况。但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。
  下图示出了有9个进程先后提出磁盘I/O请求时，按FCFS算法进行调度的情况。这里将进程号(请求者)按他们发出请求的先后次序排队。这样，平均寻道距离为55.3条磁道，与后面即将讲到的几种调度算法相比，其平均寻道距离较大，故FCFS算法仅适用于请求磁盘I/O的进程数目较少的场合。 

• 最短寻道时间优先(SSTF，Shortest Seek Time First)：
  

  该算法选择这样的进程：其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短。但这种算法不能保证平均寻道时间最短。
  下图示出了按SSTF算法进行调度时，各进程被调度的次序、每次磁头移动的距离，以及9次调度磁头平均移动的距离。
  比较图5-25和图5-26可以看出，SSTF算法的平均每次磁头移动距离明显低于FCFS的距离，因而SSTF较之FCFS有更好的寻道性能，故过去曾一度被广泛采用。 

• 扫描(SCAN)算法：
  

1) 进程“饥饿”现象
  SSTF算法虽然能获得较好的寻道性能，但却可能导致某个进程发生“饥饿”(Starvation)现象。
  因为只要不断有新进程的请求到达，且其所要访问的磁道与磁头当前所在磁道的距离较近，这种新进程的I/O请求必然优先满足。
  对SSTF算法略加修改后所形成的SCAN算法，即可防止老进程出现“饥饿”现象。 
2) SCAN算法
  该算法不仅考虑到欲访问的磁道与当前磁道间的距离，更优先考虑的是磁头当前的移动方向。例如，当磁头正在自里向外移动时，SCAN算法所考虑的下一个访问对象，应是其欲访问的磁道既在当前磁道之外，又是距离最近的。这样自里向外地访问，直至再无更外的磁道需要访问时，才将磁臂换向为自外向里移动。这时，同样也是每次选择这样的进程来调度，即要访问的磁道在当前位置内距离最近者，这样，磁头又逐步地从外向里移动，直至再无更里面的磁道要访问，从而避免了出现“饥饿”现象。
  由于在这种算法中磁头移动的规律颇似电梯的运行，因而又常称之为电梯调度算法。图 5-27示出了按SCAN算法对9个进程进行调度及磁头移动的情况。 

• 循环扫描(CSCAN)算法：
  

  SCAN算法既能获得较好的寻道性能，又能防止“饥饿”现象，故被广泛用于大、中、小型机器和网络中的磁盘调度。
  但SCAN也存在这样的问题：当磁头刚从里向外移动而越过了某一磁道时，恰好又有一进程请求访问此磁道，这时，该进程必须等待，待磁头继续从里向外，然后再从外向里扫描完所有要访问的磁道后，才处理该进程的请求，致使该进程的请求被大大地推迟。
  为了减少这种延迟，CSCAN算法规定磁头单向移动，例如，只是自里向外移动，当磁头移到最外的磁道并访问后，磁头立即返回到最里的欲访问的磁道，亦即将最小磁道号紧接着最大磁道号构成循环，进行循环扫描。
  采用循环扫描方式后，上述请求进程的请求延迟将从原来的2T减为T + Smax，其中，T为由里向外或由外向里单向扫描完要访问的磁道所需的寻道时间，而Smax是将磁头从最外面被访问的磁道直接移到最里面欲访问的磁道(或相反)的寻道时间。图5-28示出了CSCAN算法对9个进程调度的次序及每次磁头移动的距离。 

二、实验介绍

• 问题描述：

  设计程序模拟先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法的工作过程。假设有n个磁道号所组成的磁道访问序列，给定开始磁道号m和磁头移动的方向（正向或者反向），分别利用不同的磁盘调度算法访问磁道序列，给出每一次访问的磁头移动距离，计算每种算法的平均寻道长度。

• 程序要求：

1）利用先来先服务FCFS、最短寻道时间优先SSTF、SCAN和循环SCAN算法模拟磁道访问过程。

2）模拟四种算法的磁道访问过程，给出每个磁道访问的磁头移动距离。

3）输入：磁道个数n和磁道访问序列，开始磁道号m和磁头移动方向（对SCAN和循环SCAN算法有效），算法选择1-FCFS，2-SSTF，3-SCAN，4-循环SCAN。

4）输出：每种算法的平均寻道长度。

三、程序设计和程序开发

• 算法思想：

1）先来先服务(FCFS，FirstCome First Served)：根据进程请求访问磁盘的先后次序进行调度此算法的优点是公平、简单，且每个进程的请求都能依次地得到处理，不会出现某一进程的请求长期得不到满足的情况。但此算法由于未对寻道进行优化，致使平均寻道时间可能较长。

2）最短寻道时间优先(SSTF，ShortestSeek Time First)：该算法选择这样的进程：其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短。但这种算法不能保证平均寻道时间最短。

3）扫描(SCAN)算法：算法不仅考虑到欲访问的磁道与当前磁道间的距离，更优先考虑的是磁头当前的移动方向。例如，当磁头正在自里向外移动时，SCAN算法所考虑的下一个访问对象，应是其欲访问的磁道既在当前磁道之外，又是距离最近的。

4）循环扫描(CSCAN)算法：CSCAN算法规定磁头单向移动，例如，只是自里向外移动，当磁头移到最外的磁道并访问后，磁头立即返回到最里的欲访问的磁道，亦即将最小磁道号紧接着最大磁道号构成循环，进行循环扫描。

• 核心算法：

void FCFS()
{
	cout<<"******* 你选择了FCFS算法 ***********************************"<

void SSTF()
{
	cout<<"******* 你选择了SSTF算法 ***********************************"< disTemp[j])
			{
				pointMin = j;   //指向最小的位置
			}
		}
		VisitOrder[i] = TrackOrder[pointMin];  //给访问序列赋值
		MoveDistance[i] = getPositive(TrackOrder[pointMin],CurrentTrack);  //计算每次的移动距离
		totalDistance += MoveDistance[i];   //累计移动距离
		CurrentTrack = TrackOrder[pointMin];   //改变当前的磁道号
		isVisited[pointMin] = true;  //将当前的磁道号设置为已访问

	}

	AverageDistance = totalDistance*1.0/(TrackNum);
	display();
	cout<<"******* SSTF算法结束     ***********************************"<

void SCAN()
{
	/*
	算法思想：
	1. SCAN算法所考虑的下一个访问对象，应是其欲访问的磁道既在当前磁道之外，又是距离最近的
	   直至再无更外的磁道需要访问时，才将磁臂换向为自外向里移动
	2. 本程序先将磁道序列从小到大进行排序，再进行相应的处理，时间复杂度为取决于排序算法的时间复杂度
	*/
	cout<<"******* 你选择了SCAN算法 ***********************************"<=0;i--)
		{
			VisitOrder[count] = SortTrackOrder[i];
			MoveDistance[count] = getPositive(VisitOrder[count],currentTrack);
			currentTrack = VisitOrder[count];
			count++;
		}
	}//if
	else if (direction == 1)
	{
		cout<<"            向磁道减小的方向访问"<=0;i--)
		{
			VisitOrder[count] = SortTrackOrder[i];
			MoveDistance[count] = getPositive(VisitOrder[count],currentTrack);
			currentTrack = VisitOrder[count];
			count++;
		}

		for (i = point;i





void ImprovedSCAN()
{
	cout<<"******* 你选择了ImprovedSCAN算法 ***********************************"<>direction;

	initial();
	int TrackOrderIndex[MaxNumber],SortTrackOrder[MaxNumber];
	int i,j,temp,tempIndex;
	for (i = 0;i0;i--)
	{
		for (j = 0;j=SortTrackOrder[j+1])
			{
				//更新排序后的磁道号
				temp = SortTrackOrder[j];
				SortTrackOrder[j] = SortTrackOrder[j+1];
				SortTrackOrder[j+1] = temp;

				//更新排序后的磁道号索引值
				tempIndex = TrackOrderIndex[j];
				TrackOrderIndex[j] = TrackOrderIndex[j+1];
				TrackOrderIndex[j+1] = tempIndex;

			}//if
		}//for
	}//for   获得排序后的磁道号以及对应的原来的索引值

	int point = 0;
	while(StartTrack>=SortTrackOrder[point])
	{
		point++;
	}  //找到当前对应的：既在当前磁道之外，又是距离最近的磁道号索引值point

	int count = 0; 
	int currentTrack = StartTrack;
	if (direction == 0)  //向磁道增加的方向访问
	{
		cout<<"            向磁道增加的方向访问"<

四、实验结果分析

• 实验数据：

10
78 30 9 15 102 140 156 54 45 125
100

• 实验结果：

五、实验源码

// 操作系统_实验六（磁盘调度算法）.cpp : 定义控制台应用程序的入口点。
//

#include 
#include 
#include 

using namespace std;

const int MaxNumber=100;
int TrackNum;
int StartTrack;
int TrackOrder[MaxNumber];
int VisitOrder[MaxNumber];
bool isVisited[MaxNumber];
int MoveDistance[MaxNumber];
int totalDistance;
double AverageDistance;
bool direction;

void input();
void initial();
int getPositive(int num1,int num2);
void FCFS();
void SSTF();
void SCAN();
void ImprovedSCAN();
void display();

void input()
{
	ifstream readData;
	readData.open("data2.txt");
	readData>>TrackNum;  //磁道个数
	for (int i=0;i>TrackOrder[i];   //磁道访问序列
	}
	readData>>StartTrack;  //开始磁道号
	cout<<"文件信息如下："<0)
	{
		return (num1 - num2);
	}
	else
		return (num2 - num1);
}

void initial()
{
	for (int i=0;i disTemp[j])
			{
				pointMin = j;   //指向最小的位置
			}
		}
		VisitOrder[i] = TrackOrder[pointMin];  //给访问序列赋值
		MoveDistance[i] = getPositive(TrackOrder[pointMin],CurrentTrack);  //计算每次的移动距离
		totalDistance += MoveDistance[i];   //累计移动距离
		CurrentTrack = TrackOrder[pointMin];   //改变当前的磁道号
		isVisited[pointMin] = true;  //将当前的磁道号设置为已访问

	}

	AverageDistance = totalDistance*1.0/(TrackNum);
	display();
	cout<<"******* SSTF算法结束     ***********************************"<=0;i--)
		{
			VisitOrder[count] = SortTrackOrder[i];
			MoveDistance[count] = getPositive(VisitOrder[count],currentTrack);
			currentTrack = VisitOrder[count];
			count++;
		}
	}//if
	else if (direction == 1)
	{
		cout<<"            向磁道减小的方向访问"<=0;i--)
		{
			VisitOrder[count] = SortTrackOrder[i];
			MoveDistance[count] = getPositive(VisitOrder[count],currentTrack);
			currentTrack = VisitOrder[count];
			count++;
		}

		for (i = point;i>direction;

	initial();
	int TrackOrderIndex[MaxNumber],SortTrackOrder[MaxNumber];
	int i,j,temp,tempIndex;
	for (i = 0;i0;i--)
	{
		for (j = 0;j=SortTrackOrder[j+1])
			{
				//更新排序后的磁道号
				temp = SortTrackOrder[j];
				SortTrackOrder[j] = SortTrackOrder[j+1];
				SortTrackOrder[j+1] = temp;

				//更新排序后的磁道号索引值
				tempIndex = TrackOrderIndex[j];
				TrackOrderIndex[j] = TrackOrderIndex[j+1];
				TrackOrderIndex[j+1] = tempIndex;

			}//if
		}//for
	}//for   获得排序后的磁道号以及对应的原来的索引值

	int point = 0;
	while(StartTrack>=SortTrackOrder[point])
	{
		point++;
	}  //找到当前对应的：既在当前磁道之外，又是距离最近的磁道号索引值point

	int count = 0; 
	int currentTrack = StartTrack;
	if (direction == 0)  //向磁道增加的方向访问
	{
		cout<<"            向磁道增加的方向访问"<