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:

Napisać program symulujący SMO jak na rysunku:

Przy realizacji zadania należy przyjąć następujące dane z listy przedstawionej poniżej:

1. rozkład zmiennych T_j: (nrDz + i) mod 6 + 1;

2. rozkład zmiennych O_i: (nrDz + i + 1) mod 6 + 1;

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

4. AL_i: (nrDz + i + 2) mod 3 + 1;

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

6. M_i = (nrDz + i + 2) mod 4 + 1;

7. Blokowanie zgłoszeń 1. SMO;

8. 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łoszeń 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ść paczki zgłoszeń (wchodzących w tej samej chwili) j-tego strumienia;

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

L_i – 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. Wykładniczy

   2. Erlanga

   3. Normalny

   4. Jednostajny

   5. Trójkątny

   6. Weibulla

1. Długości kolejek pojedynczych SMO

   1. ograniczone (możliwe straty)

   2. nieograniczone

2. Algorytm kolejek:

   1. FIFO

   2. LIFO

   3. Z priorytetami

3. Liczba stanowisk obsługi w gniazdach (1-M)

4. Ilość zgłoszeń jednocześnie napływających do systemu (1-R)

Pozostałe dane należy określać na początku symulacji. Dane wejściowe i wyniki odczytywane/zapisywane z/do pliku.

Program powinien działać 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 prawdopodobieństwa często stosowany w analizie przeżycia do modelowania sytuacji, gdy prawdopodobieństwo śmierci/awarii zmienia się w czasie. Gęstość 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 przyjmować stany X i Y, przy czym obiekt w stanie X może ze stałym prawdopodobieństwem przejść w stan Y w jednostce czasu. Prawdopodobieństwo wyznaczane przez ten rozkład to prawdopodobieństwo przejścia ze stanu X w stan Y w czasie δt. Poniżej prezentuje wykres gęstości prawdopodobieństwa.

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ść prawdopodobieństwa

Rozkład jednostajny

• Kod źródłowy

MAIN MODULE PJ;

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 StatMod IMPORT SINTEGER,RStatObj,SREAL,TSINTEGER,ITimedStatObj;

{ żeby móc wyznaczać charakterystyki }

FROM SimMod IMPORT StartSimulation,SimTime,StopSimulation,ResetSimTime,TriggerObj, Interrupt;

{ żeby móc symulować }

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ść 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:=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,MonZgloszenWKolejce1,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.