精华内容
下载资源
问答
  • 教育资料 xx大学 操作系统 实验报告 姓名 学号 班级 实验日期 实验名称先来先服务FCFS和短作业优先SJF进程调度算法 实验一 先来先服务FCFS和短作业优先SJF进程调度算法 1. 实验目的 通过这次实验理解FCFS和SJF进程...
  • 进程调度算法实验

    2012-05-03 16:34:13
    设有两个并发执行的父子进程,不断循环输出各自进程号、优先数和调度策略。进程初始调度策略均为系统默认策略和默认优先级。当父进程收到SIGINT信号时会自动将其优先数加 1,子进程收到SIGTSTP信号时会自动将其优先数...
  • 操作系统实验三:进程调度算法实验报告。加深对进程调度概念的理解,体验进程调度机制的功能,了解Linux系统中进程调度策略的使用方法。 练习进程调度算法的编程和调试技术。三种调度方法:  1,SCHED_OTHER 分时...
  • 先来先服务FCFS和短作业优先SJF进程调度算法 实验题目先来先服务FCFS和短作业优先SJF进程调度算法 通过这次实验加深对进程概念的理解进一步掌握进程状态的 转变进程调度的策略及对系统性能的评价方法 实验内容 问题...
  • 操作系统进程调度算法,循环轮转算法和优先级数算法
  • 多级反馈进程调度算法 实验报告 及程序代码
  • 设有两个并发执行的父子进程,不断循环输出各自进程号、优先数和调度策 略。进程初始调度策略均为系统默认策略和默认优先级。当某个进程收到 SIGINT 信号时会自动将其优先数加 1,收到 SIGTSTP 信号时会自动将其优先数...
  • 先来先服务和短作业优先
  • 2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。 3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。 很完整的报告,提供三种调度方式//////
  • 文章目录一、实验时间二、实验说明三、示例实验四、实验要求五、注意事项 ...2.设置进程调度策略的系统调用语法 int sched_setscheduler(pid_t pid,int policy,const struct sched_param *sp); pid:

    一、实验时间

    2021年4月29日,星期四,第9周

    二、实验说明

    1.在linux系统中调度策略分为3种

    • SCHED_OTHER:默认的分时调度策略,值为0
    • SCHED_FIFO:先进先出调度,值为1
    • SCHED_RR:轮转法调度,值为2

    2.设置进程调度策略的系统调用语法

    int sched_setscheduler(pid_t pid,int policy,const struct sched_param *sp);
    
    • pid:进程号
    • policy:三种调度策略之一
    • sp:调度参数结构指针,里面有调度优先数

    执行成功则返回0

    3.获取进程调度策略的系统调用语法

    int sched_getscheduler(pid_t pid);
    
    • pid 进程号

    返回值: 进程当前的调度策略

    4.获取进程动态优先数的系统调用语法

    int getpriority(int which,int who);
    

    which代表设置的对象,which的值可以是

    • 进程 PRIO_PROCESS
    • 进程组 PRIO_PGRP
    • 用户 PRIO_USER

    who 对应设置对象的进程号或组号或用户号

    返回值: 所有匹配进程中的最高优先数

    5.设置进程动态优先数的系统调用语法

    int setpriority(int which,int who,int prio);
    

    which代表设置的对象,which的值可以是

    • 进程 PRIO_PROCESS
    • 进程组 PRIO_PGRP
    • 用户 PRIO_USER

    who 对应设置对象的进程号或组号或用户号
    prio 要设置的进程优先数
    返回值: 所有匹配进程中的最高优先数

    三、示例实验

    本例演示实验指导书上的示例实验

    #include <stdio.h>
    #include <stdlib.h>
    #include <sched.h>
    #include <sys/time.h>
    #include <sys/resource.h>
    int main(int argc, char *argv[])
    {
        int i,j,status;
        int pid[3]; //存放进程号
        struct sched_param p[3]; //设置调度策略时使用的数据结构
        for(i=0; i<3;i++)
        {
            //循环创建3 个子进程
            if((pid[i]=fork()) >0)
            {
                //取进程优先数放在调度策略数据结构中
                p[i].sched_priority = (argv[i+1] != NULL) ? atoi(argv[i+1]):10;
                //父进程设置子进程的调度策略.如果命令行第4,5,6 参数指定了3个策略值则按指定的数设置,否则都为默认策略
                sched_setscheduler(pid[i],(argv[i+4] != NULL) ? atoi(argv[i+4]) : SCHED_OTHER,&p[i]);
                //父进程设置子进程的优先数,如果命令行第1,2,3 参数指定了3个优先数则按指定的数设置,否则都为10
                setpriority(PRIO_PROCESS,pid[i],(argv[i+1] != NULL) ? atoi(argv[i+1]):10);
            }
            //各子进程循环报告其优先数和调度策略
            else
            {
                sleep(1);
                //每隔1 妙报告一次进程号和优先级
                for(i=0; i<10; i++)
                {
                    printf("Child PID = %d priority = %d\n",getpid(),getpriority(PRIO_PROCESS,0));
                    sleep(1);
                }
                exit( EXIT_SUCCESS);
            }
        }
        //父进程报告子进程调度策略后先行退出
        printf("My child %d policy is %d\n",pid[0],sched_getscheduler(pid[0]));
        printf("My child %d policy is %d\n",pid[1],sched_getscheduler(pid[1]));
        printf("My child %d policy is %d\n",pid[2],sched_getscheduler(pid[2]));
        return EXIT_SUCCESS;
    }
    

    通过这个实验,我们需要重点理解以下几个方法:

    • 输出优先级的方法:getpriority(PRIO_PROCESS,int pid);
    • 输出调度策略:sched_getscheduler(int pid);
    • 设置优先级的方法:setpriority(PRIO_PROCESS,int pid,int prio);

    四、实验要求

    设有两个并发执行的父子进程,不断循环输出各自进程号、优先数和调度策略。
    进程初始调度策略均为系统默认策略和默认优先级。当某个进程收到SIGINT信号时会自动将其优先数加1,收到SIGTSTP信号时会自动将其优先数减1。请编程实现以上功能。

    要完成这个实验,我们需要熟悉以下几个方法

    (1)输出进程号的方法:getpid();
    (2)输出优先级的方法:getpriority(PRIO_PROCESS,int pid);
    (3)输出调度策略:sched_getscheduler(int pid);
    (4)设置优先级的方法:setpriority(PRIO_PROCESS,int pid,int prio);
    

    还需要注意两个信号对应的是什么控制

    • SIGINT信号:按下Ctrl+C时触发
    • SIGTSTP信号:按下Ctrl+Z时触发

    本次实验源代码

    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <signal.h>
    #include <sched.h>
    #include <sys/time.h>
    #include <sys/resource.h>
    static int flag = 0;
    //加信号
    void add(int sig)
    {
        flag++;
    }
    //减信号
    void minus(int sig)
    {
        flag--;
    }
    int main()
    {
        //绑定信号
        signal(SIGINT,add);
        signal(SIGTSTP,minus);
        int pid = fork();
        if(pid == 0)
        {
            while(1)
            {
                //设置进程的优先级
                setpriority(PRIO_PROCESS,pid,flag);
                //输出进程号
                printf("child pid = %d\n",pid);
                //输出优先级
                printf("child process priority = %d\n",getpriority(PRIO_PROCESS,pid));
                //输出调度策略
                printf("child process scheduler = %d\n",sched_getscheduler(pid));
                sleep(2);
            }
        }
        else if(pid > 0)
        {
            while(1)
            {
                //设置进程的优先级
                setpriority(PRIO_PROCESS,getpid(),flag);
                //输出进程号
                printf("parent pid = %d\n",getpid());
                //输出优先级
                printf("parent process priority = %d\n",getpriority(PRIO_PROCESS,getpid()));
                //输出调度策略
                printf("parent process scheduler = %d\n",sched_getscheduler(getpid()));
                sleep(2);
            }
        }
    }
    

    程序运行结果如下

    当按下Ctrl+C时,优先级+1。当按下Ctrl+Z时,优先级-1
    在这里插入图片描述
    在这里插入图片描述

    五、注意事项

    1.一开始在写程序的时候,按下ctrl+c能实现进程优先级+1,但按下ctrl+z时进程优先级不变,后来问了别人才知道只有切换到root权限之后才能实现进程优先级-1

    2.打开终端,敲sudo su,之后输入密码即可切换到root模式,这样程序就运行成功了

    展开全文
  • 共有4个操作系统实验。分别是作业调度算法的实现、进程调度算法的模拟实现、分区式存储管理算法实现、页面调度算法的模拟实现。实验环境是Visual Studio。
  • 进程调度算法模拟 专业 XXXXX 学号 XXXXX 姓名 XXX 实验日期 20XX 年 XX 月 XX 日 一实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解 二实验要求 编写程序实现对 5 个进程的调度模拟 要求至少...
  • 进程调度算法模拟实验报告。doc
  • 进程调度算法实验报告
  • 华北科技学院计算机系综合性实验报告 操作系统 实验题目 进程调度算法模拟 一实验目的 通过对进程调度算法的模拟进一步理解进程的基本概念加深对进程运行状态和进程调度 过程调度算法的理解 二设备与环境 1硬件设备 ...
  • 操作系统 进程调度算法实验结果 最高优先数优先
  • 模拟实现进程调度算法实验目的: 1、进程调度是处理机管理的核心内容。观察、体会操作系统的进程调度方法,并通过一个简单的进程调度模拟程序的实现,加深对进程控制块、进程队列、进程调度算法,进程切换的理解,...
  • 进程调度算法 ** 1. 实验要求 编写并调试一个模拟的进程调度程序 基础实验:要求实现动态优先数调度 加分实验:要求将动态优先数调度修改成静态优先数调度 (只需要排一次序,rtime不需要) 2.算法描述 “最高...

    **

    进程调度算法

    **

    1. 实验要求

    • 编写并调试一个模拟的进程调度程序
    • 基础实验:要求实现动态优先数调度
    • 加分实验:要求将动态优先数调度修改成静态优先数调度
      (只需要排一次序,rtime不需要)

    2.算法描述

    1. “最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。 每个进程有一个进程控制块( PCB)表示。

    2. 进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。进程的到达时间为进程输入的时间。

    3. 静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。 (只需要排一次序,rtime错误)

    4. 动态优先数是指进程的优先数(0-7,0-255)在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数。例如:在进程获得一次CPU后就将其优先数减少1

    5. 进程等待的时间超过某一时限时增加其优先数的值,等等。动态优先数调度算法流程图如下:

    进程调度

    3.实验源程序代码

    动态优先数:

    #include "stdio.h"
    #include <stdlib.h>
    #include <conio.h>
    #define getpch(type) (type*)malloc(sizeof(type))
    #define NULL 0
    
    //进程调度源程序如下: ntime  ==   rtime 结束
    
    
    struct pcb   /* 定义进程控制块PCB */
    {
        char name[10];
        char state;
        int super; //优先级
        int ntime; //进程执行完成所需要时间
        int rtime; //进程已经执行时间
        struct pcb* link;
    }*ready=NULL,*p;
    typedef struct pcb PCB;
    void 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;
        }
    }
    void 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(); /* 调用sort函数*/
        }
    }
    int space()
    {
        int l=0;
        PCB* pr=ready;
        while(pr!=NULL)
        {
            l++;
            pr=pr->link;
        }
        return(l);
    }
    void 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");
    }
    void check() /* 建立进程查看函数 */
    {
        PCB* pr;
        printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/
        disp(p);
        pr=ready;
        printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/
        while(pr!=NULL)
        {
            disp(pr);
            pr=pr->link;
        }
    }
    void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
    {
        printf("\n 进程 [%s] 已完成.\n",p->name);
        free(p);
    }
    void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
    {
        (p->rtime)++;
        if(p->rtime==p->ntime)
            destroy(); /* 调用destroy函数*/
        else
        {
            (p->super)--;
            p->state='w';
            sort(); /*调用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();
    
        return 0;
    }
    
    

    运行截图:
    操作系统实验2-1

    操作系统实验2-2
    操作系统实验2-3

    赋值注意事项:
    1、进程个数>=3
    2、进程所需要运行时间ntime<=5
    3、ntime == rtime进程结束
    

    静态优先数:

    在动态优先数上进行改变即可:只需要排一次序,删除rtime

    #include "stdio.h" 
    #include <stdlib.h> 
    #include <conio.h> 
    #define getpch(type) (type*)malloc(sizeof(type)) 
    #define NULL 0 
    struct pcb { /* 定义进程控制块PCB */ 
    	char name[10]; 
    	char state; 
    	int super; 
    	int ntime; //进程执行完成所需要时间
    //	int rtime; //进程已经执行时间
    	struct pcb* link; 
    }*ready=NULL,*p; 
    
    typedef struct pcb PCB; 
    
    void 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; 
    	} 
    }
    
    void 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(); /* 调用sort函数*/ 
    	} 
    } 
    
    int space() 
    { 
    	int l=0; PCB* pr=ready;
    	while(pr!=NULL) 
    	{ 
    		l++; 
    		pr=pr->link; 
    	} 
    	return(l); 
    } 
    
    void 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"); 
    }
    
    void check() /* 建立进程查看函数 */ 
    { 
    	PCB* pr; 
    	printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ 
    	disp(p); 
    	pr=ready; 
    	printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/ 
    	while(pr!=NULL) 
    	{ 
    		disp(pr); 
    		pr=pr->link; 
    	} 
    } 
    void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ 
    { 
    	printf("\n 进程 [%s] 已完成.\n",p->name); 
    	free(p); 
    } 
    //void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
    //{(p->rtime)++; 
    //if(p->rtime==p->ntime) 
    //destroy(); /* 调用destroy函数*/ 
    //else 
    //{ 
    //	(p->super)--; 
    //	p->state='w'; 
    //	sort(); /*调用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(); 
    	
    	return 0;
    }
    
    
    展开全文
  • 操作系统实验报告 实验一 先来先服务 FCFS和短作业优先 SJF进程调度算法 学号 班级 姓名 实验题目 先来先服务 FCFS和短作业优先 SJF进程调度算法 实验目的 通过这次实验加深对进程概念的理解进一步掌握进程状态的...
  •  了解进程调度算法的特点2. 掌握进程调度算法,如先来先服务调度算法(first come first served,FCFS)、短作业优先调度算法(shotjob first,SJF)、时间片轮转调度算法。 二、 实验内容设计模拟实现FCFS、SJF、...

    一、  实验目的和要求

    1.  了解进程调度算法的特点

    2.  掌握进程调度算法,如先来先服务调度算法(first come first served,FCFS)、短作业优先调度算法(shotjob first,SJF)、时间片轮转调度算法。

     

    二、    实验内容

    设计模拟实现FCFS、SJF、时间片轮转调度算法的C语言程序

    1.  FCFS算法:按照作业/进程进入队列的先后顺序进行挑选,先进入的将先进行后续步骤的处理。

    2.  SJF算法:以进入系统的作业所要求的CPU运行时间的长短为挑选依据,优先选取预计所需服务时间最短的作业进行调度,可以分别用于高级调度和低级调度。

    3.  时间片轮转算法:将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把处理机分配给队首进程,并令其执行一个时间片。

     

    三、  实验步骤

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

    2.  完成算法代码。

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

     

    四、     实验源程序

    代码:

    #include <stdio.h>

    #include <iostream>

    #include <queue>

    #include <stack>

    #include <set>

    #include <string>

    #include <cstring>

    #include <cmath>

    #define MAX 1111

    const double Max = 11111.0;

    using namespace std;

    typedef struct FCFS

    {

        int mark;

        string name;

        doublearrivetime;

        doubleservetime;

        doublestarttime;

        doublefinishtime;

        doubleroundtime;

        doubledaiquantime;

        bool operator< (const FCFS &a)const{

            returnarrivetime > a.arrivetime;

        }

    }FCFS;

     

    typedef struct SJF

    {

        int mark;

        string name;

        doublearrivetime;

        doubleservetime;

        doublestarttime;

        doublefinishtime;

        doubleroundtime;

        doubledaiquantime;

        bool operator< (const SJF &a)const{

            returnservetime > a.servetime;

        }

    }SJF;

     

    typedef struct RDRN

    {

        int mark;

        bool flag =true;

        string name;

        double Count =0.0;

        doublearrivetime;

        doubleservetime;

        doublestarttime;

        doublefinishtime;

        doubleroundtime;

        doubledaiquantime;

        double running= 0.0;

        bool operator< (const RDRN &a)const{

            returnCount > a.Count;

        }

    }RDRN;

     

     

    void FCFS_arithmetic()

    {

        FCFS f[MAX];

        FCFS ff;

        int n;

        doubleaveragedaiquantime = 0.0;

       priority_queue<FCFS> q1;

        printf("请输入作业数(整数)\n");

       scanf("%d",&n);

        printf("请输入n组数据,每组数据包括作业名字(字符串)、作业到达时间(浮点数)、作业服务时间(浮点数)(每组数据的给元素之间用空格隔开!):\n");

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

            f[i].mark =i;

           cin>>f[i].name;

            scanf("%lf%lf",&f[i].arrivetime,&f[i].servetime);

           q1.push(f[i]);

        }

        doublestarttime = 0.0;

        ff = q1.top();

        q1.pop();

       f[ff.mark].starttime = ff.arrivetime;

       f[ff.mark].finishtime = f[ff.mark].starttime + ff.servetime;

       f[ff.mark].roundtime = f[ff.mark].finishtime - f[ff.mark].arrivetime;

       f[ff.mark].daiquantime = f[ff.mark].roundtime / f[ff.mark].servetime;

        starttime =f[ff.mark].finishtime;

        printf("先来先服务调度算法的作用时间表:\n\n");

        printf("作业名字 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");

       cout<<"  "<<f[ff.mark].name;

    printf("%10.2f %8.2f %8.2f %8.2f %8.2f%8.2f\n",f[ff.mark].arrivetime,f[ff.mark].servetime,f[ff.mark].starttime,f[ff.mark].finishtime,f[ff.mark].roundtime,f[ff.mark].daiquantime);

       while(!q1.empty()){

            ff =q1.top();

            q1.pop();

           f[ff.mark].starttime = starttime;

           f[ff.mark].finishtime = f[ff.mark].starttime + ff.servetime;

           f[ff.mark].roundtime = f[ff.mark].finishtime - f[ff.mark].arrivetime;

           f[ff.mark].daiquantime = f[ff.mark].roundtime / f[ff.mark].servetime;

           averagedaiquantime += f[ff.mark].daiquantime;

            starttime =f[ff.mark].finishtime;

           cout<<"  "<<f[ff.mark].name;

    printf("%10.2f %8.2f %8.2f %8.2f %8.2f%8.2f\n",f[ff.mark].arrivetime,f[ff.mark].servetime,f[ff.mark].starttime,f[ff.mark].finishtime,f[ff.mark].roundtime,f[ff.mark].daiquantime);

        }

        printf("\n平均代权周转时间:\n");

       printf("%.2f\n",averagedaiquantime/n);

    }

     

    void SJF_arithmetic()

    {

        SJF f[MAX];

        SJF ff;

        int n;

        doublestarttime = Max;

        doubleaveragedaiquantime = 0.0;

       priority_queue<SJF> q1;

        printf("请输入作业数(整数)\n");

       scanf("%d",&n);

        printf("请输入n组数据,每组数据包括作业名字(字符串)、作业到达时间(浮点数)、作业服务时间(浮点数)(每组数据的给元素之间用空格隔开!):\n");

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

            f[i].mark =i;

           cin>>f[i].name;

           scanf("%lf %lf",&f[i].arrivetime,&f[i].servetime);

           if(f[i].arrivetime < starttime) starttime = f[i].arrivetime;

           q1.push(f[i]);

        }

        printf("短作业优先调度算法的作用时间表:\n\n");

        int cnt = 0;

       while(!q1.empty()){

            SJFtemp[MAX];

            ff =q1.top();

            q1.pop();

           if(f[ff.mark].arrivetime <= starttime){

                for(inti=0; i<cnt; i++) q1.push(temp[i]);

                cnt =0;

               f[ff.mark].starttime = starttime;

               f[ff.mark].finishtime = f[ff.mark].starttime + ff.servetime;

               f[ff.mark].roundtime = f[ff.mark].finishtime - f[ff.mark].arrivetime;

               f[ff.mark].daiquantime = f[ff.mark].roundtime / f[ff.mark].servetime;

               averagedaiquantime += f[ff.mark].daiquantime;

               starttime = f[ff.mark].finishtime;

            }

            elsetemp[cnt++] = ff;

        }

        printf("作业名字 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");

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

           cout<<"  "<<f[i].name;

           printf("%10.2f %8.2f %8.2f %8.2f %8.2f%8.2f\n",f[i].arrivetime,f[i].servetime,f[i].starttime,f[i].finishtime,f[i].roundtime,f[i].daiquantime);

        }

        printf("\n平均代权周转时间:\n");

       printf("%.2f\n",averagedaiquantime/n);

    }

     

    void RDRN_arithmetic()

    {

        doubletimeslice;

        RDRN f[MAX];

        RDRN temp[MAX];

        int cnt = 0;

        RDRN ff;

        int n;

        doubleaveragedaiquantime = 0.0;

       priority_queue<RDRN> q1;

        printf("请输入作业数和时间片长度(作业数为整数,时间片长度可为浮点数,中间用空格隔开!):\n");

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

        int tot = n;

        printf("请输入n组数据,每组数据包括作业名字(字符串)、作业到达时间(浮点数)、作业服务时间(浮点数)(每组数据的给元素之间用空格隔开!):\n");

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

            f[i].mark =i;

           cin>>f[i].name;

           scanf("%lf %lf",&f[i].arrivetime,&f[i].servetime);

            f[i].Count= f[i].arrivetime;

           q1.push(f[i]);

        }

        double clock =q1.top().arrivetime;

        int t = 0;

        while(t != n){

            ff =q1.top();

           if(f[ff.mark].arrivetime <= clock && tot-- > 0){

               q1.pop();

               if(f[ff.mark].flag){

                   f[ff.mark].starttime = clock;

                   f[ff.mark].flag = false;

                }

     

               if(f[ff.mark].running != f[ff.mark].servetime){

                   double newtime = f[ff.mark].servetime - f[ff.mark].running;

                   if(newtime >= timeslice){

                       clock += timeslice;

                       f[ff.mark].running += timeslice;

                       f[ff.mark].Count += timeslice;

                    }

                   else{

                       clock += newtime;

                       f[ff.mark].running += newtime;

                       f[ff.mark].Count += newtime;

                    }

                   if(f[ff.mark].running != f[ff.mark].servetime) temp[cnt++] = f[ff.mark];

                }

     

               if(f[ff.mark].running == f[ff.mark].servetime){

                   t++;

                   f[ff.mark].finishtime = clock;

                   f[ff.mark].roundtime = f[ff.mark].finishtime - f[ff.mark].arrivetime;

                   f[ff.mark].daiquantime = f[ff.mark].roundtime / f[ff.mark].servetime;

                   averagedaiquantime += f[ff.mark].daiquantime;

                }

            }

     

            else{

                for(inti=0; i<cnt; i++) q1.push(temp[i]);

                cnt =0;

                tot =q1.size();

            }

        }

     

        printf("时间轮转调度算法的作用时间表:\n\n");

        printf("作业名字 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");

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

           cout<<"  "<<f[i].name;

    printf("%10.2f %8.2f %8.2f %8.2f %8.2f %8.2f\n",f[i].arrivetime,f[i].servetime,f[i].starttime,f[i].finishtime,f[i].roundtime,f[i].daiquantime);

        }

        printf("\n平均代权周转时间:\n");

       printf("%.2f\n",averagedaiquantime/n);

    }

     

    int main()

    {

       printf("********************************************************欢迎您!***********************************************************\n");

        int ca = 0;

        do{

           printf("\n请选择调度算法或结束程序:\n");

           printf("0、结束程序\n1、先来先服务\n2、短作业优先\n3、时间片轮转\n");

           scanf("%d",&ca);

            if(ca == 1)FCFS_arithmetic();

            if(ca == 2)SJF_arithmetic();

            if(ca == 3) RDRN_arithmetic();

        }while(ca);

        return 0;

    }

     

    五、  实验结果

    先来先服务调度算法:

    短作业优先调度算法:

     

    时间片轮转调度算法:

     


     

     


    展开全文
  • 操作系统:实验进程调度算法

    千次阅读 2019-11-08 15:31:31
    实验进程调度算法 一、实验目的  用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解. 二、实验指导 设计一个有 N个进程共行的进程调度程序。  进程调度算法:分别采用先来先服务...

    实验一 进程调度算法
    一、实验目的
      用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.
    二、实验指导
    设计一个有 N个进程共行的进程调度程序。
      进程调度算法:分别采用先来先服务算法、短作业优先算法、高响应比优先算法实现。
      每个进程用一个进程控制块( PCB)表示。进程控制块可以包含如下信息:进程名、优先级、到达时间、要求服务时间、进程状态等等。 其中到达时间和要求服务时间可以在程序中进行初始化或者在程序开始时由键盘输入。
      每个进程的状态可以是就绪 W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。
      每个进程完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间,这一组进程完成后要计算并打印这组进程的平均周转时间、带权平均周转时间。
       算法的流程图如图1-1
    三、提示
    1、在采用短作业优先算法和高响应比优先算法进行调度时应注意进程的到达时间,对于没有到达的进程不应参与调度。
    2、注意在采用高响应比优先算法时计算优先权的时机,因为采用动态优先权,所以应在每次调度之前都重新计算优先权,高响应比优先算法采用下列公式计算优先权
    在这里插入图片描述
    在这里插入图片描述
    fcfs算法:

    int cmp(PCB a,PCB b)//fcfs
    {
    	return a.arrive<b.arrive;
    }
    sort(pcb,pcb+5,cmp);
    for(int i=0; i<5; i++)
    {
    	if(pcb[i].arrive>finish)
    		pcb[i].end = pcb[i].arrive+pcb[i].service;
    	else
    		pcb[i].end = pcb[i].service+finish;
    	finish = pcb[i].end;
    	pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
    	pcb[i].start = pcb[i].end-pcb[i].service;
    	pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
    	sum_turnover+=pcb[i].turnover;
    	sum_author_turnover+=pcb[i].author_turnover;
    	fcfs.push_back(pcb[i]);
    }
    

    sjf算法:

    int cmp(PCB a,PCB b)//fcfs
    {
    	return a.arrive<b.arrive;
    }
    int cmp1(PCB a,PCB b)//sjf  排序,按service升序排序,如果service相等,则按arrive升序排序
    {
    	return (a.service<b.service)||(a.service==b.service&&a.arrive<b.arrive);
    }
    sort(pcb,pcb+5,cmp);//排序
    for(int i=0; i<5; i++)
    	{
    		while(j<5&&pcb[j].arrive<=finish)//当有新的进程的进入时间小于当前时间,就加入就绪队列 
    			j++;
    		sort(pcb+i,pcb+j,cmp1); 
    		if(pcb[i].arrive>finish)
    			pcb[i].end = pcb[i].arrive+pcb[i].service;
    		else
    			pcb[i].end = pcb[i].service+finish;
    		finish = pcb[i].end;
    		pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
    		pcb[i].start = pcb[i].end-pcb[i].service;
    		pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
    		sum_turnover+=pcb[i].turnover;
    		sum_author_turnover+=pcb[i].author_turnover;
    		sjf.push_back(pcb[i]);
    	}
    
    

    hrrn算法:

    int cmp(PCB a,PCB b)//fcfs
    {
    	return a.arrive<b.arrive;
    }
    int cmp2(PCB p1, PCB p2) //hrrn 
    {
    	return (p1.priority > p2.priority) || (p1.priority==p2.priority && p1.arrive<p2.arrive);
    }
    sort(pcb, pcb+5, cmp);
    for(int i = 0; i < 5; i++)
    	{
    		while(j<5 && pcb[j].arrive <= finish)
    			j++;
    		for(int k = i; k < j; k++)
    			pcb[k].priority = (finish-pcb[k].arrive+pcb[k].service) / pcb[k].service;
    		sort(pcb+i, pcb+j, cmp2);
    
    		if(pcb[i].arrive > finish)
    			pcb[i].end = pcb[i].arrive + pcb[i].service;
    		else
    			pcb[i].end = finish + pcb[i].service;
    		pcb[i].turnover = pcb[i].end - pcb[i].arrive;
    		finish = pcb[i].end;
    		pcb[i].start = pcb[i].end-pcb[i].service;
    		pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
    		sum_turnover+=pcb[i].turnover;
    		sum_author_turnover+=pcb[i].author_turnover;
    		hrrn.push_back(pcb[i]);
    	}
    

    源代码:

    #include<bits/stdc++.h>
    #include<windows.h>
    using namespace std;
    struct PCB
    {
    	int pid;//进程号
    	char pname;//进程名
    	double priority;//优先级
    	int arrive;//到达时间
    	int service;//服务时间
    	int start;//开始时间
    	int end;//结束时间
    	int turnover;//周转时间
    	double author_turnover;//带权周转时间
    } pcb[5];
    
    double fcfs_author,fcfs_turnover,sjf_author,sjf_turnover,hrrn_author,hrrn_turnover;
    vector<PCB> fcfs;
    vector<PCB> sjf;
    vector<PCB> hrrn;
    
    int cmp(PCB a,PCB b)//fcfs
    {
    	return a.arrive<b.arrive;
    }
    
    int cmp1(PCB a,PCB b)//sjf  排序,按service升序排序,如果service相等,则按arrive升序排序
    {
    	return (a.service<b.service)||(a.service==b.service&&a.arrive<b.arrive);
    }
    
    int cmp2(PCB p1, PCB p2) //hrrn 
    {
    	return (p1.priority > p2.priority) || (p1.priority==p2.priority && p1.arrive<p2.arrive);
    }
    
    void Compare()//打印算法对比 
    {
    	cout<<"先来先服务调度算法!"<<endl;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0;i<fcfs.size();i++)
    	{
    		cout<<"\t"<<fcfs[i].pname<<"\t\t"<<fcfs[i].arrive<<"\t\t"<<fcfs[i].service<<"\t\t"<<fcfs[i].end<<"\t\t"<<fcfs[i].turnover<<"\t\t";
    		printf("%.2lf\n",fcfs[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",fcfs_turnover);
    	printf("\t平均带权周转时间:%.2lf\n",fcfs_author);
    	
    	cout<<endl;
    	cout<<endl;
    	
    	cout<<"短作业优先算法!"<<endl;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0;i<sjf.size();i++)
    	{
    		cout<<"\t"<<sjf[i].pname<<"\t\t"<<sjf[i].arrive<<"\t\t"<<sjf[i].service<<"\t\t"<<sjf[i].end<<"\t\t"<<sjf[i].turnover<<"\t\t";
    		printf("%.2lf\n",sjf[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",sjf_turnover);
    	printf("\t平均带权周转时间:%.2lf\n",sjf_author);
    	
    	cout<<endl;
    	cout<<endl;
    	
    	cout<<"高响应比优先算法!"<<endl;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0;i<hrrn.size();i++)
    	{
    		cout<<"\t"<<hrrn[i].pname<<"\t\t"<<hrrn[i].arrive<<"\t\t"<<hrrn[i].service<<"\t\t"<<hrrn[i].end<<"\t\t"<<hrrn[i].turnover<<"\t\t";
    		printf("%.2lf\n",hrrn[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",hrrn_turnover);
    	printf("\t平均带权周转时间:%.2lf\n",hrrn_author);
    	system("pause");
    	system("cls");
    }
    
    void print()
    {
    	system("cls");
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    	system("pause");
    	system("cls");
    }
    
    void FCFS()   //先来先服务
    {
    
    	system("cls");
    	cout<<"先来先服务调度算法!"<<endl;
    	//打印
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    	int finish = 0;//当前时间,初始化为0
    	sort(pcb,pcb+5,cmp);
    	int sum_turnover = 0;
    	double sum_author_turnover = 0.0;
    	for(int i=0; i<5; i++)
    	{
    		if(pcb[i].arrive>finish)
    			pcb[i].end = pcb[i].arrive+pcb[i].service;
    		else
    			pcb[i].end = pcb[i].service+finish;
    		finish = pcb[i].end;
    		pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
    		pcb[i].start = pcb[i].end-pcb[i].service;
    		pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
    		sum_turnover+=pcb[i].turnover;
    		sum_author_turnover+=pcb[i].author_turnover;
    		fcfs.push_back(pcb[i]);
    	}
    
    	//过程
    	int cpu = 0;
    	int f[5] = {0};//初始化为0,代表不占用
    	while(1)
    	{
    		if(cpu==pcb[4].end)
    		{
    			cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
    			break;
    		}
    		for(int i=0; i<5; i++)
    		{
    			if(pcb[i].arrive==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
    			}
    		}
    		for(int i=0; i<5; i++)
    		{
    			if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
    			{
    				f[i]=1;//占用cpu
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    				Sleep(pcb[i].service*100);
    			}
    			if(pcb[i].end==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    				f[i]=0;//解除占用cpu
    			}
    		}
    		cpu++;
    	}
    
    	//计算
    	double avg_turnover = (double)sum_turnover/5;
    	double avg_author_turnover = (double)sum_author_turnover/5;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
    		printf("%.2lf\n",pcb[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",avg_turnover);
    	fcfs_turnover=avg_turnover;
    	printf("\t平均带权周转时间:%.2lf\n",avg_author_turnover);
    	fcfs_author=avg_author_turnover;
    	system("pause");
    	system("cls");
    }
    
    
    
    void SJF()
    {
    	system("cls");
    	cout<<"短作业优先调度算法!"<<endl;
    	//打印
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    
    	int i,j=0,finish=0;//j为当前就绪队列的末尾指针 
    	sort(pcb,pcb+5,cmp);//排序
    
    //	for(int i=0;i<5;i++)
    //		cout<<pcb[i].pname; 测试排序是否正确
    	int sum_turnover = 0;
    	double sum_author_turnover = 0.0;
    	for(int i=0; i<5; i++)
    	{
    		while(j<5&&pcb[j].arrive<=finish)//当有新的进程的进入时间小于当前时间,就加入就绪队列 
    			j++;
    		sort(pcb+i,pcb+j,cmp1); 
    		if(pcb[i].arrive>finish)
    			pcb[i].end = pcb[i].arrive+pcb[i].service;
    		else
    			pcb[i].end = pcb[i].service+finish;
    		finish = pcb[i].end;
    		pcb[i].turnover = pcb[i].end-pcb[i].arrive;//周转时间=完成时间-到达时间
    		pcb[i].start = pcb[i].end-pcb[i].service;
    		pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
    		sum_turnover+=pcb[i].turnover;
    		sum_author_turnover+=pcb[i].author_turnover;
    		sjf.push_back(pcb[i]);
    	}
    	
    	//过程
    	int cpu = 0;
    	int f[5] = {0};//初始化为0,代表不占用
    	while(1)
    	{
    		if(cpu==pcb[4].end)
    		{
    			cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
    			break;
    		}
    		for(int i=0; i<5; i++)
    		{
    			if(pcb[i].arrive==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
    			}
    		}
    		for(int i=0; i<5; i++)
    		{
    			if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
    			{
    				f[i]=1;//占用cpu
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    				Sleep(pcb[i].service*100);
    			}
    			if(pcb[i].end==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    				f[i]=0;//解除占用cpu
    			}
    		}
    		cpu++;
    	}
    	
    	
    	//计算
    	double avg_turnover = (double)sum_turnover/5;
    	double avg_author_turnover = (double)sum_author_turnover/5;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
    		printf("%.2lf\n",pcb[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",avg_turnover);
    	sjf_turnover=avg_turnover;
    	printf("\t平均带权周转时间:%.2lf\n",avg_author_turnover);
    	sjf_author=avg_author_turnover;
    	system("pause");
    	system("cls");
    }
    
    void init()
    {
    	cout<<endl;
    //	for(int i=0;i<5;i++)
    //	{
    //		pcb[i].pid = i;
    //		cout<<"进程:"<<i<<endl;
    //		cout<<"进程名:";
    //		cin>>pcb[i].pname;
    //		cout<<"到达时间:";
    //		cin>>pcb[i].arrive;
    //		cout<<"服务时间:";
    //		cin>>pcb[i].service;
    //		cout<<endl;
    //	}
    	pcb[0].pname='A';
    	pcb[0].arrive=0;
    	pcb[0].service=3;
    
    	pcb[1].pname='B';
    	pcb[1].arrive=4;
    	pcb[1].service=6;
    
    	pcb[2].pname='C';
    	pcb[2].arrive=4;
    	pcb[2].service=4;
    
    	pcb[3].pname='D';
    	pcb[3].arrive=6;
    	pcb[3].service=5;
    
    	pcb[4].pname='E';
    	pcb[4].arrive=8;
    	pcb[4].service=2;
    	system("cls");
    }
    
    void menu()
    {
    	cout<<endl;
    	cout<<endl;
    	cout<<"\t   进程调度模拟程序"<<endl;
    	cout<<endl;
    	cout<<"\t1. 输入作业情况"<<endl;
    	cout<<endl;
    	cout<<"\t2. 显示作业情况"<<endl;
    	cout<<endl;
    	cout<<"\t3. 先来先服务算法"<<endl;
    	cout<<endl;
    	cout<<"\t4. 短作业优先算法"<<endl;
    	cout<<endl;
    	cout<<"\t5. 高响应比优先算法"<<endl;
    	cout<<endl;
    	cout<<"\t6. 算法结果对比"<<endl;
    	cout<<endl;
    	cout<<"\t0. 退出"<<endl;
    	cout<<endl;
    	cout<<"请输入选择:";
    }
    
    void HRRN()
    {
    	system("cls");
    	cout<<"高响应比调度算法!"<<endl;
    	//打印
    	cout<<"\n\n";
    	cout<<"\t 进程名:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname;
    	}
    	cout<<endl;
    	cout<<"\t到达时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].arrive;
    	}
    	cout<<endl;
    	cout<<"\t服务时间:";
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].service;
    	}
    	cout<<endl;
    	cout<<endl;
    	int sum_turnover = 0;
    	double sum_author_turnover = 0.0;
    	int j=0;
    	int finish=0;
    	sort(pcb, pcb+5, cmp);
    	for(int i = 0; i < 5; i++)
    	{
    		while(j<5 && pcb[j].arrive <= finish)
    			j++;
    		for(int k = i; k < j; k++)
    			pcb[k].priority = (finish-pcb[k].arrive+pcb[k].service) / pcb[k].service;
    		sort(pcb+i, pcb+j, cmp2);
    
    		if(pcb[i].arrive > finish)
    			pcb[i].end = pcb[i].arrive + pcb[i].service;
    		else
    			pcb[i].end = finish + pcb[i].service;
    		pcb[i].turnover = pcb[i].end - pcb[i].arrive;
    		finish = pcb[i].end;
    		pcb[i].start = pcb[i].end-pcb[i].service;
    		pcb[i].author_turnover = double(pcb[i].turnover)/pcb[i].service;//带权周转时间=周转时间/服务时间
    		sum_turnover+=pcb[i].turnover;
    		sum_author_turnover+=pcb[i].author_turnover;
    		hrrn.push_back(pcb[i]);
    	}
    	
    	
    	//过程
    	int cpu = 0;
    	int f[5] = {0};//初始化为0,代表不占用
    	while(1)
    	{
    		if(cpu==pcb[4].end)
    		{
    			cout<<"\t"<<pcb[4].end<<" "<<"进程"<<pcb[4].pname<<"结束\n"<<endl;
    			break;
    		}
    		for(int i=0; i<5; i++)
    		{
    			if(pcb[i].arrive==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"到达内存\n"<<endl;
    			}
    		}
    		for(int i=0; i<5; i++)
    		{
    			if((pcb[i].start==cpu&&i==0)||(pcb[i].start==cpu&&f[i-1]==0))
    			{
    				f[i]=1;//占用cpu
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"开始执行\n"<<endl;
    				Sleep(pcb[i].service*100);
    			}
    			if(pcb[i].end==cpu)
    			{
    				cout<<"\t"<<cpu<<" "<<"进程"<<pcb[i].pname<<"结束\n"<<endl;
    				f[i]=0;//解除占用cpu
    			}
    		}
    		cpu++;
    	}
    	
    	//计算
    	double avg_turnover = (double)sum_turnover/5;
    	double avg_author_turnover = (double)sum_author_turnover/5;
    	cout<<"\t进程名\t\t"<<"到达时间\t"<<"服务时间\t"<<"完成时间\t"<<"周转时间\t"<<"带权周转"<<endl;
    	for(int i=0; i<5; i++)
    	{
    		cout<<"\t"<<pcb[i].pname<<"\t\t"<<pcb[i].arrive<<"\t\t"<<pcb[i].service<<"\t\t"<<pcb[i].end<<"\t\t"<<pcb[i].turnover<<"\t\t";
    		printf("%.2lf\n",pcb[i].author_turnover);
    	}
    	printf("\t平均周转时间:%.2lf\t",avg_turnover);
    	hrrn_turnover=avg_turnover;
    	printf("\t平均带权周转时间:%.2lf\n",avg_author_turnover);
    	hrrn_author=avg_author_turnover;
    	system("pause");
    	system("cls");
    }
    
    int main()
    {
    	int flag=1;
    	while(1)
    	{
    		menu();
    		int sel;
    		cin>>sel;
    		switch(sel)
    		{
    			case 1:
    				init();
    				break;
    			case 2:
    				print();
    				break;
    			case 3:
    				FCFS();
    				break;
    			case 4:
    				SJF();
    				break;
    			case 5:
    				HRRN();
    				break;
    			case 6:
    				Compare();
    				break;
    			case 0:
    				exit(0);
    		}
    	}
    	return 0;
    }
    

    运行效果:
    在这里插入图片描述

    展开全文
  • 文档 操作系统实验报告 实验 1 进程调度算法 报告日期 2016-6-10 学号 班级 任课教师 文档 实验 1 进程调度算法实验容 按优先数调度算法实现处理器调度 二实验目的 在采用多道程序设计的系统中 往往有若干个进程...
  • 实验进程调度算法 一、实验目的 1.实现四种不同及进程调度算法: 先来先服务、时间片轮转调、优先级调度以及短作业优先调度算法。 2.通过实验理解有关进程控制块,进程队列等的概念。 二、实验要求 1.运行素材中...

空空如也

空空如也

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

进程调度算法实验