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.

Przy realizacji zadania należy przyjąć następujące dane z listy przedstawionej poniżej:
a) rozkład zmiennych T

j

: (nrDz + i) mod 6 + 1;

b) rozkład zmiennych O

i

: (nrDz + i + 1) mod 6 + 1;

c) L

i

: (nrDz + i) mod 2 + 1;

d) AL

i

: (nrDz + i + 2) mod 3 + 1;

e) R

j

= (nrDz + i + 5) mod 3 + 1;

f) M

i

= (nrDz + i + 2) mod 4 + 1;

g) Blokowanie zgłoszeń 1. SMO;
h) Klienci niecierpliwi w SMO

i

: N

i

= (nrDz + i) mod 4 (ograniczony czas oczekiwania na rozpoczęcie

obsługi);

gdzie:

i – numer SMO;

j – numer strumienia;

T

j

– zmienna losowa oznaczająca czas pomiędzy kolejnymi napływami zgłoszeo do systemu;

O

i

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

N

i

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

R

j

– zmienna losowa oznaczająca wielkośd paczki zgłoszeo (wchodzących w tej samej chwili) j-tego

strumienia;

p

k

– prawdopodobieostwa przemieszczenia się zgłoszenia po danym łuku;

L

i

– 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

SMO

O

2

SMO

O

3

SMO

O

1

T

1

p

2

p

3

T

2

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 ź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;