WOJSKOWA AKADEMIA TECHNICZNA

Podstawy Symulacji

Zadanie projektowe

Temat :

Napisać program symulacyjny działanie sieci SMO

Prowadzący : dr inż. Jarosław Rulka
Grupa: I7G2S1
Wykonawca: Oleksiak Marek

Treść zadania:

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łoszeń do systemu;

Oi – zmienna losowa oznaczająca czas obsługi pojedynczego zgłoszenia
w gnieździe;

Ni – zmienna losowa oznaczająca czas niecierpliwości zgłoszenia (gdy
i = 0 => zgłoszenia cierpliwe);

Rj – zmienna losowa oznaczająca wielkość paczki zgłoszeń (wchodzących
w tej samej chwili) j-tego strumienia;

pk – prawdopodobieństwa przemieszczenia się zgłoszenia po danym łuku;

Li – długość kolejki i-tego SMO;

AL.i – algorytmy kolejek (w przypadku istnienia kolejki z
priorytetami należy przyjąć, ż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ójką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ść zgłoszeń jednocześnie napływających do systemu (1-R)

Pozostałe dane należy określać na początku symulacji.

Program powinien umożliwić oszacowanie następujących charakterystyk
granicznych

systemu oraz poszczególnych SMO:

●

czas przebywania zgłoszenia (średnia, odchylenie standardowe),

●

liczbę zgłoszeń (średnia, odchylenie standardowe),

●

liczbę zajętych kanał—w (średnia, odchylenie standardowe),

●

liczbę zgłoszeń w kolejce (średnia, odchylenie standardowe).

●

prawdopodobieństwo obsłużenia zgłoszenia.

W sprawozdaniu należy zawrzeć:

●

kod źródłowy programu (z komentarzem);

●

opis metody wyznaczania charakterystyk (sposób realizacji, wzory

estymator—w);

Zadanie zrealizować w języku MODSIM II.

Termin rozliczenia się z realizacji zadania na ostatnich zajęciach

laboratoryjnych.

Numer z dziennika 5

Zmienna losowa oznaczająca czas pomiędzy kolejnymi napływami zgłoszeń do
systemu

Tj: (nrDz + i) mod 6 + 1

●

T1=1 Rozkład Wykładniczy

●

T2=2 Rozkład Erlanga

Zmienna losowa oznaczająca czas obsługi pojedynczego zgłoszenia w gnieździe
Oi: (nrDz + i + 1) mod 6 + 1

●

O1=2 Rozkład Erlanga

●

O2=3 Rozkład Normalny

●

O3=4 Rozkład Jednostajny

Długość kolejki i-tego SMO Li: (nrDz + i) mod 2 + 1

●

L1=1 ograniczona

●

L2=2 nieograniczona

●

L3=1 ograniczona

Algorytmy kolejek (w przypadku istnienia kolejki z priorytetami należy
przyjąć, że zgłoszenia posiadają priorytety ALi: (nrDz + i + 2) mod 3 + 1

●

AL1=3 Z priorytetem

●

L2=1 FIFO

●

AL3=2 LIFO

Zmienna losowa oznaczająca wielkość paczki zgłoszeń (wchodzących w tej
samej chwili) j-tego strumienia Rj = (nrDz + i + 5) mod 3 + 1

●

R1=3 Rozkład Normalny

●

R2=1 Rozkład Wykładniczy

Liczba stanowisk obsługi w gniazdach Mi = (nrDz + i + 2) mod 4 + 1

●

M1=1

●

M2=2

●

M3=3

Zmienna losowa oznaczająca czas niecierpliwości zgłoszenia (gdy i = 0 =>

zgłoszenia cierpliwe)Ni = (nrDz + i) mod 4

●

N1=2 Erlanga

●

N2=3 Normalny

●

N3=0 cierpliwy

Sposób rozwiązania:

Kod źródłowy programu:

MAIN MODULE temp;
FROM IOMod IMPORT ReadKey;
{ Ņeby zatrzymaś ostatni ekran dla uŅytkownika }
FROM RandMod IMPORT RandomObj ,FetchSeed;
{ Ņeby generowaś liczby pseudolosowe i ustawiaś ziarno generatora }
FROM SimMod IMPORT StartSimulation,SimTime,StopSimulation,ResetSimTime,TriggerObj, Interrupt;
{ Ņeby můc symulowaś }
FROM StatMod IMPORT SINTEGER,RStatObj,SREAL,TSINTEGER,ITimedStatObj;
{ Ņeby můc wyznaczaś charakterystyki }
FROM GrpMod IMPORT StatQueueObj,StatStackObj,StatRankedObj,BStatGroupObj;
{ podstawowe struktury danych (z kolejkĻ prioretytowĻ jest troche inaczej) }
FROM MathMod IMPORT CEIL;
{ ceil przyda siÍ do zaokrĻgleŮ 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úś 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≥oszeŮ }
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 { wygeneruj tyle zgloszen,jaka jest wielkosc paczki }
NEW (k); { utworz nowego klienta }
liczbaJuzWygenerowanych := liczbaJuzWygenerowanych + 1; {zwieksz lczbe juz wygenerowanych}
ASK k TO Init (liczbaJuzWygenerowanych,UniformInt(1,5)); { przekaz id i losuj priorytet}
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:=2.0;
WHEN FIFO: { druga }
NEW(kFIFO);
kolejka:=kFIFO;
czasCierpliwosciKlienta:=3.0;
WHEN LIFO: { trzecia }
NEW(kLIFO);
kolejka:=kLIFO;
czasCierpliwosciKlienta:=0.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; { z pierwszej sie nie wracajĻ }

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; { jeden obsluzony wiecej }
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,MonZgloszenWKolejce
1,MonZgloszenWKolejce2,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("Podaj parametry :");
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("Parametry generatora nr 1:");
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("Parametry generatora nr 2:");
OUTPUT("");

REPEAT
OUTPUT("Podaj wartoúś oczekiwanĻ 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("*****Wyniki dzialania symulacji: ");
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;