|
EDA365欢迎您!
您需要 登录 才可以下载或查看,没有帐号?注册
x
<p><font face="Verdana">C语言源程序代码-进程调度</font><br/></p><pre>/*8.3.2 源程序*/
# |; v/ K8 Y) \. D; k3 L' H: W C#include "stdio.h"
$ d! x1 `( P8 b#include "stdlib.h") \) Z7 t1 ]# A( M3 C; `
#include "string.h"& M6 i" g2 X! Z; a" g: S
typedef struct node0 n. O9 i9 q9 C/ U# ]: q
{0 I' e) W" b) [8 b2 I! D; H1 {; Z
char name[10]; /*进程标识符*/
7 }! G( ~( X" Q9 \4 x' \ int prio; /*进程优先数*/
' v, f0 V: s6 w# F5 C' | int round; /*进程时间轮转时间片*/: [: E0 Z) l2 k' k
int cputime; /*进程占用CPU时间*/$ O- y# A1 e0 v8 Y9 u- e
int needtime; /*进程到完成还要的时间*/
7 e) g5 K% _% W# \, s int count; /*计数器*/
8 [9 o, X+ O$ s" U+ q+ \+ U! F char state; /*进程的状态*/
0 M+ s* q% Z0 Z4 p4 Z9 z struct node *next; /*链指针*/5 e7 i( j2 {) [, c0 K. C
}PCB;
% u7 r) m4 h0 X: D' A, ^) |PCB *finish,*ready,*tail,*run; /*队列指针*/
/ V4 D! m* i/ cint N; /*进程数*/
$ B7 ^( J1 b0 F3 w3 H0 J/*将就绪队列中的第一个进程投入运行*/
. d8 W6 }. L- k* `3 jfirstin()+ \/ I4 Q7 N! f9 z
{
# h& x( X8 u. i0 |- v run=ready; /*就绪队列头指针赋值给运行头指针*/, d+ a. Z9 H2 e6 x" g5 W6 w' h; |
run->state='R'; /*进程状态变为运行态*/: _ ], G. p) m, B, U, @( m
ready=ready->next; /*就绪对列头指针后移到下一进程*/
+ Y+ {' |" t9 Y% j2 Z+ P}: r7 z4 X7 t- p6 f& X
/*标题输出函数*/
' y0 d! f& d/ B% P. y W8 G6 F, N, Hvoid prt1(char a)
( J6 C- J& F! {/ Q$ X{! r9 [/ B, h# a3 T+ \* S& D
if(toupper(a)=='P') /*优先数法*/9 H: j; \. a1 E& S0 n0 @/ E
printf(" name cputime needtime priority state\n");
9 v$ _' o* C, t1 k: k else0 M% Q* \# ~1 W- \5 G9 O
printf(" name cputime needtime count round state\n");/ j5 L3 q; N* g$ A6 o. b
}% |- s4 I9 Y0 d: y; Q) L$ {' w0 c j
/*进程PCB输出*/$ ^: O, `' s& x( E
void prt2(char a,PCB *q) G! t! i$ k# B( ]/ S- W
{
% L* ]3 o8 F: J7 K if(toupper(a)=='P') /*优先数法的输出*/ y9 X" |5 _9 a' N
printf(" %-10s%-10d%-10d%-10d %c\n",q->name,
$ X+ t6 T( E# ~ u0 f2 t q->cputime,q->needtime,q->prio,q->state);) }, u/ Q6 i6 p; S
else/*轮转法的输出*/
0 u$ O. h4 e% s# |1 L& I: h7 B& v printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,
' S& e9 t: V' i1 p5 C: { q->cputime,q->needtime,q->count,q->round,q->state);% m' v* N2 Y* P4 @, p
}( P! |$ H2 h W4 R& A$ X
/*输出函数*/1 a7 b C* q* F7 P* h3 n' X* k
void prt(char algo)
1 h% {0 a) E' W+ ]: t6 _" M2 E& F{
' }% x |* j4 ]+ r; A6 P, [ PCB *p;
+ {- a* w" I& K: p5 i: i: K prt1(algo); /*输出标题*/
/ M0 R" Y& }" C/ V' s if(run!=NULL) /*如果运行指针不空*/3 v1 y2 {" {: W2 Z' f3 ^4 [4 w( a
prt2(algo,run); /*输出当前正在运行的PCB*/6 Q: G, P4 A- j0 Q& h
p=ready; /*输出就绪队列PCB*/6 U1 D( J) ] v1 C9 E d
while(p!=NULL)
" u: @/ z) Z# ~4 |$ j% l {9 @$ l1 m+ m O) o. C
prt2(algo,p); `' _5 r, j5 V7 p' A7 x! f
p=p->next;0 ?( _" W$ K* t. c1 g* H
}
% E4 x( _/ ]" ` p=finish; /*输出完成队列的PCB*/. \7 X1 f. G2 ?, k! u
while(p!=NULL)
: ~% X( ?# I* p7 O {
( \: v% G0 _1 Y e prt2(algo,p);
" J; h# e% F; W W& O p=p->next;% `; L$ c! d9 |3 {- S, ]
}
1 I. ?" Y4 D. g, ]" P getch(); /*压任意键继续*/
' M) I6 d& V9 X1 n0 e- x% e}
0 g. o. n+ T; Y" p; n/*优先数的插入算法*/ v* G9 w1 T5 F; A" |% |2 F
insert1(PCB *q)0 z* x* ^8 X! X6 m9 T1 y" r0 b
{
% X+ r. O: Q% ]$ m j$ ? PCB *p1,*s,*r;
. N: i- O$ b1 r2 X, l! G" h- U int b;( g1 e7 J( K1 X2 ]: i
s=q; /*待插入的PCB指针*/
3 R% `+ Z8 w# E0 | p1=ready; /*就绪队列头指针*/
" F/ r3 v6 \" \ r=p1; /*r做p1的前驱指针*/
! Y5 b( S: B( _ b=1;* k5 |1 b9 Y' Z8 O* H
while((p1!=NULL)&&b) /*根据优先数确定插入位置*/! b: W: F5 G- s/ c# p$ q- G
if(p1->prio>=s->prio)
/ V* S+ o0 X$ O1 F2 ~; r0 B; G {1 b% ^, F" C- \. ]1 O* [: i* ?
r=p1;
9 l; l5 g+ x5 l2 x" E p1=p1->next;
- d" c; G8 P2 [ x2 e }
4 F5 a. R z& @ else
5 ]/ n7 m6 e j: ]5 Q b=0;
8 L C3 Z, q- H7 R' c, ]4 R if(r!=p1) /*如果条件成立说明插入在r与p1之间*/3 u; I- V9 j6 O& d0 d2 J( Y5 g
{! _ H' e& y0 z; z' g6 j
r->next=s;! l E( ?( `. J1 `/ U6 Q& T
s->next=p1;, h! W9 O" [" t: b6 D, P
}# ]9 }1 y8 F1 N
else5 J$ V2 v% x- b) t6 k& b3 l @
{
, c' x$ j9 i! T( [# L s->next=p1; /*否则插入在就绪队列的头*/
9 x: D3 t* |- z ready=s;
1 N5 [* f% }6 O2 ?4 v( j( L }5 F2 I+ u# w& K7 }/ f
}$ r7 ]8 W& m7 ^9 R4 _ o* d' M
/*轮转法插入函数*/ @* m3 a1 I! V& x4 ]0 b: T
insert2(PCB *p2)1 N$ Z6 ]5 k0 z" J2 P# m( N% m
{- s9 O _2 l" c1 ~' h5 s4 F
tail->next=p2; /*将新的PCB插入在当前就绪队列的尾*/, s% p0 Q" ^0 U5 s. B- v) n
tail=p2;
+ d# L" U F0 b& S7 B0 [$ H p2->next=NULL;7 C$ j) _* I, Q+ [; H# F* o
}' T5 Q# Q$ x& a; X7 V/ r7 R
/*优先数创建初始PCB信息*/
4 A' a4 E7 f% ]6 F0 ]4 [void create1(char alg)
7 B6 @. [) T+ X2 G{
4 x' \6 k( V, Z5 d7 g9 I' L PCB *p;1 d" P/ r+ j0 P* n6 ?
int i,time;% l( o, H" O1 t
char na[10];
$ |" x: w) |& k* K' c ready=NULL; /*就绪队列头指针*/5 e6 A( w/ Q$ e" W$ E' \; T7 n
finish=NULL; /*完成队列头指针*/
9 w3 C# D: q! S run=NULL; /*运行队列指针*/9 e0 N4 ?6 g% F
printf("Enter name and time of process\n"); /*输入进程标识和所需时间创建PCB*/7 ^; G0 j- k, B6 {
for(i=1;i<=N;i++)# H1 e! P3 X8 s, A8 E0 ^
{0 N+ }) f' r' I4 @$ r' Z( K" S- w
p=malloc(sizeof(PCB));
7 ~- {/ X9 e5 Y' C scanf("%s",na);) \6 N( d( E( v3 c( n
scanf("%d",&time);
' `0 j* Y, T! A" N strcpy(p->name,na);6 T+ H( J( k, t- H
p->cputime=0;
- }8 Y% E% x) t1 K) b p->needtime=time;0 I Z; v; b' c- H4 T$ y
p->state='w';& D8 J7 `; n# N2 w" h& {% o
p->prio=50-time;
" Z7 n ?+ y) i if(ready!=NULL) /*就绪队列不空调用插入函数插入*/1 m0 W# s. q& {( s( j- u
insert1(p);
/ F; N2 J" G$ B9 M, e else
& c' O' ^7 v2 Y' w {" |, j: B a& E, \
p->next=ready; /*创建就绪队列的第一个PCB*/
" y& V1 n- ^3 J1 S& u+ V ready=p;% A5 U$ i9 |" v* l
}
( Z" |2 r; B2 }. q% s }
6 j" `8 L* ]3 N7 g5 x clrscr();) f2 \6 K+ q8 Y
printf(" output of priority:\n");6 h2 U1 ~/ k8 T' }3 }. l. f8 b
printf("************************************************\n");
' R9 Z# @4 c6 Q9 I prt(alg); /*输出进程PCB信息*/( S( B9 w4 a% i9 g& J
run=ready; /*将就绪队列的第一个进程投入运行*/* P: s) p& x5 m4 |& L8 r+ t" m0 a
ready=ready->next;
2 d k+ T* o$ H7 U( {$ F, M6 _ run->state='R';0 v1 }( y4 z7 I( G0 b. \
}
- U5 ^( {" f) V1 a; v/*轮转法创建进程PCB*/
& @: d; h5 ~% T( ^void create2(char alg)
% j: F" ~4 Z! d5 b& @2 m) Y3 K D, Y! V{+ E8 h9 Z1 L1 J: f0 I
PCB *p;
) H) l, D& t) L) p0 h/ @4 C int i,time;
8 z4 v/ m. E4 W1 o* X! i char na[10];
- ]6 ^% T+ x0 p) ~ E/ i1 A) h3 q ready=NULL;
7 t& F" T& ^* U' E# {: |8 I finish=NULL;2 l* l: m# z8 U5 M2 E
run=NULL;
* ~ @$ @" _7 f& q7 G printf("Enter name and time of round process\n");4 s5 ]' s, A" { L& C/ E3 u$ w9 H
for(i=1;i<=N;i++)
9 d* m' O* B; z) _( _. }5 Q/ \ {
5 D3 M3 ]/ F5 w2 ] p=malloc(sizeof(PCB));2 r, i# i: b0 f$ d; W; o/ q
scanf("%s",na);
~ k: u; ~5 t* B scanf("%d",&time);) B8 o: c5 w+ t0 |
strcpy(p->name,na);. H7 T: f3 v1 z0 B6 d+ i
p->cputime=0;' |5 C" S8 z9 L: K! N8 k% Q
p->needtime=time;7 b3 N) L$ |4 z1 k4 i! }' i2 h
p->count=0; /*计数器*/9 G5 C7 }/ j: ~3 }# J
p->state='w';) a. M7 p f* g4 ?: }
p->round=2; /*时间片*/1 b+ Y- N4 s' i! M2 P
if(ready!=NULL)
# a& u W, ~" q6 _; o2 |1 A; \ insert2(p);
6 y9 O7 V4 l; R% X else
" T4 R5 Q; H: O, A0 G {+ a3 b3 [. c. t y/ X
p->next=ready;
3 Z( _7 Y+ j+ P! `. X1 d ready=p;
+ c- f& x0 ~9 }& {3 H7 x. @ tail=p;
6 t! \8 |) C H7 ?* j }
, N2 Z7 d d8 W9 H6 w }
+ x0 U" L% ]4 Z& w+ S. E clrscr();1 M- T4 y" g" z! ^; K; g2 H% E
printf(" output of round\n");* }+ u+ R0 O4 d
printf("************************************************\n");' V/ y3 {0 {: _/ c" S
prt(alg); /*输出进程PCB信息*/
; F" s7 G w. L run=ready; /*将就绪队列的第一个进程投入运行*/: s% l6 S2 d4 ]/ y6 E
ready=ready->next;
" N, W1 M% v+ g+ n2 S. O run->state='R';
; |/ y1 {, M8 m: ^5 a}
i$ D9 d! w% l2 q2 h/*优先数调度算法*/
5 b" ]; f: O5 s r5 Kpriority(char alg)
) J/ p+ R: S: `0 L{! z0 N. t+ ^% {! ~
while(run!=NULL) /*当运行队列不空时,有进程正在运行*/
* Y" a. V6 l4 \ {0 C S1 k9 R0 F6 W V. G! V9 Q
run->cputime=run->cputime+1;. [/ Z) G' ?0 n# q7 n9 S
run->needtime=run->needtime-1;3 f8 K8 b1 b; v+ J1 Z
run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/
* c" q, i' P# n9 Z/ q4 V) W, u1 W! I+ O0 ~ if(run->needtime==0) /*如所需时间为0将其插入完成队列*/7 I0 }7 T* w, r) u
{' F. U% H, d/ @4 A, }7 Q
run->next=finish;
0 P0 R* d; M! Q3 n' q; |7 D finish=run;$ j1 z8 e# \9 R7 i ^
run->state='F'; /*置状态为完成态*/
1 Z; P# t1 K# ` run=NULL; /*运行队列头指针为空*/+ \$ f0 b6 X: d2 |' F8 F
if(ready!=NULL) /*如就绪队列不空*/
5 \/ p$ g( b! A- W6 `4 I' u firstin(); /*将就绪对列的第一个进程投入运行*/2 [% K( E2 T7 _+ {$ O2 p6 \) j
}
- `/ I: l+ Y8 f& s- }$ r else /*没有运行完同时优先数不是最大,则将其变为就绪态插入到就绪队列*/
: g8 M1 }* `% F9 G$ L' [7 i% L1 o if((ready!=NULL)&&(run->prio<ready->prio))
3 A$ l3 }: O$ R {$ K4 z' k4 ^' w3 T, @* w
run->state='W';* N# \9 v; J" ^4 J: e
insert1(run);
( k! g4 j% k- z: e3 E firstin(); /*将就绪队列的第一个进程投入运行*/
0 o" J9 n) l. x X9 X9 G3 E( { }( D& B& G+ ?* e6 \
prt(alg); /*输出进程PCB信息*/
; N0 Q5 }/ E. j7 F. o" g& m }
* m, I$ h4 Z' d: O; [0 W8 _}" l( K3 \: P1 {: O
/*时间片轮转法*/
a& E! `- k: g. T; b& M+ Wroundrun(char alg)
+ {' N% I, F9 q* ?0 U5 F2 t2 d{
. p2 k7 Y# E" G, N0 v while(run!=NULL)$ \* i, D- |/ u7 D1 h
{
7 u" p3 h: S: Z; E3 o O9 K run->cputime=run->cputime+1;
8 X+ y# A4 d# y) c run->needtime=run->needtime-1;' o& ]2 ^1 M2 H: v/ t6 ~. M$ q
run->count=run->count+1;( @& A j0 K9 [: a! I+ Q; Q7 {
if(run->needtime==0)/*运行完将其变为完成态,插入完成队列*/
/ j/ D2 m* G, ?0 A/ Z {: W6 v$ U0 ]- x& k3 X0 n
run->next=finish;
8 O3 j. H6 q- z finish=run;; |1 M; O0 I" P1 y( O9 |8 v4 x
run->state='F';
0 m# h& b5 z; v* @- C) Y run=NULL;: X( a: u2 g8 T* C2 [
if(ready!=NULL)
" ?, x3 S7 k {; p* ] firstin(); /*就绪对列不空,将第一个进程投入运行*/
7 {% W7 D7 q5 R9 {! d }5 p: O- ]1 |' v1 b
else% l* W R5 Y6 v
if(run->count==run->round) /*如果时间片到*/) Y" l" p) F e, t5 F" k
{
5 I) P! Z9 \$ [& ]6 b/ J0 ?. q' i run->count=0; /*计数器置0*/, q) {( z$ C& o. Y7 z+ O/ ~
if(ready!=NULL) /*如就绪队列不空*/4 N3 M2 f# Y2 N f! e- Z+ A
{
5 H3 L. J7 Y' C4 U, _ run->state='W'; /*将进程插入到就绪队列中等待轮转*/
) B9 G1 I# {2 @2 g6 l+ | insert2(run);
! M0 |5 h9 O% [1 q7 y3 } firstin(); /*将就绪对列的第一个进程投入运行*/
; |' `3 ]( Z4 v$ T" i }
# S2 T) B( k" P. s }
& O+ n& P& ~- ~# n( r prt(alg); /*输出进程信息*/
8 `6 G7 v& X+ U0 l A }
: g: ^' p2 [3 [% b}; V" a5 U* m7 n, h
/*主函数*/
- q: [0 d. k+ G m; }8 Mmain()
# [9 e" A( n$ T{0 j9 w( ], N5 u( V3 D3 z
char algo; /*算法标记*/* L$ q% J8 P6 F6 ^/ y3 d
clrscr();8 ~( u9 R6 z. F2 X& \
printf("type the algorithm /R(priority/roundrobin)\n");0 ?9 |0 A) O: U- }5 k" {; Q
scanf("%c",&algo); /*输入字符确定算法*/
* f" E5 G6 U; l4 S printf("Enter process number\n");. K- k" ?; }8 l$ Z' \. h( }# j$ \
scanf("%d",&N); /*输入进程数*/
* t0 M0 J' k; z F; Q( q7 F4 j) d2 _ if(algo=='P'||algo=='p')
; F! p) e6 F/ h9 j {
3 U6 W s0 q- t8 u. T* }9 ] create1(algo); /*优先数法*/0 W6 y0 v. P0 A! c Q" ?/ N
priority(algo);
U$ ?/ V! D2 C( t }2 k/ O4 I: }1 v% K' k
else" i+ F; L" F1 l
if(algo=='R'||algo=='r')
$ ^* o; A& U0 L2 @# U8 g { {
$ W$ V0 c. M$ X' W$ Z( q create2(algo); /*轮转法*/5 ]0 G) S: r+ w2 r3 }- d
roundrun(algo);
7 t1 ^6 |0 L+ ?4 Z: n0 S, f9 Q }% W h# G/ e6 @" k" x3 R3 t
}, D2 I$ A( Q( B f
</pre> |
|