|
DataMuseum.dkPresents historical artifacts from the history of: RC4000/8000/9000 |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about RC4000/8000/9000 Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - download
Length: 54528 (0xd500)
Types: TextFile
Names: »simulator«
└─⟦667bb35d6⟧ Bits:30007480 RC8000 Dump tape fra HCØ.
└─⟦4334b4c0b⟧
└─⟦this⟧ »simulator«
begin
simulation class ktassystem;
comment
******************************************************
* *
* Simulator til et oplysningssystem ved KTAS. *
* *
****************************************************** ;
begin
process class center;
begin
end;
\f
center class inputproces;
comment
*****************************
* *
* I N P U T P R O C E S *
* *
***************************** ;
begin
comment
****************************************************
* *
* Simularer OP-systemets inputproces.Processen si- *
* mulerer CPU-tidsforbrug ved analysebehandling af *
* inddatalinier. Processen er implementerer ved en *
* løkke, der gennemløber køen af ventende fore- *
* spørgsler. Hver forespørgsel tildeles tidskvan- *
* ter jvf. kvanttildelingsstrategien. Til sidst *
* aktiveres processtyring, til bestemmelse af næs- *
* te procesbehandlingssted for forespørgslen. *
* *
**************************************************** ;
ref (job) aktualjob;real inputprocestid;
while true do
begin
while not koe(1).empty do
begin
aktualjob :- koe(1).first;
procaktiv(1):=true;
if test=1 then spor(aktualjob.jobnr,1,1);
inputprocestid:=inputtid;
aktualjob.ankinput:=time;
aktualjob.cpuinput:=inputprocestid;
while inputprocestid > 0 do
begin
if inputprocestid < resttidskvant then
begin
hold(inputprocestid);
inputsum(tid):=inputsum(tid)+inputprocestid;
inputsum(5):=inputsum(5)+inputprocestid;
timequantum(1):=timequantum(1)+inputprocestid;
resttidskvant:=resttidskvant-inputprocestid;
aktualjob.afginput:=time;
overgang(aktualjob,inputprocesnr);
if test= 1 then spor(aktualjob.jobnr,1,2);
inputprocestid:=0;
end else
begin
hold(resttidskvant);
inputsum(tid):=inputsum(tid)+resttidskvant;
inputsum(5):=inputsum(5)+resttidskvant;
inputprocestid:=inputprocestid-resttidskvant;
timequantum(1):=timequantum(1)+resttidskvant;
activate skift after current;
koeindsaet(1);
resttidskvant:=tidskvant;
passivate;
end;
end;
if koe(1).empty then
activate skift after current;
procaktiv(1):=false;
end;
passivate;
end;
end;
\f
center class soegeproces;
comment
****************************
* *
* S O E G E P R O C E S *
* *
**************************** ;
begin
comment
*****************************************************
* *
* Simulerer OP-systemets søgeproces. Processen simu-*
* lerer CPU-tidsforbrug ved afgrænsning af mulige *
* abonnenter ud fra givne kriterier. Processen er *
* implementeret efter samme princip som inputproces,*
* dog deles tidsforbruget op i et antal lige store *
* tidsafsnit. Hvert tidsafsnit simuleres efterfulgt *
* af en pladelagertilgang, idet diskkontrol aktive- *
* res. *
* *
***************************************************** ;
ref (job) soegejob;
real soegeprocestid,delsoegeprocestid,husktid;
integer pladelagertilgange;
integer i;
integer soegeprocnr;
soegeprocnr:=soegeprocesnr;
while true do
begin
while not koe(soegeprocnr).empty do
begin
soegejob:-koe(soegeprocnr).first;
procaktiv(soegeprocnr):=true;
if test=1 then spor(soegejob.jobnr,soegeprocnr,1);
soegeprocestid := negexp(1/soegetid,startvaerdi);
soegejob.anksoeg:=time;
soegejob.cpusoeg:=soegeprocestid;
pladelagertilgange:=
randint(mindst,stoerst,startvaerdi)+1;
delsoegeprocestid := soegeprocestid/pladelagertilgange;
husktid := delsoegeprocestid;
for i:=pladelagertilgange step -1 until 0 do
begin
while delsoegeprocestid > 0 do
begin
if delsoegeprocestid <= resttidskvant then
begin
if test = 1 then
begin
if soegeprocnr = 2 then
outtext(" 1 ") else
outtext(" 2 ");
outtext("soege proces aktiv til tid ");
outfix(time,4,12);
outimage;
end;
hold(delsoegeprocestid);
soegesum(tid):=soegesum(tid)+delsoegeprocestid;
soegesum(5):=soegesum(5)+delsoegeprocestid;
timequantum(soegeprocnr):=timequantum(soegeprocnr)+
delsoegeprocestid;
resttidskvant:=resttidskvant-delsoegeprocestid;
delsoegeprocestid:=0;
if i> 1 then
activate skift after current;
end else
begin
if test = 1 then
begin
if soegeprocnr = 2 then
outtext(" 1 ") else
outtext(" 2 ");
outtext("proces soege aktiv til tid ");
outfix(time,4,12);
outimage;
end;
hold(resttidskvant);
soegesum(tid):=soegesum(tid)+resttidskvant;
soegesum(5):=soegesum(5)+resttidskvant;
timequantum(soegeprocnr):=
timequantum(soegeprocnr)+resttidskvant;
delsoegeprocestid := delsoegeprocestid -
resttidskvant;
activate skift after current;
koeindsaet(soegeprocnr);
resttidskvant:=tidskvant;
passivate;
end;
end;
if i>1 then
begin
disknr:=soegeprocnr;
diskkonnr:=1;
activate kontrol(1) after current;
pladelagertilgange := pladelagertilgange - 1;
delsoegeprocestid := husktid;
passivate;
end;
end;
soegejob.afgsoeg:=time;
overgang(soegejob,soegeprocnr);
if test=1 then spor(soegejob.jobnr,soegeprocnr,2);
if koe(soegeprocnr).empty then
activate skift after current;
procaktiv(soegeprocnr):=false;
end;
passivate;
end;
end;
\f
center class opslagproces;
comment
*******************************
* *
* O P S L A G S P R O C E S *
* *
******************************* ;
begin
comment
******************************************************
* *
* Simulerer OP-systemets opslagsproces.Processen si- *
* mulerer CPU-tidsforbruget ved egentlig opslag efter*
* abonnenter. Processen er implementeret efter samme *
* princip som søgeprocessen. *
* *
****************************************************** ;
ref (job) opslagjob;
real opslagprocestid,delopslagprocestid,husktid;
integer pladelagertilgange;
integer i;
while true do
begin
while not koe(3).empty do
begin
opslagjob :- koe(3).first;
procaktiv(3):=true;
if test = 1 then spor(opslagjob.jobnr,3,1);
opslagprocestid := negexp(1/opslagtid,startvaerdi);
opslagjob.ankopslag:=time;
opslagjob.cpuopslag:=opslagprocestid;
pladelagertilgange:=
randint(faerrest,flest,startvaerdi)+1;
delopslagprocestid := opslagprocestid/pladelagertilgange;
husktid := delopslagprocestid;
for i:=pladelagertilgange step -1 until 0 do
begin
while delopslagprocestid > 0 do
begin
if delopslagprocestid <= resttidskvant then
begin
hold(delopslagprocestid);
opslagssum(tid):=opslagssum(tid)+delopslagprocestid;
opslagssum(5):=opslagssum(5)+delopslagprocestid;
timequantum(3):=timequantum(3)+delopslagprocestid;
resttidskvant:=resttidskvant-delopslagprocestid;
delopslagprocestid := 0;
if i > 1 then
activate skift after current;
end else
begin
hold(resttidskvant);
opslagssum(tid):=opslagssum(tid)+resttidskvant;
opslagssum(5):=opslagssum(5)+resttidskvant;
timequantum(3):=
timequantum(3)+resttidskvant;
delopslagprocestid := delopslagprocestid - resttidskvant;
activate skift after current;
koeindsaet(3);
resttidskvant:=tidskvant;
passivate;
end;
end;
if i>1 then
begin
disknr:=opslagprocesnr;
diskkonnr:=1;
if kondublering then
begin
diskkonnr:=2;
activate kontrol(2) after current
end
else
activate kontrol(1) after current;
pladelagertilgange := pladelagertilgange - 1;
delopslagprocestid := husktid;
passivate;
end;
end;
opslagjob.afgopslag:=time;
overgang(opslagjob,opslagprocesnr);
if test = 1 then spor(opslagjob.jobnr,3,2);
if koe(3).empty then
activate skift after current;
procaktiv(3):=false;
end;
passivate;
end;
end;
\f
center class outputproces;
comment
*****************************
* *
* O U T P U T P R O C E S *
* *
***************************** ;
begin
comment
*******************************************************
* *
* Simulerer OP-systemet outputproces. Processen simu- *
* lerer CPU-tidsforbruget ved rediringsaktioner på in-*
* formation modtaget fra de øvrige processer. Proces- *
* sen er implementeret som inputproces, dog kan der *
* ske pladelagertilgang efter CPU-tidsforbruget. *
* *
******************************************************* ;
ref (job) udjob;
real outputprocestid,pladetilg;
while true do
begin
while not koe(4).empty do
begin
udjob :- koe(4).first;
procaktiv(4):=true;
if test = 1 then spor(udjob.jobnr,4,1);
outputprocestid:=outputtid;
udjob.ankoutput:=time;
udjob.cpuoutput:=outputprocestid;
while outputprocestid > 0 do
begin
if outputprocestid < resttidskvant then
begin
hold(outputprocestid);
outputsum(tid):=outputsum(tid)+outputprocestid;
outputsum(5):=outputsum(5)+outputprocestid;
timequantum(4):=timequantum(4)-
outputprocestid;
resttidskvant:=resttidskvant-outputprocestid;
pladetilg:=uniform(0,1,startvaerdi);
if pladetilg <= pladesands then
begin
disknr:=outputprocesnr;
diskkonnr:=1;
if kondublering then
begin
diskkonnr:=2;
activate kontrol(2) after current
end
else
activate kontrol(1) after current;
passivate;
end;
udjob.afgoutput:=time;
overgang(udjob,outputprocesnr);
if test = 1 then spor(udjob.jobnr,4,2);
outputprocestid := 0;
activate proc(5);
statkald:=5;
activate proc(5);
end else
begin
hold(resttidskvant);
outputsum(tid):=outputsum(tid)+resttidskvant;
outputsum(5):=outputsum(5)+resttidskvant;
outputprocestid:=outputprocestid-resttidskvant;
timequantum(4):=
timequantum(4)+resttidskvant;
activate skift after current;
koeindsaet(4);
resttidskvant:=tidskvant;
passivate;
end;
end;
if koe(4).empty then
activate skift after current;
procaktiv(4):=false;
end;
passivate;
end;
end;
\f
process class jobgenerator;
comment
*****************************
* *
* J O B G E N E R A T O R *
* *
***************************** ;
begin
comment
******************************************************
* *
* Simulerer ankomst af forespørgsler til OP-systemet.*
* Ankomsthyppigheden er beskrevet v.h.a. en tilfæl- *
* dighedsfordeling. *
* *
****************************************************** ;
ref (job) jobgen;
integer antaljob,tid;
while true do
begin
antaljob := antaljob + 1;
tid:=entier(time/3600000);
hold(negexp(ankomstrate(tid),startvaerdi));
jobgen :- new job;
jobgen.jobnr := antaljob;
if test = 1 then spor(jobgen.jobnr,7,1);
jobgen.jobtid := time;
koelengde(1);
jobgen.into(koe(1));
if not koe(1).cardinal > 1 then
koeindsaet(1);
if proc(1).idle and proc(2).idle
and proc(3).idle and proc(4).idle
and proc(6).idle then
activate skift;
end;
end;
\f
process class diskkontrol;
comment
**************************
* *
* D I S K K O N T R O L *
* *
************************** ;
begin
comment
*******************************************************
* *
* Simulerer styring af kommunikation mellem processer *
* og pladelagre. Processen behandler 3 hovedtilfælde: *
* a) Enproces ønsker brug af pladelager. *
* b) Et pladelager har foretaget positionering af ho-*
* vedet og ønsker tilladelse til overføring af *
* data. *
* c) En pladelageroverførsel er tilendebragt. *
* *
******************************************************* ;
ref (soegeproces) check;
ref(disk) kig;
boolean kanalaktiv,soegecheck,speccheck;
real kanalstart;
integer konnr;
while true do
begin
konnr:=diskkonnr;
if test = 1 then
begin
outint(disknr,3);
outtext("diskkontrol aktiv");
outfix(time,4,12);
outimage;
end;
if (not kontrolkald(konnr)) and
(not paratkald(konnr)) then
begin
if disknr = 2 then
proc(2).into(soegediskkoe);
if disknr = 6 then
begin
disknr:=2;
proc(6).into(soegediskkoe);
end;
if not kontrolkoe(konnr).empty then
begin
if disknr = 3 then
proc(3).into(opslagsdiskkoe);
if disknr = 4 then
proc(4).into(outputdiskkoe);
end else
if not (disknr = 2 and soegediskkoe.cardinal = 2)
then activate pladelager(disknr) after current;
end
else
begin
if kontrolkald(konnr) then
begin
if kontrolkoe(konnr).cardinal = 1 then
activate kontrolkoe(konnr).first after current;
kontrolkald(konnr):= false;
if not kanalaktiv then
begin
kanalstart:=time;
kanalaktiv:=true;
end;
end
else
begin
if paratkald(1) and
not soegediskkoe.empty
and disknr=2 then
begin
check:-soegediskkoe.first;
check.out;
if dublering and not soegediskkoe.empty then
begin
speccheck:=true;
if pladelager(disknr).idle then
activate pladelager(disknr) after current;
end;
if check.soegeprocnr = 6 then
soegecheck:=true;
end;
paratkald(konnr):=false;
if soegecheck then
begin
soegecheck:=false;
koeindsaet(6);
end else
koeindsaet(disknr);
if not soegediskkoe.empty and not speccheck
and pladelager(2).idle then
begin
speccheck:=true;
activate pladelager(2) after current ;
end else
speccheck:=false;
if not opslagsdiskkoe.empty then
begin
disknr:=3;
activate pladelager(3) after current;
opslagsdiskkoe.first.out;
end;
if not outputdiskkoe.empty then
begin
disknr:=4;
activate pladelager(4)after current;
outputdiskkoe.first.out;
end;
kig :- kontrolkoe(konnr).first;
if (not kontrolkoe(konnr).empty
and not speccheck) or
(not kontrolkoe(konnr).empty and kig.kontrolnr <> 2) then
activate kontrolkoe(konnr).first after current
else speccheck:=false;
if dublering and kontrolkoe(konnr).empty then
begin
if konnr = 1 then
begin
kanalaktiv := false;
kanalsum(1,tid):=kanalsum(1,tid)+(time-kanalstart);
kanalsum(1,5):=kanalsum(1,5)+(time-kanalstart);
end
else
begin
kanalaktiv:=false;
kanalsum(2,tid):=kanalsum(2,tid)+(time-kanalstart);
kanalsum(2,5):=kanalsum(2,5)+(time-kanalstart);
end;
end
else
begin
if not dublering and kontrolkoe(konnr).empty then
begin
kanalaktiv:=false;
kanalsum(konnr,tid):=kanalsum(konnr,tid)+(time-kanalstart);
kanalsum(konnr,5):=kanalsum(konnr,5)+(time-kanalstart);
end;
end;
end;
end;
passivate;
end;
end;
\f
process class disk;
comment
************
* *
* D I S K *
* *
************ ;
begin
comment
********************************************************
* *
* Simulerer tidsforbruget ved pladelagertilgang. Opdelt*
* i hhv. tidsforbruget ved positionering af hovedet og *
* tidsforbruget ved overførsel af data. *
* *
******************************************************** ;
integer kontrolnr;
kontrolnr:=disknr;
while true do
begin
if test = 1 then
begin
outint(kontrolnr,2);
outtext("disk starter");
outfix(time,4,12);
outimage;
end;
disktilgange(kontrolnr):=disktilgange(kontrolnr)+1;
disktid:=negexp(1/pladelagertid(kontrolnr),startvaerdi);
hold(disktid);
disksum(kontrolnr,tid):=disksum(kontrolnr,tid)+disktid;
disksum(kontrolnr,5):=disksum(kontrolnr,5)+disktid;
if kondublering then
begin
if kontrolnr = 2 then diskkonnr:=1
else diskkonnr:=2;
end else diskkonnr:=1;
kanalkoe(diskkonnr);
into(kontrolkoe(diskkonnr));
kontrolkald(diskkonnr):=true;
activate kontrol(diskkonnr) after current;
disknr:=kontrolnr;
passivate;
hold(overfoerselstid);
disksum(kontrolnr,tid):=
disksum(kontrolnr,tid)+overfoerselstid;
disksum(kontrolnr,5):=
disksum(kontrolnr,5)+overfoerselstid;
if kondublering and kontrolnr <> 2 then
kanalkoe(2) else kanalkoe(1);
out;
disknr:=kontrolnr;
if kondublering then
begin
if kontrolnr = 2 then diskkonnr:=1
else diskkonnr:=2;
end else diskkonnr:=1;
paratkald(diskkonnr):=true;
activate kontrol(diskkonnr) ;
if test = 1 then
begin
outint(kontrolnr,2);
outtext("disk faerdig");
outfix(time,4,12);
outimage;
end;
if proc(1).idle and proc(2).idle and
proc(3).idle and proc(4).idle
and proc(6).idle then
activate skift after current;
if not kontrolnr=2
or ( kontrolnr = 2 and
soegediskkoe.empty) then
passivate;
end;
end;
\f
process class processtyring;
comment
******************************
* *
* P R O C E S S T Y R I N G *
* *
****************************** ;
begin
comment
********************************************************
* *
* Simulerer aktivering af første proces i ventekø af *
* aktive processer. Desuden simuleres tidsforbruget ved*
* skift mellem processer. *
* *
******************************************************** ;
ref (koeobjekt) aktivnu;
integer n;
while true do
begin
while not aktivkoe.empty do
begin
aktivnu:-aktivkoe.first;
n:=aktivnu.aktivnr;
aktivnu.out;
if n = 6 then soegeprocesnr:=6
else soegeprocesnr:=2;
activate proc(n) delay skiftetid;
antalprocskift:=antalprocskift+1;
if resttidskvant > skiftetid then
resttidskvant:=resttidskvant-skiftetid
else
resttidskvant:=
(tidskvant+resttidskvant)-skiftetid;
if test = 1 then
begin
outtext("processtyring aktiv ");
outfix(time,4,12);
outimage;
end;
processum(tid):=processum(tid)+skiftetid;
processum(5):=processum(5)+skiftetid;
passivate;
end;
if test = 1 and time>7800 and time <8000 then
begin
outtext("process styring passiv");
outfix(time,4,12);
outimage;
end;
passivate;
end;
end;
\f
process class koeobjekt;
comment
*********************
* *
* K O E O B J E K T *
* *
********************* ;
begin
comment
****************************************************
* *
* Simulerer repræsentation af processer i ventekø *
* af aktive processer. *
* *
**************************************************** ;
integer aktivnr,prioritet;
end;
\f
procedure koeindsaet(nummer);integer nummer;
comment
***********************
* *
* K O E I N D S A E T *
* *
*********************** ;
begin
comment
*****************************************************
* *
* Simulerer indsættelse af processer på rigtige sted*
* i aktivkøen. Indplaceringen sker jvf. indsættel- *
* sesstrategien. *
* *
***************************************************** ;
ref(koeobjekt) hjelp,hjelp1;
integer n;
n:=nummer;
hjelp:-aktivkoe.first;
while hjelp =/= none and hjelp.prioritet >
objekt(n).prioritet do hjelp:-hjelp.suc;
if timequantum(n) >= tidskvant then
begin
if hjelp == none then objekt(n).into(aktivkoe)
else
begin
if hjelp.prioritet < objekt(n).prioritet then
objekt(n).precede(hjelp)
else
begin
hjelp1:-hjelp.suc;
while hjelp.suc =/= none and hjelp1.prioritet =
objekt(n).prioritet do
begin
hjelp:-hjelp.suc;
hjelp1:-hjelp.suc;
end;
end;
objekt(n).follow(hjelp);
end;
timequantum(n):=0;
if test = 1 and time >7800 and time< 8000 then
begin
outtext("nummer 1 til tid ");
outfix(time,4,12);
outtext("aktivkoelengde ");
outint(aktivkoe.cardinal,4);
outimage;
end;
end else
begin
if aktivkoe.empty then
begin
objekt(n).into(aktivkoe);
if test = 1 and time>7800 and time<8000 then
begin
outtext("nummer 2 til tid ");
outfix(time,4,12);
outtext("aktivkoelangde ");
outint(aktivkoe.cardinal,4);
outimage;
end;
end
else
begin
if hjelp == none then objekt(n).into(aktivkoe)
else
objekt(n).precede(hjelp);
if test = 1 and time >7800 and time<8000 then
begin
outtext("nummer 3 til tid ");
outfix(time,4,12);
outtext("aktivkoelengde ");
outint(aktivkoe.cardinal,4);
outimage;
end;
end;
end;
end;
\f
procedure koelengde(i);
integer i;
begin
comment
*************************
* *
* K O E L E N G D E *
* *
*************************;
comment
******************************************************
* *
* Beregner kontinuerligt længden af køen ved hver af *
* de 4 processer (input,søge,opslags og output) *
* *
****************************************************** ;
real korrtid;
antalikoe(i,tid):=koe(i).cardinal;
gnstikoe(i,5):=
((sidstmaalt(i)/time)*gnstikoe(i,5))
+(((time-sidstmaalt(i))/time)*antalikoe(i,tid));
sidstmaalt(i):=time;
korrtid:=(time-(simtid*(tid-1)));
if tid <> 5 then
gnstikoe(i,tid):=
((sidstobs(i)/korrtid)*gnstikoe(i,tid))+
(((korrtid-sidstobs(i))/korrtid)*antalikoe(i,tid));
sidstobs(i):=korrtid;
end;
\f
procedure kanalkoe(i);
integer i;
begin
comment
*************************
* *
* K A N A L K O E *
* *
************************* ;
comment
******************************************************
* *
* Beregner kontinuerligt længden af køen ved dataka- *
* nalen (diskkontrol). *
* *
****************************************************** ;
integer kanalkorr;
kanalantal(i,tid):=kontrolkoe(i).cardinal;
kanalgnst(i,5):=
((kanalsidst(i)/time)*kanalgnst(i,5))+
(((time-kanalsidst(i))/time)*kanalantal(i,tid));
kanalsidst(i):=time;
kanalkorr:=(time-(simtid*(tid-1)));
if tid <> 5 then
kanalgnst(i,tid):=
((kanalobs(i)/kanalkorr)*kanalgnst(i,tid))+
(((kanalkorr-kanalobs(i))/kanalkorr)*
kanalantal(i,tid));
kanalobs(i):=kanalkorr;
end;
\f
procedure overgang(jobreference,procesnr);
ref (job) jobreference;integer procesnr;
begin
ref (job) udtag;
boolean snyd;
comment
*********************
* *
* O V E R G A N G *
* *
********************* ;
comment
****************************************************
* *
* Bestemmer næste proces for en forespørgsel, givet*
* den netop er færdig med en bestemt proces. Fast- *
* læggelse sker v.h.a. en indlæst overgangsmatrice.*
* Behandler yderligere implementering af en duble- *
* ring af søgeprocessen. *
* *
**************************************************** ;
integer procnr;
real udtrukket;
if test = 1 then
begin
outtext("overgang kaldt");
outfix(time,4,12);
outimage;
end;
udtrukket := uniform(0,1,startvaerdi);
if procesnr = 6 then
begin
snyd:=true;
procesnr:=2;
end;
procnr:=1;
while procnr <= 5 and udtrukket >
overgangsmatrix(procesnr,procnr) do
procnr := procnr + 1;
if snyd then
begin
procesnr:=6;
snyd:=false;
end;
koelengde(procesnr);
if dublering and procnr = 2
and koe(6).empty and not koe(2).empty then
procnr:=6;koelengde(procnr);
if test= 2 and procesnr = 3 then
begin
outtext("koened til ");
outint(koe(3).cardinal,3);
outtext("jobnr - ");
outint(jobreference.jobnr,3);
outtext("time = ");
outfix(time,4,12);
outimage;
end;
if test = 2 and procnr = 3 then
begin
outtext("koeop til ");
outint(koe(3).cardinal,3);
outtext("jobnr =");
outint(jobreference.jobnr,4);
outtext("tid = ");
outfix(time,4,12);
outimage;
end;
jobreference.into(koe(procnr));
if (procnr<5 or procnr = 6) and
not procaktiv(procnr)
and not koe(procnr).cardinal > 1 then
koeindsaet(procnr);
if dublering and procesnr = 6 and
koe(6).empty and koe(2).cardinal > 1 then
begin
udtag:-koe(2).first.suc;
koelengde(2);
udtag.into(koe(6));
end;
end;
\f
process class job;
comment
**********
* *
* J O B *
* *
********** ;
begin
comment
****************************************************
* *
* Simulerer forekomsten af en forespørgsel i OP- *
* systemet. *
* *
**************************************************** ;
integer jobnr;
real jobtid,ankinput,afginput,cpuinput,
anksoeg,afgsoeg,cpusoeg,
ankopslag,afgopslag,cpuopslag,
ankoutput,afgoutput,cpuoutput;
end;
\f
center class statistik;
comment
**********************
* *
* S T A T I S T I K *
* *
********************** ;
begin
comment
****************************************************
* *
* Beregningsprocedure af tidsforbruget ved de 4 *
* processer, opdelt i CPU-tid, køtid og samlet tid.*
* *
**************************************************** ;
ref (job) jobref;
real hjelptid;
integer pointer;
real koetid,procestid;
integer t;
while true do
begin
if statkald = 5 then
begin
t:=5;
statkald:=0;
end else t:=tid;
jobref:-koe(5).first;
if test = 1 and t = 5 then
spor(jobref.jobnr,5,1);
antalforsp(1,t):=antalforsp(1,t)+1;
procestid:=jobref.afginput-jobref.ankinput;
koetid:=jobref.ankinput-jobref.jobtid;
snitforsp(1,1,t):=snitforsp(1,1,t)+procestid;
varforsp(1,1,t):=varforsp(1,1,t)+procestid*procestid;
snitforsp(1,2,t):=snitforsp(1,2,t)+jobref.cpuinput;
varforsp(1,2,t):=
varforsp(1,2,t)+jobref.cpuinput*jobref.cpuinput;
snitforsp(1,3,t):=
snitforsp(1,3,t)+koetid;
varforsp(1,3,t):=
varforsp(1,3,t)+koetid*koetid;
if jobref.cpusoeg > 0 then
begin
antalforsp(2,t):=antalforsp(2,t)+1;
procestid:=jobref.afgsoeg-jobref.anksoeg;
koetid:=jobref.anksoeg-jobref.afginput;
snitforsp(2,1,t):=
snitforsp(2,1,t)+procestid;
varforsp(2,1,t):=
varforsp(2,1,t)+procestid*procestid;
snitforsp(2,2,t):=
snitforsp(2,2,t)+jobref.cpusoeg;
varforsp(2,2,t):=
varforsp(2,2,t)+jobref.cpusoeg*jobref.cpusoeg;
snitforsp(2,3,t):=
snitforsp(2,3,t)+koetid;
varforsp(2,3,t):=
varforsp(2,3,t)+koetid*koetid;
end;
if jobref.cpuopslag > 0 then
begin
procestid:=jobref.afgopslag-jobref.ankopslag;
if jobref.cpusoeg > 0 then
koetid:=jobref.ankopslag-jobref.afgsoeg
else
koetid:=jobref.ankopslag-jobref.afginput;
antalforsp(3,t):=antalforsp(3,t)+1;
snitforsp(3,1,t):=
snitforsp(3,1,t)+procestid;
varforsp(3,1,t):=
varforsp(3,1,t)+procestid*procestid;
snitforsp(3,2,t):=
snitforsp(3,2,t)+jobref.cpuopslag;
varforsp(3,2,t):=
varforsp(3,2,t)+jobref.cpuopslag*jobref.cpuopslag;
snitforsp(3,3,t):=
snitforsp(3,3,t)+koetid;
varforsp(3,3,t):=
varforsp(3,3,t)+koetid*koetid;
end;
if jobref.cpuoutput > 0 then
begin
procestid:=jobref.afgoutput-jobref.ankoutput;
if jobref.cpuopslag > 0 then
koetid:=jobref.ankoutput-jobref.afgopslag
else
begin
if jobref.cpusoeg > 0 then
koetid:=jobref.ankoutput-jobref.afgsoeg
else
koetid:=jobref.ankoutput-jobref.afginput;
antalfejl(t):=antalfejl(t)+1;
end;
antalforsp(4,t):=antalforsp(4,t)+1;
snitforsp(4,1,t):=
snitforsp(4,1,t)+procestid;
varforsp(4,1,t):=
varforsp(4,1,t)+procestid*procestid;
snitforsp(4,2,t):=
snitforsp(4,2,t)+jobref.cpuoutput;
varforsp(4,2,t):=
varforsp(4,2,t)+jobref.cpuoutput*jobref.cpuoutput;
snitforsp(4,3,t):=
snitforsp(4,3,t)+koetid;
varforsp(4,3,t):=
varforsp(4,3,t)+koetid*koetid;
totaltid(t):=totaltid(t)+
(jobref.afgoutput-jobref.ankinput);
end;
samlettid(t):=samlettid(t)+
(jobref.afgoutput-jobref.jobtid);
if t=5 then
begin
hjelptid:=jobref.afgoutput-jobref.jobtid;
pointer:= entier(hjelptid);
pointer:= pointer // 250;
if pointer > 32 then
svarfordel(32):=svarfordel(32)+1
else
svarfordel(pointer):=svarfordel(pointer)+1;
if minsvartid > hjelptid then
minsvartid:=hjelptid;
if maxsvartid < hjelptid then
maxsvartid:=hjelptid;
jobref.out;
end;
passivate;
end;
end;
\f
procedure skrivresultat(tid);
integer tid;
comment
******************************
* *
* S K R I V R E S U L T A T *
* *
****************************** ;
begin
comment
****************************************************
* *
* Udskrivningsprocedure af tællevariable, beregnede*
* og afledte målevariable. *
* *
**************************************************** ;
real procesudnyt,totaludnyt;
real procent,accprocent;
real procedure beregnsnit(l);integer l;
if antalforsp(i,tid)>0 then
beregnsnit:=snitforsp(i,l,tid)/antalforsp(i,tid);
real procedure beregnvar(l);integer l;
if antalforsp(i,tid)>0 then
beregnvar:=varforsp(i,l,tid)/antalforsp(i,tid)-
snit*snit;
real snit;
outimage;eject(1);
for i:= 1 step 1 until 62 do outchar('*');
outimage;outchar('*');
for i:= 1 step 1 until 60 do outchar(' ');
outchar('*');
outimage;outchar('*');
outtext(" R E S U L T A T E R F R A S I M U ");
outtext("L A T O R E N *");
outimage;outchar('*');
for i:= 1 step 1 until 60 do outchar(' ');
outchar('*');outimage;
for i:= 1 step 1 until 62 do outchar('*');
outimage;
if tid = 5 then
outtext("Samlede resultater: ") else
begin
outtext("resultater for ");
outint(tid,5);
outtext(". kvarter");
end;
outimage;
for i:= 1 step 1 until 4 do
begin
outimage;outimage;
outimage;outimage;
if i = 1 then
outtext(" INPUT PROCES ");
if i = 2 then
outtext(" SOEGE PROCES ");
if i = 3 then
outtext(" OPSLAGS PROCES ");
if i = 4 then
outtext (" OUTPUT PROCES ");
outimage;
outtext(" ------------------");
outimage;
outimage;
outtext(" antal forespoergsel = ");
outint(antalforsp(i,tid),10);
outimage;
outtext(" gennemsnitlig procestid = ");
snit:=beregnsnit(1);
outfix(snit,2,8);
outimage;
outtext(" varianse på procestid = ");
outfix(beregnvar(1),2,12);
outimage;
outtext(" genenmsnitlig cputid = ");
snit:=beregnsnit(2);
outfix(snit,2,8);
outimage;
outtext(" varianse på cputid = ");
outfix(beregnvar(2),2,12);
outimage;
outtext(" gennemsnitlig koetid = ");
snit:=beregnsnit(3);
outfix(snit,2,8);
outimage;
outtext(" varianse på koetid = ");
outfix(beregnvar(3),2,12);
outimage;
end;
outimage;outimage;
outtext(" totaltid i systemet = ");
outfix(totaltid(tid),2,12);
outimage;outimage;
outtext("Gennemsnitlig svartid med inputproces =");
outfix(samlettid(tid)/antalforsp(1,tid),2,12);
outimage;
outtext("Gennemsnit svartid =");
outfix(totaltid(tid)/antalforsp(1,tid),2,12);
outimage;outimage;
outtext(" antal fejl = ");
outint(antalfejl(tid),8);
outimage;outimage;
outtext("Udnyttelsesgrad af inputproces=");
procesudnyt:=(inputsum(tid)/simtid)*100;
outfix(procesudnyt,2,7);
totaludnyt:=procesudnyt;
outimage;
outtext("Udnyttelsesgrad af soegeproces =");
procesudnyt:= (soegesum(tid)/simtid)*100;
outfix(procesudnyt,2,7);
totaludnyt:=totaludnyt+procesudnyt;
outimage;
outtext("Udnyttelsesgrad af opslagsproces =");
procesudnyt:= (opslagssum(tid)/simtid)*100;
outfix(procesudnyt,2,7);
totaludnyt:=totaludnyt+procesudnyt;
outimage;
outtext("Udnyttelsesgrad af outputproces =");
procesudnyt:= (outputsum(tid)/simtid)*100;
outfix(procesudnyt,2,7);
totaludnyt:=totaludnyt+procesudnyt;
outimage;
outtext("Udnyttelsesgrad af disk 1 =");
procesudnyt:=(disksum(1,tid)/simtid)*100;
outfix(procesudnyt,2,7);
outimage;
outtext("Udnyttelsesgrad af disk 2 =");
procesudnyt:=(disksum(2,tid)/simtid)*100;
outfix(procesudnyt,2,7);
outimage;
outtext("Udnyttelsesgrad af disk 3 =");
procesudnyt:=(disksum(3,tid)/simtid)*100;
outfix(procesudnyt,2,7);
outimage;
outtext("Udnyttelsesgrad af disk 4 =");
procesudnyt:=(disksum(4,tid)/simtid)*100;
outfix(procesudnyt,2,7);
outimage;
if not kondublering then
begin
outtext("udnyttelsesgrad af diskkanal =");
procesudnyt:=(kanalsum(1,tid)/simtid)*100;
outfix(procesudnyt,2,7);
outimage;
end
else
begin
outtext("udnyttelsesgrad af diskkanal 1 =");
procesudnyt:=(kanalsum(1,tid)/simtid)*100;
outfix(procesudnyt,2,7);
outimage;
outtext("udnyttelsesgrad af diskkanal 2 =");
procesudnyt:=(kanalsum(2,tid)/simtid)*100;
outfix(procesudnyt,2,7);
outimage;
end;
outtext("Belastning ved processkift =");
procesudnyt:=(processum(tid)/simtid)*100;
totaludnyt:=totaludnyt+procesudnyt;
outfix(procesudnyt,2,7);
outimage;
outtext(" total udnyttelse af cpu = ");
outfix(totaludnyt,2,7);
outimage;
outimage;
outtext("Gennemsnit koeleengde for inputproces =");
koelengde(1);
outfix(gnstikoe(1,tid),3,5);
outimage;
if dublering then
begin
outtext("Gennemsnitlig koelengede for soegeproces 1 =");
koelengde(2);
outfix(gnstikoe(2,tid),3,5);
outimage;
outtext("Gennemsnitlig koelengde for soegeproces 2 =");
koelengde(6);
outfix(gnstikoe(6,tid),3,5);
outimage;
end
else
begin
outtext("Gennemsnitlig koelengde for soegeproces =");
koelengde(2);
outfix(gnstikoe(2,tid),3,5);
outimage;
end;
outtext("Gennemsnitlig koelengde for opslagsproces =");
koelengde(3);
outfix(gnstikoe(3,tid),3,5);
outimage;
outtext("Gennemsnitlig koelengde for outputproces=");
outfix(gnstikoe(4,tid),3,5);
koelengde(4);
outimage;
if kondublering then
begin
outtext("Gennemsnitlig koelengde for diskkanal 1=");
kanalkoe(1);
outfix(kanalgnst(1,tid),3,5);
outimage;
outtext("Gennemsnitlig koelengde for diskkanal 2=");
outfix(kanalgnst(2,tid),3,5);
kanalkoe(2);
outimage;
end
else
begin
outtext("Gennemsnitlig koelengde for diskkanal =");
kanalkoe(1);
outfix(kanalgnst(1,tid),3,5);
outimage;
end;
if tid = 5 then
begin
outimage;
outtext("minimal svartid = ");
outfix(minsvartid,2,10);
outimage;
outtext("maksimalsvartid = ");
outfix(maxsvartid,2,10);
outimage;
outtext("antal processkift =");
outint(antalprocskift,10);
outimage;
for i:= 1 step 1 until 4 do
begin
outtext(" antal pladelagertilgange ved disc");
outint(i,3);outtext(" er =");
outint(disktilgange(i),10);
outimage;
end;
outimage;eject(1);
outtext("svartidsfordeling:");
outimage;
outtext("------------------");outimage;
outimage;
outtext("svartid i ms ");
outtext(" antalforsp. ");
outtext(" procent af alle ");
outtext(" acc.procent ");
outimage;
for i:=1 step 1 until 60 do outchar('-');
outimage;outimage;
for i:=0 step 1 until 32 do
begin
outint(i*250,5);outtext(" - ");
outint((((i+1)*250)-1),5);
outtext(" ");
outint(svarfordel(i),5);
procent:= (svarfordel(i)/antalforsp(1,5))*100;
accprocent:=accprocent+procent;
outtext(" ");
outfix(procent,2,7);
outtext(" ");
outfix(accprocent,2,7);
outimage;
end;
end;
end;
\f
procedure skrivinput;
comment
************************
* *
* S K R I V I N P U T *
* *
************************ ;
begin
eject(1);
outimage;
for i:=1 step 1 until 62 do outchar('*');
outimage;outchar('*');
for i:=1 step 1 until 60 do outchar(' ');
outchar('*');outimage;outchar('*');
outtext(" I N P U T");
outtext(" ");
outtext(" *");
outimage;outchar('*');
for i:= 1 step 1 until 60 do outchar(' ');
outchar('*');outimage;
for i:= 1 step 1 until 62 do outchar('*');
outimage;outimage;outimage;
outtext("antaljobs pr ms = ");
outfix(ankomstrate(0),6,8);
outimage;
outimage;outimage;
for i:=1 step 1 until 4 do
begin
outtext("pladetid");outchar('(');outint(i,2);
outtext(") = ");outfix(pladelagertid(i),2,7);
outimage;
end;
outtext("Overfoerselstid =");
outfix(overfoerselstid,2,7);
outimage;
outimage;outimage;
outtext("Minimale antal diskaccesser i soegeproces =");
outint(mindst,5);
outimage;
outtext("Maksimale antal diskaccesser i soegeproces =");
outint(stoerst,5);
outimage;
outtext("Minimale antal diskaccesser i opslagsproces =");
outint(faerrest,5);
outimage;
outtext("Maksimale antal diskaccesser i opslagsproces =");
outint(flest,5);
outimage;
outtext("Pladelager tilgangssandsynlighed i outputproces =");
outfix(pladesands,2,5);
outimage;
outtext("GENNEMSNITLIG CPU-TID FOR : ");
outimage;
outtext("input proces = ");outfix(inputtid,2,8);
outimage;
outtext("soege proces = ");outfix(soegetid,2,8);
outimage;
outtext("opslags proces = ");outfix(opslagtid,2,8);
outimage;
outtext("output proces = ");outfix(outputtid,2,8);
outimage;outimage;
outtext("SKIFTETID = ");
outfix(skiftetid,2,8);
outimage;
outtext("TIDSKVANT = ");outfix(tidskvant,2,8);
outimage;
outtext("startvaerdi til tilfaeldighedstals generator =");
outint(startvaerdi,3);
outimage;
outtext("simperiode =");outint(simperiode,10);
outimage;outtext("inputproces's prioritet =");
outint(objekt(1).prioritet,4);
outimage;outtext("soegeproces's prioritet=");
outint(objekt(2).prioritet,4);
outimage;outtext("opslagsproces's prioritet=");
outint(objekt(3).prioritet,4);
outimage;outtext("outputproces's prioritet=");
outint(objekt(4).prioritet,4);
outimage;
outimage;eject(1);
outimage;
outtext(" OVERGANGS SANDSYNLIGHEDS MATRIX ");outimage;
outtext(" ------------------------------- ");outimage;
outimage;
outtext(" i, j ");
for i:=1 step 1 until 5 do
begin
outtext(" ");outint(i,2);outtext(" ");
end;
for i:=1 step 1 until 5 do
begin
outimage;
outimage;
outtext(" ");outint(i,2);outtext(" ");
outtext(" ");
outfix(overgangsmatrix(i,1),2,6);
outtext(" ");
for j:=2 step 1 until 5 do
begin
outtext(" ");
outfix(overgangsmatrix(i,j)-overgangsmatrix(i,j-1),2,6);
outtext(" ");
end;
end;
end;
\f
procedure spor(nummer,procestype,status);
integer nummer,procestype,status;
begin
outtext("jobnr ");
outint(nummer,3);
if status = 1 then
outtext(" starter i ") else
outtext(" forlader ");
if procestype = 1 then
outtext("inputproces");
if procestype = 2 then
outtext("soegeproces 1");
if procestype = 3 then
outtext("opslagproces");
if procestype = 4 then
outtext("outputproces");
if procestype = 5 then
outtext("statistikproces");
if procestype = 6 then
outtext("soegeproces 2");
if procestype = 7 then
outtext("jobgenerator");
outtext(" til tiden ");
outfix(time,4,12);
outimage;
end;
\f
comment
*********************************
* *
* G L O B A L E V A R A B L E *
* *
********************************* ;
real array snitforsp,varforsp(1:6,1:3,1:5);
integer array antalforsp(1:6,1:5);
real array kanalsum(1:2,1:5);
integer array antalfejl(1:5);
real array totaltid,samlettid(1:5);
real array disksum(1:4,1:5);
real array soegesum(1:5);
real array inputsum,opslagssum,outputsum,
processum(1:5);
real skiftetid;
integer array svarfordel(0:32);
real minsvartid,maxsvartid;
integer antalprocskift;
integer array disktilgange(1:5);
boolean array kontrolkald(1:2);
boolean array paratkald(1:2);
integer diskkonnr,tid,simtid,statkald;
boolean kondublering,dublering;
real array sidstmaalt(1:6),kanalobs(1:2),
kanalgnst(1:2,1:5),kanalsidst(1:2);
integer array kanalantal(1:2,1:5);
real overfoerselstid;
real disktid;
real pladesands;
real resttidskvant;
real array gnstikoe(1:6,1:5);
real array sidstobs(1:6);
real array timequantum(1:6);
integer array antalikoe(1:6,1:5);
real array overgangsmatrix(1:5,1:5),
ankomstrate(0:23),
pladelagertid(1:4);
boolean array procaktiv(1:6);
real inputtid,soegetid,opslagtid,outputtid,
tidskvant;
integer startvaerdi,kontrolnr,inputprocesnr,
test,
soegeprocesnr,opslagprocesnr,outputprocesnr,
mindst,stoerst,faerrest,flest,disknr,i,j,simperiode;
ref (head) array kontrolkoe(1:2);
ref (disk) array pladelager(1:4);
ref (koeobjekt) array objekt(1:6);
ref (center) array proc(1:6);
ref (head) array koe(1:6);
ref (head) aktivkoe;
ref (head) soegediskkoe;
ref (head) opslagsdiskkoe,outputdiskkoe;
ref (processtyring) skift;
ref (diskkontrol) array kontrol(1:2);
\f
comment
************************************
* *
* I N I T I A L I S E R I N G *
* *
************************************ ;
test:=inint;
skiftetid:=inreal;
for i:= 0 step 1 until 23 do ankomstrate(i) := inreal;
for i:=1 step 1 until 4 do pladelagertid(i):=inreal;
inputtid := inreal;
soegetid:= inreal;
opslagtid := inreal;
outputtid := inreal;
tidskvant := inreal;
startvaerdi := inint;
inputprocesnr := inint;
soegeprocesnr:= inint;
opslagprocesnr := inint;
outputprocesnr := inint;
mindst := inint;
stoerst := inint;
faerrest := inint;
flest := inint;
pladesands:=inreal;
simperiode := inint;
overfoerselstid:=inreal;
i:=inint;
if i = 1 then kondublering := true;
i:=inint;
if i = 1 then dublering:=true;
for i:=1 step 1 until 6 do
koe(i):- new head;
for i:=1 step 1 until 2 do
kontrolkoe(i):- new head;
soegediskkoe:- new head;
opslagsdiskkoe :- new head;
outputdiskkoe :- new head;
aktivkoe:- new head;
proc(1) :- new inputproces;
proc(2) :- new soegeproces;
proc(3) :- new opslagproces;
proc(4) :- new outputproces;
proc(5) :- new statistik;
proc(6):- new soegeproces;
for i := 1 step 1 until 5 do
begin
overgangsmatrix(i,1) := 0;
for j := 2 step 1 until 5 do
overgangsmatrix(i,j) := inreal + overgangsmatrix(i,j-1);
end;
for i:=1 step 1 until 4 do
pladelager(i) :- new disk;
skift :- new processtyring;
if kondublering then
begin
for i:=1 step 1 until 2 do kontrol(i):- new diskkontrol;
end else kontrol(1):-new diskkontrol;
for i:=1 step 1 until 6 do
objekt(i):- new koeobjekt;
for i:=1 step 1 until 6 do
objekt(i).prioritet:=inint;
resttidskvant:=tidskvant;
for i:=1 step 1 until 6 do
objekt(i).aktivnr:=i;
skrivinput;
minsvartid:=100000.0;
activate new jobgenerator;
end;
ktassystem
begin
simtid:=simperiode/4;
for tid :=1 step 1 until 4 do
begin
hold(simtid);
skrivresultat(tid);
for i:=1 step 1 until 6 do
sidstobs(i):=0;
for i:=1 step 1 until 2 do kanalobs(i):=0;
end;
simtid:=simperiode;
skrivresultat(5);
end;
end;
▶EOF◀