计算机操作系统课程设计源代码《最低松弛度优先调度的实时系统调度程序代码》Word文件下载.docx
《计算机操作系统课程设计源代码《最低松弛度优先调度的实时系统调度程序代码》Word文件下载.docx》由会员分享，可在线阅读，更多相关《计算机操作系统课程设计源代码《最低松弛度优先调度的实时系统调度程序代码》Word文件下载.docx（13页珍藏版）》请在冰豆网上搜索。
//进程最近一次的最迟开始执行时间，-currenttime即为松弛度
intlatestarttime;
//进程下一次最早开始时间
intarivetime;
intk;
//k=1，表示进程正在运行，否则为0，表示进程不在执行期间
/*
若存在最小松弛度进程个数多于1个，
则采用最近最久未使用算法
采用一计数器LRU_t
*/
intLRU_t;
}process;
typedefstructsqqueue//循环队列
process*data[queuesize];
intfront,rear;
}sqqueue;
//初始化n个进程
voidInitprocess（process*pro,intn）
inti;
process*p=pro;
for（i=0;
i<
n;
i++）
*（p->
pname）='
\0'
;
p->
deadtime=0;
servetime=0;
lefttime=0;
cycle=0;
latestarttime=0;
arivetime=0;
k=0;
LRU_t=0;
p++;
}
//初始化队列（队空）
voidInitQueue（sqqueue*que）
que->
front=que->
rear=0;
//进程进入循环队列
voidenterQueue（sqqueue*que,process*pro）
//判断循环队列是否已满
if（（que->
rear+1）%queuesize==que->
front）
printf（"
队列已满!
\n"
）;
else
data[que->
rear]=pro;
//进程放入队尾
rear=（que->
rear+1）%queuesize;
//队尾指针加1
%s成功入队!
pro->
pname）;
//显示进程入队
//从当前队列中找到最低松弛度的进程
process*llf（sqqueue*dui,intcurrenttime）
sqqueue*q1=dui;
process*currentpro,*pro;
intminllf=MINLLF,llf;
intpro_LRU_t=PRO_LRU_T;
intfront=q1->
front,rear=q1->
rear;
//队首元素？
？
//将队首进程赋给当前进程
currentpro=q1->
data[front];
if（currenttime<
=MAXTIME）
//求最短松弛度currentpro，如果队列中只有一个进程
if（front==rear）
returncurrentpro;
%dms时%s%d进程的松弛度为：
%d\n"
currenttime,currentpro->
pname,currentpro->
cycle,llf）;
//进程数目多于一个
找当前时间下可以开始执行的进程中松弛度最小的，
赋给currentpro.
当最小松弛度的进程多于1个，
我们采用的是最后1个最小松弛度进程?
do
if（front!
=rear）
pro=q1->
if（pro->
arivetime<
=currenttime&
&
currenttime<
=MAXTIME）
//计算松弛度=周期*需执行的次数-（上一次）执行的时间-当前时间
llf=（pro->
deadtime）*（pro->
cycle）-pro->
lefttime-currenttime;
currenttime,pro->
pname,pro->
if（minllf>
=llf）//比较得出最低松弛度
if（pro->
LRU_t>
=pro_LRU_t）
pro_LRU_t=pro->
LRU_t;
minllf=llf;
currentpro=pro;
front=（front+1）%queuesize;
break;
}while（front!
=rear）;
//检测队列是否遍历完
//寻找松弛度<
=0的抢占进程，替代当前最小松弛度进程
process*leastlaxityfirst（sqqueue*dui,intcurrenttime）
sqqueue*q1=dui;
process*pro=NULL,*nextpro;
intfront=q1->
front,rear=q1->
rear;
当队列不空，寻找当前时刻
是否有松弛度为0（需抢占进程）的进程
while（front!
=rear）
nextpro=q1->
pro->
latestarttime初始为：
（pro->
cycle）-pro->
servetime;
latestarttime-currenttime即为松弛度
latestarttime-currenttime<
=0,
即松弛度=0，抢占，跳出循环
if（nextpro->
latestarttime<
=currenttime）
//如果队列空，返回pro
if（front==rear）
returnpro;
//队列不空，nextpro为此时抢占正在执行的进程的进程
returnnextpro;
//从队列中读取进程的过程
voidLLF_Process（sqqueue*dui）
intcurrenttime=0;
sqqueue*que=dui;
intfront=que->
front;
intrear=que->
process*currentpro,*pro,*tmppro;
//currentpro为当前时间队列中松弛度最低的进程
currentpro=llf（que,currenttime）;
//在MAXTIME时间内考虑
while（currenttime<
最低松弛度进程为空，
即为当前时间没有可运行的进程
if（currentpro==NULL）
%dms时无可运行进程!
currenttime）;
if（（currentpro->
=currenttime））
if（currenttime==MAXTIME）
//当进程正在运行
if（currentpro->
k==1）
%dms:
%s%d\n\n"
cycle）;
//当此时没有进程运行
\n=======执行只考虑前%dms，现时间已到%dms了！
======\n"
currenttime,currenttime）;
elseif（currenttime!
=MAXTIME）
if（currentpro->
k==0）
=>
%dms时刻%s%d进程开始执行:
%d-"
cycle,currenttime）;
currentpro->
k=1;
//表明进程开始运行
pro=que->
if（pro!
=currentpro）
LRU_t++;
currenttime++;
//当前时间增加
lefttime--;
//运行剩余时间减少
//当剩余运行时间等于0,即当程序运行结束
lefttime==0）
k==1）
//表明进程开始进入不执行状态
cycle++;
lefttime=currentpro->
arivetime=（currentpro->
deadtime）*（currentpro->
cycle-1）;
latestarttime=（currentpro->
cycle）-（currentpro->
servetime）;
currentpro=llf（que,currenttime）;
//当进程未运行完毕。
。
（可能被抢占）
//pro为抢占当前正执行进程的进程
pro=leastlaxityfirst（que,currenttime）;
if（pro!
=NULL）
如果当前存在抢占进程，
即pro!
=currentpro，
则使currentpro进程进入不执行状态
=currentpro）
k==1）
k=0;
cycle）
升级会员 