Wojskowa Akademia Techniczna

Im. Jarosława Dąbrowskiego

Przedmiot:

PODSTAWY SYMULACJI

Sprawozdanie z projektu

Prowadzący: dr inż. Jarosław Rulka

Wykonał: szer. pchor. Piotr Jakubowski

Grupa: I8C1S1

Zadanie:

Napisad program symulujący SMO jak na rysunku:

Przy realizacji zadania należy przyjąd 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łoszeo 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);

SMO

O

2

SMO

O

3

SMO

O

1

T

1

p

2

p

3

T

2

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śd zgłoszeo jednocześnie napływających do systemu (1-R)
Pozostałe dane należy określad na początku symulacji. Dane wejściowe i wyniki odczytywane/zapisywane z/do
pliku.

Program powinien działad w trybie z i bez komunikatów ekranowych.



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łoszonego
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))



Charakterystyka używanych rozkładów

Rozkład Weibulla

Jest to ciągły rozkład prawdopodobieostwa często stosowany w analizie przeżycia do

modelowania sytuacji, gdy prawdopodobieostwo śmierci/awarii zmienia się w czasie. Gęstośd
obliczamy za pomocą poniższego wzoru:

Rozkład wykładniczy

Jest to rozkład zmiennej losowej opisujący sytuację, w której obiekt może przyjmowad stany

X i Y, przy czym obiekt w stanie X może ze stałym prawdopodobieostwem przejśd w stan Y w
jednostce czasu. Prawdopodobieostwo wyznaczane przez ten rozkład to prawdopodobieostwo
przejścia ze stanu X w stan Y w czasie δt. Poniżej prezentuje wykres gęstości prawdopodobieostwa.

Rozkład Erlanga

Rozkład ten jest ciągłym rozkładem, który przyjmuje wartości dodatnie dla wszystkich liczb
rzeczywistych większych od zera. Określony jest poprzez dwa parametry:



k – określający kształt



λ – współczynnik

Funkcja gęstości:

Rozkład normalny

Wzór na gęstośd prawdopodobieostwa

Rozkład jednostajny



Kod źródłowy

MAIN MODULE PJ;

FROM IOMod IMPORT ReadKey;
{ żeby zatrzymad ostatni ekran dla użytkownika }

FROM RandMod IMPORT RandomObj ,FetchSeed;
{ żeby generowad liczby pseudolosowe i ustawiad ziarno generatora }

FROM StatMod IMPORT SINTEGER,RStatObj,SREAL,TSINTEGER,ITimedStatObj;
{ żeby móc wyznaczad charakterystyki }

FROM

SimMod

IMPORT

StartSimulation,SimTime,StopSimulation,ResetSimTime,TriggerObj,

Interrupt;
{ żeby móc symulowad }

FROM GrpMod IMPORT StatQueueObj,StatStackObj,StatRankedObj,BStatGroupObj;
{ podstawowe struktury danych (z kolejką prioretytową jest troche inaczej) }

FROM MathMod IMPORT CEIL;



{ TYPY }
TYPE
{-----------------------------------------------------------------------------------------------------------------------------------}

{STRUKTURY}

AlgorytmKolejkowania = (FIFO,LIFO,Priorytetowa);



GeneratorObj = OBJECT; FORWARD;
KlientObj = OBJECT; FORWARD;
KolejkaObj = OBJECT; FORWARD;
GniazdoObj = OBJECT; FORWARD;
SystemObj = OBJECT; FORWARD;
{ definicje }

{-----------------------------------------------------------------------------------------------------------------------------------}

{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 { 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:=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; { 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,MonZ
gloszenWKolejce1,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("*******************************************************************");

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.



Przykład działającego projektu

*******************************************************************
PODAJ PARAMETRY:
*******************************************************************

Dlugosc kolejki nr 1 (>0):
30
Dlugosc kolejki nr 3 (>0) :
30
Ilosc klientow do wygenerowania przez kazdy z generatorow (>0):
120
Prawdopodobienstwo powrotu do gniazda 2:
0.1
Prawdopodobienstwo powrotu do gniazda 3:
0.2

*******************************************************************
PARAMETRY GENERATORA NR 1:
*******************************************************************

Podaj wartosc oczekiwana rozkladu wykladniczego generatora nr 1:
3.3
Podaj wartosc oczekiwana rozkladu normalnego generowanych paczek zg oszen nr 1:
3.4
Podaj odchylenie standartowe rozkladu normalnego generowanych paczek zg oszen nr 1:
0.5
Podaj ziarno dla pierwszego generatora
12
*******************************************************************
PARAMETRY GENERATORA NR 2:
*******************************************************************

Podaj wartosc oczekiwana rozkladu Erlanga:
0.9
Podaj liczb stopni swobody generatora 2 rozkladu Erlanga:
2
Podaj w.oczekiwana rozkladu wykladniczego generowanych paczek zgloszen:
0.8
Podaj ziarno dla drugiego generatora
11
Parametry gniazda nr 1:

Podaj wartosc oczekiwana rozkladu wykladniczego
0.8
Parametry gniazda nr 2:

Podaj wartosc oczekwana rozkladu normalnego:
0.6
Podaj odchylenie standartowe rozkladu normalnego:
1.1
Parametry gniazda nr 3:

Podaj parametr min rozkladu jednostajnego:
1.1
Podaj parametr max rozkladu jednostajnego (>min):
1.2


WYNIKI DZIALANIA SYMULACJI:


Liczba wygenerowanych: 246

Czas przebywania zgloszenia w systemie:
Wartosc srednia 13.525536
Odchylenie standardowe: 54.491058

Czas przebywania zgloszenia w SMO 1:
Wartosc srednia 624.907537
Odchylenie standardowe: 489.362956

Czas przebywania zgloszenia w SMO 2:
Wartosc srednia 0.736448
Odchylenie standardowe: 0.860476

Czas przebywania zgloszenia w SMO 3:
Wartosc srednia 1.323083
Odchylenie standardowe: 0.765520

Liczba klientow w systemie:
Wartosc srednia 19.902311
Odchylenie standardowe4.239851

Liczba zajetych kanalow w gniezdzie 1:
Wartosc srednia 0.998616
Odchylenie standardowe: 0.037180

Liczba zajetych kanalow w gniezdzie 2:
Wartosc srednia 1.666512
Odchylenie standardowe: 0.609879

Liczba zajetych kanalow w gniezdzie 3:
Wartosc srednia 2.998311
Odchylenie standardowe: 0.067240

Liczba klientow w kolejce 1 (priorytetowej):
Wartosc srednia 12.324233
Odchylenie standardowe: 8.206077

Liczba klientow w kolejce 2 (FIFO):
Wartosc srednia 6.416480
Odchylenie standardowe: 5.465738

Liczba klientow w kolejce 3 (LIFO):
Wartosc srednia 0.130334
Odchylenie standardowe: 0.863138

Prawdopodobienstwo obsluzenia klienta w systemie: 0.178862

Nacisnij cos, aby zakonczyc program.