这几个题是我这学期的 *** 作系统实验里桥罩让面，变了两个月才弄出来的，现在跟你分享一下（运行过了 没问题的）
先来先服务：c语言编写的
#include <stdio.h>
#include <malloc.h>
typedef struct jinchen //定义结构体
{
char name[5]
int tijiaoshijian
int reachtime
int runtime
int beirun
int accomplishtime
char state
int flag
struct jinchen *next
}PCB
PCB *finish,*ready//定义队列 一个完成一个就绪
int time=0
int t=0
int num
void InitPcb() //进程初始化
{
int i,j=0
PCB *p,*q,*l,*m,*k,*n
printf("请输入进程个数:")
scanf("%d",&num)
ready=(PCB *)malloc(sizeof(PCB))
ready->next=NULL
finish=(PCB *)malloc(sizeof(PCB))
finish->next=NULL
l=(PCB *)malloc(sizeof(PCB))
l->next=NULL
p=l
for(i=0i<numi++)
{
q=(PCB *)malloc(sizeof(PCB))
printf("\n进程号 %d:\n",i)
printf("请输入进程名：")
scanf("%s",q->name)
q->reachtime=0
printf("请输入提交时间：")
scanf("%d",&(q->tijiaoshijian))
printf("请输入运行时间：")
scanf("%d",&(q->runtime))
q->beirun=q->runtime
q->state='R'
q->flag=0
if(i!=0) //链接就绪进程
{
//q->next=NULL
q->next=p->next
p->next=q
p=p->next
}
else //第一个进闷携程插入就绪队列
{
p->next=q
p=p->next
p->next=NULL
}
}
p=l->next
k=ready
for(i=0i<numi++) 敏局//按照提交时间排序
{
q=l->next
t=1000
while(q!=NULL)
{
if(q->tijiaoshijian<t&&q->flag==0)
{
t=q->tijiaoshijian
m=(PCB *)malloc(sizeof(PCB))
m->next=NULL
m->accomplishtime=q->accomplishtime
m->beirun=q->beirun
m->flag=q->flag
for(j=0j<5j++)
m->name[j]=q->name[j]
m->reachtime=q->reachtime
m->runtime=q->runtime
m->state=q->state
m->tijiaoshijian=q->tijiaoshijian
n=q
}
q=q->next
}
p=p->next
n->flag=1
m->flag=1
k->next=m
k=k->next
}
k->next=NULL
}
void display() //函数作用：计算和显示相关输出
{
PCB *p
int m,n=0,k=0,l
p=finish->next
while(p!=NULL)
{
printf("进程名 :%s",p->name)
m=p->accomplishtime-p->tijiaoshijian
printf("周转时间:%d",m)
l=m/(p->beirun)
printf("带权周转时间:%d",l)
printf("\n")
n=m+n
k=l+k
p=p->next
}
printf("平均周转时间:%d\n",n/num)
printf("平均带权周转时间:%d\n",k/num)
}
void Use()//进程调用
{
int j
PCB *p=ready->next,*k=ready,*q,*n=finish
while(k->next!=NULL)
{
p=ready->next
for(j=0j<num&&p!=NULLj++)
{
time++
//printf("%d\n\n",++t)
if(p->reachtime==0)
p->reachtime=time
if(p->state!='C')
{
printf("正在运行:%s\n",p->name)
p->runtime--
if(p->runtime!=0) //进程没有运行完，放入队列最后
{
q=p
while(q->next!=NULL)
q=q->next
ready->next=p->next
q->next=p
p=ready->next
q=q->next
q->next=NULL
}
else //进程运行完，放入完成队列
{
p->state='C'
printf("%s进程完成\n",p->name)
p->accomplishtime=time
n->next=p
n=p
ready->next=p->next
p->next=NULL
}
}
}
}
}
int main()
{
PCB *p
InitPcb()
Use()
display()
p=finish->next
printf("运行完毕!*说明：已运行完成的进程放入完成队列，未运行完成的进程放在队列最后")
}
运行结果见图
按最高优先级算法：C++程序
#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=0i<ni++)
{
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)
}
public class PrivilegeProcess {public static void main(String[] args) {
MyQueue myqueue = new MyQueue()//声明队列
PCB[] pcb = {new PCB(001,8,1),new PCB(002,7,9),new PCB(003,3,8),new PCB(004,1,7),new PCB(005,7,4)}
PCB para = new PCB()
for(int i=0i<pcb.lengthi++){//初始化后首先执行一次排序，这里使用的是选择排序，优先级高的先入队
for(int j=ij<pcb.lengthj++){
if(pcb[i].privilege <pcb[j].privilege){
para = pcb[i]
pcb[i] = pcb[j]
pcb[j] = para
}
}
}
System.out.println("初次入队后各进程的顺序：")
for(int i=0i<pcb.lengthi++){
System.out.println("初次入队后 # processname : " + pcb[i].name + " totaltime : " + pcb[i].totaltime + " privilege :" + pcb[i].privilege)
}
System.out.println()
myqueue.start(pcb)
}
}
class MyQueue {
int index = 0
PCB[] pc = new PCB[5]
PCB[] pc1 = new PCB[4]
PCB temp = new PCB()
public void enQueue(PCB process){//入队算法
if(index==5){
System.out.println("out of bounds !")
return
}
pc[index] = process
index++
}
public PCB deQueue(){//出队算法锋派
if(index==0)
return null
for(int i=0i<pc1.lengthi++){
pc1[i] = pc[i+1]
}
index--
temp = pc[0]
for(int i=0i<pc1.lengthi++){
pc[i] = pc1[i]
}
return temp
}
public void start(PCB[] pc){//显示进程表算法
while(pc[0].isNotFinish==true||pc[1].isNotFinish==true||pc[2].isNotFinish==true||pc[3].isNotFinish==true||pc[4].isNotFinish==true){
//*注意：||运算符，所有表达式都为false结果才为false,否则为true
for(int i=0i<pc.lengthi++){
pc[i].run(this)
}
System.out.println()
for(int i=0i<pc.lengthi++){//所有进程每执行完一次时间片长度的运行就重新按优先弊陵级租基戚排列一次
for(int j=ij<pc.lengthj++){
if(pc[i].privilege <pc[j].privilege){
temp = pc[i]
pc[i] = pc[j]
pc[j] = temp
}
}
}
}
}
}
class PCB {//声明进程类
int name,totaltime,runtime,privilege
boolean isNotFinish
public PCB(){
}
public PCB(int name, int totaltime, int privilege){
this.name = name//进程名
this.totaltime = totaltime//总时间
this.privilege = privilege//优先级别
this.runtime = 2//时间片，这里设值为2
this.isNotFinish = true//是否执行完毕
System.out.println("初始值： processname : " + name + " totaltime : " + totaltime + " privilege :" + privilege )
System.out.println()
}
public void run (MyQueue mq){//进程的基于时间片的执行算法
if(totaltime>1){
totaltime-=runtime//在总时间大于1的时候，总时间=总时间-时间片
privilege--
System.out.println(" processname : " + name + " remaintime : " + totaltime + " privilege :" + privilege )
}else if(totaltime==1){
totaltime--//在总时间为1时，执行时间为1
privilege--
System.out.println(" processname : " + name + " remaintime : " + totaltime + " privilege :" + privilege )
}else{
isNotFinish = false//总时间为0，将isNotFinish标记置为false
}
if(isNotFinish==true){
mq.deQueue()
mq.enQueue(this)
}
}
}
分类: 电脑/网络 >> *** 作系统/系统故障问题描述:
请问各位大虾
Windows进链指程调度的方式有那几种？
谢谢了
解析:
高级调度：又称作业调度。其主要功能是根据一定的算法，从输人的一批作业中选出若干个作业，分配必要的资源，如内存、外设等，为它建立相应的用户作业进程和为其服务的系统进程（如输人、输出进程），最后把它们的程序和数据调人内存，等待进程调度程序对其执行调度，并在作业完成后作善后处理工作。
低级调度：又称进程调度。其主要功能是根据一定的算法将CPU分派给就绪队列中的一个进程。执行低级调度功能的程序称做进程调度程序，由它实现CPU在进程间的切换。进程调度的运行频率很高，在分时系统中往往几十毫秒就要运行一次。进程调度是 *** 作系统中最基本的一种调度。在一般类型的 *** 作系统中都必须有进程调度，而且它的策略的优劣直接影响整个系统的计能。
中级调度：又称交换调度。为了使内存中同时存放的进程数目不至于太多，有时就需要把某些进程从内存中移到外存上，以减少多道程序的数目，为此设立了中级调度。特别在采用虚拟存储技术的系统或分时系统中，往往增加中级调度这一级。所以中级调度的功能是在内存使用情况紧张时，将一些暂时不能运行的讲程从内存对换到外存上等待。当以后内存有足够的空闲空间时，再将合适的进程重新换人内存，等待进程调度。引人中级调度的主要目的是为了提高内存的利用率和系统吞吐量。它实际上就是存储器管理中的对换功能
下面说说进程调度的策略问题（引用参考资料内容）：
首先硬件机制上如何保证 *** 作系统的内核调度进程可以一定的时机可以获得CPU,来进行进程调度.?
通常我们会在软件层次上找答案.其实,是通过在CPU的硬件处理机制上实现的.CPU在执行完每个指令的周期后回扫描CPU的内部的一个中断寄存器,查询是否存在中断发生,若没有,则继续执行指令若有,则保存当前的CPU工作环境,跳转到中断服务列程,CPU执行中断服务程序,在推出中断后,跳转到内核调度程序(这是个内核程序,但是是对所有的进程共享的,包括用户进程)此时,内核调度程序占据CPU,进行进程的调度,以决定下个将占用CPU的进程.
接下来就要谈谈什么时候会需要进行进程调春孙度?
在教科书书说到的有几种情况:1时间片到,即每个进程所分配的时间片用完后,要跳转到调度程序2 占用CPU的当前运行进扒唤链程提出I/O *** 作,发起对内核的系统调用时,在系统调用结束后,跳转到调度程序3 我自己的想法: 当前运行进程对所有内核系统调用的结束时都要跳转到调度程序,根据当前的调度信息来决定下一个可以占用CPU的进程. 我所指的系统调用也包括中断列程.不过对与具体的调度时机,很多书上都写的不清不楚,真不知道他们不懂,还是不屑于写出来告诉我们. 其实除了在大多数硬件中断的触发后跳转到调度程序, 每个时钟中断发生的时候,我觉得都需要跳转到调度程序.(在进入时钟中断列程中,要对进程表中的所有的进程的调度信息进行更新和对各个进程队列的处理),对更新后的进程信息进行处理以决定调度哪个进程. 通常的教科书中都将硬件物理的处理机制和软件的调度处理机制分开,在物理和逻辑两个层次上分开谈,不利于我们理解.最好是把这两个结合起来理解进程调度的工作机制.目前需要解决的是:在什么时候需要内核调度程序占据CPU来调度? 至于调度的算法那就是逻辑层次上要考虑的东西.
其实看了这么多,我也有了些小论文的想法, 因为做的方向是应用在电子电力电路上的嵌入系统控制.该应用对嵌入 *** 作系统的性能就有些特殊的需求:首先体积要小,速度快内核就要小,进程调度要实现抢占式任务调度,且调度切换要快.它的进程调度与通用 *** 作系统的进程调度不同,这是因为它们的要求不一样,嵌入式通常是要求是实时,且严格的讲在电路上的控制系统应该是硬实时,而不象通用系统是非实时,或者是软实时.这跟它们对实时性的要求不同.所以我初步定个题目 "嵌入式系统和通用系统在进程调度上比较和分析,并针对特定的电路控制嵌入实时系统提出一个调度策略". 我想我从明天开始就要准备这方面的资料,分析分析,比较比较,弄篇小论文出来,,不然我都快给它凡死了.
*** 作系统-----进程调度
[/color][color=Gray][/color][color=Blue][/color][color=Lime] 要求：实现按优先级与时间片相结合的进程调度算法
内容：
1：设计进程控制快，进程队列结构（包括：就绪队列，等待队列，运行队列）等必要的数据结构。
2：模拟 *** 作系统进程调度的功能，编写进程调度程序，模拟的处理机分派程序，进程等待函数和进程唤醒函数。
3：编写用户程序，创建6个用户进程。
进程调度的设计方法
1。数据结构
（1）优先级与时间片的设计
◆进程因等待放弃CPU时，优先级置为1（高优先级）
◆进程因时间片到放弃CPU时，优先级置为0（低优先级）
◆优先1对应时间片4；优先级0对应时间片10。
（2）进程控制块（PCB）的内容
进程标识3---9
进程优先级 0，1
进程优先级 0，1
进程等待时间 20
链接指针
2：程序算法
（1）PCB结构，变量与主程序
struct PCB
{
int pname
int pri
int runtime
int waitting
struct PCB*next
}
pcb[7]
struct PCB*running,ready,wait
int sin=0
main()
{ 创建PCB[3]--PCB[9]并插入ready队列；／*pname分别为3--9,
pri=0,runtime=10,waittime=0 */
for()/*系统程序，完成初始化和处理机分派功能 */
{cast{sig=0:swtch
sig=1:waiter
sig=3:proc3
sig=4:proc4
sig=5:proc5
sig=6:proc6
sig=7:proc7
sig=8:proc8
sig=9:proc9}
}
}
(2) 进程调度程序
swtch()
{
while(ready==NULL)wakeup()
移出就绪队列第一个PCB
送running指针；
若pri=1,则runntime=4,否则runtime=10
将running→pname 送sig
}
(3) 将进程等待函数
wait()
{将运行进程插入wait队列，优先数置1；
sig=0
}
(4) 进程唤醒函数
wakeup()
{
将wait队列中所有的PCB中waittime减1；
将wait队列中的所有的waittime=0的PCB揭除；
插入到ready队列中第一个优先级为0的PCB前面
｝
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）