磁盘调度

#include <iostream> 
#include <time.h> 
#include <vector>      //c++标准模板库，相当于一个容器，存放任意类型动态数组，能增加和压缩数据
#include <math.h> 
#include <stdlib.h> 
#include <algorithm>   //功能强大的算法库
#include <cstring>     //字符串函数
#include <windows.h>   //包含了其他windows头文件，比如：数据类型定义、内核函数、用户及二面函数、图形设备接口函数等
#include <fstream>     //文件流
using namespace std; 
 
int position = 0;      //当前磁道位置 
int dis = 0;  //记录磁道走过的长度
double average_distance = 0; 
 
/*随机生成序列函数*/
void request(vector<int>&m_vec,ofstream &outfile){ 
    cout<<"随机生成磁盘序列："<<endl; 
    int n = 0; 
    srand(time(NULL));     /*添加随机数种子的函数，time(null)返回值作为srand函数的参数，
 意思是以现在的系统时间作为随机数的种子来产生随机数！至于NULL这个参数。
 只有设置成NULL才能获得系统的时间！*/ 
    n = rand() % 20 + 1; //rand（）是一个产生随机数的函数，与srand一起用，rand()%20+1：n的取值为1-20
    int temp = 0; 
    for(int i=0;i<n;i++){ 
        temp = rand() % 100; //temp的取值为0-100
        m_vec.push_back(temp); // 将随机生成的temp数输入到vector里面，再从里面读出数据
        cout<<temp<<" "; 
        outfile<<temp<<endl; //outfile输出数据文件流
    } 
    cout<<endl; 
    position = rand() % 100; //当前磁道为随机生成的0-100之间的数
 
    cout<<"当前磁道："<<position<<endl; 
} 
 
//计算平均距离函数
void compute_dis(vector<int>m_vec,int &dis,double &average_distance){ 
    average_distance = (double)dis / (double)m_vec.size(); 
} 
 
//先来先服务算法*************************************************
void FIFO(vector<int>m_vec,int position){     
    dis = 0; 
    average_distance = 0; 
    for(vector<int>::iterator it=m_vec.begin();it!=m_vec.end();it++){ //使用迭代器访问元素：iterator begin():返回向量头指针，指向第一个元素
                   //iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置
        dis += abs(position-*it);//abs是绝对值，dis记录此时走过的长度
        Sleep(500);//休眠，500毫秒为它的参数，输出时此处停顿半秒 
        cout<<"->"<<*it; 
        position = *it; //磁头位置随着走过的磁道变化而变化
    } 
    compute_dis(m_vec,dis,average_distance); //调用计算平均距离函数
} 
 
//最短寻道时间算法 **************************************************
void SSTF(vector<int>m_vec,int position){   
    dis = 0; 
    average_distance = 0; 
    sort(m_vec.begin(),m_vec.end());    //从小到大排序，因为sstf寻址只能一个方向扫描
    int i = 0; 
    for(vector<int>::iterator it=m_vec.begin();it!=m_vec.end();it++){ 
        if(position >= *it) //找到position所在磁道，取出来的序列是否大于当前磁道，先找到全部小于当前磁道序列
            i++; 
    } 
    int count = 0; 
    int left = i-1; //i为下标
    int right = i; 
    while(count<m_vec.size()){  //选择扫描方向，如果
        if((left >=0 && abs(m_vec[right]-position) > abs(m_vec[left]-position)) || right>=m_vec.size()){  //如果左边的数减去当前磁道小于右边，则先走左边
            dis += abs(m_vec[left]-position); 
            Sleep(500); 
            cout<<"->"<<m_vec[left]; 
            position = m_vec[left]; 
            left--; 
        } 
        else{ //选择从右边开始扫描
            dis += abs(m_vec[right]-position); 
            Sleep(500); 
            cout<<"->"<<m_vec[right]; 
            position = m_vec[right]; 
            right++; 
        } 
        count++; 
    } 
    compute_dis(m_vec,dis,average_distance); 
} 
 
//电梯调度算法*******************************************************
void SCAN(vector<int>m_vec,int position){   
    dis = 0; 
    average_distance = 0; 
    sort(m_vec.begin(),m_vec.end());    //从小到大排序 
    int i = 0; 
    for(vector<int>::iterator it=m_vec.begin();it!=m_vec.end();it++){ 
        if(position >= *it) 
            i++;      //找到position所在的磁道 
    } 
    int left = i - 1;   //先从外到内扫描 
    int right = i; 
    while(left >= 0){ 
        dis += abs(position - m_vec[left]); 
        Sleep(500); 
        cout<<"->"<<m_vec[left]; 
        position = m_vec[left]; 
        left --;//当左边的序列走完之后跳出这个while循环 
    } 
    while(right < m_vec.size()){ 
        dis += abs(position - m_vec[right]); 
        Sleep(500); 
        cout<<"->"<<m_vec[right]; 
        position = m_vec[right]; 
        right ++; 
    } 
    compute_dis(m_vec,dis,average_distance); 
} 
 
void CSCAN(vector<int>m_vec,int position){   //循环扫描算法 
    dis = 0; 
    average_distance = 0; 
    sort(m_vec.begin(),m_vec.end());    //从小到大排序 
    int i = 0; 
    for(vector<int>::iterator it=m_vec.begin();it!=m_vec.end();it++){ 
        if(position >= *it) 
            i++;      //找到position所在的磁道 
    } 
    int left = i - 1;   //先从外到内扫描 
    int right = i; 
    while(left >= 0){ 
        dis += abs(position - m_vec[left]); 
        Sleep(500); 
        cout<<"->"<<m_vec[left]; 
        position = m_vec[left]; 
        left --; 
    } 
    position = 100;     //立即到最外侧的磁道 
    int len = m_vec.size()-1; 
    while(len >= right){ //从最外侧在是扫描一遍，像梳头发一样
        dis += abs(position - m_vec[len]); 
        Sleep(500); 
        cout<<"->"<<m_vec[len]; 
        position = m_vec[len]; 
        len --; 
    } 
    compute_dis(m_vec,dis,average_distance); 
} 
 

void print(){ 
    cout<<endl<<endl; 
    cout<<"经计算，磁头移动的总距离为:"<<dis<<endl; 
    cout<<"磁头平均移动距离:"<<average_distance<<endl; 
    cout<<endl<<endl; 
} 
 
int choose_algorithm(vector<int>m_vec){ 
    cout<<endl<<endl; 
    cout<<"本实验可用的调度算法有以下5种："<<endl; 
    cout<<"1.FIFO  2.SSTF  3.SCAN  4.CSCAN   5.结束本序列的调度  6.结束程序"<<endl; 
    int choice = 0; 
    cout<<"选择："<<endl; 
    cin>>choice; 
    cout<<endl; 
    while(choice!=5 && choice!=6){ 
        cout<<"磁盘请求的服务状况："<<endl; 
        cout<<position; 
        switch(choice){ 
            case 1: 
                FIFO(m_vec,position);break; 
            case 2: 
                SSTF(m_vec,position);break; 
            case 3: 
                SCAN(m_vec,position);break; 
            case 4: 
                CSCAN(m_vec,position);break; 
         /*   case 5: 
                FSCAN(m_vec,position);break; */
            default: 
                cout<<"******非法输入！******"<<endl<<endl;break;  
        }  
        if(choice<=6 && choice>=1)  
            print(); 
        cout<<"选择："<<endl; 
        cin>>choice; 
    } 
    if(choice == 6) 
        return 0; 
    else 
        cout<<endl<<endl; 
    return 1; 
} 
 
int main(){ 
    cout<<"---------------磁盘调度算法模拟实验-----------------"<<endl; 
    ofstream outfile; 
    outfile.open("data.txt"); 
    while(1){ 
        vector<int> vec; 
        while(!vec.empty()) 
            vec.pop_back(); 
        request(vec,outfile);         //请求服务序列  
        int flag = choose_algorithm(vec); 
        if(flag == 0) 
            break; 
    }  
    outfile.close(); 
    return 0; 
}