优先数调度:按最高优先级算法

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#define getpch(type) (type*)malloc(sizeof(type))

struct pcb{

char name[5];

char state;

int super;

int needtime;

int rtime;

int tijiaotime;

int starttime;

int ftime;

int zztime;

int dzztime;

struct pcb* link;

}*ready=NULL, *p;

typedef struct pcb PCB;

float pzztime=0;

float pdzztime=0;

int n;

int time=20;

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;

PCB *q;

printf("请输入进程数:");

scanf("%d",&n);

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

{

printf("\n第%d个进程:\n",i);

p=getpch(struct pcb);

printf("\n 进程名:");

scanf("%s",&p->name);

printf("\n 优先级:");

scanf("%d",&p->super);

printf("\n 运行时间:");

scanf("%d",&p->needtime);

printf("\n提交时间:");

scanf("%d",&p->tijiaotime);

p->rtime=0;

p->state=‘R‘;

p->link=NULL;

sort();

}

q=ready;

}

int space()

{

int l=0;

PCB *pr=ready;

while(pr!=NULL)

{

l++;

pr=pr->link;

}

return(l);

}

void disp(PCB *p2)

{

time = p2->tijiaotime > time? p2->tijiaotime:time;

p2->starttime=time;

time+=p2->needtime;

p2->state=‘R‘;

p2->ftime=time;

p2->zztime=p2->ftime-p2->tijiaotime;

p2->dzztime=p2->zztime/p2->needtime;

pzztime=p2->zztime+pzztime;

pdzztime=p2->dzztime+pdzztime;

printf("周转时间:%d\n",p->zztime);

printf("带权周转时间为 %d\n",p->dzztime);

}

void destroy()

{

free(p);

}

void running()

{

p->rtime=p->rtime+1;

if(p->rtime==p->needtime)

{ p->state=‘C‘;

printf("%s",p->name);

printf("运行完毕\n");

disp(p);

destroy();

}

else

{

(p->super)++;

sort();

printf("正在运行进程%s\n",p->name);

}

}

void main()

{

int len,h=0;

input();

len=space();

while((len!=0)&&(ready!=NULL))

{

h++;

p=ready;

ready=p->link;

p->link=NULL;

running();

}

pzztime=pzztime/n;

pdzztime=pdzztime/n;

printf("\n平均周转时间:%f\n平均带权周转时间为%f\n",pzztime,pdzztime);

}

时间: 2024-12-25 12:01:36

优先数调度:按最高优先级算法的相关文章

从零开始入门 K8s | 调度器的调度流程和算法介绍

导读:Kubernetes 作为当下最流行的容器自动化运维平台,以声明式实现了灵活的容器编排,本文以 v1.16 版本为基础详细介绍了 K8s 的基本调度框架.流程,以及主要的过滤器.Score 算法实现等,并介绍了两种方式用于实现自定义调度能力. 调度流程 调度流程概览 Kubernetes 作为当下最主流的容器自动化运维平台,作为 K8s 的容器编排的核心组件 kube-scheduler 将是我今天介绍的主角,如下介绍的版本都是以 release-1.16 为基础,下图是 kube-sch

实验三、动态优先数实验

一.  实验目的      用高级语言完成一个进程调度程序,以加深对进程的概念及进程调度算法的理解. 二.  实验内容和要求 编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对N(N不小于5)个进程进行调度.“最高优先级优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程. #include"stdio.h" #include"stdlib.h" #include"string.h" typedef struct n

0512操作系统 实验三 进度调度模拟程序

实验三 进程调度模拟程序                      1.    目的和要求 1.1.           实验目的 用高级语言完成一个进程调度程序,以加深对进程的概念及进程调度算法的理解. 1.2.           实验要求 1.2.1例题:设计一个有 N个进程并发执行的进程调度模拟程序. 进程调度算法:采用最高优先级优先的调度算法(即把处理机分配给优先级最高的进程)和先来先服务(若优先级相同)算法. (1).  每个进程有一个进程控制块(PCB)表示.进程控制块包含如下信息

【操作系统】知识点总结之进程管理与调度

1.中央处理器 1.1 CPU:处理器由运算器.控制器.一系列的寄存器以及高速缓存构成 运算器实现指令中的算术和逻辑运算,是计算机计算的核心 控制器负责控制程序运行的流程,包括取指令.维护CPU状态.CPU与内存的交互等等 寄存器是指令在CPU内部作处理的过程中暂存数据.地址以及指令信息的存储设备.在计算机的存储系统中它具有最快的访问速度.包括用户可见寄存器,控制寄存器. 用户可见寄存器 高级语言编译器通过算法分配并使用之,以减少程序访问主存次数 包括通用寄存器.数据寄存器.地址寄存器 数据寄存

Linux调度器 - deadline调度器

一.概述 实时系统是这样的一种计算系统:当事件发生后,它必须在确定的时间范围内做出响应.在实时系统中,产生正确的结果不仅依赖于系统正确的逻辑动作,而且依赖于逻辑动作的时序.换句话说,当系统收到某个请求,会做出相应的动作以响应该请求,想要保证正确地响应该请求,一方面逻辑结果要正确,更重要的是需要在最后期限(deadline)内作出响应.如果系统未能在最后期限内进行响应,那么该系统就会产生错误或者缺陷.在多任务操作系统中(如Linux),实时调度器(realtime scheduler)负责协调实时

计算机操作系统第三章自测题-处理机调度与死锁

1.在单处理器的多进程系统中,进程什么时候占有处理器以及决定占用时间的长短是由(  )决定的. A.进程运行时间     B.进程的特点和进程调度策略 C.进程执行的代码 D.进程完成什么功能 进程调度的时机与进程特点有关,如进程是否为CPU繁忙型还是I/O繁忙型.自身的优先级等.但是仅这些特点是不够的,能否得到调度还取决于进程调度策略,若采用优先级调度算法,则进程的优先级才起作用.至于占用处理器运行时间的长短,则要看进程自身,若进程是I/O繁忙型,运行过程中要频繁访问I/O端口,也就是说,可能

现代操作系统的调度

一. 操作系统调度的原则 1. 什么是调度 当计算机系统死多道程序设计系统时,通常就会有多个进程或者线程竞争CPU,只要有两个或者更多的进程处于就绪状态,这种情况就会发生,如果只有一个CPU可以用,那么必须选择下一个要运行的进程,在操作系统中,完成选择工作的这一部分被称为调度程序(scheduler).该程序使用的算法称为调度算法(scheduler algorithm). 几乎所有的进程的I/O请求或者计算都是交替突发的,注意,某些I/O活动可以看做是计算,例如,当CPU向视频RAM复制数据以

实现负载均衡的基本算法

平衡算法设计的好坏直接决定了集群在负载均衡上的表现,设计不好的算法,会导致集群的负载失衡.一般的平衡算法主要任务是决定如何选择下一个集群节点,然后将新的服务请求转发给它.有些简单平衡方法可以独立使用,有些必须和其它简单或高级方法组合使用.而一个好的负载均衡算法也并不是万能的,它一般只在某些特殊的应用环境下才能发挥最大效用.因此在考察负载均衡算法的同时,也要注意算法本身的适用面,并在采取集群部署的时候根据集群自身的特点进行综合考虑,把不同的算法和技术结合起来使用. 一.轮转法: 轮转算法是所有调度

块设备驱动之I/O调度层之调度算法

通过generic_make_request提交请求给I/O调度层,这个函数最后调用到q->make_request_fn(q, bio),那么对于这个函数的调用就是I/O调度层的入口点,首先来看看这个make_request_fn在哪被赋于能量的 void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn) { /* * set defaults */ q->nr_requests = BLKDEV_MA