精华内容
下载资源
问答
  • void hrrn(pcb*a,int n){ //响应比高优先 int i=0; double time=0; double arrayTotalTime=0; //平均周转时间初始化 double arrayWeightTime=0; //平均带权周转时间初始化 int j; for(i=0;i;i++){ j=...
    # include <stdio.h>
    # include <stdlib.h>
    
    typedef struct PCB{
    	char name;        //进程名字 
    	double ArriveTime;   //进程到达时间 
    	double StartTime;    //进程开始时间 
    	double ServiceTime;  //进程运行时间 
    	double FinishTime;   //进程完成时间 
    	double TotalTime;    //进程周转时间
    	double WeightTime;//进程带权周转时间 
    	double Response;  //响应比 
    	bool x;			  //进程是否完成 
    }pcb; 
    
    void initPCB(pcb*a,int n);
    void hrrn(pcb*a,int n);
    void sortService(pcb*a,int l,int r);
    int wait(pcb*a,int x,int n,double time);
    
    int main(){
    	int n;
    	printf("输入要创建的进程数\n");
    	scanf("%d",&n); 
    	printf("请初始化进程\n"); 
    	pcb a[n];
    	initPCB(a,n);
    	hrrn(a,n);
    	return 0;
    }
    
    void initPCB(pcb*a,int n){   //初始化进程池 
    	
    	int i;
    	char name;
    	double  ArriveTime;
    	double  ServiceTime;
    	for(i=0;i<n;i++){
    		fflush(stdin);
    		printf("请输入进程的名字,到达时间,所需运行时间\n"); 
    		scanf("%c%lf%lf",&a[i].name,&a[i].ArriveTime,&a[i].ServiceTime);
    	}
    }
    
    void hrrn(pcb*a,int n){    //响应比高优先 
    	int i=0;
    	double time=0;
    	double arrayTotalTime=0;        //平均周转时间初始化 
    	double arrayWeightTime=0;	    //平均带权周转时间初始化 
    	int j;
    	for(i=0;i<n;i++){
    		j=wait(a,i,n,time);      //查看等待队列的最后一个 
    		sortService(a,i,j);    //根据等待队列中的运行时间排序 
    		a[i].StartTime=time;   //开始执行进程 
    		time=time+a[i].ServiceTime;
    		a[i].FinishTime=time;
    		a[i].TotalTime=time-a[i].ArriveTime;//计算周转时间 
    		arrayTotalTime=arrayTotalTime+a[i].TotalTime/n;  
    		a[i].WeightTime=a[i].TotalTime/a[i].ServiceTime;//计算带权周转时间
    		arrayWeightTime=arrayWeightTime+a[i].WeightTime/n; 
    		printf("完成进程%c 进程开始时间%.2f 进程结束时间%.2f 进程周转时间%.2f 进程带权周转时间%.2f 响应比%.2f\n",a[i].name,a[i].StartTime,a[i].FinishTime,a[i].TotalTime,a[i].WeightTime,a[i].Response);    
    	}
    	printf("\n\n平均周转时间%.2f     平均带权周转时间%.2f\n\n\n",arrayTotalTime,arrayWeightTime);
    }
    
    void sortService(pcb*a,int l,int r){   //当前准备在等待队列中按照运行时间排序 
    	int i,j;
    	pcb t;
    	for(i=l;i<r;i++){
    		for(j=l;j<r;j++){
    			if(a[j].Response<a[j+1].Response){
    				t=a[j];
    				a[j]=a[j+1];
    				a[j+1]=t; 
    			}
    		}	
    	}
    } 
    
    int wait(pcb*a,int x,int n,double time){     //查看等待队列最后一个进程的位置并计算响应比
    	int i; 
    	for(i=x;i<n;i++){
    		if(a[i].ArriveTime>time)
    			break;
    		a[i].Response=(time-a[i].ArriveTime)/a[i].ServiceTime;
    	}
    	return i-1;
    }

    流程图

    展开全文
  • 利用高级语言模拟进程的时间片轮转调度算法,响应比高优先调度算法
  • 处理器调度总是选队首进程运行。采用动态改变响应比的办法,进程每运行一次重新计算各进程的响应比。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:要求运行时间-1、等待时间为0...
  • 事先说明: 本代码为原创,转载请附原博地址。 代码可以运行,但是运算结果并不知道对错(感觉第三个有问题),凌晨两点写的,大脑并不清醒,欢迎交流修改。...短作业优先算法,是在作业到达的基础上,如果有多...

    事先说明:

    本代码为原创,转载请附原博地址。

    代码可以运行,但是运算结果并不知道对错(感觉第三个有问题),凌晨两点写的,大脑并不清醒,欢迎交流修改。

    如果我的老师查重的时候看到这篇,请你看一下交作业时间和博客时间来确定这是我本人写的~

    理论部分:

    简单地说一下吧,毕竟书上应该都有。

    先来先服务算法,就非常简单地按照作业到达先后进行计算。

    短作业优先算法,是在作业到达的基础上,如果有多个作业都已经到达,选择运行时间短的作业先计算。

    响应比高者优先算法,也是在作业到达的基础上,如果有多个作业都已经到达,计算他们的优先级,优先级高的作业先计算。

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

    代码:

    #include<iostream>
    #include<algorithm>
    #include<cstring>
    #include<cmath>
    #include<vector>
    using namespace std;
    struct zy//每个作业
    {
    	int gettime;//到达时间
    	int runtime;//运行时间
    	int k;//标记有没有被用过(用于第二个算法)
    	int y;//优先级(第三个算法)
    };
    bool cmp(zy a, zy b)//按照到达时间进行排序
    {
    	return a.gettime < b.gettime;
    }
    bool cmp2(zy a, zy b)//按照运行时间进行排序
    {
    	return a.runtime < b.runtime;
    }
    bool cmp3(zy a, zy b)//按照优先级排序
    {
    	return a.y > b.y;
    }
    int main()
    {
    	/*输入数据*/
    	int n;
    	cout << "请输入有几组:";
    	cin >> n;
    	zy z[100];
    	cout << "输入每个作业的到达时间和运行时间" << endl;
    	for (int i = 0; i < n; i++)
    	{
    		cin >> z[i].gettime >> z[i].runtime;
    		z[i].k = 0;
    	}
    
    	int overtime[100];//结束时间
    	int starttime[100];//开始时间
    	int zhouzhuan[100];//周转时间
    	double dq[100];//带权周转时间
    
    	/*先来先服务算法*/
    	sort(z, z + n, cmp);
    	for (int i = 0; i < n; i++)
    	{
    		if(i==0)starttime[i] = z[i].gettime;
    		else starttime[i] = z[i].gettime + overtime[i - 1];
    		overtime[i] = starttime[i] + z[i].runtime;
    		zhouzhuan[i] = overtime[i] - z[i].gettime;
    		dq[i] = zhouzhuan[i]*1.0 / z[i].runtime;
    	}
    	double T=0, W=0;
    	for (int i = 0; i < n; i++)
    	{
    		T = T + zhouzhuan[i];
    		W = W + dq[i];
    	}
    	T = T / n*1.0;
    	W = W / n*1.0;
    	cout << "先来先服务算法的平均时间是: " << T << " 带权平均周转时间是:" << W << endl;
    
    	/*短作业优先算法*/
    	memset(overtime, 0, sizeof(overtime));
    	memset(starttime, 0, sizeof(starttime));
    	memset(zhouzhuan, 0, sizeof(zhouzhuan));
    	memset(dq, 0, sizeof(dq));
    	T = 0, W = 0;
    	sort(z, z + n, cmp);
    	for (int i = 0; i < n; i++)
    	{
    		if (i == 0) {
    			starttime[i] = z[i].gettime;
    			overtime[i] = starttime[i] + z[i].runtime;
    			zhouzhuan[i] = overtime[i] - z[i].gettime;
    			dq[i] = zhouzhuan[i]*1.0 / z[i].runtime;
    			z[i].k = 1;
    		}
    		else {
    			for (int j = 0; j < n; j++)//找最短时间的作业
    			{
    				if (z[j].k == 0 && z[j].gettime <= overtime[i - 1]) {//如果没有使用过且在结束时间内
    					starttime[i] = z[j].gettime;
    					overtime[i] = starttime[i] + z[j].runtime;
    					zhouzhuan[i] = overtime[i] - z[i].gettime;
    					dq[i] = zhouzhuan[i]*1.0 / z[j].runtime;
    					z[j].k = 1;
    					break;
    				}
    			}
    		}
    		sort(z, z + n, cmp2);
    	}
    	for (int i = 0; i < n; i++)
    	{
    		T = T + zhouzhuan[i];
    		W = W + dq[i];
    	}
    	T = T / n*1.0;
    	W = W / n*1.0;
    	cout << "短作业优先算法的平均时间是: " << T << " 带权平均周转时间是:" << W << endl;
    
    	/*高响应比优先算法*/
    	memset(overtime, 0, sizeof(overtime));
    	memset(starttime, 0, sizeof(starttime));
    	memset(zhouzhuan, 0, sizeof(zhouzhuan));
    	memset(dq, 0, sizeof(dq));
    	T = 0, W = 0;
    	sort(z, z + n, cmp);
    	for (int i = 0; i < n; i++)
    	{
    		if (i == 0) {
    			starttime[i] = z[i].gettime;
    			overtime[i] = starttime[i] + z[i].runtime;
    			zhouzhuan[i] = overtime[i] - z[i].gettime;
    			dq[i] = zhouzhuan[i] * 1.0 / z[i].runtime;
    		}
    		else {
    			int g;//标记最后一个在上一个结束时间内的作业
    			for (int j = i; j < n; j++)
    			{
    				if (z[j].gettime <= overtime[i])g = j;
    				else break;
    			}
    			if (g - i == 1) {//只有一个作业可执行
    				starttime[i] = z[i].gettime + overtime[i - 1];
    				overtime[i] = starttime[i] + z[i].runtime;
    				zhouzhuan[i] = overtime[i] - z[i].gettime;
    				dq[i] = zhouzhuan[i] * 1.0 / z[i].runtime;
    			}
    			else {//需要计算优先级
    				for (int j = i; j <= g; j++)
    				{
    					z[j].y = 1 + (overtime[i - 1] - z[j].gettime) / z[j].runtime;
    				}
    				sort(z+i, z + g, cmp3);
    				starttime[i] = z[i].gettime + overtime[i - 1];
    				overtime[i] = starttime[i] + z[i].runtime;
    				zhouzhuan[i] = overtime[i] - z[i].gettime;
    				dq[i] = zhouzhuan[i] * 1.0 / z[i].runtime;
    			}
    		}
    	}
    	for (int i = 0; i < n; i++)
    	{
    		T = T + zhouzhuan[i];
    		W = W + dq[i];
    	}
    	T = T / n*1.0;
    	W = W / n*1.0;
    	cout << "高响应比优先算法的平均时间是: " << T << " 带权平均周转时间是:" << W << endl;
    	system("pause");
    	return 0;
    }

    运行结果:

    展开全文
  • 编写程序完成批处理系统中的作业调度,要求采用响应比高优先的作业调度算法。实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所作工作进程测试。 4.提示与...
  • 编写程序完成批处理系统中的作业调度,要求采用响应比高优先的作业调度算法。实验具体包括:首先确定作业控制块的内容和组织方式;然后完成作业调度;最后编写主函数,对所做工作进行测试。
  • 非抢占式的响应比高者进程调度优先算法java
  • 处理及调度算法代码 nt counter; /*实际进程个数*/ int fcfs(); /*先来先服务*/ int ps(); /*优先级调度*/ ... /*响应比高优先*/ int pinput(); /*进程参数输入*/ int poutput(); /*调度结果输出*/
  • ******##1这是课程作业的简单分享 ******##2肯定会有地方对特殊的数据没有考虑到,欢迎改进 ******##3使用的 java version "1.8.0_131",eclipse上编辑 ...编写一个程序完成多道程序的调度 具体要求 只...
    ******##1这是课程作业的简单分享
    ******##2肯定会有地方对特殊的数据没有考虑到,欢迎改进
    ******##3使用的 java version "1.8.0_131",eclipse上编辑
    

    设计要求

    1. 用可视化编程工具编制程序,在机器上调试运行,并通过上机考核。
    2. 要求界面设计美观,功能完整,使用方便,能运行通过。
    

    设计内容

    编写一个程序完成多道程序的调度
    

    具体要求

    只考虑1个CPU的资源,其他资源不考虑 使用响应比高者优先算法 程序采用键盘输入,输入格式为:
       K
       TJ1    YS1
       …… 
       TJK    YSK
    
    其中K是作业数(>0),TJi提交时间,YSi(i=1~K)是作业预计的运行时间(以分钟计)TJ的输入格式是XXYY, 其中XX是时,YY是分, 如10点28
    分,输入为1028。但内部计算要以60进制来算。要求输出按照作业调度的先后次序输出结果,每行为一个作业状态,从左到右分别是调度次序,作业
    号,调度时间,周转时间和带权周转时间最后一行输出两个数,第一为平均周转时间,第二为平均带权周转时间(带权周转时间=周转时间/运行时间)。
    

    Java实现代码

    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.util.*;
    import javax.swing.*;
    
    class Task implements Comparable{       //定义任务的class同时implements Comparable使得可使用ArrayList
    	public String name;
    	private float Entime;
    	private float Retime;
    	public Task(String name, float Entime, float Retime) {
    		this.name = name;
    		this.Entime = Entime;
    		this.Retime = Retime;
    	    }
    	    public String getName() {
    	        return name;
    	    }
    	    public void setName(String name) {
    	        this.name = name;
    	    }
    	    public float getEntime() {
    	        return Entime;
    	    }
    	    public void setEntime(float Entime) {
    	        this.Entime = Entime;
    	    }
    	    public float getRetime() {
    	        return Retime;
    	    }
    	    public void setRetime(float Retime) {
    	        this.Retime = Retime;
    	    }
    	    public int compareTo(Object o){               //排队条件
    	        Task s = (Task)(o);
    	        if(this.Entime >= s.Entime) {
    	    	    return 1;
    	    	}
    	    	return -1;
    	    } 
    }
    
    class Pframe{                  //简单界面,左侧为输入框,右侧为测试结果框
    	JFrame frame;
    	JButton start;      
    	JTextArea Prarea, Rearea;    
    	JLabel label1, label2;
    	JButton work;
    	JPanel panel;
    	Pframe(String title){
    		frame = new JFrame(title);
    		frame.setSize(800,600);
    		frame.setLayout(null);
    		Prarea = new JTextArea(5,20);
    		Rearea = new JTextArea(6,20);
    		label1 = new JLabel("请输入测试数据:");		
    		label2 = new JLabel("测试结果:");
    		work = new JButton("Examining");
    		frame.add(Rearea);
    		frame.add(Prarea);
    		frame.add(label1);
    		frame.add(label2);
    		label1.setBounds(50, 50, 120, 30);
    		label2.setBounds(300, 50, 120, 30);
    		Prarea.setBounds(300, 80, 430, 250);
    		Rearea.setBounds(50, 80, 220, 250);
    		frame.add(work);
    		work.setBounds(250, 400, 100, 40);
    		frame.setVisible(true);
    		work.addActionListener(new ButtonEvent());
    	}
    	class ButtonEvent implements ActionListener{           //按钮Examining的响应
    		public void actionPerformed(ActionEvent e){
    			Prarea.setText("");
    			Scanner In = new Scanner(Rearea.getText());
    			int num = In.nextInt();
    			int ordernum = 0;
    			String Taskname;
    			float Entime;float Retime;
    			ArrayList<Task> arr = new ArrayList<>();
    			
    			for(int i = 0; i < num; i++) {           //读入数据
    			    Taskname = In.next();
    			    Entime=In.nextFloat();
    			    Entime= (int)(Entime/100)*60 + Entime%100;        //得到时间转化为10进制
    			    Retime=In.nextFloat();
    			    Task task = new Task(Taskname, Entime, Retime);
    			    arr.add(task);
    			}
    			In.close();
    			
    			Collections.sort(arr);                  //按照进入时刻排序
    			Prarea.append("调度次序\t作业号\t调度时间\t周转时间\t带权周转时间");
    			float CurrentTime = arr.get(0).getEntime();		
    			float sum1 = 0, sum2 = 0;
    			float retime = 0;
    			float entime = 0;
    			
    			for(int i = 0;i<num;i ++) {                 //选取能在时间进行调度的Task
    			    List<Task> newarr = new ArrayList<>();
    			    for(int j = 0;j < arr.size();j ++) {
    			    	if(arr.get(j).getEntime()<=CurrentTime) {
    			    		newarr.add(arr.get(j));
    			    		}
    			    }
    			    if(newarr.size() == 0 && arr.size() != 0) {   //空转,当没有任务的时候
    			    	i--;
    			    	CurrentTime++;
    			    	continue;
    			    }
    			    
    			    for(int j=1;j<newarr.size();j++) {              //确定作业号Task,最高响应比确定,并将其放在0号arr单元
    			    	if((CurrentTime-newarr.get(j).getEntime())/newarr.get(j).getRetime()>=(CurrentTime-newarr.get(0).getEntime())/newarr.get(0).getRetime()) {
    			    		if((CurrentTime-newarr.get(j).getEntime())/newarr.get(j).getRetime() == (CurrentTime-newarr.get(0).getEntime())/newarr.get(0).getRetime()) {
    			    			if(newarr.get(0).getRetime() > newarr.get(j).getRetime())     //相应比相同的比较需要执行的时间
    			    				newarr.set(0, newarr.get(j));
    			    		}
    			    		else
    			    			newarr.set(0, newarr.get(j));
    			    	}
    			    }
    			   
    			    arr.remove((Task)newarr.get(0));                  //移除作业号进行此次调度的输出操作
    			    retime = newarr.get(0).getRetime();
    			    entime = newarr.get(0).getEntime();                //对于输出 调度时间的输出是60进制,周转时间和带权周转时间的输出为10进制
    			   
    			    //输出
    			    Prarea.append("\n"+(++ordernum)+"\t"+newarr.get(0).getName()+"\t");
    			    
    			    int a1 = (int)CurrentTime/60;       //对调度时间的输出才去时间的输出格式
    			    int a2 = (int)CurrentTime%60;
    			    if(a1>=10) {
    			    	Prarea.append(a1+":");
    			    	if(a2>=10) {
    			    		Prarea.append(a2+"");
    			    	}
    			    	else Prarea.append("0"+a2);
    			    }
    			    else {
    			    	Prarea.append("0"+a1+":");
    			    	if(a2>=10) {
    			    		Prarea.append(a2+"");
    			    	}
    			    	else Prarea.append("0"+a2);
    			    }
    			    
    			    Prarea.append("\t"+(int)(CurrentTime-entime+retime)+"min"+"\t"+((retime+CurrentTime-entime)/retime));
    			    sum2+=(CurrentTime-entime+retime)/retime;
    			    sum1 += CurrentTime-entime+retime;
    			    CurrentTime = CurrentTime+retime;
    			}
    			Prarea.append("\n"+"平均周转时间为"+String.format("%.2f", sum1/num)+"min"+"        "+"平均带权周转时间为"+String.format("%.2f", sum2/num)+"min");
    
    		}
    	}	
    }
    
    public class processing {
    	public static void main(String arg[]){
    		new Pframe("多道批处理作业");
    	}
    }
    

    输入测试数据1:

    6
    1 1028	6
    2 1029	6
    3 1029	8
    4 1034	12
    5 1032	7
    6 1033	5
    

    显示:
    在这里插入图片描述
    输入测试数据2:

    5
    1 0830 20
    2 0900 30
    3 0900 20
    4 0910 10
    5 0920 20
    

    显示
    在这里插入图片描述
    每次输入测试数据只需在左侧文本框修改即可,欢迎探讨。

    展开全文
  • 1、对于给定的一组作业, 给出其到达时间和运行时间 2、分别用先来先服务算法、短作业优先响应比高优先三种算法给出作业的调度顺序。 3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
  • 进程调度-作业调度: 先来先服务--短作业优先--响应比高算法1.调度的概念1. 调度的基本概念在多道程序系统中,进程的数量往往多于处理机的个数,进程争用处理机的情况就在所难免。处理机调度是对处理机进行分配,...

    进程调度-作业调度: 先来先服务--短作业优先--响应比高算法


    1.调度的概念

    1. 调度的基本概念
    在多道程序系统中,进程的数量往往多于处理机的个数,进程争用处理机的情况就在所难免。处理机调度是对处理机进行分配,就是从就绪队列中,按照一定的算法(公平、髙效)选择一个进程并将处理机分配给它运行,以实现进程并发地执行。

    处理机调度是多道程序操作系统的基础,它是操作系统设计的核心问题。

    2. 调度的层次
    一个作业从提交开始直到完成,往往要经历以下三级调度,如图2-4所示。

    1)作业调度。又称高级调度,.其主要任务是按一定的原则从外存上处于后备状态的作业中挑选一个(或多个)作业,给它(们)分配内存、输入/输出设备等必要的资源,并建立相应的进程,以使它(们)获得竞争处理机的权利。简言之,就是内存与辅存之间的调度。对于每个作业只调入一次、调出一次。

    多道批处理系统中大多配有作业调度,而其他系统中通常不需要配置作业调度。作业调度的执行频率较低,通常为几分钟一次。

    2)中级调度。又称内存调度。引入中级调度是为了提高内存利用率和系统吞吐量。为此,应使那些暂时不能运行的进程,调至外存等待,把此时的进程状态称为挂起状态。当它们已具备运行条件且内存又稍有空闲时,由中级调度来决定,把外存上的那些已具备运行条件的就绪进程,再重新调入内存,并修改其状态为就绪状态,挂在就绪队列上等待。

    3)进程调度。又称为低级调度,其主要任务是按照某种方法和策略从就绪队列中选取一个进程,将处理机分配给它。进程调度是操作系统中最基本的一种调度,在一般操作系统中都必须配置进程调度。进程调度的频率很高,一般几十毫秒一次。


    图2-4  处理机的三级调度

    3.三级调度的联系
    作业调度从外存的后备队列中选择一批作业进入内存,为它们建立进程,这些进程被送入就绪队列,进程调度从就绪队列中选出一个进程,并把其状态改为运行状态,把CPU分配给它。中级调度是为了提高内存的利用率,系统将那些暂时不能运行的进程挂起来。当内存空间宽松时,通过中级调度选择具备运行条件的进程,将其唤醒。

    1) 作业调度为进程活动做准备,进程调度使进程正常活动起来,中级调度将暂时不能运行的进程挂起,中级调度处于作业调度和进程调度之间。

    2) 作业调度次数少,中级调度次数略多,进程调度频率最高。

    3) 进程调度是最基本的,不可或缺。

    2.调度的时机、切换与过程
    进程调度和切换程序是操作系统内核程序。当请求调度的事件发生后,才可能会运行进程调度程序,当调度了新的就绪进程后,才会去进行进程间的切换。理论上这三件事情应该顺序执行,但在实际设计中,在操作系统内核程序运行时,如果某时发生了引起进程调度的因素,并不一定能够马上进行调度与切换。

    现代操作系统中,不能进行进程的调度与切换的情况有以下几种情况。

    1) 在处理中断的过程中:中断处理过程复杂,在实现上很难做到进程切换,而且中断处理是系统工作的一部分,逻辑上不属于某一进程,不应被剥夺处理机资源。

    2) 进程在操作系统内核程序临界区中:进入临界区后,需要独占式地访问共享数据,理论上必须加锁,以防止其他并行程序进入,在解锁前不应切换到其他进程运行,以加快该共享数据的释放。

    3) 其他需要完全屏蔽中断的原子操作过程中:如加锁、解锁、中断现场保护、恢复等原子操作。在原子过程中,连中断都要屏蔽,更不应该进行进程调度与切换。

    如果在上述过程中发生了引起调度的条件,并不能马上进行调度和切换,应置系统的请求调度标志,直到上述过程结束后才进行相应的调度与切换。

    应该进行进程调度与切换的情况有:

    1) 当发生引起调度条件,且当前进程无法继续运行下去时,可以马上进行调度与切换。如果操作系统只在这种情况下进行进程调度,就是非剥夺调度。 

    2) 当中断处理结束或自陷处理结束后,返回被中断进程的用户态程序执行现场前,若置上请求调度标志,即可马上进行进程调度与切换。如果操作系统支持这种情况下的运行调度程序,就实现了剥夺方式的调度。

    进程切换往往在调度完成后立刻发生,它要求保存原进程当前切换点的现场信息,恢复被调度进程的现场信息。现场切换时,操作系统内核将原进程的现场信息推入到当前进程的内核堆栈来保存它们,并更新堆栈指针。内核完成从新进程的内核栈中装入新进程的现场信息、更新当前运行进程空间指针、重设PC寄存器等相关工作之后,开始运行新的进程。

    3.进程调度方式

    所谓进程调度方式是指当某一个进程正在处理机上执行时,若有某个更为重要或紧迫的进程需要处理,即有优先权更髙的进程进入就绪队列,此时应如何分配处理机。

    通常有以下两种进程调度方式:

    1) 非剥夺调度方式,又称非抢占方式。是指当一个进程正在处理机上执行时,即使有某个更为重要或紧迫的进程进入就绪队列,仍然让正在执行的进程继续执行,直到该进程完成或发生某种事件而进入阻塞状态时,才把处理机分配给更为重要或紧迫的进程。

    在非剥夺调度方式下,一旦把CPU分配给一个进程,那么该进程就会保持CPU直到终止或转换到等待状态。这种方式的优点是实现简单、系统开销小,适用于大多数的批处理系统,但它不能用于分时系统和大多数的实时系统。

    2) 剥夺调度方式,又称抢占方式。是指当一个进程正在处理机上执行时,若有某个更为重要或紧迫的进程需要使用处理机,则立即暂停正在执行的进程,将处理机分配给这个更为重要或紧迫的进程。.

    釆用剥夺式的调度,对提高系统吞吐率和响应效率都有明显的好处。但“剥夺”不是一种任意性行为,必须遵循一定的原则,主要有:优先权、短进程优先和时间片原则等。

    4.调度的基本准则
    不同的调度算法具有不同的特性,在选择调度算法时,必须考虑算法所具有的特性。为了比较处理机调度算法的性能,人们提出很多评价准则,下面介绍主要的几种:

    1)  CPU利用率:CPU是计算机系统中最重要和昂贵的资源之一,所以应尽可能使CPU 保持“忙”状态,使这一资源利用率最髙。

    2) 系统吞吐量:表示单位时间内CPU完成作业的数量。长作业需要消耗较长的处理机时间,因此会降低系统的吞吐量。而对于短作业,它们所需要消耗的处理机时间较短,因此能提高系统的吞吐量。调度算法和方式的不同,也会对系统的吞吐量产生较大的影响。

    3) 周转时间:是指从作业提交到作业完成所经历的时间,包括作业等待、在就绪队列中排队、在处迤机上运行以及进行输入/输出操作所花费时间的总和。

    作业的周转时间可用公式表示如下:
                        周转时间 = 作业完成时间 - 作业提交时间

    平均周转时间是指多个作业周转时间的平均值:
                        平均周转时间 = (作业1的周转时间 + … + 作业 n 的周转时间) / n

    带权周转时间是指作业周转时间与作业实际运行时间的比值:
                        

    平均带权周转时间是指多个作业带权周转时间的平均值:
                        平均带权周转时间 = (作业1的带权周转时间 + … + 作业 n 的带权周转时间) / n

    4) 等待时间:是指进程处于等处理机状态时间之和,等待时间越长,用户满意度越低。处理机调度算法实际上并不影响作业执行或输入/输出操作的时间,只影响作业在就绪队列中等待所花的时间。因此,衡量一个调度算法优劣常常只需简单地考察等待时间。

    5) 响应时间:是指从用户提交请求到系统首次产生响应所用的时间。在交互式系统中,周转时间不可能是最好的评价准则,一般釆用响应时间作为衡量调度算法的重要准则之一。从用户角度看,调度策略应尽量降低响应时间,使响应时间处在用户能接受的范围之内。

    要想得到一个满足所有用户和系统要求的算法几乎是不可能的。设计调度程序,一方面要满足特定系统用户的要求(如某些实时和交互进程快速响应要求),另一方面要考虑系统整体效率(如减少整个系统进程平均周转时间),同时还要考虑调度算法的开销。


    5.作业调度案例
    1、假设系统中可同时运行两道作业,给出每道作业的到达时间和运行时间,例如下表所示:

    作业名

    A

    B

    C

    D

    E

    F

    G

    H

    I

    J

    到达时间

    0

    2

    5

    7

    12

    15

    4

    6

    8

    10

    运行时间

    7

    10

    20

    30

    40

    8

    8

    20

    10

    12

    2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
    3、计算每一种算法的 平均周转时间 及 平均带权周转时间 并比较不同算法的优劣
            响应比=等待时间/运行时间+1
            周转时间=完成时间-到达时间
            带权周转时间=周转时间/运行时间


    6.代码
    #include<iostream>
    #include<string>
    #include<queue>
    #include<fstream>
    #include<iomanip>
    using namespace std;
    #define max 0x3f3f3f3f
    
    struct pcb
    {
        string name; //名称
        int need;    //运行时间
        int turn;    //结束时间
        int arrive;  //到达时间
        float xyb;   //响应比
        int zz;      //周转时间
        float xzz;   //带权周转时间
        pcb *next;
    };
    pcb *pcb1=new pcb;
    
    int clock1=0;  //时钟1
    int clock2=0;  //时钟2
    int azz=0;     //平均周转时间
    float axzz=0;    //平均带权周转时间
    
    
    void init()
    {
        ifstream ifile;
        ifile.open("作业调度.txt");
    
        pcb1->next=NULL;
        pcb *t=new pcb;
        t->next=NULL;
        ifile>>t->name>>t->arrive>>t->need;
      //  t->xyb=t->arrive/(t->need*1.0)+1;
        t->xyb=1;
        t->next=pcb1->next;
        pcb1=t;
        for(int i=0;i<9;i++)
        {
            pcb *s=new pcb;
            s->next=NULL;
            ifile>>s->name>>s->arrive>>s->need;
            s->xyb=max;
            if(i==0) s->xyb=1;
            pcb *t=pcb1;
            while(t->next!=NULL) t=t->next;
            s->next=t->next;
            t->next=s;
        }
    
        ifile.close();
    }
    
    void prioritygo()
    {
        clock1=0;
        clock2=0;
        azz=0;
        axzz=0;
        cout<<" 进程     结束时间   周转时间    带权周转时间 "<<endl;
        bool non;
        for(int i=0;i<10;i++)
        {
            non=false;
            pcb *p=new pcb;
            pcb *q=new pcb;
            p=pcb1;
            q->need=max;
            q->next=NULL;
            while(p!=NULL)
            {
                if(clock1<=clock2&&p->arrive<=clock1)
                {
                    if(p->need!=0&&p->need<=q->need)
                    {
                        q=p;
                        //   cout<<endl<<q->name<<" "<<q->arrive<<" "<<q->need<<"  "<<clock1<<"  "<<clock2<<endl;
                        non=true;
                    }
                }
                if(clock1>clock2&&p->arrive<=clock2)
                {
                    if(p->need!=0&&p->need<=q->need)
                    {
                        q=p;
                        //   cout<<endl<<q->name<<" "<<q->arrive<<" "<<q->need<<"  "<<clock1<<"  "<<clock2<<endl;
                        non=true;
                    }
                }
                p=p->next;
            }
    
            if(!non)
            {
                q->arrive=max;
                q->next=NULL;
                p=pcb1;
                while(p!=NULL)
                {
                    if(p->need!=0&&p->arrive<=q->arrive)
                    {
                        q=p;
                        //         cout<<endl<<q->name<<" "<<q->arrive<<" "<<q->need<<"  "<<clock1<<"  "<<clock2<<endl;
                    }
    
                    p=p->next;
                }
            }
            if(clock1<=clock2)
            {
                if(i==0) clock1=q->arrive;
                if(!non) clock1=q->arrive;
                clock1+=q->need;
                q->turn=clock1;
                q->zz=q->turn-q->arrive;      azz+=q->zz;
                q->xzz=q->zz/(q->need*1.0);   axzz+=q->xzz;
                q->need=0;
                cout<<setw(5)<<q->name<<setw(10)<<q->turn<<setw(10)<<q->zz<<setw(15)<<q->xzz<<endl;
            }
            else
            {
                if(i==1) 
                {
                    pcb *k=pcb1;
                    k=pcb1->next;
                    clock2=k->arrive;
                    clock2+=k->need;
                    k->turn=clock2;
                    k->zz=k->turn-k->arrive;    azz+=k->zz;
                    k->xzz=k->zz/(k->need*1.0); axzz+=k->xzz;
                    k->need=0;
                    cout<<setw(5)<<k->name<<setw(10)<<k->turn<<setw(10)<<k->zz<<setw(15)<<k->xzz<<endl;
                    continue;
                }
                if(!non) clock2=q->arrive;
                clock2+=q->need;
                q->turn=clock2;
                q->zz=q->turn-q->arrive;      azz+=q->zz;
                q->xzz=q->zz/(q->need*1.0);   axzz+=q->xzz;
                q->need=0;
                cout<<setw(5)<<q->name<<setw(10)<<q->turn<<setw(10)<<q->zz<<setw(15)<<q->xzz<<endl;
            }
        }
        cout<<"平均周转时间:     "<<azz/10.0<<endl;
        cout<<"平均带权周转时间: "<<axzz/10.0<<endl;
    }
    
    void firstgo()
    {
        clock1=0;
        clock2=0;
        azz=0;
        axzz=0;
        cout<<" 进程     结束时间   周转时间    带权周转时间 "<<endl;
        bool non;
        for(int i=0;i<10;i++)
        {
            non=false;
            pcb *p=new pcb;
            pcb *q=new pcb;
            p=pcb1;
            q->arrive=max;
            q->next=NULL;
            while(p!=NULL)
            {
                if(p->need!=0&&p->arrive<=q->arrive&&(p->arrive<=clock1||p->arrive<=clock2))
                {
                    q=p;
                    non=true;
                }
                p=p->next;
            }
            if(!non)
            {
                q->arrive=max;
                q->next=NULL;
                p=pcb1;
                while(p!=NULL)
                {
                    if(p->need!=0&&p->arrive<=q->arrive)
                    {
                        q=p;
                    }
    
                    p=p->next;
                }
            }
            if(clock1<=clock2)
            {
                if(i==0) clock1=q->arrive;
                if(!non) clock1=q->arrive;
                clock1+=q->need;
                q->turn=clock1;
                q->zz=q->turn-q->arrive;      azz+=q->zz;
                q->xzz=q->zz/(q->need*1.0);   axzz+=q->xzz;
                q->need=0;
                cout<<setw(5)<<q->name<<setw(10)<<q->turn<<setw(10)<<q->zz<<setw(15)<<q->xzz<<endl;
            }
            else
            {
                if(i==1) 
                {
                    pcb *k=pcb1;
                    k=pcb1->next;
                    clock2=k->arrive;
                    clock2+=k->need;
                    k->turn=clock2;
                    k->zz=k->turn-k->arrive;    azz+=k->zz;
                    k->xzz=k->zz/(k->need*1.0); axzz+=k->xzz;
                    k->need=0;
                    cout<<setw(5)<<k->name<<setw(10)<<k->turn<<setw(10)<<k->zz<<setw(15)<<k->xzz<<endl;
                    continue;
                }
                if(!non) clock2=q->arrive;
                clock2+=q->need;
                q->turn=clock2;
                q->zz=q->turn-q->arrive;      azz+=q->zz;
                q->xzz=q->zz/(q->need*1.0);   axzz+=q->xzz;
                q->need=0;
                cout<<setw(5)<<q->name<<setw(10)<<q->turn<<setw(10)<<q->zz<<setw(15)<<q->xzz<<endl;
            }
        }
        cout<<"平均周转时间:     "<<azz/10.0<<endl;
        cout<<"平均带权周转时间: "<<axzz/10.0<<endl;
    }
    
    void percentgo()
    {
        clock1=0;
        clock2=0;
        azz=0;
        axzz=0;
        cout<<" 进程     结束时间   周转时间    带权周转时间   响应比"<<endl;
        bool non;
        for(int i=0;i<10;i++)
        {
            non=false;
            pcb *p=new pcb;
            pcb *q=new pcb;
            p=pcb1;
            q->xyb=-1;
            q->next=NULL;
            while(p!=NULL)
            {
                if(clock1<=clock2&&p->arrive<=clock1)
                {
                    pcb *t=pcb1;
                    while(t!=NULL)
                    {
                        t->xyb=(clock1-t->arrive)/(t->need*1.0)+1;
                        if(i==0) t->xyb=1;
                        t=t->next;
                    }
                    if(p->need!=0&&p->xyb>=q->xyb)
                    {           
                        q=p;
                        //  cout<<endl<<q->name<<" "<<q->arrive<<" "<<q->need<<"  "<<clock1<<"  "<<clock2<<endl;
                        non=true;
                    }
                }
    
                if(clock1>clock2&&p->arrive<=clock2)
                {
                    pcb *t=pcb1;
                    while(t!=NULL)
                    {
                        t->xyb=(clock2-t->arrive)/(t->need*1.0)+1;
                        if(i==1) t->xyb=1;
                        t=t->next;
                    }
                    if(p->need!=0&&p->xyb>=q->xyb)
                    {           
                        q=p;
                        //  cout<<endl<<q->name<<" "<<q->arrive<<" "<<q->need<<"  "<<clock1<<"  "<<clock2<<endl;
                        non=true;
                    }
                }
                p=p->next;
            }
            if(!non)
            {
                q->arrive=max;
                q->next=NULL;
                p=pcb1;
                while(p!=NULL)
                {
                    if(p->need!=0&&p->arrive<=q->arrive)
                    {
                        q=p;
                       // cout<<endl<<q->name<<" "<<q->arrive<<" "<<q->need<<"  "<<clock1<<"  "<<clock2<<endl;
                    }
    
                    p=p->next;
                }
            }
            if(clock1<=clock2)
            {
                if(i==0) clock1=q->arrive;
                if(!non) clock1=q->arrive;
                clock1+=q->need;
                q->turn=clock1;
                q->zz=q->turn-q->arrive;      azz+=q->zz;
                q->xzz=q->zz/(q->need*1.0);   axzz+=q->xzz;
                q->need=0;
                cout<<setw(5)<<q->name<<setw(10)<<q->turn<<setw(10)<<q->zz<<setw(15)<<q->xzz<<setw(13)<<q->xyb<<endl;
    
            }
            else
            {
                if(i==1) 
                {
                    pcb *k=pcb1;
                    k=pcb1->next;
                    clock2=k->arrive;
                    clock2+=k->need;
                    k->turn=clock2;
                    k->zz=k->turn-k->arrive;    azz+=k->zz;
                    k->xzz=k->zz/(k->need*1.0); axzz+=k->xzz;
                    k->need=0;
                    cout<<setw(5)<<k->name<<setw(10)<<k->turn<<setw(10)<<k->zz<<setw(15)<<k->xzz<<setw(13)<<k->xyb<<endl;
                
                    continue;
                }
                if(!non) clock2=q->arrive;
                clock2+=q->need;
                q->turn=clock2;
                q->zz=q->turn-q->arrive;      azz+=q->zz;
                q->xzz=q->zz/(q->need*1.0);   axzz+=q->xzz;
                q->need=0;
                cout<<setw(5)<<q->name<<setw(10)<<q->turn<<setw(10)<<q->zz<<setw(15)<<q->xzz<<setw(13)<<q->xyb<<endl;
            }
        }
        cout<<"平均周转时间:     "<<azz/10.0<<endl;
        cout<<"平均带权周转时间: "<<axzz/10.0<<endl;
    }
    
    void p()
    {
        cout<<" 进程   到达时间   运行时间"<<endl;
        pcb *p=pcb1;
        while(p!=NULL)
        {
            cout<<setw(5)<<p->name<<setw(10)<<p->arrive<<setw(10)<<p->need<<endl;
            p=p->next;
        }
        cout<<endl;
    }
    
    int main(int argc,char* argv[])
    {
        cout<<"运行结果"<<endl;
        init();
        p();
        cout<<"先来先服务算法:"<<endl;
        firstgo();
        cout<<endl;
    
        init();
        cout<<"短进程优先算法:"<<endl;
        prioritygo();
        cout<<endl;
    
        init();
        cout<<"响应比优先算法:"<<endl;
        percentgo();
        cout<<endl;
    
        return 0;
    }
    

    7.结论分析

    End

    展开全文
  • 4 响应比高优先调度算法 测试数据: id reachtime dotime privilege 1 70 20 1 2 80 10 3 3 85 20 4 4 90 5 2 代码: #define _CRT_SECURE_NO_WARNINGS //解决VS报错 #include<stdio.h> #include<stdlib.h...
  • 用C语言实现了先来先服务(FCFS)、短作业优先(SJF)、响应比高优先(HRRF)、优先权高优先(HPF)四种作业调度算法,程序同样适用于进程调度算法。以文件形式提交输入,附样例输入文件job.txt。
  • printf("对进程按响应比高优先调度。\n\n"); hrrn(); poutput(); break; } } int fcfs() /*先来先服务*/ { float time_temp=0; int i; int number_schedul; time_temp=tasks[0].come_time; for(i=0;i;i++) { tasks[i...
  • 在采用响应比高优先调度算法时,其平均周转时间为T为()小时? 计算 周转时间=作业完成时间-作业提交时间 响应比=(作业等待时间+作业执行时间)/作业执行时间 当提交J1时,只有J1作业,执行J1,J1的
  • 调度算法

    2020-06-17 17:41:31
    响应比高优先算法;优先级算法;多队列循环算法;资源搭配算法。 先来先服务:总是把当前处于就绪队列之首的那个进程调度到运行状态。 多级队列算法:既能使高优先级的作业得到响应又能使短作业(进程)迅速完成...
  • 操作系统关于系统调度算法的实验报告:包括先来先服务调度算法、短作业优先调度算法响应比高优先调度算法在单道以及多道环境下的优劣势比较。
  • 使用响应比高优先算法 程序采用键盘输入,输入格式为: K TJ1 YS1 …… TJK YSK 其中K是作业数(>0),TJi提交时间,YSi (i=1~K)是作业预计的运行时间(以分钟计)TJ的输入格式是XXYY,其中XX是时,...
  • 作业调度算法

    2013-12-30 10:29:40
    作业调度算法: 分别使用先来先服务(FCFS),最短作业优先(SJF)、响应比高优先(HRN)的调度算法。c语言完成。
  • CPU 调度算法

    千次阅读 2019-03-24 22:19:47
    先来先服务调度(First Come First Serve) 效率不高,只考虑等候时间,而没考虑作业的长短,不利于短作业情况。 ...响应比高优先调度算法 兼顾响应时间和等待时间,计算作业的响应时间和运行...
  • 作业调度算法.zip

    2020-05-19 11:55:40
    银行家算法java实现 和三种常见作业调度算法实现,先来先服务(FCFS)、短作业优先(SJF)、响应比高优先(HRRF),使用了java语言
  • 操作系统复习资料以及各个算法源程序代码(银行家算法,进程调度算法,页面置换算法,作业调度-响应比高优先调度算法,设备管理-电梯调度算法, 可变式分区存储管理空间分配与去配)
  • 该资源是操作系统课程设计中作业调度算法的源程序,程序中主要用三种作业调度算法来实现一次作业调度,三种算法分别为:先来先服务算法、短作业优先算法、响应比高优先算法。程序简单易懂,包含大量注释。
  • 进程调度算法

    2011-12-14 17:21:53
    1.先来先服务\n"); 2.优先级调度\n"); 3.短作业优先\n"); 4.响应比高优先\n");
  • 先到先运行,短作业优先响应比高优先三种算法,附运行结果

空空如也

空空如也

1 2 3 4 5 6
收藏数 120
精华内容 48
关键字:

响应比高优先调度算法