精华内容
下载资源
问答
  • 磁盘调度算法sstf算法 辅助存储和磁盘调度算法 (Secondary Storage and Disk Scheduling Algorithms) Secondary storage devices are those devices whose memory is non volatile, meaning, the stored data will ...

    磁盘调度算法sstf算法

    Secondary storage devices are those devices whose memory is non volatile, meaning, the stored data will be intact even if the system is turned off. Here are a few things worth noting about secondary storage.

    辅助存储设备是那些内存是非易失性的设备,这意味着即使关闭系统电源,存储的数据也将保持完整。 以下是有关辅助存储的一些注意事项。

    • Secondary storage is also called auxiliary storage.

      辅助存储也称为辅助存储。

    • Secondary storage is less expensive when compared to primary memory like RAMs.

      与主存储器(如RAM)相比,二级存储的价格便宜。

    • The speed of the secondary storage is also lesser than that of primary storage.

      辅助存储的速度也小于主存储的速度。

    • Hence, the data which is less frequently accessed is kept in the secondary storage.

      因此,较少访问的数据被保存在辅助存储器中。

    • A few examples are magnetic disks, magnetic tapes, removable thumb drives etc.

      一些示例是磁盘,磁带,可移动拇指驱动器等。

    磁盘结构 (Magnetic Disk Structure)

    In modern computers, most of the secondary storage is in the form of magnetic disks. Hence, knowing the structure of a magnetic disk is necessary to understand how the data in the disk is accessed by the computer.

    在现代计算机中,大多数辅助存储都是磁盘形式的。 因此,必须了解磁盘的结构才能理解计算机如何访问磁盘中的数据。

    Magnetic Disk

    Structure of a magnetic disk

    磁盘的结构

    A magnetic disk contains several platters. Each platter is divided into circular shaped tracks. The length of the tracks near the centre is less than the length of the tracks farther from the centre. Each track is further divided into sectors, as shown in the figure.

    磁盘包含多个磁盘 。 每个盘子分成圆形的轨道 。 靠近中心的轨道的长度小于远离中心的轨道的长度。 如图所示,每个磁道进一步划分为多个扇区

    Tracks of the same distance from centre form a cylinder. A read-write head is used to read data from a sector of the magnetic disk.

    距中心相同距离的轨道形成一个圆柱体。 读写头用于从磁盘的扇区读取数据。

    The speed of the disk is measured as two parts:

    磁盘的速度分为两个部分:

    • Transfer rate: This is the rate at which the data moves from disk to the computer.

      传输速率:这是数据从磁盘移动到计算机的速率。

    • Random access time: It is the sum of the seek time and rotational latency.

      随机访问时间:它是寻道时间和旋转等待时间的总和。

    Seek time is the time taken by the arm to move to the required track. Rotational latency is defined as the time taken by the arm to reach the required sector in the track.

    搜索时间是手臂移动到所需轨道所花费的时间。 旋转等待时间定义为手臂到达轨道中所需扇区所花费的时间。

    Even though the disk is arranged as sectors and tracks physically, the data is logically arranged and addressed as an array of blocks of fixed size. The size of a block can be 512 or 1024 bytes. Each logical block is mapped with a sector on the disk, sequentially. In this way, each sector in the disk will have a logical address.

    即使磁盘按扇区排列并在物理上进行跟踪,但数据在逻辑上按固定大小的块阵列排列和寻址。 块的大小可以是5121024字节。 每个逻辑块依次与磁盘上的一个扇区映射。 这样,磁盘中的每个扇区都会有一个逻辑地址。

    磁盘调度算法 (Disk Scheduling Algorithms)

    On a typical multiprogramming system, there will usually be multiple disk access requests at any point of time. So those requests must be scheduled to achieve good efficiency. Disk scheduling is similar to process scheduling. Some of the disk scheduling algorithms are described below.

    在典型的多程序系统上,通常在任何时间点都会有多个磁盘访问请求。 因此,必须安排这些请求以实现良好的效率。 磁盘调度类似于进程调度。 下面描述了一些磁盘调度算法。

    先到先得 (First Come First Serve)

    This algorithm performs requests in the same order asked by the system. Let's take an example where the queue has the following requests with cylinder numbers as follows:

    该算法以系统要求的相同顺序执行请求。 让我们以一个示例为例,其中队列具有以下带有柱面编号的请求,如下所示:

    98, 183, 37, 122, 14, 124, 65, 67

    98、183、37、122、14、124、65、67

    Assume the head is initially at cylinder 56. The head moves in the given order in the queue i.e., 56→98→183→...→67.

    假设头部最初在汽缸56处 。 磁头在队列中以给定的顺序移动,即56→98→183→...→67

    First Come First Serve

    最短搜寻时间优先(SSTF) (Shortest Seek Time First (SSTF))

    Here the position which is closest to the current head position is chosen first. Consider the previous example where disk queue looks like,

    在此首先选择最接近当前磁头位置的位置。 考虑前面的示例,其中磁盘队列如下所示:

    98, 183, 37, 122, 14, 124, 65, 67

    98、183、37、122、14、124、65、67

    Assume the head is initially at cylinder 56. The next closest cylinder to 56 is 65, and then the next nearest one is 67, then 37, 14, so on.

    假设头部最初在汽缸56处 。 下一个最接近的气缸5665,然后下一个最近的一个是67,然后37,14,等等。

    Shortest Seek Time First

    扫描算法 (SCAN algorithm)

    This algorithm is also called the elevator algorithm because of it's behavior. Here, first the head moves in a direction (say backward) and covers all the requests in the path. Then it moves in the opposite direction and covers the remaining requests in the path. This behavior is similar to that of an elevator. Let's take the previous example,

    由于其行为,该算法也称为提升算法。 在这里,首先头部朝一个方向移动(例如向后移动)并覆盖路径中的所有请求。 然后,它沿相反的方向移动,并覆盖路径中的其余请求。 此行为类似于电梯的行为。 让我们来看前面的例子,

    98, 183, 37, 122, 14, 124, 65, 67

    98、183、37、122、14、124、65、67

    Assume the head is initially at cylinder 56. The head moves in backward direction and accesses 37 and 14. Then it goes in the opposite direction and accesses the cylinders as they come in the path.

    假设头部最初在汽缸56处 。 头部向后移动并进入3714 。 然后,它沿着相反的方向前进,并在圆柱体进入路径时进入圆柱体。

    SCAN algorithm

    翻译自: https://www.studytonight.com/operating-system/secondary-storage

    磁盘调度算法sstf算法

    展开全文
  • 磁盘调度算法

    2019-12-07 16:38:27
    磁盘调度算法 本文内容 用c++写了一个简单的控制台程序用来演示几种调度算法的磁头移动过程, 包括: 先来先服务法(First-Come, First-Served,FCFS)。 最短寻道时间优先法(Shortest Seek Time First, SSTF...

    磁盘调度算法

    本文内容

    用c++写了一个简单的控制台程序用来演示几种调度算法的磁头移动过程, 包括:

    1. 先来先服务法(First-Come, First-Served,FCFS)。
    2. 最短寻道时间优先法(Shortest Seek Time First, SSTF)。
    3. 电梯法。

    知识点

    先来先服务算法(FCFS )First Come First Service

    特点:一种简单的磁盘调度算法。根据进程请求访问磁盘的先后次序进行调度。
    优点:公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。
    缺点:由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,将降低设备服务的吞吐量,致使平均寻道时间可能较长。

    最短寻道时间优先算法(SSTF ) Shortest Seek Time First

    特点: 先访问当前磁头所在的磁道距离最近的盘块,以使每次的寻道时间最短。
    **优点:**可以得到比较好的吞吐量。
    **缺点:**不能保证平均寻道时间最短,且对用户的服务请求的响应机会不是均等的,因而导致响应时间的变化幅度很大。

    电梯调度

    特点:优先考虑磁头的当前移动方向。
    有点:可避免了饥饿现象的出现,基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点。
    缺点:由于是摆动式的扫描方法,两侧磁道被访问的频率仍低于中间磁道。


    程序运行效果

    FCFS:
    在这里插入图片描述
    SSTF:
    在这里插入图片描述
    电梯算法:
    在这里插入图片描述


    代码

    #pragma once
    #include<string.h>
    #include<iostream>
    #include<string>
    #include<vector>
    #include<set>
    using namespace std;
    #define LAB(a,b) (a>b?a-b:b-a)
    #define MIN(a, b) (a<b?b:a)
    typedef int uint;
    typedef vector<uint> intVec;
    
    
    void printChar(uint n, char c = ' '){
    	for (uint i = 0; i < n; i++) printf("%c", c);
    	return;
    }
    
    //printf the movement of the disk and return distant need to move
    uint printTrack(uint nowAt, uint target){
    	uint distant = 0;
    
    	if (nowAt == target) {   //dont't need to move
    		printChar(nowAt);
    		printf("\n");
    		printChar(target);
    		printf("| %d", target);
    		printf("\n");
    	}
    
    	if (nowAt > target){		//move to left
    		distant = LAB(nowAt, target);
    		printChar(nowAt > distant ? nowAt - distant : 0);
    		printChar(distant, '-');
    		printf("\n");
    		printChar(target);
    		printf("| %d\n", target);
    	}
    
    	if (nowAt < target){	//move to right
    		uint distant = LAB(nowAt, target);
    		printChar(nowAt);
    		printChar(distant, '-');
    		printf("\n");
    		printChar(target);
    		printf("| %d\n", target);
    	}
    
    	return distant;
    }
    
    //first come first server
    void FCFS(intVec* vec, uint start_p = 0, uint max_track = 1000){
    	uint totalMove = 0;
    	uint nowAt = start_p;
    	printf("First come first serve:  start_p: %d   target_number:%d \n", start_p, vec->size());
    
    	for (uint i = 0; i < vec->size(); i++){
    		uint target = vec->at(i);
    		if (target < 0 || target >= max_track){
    			printf("Input block indx illeagl!!!\n");
    			exit(1);
    		}
    		totalMove += printTrack(nowAt, target);
    		nowAt = target;
    	}
    	printf("\n=================== Total move distant %d ===================\n\n\n", totalMove);
    	return;
    }
    
    //shortest seek time first
    void SSTF(intVec* vec, uint start_p = 0, uint max_track = 1000){
    	uint totalMove = 0;
    	uint nowAt = start_p;
    	set<uint> isRead;		//to record the index of block that have been read
    	printf("Shortest seek time first:   start_point: %d     target_number: %d \n", start_p, vec->size());
    
    	for (int i = 0; i < vec->size(); i++){
    		uint target = vec->at(i);
    		if (target<0 || target>max_track){
    			printf("Input block indx illeagl!!!\n");
    			exit(1);
    		}
    		uint shortNum = 1 << 30;
    		uint shortIdx = 0;
    		//find the shortest move and index
    		for (uint j = 0; j < vec->size(); j++){
    			if (isRead.find(vec->at(j)) != isRead.end()) continue;
    			uint distant = LAB(vec->at(j), nowAt);
    			if (shortNum > distant){
    				shortNum = distant;
    				shortIdx = j;
    			}
    		}
    		if (isRead.find(vec->at(shortIdx)) != isRead.end()) continue;
    		//move to the closest disk block
    		target = vec->at(shortIdx);
    		totalMove += printTrack(nowAt, target);
    		nowAt = target;
    		isRead.insert(target);
    	}
    	printf("\n=================== Total move distant : %d ================ \n\n\n", totalMove);
    	return;
    }
    
    //elevator alogrithm
    void ELEVSTOR(intVec* vec, uint start_p = 0, uint max_track = 1000, bool toLeft = true){
    	uint totalMove = 0;
    	uint nowAt = start_p;
    	set<uint> isNotRead;		//to record the index of block that have been read
    	printf("elevstor algorithm: start_from: %d  target_number: %d    direction: %s\n", start_p, vec->size(), (toLeft ? "left" : "right"));
    	int nextStep = (toLeft ? -1 : 1);
    	for (uint i = 0; i < vec->size(); i++) {	//set all disk block as unread state
    		isNotRead.insert(vec->at(i));
    	}
    	//first round
    	uint lastReadTrack = nowAt;
    	while (nowAt < max_track && nowAt >= 0){	//move to left or right
    		if (isNotRead.find(nowAt) != isNotRead.end()) {		//find target in it track
    			isNotRead.erase(isNotRead.find(nowAt));
    			totalMove += printTrack(lastReadTrack, nowAt);
    			lastReadTrack = nowAt;
    		}else if (nowAt == 0 || nowAt == max_track - 1){	//at the edge of disk
    			totalMove += printTrack(lastReadTrack, nowAt);
    			lastReadTrack = nowAt;
    			break;
    		}
    		//move to next track if possible
    		if (nowAt + nextStep >= max_track || nowAt + nextStep < 0) {
    			break;
    		}
    		nowAt += nextStep;
    	}
    	//second round
    	nextStep = -nextStep;	//change the direction
    	while (nowAt < max_track && nowAt >= 0) {
    		if (isNotRead.find(nowAt) != isNotRead.end()) {
    			isNotRead.erase(isNotRead.find(nowAt));
    			totalMove += printTrack(lastReadTrack, nowAt);
    			lastReadTrack = nowAt;
    		}
    		int nextTrack = nowAt + nextStep;
    		if (nextTrack >= 0 && nextTrack < max_track){
    			nowAt += nextStep;
    		}
    		else{
    			break;
    		}
    	}
    	printf("\n =================== Total move distant: %d ==================\n\n\n", totalMove);
    	return;
    }
    
    int main(){
    	intVec vec = { 14, 42, 61, 22, 40, 10, 47, 23, 29, 8, 63, 22, 19, 13, 20, 20, 16,22 };
    	FCFS(&vec, 50, 100);
    	SSTF(&vec, 50, 100);
    	ELEVSTOR(&vec, 50, 100, false);
    }
    
    
    展开全文
  •  掌握磁盘调度算法,如先来先服务(firstcome first served,FCFS)调度算法、最短寻道时间优先(shortest seek timefirst,SSTF)调度算法、扫描(SCAN)调度算法、循环扫描(C-SCAN)调度算法。二、 实验内容设计...

    一、  实验目的和要求

    1.  了解磁盘调度技术的特点

    2.  掌握磁盘调度算法,如先来先服务(firstcome first served,FCFS)调度算法、最短寻道时间优先(shortest seek timefirst,SSTF)调度算法、扫描(SCAN)调度算法、循环扫描(C-SCAN)调度算法。

    二、    实验内容

    设计模拟实现FCFS、SSTF、SCAN和C-SCAN调度算法的C语言程序。

    1.  FCFS算法:根据进程请求访问磁盘的先后次序进行调度。

    2.  SSTF算法:要求访问的磁道与当前磁头所在的磁道距离最近,以便每次的寻道时间最短。

    3.  SCAN算法:不仅考虑了欲访问的磁道与当前磁道间的距离,更优先考虑的是磁头当前的移动方向。

    三、  实验步骤

    1.  使用C++语言编译程序。

    2.  完成算法代码。

    3.  运行程序,算出结果。

    四、     实验源程序

    代码:

              #include <stdio.h>

    #include <iostream>

    #include <queue>

    #include <stack>

    #include <set>

    #include <string>

    #include <cstring>

    #include <cmath>

    #include <algorithm>

    #include <list>

    #define MAX 1111

    #define INF 0x3f3f3f3f

    using namespace std;

    typedef struct Disk_Scheduling

    {

        doubleTrackhao;

        doubleTrackshu;

     

    }DKSG;

     

    DKSG ds[MAX];

    double track[MAX];

    int mark[MAX];

     

    int input(int &n,double &now)

    {

        int im;

        int Min = INF;

        printf("请输入所求磁道号个数和开始磁道号(用空格隔开!):\n");

        scanf("%d%lf",&n,&now);

        printf("请输入%d个磁道号(各磁道号之间用空格隔开!):\n",n);

        for(int i=0;i<n; i++){

           scanf("%lf",&track[i]);

            double temp= fabs(track[i]-now);

            if(temp< Min){

                Min =temp;

                im = i;

            }

        }

        return im;

    }

     

    void output(int n)

    {

       printf("%s  %s\n","被访问的下一个磁道号","横跨磁道数");

        for(int i=0;i<n; i++){

           printf("%12.2f %16.2f\n",ds[i].Trackhao,ds[i].Trackshu);

        }

    }

     

    void FCFS()

    {

        int n;

        double now;

        input(n,now);

        for(int i=0;i<n; i++){

           ds[i].Trackhao = track[i];

            ds[i].Trackshu = fabs(track[i]-now);

            now =track[i];

        }

        printf("\n先来先服务:\n");

        output(n);

    }

     

    void SSTF()

    {

       memset(mark,0,sizeof(mark));

        int n;

        double now;

        int im =input(n,now);

        int cnt1,cnt2;

        double t1,t2;

        for(int i=0;i<n; i++){

            int Min =INF;

           ds[i].Trackhao = track[im];

           ds[i].Trackshu = fabs(track[im]-now);

            now =track[im];

            mark[im] =1;

            for(intj=0; j<n; j++){

               if(!mark[j]){

                    doubletemp = fabs(track[j]-now);

                   if(temp < Min){

                       Min = temp;

                       im = j;

                    }

                }

            }

        }

        printf("\n最短寻道时间优先:\n");

        output(n);

    }

     

    void SCAN()

    {

        double retrack[MAX];

        int n;

        double now;

        input(n,now);

       sort(track,track+n);

        int locate =upper_bound(track,track+n,now) - track;

        int t = locate;

        int k,r;

        for(k=0;k<n-locate; k++){

            retrack[k]= track[k+locate];

        }

        for(r=k; r<n;r++){

            retrack[r]= track[--t];

        }

        for(int i=0;i<n; i++){

           ds[i].Trackhao = retrack[i];

           ds[i].Trackshu = fabs(retrack[i]-now);

            now =retrack[i];

        }

        printf("\n扫描调度算法:\n");

        output(n);

    }

     

    void C_SCAN()

    {

        int n;

        double now;

        input(n,now);

       sort(track,track+n);

        int locate =upper_bound(track,track+n,now) - track;

        int im;

        for(int i=0;i<n; i++){

            im =(i+locate)%n;

           ds[i].Trackhao = track[im];

           ds[i].Trackshu = fabs(track[im]-now);

            now =track[im];

        }

        printf("\n循环扫描调度算法:\n");

        output(n);

    }

     

    int main()

    {

       printf("%*s\n",80,"欢迎您!");

        int ca = 0;

        do{

           printf("\n%*s\n",80,"请选择磁盘调度算法或结束程序:");

           printf("0、结束程序\n1、先来先服务\n2、最短寻道时间优先\n3、扫描\n4、循环扫描\n");

           scanf("%d",&ca);

            if(ca == 1)FCFS();

            if(ca == 2)SSTF();

            if(ca == 3)SCAN();

            if(ca == 4)C_SCAN();

           printf("\n\n");

        }while(ca);

        return 0;

    }

     

     

     

    五、  实验结果

     

    先来先服务调度算法:

     

    最短寻道时间调度算法:

     

    扫描调度算法:


    循环扫描调度算法:



    展开全文
  • (1) 实现的磁盘调度算法有FCFS,SSTF,SCAN,CSCAN和 NStepSCAN算法。 (2) 设定开始磁道号寻道范围,依据起始扫描磁道号和最大磁道号数,随机产生要进行寻道的磁道号序列。 (3) 选择磁盘调度算法,显示该算法的磁道...
  • 通过模拟磁盘调度算法加深对磁盘调度的理解,熟悉磁盘管理系统的设计方法;加深对磁盘访问过程的理解。 二、实验内容 编程实现下述磁盘调度算法,并求出每种算法的平均寻道长度,并给出调度顺序;要求在主界面中...

    一、实验目的及要求

        通过模拟磁盘调度算法加深对磁盘调度的理解,熟悉磁盘管理系统的设计方法;加深对磁盘访问过程的理解。

    二、实验内容

         编程实现下述磁盘调度算法,并求出每种算法的平均寻道长度,并给出调度顺序;要求在主界面中灵活选择调度算法,要求实现以下磁盘调度算法:

        1.先来先服务FCFS  

        2.最短寻道时间优先SSTF   

        3.扫描算法SCAN   

       4.循环扫描算法CSCAN

    三、程序结构及流程图 

    程序包含一个主函数以及四种调度算法对应的子函数。

    主函数main()中显示程序功能菜单,用户输入要处理的磁道数以及具体磁道号,之后选择要执行的算法,根据输入选择调用相应的子函数。

    先来先服务算法void FCFS(int a[], int n),将请求处理的磁道按请求的先后次序排队,依次访问。

    最短寻道时间优先算法void SSTF(int a[], int n),每次访问与当前磁头所在磁道距离最近的磁道,先冒泡排序将磁道号进行排序,根据当前磁道号与所请求访问的磁道号的大小比较,具体选择访问次序。

    扫描算法void SCAN(int a[], int n),首先将数组内的数据进行排序,然后同样地确定当前磁道号在有序数据中的位置,根据用户输入确定磁头移动方向(0向内,1向外)。然后在向内(外)的方向上依次访问,访问完了之后,再输出初始位置向外(内)的服务序列。

    循环扫描算法void CSCAN(int a[], int n),规定磁头单向移动。开始和前面的算法一样,也是先进行排序,定位,根据用户输入确定磁头移动方向(0向内,1向外)。然后在向内的方向上依次访问,访问完了之后,再从最外层向内扫。(或者相反)

    程序流程图如图1所示:

     四、实验步骤

    1.设置先来先服务算法(FCFS):

        用户输入当前磁道号,将请求处理的磁道按请求的先后次序排队,依次访问。计算移动的总磁道数和移动的平均磁道数。

    2.设置最短寻道时间优先算法(SSTF)

    用户输入当前磁道号,每次访问与当前磁头所在磁道距离最近的磁道,先冒泡排序将磁道号进行排序,根据当前磁道号与所请求访问的磁道号的大小比较,具体选择访问次序。计算移动的总磁道数和移动的平均磁道数。

    3.设置扫描算法(SCAN)

    首先将数组内的数据进行排序,然后同样地确定当前磁道号在有序数据中的位置,用户输入当前的磁道号以及磁头的移动方向,根据用户输入确定磁头移动方向(0向内,1向外)。然后在向内(外)的方向上依次访问,访问完了之后,再输出初始位置向外(内)的服务序列。计算移动的总磁道数和移动的平均磁道数。

    4.设置循环扫描算法(CSCAN)

    用户输入当前的磁道号以及磁头移动方向,开始和前面的算法一样,也是先进行排序,定位,根据用户输入确定磁头移动方向(0向内,1向外)。磁头单向移动,在向内的方向上依次访问,访问完了之后,再从最外层向内扫。(或者相反)最后,计算移动的总磁道数和移动的平均磁道数。

    5.设置主函数

    主函数main()中显示程序功能菜单,用户输入要处理的磁道数以及具体磁道号,之后选择要执行的算法,根据输入选择调用相应的子函数。用户输入1选择执行FCFS,输入2执行SSTF,输入3执行SCAN,输入4执行CSCAN,输入0则退出程序。

    五、实验结果与数据处理

        程序测试:    

        假设有9个进程先后提出磁盘I/O请求,先后请求的磁道号依次为55,58,39,18,90,160,150,38,184。当前磁道号为100。

    首先输入要处理的磁道数为9;依次输入请求的磁道号。结果如图2所示:

    输入1,选则执行FCFS算法,输入当前磁道号为100。结果如图3所示:

    移动的平均磁道数为55.33

     

    输入2,选择执行SSTF算法。执行结果如图4所示:

    移动的平均磁道数为27.56

    输入3,选择执行SCAN算法。执行结果如图5所示:

    移动的平均磁道数为27.78

     

    输入4,选择执行SSTF算法。执行结果如图6所示:

    移动的平均磁道数为27.56

    输入0,选择终止程序,成功退出。如图7所示:

    、分析与讨论

    通过实验更清楚的了解了磁盘调度四种调度算法的具体实现过程。(先来先服务算法;最短寻道时间优先算法;扫描算法;循环扫描算法)

    实验过程中也遇到了一些问题,在实现扫描算法时,当输入的当前的磁道号不在磁盘请求序列中时,程序可以正常执行,当输入的当前的磁道号在磁盘请求序列中时,程序执行时出现处理序列顺序错误的问题,发现变量初值设置有问题,经过调整后,程序执行无误,达到了预期的效果。

    七、实验源代码

    #define _CRT_SECURE_NO_WARNINGS 
    #include<stdio.h> 
    #include<stdlib.h> 
    #include<time.h> 
    #include<Windows.h>  
    /*先来先服务 (FCFS)*/ 
    void FCFS(int a[], int n) 
    { 
        int sum = 0, i, j, now; 
        printf("请输入当前磁道号:\n"); 
        scanf("%d", &now); 
        sum += abs(a[0] - now); 
        printf("从当前位置到第1个磁道移动的磁道数:\t%d\n", sum); 
        for (i = 0, j = 1; j < n; j++, i++){ 
            sum += abs(a[j] - a[i]); 
            printf("从第%d磁道到第%d磁道移动的磁道数:\t%d\n", i + 1, j + 1, abs(a[j] - a[i])); 
        } 
        printf("移动的总磁道数:%d\n", sum); 
        printf("移动的平均磁道数:%.2lf\n", 1.0*sum / n); 
        printf("请再次输入你想使用的方法:\n"); 
    } 
    
    /*最短寻道时间函数SSTF*/ 
    void SSTF(int a[], int n){ 
        int temp; 
        int now; 
        int sum = 0, i, j, k=0;      
    	printf("排序后的磁道分布:\n");   //冒泡排序法对磁道号进行排序
        for (i = 0; i < n; i++){ 
            for (j = i + 1; j < n; j++){ 
                if (a[i]>a[j]){ 
                    temp = a[i]; 
                    a[i] = a[j]; 
                    a[j] = temp; 
                } 
            } 
            printf("%d \t", a[i]); 
            if (i % 10 == 9){ 
                printf("\n"); 
            } 
        } 
        printf("\n"); 
        printf("请输入当前磁道号:\n"); 
        scanf("%d", &now); 
        if (a[0] >=now){ 
            printf("当前访问的磁道%d\n", a[0]); 
            for (i = 0; i < n-1; i++){ 
            printf("当前访问的磁道:\t%d\n",a[i+1]); 
              
            } 
            sum = a[n - 1] - now; 
            printf("移动的总磁道数:%d\n", sum); 
        } 
        else if (a[n - 1] <= now){ 
            printf("当前访问的磁道:%d\n", a[n-1]); 
            for (j=n-1; i<n-1;j--){ 
                printf("当前访问的磁道:\t%d\n",a[j-1]); 
      
            } 
            sum = now-a[0]; 
            printf("移动的总磁道数:%d\n", sum); 
        } 
        else{ 
            while (a[k] < now){ 
                k++; 
            } 
            j = k-1; 
            i = 0; 
            while ((j>=0)&&(k<n)){ 
                i++; 
                if (now - a[j] >= a[k] - now){ 
                    printf("当前访问的磁道:\t%d\n", a[k]); 
                      
                    sum += a[k] - now; 
                    now = a[k]; 
                    k++; 
                } 
                else{ 
                    printf("当前访问的磁道:\t%d\n",  a[j]); 
                    sum += now - a[j]; 
                    now = a[j]; 
                    j--; 
                } 
            } 
            if (k > n-1){ 
                for (int t = j; t > 0; t--){ 
                    i++; 
                    if (t == j){ 
                        printf("当前访问的磁道:\t%d\n",a[j]); 
                    } 
                    else{ 
                        printf("当前访问的磁道:\t%d\n", a[t+1]); 
                    } 
                      
                } 
                sum += a[n - 1] - a[0]; 
            } 
            if (j <0){ 
                for (int t = k; t < n; t++){ 
                    i++; 
                    if (t == k){ 
                        printf("当前访问的磁道:\t%d\n",a[k]); 
                    } 
                    else{ 
                        printf("当前访问的磁道:\t%d\n",a[t]); 
                    } 
                } 
                sum += a[n - 1] - a[0]; 
            } 
        } 
        printf("经过的总磁道数为:%d\n", sum); 
        printf("移动的平均磁道数:%.2lf\n", 1.0*sum / n); 
        printf("请再次输入你想使用的方法:\n"); 
      
    } 
    
    /*扫描算法*/
    void SCAN(int a[], int n){ 
        int temp; 
        int now; 
        int sum = 0, i, j, k = 0; 
    	printf("排序后的磁道分布:\n");  //冒泡排序法对磁道号进行排序 
        for (i = 0; i < n; i++){ 
            for (j = i + 1; j < n; j++){ 
                if (a[i]>a[j]){ 
                    temp = a[i]; 
                    a[i] = a[j]; 
                    a[j] = temp; 
                } 
            } 
            printf("%d \t", a[i]); 
            if (i % 10 == 9){ 
                printf("\n"); 
            } 
        } 
        printf("\n请输入当前磁道号:\n"); 
        scanf("%d", &now); 
        if (a[0] >= now){ 
            printf("当前访问的磁道:%d\n", a[0]); 
            for (i = 0; i < n - 1; i++){ 
                printf("当前访问的磁道:\t%d\n", a[i + 1]); 
            } 
            sum = a[n - 1] - now; 
            printf("移动的总磁道数:%d\n", sum); 
        } 
        else if (a[n - 1] <= now){ 
            printf("当前访问的磁道:%d\n", a[n - 1]); 
            for ( j = n - 1; i<n - 1; j--){ 
                printf("当前访问的磁道:\t%d\n",  a[j - 1]); 
            } 
            sum = now - a[0]; 
            printf("移动的总磁道数:%d\n", sum); 
        } 
        else{ 
            int d; 
    		int t;
            while (a[k] < now){ 
                k++; 
            } 
            j = k - 1; 
            printf("请输入当前磁头移动的方向(0向内,1向外):\n"); 
            scanf("%d", &d);             
                if (d == 1){ 
                    for (t = k; t < n; t++){ 
                        printf("当前访问的磁道:\t%d\n",a[t]); 
                        sum += a[t] - now; 
                        now = a[t]; 
                    } 
                    for (t = j; t >=0; t--){ 
                        printf("当前访问的磁道:\t%d\n",a[t]); 
                    } 
                    sum += a[n - 1] - a[0]; 
                } 
                  
                else if (d == 0){ 
                    for (t = j; t >= 0; t--){ 
                        printf("当前访问的磁道:\t%d\n", a[t]); 
                        sum += now - a[t]; 
                        now = a[t]; 
                    } 
                    for (t = k; t < n; t++){ 
                            printf("当前访问的磁道:\t%d\n",a[t]); 
                    } 
                    sum += a[n - 1] - a[0]; 
                } 
                else{ 
                    printf("输入错误,重新回到选择算法界面!\n"); 
                } 
                  
        } 
        printf("经过的总磁道数为:%d\n", sum); 
          
        printf("移动的平均磁道数:%.2lf\n", 1.0*sum/n); 
        printf("请再次输入你想使用的方法:\n"); 
    }
     
    /*循环扫描算法*/ 
    void CSCAN(int a[], int n){ 
        int temp; 
        int now; 
        int sum = 0, i, j, k = 0;    
    	printf("排序后的磁道分布:\n");   //冒泡排序法对磁道号进行排序
        for (i = 0; i < n; i++){ 
            for (j = i + 1; j < n; j++){ 
                if (a[i]>a[j]){ 
                    temp = a[i]; 
                    a[i] = a[j]; 
                    a[j] = temp; 
                } 
            } 
            printf("%d \t", a[i]); 
            if (i % 10 == 9){ 
                printf("\n"); 
            } 
        } 
        printf("\n请输入当前磁道号:\n"); 
        scanf("%d", &now); 
        if (a[0] >= now){ 
            printf("当前访问的磁道:%d\n", a[0]); 
            for (i = 0; i < n - 1; i++){ 
                printf("当前访问的磁道:\t%d\n", a[i + 1]); 
            } 
            sum = a[n - 1] - now; 
            printf("移动的总磁道数:%d\n", sum); 
        } 
        else if (a[n - 1] <= now){ 
            printf("当前访问的磁道:%d\n", a[n - 1]); 
            for ( j = n - 1; i>=0; j--){ 
                printf("当前访问的磁道:\t%d\n",a[j - 1]); 
            } 
            sum = now - a[0]; 
            printf("移动的总磁道数:%d\n", sum); 
        } 
        else{ 
            int d; 
    		int t;
            while (a[k] < now){ 
                k++; 
            } 
            j = k - 1; 
            printf("请输入当前磁头移动的方向(0向内,1向外):\n"); 
            scanf("%d", &d); 
            if (d == 1){ 
                int i = 0; 
                for (t = k; t < n; t++){ 
                    printf("当前访问的磁道:\t%d\n", a[t]); 
                    sum += a[t] - now; 
                    now = a[t]; 
                } 
                for (t = 0; t < k; t++){ 
                    printf("当前访问的磁道:\t%d\n",  a[t]); 
                } 
                sum += a[n-1] - a[0]+a[j]-a[0]; 
            } 
      
            else if (d == 0){ 
                for (t = j; t >= 0; t--){ 
                    printf("当前访问的磁道:\t%d\n",  a[t]); 
                    sum += now - a[t]; 
                    now = a[t]; 
                } 
                for (t = n-1; t >=k; t--){ 
                    printf("当前访问的磁道:\t%d\n",  a[t]); 
                } 
                sum += a[n - 1] - a[0]+a[n-1]-a[k]; 
            } 
            else{ 
                printf("输入错误,重新回到选择算法界面!\n"); 
            } 
      
        } 
        printf("经过的总磁道数为:%d\n", sum); 
        printf("移动的平均磁道数:%.2lf\n", 1.0*sum / n); 
        printf("请再次输入你想使用的方法:\n"); 
    } 
    
    /* 主函数*/ 
        void main(){ 
    		int n;    //磁道数     
    		int control=1;      //控制处理的方式     
    		printf("请输入要处理的磁道数:\n"); 
    	    scanf("%d",&n); 
    	    int c[1000]; 
    		printf("请按求先后顺序依次输入磁道号:\n"); 	    
    	   for (int i = 0; i < n; i++){ 
    			 scanf("%d",&c[i]); 
    		 } 
    
        printf("\n 数据输入完毕! 已有进程提出磁盘I/O请求!\n"); 
        printf("**************************************************\n"); 
        printf("*                                                *\n"); 
        printf("******************* 算法选择 *********************\n"); 
        printf("*                                                *\n"); 
        printf("*               1.先来先服务算法                 *\n"); 
        printf("*               2.最短寻道时间算法               *\n"); 
        printf("*               3.扫描算法                       *\n"); 
        printf("*               4.循环扫描算法                   *\n"); 
        printf("*               0.退出程序                       *\n"); 
        printf("*                                                *\n"); 
        printf("**************************************************\n"); 
        printf("\n"); 
        /*算法选择*/
        printf("请输入要执行的方法:\n"); 
        while (control){ 
              
            scanf("%d", &control); 
            switch (control){ 
            case 0: 
    			control=0;
                break; 
            case 1: 
                FCFS(c, n);  
                break; 
            case 2: 
                SSTF(c, n); 
                break; 
            case 3: 
                SCAN(c, n); 
                break; 
            case 4: 
                CSCAN(c, n); 
                break; 
            default: 
                printf("选项错误!重新选择!"); 
                break; 
            } 
        } 
        printf("程序退出成功,谢谢使用!"); 
        system("pause"); 
    }

    这是一篇详细的课程设计,适合正在学习磁盘调度算法的同学,如果你觉得有用,请为我点个赞吧~

     

    展开全文
  • 操作系统磁盘调度算法 运用C++语言编写
  • 本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及...
  • 磁盘调度算法 C++实现

    万次阅读 多人点赞 2016-09-08 10:40:04
    常见的磁盘调度算法大致分为以下5类: FCFS、SSTF、SCAN、CSCAN、FSCAN 程序实现了上述5类调度算法。 其中,当前磁道和要求服务的磁道均由系统随机产生。 程序入口是main主函数,在程序一开始由request()函数...
  • 操作系统上机实验程序——SSTF磁盘调度算法模拟(含代码)
  • 操作系统磁盘调度 算法课程设计 FCFSB法流程图 SSTFW法流程图 SCAN#法流程图: 选择移动臂 cscaN!法流程图: SSTF: SCAN
  • 模拟磁盘调度算法SCAN

    千次阅读 2019-06-15 12:08:58
    基于JAVA的模拟磁盘调度算法SCAN思考问题:简单讲一下原理功能描述功能描述:算法流程图:话不多说,上代码:利用Disk类来模拟磁盘的工作流程 ,get_cidao()磁道方法为获取磁头的当前位置,set_citou(int f,int c)...
  • 操作系统实 验 报 告课程名称操作系统实验实验项目名称磁盘调度算法学号班级姓名专业计算机科学与技术学生所在学院计算机科学与技术学院指导教师初妍实验室名称地点21#428哈尔滨工程大学计算机科学与技术学院第六讲 ...
  • 操作系统:磁盘调度算法

    千次阅读 多人点赞 2018-12-18 10:45:59
     磁盘调度算法 一:概念  常见的磁盘调度算法有: 1.FCFS:先来先服务算法; 2.SSTF:最短寻道时间算法; 3.SCAN:扫描算法(也叫电梯调度算法); 4.CSCAN:循环扫描算法    算法的详细介绍: FCFS:...
  • 为电梯调度算法,有程序和文档,可运行,操作系统课程设计。
  • 磁盘调度算法,用c语言编写的,内容丰富,希望能帮助大家
  • FIFO:先进先出的调度策略,这个策略具有公平的优点,因为每个请求都会得到处理,并且是按照接收到的顺序进行处理 ...  磁盘调度算法的数据比较  磁盘调度算法的描述  磁盘调度算法的直观比较
  • 本文档是计算机操作系统实验,用FSFC算法和SCAN算法实现了磁盘调度算法
  • 磁盘调度算法的模拟实现课程设计报告淮北师范大学操作系统课程设计磁盘调度算法的模拟实现学 院 计算机科学与技术专 业 计算机科学与技术(师范)学 号学 生 姓 名指导教师姓名2015年7月1日目录一、引言2二、总体设计...
  • 课 程 设 计 计算机操作系统 题 目 CSCAN磁盘调度算法 班 级 姓 名 指导教师 系主任 2014年03月01日 目 录 TOC \o "1-3" \h \z \u 1CSCAN磁盘调度算法问题课程设计 1 1.1 题目分析 1 1.2 数据结构 1 1.3 流程图 ...
  • 哈尔滨理工大学 课 程 设 计 课程名称 题 目 SSTF磁盘调度算法 班 级 姓 名 指导教师 系主任 2014年03月01日 目 录 TOC \o "1-3" \h \z \u 1SSTF磁盘调度算法课程设计 1 1.1 题目分析 1 1.2 数据结构 1 1.3 流程图 1...
  • 磁盘调度算法的模拟与实现

    千次阅读 2019-01-05 22:20:46
    这是一个用IDEA为工具、Java为编程语言在Windows10为环境而实现模拟先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、 扫描算法(SCAN)的一个模拟磁盘调度程序。 系统设计的内容 1.先来先服务算法(FCFS) 该...
  • 计算机操作系统-磁盘调度算法

    千次阅读 2019-06-08 21:05:39
    磁盘调度算法 当多个访盘请求等待时,采用一定的策略,对这些请求的服务顺序调整安排,旨在降低平均磁盘服务时间,达到公平、高效。 公平:一个I/O请求在有限时间内满足 高效:减少设备机械运动所带来的时间浪费 先...
  • https://blog.csdn.net/qq_27607965/article/details/82355797 四种常用磁盘调度算法
  • 此程序模拟磁盘调度算法电梯算法和最短寻道时间优先SSTF算法,电梯算法具体实现原理看图片和程序开头的介绍。采用C++语言开发,运用链表,指针实现访问。
  • 磁盘调度算法简述

    2019-04-17 23:59:00
    一 丶意义:良好的调度算法,能减少IO读取时间(磁盘读取(最慢)+读取+传输) 磁盘访问时间=寻道时间+旋转延迟时间+数据传输时间, 磁盘读写顺序:由上直下(柱面磁道),由外到里(柱面排序,外磁道速度最快),...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,786
精华内容 7,914
关键字:

磁盘调度算法流程图