精华内容
下载资源
问答
  • 1. 银行家算法(模拟设备分配和回收的算法)  用高级语言编写一个银行家的模拟算法。  设置恰当的数据结构,有效存储数据。   输出分配过程、分配结果以及其它相关的信息。  界面友好,提示清晰。
  •  (2)设计设备分配表的结构,根据模拟的要求,自己决定必须设置的字段  (3)编程实现独占设备的静态模拟程序 copyright (C), 2014-2015, Lighting Studio. Co., Ltd. File name: Author:hxj

    实验4:独占设备的静态分配模拟

    实验内容:(1)设计设备类表的结构,根据模拟的要求,自己决定必须设置的字段

        (2)设计设备分配表的结构,根据模拟的要求,自己决定必须设置的字段

        (3)编程实现独占设备的静态模拟程序

    copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
    File name:
    Author:hxj    Version:0.1    Date:2016.11.22 
    Description:
    Funcion List: 
    *****************************************************/
    
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #define MAX_SIZE 1024
    struct equip_alloc
    {
        int num;                  //设备的绝对号
        int rnum;		      //设备的相对号
        int alloc;		      //是否分配(0/1)
        int damage;		      //是否损坏(0/1)
        char job[MAX_SIZE];	      //占用的作业名
    };
    struct equip_type
    {
        char type[MAX_SIZE];      //设备类
        int count;		      //该设备类的设备总数
        int usable_num;	      //可用设备数
        struct equip_alloc p[MAX_SIZE];     //指向设备分配表
        struct equip_type *next;        
    };
    
    typedef struct equip_type link;
    typedef link* Link;
    void creat(Link *head)              //直接赋值,可以根据newnode指向的结构体中设备类个数决定P[i]i取值,这里图个最简了
    {
        Link temp = *head;
    
        Link newnode1;
        newnode1 = (Link)malloc(sizeof(link));
        Link newnode2 = (Link)malloc(sizeof(link));
        
        newnode1->count = 1;
        newnode1->usable_num = 1;
        strcpy(newnode1->type,"disk");
    
        newnode1->p[0].num = 1001;
        newnode1->p[0].rnum = 1;
        newnode1->p[0].alloc = 0;
        newnode1->p[0].damage = 0;
        strcpy(newnode1->p[0].job,"leisure");
        
        newnode2->count = 1;
        newnode2->usable_num = 1;
        strcpy(newnode2->type,"printer");
        newnode2->p[0].num = 1001;
        newnode2->p[0].rnum = 1;
        newnode2->p[0].alloc = 0;
        newnode2->p[0].damage = 0;
        strcpy(newnode2->p[0].job,"leisure");
        printf("\n");
        temp->next = newnode1;
        newnode1->next = newnode2;
        newnode2->next = NULL;
        
    }
    
    void init(Link *head)
    {
        *head = (Link)malloc(sizeof(struct equip_type));
        (*head)->next = NULL;
    }
    void alloc(Link *head)
    {
        char type[MAX_SIZE];
        char job[MAX_SIZE];
        Link temp = (*head)->next;
        printf("input type:");
        scanf("%s",type);
        
        while(temp != NULL)
        {
            if(0 == strcmp(temp->type,type))
            {
                if(0 == temp->usable_num)
                {
                    printf("no one can be used!\n");
                    break;
                }
                else
                {
                    printf("please input job:");
                    scanf("%s",job);
                    temp->usable_num = temp->usable_num - 1;
                    temp->p[0].alloc = temp->p[0].alloc + 1;
                    strcpy(temp->p[0].job,job);
                    printf("alloc success\n");
                    getchar();
                    break;
                }
            }
            temp = temp->next;
        }
    }
    void recycle(Link *head)
    {
        int i;
        Link temp = (*head)->next;
        char type[MAX_SIZE];
        int num;
        printf("please input which type recy:");
        scanf("%s",type);
    
        while(temp != NULL)
        {
            if(0 == strcmp(temp->type,type))
            {
                printf("please input which num:");
                scanf("%d",&num);
                for(i = 0; i < temp->count; i++)
                {
                    if(temp->p[i].num == num)
                    {
                        strcpy(temp->p[i].job,"leisure");
                        temp->p[i].alloc = 0;
                        temp->usable_num++;
                        printf("rec success\n");
                    }
                }
            }
            temp = temp->next;
        }
    
    }
    void display(Link head)
    {
        int i;
        Link temp = head->next;
    
        while(temp != NULL)
        {
            printf("\t\toutput equip_type:\n");
            printf("\t\ttype\tcount\tusable_num\n");
            printf("\t\t%s\t%d\t%d\n",temp->type,temp->count,temp->usable_num); 
            printf("\t\tout put equip_alloc:\n");
            printf("\t\tnum\trnum\talloc\tdamage\tjob\n");
            for(i = 0; i < temp->count; i++)
            {
                printf("\t\t%d\t%d\t%d\t%d\t%s\n",temp->p[i].num,temp->p[i].rnum,temp->p->alloc,temp->p[i].damage,temp->p[i].job);
                
            }
        
            printf("\n");
            temp = temp->next;
        }
    }
    /*    打算加文件操作,由于是两个结构体,待完成后续更新
    void save(Link head)
    {
        Link temp = head->next;
        FILE *fp;
        int i;
    
        if((fp = fopen("/root/OS_TEST/text.txt","w")) == NULL)
        {
            printf("open error\n");
            exit(0);
        }
        while(temp != NULL)
        {
            fprintf(fp,"%s %d %d\n",temp->type,temp->count,temp->usable_num);
            temp = temp->next;
        }
        fclose(fp);
        
    }
    */
    int main()
    {
        system("clear");
        int chose;
        Link head;
        
        init(&head);
        
        creat(&head);
        
        while(1)
        {
            printf("\n\t\t       my  demo_4          \n");
            printf("\t\t**********1.exit*************\n");
            printf("\t\t**********2.alloc************\n");
            printf("\t\t**********3.recycle**********\n");
            printf("\t\t**********4.display**********\n");
            printf("\t\tplease choose:");
            scanf("%d",&chose);
            printf("\n");
            switch(chose)
            {
                case 1:
                    {
                        save(head);
                        exit(0);
                    }
                case 2:
                    {
                        system("clear");
                        alloc(&head);
                        printf("\n\t\tinput any num exit:");
                        getchar();
                        getchar();
                        break;
                    }
                case 3:
                    {
                        system("clear");
                        recycle(&head);
                        printf("\n\t\tinput any num exit:");
                        getchar();
                        getchar();
                        break;
                    }
                case 4:
                    {
                        system("clear");
                        display(head);
                        printf("\n\t\tinput any num exit:");
                        getchar();
                    
                        break;
                    }
                default:
                    break;
    
            }
            system("clear");
    
        }
        return 0;
    }


    
    大体功能实现
    如若程序有不足之处,还请留言

    展开全文
  • 模拟操作系统的进程调度,作业管理,设备分配,存储管理,来实现判别一系列作业请求队列的响应顺序的要求
  • C语言模拟实现(三)-----独占型设备分配

    千次阅读 多人点赞 2018-12-08 16:47:35
    独占型设备分配相关概念 有关独占型设备分配的相关内容,在这位老师的这篇博客(https://blog.csdn.net/dongyanxia1000/article/details/51862577)中,写的十分详细。十分感谢老师的分享。 实验环境 实验前提...

    独占型设备分配相关概念

    有关独占型设备分配的相关内容,在这位老师的这篇博客(https://blog.csdn.net/dongyanxia1000/article/details/51862577)中,写的十分详细。十分感谢老师的分享。

    实验环境

    实验前提条件

    假如系统中已经存在4类设备,每类设备各一个;3个设备控制器,设备控制器可以添加,添加系统中已存在的设备时,不需要添加设备控制器,而添加系统中不存在的设备时,需要自己手动添加新的设备控制器;2个通道;只有设备、设备控制器、通道三者同时被申请成功,设备才能分配成功。本实验中,通道不能添加。

    实验相关代码

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define  MAX   100
    typedef struct pcb/*进程*/
    {
    	int pcbID;		/*进程名称*/
    	struct pcb *next;
    }PCB;
    
    typedef struct chct//通道控制表
    {
        int chctID;
        int status;//设备状态
        PCB *block;//阻塞队列
    }CHCT;
    
    typedef struct coct//控制器控制表
    {
        int coctID;
        int status;//设备状态
        CHCT *chct;//控制器所连接的通道
        PCB *block;//阻塞队列
        struct coct *next;//控制器队列
    }COCT;
    
    typedef struct dct//设备控制表
    {
        int dctID;
        int status;//设备状态
        int processid;//占用进程ID
        PCB *block;//阻塞队列指针
        COCT *coct;//与设备控制器相关连的控制器控制表
        struct dct* next;//同类设备的不同设备
    }DCT;
    typedef struct sdt//系统设备表
    {
        char type;//系统设备表类型
        char name[MAX];//系统设备表名称
        DCT *dct;//DCT设备控制表
        struct sdt *next;//驱动入口地址
    }SDT;
    /*设置全局变量   2个通道、3个设备控制器、4个设备*/
    CHCT *CH1,*CH2;//两个通道ch1,ch2
    COCT *coct_head;//控制器控制表头部
    SDT *sdt_head;
    void init()
    {
        PCB *ch1pcbblock,*ch2pcbblock,*co1pcbblock,
        *co2pcbblock,*co3pcbblock,
        *d1pcbblock,*d2pcbblock,
        *d3pcbblock,*d4pcbblock;//各个设备的等待队列
        COCT*CO1,*CO2,*CO3;
        DCT *dct1,*dct2,*dct3,*dct4;
        SDT *sdt1,*sdt2,*sdt3,*sdt4;
        CH1=(CHCT*)malloc(sizeof(CHCT));
        CH2=(CHCT*)malloc(sizeof(CHCT));
        CH1->status=0;
        CH2->status=0;
        CH1->chctID = 1;
        CH2->chctID = 2;
        ch1pcbblock=(PCB*)malloc(sizeof(PCB));
        ch2pcbblock=(PCB*)malloc(sizeof(PCB));
        ch1pcbblock->next=NULL;
        ch2pcbblock->next=NULL;
        CH1->block=ch1pcbblock;
        CH2->block=ch2pcbblock;
        coct_head=(COCT*)malloc(sizeof(COCT));
        coct_head->next=NULL;
        CO1=(COCT*)malloc(sizeof(COCT));
        CO2=(COCT*)malloc(sizeof(COCT));
        CO3=(COCT*)malloc(sizeof(COCT));
        CO1->status=0;
        CO2->status=0;
        CO3->status=0;
        coct_head->next=CO1;
        CO1->next=CO2;
        CO2->next=CO3;
        CO3->next=NULL;
        co1pcbblock=(PCB *)malloc(sizeof(PCB));
        co1pcbblock->next=NULL;
        co2pcbblock=(PCB *)malloc(sizeof(PCB));
        co2pcbblock->next=NULL;
        co3pcbblock=(PCB *)malloc(sizeof(PCB));
        co3pcbblock->next=NULL;
        CO1->coctID = 1;
        CO2->coctID = 2;
        CO3->coctID = 3;
        //随机分配起始时的通道和控制的连接情况
        CO1->chct=CH1;
        CO2->chct=CH1;
        CO3->chct=CH2;
        CO1->block=co1pcbblock;
        CO2->block=co2pcbblock;
        CO3->block=co3pcbblock;
    
        d1pcbblock=(PCB *)malloc(sizeof(PCB));
        d2pcbblock=(PCB *)malloc(sizeof(PCB));
        d3pcbblock=(PCB *)malloc(sizeof(PCB));
        d4pcbblock=(PCB *)malloc(sizeof(PCB));
        d1pcbblock->next=NULL;
        d2pcbblock->next=NULL;
        d3pcbblock->next=NULL;
        d3pcbblock->next=NULL;
    
        dct1=(DCT *)malloc(sizeof(DCT));
        dct2=(DCT *)malloc(sizeof(DCT));
        dct3=(DCT *)malloc(sizeof(DCT));
        dct4=(DCT *)malloc(sizeof(DCT));
        dct1->dctID = 1;
        dct2->dctID = 1;
        dct3->dctID = 1;
        dct4->dctID = 1;
        dct1->coct=CO1;
        dct2->coct=CO2;
        dct3->coct=CO3;
        dct4->coct=CO3;
        dct1->status=0;
        dct2->status=0;
        dct3->status=0;
        dct4->status=0;
        //同类设备链表
        dct1->next = NULL;
        dct2->next = NULL;
        dct3->next = NULL;
        dct4->next = NULL;
        dct1->block=d1pcbblock;
        dct2->block=d2pcbblock;
        dct3->block=d3pcbblock;
        dct4->block=d4pcbblock;
        sdt_head=(SDT *)malloc(sizeof(SDT));
        sdt_head->next=NULL;
        sdt1=(SDT *)malloc(sizeof(SDT));
        sdt2=(SDT *)malloc(sizeof(SDT));
        sdt3=(SDT *)malloc(sizeof(SDT));
        sdt4=(SDT *)malloc(sizeof(SDT));
        sdt_head->next=sdt1;
        sdt1->next=sdt2;
        sdt2->next=sdt3;
        sdt3->next=sdt4;
        sdt4->next = NULL;
        strcpy(sdt1->name,"printer");
        strcpy(sdt2->name,"screen");
        strcpy(sdt3->name,"keyboad");
        strcpy(sdt4->name,"mouse");
        sdt1->dct=dct1;
        sdt2->dct=dct2;
        sdt3->dct=dct3;
        sdt4->dct=dct4;
    }
    /**
        遍历sdt表,找到相应的设备类
    */
    SDT* TravseSDT(char searchname[]){
        SDT* tmp;
        tmp = sdt_head->next;
        while(tmp!=NULL){
    //        printf("%s\n",tmp->name);
            if(strcmp(tmp->name,searchname) == 0){
                printf("a:%s\n",tmp->name);
                return tmp;
            }
            tmp = tmp->next;
        }
        return sdt_head;
    }
    /**
        显示所有的设备及状态
    */
    void display(){
        SDT* sdttmp = sdt_head->next;
        DCT* dcttmp = NULL;
        printf("SDT   设备ID  设备状态 所连COCT的ID  COCT状态   所连CHCT的ID   CHCT状态\n");
        while(sdttmp != NULL){
            dcttmp = sdttmp->dct;
            while(dcttmp != NULL){
                printf("%s\t%d\t%d         %d            %d             %d         %d\n",sdttmp->name,dcttmp->dctID,dcttmp->status,dcttmp->coct->coctID,dcttmp->coct->status,dcttmp->coct->chct->chctID,dcttmp->coct->chct->status);
                dcttmp = dcttmp->next;
            }
            sdttmp = sdttmp->next;
        }
    }
    
    /**
    void displaySDT(){
        SDT* p = sdt_head->next;
        while(p!=NULL){
            printf("%s\n",p->name);
            p = p->next;
        }
    }
    */
    
    /**
        添加设备
    */
    void addDevice(){
        int channelid;//通道号
        printf("请输入待添加设备的名称\n");
        char devicename[30];
        scanf("%s",devicename);
        SDT* cur = TravseSDT(devicename);
        DCT* pt = cur->dct;
        if(cur != sdt_head){//添加已知种类的设备
            while(pt->next!=NULL){
                pt=pt->next;
            }
            DCT* p = (DCT*)malloc(sizeof(DCT));
            pt->next = p;
            p->next = NULL;
            printf("请输入待添加设备的标识\n");
            scanf("%d",&p->dctID);
            p->status = 0;
            p->block = (PCB*)malloc(sizeof(PCB));
            p->coct = cur->dct->coct;
        }else{//添加新的种类的设备
            SDT* newsdt = (SDT*)malloc(sizeof(SDT));
            newsdt->next= sdt_head->next;
            sdt_head->next = newsdt;
            DCT* newdct = (DCT*)malloc(sizeof(SDT));
            newdct->dctID = 1;
            newdct->status=0;
            strcpy(newsdt->name,devicename);
            newsdt->dct=newdct;
            newdct->next = NULL;
            printf("请输入要添加设备控制器的信息\n");
            COCT* con = (COCT*)malloc(sizeof(COCT));
            newdct->coct = con;
            con->next = coct_head->next;
            coct_head->next = con;
            printf("请输入控制器的标识\n");
            scanf("%d",&con->coctID);
            con->status=0;
            printf("请输入要使用的通道号\n");
            scanf("%d",&channelid);
            if(channelid == 1){
                con->chct = CH1;
            }
            if(channelid == 2){
                con->chct = CH2;
            }
            con->block = (PCB*)malloc(sizeof(PCB));
        }
    }
    /**
        删除设备
    */
    void deleteDevice(){
        printf("请输入要删除的设备的种类名称\n");
        char deletename[30];
        scanf("%s",deletename);
        SDT* tmp = TravseSDT(deletename);//找到该类设备的sdt
        int i =1;
        if(tmp!=sdt_head){
            printf("请输入要删除设备的ID\n");
            int deleteid;
            scanf("%d",&deleteid);
            DCT* cur = tmp->dct;
            while(cur != NULL){
                if(cur->dctID == deleteid && i==1){//删除找到的设备ID,删除第一个节点
                    tmp->dct = cur->next;
    
                    break;
                }else if(cur->next->dctID == deleteid && cur->next->next != NULL){//中间节点
                    DCT* p = cur->next;
                    p->coct = NULL;
                    cur->next = cur->next->next;
                    free(p);
                    break;
                }else if(cur->next->dctID == deleteid && cur->next->next == NULL){//最后一个节点
                    cur->next = NULL;
                }
                cur =  cur->next;
                i++;
            }
        }else{
            printf("该类设备不存在\n");
        }
    
    }
    /**
        分配设备
    */
    void allotDevice(){
        PCB* pro = (PCB*)malloc(sizeof(PCB));
        printf("输入进程标识\n");
        scanf("%d",&pro->pcbID);
        pro->next = NULL;
        printf("请输入要申请的设备种类名称\n");
        char name[30];
        scanf("%s",name);
        //判断所有该类设备是否有空闲的
        SDT* p = sdt_head->next;
        DCT* pt = NULL;
        int flag=0;
        while(p!=NULL){
            if(strcmp(p->name,name) == 0){//找到该类设备
                pt = p->dct;
                while(pt!=NULL){
                    if(pt->status == 0){//设备可用
                        pt->status =1;
                        flag = 1;
                        break;
                    }
                    pt = pt->next;
                }
                if(flag==1){
                    if(pt->coct->status == 0){//该类设备对应的设备控制器可用
                        pt->coct->status = 1;
                        if(pt->coct->chct->status == 0){//相应的通道可用
                            pt->coct->chct->status =1;
                            printf("设备分配成功\n");
                        }else{//进入相应的通道等待队列
                            printf("通道忙碌\n");
                            PCB* newpcb = (PCB*)malloc(sizeof(PCB));
                            newpcb->next = pt->coct->chct->block->next;
                            pt->coct->chct->block->next = newpcb;
                        }
                    }else{//进入该设备相应的设备控制器等待队列
                        printf("设备控制器忙碌\n");
                        PCB* newpcb = (PCB*)malloc(sizeof(PCB));
                        newpcb->next = pt->coct->block->next;
                        pt->coct->block->next = newpcb;
                    }
                }else{//进入设备等待队列
                    printf("设备忙碌\n");
                    PCB* newpcb = (PCB*)malloc(sizeof(PCB));
                    newpcb->next = pt->block->next;
                    pt->block->next = newpcb;
                }
            }
            p = p->next;
        }
    }
    
    
    /**
        回收设备
    */
    void reclaimDevice(){
        printf("请输入要回收的设备种类\n");
        char reclainname[30];
        scanf("%s",reclainname);
        int reclainID;//回收设备号
        SDT* p = sdt_head->next;
        DCT* pt = NULL;
        while(p!=NULL){
            if(strcmp(reclainname,p->name) == 0){//找到该类设备
                printf("请输入要回收的设备ID\n");
                scanf("%d",&reclainID);
                pt = p->dct;
                while(pt!=NULL){
                    if(pt->dctID == reclainID){
                        pt->status=0;
    //                    pt->coct->status =0;
    //                    pt->coct->chct->status = 0;
                    }
                    pt=pt->next;
                }
            }
            p = p->next;
        }
    }
    int main()
    {
        //初始化
        init();
        display();
        int NUM;
        while(1){
            printf("----选项----\n");
            printf("NUM = 1:添加设备\n");
            printf("NUM = 2:删除设备\n");
            printf("NUM = 3:分配设备\n");
            printf("NUM = 4:回收设备\n");
            printf("请输入NUM:");
            scanf("%d",&NUM);
            if(NUM == 1){
                addDevice();
                display();
            }else if(NUM == 2){
                deleteDevice();
                display();
            }else if(NUM == 3){
                allotDevice();
                display();
            }else{
                reclaimDevice();
                display();
            }
        }
        return 0;
    }
    

     

    展开全文
  • 编写单通路I/O系统中的设备分配程序。 要求: (1) 设计: 系统设备表SDT 控制器表COCT 设备控制表DCT 通道表CHCT 逻辑设备表LUT (2)给出各表目初态 (3)回答信息: 能够分配时,给出设备号 、控制器号、通道...
  • 1、参考操作系统有关设备分配的分配策略,模拟给出设备请求到分配的过程,对于外部存储器设备,分配后要模拟出它的的I/O过程,调用磁盘调度算法。 2、设备分配过程中,要给设备分配设备控制器,通道都要有。 3、...
  • 1、参考操作系统有关设备分配的分配策略,模拟给出设备请求到分配的过程,对于外部存储器设备,分配后要模拟出它的的I/O过程,调用磁盘调度算法。 2、设备分配过程中,要给设备分配设备控制器,通道都要有。 3、...
  • 设备管理模拟实现

    2012-06-29 11:05:53
    模拟实现的程序包括建立设备类表和设备表的程序段,分配设备和回收设备的函数...⑵ 根据设备管理过程实现设备分配和回收操作。 ⑶ 操作要求:提供界面选择分配、回收操作以及输入相关参数;能够显示当前设备使用情况。
  • 独占设备分配和回收

    2012-03-20 16:14:53
    统过模拟独占设备分配和回收,了解操作系统对设备资源进行组织管理和分配、回收过程,掌握设备管理的思想。
  • 1、参考操作系统有关设备分配的分配策略,模拟给出设备请求到分配的过程,对于外部存储器设备,分配后要模拟出它的的I/O过程,调用磁盘调度算法。 2、设备分配过程中,要给设备分配设备控制器,通道都要有。 3、...
  • 操作系统实验:实现动态分区分配模拟实验 JAVA实现,源代码
  • 模拟单通道设备处理器分配过程,主要就是建立几个表,本代码用jsp
  • 设备分配

    千次阅读 2019-08-27 21:07:11
    一、设备分配的功能 当进程向系统提出I/O请求后,由设备分配程序按照一定的策略把所要求的设备分配给该进程,为确保CPU与设备之间能进行通信,还应分配相应的控制器和通道。 二、设备分配时应考虑的因素 系统必须...

    一、设备分配的功能

    当进程向系统提出I/O请求后,由设备分配程序按照一定的策略把所要求的设备分配给该进程,为确保CPU与设备之间能进行通信,还应分配相应的控制器和通道。

    二、设备分配时应考虑的因素

    系统必须具有一种合理的设备分配策略,该策略与下述的四个因素有关;

    1)设备的固有属性

    2)系统采用的分配算法

    3)设备分配的安全性

    4设备的无关性,用户程序与实际使用的物理设备无关。

    1、设备的固有属性——设备分配的方式

    1)独占设备——静态分配

    独占设备有打印机,键盘,显示器。

    对独占型设备一般采用静态分配即在作业级进行的分配,当一个作业运行之前由系统一次分配满足需要的全部设备,这些设备一直为该作业占用,直到作业撤消。这种分配不会出现死锁,但设备的利用效率较低。

    2)共享设备——动态分配

    共亨设备包括磁盘,磁鼓和磁带。

    对共享设备采用动态分配的方式,即在进程运行的过程中进行的,当进程需要使用设备时,通过系统调用命令向系统提出设备请求,系统按一定的分配策略给进程分配所需设备,一旦使用完毕立即释放。显然这种分配方式有利于提高设备的使用效率,但会出观死锁。

    3)虚拟设备——虚拟分配

    虚拟设备有虚拟的输入机,虚拟的打印机。

    为提高设备的利用率,通过Spooling技术把一台独占设备变换为若干台逻辑设备,供若干个用户(进程)同时使用。用来模拟独占设备的那部分共享设备称为虚拟设备

    2I/O设备分配算法

    1.先来先服务。根据进程对某设备提出请求的先后次序,可将进程排成一个队列,设备分配程序总是先把设备分配给队首进程。

    2.优先级高者优先。本算法总是将设备分配给优先级最高的进程。为此,通常在形成设备队列时,是将优先级高的进程排在前面;对于相同优先级的IO请求,则按先来先服务原则排队。

    3、设备分配的安全性

    从进程运行的安全性上考虑,设备分配有以下两种方式

    1) 安全分配方式(单请求方式)在这种分配方式中,每当进程发出IO请求后便进入阻塞状态,直至IO操作完成时才被唤醒。在此策略中,由于已经避免了造成死锁的四个必要条件之一的“请求和保护”条件,因而分配是安全的。其缺点是进程进展缓慢、CPU1O之间是串行工作的。

    2) 不安全分配方式(多请求方式)在这种分配方式中,进程发出IO请求后仍继续运行,需要时又发出第二个IO请求、第三个IO请求。仅当进程所请求的设备己被另一进程占用时.进程才进入阻塞状态。

    优点:一个进程可同时操作多个设备,使这些设备能并行工作;

    缺点:分配不安全,从而可能形成死锁。因此在设备分配程序中还应增加一个功能,用于对本次的设备分配是否会形成死锁而进行安全性计算,仅当计算结果说明分配是安全时,方才进行分配。

    三、逻辑设备名到物理设备名映射的实现

    逻辑设备表LUT(Logical Unit Table)
      在逻辑设备表的每个表目中包含了三项:逻辑设备名、物理设备名和设备驱动程序的入口地址。

    四、设备分配的数据结构

    设备控制表(DCT——每个设备一张,记录了设备特性以及设备和I/O控制器的连接情况。

    控制器表(COCT——每个控制器一张,记录了控制器的使用状态以及和通道的连接情况。

    通道控制表(CHCT——每个通道一张,记录了通道的情况。

    系统设备表(SDT——整个系统一张,每个设备占一个表项,记录了系统中所有设备的情况。

    设备分配检索流程

    五、独占设备的分配程序   

    1)  基本的设备分配程序
       我们通过一个例子来介绍设备分配过程。当某进程提出
    I/O请求后,系统的设备分配程序可按下述步骤进行设备分配:
      
    (1) 分配设备。
      
    (2) 分配控制器。
      
    (3) 分配通道。

    2) 设备分配程序的改进
      为获得设备的独立性,进程应使用逻辑设备名请求
    I/O

    六、假脱机(Spooling)系统

    1、假脱机技术

    1)脱机输入输出系统

    2)假脱机(Spooling)技术

         联机同时外围设备操作技术称为Spooling技术或称为假脱机技术

    2SPOOLing的组成

          大容量磁盘  输入井——用于存放作业的原始信息

                      输出井——用于存放作业的执行结果

                输入缓冲区和输出缓冲区

          输入进程SPi和SPo

     

    3、假脱机打印机系统

        当用户(或进程)申请独占设备时,系统给它分配共享设备的一部分存储空间。当进程要与设备交换信息时,系统就把要交换的信息存放在这部分存储空间。在适当的时候再将存贮空间的信息传输到相应的设备上去处理。

        如系统打印信息时,就把要打印的信息送到某个存储空间中去,然后由系统在适当时机把存储空间上的信息送到打印机上打印。这个时机可能是打印机空闲或打印机完成了一用户的打印之后。

    4、实现虚拟设备的好处

    1)提高了独占设备的利用率;

    2)每个用户都有速度极高的“输入机”和“打印机”,缩短  了作业执行时间;

    3)能够多道并行工作 。

     

    展开全文
  • 设计一种独占设备分配和回收的方案,要求满足设备独立性。使用编程语言(C或者C++)实现;当进程申请某类设备时,系统先查找“设备类表” 如果该类设备的现存台数可以满足申请要求,则从该类设备的“设备表”始址开始...
  • 用C语言或C++语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中,空闲分区通过空闲分区链表来管理,在进行内存分配时,系统优先使用空闲区低端空间。
  • 对作业装入内存的过程进行了模拟,主要是对装入的作业分页,在位示图中看是否有足够的位置可以装入,帧号=位示图相应位置的字号*字长+位号,并给作业分配一个页表。开发工具:C++
  • 编写程序,模拟实现以下功能: 采用连续分配方式之动态分区分配存储管理,使用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法4种算法完成设计(任选两种算法)。 由用户指定申请和释放操作,结果以...
  • 1.用C或其他语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程和回收过程。 2.设置初始状态,每次分配和回收后显示出空闲内存分区链的情况。 3.主要仪器设备 仪器: PC机 实验环境: Ubuntu16.04 ...

    1.实验目的

    了解动态分区分配方式中使用的数据结构和分配算法,进一步加深对动态分区存储管理方式及其实现过程的理解。

    2.实验内容和要求

    1.用C或其他语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程和回收过程。
    2.设置初始状态,每次分配和回收后显示出空闲内存分区链的情况。

    3.主要仪器设备

    仪器: PC机
    实验环境: Ubuntu16.04
    编程语言:C++

    4.实验原理

    程序执行流程图
    在这里插入图片描述

    5.预备知识

    1. 动态分区分配
      动态分区分配是指,在处理作业的过程中,建立分区,依据用户请求的大小分配分区。在分区回收的过程中会涉及到一个空间利用效率相关的放置策略,即选择空闲区的策略。

    2. 首次适应算法(First Fit)
      该算法从空闲分区链首开始查找,直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业的大小,从该分区中划出一块内存分配给请求者,余下的空闲分区仍留在空闲分区链中。
      优点:该算法倾向于使用内存中低地址部分的空闲区,在高地址部分的空闲区很少被利用,从而保留了高地址部分的大空闲区。显然为以后到达的大作业分配大的内存空间创造了条件。
      缺点:低地址部分不断被划分,留下许多难以利用、很小的空闲区,而每次查找又都从低地址部分开始,会增加查找的开销。

    3. 最佳适应算法(Best Fit)
      该算法总是把既能满足要求,又是最小的空闲分区分配给作业。为了加速查找,该算法要求将所有的空闲区按其大小排序后,以递增的顺序形成一个空白链。这样每次找到的第一个满足要求的空闲区,必然是最优的。孤立地看,该算法似乎是最优的,但是事实上并不一定。因为每次分配后的剩余的空间一定是最小的,在存储器中将留下许多难以利用的小空闲区。同时每次分配后必须重新排序,这也带来了一定的开销。
      优点:每次分配给文件的都是最合适该文件大小的分区。
      缺点:内存中留下许多难以利用的小的空闲区。

    5.源程序

    #include<iostream>
    #include<stdlib.h>
    using namespace std;
    enum State{
    	Free,Busy
    };
    #define OK 1
    #define ERROR 0
    #define max_length 640
    int flag;
    typedef bool Status;
    
    typedef struct Free_area{
    	long size;
    	long address;
    	State state;
    }ElemType;
    
    typedef struct DuLNode{
    	ElemType data;
    	struct DuLNode *prior;
    	struct DuLNode *next;
    }DuLNode,*DuLinkList;
    
    DuLinkList block_first;
    DuLinkList block_last;
    Status alloc(int);
    Status free(int);
    Status First_fit(int);
    Status Best_fit(int);
    void show();
    
    Status Initblock();
    Status Initblock(){
    	block_first = (DuLinkList)malloc(sizeof(DuLNode));
    	block_last = (DuLinkList)malloc(sizeof(DuLNode));
    	block_first->prior = NULL;
    	block_first->next = block_last;
    	block_last->prior = block_first;
    	block_last->next = NULL;
    	block_last->data.address = 0;
    	block_last->data.size = max_length;
    	block_last->data.state = Free;
    	return OK;
    }
    Status alloc(int ch){
    	
    	int request = 0;
    	cout << "Enter the size(KB) of main memory to be allocated:\n";
    	cin >> request;
    	if(request<=0)
    	{
    		cout << "allocate error!Please enter again.\n"<<endl;
    		return ERROR;
    	}
    	
    	if(ch == 1)
    	{
    		if(First_fit(request)==OK)
    		cout << "allocation success." << endl;
    		else 
    		{
    			cout << "allocation fail." << endl;
    			return ERROR;
    		} 
    		return OK;
    	 } 
    	 
    	else
    	{
    		if(Best_fit(request)==OK)
    		{
    			cout << "allocation success." << endl;
    			return OK;
    		}
    		else 
    		{
    			cout << "allocation fail." << endl;
    			return ERROR;
    		} 
    	 } 
    	
    }
    Status free(int flag){
    	
    	DuLNode *p =block_first;
    	for(int i=0;i<=flag;i++)
    	{
    		if(p!=NULL)
    		p = p->next;
    		else
    		return ERROR;
    	}
    	p->data.state = Free;
    	/*merge with the previous free block*/
    	if(p->prior != block_first && p->prior->data.state == Free)
    	{
    		p->prior->data.size += p->data.size;
    		p->prior->next = p->next;
    		p->next->prior = p->prior;
    		p = p->prior;
    	}
    	/*merge with the following free block*/
    	if(p->next != block_last && p->next->data.state ==Free)
    	{
    		p->data.size +=p->next->data.size;
    		p->next->next->prior = p;
    		p->next = p->next->next;
    	}
    	/*merge with the last free block*/
    	if(p->next == block_last && p->next->data.state == Free)
    	{
    		p->data.size += p->next->data.size;
    		p->next=NULL;
    	}
    	return OK;
    }
    Status First_fit(int request){
    	
    	DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
    	temp->data.size = request;
    	temp->data.state = Busy;
    	
    	DuLNode *p = block_first->next;
    	while(p)
    	{
    		if(p->data.state == Free && p->data.size == request)
    		{
    			p->data.state = Busy;
    			return OK;
    			break;
    		}
    		
    		if(p->data.state == Free && p->data.size>request)
    		{//
    			temp->prior = p->prior;
    			temp->next = p;
    			temp->data.address = p->data.address;
    			p->prior->next = temp;
    			p->prior = temp;
    			p->data.address = temp->data.address + temp->data.size;
    			p->data.size -= request;
    			return OK;
    			break;	
    		}
    		p = p->next;
    	}
    	return ERROR;
    }
    
    Status Best_fit(int request){
    	
    	int min_size;
    	DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
    	temp->data.size = request;
    	temp->data.state = Busy;
    	DuLNode *p = block_first->next;
    	DuLNode *q = NULL;//record the best insert position
    	
    	while(p)//initialize the min_size and the best positon
    	{
    		if(p->data.state == Free && (p->data.size)>=request)
    		{
    			if(q==NULL)
    			{
    				q=p;
    				min_size = p->data.size - request;	
    			}
    			else if(q->data.size > p->data.size)
    			{
    				q=p;
    				min_size = p->data.size - request;
    			}
    		}
    		p = p->next;
    	}
    		
    	if(q==NULL){
    		return ERROR;
    	}
    	else if(q->data.size == request)
    	{
    		q->data.state = Busy;
    		return OK;
    	}
    	else
    	{
    		temp->prior = q->prior;
    		temp->next = q;
    		temp->data.address = q->data.address;
    		q->prior->next = temp;
    		q->prior = temp;
    		q->data.address = q->data.address+request;
    		q->data.size = min_size; 
    		return OK;
    	}
    }
    
    void show()
    {
    	int flag=0;
    	cout << "\nMain memory allocation:\n";
    	cout << "++++++++++++++++++++++++++++++++++++++++++++++\n\n";
    	DuLNode *p = block_first->next;
    	cout << "block_id\t start_address\t block_size\t block_state\n\n";
    	while(p)
    	{
    		cout << "  " << flag++ << "\t\t";
    		cout << "  " << p->data.address << "\t\t";
    		cout << "  " << p->data.size << "KB\t\t";
    		if(p->data.state == Free)
    		cout << "free\n\n";
    		else
    		cout << "busy\n\n";
    		
    		p = p->next;		
    	}
    	cout << "++++++++++++++++++++++++++++++++++++++++++++++\n\n";
    }
    
    
    int main()
    {
    	int ch;// algorithm choice
    	cout << "Please enter the memory allocation algorithm used:\n";
    	cout << "1.First Fit\n2.Best Fit\n";
    	cin >> ch;
    	while(ch<1||ch>2)
    	{
    		cout << "input error,please enter again!" <<endl;
    		cin >> ch;
    	}
    	Initblock();
    	int choice;//operation choice 
    	while(1)
    	{
    		show();
    		cout << "\n 1.allocate\n 2.free\n 3.exit\n";
    		cin >> choice;
    		if(1==choice)
    		alloc(ch);
    		else if(2==choice)
    		{
    			int flag;
    			cout << "Please enter the block id which you want to free."<<endl;
    			cin >> flag;
    			free(flag);
    		}
    		else if(3==choice)
    		{
    			break;
    		}
    		else
    		{
    			cout<<"wrong input!Please do it again."<<endl;
    			continue;
    		}
    	 } 
    	 return 0;
    }
    

    7.实验步骤与调试

    程序结构:

    1. 定义空闲区结构体
    2. 定义双向链表存储结构
    3. 开创带头结点的空间链表,默认最大内存为640KB
    4. 定义alloc、free函数
    5. 定义首次适应算法和最佳适应算法

    在构造程序之前先把程序所需要的框架搭好,把每一部分的内容分别写出来,再组合成整体运行。

    Best Fit算法运行结果:
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述

    First Fit算法运行结果:

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    8.实验结果与分析

    对比试验:
    在以下操作下,对比观察BF算法和FF算法的区别:
    作业1申请130KB
    作业2申请60KB
    作业3申请100KB
    作业2释放60KB
    作业4申请200KB
    作业3释放100KB
    作业1释放130KB
    作业5申请140KB
    作业6申请60KB
    作业7申请50KB
    作业6释放60KB

    展开全文
  • 设备分配和回收

    千次阅读 2019-11-05 10:01:17
    设备分配和回收
  • 第一题:在可变分区管理方式下采用首次适应算法实现主存空间的分配和回收,采用空闲区说明表数据结构。 1, 按下图从键盘输入并显示内存空间的分配现状,每个分区有四个数据项:起始地址,大小,状态,进程号。起始...
  • 自己写的模拟编写单通路IO系统中的设备分配程序,第一次上传,保证给您不一样的感觉,老师肯定会给高分的
  • 如前所述,设备模拟模型会导致虚拟化性能大大下降;泛虚拟化设备模型虽然在性能上拥有一定的优势,但由于需要修改操作系统,具有局限性.。并且当前的两种I/O设备虚拟化模型已无法满足高速的数据交换需求,应运而生的...
  • 操作系统之设备分配笔记

    千次阅读 2013-12-02 10:16:51
    要明白操作系统如何为进程分配设备,就要对计算机内部组成有一定的认识,操作系统通过驱动程序作为桥梁,向DMA(设备管理器)发出控制信息,DMA一头连着CUP,一头连着设备接口。由于计算机设备众多,如果要CUP全部...
  • 并加以实现,加深对操作系统原理和实现过程的理解。 二、实验内容: 多级反馈队列调度的模拟。 本算法设置了三个优先级从高到低的队列,时间片长度分别为: 队列一:2 队列二:4 队列三:8 三、实现思路: 采用...
  • GiWiFi模拟登录的完整过程

    千次阅读 2019-09-22 16:59:37
    本文灵感来自: 校园网GiWiFi模拟登陆
  • 方法基于模块组合思想,利用网络对空间结构的描述能力,通过定义不同技术设备的描述符号以及相关计算法则,结合专为各种性质列车分别创建的网络变换建立高铁客运站技术设备使用时段分配网络模型。模型采用按一定顺序...
  • Linux下使用USB模拟ACM串口设备

    万次阅读 2017-01-05 16:48:07
    从物理上看,其实就是一对差分线,连接两台设备后,相互间进行数据传输。加上另外两路供电( 5V 和 GND)线,一共是 4 根线。 那么,既然是只有一对差分线,那么该如何决定由谁传给谁呢(如果两边同时在线上建立
  • 模拟鼠标或者键盘,必须使用外部固件模式,内置固件只负责信息数据的传输,所以不得不选择并口控制或者SPI的方式,接下来就是了解基本的USB协议的尝试,懂得USB设备与PC机进行信息握手的过程,懂得什么是SETUP,什么...
  • 设备控制软件编程涉及到的基本通信方式主要有TCP/IP与串口,用到的数据通信协议有Fins与ModBus。 更高级别的通信如.net中的Remoting与WCF在进行C/S架构软件开发时会采用。 本篇文章结合Fins/ModBus协议的指令帧...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,661
精华内容 24,664
关键字:

设备分配过程的模拟