#include <stdio.h>
int m1 //共享变量
int m2 //共享变量
struct{
int id //进程标号
int waiter1 //指针，用于标识等待队列的下一个进程
int priority //进程优先级
char status //进程状态
}pcb[4]
struct{
int value //信号量的值
int waiter2//指针，用于标识等待此信号量队列的第一个进程
}sem[3]
char stack[11][4] //现场保护堆栈
int i； //cpu中的通用寄存器
int ep//当前运行进程指针
char addr //程序运行时的地址
void init() //初始化
int find() //找出就绪进程
int w2() //
int process1() //进程1
int process2() //进程2
int process3() //进程3
int p(int,int ,char) //P原语
int v(int,int ,char) //V原语
main()
{
init()
printf("系统程序开始执行\n")
for(){
if(find()!=0) //找出就绪进程
w2() //进程调度
else break//退出程序
}
printf("系统程序结束\n")
}
void init() //初始化进程
{
int j,k
pcb[0].status='w' //进程状态设置为等待
pcb[0].priority=4 //进程的优先级别
for(j=1j<=3j++){
pcb[j].id=j //进程编号
pcb[j].status='r' //进程状态设置为就绪
pcb[j].waiter1=0 //进程指针初始化为0
pcb[j].priority=j //设置进程优先级
}
for(j=1j<=2j++){
sem[j].value=1 //信号量赋值为1
sem[j].waiter2=0 //等待信号量队列的初始化
}
i=0 //CPU通用寄存器初始化
ep=0 //
addr='0' //程序运行地址
m1=0 //共享变量初始化
m2=0 //共享变量初始化
for(j=1j<=10j++){
for(k=1k<=3k++)
stack[j][k]='0' //现场保护堆栈初始化
}
}
int find(){ //查找初始化变量
int j
for(j=1j<=3j++)
if(pcb[j].status=='r') return(j)//如果pcb队列中有就绪进程，返回进程编号
return(0)
}
int w2(){ //进程调度程序
int pd
pd=find() //找出就绪进程编号
if(pd==0) return(0)//如果没有找到就绪进程，退出程序
else if(ep==0){//如果当前运行进程是否为0
pcb[pd].status='e' //直接将当前进程设置为运行状态
ep=pd //当前运行进程设置为pd
printf("进程%d正在执行\n",ep)
}
else
if(pcb[pd].priority<pcb[ep].priority)//如果当前进程比待调入进程优先级进行比较
{//调入进程优先级别高
pcb[ep].status='r'//把CPU运行进程执行状态设置为就绪
printf("读取进程%d\n",pcb[pd].id)
pcb[pd].status='e'//将待调入进程执行状态设置为执行
ep=pd//将当前运行进程指针为待调入进程
}
printf("运行进程%d\n",ep)
i=stack[1][ep] //恢复进程的通用寄存器中的值和运行地址。
addr=stack[2][ep]
switch(ep){ //根据当前运行的进程选择运行
case 1:process1()
break
case 2:process2()
break
case 3:process3()
break
default:printf("当前进程出现错误%d\n",ep)
break
}
}
int process1(){//进程1
if(addr=='m') goto m//如果当前运行地址是m，跳到m运行
i=1
a:
printf("进程1在信号量sem[1]上调用P *** 作\n")
if(p(1,1,'m')==0) return(0)//进行p *** 作，m表示程序执行到m
else goto m
m:
printf("打印进程1...m1=%d\n",m1)//进程1的 *** 作，打印，寄存器i＋5
printf("打印进程1...i=%d\n",i)
i+=5
goto a//跳回a执行
}
int process2(){//进程分为3部分
if(addr=='m') goto m
if(addr=='n') goto n
i=1
a:
printf("进程2在信号量sem[2]上调用P *** 作\n")
if(p(2,2,'m')==0) return(0)
m:
m1=2*m2
printf("进程2在信号量sem[1]上调用V *** 作m1=%d\n",m1)
if(v(1,2,'n')==0) return(0)
else{
n:
printf("打印进程2...i=%d\n",i)
i+=10
goto a
}
}
int process3(){
if(addr=='m') goto m
if(addr=='n') goto n
i=1
a:
if(i>4){
printf("进程3在信号量sem[2]上调用P *** 作\n")
if(p(2,3,'n')==0) return(0)
}
n:
m2=i
printf("进程3在sem[2]信号量上调用V *** 作m=%d\n",m2)
if(v(2,3,'m')==0) return(0)
else{
m:
i+=1
goto a
}
}
int p(int se,int p,char ad){
int w
sem[se].value--//信号量减1
if(sem[se].value==0) return(1)//如果信号量＝0，返回1，说明阻塞
printf("阻塞当前进程%d\n",p)
pcb[p].status='w'//改变进程状态
ep=0//运行进程为空
pcb[p].waiter1=0//设为尾末
w=sem[se].waiter2//找出等待队列的队尾
if(w==0) sem[se].waiter2=p//插入等待队列
else{
while(pcb[w].waiter1!=0) w=pcb[w].waiter1
pcb[w].waiter1=p
}
stack[1][p]=i//保存现场
stack[2][p]=ad
return(0)
}
int v(int se,int p,char ad){
int w
sem[se].value++//信号量加1
if(sem[se].value>0) return(1)//信号量>0，无等待进程
w=sem[se].waiter2//返回第一个等待进程
sem[se].waiter2=pcb[w].waiter1//调整位置
pcb[w].status='r'//进程改变状态
printf("唤醒进程%d\n",w)
stack[1][p]=i//进程状态进栈
stack[2][p]=ad
return(0)
}
分类: 电脑/网络 >> *** 作系统/系统故障问题描述:
请问各位大虾
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条）