labweek18

最新推荐文章于 2023-11-01 21:12:24 发布
最新推荐文章于 2023-11-01 21:12:24 发布
阅读量909 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwx54088/article/details/118163659
版权

实验报告

实验内容

硬盘调度: 编写 C 程序模拟实现课件 Lecture25 中的硬盘柱面访问调度算法包括 FCFS、SSTF、SCAN、C-SCAN、LOOK、C-LOOK，并设计输入用例验证结果。

实验环境

 Ubuntu 20.04.2.0（64位）

基础知识

  1. FCFS（先来先服务）: 根据进程请求访问磁盘的先后顺序进行调度。

例1：
在这里插入图片描述

例2：

如磁道请求队列为55、58、39、18、90、160、150、38、184，从100号开始。
在这里插入图片描述

  1. SSTF（最短寻道时间优先）：其要求访问的磁道与当前磁头所在的磁道距离最近。

例1：
在这里插入图片描述

例2：

如磁道请求队列为55、58、39、18、90、160、150、38、184，从100号开始。
在这里插入图片描述

  1. SCAN（扫描算法）: 磁臂从磁盘的一端开始向另一端移动，在到达每个柱面时为请求提供服务，直到到达磁盘的另一端，磁头的移动方向相反，服务继续进行。

例1：
在这里插入图片描述

例2：

如磁道请求队列为55、58、39、18、90、160、150、38、184，从100号开始。向磁道号增加方向访问。
在这里插入图片描述

  1. LOOK: LOOK就是对应SCAN的改进算法。因为SCAN中每次磁头都要走到磁道尽头，而实际过程中并不需要要求磁头走到尽头，而是到达该方向的最后一个请求后即可返回，这样可以避免一些不必要的磁头移动。

例1：
在这里插入图片描述

例2：

如磁道请求队列为55、58、39、18、90、160、150、38、184，从100号开始。向磁道号增加方向访问。
在这里插入图片描述

  1. CSCAN（循环扫描算法）: 首先自里向外访问，当磁头移到最外的磁道后，磁头返回到最里的磁道，即将最小磁道号紧接着最大磁道号构成循环，继续循环扫描。

例1：
在这里插入图片描述

例2：

如磁道请求队列为55、58、39、18、90、160、150、38、184，从100号开始。
在这里插入图片描述

  1. CLOOK: CLOOK就是对应CSCAN的改进算法。因为CSCAN中每次磁头都要走到磁道尽头，而实际过程中并不需要要求磁头走到尽头，而是到达该方向的最后一个请求后即可返回，这样可以避免一些不必要的磁头移动。

例1：
在这里插入图片描述
例2：

如磁道请求队列为55、58、39、18、90、160、150、38、184，从100号开始。
在这里插入图片描述

（参考资料1：课件）

（参考资料2）

实验过程

规定硬盘只有200个磁道，从0~199：
在这里插入图片描述

一. 用以上例2作为输入样例：
在这里插入图片描述

  1. FCFS结果：
    在这里插入图片描述
    与例2中的结果一致，计算所得的总寻道长度和平均寻道长度也正确。

  2. SSTF结果：
    在这里插入图片描述
    与例2中的结果一致，计算所得的总寻道长度和平均寻道长度也正确。

  3. SCAN结果：
    在这里插入图片描述
    可以看到，磁头需要走到磁盘一端的最后一个磁道才会往回移动，其他与例2中的结果一致，计算所得的总寻道长度和平均寻道长度也正确。

  4. CSCAN结果：
    在这里插入图片描述
    可以看到，磁头需要走到磁盘一端的最后一个磁道才会往回移动，其他与例2中的结果一致，计算所得的总寻道长度和平均寻道长度也正确。

  5. LOOK结果：
    在这里插入图片描述
    可以看到，磁头只需要走到其方向上的最后一个请求即可往回移动，与例2中的结果一致，计算所得的总寻道长度和平均寻道长度也正确。

  6. CLOOK结果：
    在这里插入图片描述
    可以看到，磁头只需要走到其方向上的最后一个请求即可往回移动，与例2中的结果一致，计算所得的总寻道长度和平均寻道长度也正确。

一. 用以上例1作为另一输入样例：
在这里插入图片描述

  1. FCFS结果：
    在这里插入图片描述

  2. SSTF结果：
    在这里插入图片描述

  3. SCAN结果：
    在这里插入图片描述

  4. CSCAN结果：
    在这里插入图片描述

  5. LOOK结果：
    在这里插入图片描述

  6. CLOOK结果：
    在这里插入图片描述

代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define MAX_TASK 100
#define MAX_track 199

#define waiting 0
#define complete 1

// structure of task
typedef struct task
{
    int track;      // task's track
    int stat;       // task's state: wait or complete
} Task;  

// structure of read-write head
typedef struct head
{
    int track;      // head's track
    int seek_length;  // total seek length
} Head; 

void FCFS(Task task[], Head head, int task_n);
void SSTF(Task task[], Head head, int task_n);
void SCAN(Task task[], Head head, int task_n);
void CSCAN(Task task[], Head head, int task_n);
void LOOK(Task task[], Head head, int task_n);
void CLOOK(Task task[], Head head, int task_n);

int main()
{
    printf("In this hard disk, the tracks is from 0 to %d.\n", MAX_track);

    printf("\n");
    int task_n = 9; // the number of tasks
    printf("Please enter the number of task(<=100): ");
    scanf("%d", &task_n);
    if(task_n > 100){
        printf("Error: value out of range!\n");
        return -1;
    }

    printf("\n");
    printf("Please enter the track in each task:\n");
    Task task[task_n];      // array of task
    for(int i = 0; i < task_n; i++){
        printf("task %d(0 ~ %d): ", i, MAX_track);
        scanf("%d", &task[i].track);
        if(task[i].track > MAX_track || task[i].track < 0){
            printf("Error: value out of range!\n");
            return -1;
        }

        task[i].stat = waiting;     // initialize task's state
    }
    // task[0].track = 55;
    // task[1].track = 58;
    // task[2].track = 39;
    // task[3].track = 18;
    // task[4].track = 90;
    // task[5].track = 160;
    // task[6].track = 150;
    // task[7].track = 38;
    // task[8].track = 184;

    printf("\n");
    Head head;
    int head_track;
    printf("Please enter initial track of read-write head(0 ~ %d): ", MAX_track);
    scanf("%d", &head_track);
    if(head_track > MAX_track || head_track < 0){
        printf("Error: value out of range!\n");
        return -1;
    }

    printf("\n");
    // creat copy
    head.track = head_track;
    head.seek_length = 0;
    Task task_FCFS[task_n];
    for(int i = 0; i < task_n; i++){
        task_FCFS[i].track = task[i].track;
        task_FCFS[i].stat = task[i].stat;
    }
    printf("Scheduling Mode: FCFS.\n");
    FCFS(task_FCFS, head, task_n);

    printf("\n");
    // creat copy
    head.track = head_track;
    head.seek_length = 0;
    Task task_SSTF[task_n];
    for(int i = 0; i < task_n; i++){
        task_SSTF[i].track = task[i].track;
        task_SSTF[i].stat = task[i].stat;
    }
    printf("Scheduling Mode: SSTF.\n");
    SSTF(task_SSTF, head, task_n);

    printf("\n");
    // creat copy
    head.track = head_track;
    head.seek_length = 0;
    Task task_SCAN[task_n];
    for(int i = 0; i < task_n; i++){
        task_SCAN[i].track = task[i].track;
        task_SCAN[i].stat = task[i].stat;
    }
    printf("Scheduling Mode: SCAN.\n");
    printf("Assume that the disk arm is moving toward 199.\n");
    SCAN(task_SCAN, head, task_n);

    printf("\n");
    // creat copy
    head.track = head_track;
    head.seek_length = 0;
    Task task_CSCAN[task_n];
    for(int i = 0; i < task_n; i++){
        task_CSCAN[i].track = task[i].track;
        task_CSCAN[i].stat = task[i].stat;
    }
    printf("Scheduling Mode: CSCAN.\n");
    CSCAN(task_CSCAN, head, task_n);

    printf("\n");
    // creat copy
    head.track = head_track;
    head.seek_length = 0;
    Task task_LOOK[task_n];
    for(int i = 0; i < task_n; i++){
        task_LOOK[i].track = task[i].track;
        task_LOOK[i].stat = task[i].stat;
    }
    printf("Scheduling Mode: LOOK.\n");
    printf("Assume that the disk arm is moving toward 199.\n");
    LOOK(task_LOOK, head, task_n);

    printf("\n");
    // creat copy
    head.track = head_track;
    head.seek_length = 0;
    Task task_CLOOK[task_n];
    for(int i = 0; i < task_n; i++){
        task_CLOOK[i].track = task[i].track;
        task_CLOOK[i].stat = task[i].stat;
    }
    printf("Scheduling Mode: CLOOK.\n");
    CLOOK(task_CLOOK, head, task_n);

    return 0;
}

void FCFS(Task task[], Head head, int task_n)
{
    printf("track visited\tseek length\n");

    for(int i = 0; i < task_n; i++){
        task[i].stat = complete;

        int temp = abs(task[i].track - head.track);     // absolute value: distance between track and head
        printf("%13d\t%11d\n", task[i].track, temp);

        head.track = task[i].track;
        head.seek_length += temp;
    }

    printf("Total seek length: %d.\n", head.seek_length);
    printf("Average seek length: %.1f.\n", 1.0 * head.seek_length/task_n);
}

void SSTF(Task task[], Head head, int task_n)
{
    printf("track visited\tseek length\n");
    
    for(int i = 0; i < task_n; i++){
        int min_dis = 200;  // the least distance from the head
        int min_task = 0;      // the track with the least distance from the head
        int temp = 0;       // absolute value: distance between track and head
        
        for(int j = 0; j < task_n; j++){    // find the task with the least distance from the head
            if(task[j].stat == waiting){
                temp = abs(task[j].track - head.track);
                if(temp < min_dis){
                    min_dis = temp;
                    min_task = j;
                }
            }            
        }

        printf("%13d\t%11d\n", task[min_task].track, min_dis);

        head.track = task[min_task].track;
        head.seek_length += min_dis;
        task[min_task].stat = complete;
    }

    printf("Total seek length: %d.\n", head.seek_length);
    printf("Average seek length: %.2f.\n", 1.0 * head.seek_length/task_n);
}

void SCAN(Task task[], Head head, int task_n)
{
    printf("track visited\tseek length\n");

    int temp_head = head.track;

    while(temp_head <= MAX_track){      // head: from head track to max track 
        for(int i = 0; i < task_n; i++){
            if(task[i].stat == waiting){
                if(task[i].track == temp_head){
                    task[i].stat = complete;

                    int temp = abs(task[i].track - head.track);
                    printf("%13d\t%11d\n", task[i].track, temp);

                    head.track = task[i].track;
                    head.seek_length += temp;
                    break;
                }
            }
        }

        temp_head++;
    }

    while(temp_head >= 0){      // head: from max track to 0
        for(int i = 0; i < task_n; i++){
            if(task[i].stat == waiting){
                if(task[i].track == temp_head){
                    task[i].stat = complete;

                    int temp = abs(task[i].track - head.track);
                    printf("%13d\t%11d\n", task[i].track, temp);

                    head.track = task[i].track;
                    head.seek_length += temp;
                    break;
                }
            }
        }

        temp_head--;
    }

    printf("Total seek length: %d.\n", head.seek_length);
    printf("Average seek length: %.1f.\n", 1.0 * head.seek_length/task_n);
}

void CSCAN(Task task[], Head head, int task_n)
{
    printf("track visited\tseek length\n");

    int temp_head = head.track;

    while(temp_head <= MAX_track){      // head: from head track to max track
        for(int i = 0; i < task_n; i++){
            if(task[i].stat == waiting){
                if(task[i].track == temp_head){
                    task[i].stat = complete;

                    int temp = abs(task[i].track - head.track);
                    printf("%13d\t%11d\n", task[i].track, temp);

                    head.track = task[i].track;
                    head.seek_length += temp;
                    break;
                }
            }
        }

        temp_head++;
    }

    temp_head = 0;      // head: back to the beginning

    while(temp_head <= MAX_track){      // head: from beginning to max track
        for(int i = 0; i < task_n; i++){
            if(task[i].stat == waiting){
                if(task[i].track == temp_head){
                    task[i].stat = complete;

                    int temp = abs(task[i].track - head.track);
                    printf("%13d\t%11d\n", task[i].track, temp);

                    head.track = task[i].track;
                    head.seek_length += temp;
                    break;
                }
            }
        }

        temp_head++;
    }

    printf("Total seek length: %d.\n", head.seek_length);
    printf("Average seek length: %.1f.\n", 1.0 * head.seek_length/task_n);
}

void LOOK(Task task[], Head head, int task_n)
{
    int min_track = 200;
    int max_track = -1;
    for(int i = 0; i < task_n; i++){        // find min task's track and max task's track
        if(task[i].track < min_track){
            min_track = task[i].track;
        }
        
        if(task[i].track > max_track){
            max_track = task[i].track;
        }
    }

    printf("track visited\tseek length\n");

    int temp_head = head.track;
    
    while(temp_head <= max_track){      // head: from head track to max task's track
        for(int i = 0; i < task_n; i++){
            if(task[i].stat == waiting){
                if(task[i].track == temp_head){
                    task[i].stat = complete;

                    int temp = abs(task[i].track - head.track);
                    printf("%13d\t%11d\n", task[i].track, temp);

                    head.track = task[i].track;
                    head.seek_length += temp;
                    break;
                }
            }
        }

        temp_head++;
    }

    while(temp_head >= min_track){      // head: from max task's track to min task's track
        for(int i = 0; i < task_n; i++){
            if(task[i].stat == waiting){
                if(task[i].track == temp_head){
                    task[i].stat = complete;

                    int temp = abs(task[i].track - head.track);
                    printf("%13d\t%11d\n", task[i].track, temp);

                    head.track = task[i].track;
                    head.seek_length += temp;
                    break;
                }
            }
        }

        temp_head--;
    }

    printf("Total seek length: %d.\n", head.seek_length);
    printf("Average seek length: %.1f.\n", 1.0 * head.seek_length/task_n);
}

void CLOOK(Task task[], Head head, int task_n)
{
    int min_track = 200;
    int max_track = -1;
    for(int i = 0; i < task_n; i++){        // find min task's track and max task's track
        if(task[i].track < min_track){
            min_track = task[i].track;
        }
        
        if(task[i].track > max_track){
            max_track = task[i].track;
        }
    }

    printf("track visited\tseek length\n");

    int temp_head = head.track;
    
    while(temp_head <= max_track){      // head: from head track to max task's track
        for(int i = 0; i < task_n; i++){
            if(task[i].stat == waiting){
                if(task[i].track == temp_head){
                    task[i].stat = complete;

                    int temp = abs(task[i].track - head.track);
                    printf("%13d\t%11d\n", task[i].track, temp);

                    head.track = task[i].track;
                    head.seek_length += temp;
                    break;
                }
            }
        }

        temp_head++;
    }

    temp_head = min_track;      // head: back to min task's track

    while(temp_head <= max_track){      // head: from min task's track to max task's track
        for(int i = 0; i < task_n; i++){
            if(task[i].stat == waiting){
                if(task[i].track == temp_head){
                    task[i].stat = complete;

                    int temp = abs(task[i].track - head.track);
                    printf("%13d\t%11d\n", task[i].track, temp);

                    head.track = task[i].track;
                    head.seek_length += temp;
                    break;
                }
            }
        }

        temp_head++;
    }

    printf("Total seek length: %d.\n", head.seek_length);
    printf("Average seek length: %.1f.\n", 1.0 * head.seek_length/task_n);
}
Bian~
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LabWeeK2
03-11
在本周的实验“LabWeeK2”中，我们将深入探讨C++编程语言的核心概念和技术。C++是一种强大且灵活的面向对象编程语言，广泛应用于系统软件、游戏开发、嵌入式系统以及高性能计算等多个领域。这个实验室主要关注C++的...
操作系统-CLOCK置换算法
热门推荐
qq_51781828的博客
05-09 2万+
CLOCK置换算法： 是一种LRU的近似算法，是一种性能和开销较均衡的算法。由于LRU算法需要较多的硬件支持，采用CLOCK置换算法只需相对较少的硬件支持。又称为最近未用算法（NRU） 简单的CLOCK置换算法 1.实现方法： （1）为每个页面设置一个访问位，再将内存中的页面都通过链接指针链接成一个循环队列 （2）当某页被访问时，其访问位置为1 （3）当需要淘汰一个页面时，只需检查页的访问位：如果是0，选择此页换出；如果是1，将它置0，暂不换出，继续检查下一个页面 （4）若第一轮扫描中所有页.
页面置换算法之CLOCK算法和改进型CLOCK算法
D97756228的博客
06-19 1万+
页面转换算法，CLOCK置换算法和改进型CLOCK置换算法算法步骤
Clock简单算法自我理解总结，超详细
醉瑾_的博客
04-29 4035
Clock简单算法自我理解总结。 当页面队列的队头页面需要进入物理块时： 先检查物理块： ①若在物理块（内存）中能找到，则指针的位置不能变，将物理块中对应的页面的访问位设置为 1。 ②若在物理块中找不到（缺页）： （1）检查物理块中的页面是否有访问位为0的页面，若有，则指针从当前位置按正确方向（由题目决定，低地址到高地址或者高地址到低地址）开始移动到此页面在物理块中的位置，并且指针之前经过的页面访问位都设置为0，队头页面访问位设置为1，并将此页面置换出来，指针在按正确方向移一位。 （2）若物理块中无访问位为
操作系统Clock算法
shenhaizpg的博客
05-08 1万+
Clock算法 Clock算法的简介 由于LRU算法对于硬件要求很高，它的近似算法通常是更好的选择，Clock算法就是用的比较多的一种LRU近似算法。 Clock算法的理解 话不多说，直接进入正题！ 简单Clock置换算法 例题：页面流 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1 在3个物理块下的置换过程。 相比起其他算法，Clock算法需要一个指针，简单理解就是指针指向哪里页面就插入哪里。 比如在初始状态时指针指向第一个物理块，页面7便插入第一个物理块，同时指针下移，那
磁盘调度算法
清欢Viki的博客
05-08 3424
需求分析 分别实现先到先服务调度(FCFS)磁盘调度算法、最短寻道时间优先算法(SSTF)、“电梯”调度算法（SCAN算法）、C-SCAN算法、LOOK调度算法和C-LOOK调度算法 概要设计 1.先到先服务调度(FCFS)磁盘调度算法 按照磁道的访问顺序依次访问每个磁道。 2.最短寻道时间优先算法(SSTF) 从指定磁道，依次访问距离本磁道最近的磁道。 3.“电梯”调度算法（S...
SI_LabWeek7:是的实验周7
04-29
SI_LabWeek7 SI实验第7周使用以下方法完成： html作为接收用户输入的表单 servlet作为控制器 jsp作为输出页面 一个实现ServletContextListener进行数据库初始化的侦听器 web.xml作为部署描述符，其中包含servlet，...
SSTF-CLOOK-LOOK:这正在SSTF，CLOOK，LOOK上实现C ++程序
04-22
SSTF-CLOOK-LOOK 这正在SSTF，CLOOK，LOOK上实现C ++程序
第五章 I/O管理 十、磁盘调度算法（FCFS、SSTF、SCAN、C-SCAN、C-LOOK）
最新发布
icbbm的博客
11-01 3496
根据进程请求访问磁盘的先后顺序进行调度。SSTF算法会优先处理的磁道是与当前磁头最近的磁道。可以保证每次的寻道时间最短，但是并不能保证总的寻道时间最短。(其实就是贪心算法的思想，只是选择眼前最优，但是总体未必最优)SSTF算法会产生饥饿的原因在于:磁头有可能在一个小区域内来回来去地移动。为了防止这个问题，可以规定，只有磁头移动到最外侧磁道的时候才能往内移动，移动到最内侧磁道的时候才能往外移动。这就是扫描算法（SCAN)的思想。由于磁头移动的方式很像电梯，因此也叫电梯算法。
磁盘调度
yqajsj的博客
11-23 442
磁盘访问时间 磁盘访问时间=寻道时间Ts+旋转延迟时间+传输时间 寻道时间：磁臂（磁头）移动到指定磁道上所经历的时间 旋转延迟时间：指定扇区移动到磁头下面所经历的时间，1/(2r) 传输时间：把数据从磁盘读出或向磁盘写入数据所经历的时间，b/(rN) 先来先服务FCFS 按顺序处理请求；公平对待所有进程；在有很多进程的情况下，接近随即调度的性能。 最短寻道时间优先SSTF 选择从磁...
操作系统学习之用C语言模拟CLOCK算法
RongLin02的博客
06-06 2001
CLOCK算法 C语言 操纵系统
【基础】《操作系统》学习笔记（B站王道考研）（2）
m0_51221102的博客
12-30 3002
第三章 内存的基础知识 内存是用于存放数据的硬件。程序执行前需要先放到内存中才能被CPU处理。 每个内存地址对应一个存储单元。 如果计算机“按字节编址”则每个存储单元大小为1字，即1B，即8个二进制位 如果字长为16位的计算机“按字编址”则每个存储单元大小为1个字：每个字的大小为16个二进制位 几个常用的数量单位（字节）： 210 = 1K、220 = 1M、230 = 1G 指令的工作原理：操作码+若干参数（可能含地址参数） 相对地址又称逻辑地址，绝对地址又称物理地址。 从写程序到程序运行： 编辑源代码
用c语言写一个look算法,LOOK和C LOOK调度算法图解
weixin_39652154的博客
05-23 1768
就像SCAN调度算法一样, 除了不同之处在于, 在该调度算法中, 当在该方向上不再有请求时, 磁盘的臂停止向内(或向外)移动。该算法试图克服SCAN算法的开销, 该开销迫使磁盘臂沿一个方向移动到最后, 而不管是否知道该方向上是否存在任何请求。例子考虑以下具有100个磁道的磁盘的磁盘请求顺序98, 137, 122, 183, 14, 133, 65, 78头指针从54开始并向左移动。使用LOOK调...
4.2.2 OS之磁盘调度算法（FCFS、SSTF、SCAN、LOOK、S-SCAN、C-LOOK）
Lianuuu的博客
07-10 1384
文章转自：4.2.2 OS之磁盘调度算法（FCFS、SSTF、SCAN、LOOK、S-SCAN、C-LOOK）_BitHachi的博客-CSDN博客_look算法目录0.思维导图1.一次磁盘读/写操作需要的时间2.先来先服务(FCFS)3.最短寻找时间优先算法（SSTF）4.扫描算法（SCAN）5.LOOK算法6.循环扫描算法（S-SCAN）7.C-LOOK算法...
磁盘调度算法——FCFS、SSTF、SCAN、CSCAN、LOOK、CLOOK
Baiyi_destroyer的博客
07-08 1万+
为了减少对文件的访问时间，应采用一种最佳的磁盘调度算法，以使各进程对磁盘的平均访问时间最少。由于在访问磁盘时主要是寻道时间。因此，磁盘调度的目标是使磁盘的平均寻道时间最少。 一.先来先服务（FCFS） 1.方法 根据进程请求访问磁盘的先后顺序进行调度 2.优点 公平、简单、每个进程请求都能依次得到处理，不会出现某一进程的请求长期得不到满足。 3.缺点 平均寻道时间有点长，适用于磁盘I/O进程数目较少的场合 4.举例 从100号磁道访问 FCFS调度算法 被访问的下一个磁道号 移..
fat998
KKiseki的博客
06-14 165
编写一个 C 程序模拟实现课件 Lecture25 中的硬盘磁头调度算法，包括FCFS、SSTF、SCAN 和 C-LOOK 调度策略。分析上述实验结果。磁盘为现代计算机系统提供大量外存，容量以GB计数，结构如下所示。 每一层称为一个柱面，共有数千个柱面。每个柱面分有若干个扇区。每个扇区有若干个磁道。数据可以理解为储存在某个柱面的某个扇区的某个磁道上。 在通电后磁盘高速旋转每秒约转60~250次。 读取和写入数据时，磁头要移动到对应的柱面，所需时间称为寻道时间 选择磁头到目标扇区的时间称为选择延迟 本实验仅
【操作系统】磁盘调度算法（FCFS、SSTF、SCAN 和 C-LOOK 调度策略）
MaxwellWong
06-15 8981
实验内容：硬盘调度由于内存通常太小而且不能永久保存所有数据和程序，因此计算机系统必须提供外存来备份内存。现代计算机系统采用磁盘（硬盘）作为信息（程序与数据）的主要在线存储介质。换句话说，硬盘或磁盘为现代计算机系统提供大量外存。磁盘是表面涂有磁性物质的物理盘片，通过磁头（导体线圈）从磁盘存取数据，在读/写期间，磁头固定，磁盘在下面高速旋转。磁盘盘面上的数据存储在一组同心圆中，称为磁道。每个磁道和磁头一样宽，一个盘面上有上千个磁道。磁道又分为几百个扇区，每个扇区固定存储大小，因此越往内的扇区密度越高。磁盘地址由
操作系统概念——第12章 大容量存储器结构
LongXinKou的博客
01-07 1583
文章目录1. 大容量存储器结构简介1.1 磁盘1.2 磁带2. 磁盘结构3. 磁盘附属4. 磁盘调度4.1 FCFS调度4.2 SSTF调度4.3 SCAN调度4.3 CSCAN调度4.4 LOOK(CLOOOK)调度 1. 大容量存储器结构简介 1.1 磁盘 磁道： 磁盘片表面被逻辑地划分成圆形磁道。 扇区： 磁道进一步划分为扇区 柱面： 位于同一磁臂位置的磁道集合 定位时间： 定位时间由寻道时间（移动磁臂到所要柱面） 和 旋转等待时间（等待所要扇区到达磁臂下） 两部分组成 磁头碰撞： 磁头与磁盘表面接触
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值