短作业调度算法

#include <stdio.h>
struct sjf //定义进程的结构体
{
 char name[10]; //进程名
 float arrivetime; //到达时间
 float servicetime; //服务时间
 float starttime;  //开始时间
 float finishtime; //完成时间
 float zztime; //周转时间
 float dqzztime; //带权周转时间
 };
 sjf b[100]; //定义短作业优先算法进程的最大数量
 void Sinput(sjf *p,int N)  //输入函数
 {
   int i;
 printf("输入进程的名称、到达时间、服务时间:\n");
 for(i=0;i<=N-1;i++)
 {
 printf("输入第%d进程的名称、到达时间、服务时间:",i+1);
 scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);
 
}
}  //输出每个进程的信息

void
SPrint(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N)
{
 int k;
 printf("\n执行顺序:\n");
 printf("%s",p[0].name);
 for(k=1;k<N;k++)
 {
 printf("-%s",p[k].name);
 }
 printf("\n进程名\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");
 for(k=0;k<=N-1;k++)
 {
printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n",p[k].name,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);
 }
}//输出执行顺序
 
void Ssort(sjf *p,int N) //按短作业优先算法排序
{
 for(int i=1;i<=N-1;i++)
 for(int j=1;j<=i;j++)
 if(p[i].servicetime<p[j].servicetime)
 {
 sjf temp;
 temp=p[i];
 p[i]=p[j];
 p[j]=temp;
 }
} //运行结果(冒泡排序)
 
void Sdeal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N)
{
 int k;
 for(k=0;k<=N-1;k++)
 {
 if(k==0)
 {
 p[k].starttime=p[k].arrivetime;
 p[k].finishtime=p[k].arrivetime+p[k].servicetime;
 }
 else
 {
 p[k].starttime=p[k-1].finishtime; //开始时间=前一个进程的完成时间
 p[k].finishtime=p[k-1].finishtime+p[k].servicetime; //结束时间=前一个进程的完成时间+现在进程的服务时间
 }
 }
 for(k=0;k<=N-1;k++)
 {
 p[k].zztime=p[k].finishtime-p[k].arrivetime;  //周转时间=完成时间-到达时间
 p[k].dqzztime=p[k].zztime/p[k].servicetime;  //带权周转时间=周转时间/服务时间
 }
}  //计算各种时间

void SJF(sjf *p,int N)
{
float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0; //初始化
Ssort(p,N); //调用的排序
Sdeal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N); //得到各种时间
SPrint(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);//输出结果

void main() //主函数
 {
  int M;
 printf("短作业优先调度算法\n");
 printf("输入进程数:");
 scanf("%d",&M);
 Sinput(b,M);
 SJF(b,M); 
}

时间: 2024-10-12 15:09:57

短作业调度算法的相关文章

模拟处理机作业调度---短作业优先调度算法

短作业优先调度原理 短作业优先调度算法是指对短作业优先调度的算法.短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行. 算法流程图 JCB 代表一个作业,JCB 的结构如下: 模拟实现 在屏幕上输出以下作业状态表: 可以通过键盘命令动态地增加作业(即增加一个 JCB 数 据结构项).增加作业后,作业状态表内容可更新查看. 算法代码: #include "stdafx.h" #include<iostream> #inclu

短作业优先调度算法(SJF)

假设有n项作业位于就绪队列中,这些作业的提交时间用数组requestTimes按照提交时间的先后顺序存储,对应的作业服务时间(持续时间)用数组durations存储.采用SJF算法,计算n项作业的平均等待时间.当存在多个相同长度的短作业时,按照提交时间的先后顺序进行调度.假设0<= n <= 100.求出所有作业的平均等待时间. 函数原型:void minWaitingTime(int requestTimes[],int durations[],int n) 测试用例: 输入 40 2 4

作业调度算法

先来先服务.短进程优先算法 一.实验目的 通过使用c对先来先服务.短进程优先算法的实现,进一步理解并掌握调度算法的逻辑过程,以及每种算法分别在进程调度和作业调度中的的处理方法. 二.实验原理 先来先服务:该算法在每次调度中,都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为他们分配资源.创建进程,然后放入就绪队列.在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,位置分配处理机,使之投入运行.该进程一直运行到完成或发生某事件而阻塞后才放

转 作业调度算法

http://blog.csdn.net/piaojun_pj/article/details/5931324 .先来先服务(FCFS, First Come First Serve)是最简单的调度算法,按先后顺序进行调度. 定义: 按照作业提交或进程变为就绪状态的先后次序,分派CPU: 当前作业或进程占用CPU,直到执行完或阻塞,才出让CPU(非抢占方式). 在作业或进程唤醒后(如I/O完成),并不立即恢复执行,通常等到当前作业或进程出让CPU. 适用场景: 比较有利于长作业,而不利于短作业.

常见的作业调度算法总结

今天被问到操作系统的一些知识,发现自己一个不会,实在还是有点尴尬,之前的学习一直在框架,游戏引擎上,基本上忽略了学校大部分的理论知识-于是最近突然想学学操作系统了-反正也没什么事忙了!! ---------------------------------------- 操作系统是什么?[概念] 是管理和控制计算机硬件与软件资源的计算机程序,是直接运行在“裸机”上的最基本的系统软件 -----这句话感觉意思都懂,但是就是概括不出来- 进程是什么?[概念] 进程是操作系统结构的基础:是一次程序的执行

Hadoop集群三种作业调度算法介绍

Hadoop集群中有三种作业调度算法,分别为FIFO,公平调度算法和计算能力调度算法先来先服务(FIFO)Hadoop中默认的调度器FIFO,它先按照作业的优先级高低,再按照到达时间的先后选择被执行的作业.FIFO比较简单,hadoop中只有一个作业队列,被提交的作业按照先后顺序在作业队列中排队,新来的作业插入到队尾.一个作业运行完后,总是从队首取下一个作业运行.这种调度策略的优点是简单.易于实现,同时也减轻了jobtracker的负担.但是它的缺点也是显然的,它对所有的作业都一视同仁,没有考虑

【ZX笔试】短作业优先算法

时间复杂度为O(n*n),空间复杂度为O(n)的解法 1 // ShortJobFirst.cpp : 定义控制台应用程序的入口点. 2 // 3 4 #include "stdafx.h" 5 #include <iostream> 6 #include <vector> 7 8 using namespace std; 9 10 /* 11 每一步都计算当前时间和总的等待时间,根据当前时间(cpu_time)找到已经就绪的作业下标, 12 保存到vec_re

YARN中用的作业调度算法:DRF(Dominant Resource Fairness)

在Mesos和YARN中,都用到了dominant resource fairness算法(DRF),它不同于hadoop基于slot-based实现的fair scheduler和capacity scheduler,论文阅读:Dominant Resource Fairness: Fair Allocation of Multiple Resource Types .考虑在一个包括多种资源类型(主要考虑CPU和MEM)的系统的公平资源分配问题,其中不同用户对资源有不同的需求.为了解决这个问题

【操作系统】作业调度的算法

先来先服务调度算法(FCFS) FCFS是最简单的调度算法,该算法即可用于作业调度也可以用于进程调度. 作业等待的长短是其优先级 按照作业先后到达的顺序调度 也可能是系统中等待时间最长的作业 短作业优先调度算法(SJF) 由于实际情况中,短作业进程占了很大比例,为了能使他们能比长作业优先执行,而产生了短作业调度算法 作业的长短是其优先级 作业越短,优先级越高 先调度短作业,等短作业调度完,再调度长作业 缺点: 必须知道预知作业的运行时间 对长作业非常不利 人机无法实现交互 没有完全考虑作业的紧迫