精华内容
下载资源
问答
  • 操作系统算法模拟实例之单处理机系统进程调度 1.实验目的 在多道程序或多任务系统中,系统回时处于就绪态的进程有若干个,为使系统中 的各进程能有条不素地运行,必须选择某种调度策略,以选择一进程占用处理机。 ...

    操作系统算法模拟实例之单处理机系统进程调度

    1.实验目的

    在多道程序或多任务系统中,系统回时处于就绪态的进程有若干个,为使系统中
    的各进程能有条不素地运行,必须选择某种调度策略,以选择一进程占用处理机。
    要求学生设计一个模拟单处理机调度算法,以巩固和加探对进念和进程调度算法的理解。

    2.实验内容

    编写程序完成单处理机系统中的进程调度,要求采用最高优先级优先调度算法。具体内容包括

    • 确定进程控制块的内容和组织方式;
    • 完成进程创建原语和进调度原语:
    • 编写主函数井对所做的工作进行测试

    3.实验指导

    进程调度算法:

    采用最高优先级优先调度算法(即把处理机分配给优先级最高的进程)和先来先服务调度算法,每个进程用一个进程控制块(PCB)表示,进程控制块可以包含以下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间,进程状态等。进程的优先数(表示优先级别)及需要的运行时间可以事先人为描定(也可以随机数产生),进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位。

    每个进程的状态可以是就绪W(Wait),运行R(Run)或完成F( Finish)三种状态之就绪进程获得CPU后都只能运行一个时间片,用已占用CPU时间加1来表示,如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则激销该进程,如果运行一个时间片后进程的已占用CPU时间还未达到所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

    每进行一次,调度程序都打印一次运行进程,就绪队列以及各个进程的PCB,以假进
    行检查。重复以上过程,直到所有进程都完成为止。

    4.程序实例

    #include"stdio.h"
    #include <stdlib.h>
    #include <conio.h>
    #define getpch(type)(type *)malloc(sizeof(type))
    
    struct pcb               //定义进程控制块
    {
        char name[10];
        char state;
        int super;
        int ntime;
        int rtime;
        struct pcb* link;
    }*ready=NULL,*p;
    typedef struct pcb PCB;
    int sort()                  //建立对进程进行优先级排列的函数
    {
        PCB *first,*second;
        int insert = 0;
        //优先级最大者,插入队首
        if((ready==NULL)||((p->super )>(ready->super )))
        {
            p->link =ready;
            ready=p;
        }
        else        //进程比较优先级,插入适当的位置中
        {
            first = ready;
            second = first->link ;
            while(second != NULL)
            { //插入进程比当前进程优先数大、插到当前进程前面
                if((p->super )>(second->super ))
                {
                    p->link =second;
                    first->link = p ;
                    second = NULL;
                    insert = 1;
                }
                else    //插入进程优先级数最低,则插入到队尾
                {
                    first=first->link ;
                    second=second->link ;
                }
            }
            if(insert==0)   first->link=p;
        }
    }
    /*
        说明:上述程序首先定义进程控制块结构,然后对每个进程的优先级赋初值,完成
        优先级的排序过程,把优先级大的进程插入就绪队首,等待cup调度,该实验完成了
        优先级大者优先调度的原则,从而对进程调度过程加深理解和掌握
    */
    int input() //建立进程控制块函数
    {
        int i,num;
    
        system("cls");       //清屏
        printf("\n请输入进程个数?");
        scanf("%d",&num);
        for(i = 0; i < num; i++)
        {
            printf("\n进程号 No.%d:\n",i);
            p = getpch(PCB);
            printf("\n输入进程名:");
            scanf("%s",p->name );
            printf("\n 输入进程优先数:");
            scanf("%d",&p->super );
            printf("\n 输入进程运行时间:");
            scanf("%d",&p->ntime );
            printf("\n");
            p->rtime = 0;
            p->state = 'w';
            p->link = NULL;
            sort();
        }
    }
    int space()
    {
        int l = 0;
        PCB *pr = ready;
        while(pr!=NULL)
        {
            l++;
            pr = pr->link;
    
        }
        return(l);
    }
    int disp(PCB *pr)
    {
        printf("\n qname\t state\t super \t ndtime \t runtime \n");
        printf("|%s\t",pr->name);
        printf("|%c\t",pr->state);
        printf("|%d\t",pr->super);
        printf("|%d\t",pr->ntime);
        printf("|%d\t",pr->rtime);
        printf("\n");
    
    }
    int check()         //进程查看函数
    {
        PCB *pr;
        printf("\n****当前正在运行的程序是:%s",p->name );     //显示当前运行进程
        disp(p);
        pr=ready;
        printf("\n****当前就绪队列状态为:\n");                //显示就绪队列状态
        while (pr!=NULL)
        {
            disp(pr);
            pr=pr->link;
        }
    }
    int destroy()                      //建立进程撤销函数(进程运行结束,撤销进程)
    {
        printf("\n进程{%s}已完成.\n",p->name );
        free(p);
    
    }
    int running()                  //建立进程就绪函数(进程运行时间到,置就绪状态)
    {
        (p->rtime )++;
        if(p->rtime ==p->ntime )
            destroy();
        else
        {
            (p->super )--;
            p->state ='w';
            sort();
        }
    }
    int main()
    {
        int len,h = 0;
        char ch;
        input();
        len = space();
        while((len!=0)&&(ready != NULL))
        {
            ch=getchar();
            h++;
            printf("\n The execute number:%d\n",h);
            p=ready;
            ready=p->link ;
            p->link =NULL;
            p->state ='R';
            check();
            running();
            printf("\n 按任意键继续....");
            ch=getchar();
    
        }
        printf("\n\n进程已经完成.\n");
        ch=getchar();
    }
    
    展开全文
  • 编写一个单处理机下进程调度程序,模拟操作系统对进程的调度。 要求: 能够创建指定数量的进程,每个进程由一个进程控制块表示。 实现先来先服务调度算法:进程到达时间可由进程创建时间表示。 实现短作业...
  • 1.进程控制块的数据结构定义如下: pointer=^pcb; pcb=RECORD name:char; status:string; priority:integer;//进程动态优先级 ax:integer; next:pointer; times://进程要求服务时间 END; 2.通过过程creat...
  • 编写一个单处理机下进程调度程序,模拟操作系统对进程的调度。 要求: 1.能够创建指定数量的进程,每个进程由一个进程控制块表示。 2.实现先来先服务调度算法:进程到达时间可由进程创建时间表示。 3.实现短作业...
  •  编写一个单处理机下进程调度程序,模拟操作系统对进程的调度。 实验目的: 进程是操作系统中最基本、最重要的概念,进程调度又是操作系统的核心模块。本实验要求学生独立设计并实现进程调度模拟程序,以加深对...
  • 操作系统设计实现一个简单的数据链路层协议编写程序完成处理器系统的进程调度,要求采用时间片轮转法调度策略。
  • 操作系统实验 模拟实现单处理机下进程调度程序 包括先来先服务 短作业优先 时间片轮转 动态优先级 并有详细注释
  • 单处理机调度按优先级数进行调度的算法,可以通过pcb块代表进程,编写程序进行模拟调度.本程序代码可供大家参考.
  • 假设某单处理机系统采用“基于动态优先权的时间片轮转”调度算法,系统允许进程的最大个数为10。进程队列采用单向链表组织进程控制块。请编程实现该算法。 三、实验要求 1.进程控制块的数据结构定义如下: ...

    一、实验目的
            了解并掌握进程、进程调度的概念及进程调度算法。
    二、实验内容
            假设某单处理机系统采用“基于动态优先权的时间片轮转”调度算法,系统允许进程的最大个数为10。进程队列采用单向链表组织进程控制块。请编程实现该算法。


    三、实验要求
        1.进程控制块的数据结构定义如下:
             pointer=^pcb;
             pcb=RECORD
                    name:char;
                    status:string;
                    priority:integer;//进程动态优先级
                    ax:integer;
                    next:pointer;
                    times://进程要求服务时间
                  END;
            2.通过过程creat创建进程,进程控制块的相关数据手动输入(当输满10个或进程名为“0”时结束输入)

            3. 通过函数schedule进行进程调度,并输出调度的顺序。
            4. 时间片长度自行设定,动态优先权的修改方法自行设定(但必须符合算法设计的原则),不足的条件可自行补充。

    展开全文
  • 操作系统实验-单处理机系统的进程调度

    千次阅读 多人点赞 2018-12-17 17:43:56
    通过模拟进程控制方法和单处理机系统进程调度,了解进程的结构、进程的创建与撤销,进程的组织及进程的状态及其转换,掌握进程调度策略。 (二)实验材料和仪器设备 Windows操作系统环境的个人微机。 (三...

    实验项目一:单处理机系统的进程调度 4学时

    (一)实验目的要求

    通过模拟进程控制方法和单处理机系统下的进程调度,了解进程的结构、进程的创建与撤销,进程的组织及进程的状态及其转换,掌握进程调度策略。

    (二)实验材料和仪器设备

    Windows操作系统环境下的个人微机。

    (三)实验内容

    设计实现一个对N个进程采用动态优先权算法的进程调度。本实验为单机模拟进程调度算法,在程序设计时不需真正地建立线程或进程。

    程序要求:为了清楚地观察诸进程的调度过程,程序中应有显示或打印语句,能显示或打印每次被选中进程的进程名,以及运行一次后进程队列的变化。打印程序运行时的初值和运行结果的要求如下:

    I)进程控制块的初始状态。

     

    II)选中运行的进程名以及选中进程运行后的各进程控制块状态。

     

    对于II要求每选中一个进程运行后都要打印。

    【提示】

    (1)假定系统有5个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:

    进程名

    指针

    要求运行时间

    优先数

    状态

    其中,进程名——作为进程的标识,假设五个进程的进程名分别为P1,P2,P3,P4,P5。

    指针——按优先数的大小把5个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”。

    要求运行时间——假设进程需要运行的单位时间数。

    优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。

    状态——可假设有两种状态,“就绪”状态和“结束”状态。5个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。

    (2)在每次运行设计的处理机调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。

    (3)为了调度方便,把5个进程按给定的优先数从大到小连成队列。用一单元指出队首进程,用指针指出队列的连接情况。例: 

      队首标志

             K2    

    K1

    P1

     K2

    P2

     K3

    P3

     K4

    P4

     K5

    P5

     

    0

     

    K4

     

    K5

     

    K3

     

    K1

     

    2

     

    3

     

    1

     

    2

     

    4

     

    1

     

    5

     

    3

     

    4

     

    2

     

    R

     

    R

     

    R

     

    R

     

    R

     

    PCB1

     

    PCB2

     

    PCB3

     

    PCB4

     

    PCB5

    (4)处理机调度总是选队首进程运行。优先权改变的原则,进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:

    优先数-1

    要求运行时间-1

    来模拟进程的一次运行。

    提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行结束。在这里省去了这些工作。

    (5)进程运行一次后,若要求运行时间¹0,则再将它加入队列(按优先数大小插入,且置队首标志);若要求运行时间=0,则把它的状态修改成“结束”(E),且退出队列。

    (6)若“就绪”状态的进程队列不为空,则重复上面(4)和(5)的步骤,直到所有进程都成为“结束”状态。

    (7)为5个进程任意确定一组“优先数”和“要求运行时间”,启动所设计的处理机调度程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

     

    代码:

    #include<iostream>
    #include<queue>
    #include<vector>
    #define maxn 10
    #define R true
    #define E false
    using namespace std;
    
    struct Node
    {
    	string name;  //进程名 
    	int *p;       //指针 
    	int ndtime;   //需要运行时间 
    	int prenum;   //优先级数 
    	int state;    //状态 
    }pcb[maxn];
    
    struct cmp
    {
    	bool operator()(const Node &p,const Node &q){
    		return p.prenum<q.prenum;  //根据优先级数从大到小排序 
    	}
    };
    void RunQueue(int n);
    void MuiltyInput();
    void Init(); 
    
    int main()
    {
    	Init();
    	
    	RunQueue(5);
    	
    	MuiltyInput();
    	
    	return 0;
    }
    void Init()
    {
    	printf("以下是进程数为5的情况的展示:\n");
    	pcb[1].name = "k1";
    	pcb[1].ndtime = 10;
    	pcb[1].prenum = 17;
    	pcb[1].state = R;			
    	
    	pcb[2].name = "k2";
    	pcb[2].ndtime = 8;
    	pcb[2].prenum = 15;
    	pcb[2].state = R;
    	
    	pcb[3].name = "k3";
    	pcb[3].ndtime = 9;
    	pcb[3].prenum = 16;
    	pcb[3].state = R;
    	
    	pcb[4].name = "k4";
    	pcb[4].ndtime = 5;
    	pcb[4].prenum = 14;
    	pcb[4].state = R;
    	
    	pcb[5].name = "k5";
    	pcb[5].ndtime = 6;
    	pcb[5].prenum = 18;
    	pcb[5].state = R;
    }
    void RunQueue(int n)
    {
    	priority_queue<Node,vector<Node>,cmp> q;
    	vector<string> v;
    	
    	for(int i=1;i<=n;++i)
    	{
    		cout<<"将进程"<<pcb[i].name<<"加入队列"<<endl; 
    		q.push(pcb[i]);
    	}
    	while(!q.empty()){
    		Node t = q.top();
    		q.pop();
    		cout<<"执行进程"<<t.name<<endl;
    		v.push_back(t.name);
    		t.prenum -= 1;
    		t.ndtime -= 1;
    		if(t.ndtime!=0){
    			q.push(t);
    			cout<<"将进程"<<t.name<<"再次加入队列"<<endl; 
    		}
    		else{
    			cout<<"进程"<<t.name<<"退出队列,状态为结束"<<endl;
    			t.state = E;
    		}
    	}
    	cout<<"============模拟进程结束============="<<endl; 
    	
    	cout<<"进程运行序列为:"<<endl;
    	for(int i=0;i<v.size();++i){
    		cout<<v[i]<<" ";
    	}
    	cout<<endl;
    	
    }
    void MuiltyInput()
    {
    	int n;  //进程数 
    	while(1){
    		printf("请输入进程数(1-6) : ");
    		scanf("%d",&n);
    		for(int i=1;i<=n;++i){
    			printf("请输入第%d个进程的 运行所需时间(5-10),优先级数(10-20),运行状态(0/1,初始为1):\n",i);
    			scanf("%d %d %d",&pcb[i].ndtime,&pcb[i].prenum,&pcb[i].state);
    		} 
    		RunQueue(n);
    	} 
    } 
    

     运行结果截图:

    假设5个进程的运行结果:

     

    输入任意进程数的运行结果:

    展开全文
  • 对于批量型作业而言,通常需要经历作业调度(又称为高级调度或长程调度)和进程调度(又称为低级调度或短程调度)两个过程后方能获得处理机;对于终端型作业,通常只需要经过进程调度即可获得处理机。 高级调度的...

    在多道程序系统中,主存中有着多个进程,其数目往往多于处理机数目,这就要求系统能按照某种算法,动态地将处理机分配给就绪队列中的某个进程,使之执行。
    对于批量型作业而言,通常需要经历作业调度(又称为高级调度或长程调度)和进程调度(又称为低级调度或短程调度)两个过程后方能获得处理机;对于终端型作业,通常只需要经过进程调度即可获得处理机。

    高级调度的对象是作业,作业和进程是不同的东西。 作业是一个更为广泛的概念,作业不仅包含了通常的程序和数据,还应该包含一份作业说明书,系统根据说明书来对程序的运行进程控制。

    进程调度:是指对处于就绪状态的多个进程,按照一定的策略选出一个进程使之从就绪状态变成执行状态,真正获得CPU来运行程序。

    进程调度方式:

    1.非抢占式:采用这种调度方式时,一旦处理机分配给某个进程后,不管该进程运行多长时间,都会让它一直运行下去,不会因为其他原因而抢占正常运行进程的处理机。

    引起原因:
    1)正在执行的进程执行结束,或因某个原因该进程不再执行。

    2)该进程执行过程中因为提出I/O请求而暂停执行。

    3)在进程通信或同步过程中执行了某个原语操作,如P操作。

    2.抢占式:这种调度方式允许调度程序按照某种原则去暂停某个正在执行的进程,将已分配给该进程的处理机重新分配给另外一个进程。

    引起原因:
    1)优先权原则。当一些优先权较高的进程或作业到达时,正在执行的进程会停止,调度程序将处理机分配给优先权更高的进程。

    2)短作业(进程)优先原则。当新到达的进程或作业比正在执行的进程或作业执行时间短,调度程序将处理机分配给短进程。

    3)时间片原则。各进程按照时间片轮流运行,当前时间片用完之后,该进程便停止执行,调度程序进程重新调度。

    调度算法

    作业调度:FCFS、SJF、高优先权优先、高响应比优先
    进程调度:FCFS、SJF、高优先权优先、时间片轮转

    1.先来先服务(FCFS)调度算法

    该算法根据名字就很好理解,先来后到,始终选队首进程(作业),进程获得CPU,直至执行完毕或发生某个等待事件,释放CUP。
    该调度算法有利于长进程(作业),不利于短进程(作业)。

    2.短作业(进程)优先(SJF)调度算法

    和FCFS类似,只是在进行选择的时候,从后备队列中选择一个运行时间最短的进程(作业)。
    该调度算法不利于长进程(作业),也没有考虑到进程的紧迫程度。

    3.高优先权优先调度算法

    1)静态优先级 调度算法:进程创建时被赋予优先级,而且在进程的运行过程中保持不变,优先级最高的进程率先被调度,优先级相同的进程采用FCFS调度算法

    2)动态优先级 调度算法:进程创建时赋予优先级,但是优先级在运行过程中可以改变,以便获得更好的调度性能。 优先级最高的先被调度,优先级相同的进程采用FCFS调度算法。

    4.高响应比有限调度算法

    优先权 = (等待时间 + 要求服务时间)/ 要求服务时间

    从上面的式子可以看出:
    1)当作业的等待时间相同时,如果要求服务的时间越短,优先权越大,所以该算法更有利于短作业。

    2)当作业的要求服务时间相同时,等待时间越长,优先权越高,此时它实现的是FCFS。

    3)对于长作业而言,作业的优先级可以随着等待时间的增加而提高,,当期等待时间达到一定程度时,其优先级也能提升到很高,从而也能获得处理机。

    5.时间片轮转调度算法

    每个进程按照先进先出的原则进入就绪队列,每次调度时,调度程序将CPU分配给队首的进程,让其执行一个时间片q,该进程运行完时间片q后,有以下几种情况:
    1)该进程执行完毕,调度下一个进程运行

    2)该进程未执行完,进程执行被时钟中断,排到就绪队列队尾,特别注意:如果这个时候有一个新到达的进程,则刚才时间片用完的进程排在新到达进程的后面。然后调度就绪队列中的下一个进程执行。

    3)该进程I/O等原因而被阻塞,该进程进入阻塞队列,调度就绪队列的下一个进程执行,等该进程被解封后,再从阻塞队列进入就绪队列队尾。

    展开全文
  • 处理机进程调度模拟

    千次阅读 2015-12-27 13:53:02
    这就要求进程调度程序按一定的策略,动态地把处理机分配给处于就绪队列中的某一个进程,以使之执行。进程调度属于处理机调度。   处理机调度分为三个层次: 高级调度:(High-Level Scheduling)又称为长程调度、...
  • 操作系统实验之单处理机系统的进程调度 假设某单处理机系统采用“基于动态优先权的时间片轮转”调度算法。进程队列采用单向链表组织进程控制块。 过程:假设进入的进程有3个,轮转时间片为5 运行逻辑如下: ...
  • 1. 处理机调度概念 ...处理机调度就是从就绪队列中挑选一个占用CPU运行的进程单处理机),如果是多处理机的话,就还包含从多个可以用的CPU中挑选就绪进程可使用的CPU资源。 调度程序是指在内核当中,用...
  • 操作系统3——处理机调度(作业调度+进程调度) 目录 操作系统3——处理机调度(作业调度+进程调度) 1、处理机的调度层次和目标 2、作业调度——先来先服务调度算法(FCFS) 3、作业调度——短作业优先调度...
  • 描述处理机进程调度过程 C和C++实现 采用链表形式,按进程优先级进行进程调度
  • 自己写的代码和实验报告,模拟了在单处理机系统进程调度。适于操作系统初学者理解操作系统中的进程调度原理。(希望朋友们先根据要求自己实现代码,然后再参考我的代码。)
  • 自己改的·实现4种算法(先进先出FIFO,短作业优先SJF,高响应比优先HRN,时间片)界面不错。用户输入进程,创建进程。高响应比优先包括2个,一个是静态优先级,一个动态优先级
  • 处理机调度

    2018-05-17 10:26:47
    内容主要包括: 处理机的多级调度 作业调度 进程调度 UNIX系统的进程调度 Linux系统的进程调度
  • 多处理器系统进程分配多处理器系统 (MPS) 的类型 ...进程调度在主处理器上执行。 有潜在的不可靠性(主机故障造成系统崩溃)。 对称多处理器系统中进程分配方式 静态分配 每个 CPU 设立一个就绪队列,进程从开
  • 处理机调度算法详解----进程调度

    千次阅读 2020-01-25 17:43:17
    进程调度调度的对象是进程,其主要任务是根据某种算法,选取处于就绪队列中的进程,并由分派程序将处理机分配给被选中的进程。进程调度是一种最基本的调度,在多道批处理、分时和实时等OS中,都必须要配置这级调度。...
  • 进程调度处理机管理的核心内容。本实验要求用C语言编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念,并体会和了解优先数和时间片轮转调度算法的具体实施办法。
  • 实验内容: 编写一个单处理机下进程调度程序,模拟操作系统对进程的调度。 要求:能够创建指定数量的进程,每个进程由一个进程控制块表示。 实现先来先服务调度算法:进程到达时间可由进程创建时间表示。 3.实现短作业...
  • 问题一:在0时刻,进程A进入系统,按照这个顺序,在30时刻,进程B和进程C也抵达;在90时刻,进程D和进程E也抵达。一个时间片是10个单元。(进程A需要占用CPU 50个单元;进程B需要占用CPU 40个单元;进程C需要占用CPU...
  • 低级调度(进程调度/处理机调度)频率最高 进程的七状态模型 五状态模型 -> 七状态模型 进程调度的时机 1、当前运行的进程主动放弃处理机 2、当前运行的进程被动放弃处理机 补充:不能进行进程调度与切换的情况 进程...
  • 亲测可用!有源码!!处理器系统的进程调度算法。(单处理机系统采用“基于动态优先权的时间片轮转”调度算法,系统允许进程的最大个数为10。进程队列采用单向链表组织进程控制块。 )
  • 处理机调度 知识点归纳 1调度的基本概念 1调度的层次 高级调度 中级高度 低级调度 各层调度的运行频率 高级调度<中级高度<低级调度 处理机调度 知识点归纳 1调度的基本概念 2CPU调度程序 3作业调度与进程调度的区别 ...
  • 进程调度

    千次阅读 2012-12-04 15:27:35
    这就要求进程调度程序按一定的策略,动态地把处理机分配给处于就绪队列中的某一个进程,以使之执行。 目录 进程有四个基本属性进程的三种基本状态处理机调度的分级进程调度的方式 非剥夺方式...
  • 模拟处理机调度算法

    2011-11-19 10:53:55
    该算法模拟操作系统里面处理机的基本调度过程,实现了简单的处理机进程调度

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 124,283
精华内容 49,713
关键字:

单处理机下进程的调度