操作系统实验：实验七 磁盘调度算法的模拟与实现

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

1、实验目的

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

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

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

2、实验基本知识及原理

（1）磁盘数据的组织

磁盘上每一条物理记录都有唯一的地址，该地址包括三个部分：磁头号（盘面号）、柱面号（磁

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

（2）磁盘访问时间的计算方式**

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

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

迟时间和传输时间。

（3）磁盘调度算法

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

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

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

行调度。

SCAN（电梯算法）：要求磁头臂先沿一个方向移动，并在途中满足所有未完成的请求，直到它

到达这个方向上的最后一个磁道，或者在这个方向上没有别的请求为止，后一种改进有时候称作

LOOK 策略。然后倒转服务方向，沿相反方向扫描，同样按顺序完成所有请求。

C-SCAN（循环扫描）算法：在磁盘调度时，把扫描限定在一个方向，当沿某个方向访问到最

后一个磁道时，磁头臂返回到磁盘的另一端，并再次开始扫描。

3、实验内容

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

（1）测试数据：参见教材 P305，测试结果参见表 11.2。

（2）编程实现 FIFO、SSTF、SCAN、C-SCAN 算法。

代码：磁道实体类

public class CiDao {
    private int[] target;//寻道目标
    private int FistNum;//磁头臂所在位置

    public int[] getTarget() {
        return target;
    }

    public void setTarget(int[] target) {
        this.target = target;
    }

    public int getFistNum() {
        return FistNum;
    }

    public void setFistNum(int fistNum) {
        FistNum = fistNum;
    }
}

代码：FIFO

public class FIFO {
    int sum;//磁臂移动道数
    public int Do(int[] target,int FistNum){
        System.out.print("磁头的移动轨迹：\n"+FistNum);
        for (int i = 0; i < target.length; i++) {
            int temp =target[i];
            System.out.print(" ,"+temp);
            int p=target[i]-FistNum;
            if(p<0){
                p=-p;
            }
            FistNum =temp;
            sum+=p;
        }
        System.out.println("");
        return sum;

    }

}

代码：SSTF

package com.hao.SSD;

public class SSTF {
    int close;//最近的目标
    int sum;//磁臂移动总道数

    public int Do(int[] target, int FistNum) {
        System.out.print("磁头的移动轨迹：\n" + FistNum);
        int[] aim = target;//设置寻道目标aim
        for (int i = 0; i < target.length; i++) {
            sum += shortest(aim, FistNum);//获取扫描当前最近目标移动的道数
            aim = Newtarget(aim);//获取新的寻道目标
        }
        System.out.println("");
        return sum;
    }

    public int shortest(int[] target, int FistNum) {//获取当前磁头位置最近的目标位置以及扫描所需要的移动的道数
        int min = 300;
        for (int i = 0; i < target.length; i++) {
            int p = target[i] - FistNum;
            if (p < 0) {
                p = -p;
            }
            if (p < min) {
                min = p;
                close = i;
            }

        }
        System.out.print(", " + target[close]);
        return min;
    }//获取当前最短道数

    public int[] Newtarget(int[] target) {//去除已寻目标生成新的寻道目标
        int[] aim = new int[target.length - 1];
        for (int i = 0, j = 0; i < target.length; i++) {

            if (i != close) {
                aim[j] = target[i];
                j++;
            }
        }
        return aim;
    }//获取新的目标集合

}

代码：SCAN

package com.hao.SSD;

import java.util.Arrays;

import static java.util.Arrays.sort;

//初始方向向右的SCAN
public class SCAN {
    int sum;//总道数

    public int Do(int[] target, int FistNum) {
        System.out.print("磁头的移动轨迹：\n" + FistNum);
        Show(target, FistNum);//输出磁头移动的轨迹
        System.out.println("");
        int max = Right(target, FistNum);//获取向右边扫描移动的总道数
        sum += max;
        sum += Reverse(target, FistNum, max);//获取磁头反转扫描移动的总道数


        return sum;
    }

    public void Show(int[] target, int FistNum) {
        sort(target);
        for (int i = 0; i < target.length; i++) {
            if (target[i] > FistNum) {
                System.out.print(" ," + target[i]);
            }
        }
        for (int i = target.length - 1; i >= 0; i--) {
            if (target[i] < FistNum) {
                System.out.print(" ," + target[i]);
            }

        }


    }

    public int Right(int[] target, int FistNum) {
        int max = FistNum;
        for (int i = FistNum; i < 300; i++) {
            for (int k : target) {
                if (i == k) {
                    if (max < k) {
                        max = k;
                    }
                }
            }


        }
        return max;

    }

    public int Reverse(int[] target, int FistNum, int max) {
        int min = FistNum;
        int flag = 0;
        for (int i = FistNum; i >= 0; i--) {
            for (int k : target) {
                if (k == i) {
                    flag = 1;
                    if (min > k) {
                        min = k;
                    }
                }

            }


        }
        if (flag != 0) {
            return (max - min);
        } else {
            return 0;
        }
    }
}

代码：C-SCAN

import static java.util.Arrays.sort;

public class CSCAN {
    int sum;//总道数

    public int Do(int[] target, int FistNum) {
        System.out.print("磁头的移动轨迹：\n" + FistNum);
        Show(target, FistNum);//输出磁头移动的轨迹
        System.out.println("");
        int max = Right(target, FistNum);//获取向右边扫描未返回另一端时扫描移动的总道数
        sum += max;
        sum += Reverse(target, FistNum, max);//获取磁头返回另一端后扫描移动的总道数
        return sum;
    }

    public void Show(int[] target, int FistNum) {
        sort(target);
        for (int i = 0; i < target.length; i++) {
            if (target[i] > FistNum) {
                System.out.print(" ," + target[i]);
            }
        }
        for (int i = 0; i < target.length; i++) {
            if (target[i] < FistNum) {
                System.out.print(" ," + target[i]);
            }
        }


    }

    public int Right(int[] target, int FistNum) {
        int max = FistNum;
        for (int i = FistNum; i < 300; i++) {
            for (int k : target) {
                if (i == k) {
                    if (max < k) {
                        max = k;
                    }
                }
            }


        }
        return max;

    }

    public int Reverse(int[] target, int FistNum, int max) {
        int min = FistNum;

        int flag = 0;
        for (int i = FistNum; i >= 0; i--) {
            for (int k : target) {
                if (k == i) {
                    flag = 1;
                    if (min > k) {
                        min = k;
                    }
                }

            }


        }
        int Max = min;
        for (int i = FistNum; i >= 0; i--) {
            for (int k : target) {
                if (k == i) {
                    if (Max < k) {
                        Max = k;
                    }
                }

            }


        }
        if (flag != 0) {

            return (max - min + Max - min);
        } else {
            return 0;
        }
    }
}

代码： 测试类

public class main {
    public static void main(String[] args) {
        CiDao C = new CiDao();
        C.setFistNum(100);
        int[] target = {45, 23, 67, 2, 9, 89, 165, 49, 80, 77, 255, 184, 196, 145};
        C.setTarget(target);
        int sum = 0;
        FIFO fifo = new FIFO();
        SCAN scan = new SCAN();
        SSTF sstf = new SSTF();
        CSCAN cscan = new CSCAN();
        System.out.println("----FIFO----");
        sum = fifo.Do(C.getTarget(), C.getFistNum());
        System.out.println("磁头移动的总道数为:" + sum + " ;平均寻道数为：" + (1.0 * sum / target.length));
        System.out.println("----SSTF----");
        sum = sstf.Do(C.getTarget(), C.getFistNum());
        System.out.println("磁头移动的总道数为:" + sum + " ;平均寻道数为：" + (1.0 * sum / target.length));
        System.out.println("----SCAN----");
        sum = scan.Do(C.getTarget(), C.getFistNum());
        System.out.println("磁头移动的总道数为:" + sum + " ;平均寻道数为：" + (1.0 * sum / target.length));
        System.out.println("----CSCAN----");
        sum = cscan.Do(C.getTarget(), C.getFistNum());
        System.out.println("磁头移动的总道数为:" + sum + " ;平均寻道数为：" + (1.0 * sum / target.length));


    }
}

测试结果