操作系统-磁盘调度算法

实验七 磁盘调度算法

磁盘调度在多道程序设计的计算机系统中，各个进程可能会不断提出不同的对磁盘进行读/写操作的请求。由于有时候这些进程的发送请求的速度比磁盘响应的还要快，因此我们有必要为每个磁盘设备建立一个等待队列，常用的磁盘调度算法有以下四种：
  先来先服务算法（FCFS ），
  最短寻道时间优先算法（SSTF ），
  扫描算法（SCAN ），
  循环扫描算法（CSCAN ）

例:  假定某磁盘共有200个柱面，编号为 0-199，如果在为访问 143 号柱面的请求者服务后，当前正在为访问 125 号柱面的请求服务，同时有若干请求者在等待服务，它们每次要访问的柱面号为 86 ，147 ，91 ，177 ，94 ，150 ，102， 175 ，130

1 、先来先服务算法（FCFS ）First Come First Service
这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
先来先服务 （125）86.147.91.177.94.150.102.175.130
2 、最短寻道时间优先算法（SSTF ） Shortest Seek Time First
该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。
最短寻道时间优先（125）130.147.150.175.177.102.94.91.86
3 、扫描算法（SCAN ）电梯调度
扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道。
电梯调度（125）102.94.91.86.130.147.150.175.177
4 、循环扫描算法（CSCAN ）
循环扫描算法是对扫描算法的改进。如果对磁道的访问请求是均匀分布的，当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少。这是由于这些磁道刚被处理，而磁盘另一端的请求密度相当高，且这些访问请求等待的时间较长，为了解决这种情况，循环扫描算法规定磁头单向移动。例如，只自里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的欲访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描。
循环扫描 （125）130.147.150.175.177.86.91.94.102
5 、平均寻道距离
假设当前磁头在 67 号，要求访问的磁道号顺序为 98,25,63,97,56,51,55,55,6
FIFO 算法的服务序列是：98,25,63,97,56,51,55,55,6
磁头移动的总距离 distance =
(98-67)+(98-25)+(63-25)+(97-63)+(97-56)+(56-51)+(55-51)+(55-55)+(55-6)
SSTF 算法的服务序列是: 63,56,55,55,51,25,6,97,98
磁头移动的总距离 distance =
(67-63)+(63-56)+(56-55)+(55-55)+(55-51)+(51-25)+(25-6)+(97-6)+(98-97)
SCAN 算法的服务序列是：63,56,55,55,51,25,6,97,98
磁头移动的总距离 distance =
(67-63)+(63-56)+(56-55)+(55-55)+(55-51)+(51-25)+(25-6)+(97-6)+(98-97)
我发现这里例子举的不好，SSTF 和 SCAN 算法的服务序列竟是一样的，尴
尬！
CSCAN 算法的服务序列是：63,56,55,55,51,25,6,98,97
磁头移动的总距离 distance =
(67-63)+(63-56)+(56-55)+(55-55)+(55-51)+(51-25)+(25-6)+(100-98)+(98-97)

6、参考代码

#include <iostream> 
#include <vector> 
#include <fstream> 
using namespace std; 
typedef vector<int> vInt; //向量，动态数组
struct OrderItem 
{ 
    int Data; 
    bool IsVisited; 
}; 
typedef vector<OrderItem> Order; 
Order InitOrder; 
vInt TrackOrder; 
vInt MoveDistance; 
double AverageDistance;

void InitDate(int &num);
inline void Init(int disk); //内联函数（内联函数的代码会在任何调用它的地方展开）
void FCFS(int disk); 
void SSTF(int disk); 
void SCAN(int disk); 
void CSCAN(int disk); 
void Show(int disk);

int main() 
{ 
    int num; 
    InitDate(num); 
    char cmd; 
    do 
    { 
        cout<<"选择算法:\n"<<"1-FCFS,2-SSTF,3-SCAN,4-CSCAN:\t"; 
        int type;cin>>type; 
        switch(type) 
        {   
case 1:FCFS(num);break; 
            case 2:SSTF(num);break; 
            case 3:SCAN(num);break; 
            case 4:CSCAN(num);break; 
        } 
        Show(num); 
        cout<<"Continue? y or n?\t"; 
        cin>>cmd; 
    }while(cmd!='n'); 
    return 0; 
}

inline void Init(int disk) 
{ 
    TrackOrder.clear(); 
    MoveDistance.clear(); 
    for(int i = 0; i < disk; i++) 
    { 
        InitOrder[i].IsVisited = false; 
    } 
}

void InitDate(int &num) 
{ 
    //ifstream cin("data.txt"); 
    cout<<"输入磁道个数"; 
    cin>>num; 
    cout<<"磁盘访问序列"; 
for(int i=0; i<num; i++)
{ 
        OrderItem oi; 
        cin>>oi.Data; 
        oi.IsVisited = false; 
        InitOrder.push_back(oi); 
    } 
}

void FCFS(int disk) 
{ 
    cout<<"输入开始磁盘号"; 
    int start;cin>>start; 
    cout<<"FCFS:"<<endl; 
    int p = start; 
    Init(disk); 
    for(int i = 0 ; i < disk; i++ ) 
    { 
        TrackOrder.push_back(InitOrder[i].Data); 
        int t = InitOrder[i].Data-p; 
        MoveDistance.push_back(t>0?t:-t); 
        InitOrder[i].IsVisited = true; 
        p = InitOrder[i].Data; 
     } 
}

void SSTF(int disk) 
{ 
    cout<<"输入开始磁盘号"; 
    int start;cin>>start; 
    cout<<"SSTF:"<<endl; 
    Init(disk); 
    int curp=0,dif=0; 
    int p = start; 
    for(int i = 0; i < disk; i++) 
    { 
        int temp = 0; 
        for(int j = 0 ; j < disk; j++) 
        { 
            if(InitOrder[j].IsVisited == false) 
            { 
                temp = p-InitOrder[j].Data>0? 
                p-InitOrder[j].Data:-(p-InitOrder[j].Data); 
                if(dif==0||temp<dif) 
                { 
                    dif = temp; 
                    curp = j;
} 
            } 
        } 
        InitOrder[curp].IsVisited = true; 
        TrackOrder.push_back(InitOrder[curp].Data); 
        MoveDistance.push_back(dif); 
        p = InitOrder[curp].Data; 
        dif = 0; 
     } 
}

void SCAN(int disk) 
{ 
    cout<<"输入开始磁盘号"; 
    int start;cin>>start; 
    cout<<"选择访问方向:0-磁道号递增1-磁道号递减\t"; 
    int dir; cin>>dir; 
    cout<<"SSTF:"<<endl; 
    Init(disk); 
    int curp=0,dif=0,cdir=dir,max=InitOrder[0].Data,min=max; 
    for(int i =1; i<disk;i++) 
    { 
        if(max<InitOrder[i].Data) 
            max = InitOrder[i].Data; 
        if(min>InitOrder[i].Data) 
            min = InitOrder[i].Data; 
    } 
    int p = start; 
    for(int k = 0; k< disk; k++) 
    { 
        int temp = 0; 
        for(int j = 0 ; j < disk; j++) 
        { 
            
if(cdir==0&&p>InitOrder[j].Data||cdir==1&&p<InitOrder[j].Data) 
                continue; 
            if(InitOrder[j].IsVisited == false) 
            { 
                temp = p-InitOrder[j].Data>0? 
                p-InitOrder[j].Data:-(p-InitOrder[j].Data); 
                if(dif==0||temp<dif) 
                { 
                    dif = temp; 
                    curp = j; 
                }
} 
        } 
        if(dir==0&&InitOrder[curp].Data==max)cdir = 1; 
        if(dir==1&&InitOrder[curp].Data==min)cdir = 0; 
        InitOrder[curp].IsVisited = true; 
        TrackOrder.push_back(InitOrder[curp].Data); 
        MoveDistance.push_back(dif); 
        p = InitOrder[curp].Data; 
        dif = 0; 
    } 
}

void CSCAN(int disk) 
{ 
    cout<<"输入开始磁盘号"; 
    int start;cin>>start; 
    cout<<"选择访问方向:0-磁道号递增1-磁道号递减\t"; 
    int dir; cin>>dir; 
    cout<<"CSSTF:"<<endl; 
    Init(disk); 
    int curp=0,dif=-1,max=InitOrder[0].Data,min=max,mmin=0,mmax=0; 
    for(int i =1; i<disk;i++)//找到磁道序列中最小和最大的磁道号及下标 
    { 
        if(max<InitOrder[i].Data) 
        { 
            max = InitOrder[i].Data; 
            mmax = i; 
        } 
        if(min>InitOrder[i].Data) 
        { 
            min = InitOrder[i].Data; 
            mmin=i; 
        } 
    } 
    int p = start;//p表示上一个访问的磁道号 
    for(int k = 0; k < disk; k++) 
    { 
        int temp = 0; 
        for(int j = 0 ; j < disk; j++)//查找下一个要访问的磁道 
        { 
            
if(dir==0&&p>InitOrder[j].Data||dir==1&&p<InitOrder[j].Data) 
                continue; 
            if(InitOrder[j].IsVisited == false)//dir方向且未被访问的项 
            {
temp = p-InitOrder[j].Data>0? 
                (p-InitOrder[j].Data):(InitOrder[j].Data-p); 
                if(dif==-1||temp<dif) 
                { 
                    dif = temp; 
                    curp = j;//找到下一个被访问的磁道 
                } 
            } 
        } 
        InitOrder[curp].IsVisited = true;//访问 
        TrackOrder.push_back(InitOrder[curp].Data); 
        MoveDistance.push_back(dif); 
        p  = InitOrder[curp].Data; 
        //达到极限点 
        
if(dir==0&&InitOrder[curp].Data==max&&InitOrder[mmin].IsVisited==false) 
        { 
            //从最小项开始 
            TrackOrder.push_back(min); 
            InitOrder[mmin].IsVisited = true; 
            MoveDistance.push_back(p-TrackOrder[mmin]>=0? 
                p-TrackOrder[mmin]:TrackOrder[mmin]-p); 
            curp = mmin; 
        } 
        
if(dir==1&&InitOrder[curp].Data==min&&InitOrder[mmax].IsVisited==false) 
        { 
            TrackOrder.push_back(max); 
            InitOrder[mmax].IsVisited = true; 
            MoveDistance.push_back(p-TrackOrder[mmin]>=0? 
                p-TrackOrder[mmin]:TrackOrder[mmin]-p); 
            curp = mmax; 
        } 
        p = InitOrder[curp].Data; 
        dif = -1; 
    } 
}

void Show(int disk) 
{ 
    cout<<"被访问的下一个磁道号\t"<<"移动距离"<<endl; 
    int sum=0; 
    for(int i = 0 ; i <disk; i++) 
    { 
        sum+=MoveDistance[i];
cout<<"\t"<<TrackOrder[i]<<"\t\t  "<<MoveDistance[i]<<endl; 
    } 
    AverageDistance = (double)sum/disk; 
    cout<<"平均寻道长度:"<<AverageDistance<<endl; 
}