Wojskowa Akademia Techniczna
im. Jarosława Dąbrowskiego
PODSTAWY SYMULACJI
Sprawozdanie z Projektu
Temat: Program symulujący działanie sieci SMO.
Prowadzący: dr inż. Jarosław Rulka
Wykonał: Marcin Przerwa
Grupa: I7G2S1
1. Treśd zadania 3.
T1
p2
O1
O2
SMO
SMO
T2
O3
SMO
p3
Przy realizacji zadania należy przyjąć następujące dane z listy przedstawionej poniżej:
a) rozkład zmiennych Tj: (nrDz + i) mod 6 + 1;
b) rozkład zmiennych Oi: (nrDz + i + 1) mod 6 + 1;
c) Li: (nrDz + i) mod 2 + 1;
d) ALi: (nrDz + i + 2) mod 3 + 1;
e) Rj = (nrDz + i + 5) mod 3 + 1;
f) Mi = (nrDz + i + 2) mod 4 + 1;
g) Blokowanie zgłoszeń 1. SMO;
h) Klienci niecierpliwi w SMOi : Ni = (nrDz + i) mod 4 (ograniczony czas oczekiwania na rozpoczęcie
obsługi);
gdzie:
i  numer SMO;
j  numer strumienia;
Tj  zmienna losowa oznaczająca czas pomiędzy kolejnymi napływami zgłoszeo do systemu;
Oi  zmienna losowa oznaczająca czas obsługi pojedynczego zgłoszenia w gniez
dzie;
Ni  zmienna losowa oznaczająca czas niecierpliwości zgłoszenia (gdy i = 0 => zgłoszenia cierpliwe);
Rj  zmienna losowa oznaczająca wielkośd paczki zgłoszeo (wchodzących w tej samej chwili) j-tego
strumienia;
pk  prawdopodobieostwa przemieszczenia się zgłoszenia po danym łuku;
Li  długośd kolejki i-tego SMO;
AL.i  algorytmy kolejek (w przypadku istnienia kolejki z priorytetami należy przyjąd, że zgłoszenia
posiadają priorytety);
1. Rozkłady zmiennych losowych:
1.1. Wykładniczy
1.2. Erlanga
1.3. Normalny
1.4. Jednostajny
1.5. Trókątny
1.6. Weibulla
2. Długości kolejek pojedynczych SMO
2.1. ograniczone (możliwe straty)
2.2. nieograniczone
3. Algorytm kolejek:
3.1. FIFO
3.2. LIFO
3.3. Z priorytetami
4. Liczba stanowisk obsługi w gniazdach (1-M)
5. Ilośd zgłoszeo jednocześnie napływających do systemu (1-R)
Pozostałe dane należy określad na początku symulacji.
2. Dane.
NrDz= 11.
a) rozkład zmiennych Tj: (nrDz + i) mod 6 + 1;
T1=1; rozkład Wykładniczy (Exponential(1.0/lambda)) ; czas pomiędzy kolejnymi napływami
zgłoszeo do systemu z generatora 1
T2 =2; rozkład Erlanga (Erlang(lo,hi)) ; czas pomiędzy kolejnymi napływami zgłoszeo do systemu z
generatora 2
b) rozkład zmiennych Oi: (nrDz + i + 1) mod 6 + 1;
O1=2 ; rozkład Erlang (Erlang(mean,k))
O2=3 ; rozkład Normal (Normal(mean,sigma))
O3=4 ; rozkład Jednostajny (Uniform(lo,hi))
c) Li: (nrDz + i) mod 2 + 1; długości kolejek
L1=1 => kolejka ograniczona
L2=2 => kolejka nieograniczona
L3=1 => kolejka ograniczona
d) ALi: (nrDz + i + 2) mod 3 + 1; algorytmy kolejek
AL1=3;Z priorytetami
AL2=1; FIFO
AL3=2; LIFO
e) Rj = (nrDz + i + 5) mod 3 + 1; ; rozkład wielkości paczki zgłoszeo
R1=3 ; rozkład Normalny
R2=1 ; rozkład Wykładniczy (Exponential(1.0/lambda))
f) Mi = (nrDz + i + 2) mod 4 + 1; liczba stanowisk obsługi w gniazdach
M1 =3;
M2 =4;
M3 =1;
g) Klienci niecierpliwi w SMOi : Ni = (nrDz + i) mod 4 (ograniczony czas oczekiwania na rozpoczęcie
obsługi);
N1 = 0; klienci cierpliwi;
N2 = 1; klienci niecierpliwi z R2=3 ; rozkład Wykładniczy ( Exponential(1.0/lambda))
N3 = 2; klienci niecierpliwi z R3=1 ; rozkład Erlanga (Erlang(mean,k))
3. Sposób rozwiązania.
4. Kod z
ródłowy.
MAIN MODULE Przerwa;
FROM IOMod IMPORT ReadKey;
{ Zatrzymuje ostatni ekran dla użytkownika }
FROM RandMod IMPORT RandomObj ,FetchSeed;
{ generowanie liczb pseudolosowych}
FROM SimMod IMPORT StartSimulation,SimTime,StopSimulation,ResetSimTime,TriggerObj, Interrupt;
FROM StatMod IMPORT SINTEGER,RStatObj,SREAL,TSINTEGER,ITimedStatObj;
FROM GrpMod IMPORT StatQueueObj,StatStackObj,StatRankedObj,BStatGroupObj;
{ podstawowe struktury danych }
FROM MathMod IMPORT CEIL;
{ ceil wykorzystanie do zaokrągleo wielkości paczki }
 {TYPY}
{**********************************************************************************}
TYPE
{STRUKTURY}
AlgorytmKolejkowania = (FIFO,LIFO,Priorytetowa);
{ dla czytelności (lepsze niż np. INTEGERY) }
GeneratorObj = OBJECT; FORWARD;
KlientObj = OBJECT; FORWARD;
KolejkaObj = OBJECT; FORWARD;
GniazdoObj = OBJECT; FORWARD;
SystemObj = OBJECT; FORWARD;
{ definicje wyprzedzające }
{DEFINICJE OBIEKTOW}
{**********************************************************************************}
KlientObj = OBJECT(RandomObj)
id : INTEGER;
priorytet : INTEGER;
wKolejce:REAL;
wSystemie:REAL;
ASK METHOD Init ( IN i:INTEGER; IN p:INTEGER);
ASK METHOD WszedlDoKolejki();
ASK METHOD WszedlDoSystemu();
TELL METHOD Czeka(IN s: SystemObj; IN k:KolejkaObj; IN t:REAL);
END OBJECT;
{**********************************************************************************}
GniazdoObj = OBJECT(RandomObj)
system:SystemObj;
kolejkaWE : KolejkaObj;
kolejkaWY : KolejkaObj;
id:INTEGER;
obslugiwany:KlientObj;
czas:SREAL;
liczbaStanowisk:TSINTEGER;
liczbaZajetych:TSINTEGER;
pstwo : REAL; {prawdopodobienstwo powrotu do gniazda}
par1 : REAL;
par2 : REAL;
par3 : INTEGER;
ASK METHOD Init( IN i:INTEGER; IN s:SystemObj;IN kwy:KolejkaObj;IN kwe:KolejkaObj;IN ls:INTEGER;IN p1:REAL;IN p2:REAL;IN
p3:INTEGER;IN ps:REAL;IN se:INTEGER);
TELL METHOD Obsluz();
END OBJECT;
{**********************************************************************************}
KolejkaPriorytetowaObj = OBJECT(StatRankedObj)
OVERRIDE
ASK METHOD Rank(IN a : ANYOBJ; IN b : ANYOBJ) : INTEGER;
END OBJECT;
{**********************************************************************************}
KolejkaObj = OBJECT
system : SystemObj;
gniazdo : GniazdoObj;
rodzaj : AlgorytmKolejkowania;
dlugosc : INTEGER; { 0 oznacza kolejke nieskonczona }
liczbaKlientow : TSINTEGER; { to bedzie obliczane }
kolejka : BStatGroupObj; { tu będą przechowywani klienci }
czasCierpliwosciKlienta:REAL; { czas cierpliwości klienta jest zależny od kolejki }
ASK METHOD Init( IN s:SystemObj; IN g:GniazdoObj; IN r:AlgorytmKolejkowania; IN dl:INTEGER);
ASK METHOD Dodaj( IN s:SystemObj; IN k:KlientObj);
 ASK METHOD Usun(IN k:KlientObj):KlientObj;
END OBJECT;
{**********************************************************************************}
GeneratorObj = OBJECT(RandomObj);
system : SystemObj;
kolejka : KolejkaObj; { kolejka z którą związany jest generator }
id : INTEGER; { id generatora (do wypisywania np.) }
par11 : REAL; {parametry do generatora (p3 jest do Erlanga)}
par21 : REAL;
par22 : INTEGER;
par31 : REAL; {parametry zmiennej losowej ocznaczającej wielkośd paczki}
par32 : REAL;
liczbaJuzWygenerowanych : INTEGER;
liczbaZgloszenDoWygenerowania : INTEGER;
maxWielkoscPaczki : INTEGER;
ASK METHOD Init( IN i : INTEGER; IN s : SystemObj; IN k : KolejkaObj; IN p11 : REAL; IN p21 : REAL; IN p22 : INTEGER;IN p31 : REAL;IN p32
: REAL;IN lzdw : INTEGER;IN mwp : INTEGER;IN se : INTEGER ); { inicjowanie zmiennych obiektu }
TELL METHOD Wygeneruj(); { generowanie zgłoszeo }
END OBJECT;
{**********************************************************************************}
SystemObj = OBJECT
czasPrzebywaniaZgloszenia:SREAL;
liczbaZgloszen:TSINTEGER;
liczbaObsluzonychZgloszen:INTEGER;
liczbaWygenerowanych:INTEGER;
ASK METHOD Wlacz();
ASK METHOD Zwieksz();
ASK METHOD CzasWejscia(IN k:KlientObj);
ASK METHOD KlientWyszedl(IN k:KlientObj; IN zostalObsluzony:BOOLEAN);
END OBJECT;
{**********************************************************************************}
OBJECT GeneratorObj;
ASK METHOD Init( IN i : INTEGER;
IN s : SystemObj;
IN k : KolejkaObj;
IN p11 : REAL;
IN p21 : REAL;
IN p22 : INTEGER;
IN p31 : REAL;
IN p32 : REAL;
IN lzdw : INTEGER;
IN mwp : INTEGER;
IN se : INTEGER );
BEGIN
id := i;
system := s;
kolejka := k;
par11 := p11;
par21 := p21;
par22 := p22;
par31 := p31;
par32 := p32;
liczbaJuzWygenerowanych := 0;
liczbaZgloszenDoWygenerowania := lzdw;
maxWielkoscPaczki := mwp;
SetSeed(se);
END METHOD;
TELL METHOD Wygeneruj();
VAR
t : REAL;
k : KlientObj;
wp : INTEGER; { wielkosc paczki }
i: INTEGER; { zmienna iteracyjna }
 BEGIN
WHILE liczbaJuzWygenerowanych < liczbaZgloszenDoWygenerowania
CASE id { w zależności od id losuje czas pomiędzy zgłoszeniami i wielkosc paczki }
WHEN 1:
t := ASK SELF TO Exponential( par11 );
wp := CEIL(Normal(par31,par32));
WHEN 2:
t := ASK SELF TO Erlang( par21, par22 );
wp := CEIL(Exponential(par31));
END CASE;
IF t < 0.0 { żeby nie wyszedł ujemny czas }
t := 0.0;
END IF;
WAIT DURATION t
END WAIT;
IF wp < 0
wp := 0;
END IF;
FOR i:=0 TO wp
NEW (k); { utworz nowego klienta }
liczbaJuzWygenerowanych := liczbaJuzWygenerowanych + 1; {zwieksz lczbe juz wygenerowanych}
ASK k TO Init (liczbaJuzWygenerowanych,UniformInt(1,5));
ASK system TO Zwieksz;
ASK system TO CzasWejscia(k);
ASK kolejka TO Dodaj(system, k);
END FOR;
END WHILE;
END METHOD;
END OBJECT;
{**********************************************************************************}
OBJECT KolejkaPriorytetowaObj;
ASK METHOD Rank(IN a,b : ANYOBJ) : INTEGER;
VAR
k1 : KlientObj;
k2 : KlientObj;
BEGIN
k1 := a;
k2 := b;
IF ASK k1 TO priorytet < ASK k2 TO priorytet
RETURN -1;
END IF;
IF ASK k1 TO priorytet > ASK k2 TO priorytet
RETURN 1;
END IF;
RETURN 0;
END METHOD;
END OBJECT;
{**********************************************************************************}
OBJECT KlientObj;
ASK METHOD Init ( IN i:INTEGER; IN p:INTEGER);
BEGIN
id := i;
priorytet := p;
END METHOD;
TELL METHOD Czeka(IN s: SystemObj; IN k:KolejkaObj; IN t:REAL);
VAR
self:KlientObj;
BEGIN
IF t>0.0; { jak t = 0 klient jest baaardzo cierpliwy }
WAIT DURATION t;
self := ASK k TO Usun(SELF); { popros kolejke o usuniecie z niej siebie }
ASK s TO KlientWyszedl(SELF, FALSE); { niech klient poinformuje system że zostal odrzucony}
ON INTERRUPT;
END WAIT;
END IF;
 END METHOD;
ASK METHOD WszedlDoKolejki();
BEGIN
wKolejce := SimTime;
END METHOD;
ASK METHOD WszedlDoSystemu();
BEGIN
wSystemie := SimTime;
END METHOD;
END OBJECT;
{**********************************************************************************}
OBJECT KolejkaObj;
ASK METHOD Init(IN s:SystemObj;IN g:GniazdoObj;IN r:AlgorytmKolejkowania;IN dl:INTEGER);
VAR
kPrio:KolejkaPriorytetowaObj;
kFIFO:StatQueueObj;
kLIFO:StatStackObj;
BEGIN
system := s;
gniazdo := g;
rodzaj := r;
dlugosc := dl;
liczbaKlientow := 0;
CASE rodzaj { utworz odpowiedni rodzaj kolejki i ustaw czasy cierpliwości klientów }
WHEN Priorytetowa: { to jest pierwsza }
NEW(kPrio);
kolejka:=kPrio;
czasCierpliwosciKlienta:=0.0;
WHEN FIFO: { druga }
NEW(kFIFO);
kolejka:=kFIFO;
czasCierpliwosciKlienta:=1.0;
WHEN LIFO: { trzecia }
NEW(kLIFO);
kolejka:=kLIFO;
czasCierpliwosciKlienta:=2.0;
END CASE;
END METHOD;
ASK METHOD Dodaj(IN s:SystemObj;IN k:KlientObj);
VAR
BEGIN
IF dlugosc > 0 { jeżeli kolejka jest ograniczona }
IF liczbaKlientow < dlugosc { ale jest jeszcze miejsce na klienta }
ASK k TO WszedlDoKolejki();
ASK kolejka TO Add(k); {wejscie klienta do kolejki}
TELL k TO Czeka ( s, SELF, czasCierpliwosciKlienta );
liczbaKlientow := liczbaKlientow + 1;
IF ( ASK gniazdo TO liczbaZajetych ) < ( ASK gniazdo TO liczbaStanowisk )
TELL gniazdo TO Obsluz();
END IF;
ELSE
ASK system TO KlientWyszedl(k,FALSE);
END IF;
ELSE
ASK k TO WszedlDoKolejki();
ASK kolejka TO Add(k);
liczbaKlientow := liczbaKlientow + 1;
IF ( ASK gniazdo TO liczbaZajetych ) < ( ASK gniazdo TO liczbaStanowisk )
TELL gniazdo TO Obsluz();
END IF;
END IF;
END METHOD;
 ASK METHOD Usun(IN k:KlientObj):KlientObj; {usuwanie klienta z kolejki, zwraca usunietego klienta}
VAR
temp : KlientObj;
BEGIN
IF liczbaKlientow > 0
IF k = NILOBJ
temp := ASK kolejka TO Remove();
ELSE
ASK kolejka TO RemoveThis(k);
temp := k;
END IF;
liczbaKlientow := liczbaKlientow - 1;
RETURN temp;
ELSE
RETURN NILOBJ;
END IF;
END METHOD;
END OBJECT;
{**********************************************************************************}
OBJECT GniazdoObj;
ASK METHOD Init( IN i:INTEGER;IN s:SystemObj;IN kwy:KolejkaObj;IN kwe:KolejkaObj;IN ls:INTEGER; IN p1:REAL; IN p2:REAL; IN
p3:INTEGER; IN ps:REAL;IN se:INTEGER );
BEGIN
system := s;
id := i;
liczbaStanowisk := ls;
kolejkaWE := kwe;
kolejkaWY := kwy;
pstwo := ps;
par1 := p1;
par2 := p2;
par3 := p3;
liczbaZajetych := 0;
czas := 0.0;
SetSeed(se);
END METHOD;
TELL METHOD Obsluz();
VAR
cz : REAL;
BEGIN
IF (((ASK kolejkaWE TO liczbaKlientow) > 0) AND (liczbaStanowisk > liczbaZajetych))
liczbaZajetych := liczbaZajetych + 1;
CASE id { przeczekaj obsluge }
WHEN 1:
cz := Erlang(par1,par3);
WHEN 2:
cz := Normal(par1,par2);
WHEN 3:
cz := UniformReal(par1,par2);
END CASE;
IF cz<0.0
cz := 0.0;
END IF;
obslugiwany := ASK kolejkaWE TO Usun(NILOBJ);
Interrupt(obslugiwany, "Czeka");
WAIT DURATION cz;
END WAIT;
czas := SimTime - (ASK obslugiwany TO wKolejce);
IF Sample() > pstwo;
IF ASK SELF TO id = 1;
ASK kolejkaWY TO Dodaj(system, obslugiwany);
ELSE
ASK system TO KlientWyszedl(obslugiwany, TRUE);
END IF;
liczbaZajetych := liczbaZajetych -1;
ELSE
ASK kolejkaWE TO Dodaj(system, obslugiwany);
END IF;
Obsluz();
{TELL SELF TO Obsluz()}
END IF;
END METHOD;
END OBJECT;
{**********************************************************************************}
OBJECT SystemObj;
ASK METHOD Wlacz();
BEGIN
czasPrzebywaniaZgloszenia := 0.0;
liczbaZgloszen := 0;
liczbaObsluzonychZgloszen := 0;
liczbaWygenerowanych := 0;
END METHOD;
ASK METHOD CzasWejscia(IN k : KlientObj);
BEGIN
ASK k TO WszedlDoSystemu;
liczbaZgloszen := liczbaZgloszen + 1;
END METHOD;
ASK METHOD KlientWyszedl(IN k:KlientObj; IN obs:BOOLEAN);
BEGIN
czasPrzebywaniaZgloszenia := (SimTime-(ASK k TO wSystemie));
IF obs
liczbaObsluzonychZgloszen := liczbaObsluzonychZgloszen + 1;
ELSE
{ nie zostal obsluzony }
END IF;
liczbaZgloszen := liczbaZgloszen - 1;
END METHOD;
ASK METHOD Zwieksz();
BEGIN
liczbaWygenerowanych := liczbaWygenerowanych +1;
END METHOD;
END OBJECT;
{**********************************************************************************}
VAR
System:SystemObj;
Generator1,Generator2:GeneratorObj;
Gniazdo1,Gniazdo2,Gniazdo3:GniazdoObj;
Kol1,Kol2,Kol3:KolejkaObj;
pstwo2 : REAL;
pstwo3 : REAL;
gen1par1 : REAL; { wykladniczy }
gen2par1 : REAL; { Erlanga }
gen2par2 : INTEGER;
gen1parP1 : REAL; { parametry generowanych wielkosci paczek normalny i wykladniczy}
gen1parP2 : REAL;
gen2parP1 : REAL;
gnia1par1 : REAL; { Erlanga }
gnia1par2 : INTEGER;
gnia2par1 : REAL; { normalny }
gnia2par2 : REAL;
 gnia3par1 : REAL; { jednostajny }
gnia3par2 : REAL;
dlugoscKol1,dlugoscKol3:INTEGER;
Klient:KlientObj;
doWygenerowania : INTEGER;
MonCzas,MonCzasSMO1,MonCzasSMO2,MonCzasSMO3:RStatObj;
MonLiczbaZgloszenSys,MonLiczbaZajetychGn1,MonLiczbaZajetychGn2,MonLiczbaZajetychGn3,MonZgloszenWKolejce1,MonZgloszenWKole
jce2,MonZgloszenWKolejce3:ITimedStatObj;
pstwoObsluzenia:REAL;
gen1Seed,gen2Seed:INTEGER;
temp:CHAR;
BEGIN
pstwo2 := 0.1;
pstwo3 := 0.1;
gen1par1 := 4.1;
gen2par1 := 4.0;
gen2par2 := 1;
gen1parP1 := 3.2;
gen1parP2 := 3.3;
gen2parP1 := 4.0;
gnia1par1 := 60.2;
gnia1par2 := 1;
gnia2par1 := 3.3; { normalny }
gnia2par2 := 1.2;
gnia3par1 := 1.1; { jednostajny }
gnia3par2 := 6.2;
dlugoscKol1 := 40;
dlugoscKol3 := 40;
doWygenerowania := 1230;
gen1Seed := 123;
gen2Seed := 21;
OUTPUT("*******************************************************************");
OUTPUT("********************** Marcin Przerwa I7G2S1 **********************");
OUTPUT("*******************************************************************");
OUTPUT("");
OUTPUT("*******************************************************************");
OUTPUT("************************* PODAJ PARAMETRY: ************************");
OUTPUT("*******************************************************************");
OUTPUT("");
REPEAT
OUTPUT("Dlugosc kolejki nr 1 (>0):");
INPUT(dlugoscKol1);
UNTIL(dlugoscKol1>1);
REPEAT
OUTPUT("Dlugosc kolejki nr 3 (>0) :");
INPUT(dlugoscKol3);
UNTIL(dlugoscKol3>1);
REPEAT
OUTPUT("Ilosc klientow do wygenerowania przez kazdy z generatorow (>0): ");
INPUT( doWygenerowania );
UNTIL(doWygenerowania>1);
REPEAT
OUTPUT("Prawdopodobienstwo powrotu do gniazda 2: ");
INPUT(pstwo2);
UNTIL( (pstwo2>0.0) AND (pstwo2<1.0) );
REPEAT
OUTPUT("Prawdopodobienstwo powrotu do gniazda 3: ");
INPUT(pstwo3);
UNTIL( (pstwo3>0.0) AND (pstwo3<1.0) );
OUTPUT("*******************************************************************");
OUTPUT("******************* PARAMETRY GENERATORA NR 1: ********************");
OUTPUT("*******************************************************************");
OUTPUT("");
REPEAT
OUTPUT("Podaj wartosc oczekiwana rozkladu wykladniczego generatora nr 1: ");
INPUT(gen1par1);
UNTIL( gen1par1>0.0 );
REPEAT
OUTPUT("Podaj wartosc oczekiwana rozkladu normalnego generowanych paczek zgłoszen nr 1: ");
INPUT(gen1parP1);
UNTIL( gen1parP1>0.0 );
REPEAT
OUTPUT("Podaj odchylenie standartowe rozkladu normalnego generowanych paczek zgłoszen nr 1: ");
INPUT(gen1parP2);
UNTIL( gen1parP2>0.0 );
OUTPUT("Podaj ziarno dla pierwszego generatora");
INPUT(gen1Seed);
OUTPUT("*******************************************************************");
OUTPUT("******************* PARAMETRY GENERATORA NR 2: ********************");
OUTPUT("*******************************************************************");
OUTPUT("");
REPEAT
OUTPUT("Podaj wartosc oczekiwana rozkladu Erlanga: ");
INPUT(gen2par1);
UNTIL( gen2par1>0.0 );
REPEAT
OUTPUT("Podaj liczbę stopni swobody generatora 2 rozkladu Erlanga: ");
INPUT(gen2par2);
UNTIL( gen2par2>=1 );
REPEAT
OUTPUT("Podaj w.oczekiwana rozkladu wykladniczego generowanych paczek zgloszen: ");
INPUT(gen2parP1);
UNTIL( gen2parP1>=0.0 );
OUTPUT("Podaj ziarno dla drugiego generatora");
INPUT(gen2Seed);
OUTPUT("Parametry gniazda nr 1:");
OUTPUT("");
REPEAT
OUTPUT("Podaj wartosc oczekiwana rozkladu wykladniczego");
INPUT(gnia2par1);
UNTIL( gnia2par1>=0.0 );
OUTPUT("Parametry gniazda nr 2:");
OUTPUT("");
REPEAT
OUTPUT("Podaj wartosc oczekwana rozkladu normalnego: ");
INPUT(gnia2par1);
UNTIL( gnia2par1>=0.0 );
REPEAT
OUTPUT("Podaj odchylenie standartowe rozkladu normalnego: ");
INPUT(gnia2par2);
UNTIL( gnia2par2>=0.0 );
OUTPUT("Parametry gniazda nr 3:");
OUTPUT("");
REPEAT
OUTPUT("Podaj parametr min rozkladu jednostajnego: ");
INPUT(gnia3par1);
UNTIL( gnia3par1>=0.0 );
REPEAT
OUTPUT("Podaj parametr max rozkladu jednostajnego (>min): ");
INPUT(gnia3par2);
UNTIL( gnia3par2 >= gnia3par1 );
NEW(System);
NEW(Gniazdo1);
NEW(Gniazdo2);
NEW(Gniazdo3);
NEW(Kol1);
NEW(Kol2);
NEW(Kol3);
NEW(Generator1) ;
NEW(Generator2) ;
ASK System TO Wlacz();
ASK Kol1 TO Init (System, Gniazdo1, Priorytetowa, dlugoscKol1);
ASK Kol2 TO Init (System, Gniazdo2, FIFO , 0);
ASK Kol3 TO Init (System, Gniazdo3, LIFO, dlugoscKol3);
ASK Generator1 TO Init(1,System, Kol1,gen1par1, 0.0,0 ,gen1parP1,gen1parP2,doWygenerowania, 3, gen1Seed);
ASK Generator2 TO Init(2,System, Kol3,0.0 ,gen2par1,gen2par2 ,gen2parP1,0.0,doWygenerowania, 1, gen2Seed);
ASK Gniazdo1 TO Init(1, System, Kol2, Kol1, 1,gnia1par1, 0.0,gnia1par2, 0.0,gen1Seed);
ASK Gniazdo2 TO Init(2, System, NILOBJ, Kol2, 2,gnia2par1,gnia2par2,0, pstwo2,gen2Seed);
ASK Gniazdo3 TO Init(3, System, NILOBJ, Kol3, 3,gnia3par1,gnia3par2,0, pstwo3,gen1Seed+gen2Seed);
TELL Generator1 TO Wygeneruj();
TELL Generator2 TO Wygeneruj();
StartSimulation;
MonCzas := GETMONITOR(ASK System TO czasPrzebywaniaZgloszenia,RStatObj);
MonCzasSMO1 := GETMONITOR(ASK Gniazdo1 TO czas,RStatObj);
MonCzasSMO2 := GETMONITOR(ASK Gniazdo2 TO czas,RStatObj);
MonCzasSMO3 := GETMONITOR(ASK Gniazdo3 TO czas,RStatObj);
MonLiczbaZgloszenSys := GETMONITOR(ASK System TO liczbaZgloszen,ITimedStatObj);
MonLiczbaZajetychGn1 := GETMONITOR(ASK Gniazdo1 TO liczbaZajetych,ITimedStatObj);
MonLiczbaZajetychGn2 := GETMONITOR(ASK Gniazdo2 TO liczbaZajetych,ITimedStatObj);
MonLiczbaZajetychGn3 := GETMONITOR(ASK Gniazdo3 TO liczbaZajetych,ITimedStatObj);
MonZgloszenWKolejce1 := GETMONITOR(ASK Kol1 TO liczbaKlientow,ITimedStatObj);
MonZgloszenWKolejce2 := GETMONITOR(ASK Kol2 TO liczbaKlientow,ITimedStatObj);
 MonZgloszenWKolejce3 := GETMONITOR(ASK Kol3 TO liczbaKlientow,ITimedStatObj);
pstwoObsluzenia := FLOAT(ASK System TO liczbaObsluzonychZgloszen)/FLOAT(ASK System TO liczbaWygenerowanych);
OUTPUT("");
OUTPUT("||||====================================|||");
OUTPUT("|||||||| WYNIKI DZIALANIA SYMULACJI: ||||||");
OUTPUT("||||====================================|||");
OUTPUT("");
OUTPUT("|||Liczba wygenerowanych: ",ASK System TO liczbaWygenerowanych);
OUTPUT("");
OUTPUT("|||Czas przebywania zgloszenia w systemie:");
OUTPUT("|||Wartosc srednia ",ASK MonCzas TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonCzas TO StdDev);
OUTPUT("");
OUTPUT("|||Czas przebywania zgloszenia w SMO 1:");
OUTPUT("|||Wartosc srednia ",ASK MonCzasSMO1 TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonCzasSMO1 TO StdDev);
OUTPUT("");
OUTPUT("|||Czas przebywania zgloszenia w SMO 2:");
OUTPUT("|||Wartosc srednia ",ASK MonCzasSMO2 TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonCzasSMO2 TO StdDev);
OUTPUT("");
OUTPUT("|||Czas przebywania zgloszenia w SMO 3:");
OUTPUT("|||Wartosc srednia ",ASK MonCzasSMO3 TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonCzasSMO3 TO StdDev);
OUTPUT("");
OUTPUT("|||Liczba klientow w systemie: ");
OUTPUT("|||Wartosc srednia ",ASK MonLiczbaZgloszenSys TO Mean);
OUTPUT("|||Odchylenie standardowe",ASK MonLiczbaZgloszenSys TO StdDev);
OUTPUT("");
OUTPUT("|||Liczba zajetych kanalow w gniezdzie 1:");
OUTPUT("|||Wartosc srednia ",ASK MonLiczbaZajetychGn1 TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonLiczbaZajetychGn1 TO StdDev);
OUTPUT("");
OUTPUT("|||Liczba zajetych kanalow w gniezdzie 2:");
OUTPUT("|||Wartosc srednia ",ASK MonLiczbaZajetychGn2 TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonLiczbaZajetychGn2 TO StdDev);
OUTPUT("");
OUTPUT("|||Liczba zajetych kanalow w gniezdzie 3:");
OUTPUT("|||Wartosc srednia ",ASK MonLiczbaZajetychGn3 TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonLiczbaZajetychGn3 TO StdDev);
OUTPUT("");
OUTPUT("|||Liczba klientow w kolejce 1 (priorytetowej):");
OUTPUT("|||Wartosc srednia ",ASK MonZgloszenWKolejce1 TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonZgloszenWKolejce1 TO StdDev);
OUTPUT("");
OUTPUT("|||Liczba klientow w kolejce 2 (FIFO):");
OUTPUT("|||Wartosc srednia ",ASK MonZgloszenWKolejce2 TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonZgloszenWKolejce2 TO StdDev);
OUTPUT("");
OUTPUT("|||Liczba klientow w kolejce 3 (LIFO):");
OUTPUT("|||Wartosc srednia ",ASK MonZgloszenWKolejce3 TO Mean);
OUTPUT("|||Odchylenie standardowe: ",ASK MonZgloszenWKolejce3 TO StdDev);
OUTPUT("");
OUTPUT("|||Prawdopodobienstwo obsluzenia klienta w systemie: ",pstwoObsluzenia);
OUTPUT("");
DISPOSE(Kol1);
DISPOSE(Kol2);
DISPOSE(Kol3);
DISPOSE(Generator1);
DISPOSE(Generator2);
DISPOSE(Gniazdo1);
DISPOSE(Gniazdo2);
DISPOSE(Gniazdo3);
 DISPOSE(System);
OUTPUT("Nacisnij cos, aby zakonczyc program.");
temp := ReadKey;
END MODULE;