精华内容
下载资源
问答
  • 模拟电梯调度算法
    2021-07-20 01:54:01

    #include #define null 0

    #define len sizeof(struct cidaohao)

    struct cidaohao

    {

    struct cidaohao *pre;

    int num;

    struct cidaohao *next;

    };

    FCFS(array)

    int array[50];

    {int i,j,sum=0;

    printf("nFCFS : ");

    for(i=1;array[i]!=-1;i++)

    {

    printf(" %d ",array[i]);

    }

    i=0;

    for(i=0,j=1;array[j]!=-1;i++,j++)

    {

    if(array[i]>array[j]) sum+=(array[i]-array[j]);

    else sum+=(array[j]-array[i]);

    }

    return(sum);

    }

    SSTF(head,now)

    struct cidaohao *head;

    int now;

    {struct cidaohao *p,*lp,*rp;

    int sum=0,front,behind;

    p=head;

    printf("nSSTF :");

    while(p->num!=now) p=p->next;/* */

    lp=p->pre;

    rp=p->next;

    do

    {

    if(p->next!=null&&p->pre!=null)

    {front=p->num-lp->num;

    behind=rp->num-p->num;

    if(front>=behind)

    {

    sum+=behind;

    p=rp;

    printf(" %d ",p->num);

    rp=p->next;

    }

    else

    {

    sum+=front;

    p=lp;

    printf(" %d ",p->num);

    lp=p->pre;

    }

    }

    else

    {

    if(p->next==null)

    { while(lp->num!=0)

    {

    sum+=p->num-lp->num;

    p=lp;

    printf(" %d ",p->num);

    lp=p->pre;

    }

    return(sum);

    }

    if(p->pre==null)

    {

    while(rp->num!=0)

    {

    sum+=rp->num-p->num;

    p=rp;

    printf(" %d ",p->num);

    rp=p->next;

    }

    return(sum);

    }

    }

    }while(p->next!=null||p->pre!=null);

    }

    SCAN(head,n,m)

    struct cidaohao *head;

    int n,m;

    {struct cidaohao *p,*pp;

    int sum=0;

    printf("nSCAN : ");

    p=head;

    while(p->num!=m) p=p->next;/* */

    pp=p;

    if(n{while(pp->next!=null)

    {

    sum+=pp->next->num-pp->num;

    pp=pp->next;

    printf(" %d ",pp->num);

    }

    sum+=pp->num-p->pre->num;

    pp=p->pre;

    if(pp->num==0) return(sum);

    else

    {while(pp->pre!=null)

    {

    printf(" %d ",pp->num);

    sum+=pp->num-pp->pre->num;

    pp=pp->pre;

    }

    printf(" %d ",pp->num);

    return(sum);

    }

    }

    else

    {

    while(pp->pre!=null)

    {

    sum+=pp->num-pp->pre->num;

    pp=pp->pre;

    printf(" %d ",pp->num);

    }

    sum+=p->next->num-pp->num;

    pp=p->next;

    if(pp->num==0) return(sum);

    else

    {while(pp->next!=null)

    {

    printf(" %d ",pp->num);

    sum+=pp->next->num-pp->num;

    pp=pp->next;

    }

    printf(" %d ",pp->num);

    return(sum);

    }

    }

    }

    main()

    {

    FILE *fp;

    char pt;

    char str[10];

    int cidao[100],i,j=1,count1=0,count2=0,count3=0,last,space=0;

    struct cidaohao *p1,*p2,*new,*head;/* */

    struct cidaohao *p,*lp,*rp;

    for(i=0;i<50;i++) cidao[i]=-1;

    i=0;

    fp=fopen("cipan.txt","r+");/* */

    if(fp==NULL)

    {

    printf("Cann't open this file ");

    exit(0);

    }

    printf("nPlease input cidaohao now : ");

    scanf("%d",&cidao[0]);

    while((pt=fgetc(fp))!=EOF)/* */

    {

    if(pt>='0'&&pt<='9')

    {

    str[i]=pt;i++;

    space=0;

    }

    else

    {

    if(pt==' '||pt=='n')

    {if(space==1) break;

    else

    {str[i]='0';

    cidao[j]=atoi(str);

    if(pt=='n') break;

    else

    {

    space=1;

    j++;

    i=0;

    }

    }

    }

    }

    }/* */

    if(pt==EOF) {str[i]='0';cidao[j]=atoi(str);}

    fclose(fp);

    i=0;

    count1=FCFS(cidao);/* */

    printf("nThe Total : %d n",count1);

    p1=p2=head=(struct cidaohao* )malloc(len);/* */

    p1->pre=null;

    p1->num=cidao[0];

    p1->next=null;

    i=1;

    while(cidao[i]!=-1)

    { if(cidao[i]num)/* */

    {

    p1=(struct cidaohao *)malloc(len);

    p1->next=head;

    p1->pre=null;

    p1->num=cidao[i];

    head->pre=p1;

    head=p1;

    }

    else

    {

    while(p1->next!=null&&p1->num<=cidao[i])/* */

    { p2=p1;

    p1=p1->next;

    }

    if (p1->num>cidao[i])/* */

    {

    new=(struct cidaohao*)malloc(len);

    new->num=cidao[i];

    new->next=p1;

    new->pre=p2;

    p1->pre=new;

    p2->next=new;

    }

    else

    {/* */

    new=(struct cidaohao*)malloc(len);

    new->num=cidao[i];

    new->next=null;

    new->pre=p1;

    p1->next=new;

    }

    p1=head;/* */

    }

    i++;/* */

    }

    count2=SSTF(head,cidao[0]);

    printf("nThe Total : %d ",count2);

    printf("nnPleast input last cipanhao : ");

    scanf("%d",&last);

    count3=SCAN(head,last,cidao[0]);

    printf("nThe Total : %d n",count3);

    }

    更多相关内容
  • 操作系统课程设计-模拟电梯调度算法 实现对磁盘的驱动调度.doc
  • 操作系统上机实验 模拟电梯调度算法,实现对磁盘的驱动调度 对磁盘进行移臂和旋转调度
  • 第五章 实验三模拟电梯调度算法电梯调度算法:不仅考虑到欲访问的磁道与当前磁道的距离,更优先考虑的是磁头的当前移动方向。例如:当磁头正在由里向外移动时,SCAN
  • 模拟电梯调度算法,实现对磁盘的调度。 实验目的 磁盘是一种高速、大量旋转型、可直接存取的存储设备。它作为计算机系统的辅助存储器,负担着繁重的输入输出任务,在多道程序设计系统中,往往同时会有若干个要求...

    实验内容

    • 模拟电梯调度算法,实现对磁盘的调度。

    实验目的

    • 磁盘是一种高速、大量旋转型、可直接存取的存储设备。它作为计算机系统的辅助存储器,负担着繁重的输入输出任务,在多道程序设计系统中,往往同时会有若干个要求访问磁盘的输入输出请示等待处理。系统可采用一种策略,尽可能按最佳次序执行要求访问磁盘的诸输入输出请求,这就叫磁盘调度,使用的算法称磁盘调度算法。磁盘调度能降低为若干个输入输出请求服务所须的总时间,从而提高系统效率。本实验要求学生模拟设计一个磁盘调度程序,观察磁盘调度程序的动态运行过程。

    实验原理

    • 模拟电梯调度算法,对磁盘调度。
      磁盘是要供多个进程共享的存储设备,但一个磁盘每个时刻只能为一个进程服务。
      当有进程在访问某个磁盘时,其他想访问该磁盘的进程必须等待,直到磁盘一次工作结束。
      当有多个进程提出输入输出请求处于等待状态,可用电梯调度算法从若干个等待访问者中选择一个进程,让它访问磁盘。当存取臂仅需移到一个方向最远的所请求的柱面后,如果没有访问请求了,存取臂就改变方向。

    完整代码+测试

    import java.util.Comparator;
    import java.util.LinkedList;
    import java.util.List;
    
    //这是一个磁头里面描述此时他在哪个下标 并且是往左方向走还是右方向
    class Head {
        public int index;
        public String direction;
    
        public Head(int index, String direction) {
            this.index = index;
            this.direction = direction;
        }
    }
    
    //这是描述一个访问磁道任务的一个类
    class MyRunnable implements Runnable {
    
        //要访问的磁道
        public int track;
        public boolean key = true;
    
        public MyRunnable(int track) {
            this.track = track;
        }
    
        @Override
        public void run() {
            System.out.print(track + " ");
        }
    }
    
    public class DiskScheduling extends Thread {
    
        //需要一个链表去存储去存储要访问磁盘的线程
        //一个count记录访问次数
        //sum去记录访问距离
        //还需要一个磁头
        //还需要一个最大磁道是多少
        private List<MyRunnable> threadList = new LinkedList<>();
        private int count;
        private int sum;
        private Head head;
        public static final int MaximumTrack = 200;
    
        //在构造函数里初始化磁头
        public DiskScheduling(int index, String direction) {
            this.head = new Head(index, direction);
        }
    
        //需要一个方法往链表为添加程序
        public void add(int[] tracks) throws InterruptedException {
    
            //创建线程 线程的名字就是他有寻找的磁道地址
    
            for (int track : tracks
                 ) {
                MyRunnable myRunnable = new MyRunnable(track);
                threadList.add(myRunnable);
            }
    
    
            //将链表按要寻道的地址进行排序
           threadList.sort(new Comparator<MyRunnable>() {
               @Override
               public int compare(MyRunnable o1, MyRunnable o2) {
                   return o1.track - o2.track;
               }
           });
    
            this.start();
            this.join();
            //worke();
        }
    
        @Override
        public void run() {
    
            while (this.count != threadList.size()) {
                while (this.head.direction.equals("right")) {
    
                    for (MyRunnable m : threadList
                            ) {
                        if (m.track >= head.index && m.key) {
                            count++;
                            int distance = m.track - this.head.index;
                            sum += distance;
                            this.head.index = m.track;
                            m.key = false;
                            m.run();
                            //threadList.remove(m);
                        }
                        this.head.direction = "left";
                    }
    
                }
    
    
                while (this.head.direction.equals("left")) {
    
                    for (int i = threadList.size() - 1; i >= 0; i--) {
    
                        if (threadList.get(i).track > this.head.index || !threadList.get(i).key) {
                            continue;
                        }
    
                        //此时表示找到了比现在下标小的
                        this.count++;
                        int distance = this.head.index - threadList.get(i).track;
                        sum += distance;
                        this.head.index = threadList.get(i).track;
                        threadList.get(i).key = false;
                        this.threadList.get(i).run();
                        //this.threadList.remove(this.threadList.get(i));
                    }
    
                    this.head.direction = "right";
                }
            }
        }
    
        /* //需要一个方法去执行程序
        private void worke() throws InterruptedException {
    
            while (! this.threadList.isEmpty()) {
    
                while (this.head.direction.equals("right")) {
                    synchronized (this) {
                        for (Thread t : this.threadList
                        ) {
                            if (Integer.parseInt(t.getName()) > this.head.index) {
                                this.count++;
                                int distance = Integer.parseInt(t.getName()) - this.head.index;
                                sum += distance;
                                this.head.index = Integer.parseInt(t.getName());
                                t.start();
                                t.join();
                                this.threadList.remove(t);
                            }
                        }
                    }
                    this.head.direction = "left";
                }
    
                while (this.head.direction.equals("left")) {
                    synchronized (this) {
                        for (int i = this.threadList.size() - 1; i >= 0; i--) {
                            if (Integer.parseInt(this.threadList.get(i).getName()) > this.head.index) {
                                continue;
                            }
    
                            //此时表示找到了比现在下标小的
                            this.count++;
                            int distance = this.head.index - Integer.parseInt(this.threadList.get(i).getName());
                            sum += distance;
                            this.head.index = Integer.parseInt(this.threadList.get(i).getName());
                            this.threadList.get(i).start();
                            this.threadList.get(i).join();
                            this.threadList.remove(this.threadList.get(i));
                        }
                    }
                    this.head.direction = "right";
                }
    
            }
        }*/
    
        //需要一个方法返回平均寻道长度
        public float averageSeekLength () {
    
            return (float) ((this.sum * 1.0) / this.count);
        }
    }
    
    
    
    
    
    • 测试
      假设磁盘有200个磁道,用C语言随机函数随机生成一个磁道请求序列(不少于15个)放入模拟的磁盘请求队列中,假定当前磁头在100号磁道上,并向磁道号增加的方向上移动。请给出按电梯调度算法进行磁盘调度时满足请求的次序,并计算出它们的平均寻道长度。
    import java.util.Arrays;
    import java.util.Random;
    
    public class DiskTest {
    
        public static void main(String[] args) throws InterruptedException {
    
            //需要在创建磁盘调度的时候说明此时磁头的位置和方向
            DiskScheduling diskScheduling = new DiskScheduling(100, "right");
    
            //生成15个随机数
            int[] nums = new int[15];
            for (int i = 0; i < 15; i++) {
                Random random = new Random();
                nums[i] = random.nextInt(DiskScheduling.MaximumTrack);
            }
    
            System.out.println("初始申请序列:");
            System.out.println(Arrays.toString(nums));
    
            System.out.println("=========================");
    
            System.out.println("电梯调度执行顺序");
            diskScheduling.add(nums);
    
            System.out.println();
            //等线程执行完毕再去打印寻道
            diskScheduling.join();
            System.out.print("平均寻道为:");
            System.out.println(diskScheduling.averageSeekLength());
        }
    }
    
    
    • 结果
      在这里插入图片描述
    展开全文
  • #include #include #include #include typedef struct _proc { char name[32]; /*定义进程名称*/ int team; /*定义柱面号*/ int ci; /*定义磁道面号*/ int rec; /*定义记录号*/
  • 模拟电梯调度算法实现对磁盘的驱动调度.pdf
  • 主要介绍了Python模拟简单电梯调度算法,涉及Python线程、队列、时间延迟等相关操作技巧,需要的朋友可以参考下
  • 模拟电梯调度算法,实现对磁盘的驱动调度。.docx
  • 模拟电梯调度算法,实现对磁盘的驱动调度。.doc
  • 操作系统实验:驱动调度 模拟电梯调度算法 C语言实现

    一:实验内容

    模拟电梯调度算法,对磁盘进行移臂和旋转调度。


    二.实验题目

    (1).“驱动调度”进程和“接收请求”进程能否占有处理器运行,取决于磁盘的结束中断信 号和处理器调度策略。在实验中可用随机数来模拟确定这两个进程的运行顺序,以代替中断 处理和处理器调度选择的过程。因而,程序的结构可参考下图:

    (2).“接收请求”进程建立一张“请求 I/O”表,指出访问磁盘的进程要求访问的物理 地址,表的格式为:

    假定某个磁盘组共有 200 个柱面,由外向里顺序编号(0—199),每个柱面上有 20 个 磁道,编号为 0—19,每个磁道分成 8 个物理记录,编号 0—7。进程访问磁盘的物理地址 可以用键盘输入的方法模拟得到。下图 是“接收请求”进程的模拟算法。


    三.代码实现

    #include<stdio.h>
    #include<stdlib.h>
    
    #define IOnum 10 //模拟IO表最大长度
    struct IO_table
    {
        char Pname; //进程名
        int Zhu;  //柱面号
        int Ci; //磁头号
        int Sha; //扇区号(物理记录)
    }IO_table[IOnum],current; //current用于存储每次调度前的上一次访问磁盘的位置
    
    int more_current[IOnum] = {-1}; //存储柱面号大于当前柱面号的数组
    int more_length = 0;//more数组有效长度
    int less_current[IOnum] = {-1}; //存储柱面号小于当前柱面号的数组
    int less_length = 0; //less数组有效长度
    int processNum = 0; //存储当前IO表中进程总数
    int YB_direct = 1; //移臂方向标识符 1表示向内up 0表示向外down  默认向内为1
    void IO_table_init() //IO请求表初始化
    {
        int i = 0;  
        for (i; i < IOnum; i++)//初始化未使用时表内各项数据均为-1
        {
            IO_table[i].Pname = '-1';
            IO_table[i].Zhu = -1;
            IO_table[i].Ci = -1;
            IO_table[i].Sha = -1;
            more_current[i] = -1;
            less_current[i] = -1;
        }
        
        //模拟预装入8条请求,顺序任意
        IO_table[0].Pname = 'A'; IO_table[0].Zhu = 58; IO_table[0].Ci = 2; IO_table[0].Sha = 1;//第一个请求
        IO_table[1].Pname = 'B'; IO_table[1].Zhu = 55; IO_table[1].Ci = 3; IO_table[1].Sha = 2;//第二个请求
        IO_table[2].Pname = 'C'; IO_table[2].Zhu = 39; IO_table[2].Ci = 4; IO_table[2].Sha = 3;//第三个请求
        IO_table[3].Pname = 'D'; IO_table[3].Zhu = 38; IO_table[3].Ci = 5; IO_table[3].Sha = 4;//第四个请求
        IO_table[4].Pname = 'E'; IO_table[4].Zhu = 18; IO_table[4].Ci = 6; IO_table[4].Sha = 5;//第五个请求
        IO_table[5].Pname = 'F'; IO_table[5].Zhu = 160; IO_table[5].Ci = 7; IO_table[5].Sha = 6;//第六个请求
        IO_table[6].Pname = 'G'; IO_table[6].Zhu = 150; IO_table[6].Ci = 8; IO_table[6].Sha = 7;//第七个请求
        IO_table[7].Pname = 'H'; IO_table[7].Zhu = 184; IO_table[7].Ci = 9; IO_table[7].Sha = 0;//第八个请求
        //模拟预设置 current的值
        current.Pname = '-1'; current.Zhu = 100; current.Ci = 1; current.Sha = 0;
        
    } 
    
    void show_IO_table()  //打印当前请求IO表
    {
        printf("----------------------[I/O请求表]------------------------\n");
        int i = 0;
        for (i; i < IOnum; i++)
        {                    
            if (IO_table[i].Sha != -1)  //打印非空项
            {
                printf("【进程名】:%c", IO_table[i].Pname);
                printf("  【柱面号】:%3d", IO_table[i].Zhu);
                printf("  【磁头号】:%d", IO_table[i].Ci);
                printf("  【扇区号】:%d\n", IO_table[i].Sha);
            }
        }
        printf("----------------------[I/O请求表]------------------------\n");
    }
    
    int find_inLocation()  //寻找当前IO表中第一个空闲位置,未找到则返回-1
    {    
        int flag = -1;
        int i = 0;
        for (i; i < IOnum; i++)
        {
            if (IO_table[i].Zhu == -1)  //找到IO表中第一个空下标保存并退出
            {
                flag = i;
                break;
            }
        }
        return flag;
    }
    
    void show_current() //打印选中的current进程,模拟其访问磁盘
    {
        printf("【提示】当前选中进程:");
        printf("【进程名】:%c", current.Pname);
        printf("  【柱面号】:%3d", current.Zhu);
        printf("  【磁头号】:%d", current.Ci);
        printf("  【扇区号】:%d\n", current.Sha);
    }
    
    void show_updown()//打印方向
    {
        if (YB_direct == 1)
            printf("【方向】:up(内)\n");
        if(YB_direct==0)
            printf("【方向】:down(外)\n");
    }
    
    void add_IO_request() //添加新请求
    {
        int flag = -1; //用于标识插入IO表位置
        flag = find_inLocation();
        if (flag != -1)
        {
            printf("【提示】请依次输入【进程名】-【柱面号】-【磁头号】-【扇区号】:\n");
            scanf("%s%d%d%d", &IO_table[flag].Pname, &IO_table[flag].Zhu, &IO_table[flag].Ci, &IO_table[flag].Sha);
        }
        else
        {
            printf("【提示】IO表已满");
        }
        show_IO_table();//打印修改后的IO表
    }
    
    int find_zhu(int X) //寻找是否有与X相同的柱面  找到返回其在IO表下标,未找到返回-1
    {
        int flag = -1;
        int i = 0;
        for (i; i < IOnum; i++)
        {
            if (IO_table[i].Zhu ==X) //两柱面相同
            {
                flag = i;  //找到符合条件的第一个即返回下标
                break;
            }
        }
        return flag;
    }
    
    void sort(int a[],int count)// 直接插入排序 count为数组有效长度,排序为从小到大
    {
            int i, j, temp;
            for (i = 1; i < count; i++)
            {
                temp = a[i];
                j = i - 1;
                while (a[j] > temp && j >= 0)
                {
                    a[j + 1] = a[j];
                    j--;
                }
                if (j != (i - 1))
                    a[j + 1] = temp;
            }
    }
    void divide_IO_table() //将IO表按current大小一分为二
    {
        int i = 0, j = 0,t=0;
        for (t; t < processNum; t++) //当t小于IO表有效长度时
        {
            if (IO_table[t].Zhu > current.Zhu)  //找到柱面号大于current的保存
            {
                more_current[i] = IO_table[t].Zhu; //添加
                i++;
            }
            if (IO_table[t].Zhu < current.Zhu) //找到柱面号小于current的保存
            {
                less_current[j] = IO_table[t].Zhu;
                j++;
            }
        }
        more_length = i;//保存more有效长度
        less_length = j ;//保存less有效长度
    }
    void update_IO_table() //更新IO表信息
    {
        int flag = find_zhu(current.Zhu);//用于标识删除位置
        int i = 0;
        if (flag == IOnum - 1)  //若删除的是最后一个
        {
            IO_table[flag].Pname = '-1'; IO_table[flag].Zhu = -1; IO_table[flag].Ci = -1; IO_table[flag].Sha = -1;
        }
        else 
        {
            for (i = flag; i < IOnum - 1; i++) //删除非最后一个,数组整体前移
            {
                IO_table[i].Pname = IO_table[i + 1].Pname;
                IO_table[i].Zhu = IO_table[i + 1].Zhu;
                IO_table[i].Ci = IO_table[i + 1].Ci;
                IO_table[i].Sha = IO_table[i + 1].Sha;
            }
        }
    }
    void reset_para()//重置各项工作参数
    {
        more_length = 0; less_length = 0;
        int i = 0;
        for (i; i < IOnum; i++)
        {
            more_current[i] = -1;
            less_current[i] = -1;
        }
    }
    void scheduling() //调度程序
    {
        int i = 0;
        //先检查此时IO表中请求总数
        processNum = find_inLocation();
        if (processNum == 0)  //请求表为空
        {
            printf("【提示】此时IO表中无等待进程,已退出\n");
        }
        //更新current
        else  //请求表不为空
        {
            if (find_zhu(current.Zhu) != -1) //找到与current相同柱面的请求
            {
                //更新current
                current.Pname = IO_table[find_zhu(current.Zhu)].Pname; //进程名
                current.Ci = IO_table[find_zhu(current.Zhu)].Ci; //磁头号
                current.Sha = IO_table[find_zhu(current.Zhu)].Sha; //扇区号
            }
            else  //未找到相同柱面,采用电梯算法寻找一个合理请求
            {
                divide_IO_table();//以current为基准划分IO表,且保存more_current/less_current可作为端点判断
                //将划分的两个数组进行排序
                sort(more_current, more_length);
                sort(less_current, less_length);
                if (YB_direct == 1) //移臂为1表示此时向内
                {
                    if (more_length != 0) //即存在比current还大的柱面号
                    {
                        //更新current
                        current.Pname = IO_table[find_zhu(more_current[0])].Pname;//进程名
                        current.Zhu = IO_table[find_zhu(more_current[0])].Zhu; //柱面号
                        current.Ci = IO_table[find_zhu(more_current[0])].Ci; //磁头号
                        current.Sha= IO_table[find_zhu(more_current[0])].Sha; //扇区号
                    }
                    else  //不存在比current还大的柱面号,需变向
                    {
                        YB_direct = 0;//移臂方向改为向外
                        //按YB=1的方式更新current 模拟变向
                        current.Pname = IO_table[find_zhu(less_current[less_length - 1])].Pname; //进程名
                        current.Zhu = IO_table[find_zhu(less_current[less_length-1])].Zhu; //柱面号
                        current.Ci = IO_table[find_zhu(less_current[less_length-1])].Ci; //磁头号
                        current.Sha = IO_table[find_zhu(less_current[less_length-1])].Sha; //扇区号
                    }
                }//YB=1
                if (YB_direct == 0)//移臂为0表示此时向外
                    {
                        if (less_length != 0) //即存在比current还小的柱面号
                        {
                            //更新current
                            current.Pname = IO_table[find_zhu(less_current[less_length - 1])].Pname;//进程名
                            current.Zhu = IO_table[find_zhu(less_current[less_length - 1])].Zhu; //柱面号
                            current.Ci = IO_table[find_zhu(less_current[less_length - 1])].Ci; //磁头号
                            current.Sha = IO_table[find_zhu(less_current[less_length - 1])].Sha; //扇区号
                        }
                        else  //不存在比current还小的柱面号,需变向
                        {
                            YB_direct = 1;//移臂方向改为向内
                            //按YB=0的方式更新current 模拟变向
                            current.Pname = IO_table[find_zhu(more_current[0])].Pname; //进程名
                            current.Zhu = IO_table[find_zhu(more_current[0])].Zhu; //柱面号
                            current.Ci = IO_table[find_zhu(more_current[0])].Ci; //磁头号
                            current.Sha = IO_table[find_zhu(more_current[0])].Sha; //扇区号
                        }
                }//YB=0
            }
            //打印方向
            show_updown();
            //current已更新完-模拟访问磁盘
            show_current();//打印current
            //更新IO表,即删除此次访问项
            update_IO_table();
            //重置各项辅助参数
            reset_para();
            //打印本次执行后IO表
            show_IO_table();
        }
    }
    void main()
    {
        IO_table_init(); //初始化
        show_IO_table(); //打印初始IO请求表
        int select = -1; //选择标识符
        printf("【提示】请选择要执行的操作:(0->驱动调度:1->接收进程)");
        scanf("%d", &select);
        while (1) 
        {    
            printf("【提示】当前磁盘位置:");
            printf("【进程名】:%c", current.Pname);
            printf("  【柱面号】:%3d", current.Zhu);
            printf("  【磁头号】:%d", current.Ci);
            printf("  【扇区号】:%d\n", current.Sha);
            if(select==0)
                scheduling(); //调用驱动程序
            if (select == 1)
                add_IO_request();//接受进程
            printf("【提示】请选择要执行的操作:(0->驱动调度:1->接收进程)");
            scanf("%d", &select);
        }
        system("pause");
    }


    四.运行结果

    【初始化IO表并打印】

    【进行一次驱动调度】当前current.Zhu=100

    可发现“选中进程”已从IO请求表中移除。

     【进行一次驱动调度】当前current.Zhu=150

    观察可发现“选中进程”已从IO请求表中移除

    【进行一次接受进程】当前current.Zhu=160

    可发现模拟新请求已插入到请求表中


     五.流程图

    (1.)scheduling()调度函数

    (2).电梯调度算法

     

     

     

    展开全文
  • 设计一个以电梯调度思想为主并考虑旋转优化的程序,对磁盘进行移臂和旋转调度,对磁盘进行移臂和旋转调度。 假定某个磁盘组共有 200 个柱面,由外向里顺序编号(0—199),每个柱面上有 20 个磁道,编号为 0...
            设计一个以电梯调度思想为主并考虑旋转优化的程序,对磁盘进行移臂和旋转调度,对磁盘进行移臂和旋转调度。
            假定某个磁盘组共有 200 个柱面,由外向里顺序编号(0— 199 ),每个柱面上有 20 个磁道,编号为 0 19 ,每个磁道分成 8 个物理记录,编号 0 7 。进程访问磁盘的物理 地址可以用键盘输入的方法模拟得到。
            图 4-1 中的初始化工作包括,初始化“请求 I/O”表,置当前移臂方向为里移; 置当前位置为 0 号柱面,0 号物理记录。程序运行前可假定“请求 I/O”表中已经有如干个进程等待访问磁盘。
            在模拟实验中,当选中一个进程可以访问磁盘时,并不实际地启动磁盘,而用显示:“请求 I/O表;当前移臂方向;当前柱面号,物理记录号来代替图 4-3 中的“启动磁盘” 这项工作

     

     

     

    /*模拟电梯调度算法,实现对磁盘的驱动调度。*/
    
    
    #include<iostream>
    #include<string>
    #include<iomanip>
    #include<cmath>
    
    using namespace std;
    
    typedef struct request {//请求I/O表
    	string name;//进程名
    	int cylinder;//柱面号
    	int magnetic;//磁道号
    	int record;//物理记录号
    }Request;
    
    int tableNum = 0;
    Request Table[100];
    Request current;
    
    void InitCurrent() {//初始化初始进程
    	current.name = "初始进程";
    	current.cylinder = 0;
    	current.magnetic = 0;
    	current.record = 0;
    
    	//假定表中已经存在的请求
    	Table[0].name = "请求A";
    	Table[0].cylinder = 1;
    	Table[0].magnetic = 5;
    	Table[0].record = 0;
    	Table[1].name = "请求B";
    	Table[1].cylinder = 10;
    	Table[1].magnetic = 4;
    	Table[1].record = 2;
    	Table[2].name = "请求C";
    	Table[2].cylinder = 66;
    	Table[2].magnetic = 3;
    	Table[2].record = 6;
    	Table[3].name = "请求D";
    	Table[3].cylinder = 30;
    	Table[3].magnetic = 4;
    	Table[3].record = 5; 
    	Table[4].name = "请求E";
    	Table[4].cylinder = 3;
    	Table[4].magnetic = 1;
    	Table[4].record = 3;
    	Table[5].name = "请求F";
    	Table[5].cylinder = 77;
    	Table[5].magnetic = 0;
    	Table[5].record = 1;
    }
    
    void CountTable() {
    	int i;
    	for (i = 0; Table[i].cylinder != NULL; i++) {}
    	tableNum = i;
    }
    
    int FindNearest() {
    	int min = 8, k;//最小距离,最小距离的编号
    	int distance = 8;//当前距离
    	for (int i = 0; i < tableNum; i++) {
    		if (Table[i].cylinder == current.cylinder) {
    			distance = abs(Table[i].record - current.record);
    			if (distance < min) {
    				min = distance;
    				k = i;
    			}
    		}
    	}
    	return k;
    }
    
    void print_io() {//打印请求I/O表
    	cout << "--------------------------请求I/O表---------------------------" << endl;
    	cout << "进程名:         柱面号:         磁道号:         物理记录号:" << endl;
    	for (int i = 0; i < tableNum; i++) {
    		cout << setfill(' ') << setw(6) << Table[i].name << setfill(' ') << setw(15) << Table[i].cylinder << setfill(' ') << setw(16) << Table[i].magnetic << setfill(' ') << setw(17) << Table[i].record << endl;
    	}
    	cout << "--------------------------------------------------------------" << endl;
    }
    
    void PrintProcess(bool direction) {
    	string directionStr;
    	if (direction == 1) {
    		directionStr = "up";
    	}
    	else {
    		directionStr = "down";
    	}
    	cout << "------------------------选中的进程信息------------------------" << endl;
    	cout << "进程名:         柱面号:         物理记录号:         方向:" << endl;
    	cout << setfill(' ') << setw(6) << current.name << setfill(' ') << setw(15) <<current.cylinder << setfill(' ') << setw(16) << current.record << setfill(' ') << setw(17) << directionStr << endl;
    	cout << "--------------------------------------------------------------" << endl;
    }
    
    int CylinderJudge() {//遍历请求表判断是否有与当前柱面号相同的访问者
    	for (int i = 0; i < tableNum; i++) {
    		if (Table[i].cylinder == current.cylinder)
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    
    int CylinderMax() {
    	int differenceC=200;//柱面号之差
    	int t = 8;//最小物理记录
    	int k;//选择出的最小柱面号
    	int a;//选择出的最佳请求号
    	for (int i = 0; i < tableNum; i++) {
    		if (abs(Table[i].cylinder - current.cylinder) < differenceC && Table[i].cylinder > current.cylinder) {
    			differenceC = Table[i].cylinder - current.cylinder;
    		}
    		k = current.cylinder + differenceC;
    	}
    	for (int i = 0; i < tableNum; i++) {
    		if (Table[i].cylinder == k && Table[i].record < t) {
    			t = Table[i].record;
    			a = i;
    		}
    	}
    	if (differenceC == 200) {//没有比当前柱面号大的访问请求
    		return -1;
    	}
    	else {
    		return a;
    	}
    }
    
    int CylinderMin() {
    	int differenceC = 200;//柱面号之差
    	int t = 8;//最小物理记录
    	int k;//选择出的最大柱面号
    	int a;//选择出的最佳请求号
    	for (int i = 0; i < tableNum; i++) {
    		if (abs(Table[i].cylinder - current.cylinder) < differenceC && Table[i].cylinder < current.cylinder) {
    			differenceC = abs(Table[i].cylinder - current.cylinder);
    		}
    		k = current.cylinder - differenceC;
    	}
    	for (int i = 0; i < tableNum; i++) {
    		if (Table[i].cylinder == k && Table[i].record < t) {
    			t = Table[i].record;
    			a = i;
    		}
    	}
    	if (differenceC == 200) {//没有比当前柱面号小的访问请求
    		return -1;
    	}
    	else {
    		return a;
    	}
    }
    
    void PopProcess(int process) {
    	for (int i = process; i < tableNum; i++) {
    		Table[i] = Table[i + 1];
    	}
    	tableNum--;
    }
    
    int Scan(){
    	int process;//选择的进程号
    	bool direction =1; //方向0=out,1=in,默认移臂方向为向里移
    	print_io();
    	if (tableNum == 0) {//无等待访问者
    		cout << "无等待访问者!!!" << endl;
    		return 0;
    	}
    	else//有等待访问者
    	{
    		if (CylinderJudge() != -1) {//有与当前柱面号相同的访问者
    			process = FindNearest();
    		}
    		else//没有与当前柱面号相同的访问者
    		{
    			if (direction == 1) {//移臂方向为向里
    				process = CylinderMax();
    				if (process == -1) {//没有比当前柱面号大的访问请求
    					process = CylinderMin();
    					direction = 0;
    				}
    			}
    			else {//移臂方向为向外
    				process = CylinderMin();
    				if (process == -1) {//没有比当前柱面号小的访问请求
    					process = CylinderMax();
    					direction = 1;
    				}
    			}
    		}
    		current = Table[process];
    		PrintProcess(direction);
    		PopProcess(process);
    	}
    }
    
    void Accept() {
    	int flag = 1;
    	while (flag == 1) {
    		cout << "输入:进程名、柱面号、磁道号、物理记录号" << endl;
    		cin >> Table[tableNum].name >> Table[tableNum].cylinder >> Table[tableNum].magnetic >> Table[tableNum].record;
    		tableNum++;
    		cout << "登记成功!继续登记请求按1否则按0" << endl;
    		cin >> flag;
    	}
    }
    
    void Init() {
    	float n;
    	int command=1;
    	InitCurrent();//初始化当前位置
    	CountTable();//统计IO请求表中请求数目
    	while (command == 1) {
    	cout << "输入在[0,1]区间内的一个随机数!!!" << endl;
    	cin >> n;
    	if (n > 0.5) {
    		Scan();
    	}
    	else {
    		Accept();
    	}
    	cout << "继续请按1,退出请按0" << endl;
    	cin >> command;
    	}
    }
    
    int main(){
    	Init();
    }

    运行结果:

     

     

    展开全文
  • 操作系统中模拟驱动调度 java模拟电梯调度算法实现驱动调度
  • 了解驱动调度程序的动态运行过程,理解和掌握驱动调度的职能。驱动调度能降低为若干个输入输出请求服务所需的总时间,从而提高系统功能。
  • 模拟电梯调度算法(操作系统)
  • 本实验要求模拟设计一个去驱动调度程序,观察驱动调度程序的动态运行过程,采用电梯调度算法,实现对磁盘的读写管理。先假设有5个进程等待使用磁盘,用随机数模拟接受请求,确定程序的运行顺序。 内附源码,实验流程...
  • 一. 实验内容 模拟电梯调动算法,实现对磁盘的驱动调度。 二. 实验目的 磁盘是一种高速、大容量、旋转型、可直接存取的存储...模拟电梯调度算法,对磁盘进行移臂和旋转调度 运行环境:Microsoft Visual Studio 2005
  • 此程序模拟磁盘调度算法电梯算法和最短寻道时间优先SSTF算法,电梯算法具体实现原理看图片和程序开头的介绍。采用C++语言开发,运用链表,指针实现访问。
  • 本实验要求模拟设计一个去驱动调度程序,观察驱动调度程序的动态运行过程,采用电梯调度算法,实现对磁盘的读写管理。先假设有5个进程等待使用磁盘,用随机数模拟接受请求,确定程序的运行顺序。 内附流程图
  • 电梯调度算法 4 Java版

    2010-11-06 12:33:40
    用Java写的电梯调度算法4,模拟操作系统的进程调度,图形界面
  • #include #include using namespace std; class PCB { friend class Myqueue; public: char *name; PCB* next; int times; int nums;... PCB(char *Name,PCB*Next,int Times,int Nums,char Status) ...
  • 电梯调度算法实现

    2012-05-04 15:35:31
    操作系统磁盘管理,电梯调度算法实现,源码!
  • 磁盘移臂调度过程模拟设计--电梯算法、最短寻道时间优先算法
  • #include #include #include int *Init(int arr[]) { int i = 0; srand((unsigned int)time(0)); for (i = 0; i ; i++) { arr[i] = rand() % 200 + 1; printf("%d ", arr[i]); } ... ret
  • 编程实现简单常用的磁盘驱动调度算法先来先服务(FIFO)、电梯调度算法、最短寻找时间优先算法、扫描(双向扫描)算法、单向扫描(循环扫描)算法等
  • 模拟电梯调度算法,实现对磁盘的调度。 二、实验目的 磁盘是一种高速、大量旋转型、可直接存取的存储设备。它作为计算机系统的辅助存储器,负担着繁重的输入输出任务,在多道程序设计系统中,往往同时会有若干个要求...
  • 作业调度学院:软件学院专业:软件工程班级:软件工程12-01姓名:***学号:541213460157实验一:作业调度实现FCFS和SJF调度算法【实验题目】:编写程序,实现FCFS和SJF算法,模拟作业调度过程,加深对作业调度的理解...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,868
精华内容 747
关键字:

模拟电梯调度算法