首页 > 其他分享 >处理机调度

处理机调度

时间：2024-06-14 19:30:40浏览次数：21  
标签：处理机 int 调度 算法 时间 周转 pcb

目录

第1关：先来先服务调度算法

任务描述

相关知识

先来先服务调度算法FCFS

周转时间和带权周转时间

编程要求

分析：

答案： 

第2关：短作业优先调度算法 

任务描述

相关知识

短作业优先调度算法SJF

周转时间和带权周转时间

编程要求

分析： 

答案：

 第3关：高响应比优先调度算法

任务描述

相关知识

高响应比优先调度算法HRRN

周转时间和带权周转时间

编程要求

分析：

答案：

第1关：先来先服务调度算法

任务描述

本关任务：编写一个先来先服务器调度算法解决一个实际的进程调度问题，并打印出每个进程的完成时间、周转时间和带权周转时间

相关知识

为了完成本关任务，你需要掌握：1.先来先服务调度算法，2.进程周转时间和平均周转时间的计算方法。

先来先服务调度算法FCFS

FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，

周转时间和带权周转时间

周转时间=完成时间-到达时间

带权周转时间=周转时间/执行时间

编程要求

给定一组进程的到达时间和服务时间，实现先来先服务调度算法，并打印出调度结果，包括每个进程的完成时间、周转时间和带权周转时间。

进程 到达时间 服务时间

A         0         3

B         2         6

C         4         4

D         6        5

E         8         2

分析：

先来先服务调度算法

按照先后次序进行完成

首先从前往后遍历结构体数组，

如果到达时间小于或等于当前时间，则可以完成该作业，

否则到达时间大于当前时间则需要等待，即将当前时间更新为到达时间

答案： 
#include <stdio.h>
#include <string.h>

#define N 5

typedef struct JCB
{
	char name[10];
	int arriveTime;  //到达时间 
	int serveTime;   //服务时间 
	int finishTime;  //完成时间 
	int aroundTime;  //周转时间 
	float waroundTime; //带权周转时间 
}PCB;



void input(PCB pcb[N])
{
	strcpy(pcb[0].name,"A");
	pcb[0].arriveTime = 0;
	pcb[0].serveTime = 3;
	
	strcpy(pcb[1].name,"B");
	pcb[1].arriveTime = 2;
	pcb[1].serveTime = 6;
	
	strcpy(pcb[2].name,"C");
	pcb[2].arriveTime = 4;
	pcb[2].serveTime = 4;
	
	strcpy(pcb[3].name,"D");
	pcb[3].arriveTime = 6;
	pcb[3].serveTime = 5;
	
	strcpy(pcb[4].name,"E");
	pcb[4].arriveTime = 8;
	pcb[4].serveTime = 2;
	
	int i = 0;
	for(; i < N; ++i)
	{
		pcb[i].finishTime = 0;
		pcb[i].aroundTime = 0;
		pcb[i].waroundTime = 0;
	}

}

void output(PCB pcb[N])
{
	int i = 0;
	printf("进程\t");
	printf("完成时间\t");
	printf("周转时间\t");
	printf("带权周转时间\t\n");
	for(; i < N; ++i)
	{
		printf("%s\t",pcb[i].name);
		printf("%d\t\t",pcb[i].finishTime);
		printf("%d\t\t",pcb[i].aroundTime);
		printf("%f\t\t\n",pcb[i].waroundTime);
	}
}

//先来先服务调度算法 
void FCFS(PCB pcb[N])
{
	//请补充先来先服务算法的实现代码
    int i;
    int currentTime=0;
    for(i=0;i<N;i++)
    {
        if(pcb[i].arriveTime>currentTime)//到达时间晚于当前时间，等待
        {
            currentTime=pcb[i].arriveTime;
        }
        currentTime=currentTime+pcb[i].serveTime;//更新当前时间
        pcb[i].finishTime=currentTime;//更新完成时间
        pcb[i].aroundTime=pcb[i].finishTime-pcb[i].arriveTime;//计算周转时间
        pcb[i].waroundTime=1.0*pcb[i].aroundTime/pcb[i].serveTime;//计算带权周转时间
        
    }
}


int main()
{
	PCB pcb[N];
	
	input(pcb);
	FCFS(pcb);
	printf("先来先服务FCFS:\n"); 
	output(pcb);
	printf("\n");
	
}

第2关：短作业优先调度算法 

任务描述

本关任务：编写一个先来先服务器调度算法解决一个实际的进程调度问题，并打印出每个进程的完成时间、周转时间和带权周转时间

相关知识

为了完成本关任务，你需要掌握：1.短作业优先调度算法，2.进程周转时间和平均周转时间的计算方法。

短作业优先调度算法SJF

SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。作业的长短是以作业所要求的运行时间来衡量的。SJF算法可以分别用于作业调度和进程调度，处理机优先选择运行时间短的作业或者进程。

周转时间和带权周转时间

周转时间=完成时间-到达时间

带权周转时间=周转时间/执行时间

编程要求

给定一组进程的到达时间和服务时间，实现短作业优先调度算法，并打印出调度结果，包括每个进程的完成时间、周转时间和带权周转时间。

进程 到达时间 服务时间

A         0         3

B         2         6

C         4         4

D         6         5

E         8         2

分析： 

短作业优先调度算法 

服务时间越短优先级越高

寻找到达时间小于等于当前时间，且服务时间最短的作业完成

答案：
#include <stdio.h>
#include <string.h>

#define N 5

typedef struct JCB
{
	char name[10];
	int arriveTime;  //到达时间 
	int serveTime;   //服务时间 
	int finishTime;  //完成时间 
	int aroundTime;  //周转时间 
	float waroundTime; //带权周转时间 
}PCB;



void input(PCB pcb[N])
{
	strcpy(pcb[0].name,"A");
	pcb[0].arriveTime = 0;
	pcb[0].serveTime = 3;
	
	strcpy(pcb[1].name,"B");
	pcb[1].arriveTime = 2;
	pcb[1].serveTime = 6;
	
	strcpy(pcb[2].name,"C");
	pcb[2].arriveTime = 4;
	pcb[2].serveTime = 4;
	
	strcpy(pcb[3].name,"D");
	pcb[3].arriveTime = 6;
	pcb[3].serveTime = 5;
	
	strcpy(pcb[4].name,"E");
	pcb[4].arriveTime = 8;
	pcb[4].serveTime = 2;
	
	int i = 0;
	for(; i < N; ++i)
	{
		pcb[i].finishTime = 0;
		pcb[i].aroundTime = 0;
		pcb[i].waroundTime = 0;
	}
	
}

void output(PCB pcb[N])
{
	int i = 0;
	printf("进程\t");
	printf("完成时间\t");
	printf("周转时间\t");
	printf("带权周转时间\t\n");
	for(; i < N; ++i)
	{
		printf("%s\t",pcb[i].name);
		printf("%d\t\t",pcb[i].finishTime);
		printf("%d\t\t",pcb[i].aroundTime);
		printf("%f\t\t\n",pcb[i].waroundTime);
	}
}


//短作业优先调度算法 
void SJF(PCB pcb[N])
{
	//请补充短作业优先算法的实现代码
	int st[N]={0};//标记是否完成
	int currentTime=0;//记录当前时间
	int minx;//查找每次的最小执行时间
	int index;//记录下标
	for(int i=0;i<N;i++)
	{
		minx=0x3f3f3f3f;//为了查找最小值，先赋予一个无穷大的值，0x3f3f3f3f是一个很大的值
		for(int j=0;j<N;j++)
		{
			if(!st[j]&&pcb[j].arriveTime<=currentTime)//如果没完成，并且到达时间小于等于当前时间
			{
				if(minx>pcb[j].serveTime)//则判断执行时间是否比记录的执行时间小
				{
					minx=pcb[j].serveTime;//是则记录下来
					index=j;
				}
			}
		}
		st[index]=1;//完成则标记，置为1
		currentTime=currentTime+pcb[index].serveTime;//更新当前时间
		pcb[index].finishTime=currentTime;//计算完成时间
		pcb[index].aroundTime=pcb[index].finishTime-pcb[index].arriveTime;//计算周转时间
		pcb[index].waroundTime=1.0*pcb[index].aroundTime/pcb[index].serveTime;//计算带权周转时间
	}
}


int main()
{
	PCB pcb[N];
	
	
	input(pcb);
	SJF(pcb);
	printf("短作业优先SJF:\n"); 
	output(pcb);
	printf("\n");
	
}

 第3关：高响应比优先调度算法

任务描述

本关任务：编写一个高响应比优先调度算法解决一个实际的进程调度问题，并打印出每个进程的完成时间、周转时间和带权周转时间

相关知识

为了完成本关任务，你需要掌握：1.先来先服务调度算法，2.进程周转时间和平均周转时间的计算方法。3、响应比的计算方法

高响应比优先调度算法HRRN

在批处理系统中，FCFS算法所考虑的只是作业的等待时间，而忽视了作业的运行时间。而SJF算法正好与之相反，只考虑作业的运行时间，而忽视了作业的等待时间。高响应比优先调度算法则是既考虑了作业的等待时间，又考虑作业运行时间的调度算法，因此既照顾了短作业，又不致使长作业的等待时间过长，从而改善了处理机调度的性能。 高响应比优先算法引入了响应比的概念，响应比定义如下 响应比=（等待时间+运行时间）/运行时间 高响应比优先算法每次选择响应比最高的进程，进程的响应比是动态变化的，既考虑了进程的等待时间，也考虑了进程的服务时间。

周转时间和带权周转时间

周转时间=完成时间-到达时间

带权周转时间=周转时间/执行时间

编程要求

给定一组进程的到达时间和服务时间，实现高响应比优先调度算法，并打印出调度结果，包括每个进程的完成时间、周转时间和带权周转时间。

进程 到达时间 服务时间

A         0         3

B         2         6

C         4         4

D         6         5

E         8         2

分析：

高响应比优先调度算法

响应比高的优先

计算每个作业的响应比，再挑选其中最高的先完成

答案：
#include <stdio.h>
#include <string.h>

#define N 5

typedef struct JCB
{
	char name[10];
	int arriveTime;  //到达时间 
	int serveTime;   //服务时间 
	int finishTime;  //完成时间 
	int aroundTime;  //周转时间 
	float waroundTime; //带权周转时间 
}PCB;



void input(PCB pcb[N])
{
	strcpy(pcb[0].name,"A");
	pcb[0].arriveTime = 0;
	pcb[0].serveTime = 3;
	
	strcpy(pcb[1].name,"B");
	pcb[1].arriveTime = 2;
	pcb[1].serveTime = 6;
	
	strcpy(pcb[2].name,"C");
	pcb[2].arriveTime = 4;
	pcb[2].serveTime = 4;
	
	strcpy(pcb[3].name,"D");
	pcb[3].arriveTime = 6;
	pcb[3].serveTime = 5;
	
	strcpy(pcb[4].name,"E");
	pcb[4].arriveTime = 8;
	pcb[4].serveTime = 2;
	
	int i = 0;
	for(; i < N; ++i)
	{
		pcb[i].finishTime = 0;
		pcb[i].aroundTime = 0;
		pcb[i].waroundTime = 0;
	}
	
}

void output(PCB pcb[N])
{
	int i = 0;
	printf("进程\t");
	printf("完成时间\t");
	printf("周转时间\t");
	printf("带权周转时间\t\n");
	for(; i < N; ++i)
	{
		printf("%s\t",pcb[i].name);
		printf("%d\t\t",pcb[i].finishTime);
		printf("%d\t\t",pcb[i].aroundTime);
		printf("%f\t\t\n",pcb[i].waroundTime);
	}
}


//高响应比优先调度算法 
void HRRN(PCB pcb[N])
{
	//请补充高响应比优先调度算法实现代码
	int st[N]={0};//判断是否完成
	int xyb;//响应比
	int currentTime=0;//当前时间
	int index;
	for(int i=0;i<N;i++)
	{
		xyb=0;
		for(int j=0;j<N;j++)
		{
			if(st[j])continue;
			int run=currentTime-pcb[j].arriveTime;//计算等待时间
			int t=(run+pcb[j].serveTime)/pcb[j].serveTime;//计算响应比
			if(xyb<t)//找到响应比最高的下标
			{
				xyb=t;
				index=j;//记录响应比最高的下标
			}
		}
		st[index]=1;//完成则标记，置为1
		currentTime=currentTime+pcb[index].serveTime;//更新当前时间
		pcb[index].finishTime=currentTime;//计算完成时间
		pcb[index].aroundTime=pcb[index].finishTime-pcb[index].arriveTime;//计算周转时间
		pcb[index].waroundTime=1.0*pcb[index].aroundTime/pcb[index].serveTime;//计算带权周转时间
	}
}


int main()
{
	PCB pcb[N];
	
	input(pcb);
	HRRN(pcb);
	printf("高响应比优先HRRN:\n"); 
	output(pcb);
	
}

标签：处理机,int,调度,算法,时间,周转,pcb
From： https://blog.csdn.net/qwertf123/article/details/139686759

相关文章

  • K8S故障处理：临时设置节点为不可调度（cordon与drain区别）
    在Kubernetes中，节点驱逐是一种管理和维护集群的重要操作，允许节点在维护、升级或者发生故障时从集群中移除，等到节点修复后，再重新承担pod调度功能。1.K8s节点驱逐节点驱逐是指将节点上运行的Pod迁移到其他可用节点上，并暂时从集群中移除目标节点。这个操作通常在节点维护、系统升级......
  • 磁盘性能概述与磁盘调度算法
    目录1.磁盘性能概述1.数据传输速率2.寻道时间3.旋转延迟4.平均访问时间2.早期的磁盘调度算法1.FIFO（First-In-First-Out）调度算法2.SSTF（ShortestSeekTimeFirst）调度算法3.SCAN（ElevatorAlgorithm）调度算法4.C-SCAN（CircularSCAN）调度算法3.基于扫描的磁......
  • 调度系统的计算资源的利用率，以及常见的可以计算的资源
    计算各个计算资源的利用率通常是通过将实际工作量与资源的总容量进行比较来实现的。具体来说，利用率可以根据不同类型的计算资源来计算，包括：处理器利用率：对于CPU，可以通过计算CPU的工作时间与总时间的比例来计算利用率。例如，可以使用操作系统提供的工具来监控CPU的使用情况，并......
  • 一个串行程序，94%的执行时间花费在一个可以并行化的函数中。现使其并行化，问该并行程序
    经测试发现，1）一个串行程序，94%的执行时间花费在一个可以并行化的函数中。现使其并行化，问该并行程序在10个处理机上执行所能达到的加速比是多少？能达到的最大加速比是多少？2）一个并行程序，在单个处理机上执行，6%的时间花费在一个I/O函数中，问要达到加速比10，至少需要多少个处理机？......
  • 如何评估pcdn调度算法的优化效果（贰）
    PCDN（PersonalizedContentDeliveryNetwork）调度算法的优化可以通过以下几个方面来进行：1、性能指标：首先确定要评估的关键性能指标（KPIs），如平均响应时间、内容分发速度、缓存命中率、用户满意度等。这些指标应直接反映算法优化后的效果。2、基准测试：在优化之前，进行基准测试以......
  • Go语言goroutine调度器初始化
    1、调度器初始化调用点：src/runtime/asm_amd64.s:349 -> CALLruntime·schedinit(SB)runtime/proc.go:526funcschedinit(){//raceinitmustbethefirstcalltoracedetector.//Inparticular,itmustbedonebeforemallocinitbelowcallsracemapshadow.......
  • presto 查询调度流程 (Coordinator Scheduler)
    basedontag:0.287presto的scheduler是SqlQueryScheduler这个类控制的,这个class主要是负责调度物理执行计划。调度具体的每个SqlStageExecution.这个Stage可以当成Fragment的一个概念他会先把所有的stage创建一个schedule计划。一共有两种schedule计划，一个是all-at-on......
  • 在Linux中，如何进行调度任务？什么是 crontab 并解释 crontab 中的字段？
    在Linux中，调度任务通常指的是在预定的时间自动执行脚本或命令。cron（cronjob）是一种常用的任务调度工具，它按照设定的时间表周期性地执行任务。1.什么是crontab？crontab是一个配置文件，它包含了一个或多个cron任务的列表。每个任务都有一个特定的时间表，定义了任务何时执行。cro......
  • 【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 机场航班调度程序(100分) - 三语言A
    ......
  • 第3讲：进程调度
    分为两类：抢占式多任务非抢占式多任务进程可分为：IO消耗型、CPU消耗型。调度方式（1）优先级调度nice值（-20~19）：值越大、优先级越低。nice值映射到时间片问题：（1）绝对时间片无法保证最优解；（2）nice值越靠近边界、波动越大；（3）定时器节拍问题实时优先级。（2）时间片CFS调度分配的是......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99