Wojskowa Akademia Techniczna
im. Jarosława Dąbrowskiego
Podstawy Symulacji
Projekt
Prowadzący: dr inż. Jarosław Rulka
Wykonał:
Kamil Piersa
I7G2S1
Projekt - Podstawy Symulacji Strona 1
Zadanie:
p2
O2
T1 p1
O1 SMO
1-p1
SMO
O3
SMO
p3
Przy realizacji zadania należy przyjąć następujące dane z listy przedstawionej poniżej:
a) rozkład zmiennych Tj: (nrDz + i) mod 6 + 1; T1 =2
b) rozkład zmiennych Oi: (nrDz + i + 1) mod 6 + 1; O1=3, O2=4, O3= 5
c) Li: (nrDz + i) mod 2 + 1; 2 1 2
d) ALi: (nrDz + i + 2) mod 3 + 1; 1 2 3
e) Rj = (nrDz + i + 5) mod 3 + 1; 1
f) Mi = (nrDz + i + 2) mod 4 + 1; 2 3 4
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 gniez
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
Projekt - Podstawy Symulacji Strona 2
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.
Dane przyjęte do zadania laboratoryjnego:
Dla nrDz (numeru z dziennika) = 6.
Rozkłady zmiennych losowych oznaczających czas pomiędzy kolejnymi napływami zgłoszeń do systemu:
T1= rozkład Erlanga
Paczka R1 = 1
Rozkłady zmiennych losowych oznaczających czas obsługi pojedynczego zgłoszenia w gniez
dzie:
O1  rozkład Normalny
O2  rozkład Jednostajny
O3  rozkład Trójkątny
Długości kolejek SMO:
L1  nieograniczona
L2  ograniczona
L3  nieograniczona
Projekt - Podstawy Symulacji Strona 3
Algorytmy kolejek:
AL1  FIFO
AL2  LIFO
AL3  Z priorytetami
Zmienne losowe oznaczające czas niecierpliwości zgłoszenia:
N1  rozkład Wykładniczy
N2  rozkład Erlanga
N3  rozkład Normalny
Liczba stanowisk obsługi:
M1  2
M2  3
M3  4
Rozkłady:
Rozkład normalny
Gęstość prawdopodobieństwa:
dwuparametrowy o parametrach:
µ - wartość oczekiwana
à odchylenie standardowe
Rozkład wykładniczy
Projekt - Podstawy Symulacji Strona 4
Gęstość prawdopodobieństwa:
Dystrybuanta:
  wartość oczekiwana
Rozkład Erlanga:
Gęstość:
o parametrach:
k > 0
 >0
Rozkład Trójkątny:
Gęstość:
a  min
Projekt - Podstawy Symulacji Strona 5
b  mean
c  max
Rozkład jedostajny:
Sposób rozwiązania zadania:
Generowanie klientów odbywa się do pierwszej kolejki FIFO po jednym kliencie. Priorytet i prawdopodobieństwo przejść między elementami systemu zostaje przypisany
każdemu klientowi. Do pierwszego gniazda obsługi o rozkładzie Normalnym i ilości stanowisk obsługi = 2 gdzie jest obsługiwany klient przechodzi z pierwszej kolejki. Klient
wychodzi z pierwszego gniazda obsługi z nadanym prawdopodobieństwem do gniazda drugiego o rozkładzie Jednostajnym i ilości stanowisk obsługi = 3 lub do trzeciego o
rozkładzie Trójkątnym i ilości stanowisk obsługi = 4. Po wyjściu z gniazd może opuścić system, bądz
do niego powrócić. Jeśli klient powróci, zostanie tym samym
zmniejszone prawdopodobieństwo , że przy następnym wyborze zostanie w systemie. System został zaprojektowany tak, że może przeprowadzić symulację dla liczby
klientów określonych przez użytkownika.
Sposób wyznaczania charakterystyk:
Charakterystyki graniczne systemu wyznaczane sÄ… za pomocÄ… zmiennych monitorowanych odpowiedniego typu.
Czas przebywania zgłoszenia:
Zmienna typu SREAL monitoruje czas wejścia i wyjścia klienta z kolejki. Dzięki temu, wyliczany jest średni czas przebywania zgłoszenia w SMO po zakończeniu symulacji.
Liczba zgłoszeń:
Liczbę klientów przebywających w systemie oznacza zmienna typu TSINTEGER. Liczba zgłoszeń jest zmieniana przy wychodzeniu klienta w przypadkach: nie jest
obsługiwany, zniecierpliwiony odchodzi , nie może wejść.
Liczba zajętych kanałów:
Zmienna typu TSINTEGER zwiększana w chwili, gdy dany kanał rozpoczyna obsługę klienta, a zmniejszana, gdy ją kończy.
Projekt - Podstawy Symulacji Strona 6
Liczba zgłoszeń w kolejce:
Zmienna typu TSINTEGER obliczana dla poszczególnych SMO za pomocą odpowiednich metod obiektów StatQueueObj, StatStackObj lub StatRankedObj.
Prawdopodobieństwo obsłużenia zgłoszenia:
Jest to stosunek liczby obsłużonych klientów do liczby wszystkich klientów wchodzących do SMO.
Klient znajduje sie w SMO3
Przykład działania programu:
Klient znajduje sie w kolejce FIFO
Klient w SMO1
*******************************
Klient znajduje sie w kolejce FIFO
Wprowadzanie parametrow symulacji
Klient obsluzony w 1 gniezdzie
*******************************
Klient znajduje sie w kolejce PRIORYTETOWEJ
***Ilosc klientow:
Klient w SMO1
40
Klient obsluzony w 2 gniezdzie
Dlugosc kolejki:
!!!KLIENT OPUSCIL SYSTEM!!!
4
Klient znajduje sie w kolejce FIFO
***Parametr 'k' dla generatora o rozkladzie Erlanga:
Klient znajduje sie w kolejce FIFO
1
Klient znajduje sie w kolejce FIFO
Parametr 'lambda' dla generatora o rozkladzie Erlanga:
Klient znajduje sie w kolejce FIFO
2
Klient znajduje sie w kolejce FIFO
***Pierwszy parametr dla SMO o rozkladzie Normalnym:
Klient obsluzony w 3 gniezdzie
3
!!!KLIENT OPUSCIL SYSTEM!!!
Drugi parametr dla SMO o rozkladzie Normalnym:
Klient znajduje sie w SMO3
4
Klient znajduje sie w kolejce FIFO
***Pierwszy parametr dla SMO o rozkladzie Jednostajnym:
Klient obsluzony w 1 gniezdzie
5
Klient znajduje sie w kolejce LIFO
Drugi parametr dla SMO o rozkladzie Jednostajnym:
Klient w SMO1
6
Klient w SMO2
***Pierwszy (min) parametr dla SMO o rozkladzie Trojkatnym:
Klient znajduje sie w kolejce FIFO
7
Klient znajduje sie w kolejce FIFO
Drugi (mean) parametr dla SMO o rozkladzie Trojkatnym:
Klient obsluzony w 1 gniezdzie
8
Klient znajduje sie w kolejce PRIORYTETOWEJ
***Trzeci (max) parametr dla SMO o rozkladzie Trojkatnym:
Klient znajduje sie w kolejce FIFO
9
Klient w SMO1
**********************************
Klient znajduje sie w kolejce FIFO
S T A R T S Y M U L A C J I
Klient obsluzony w 2 gniezdzie
**********************************
!!!KLIENT OPUSCIL SYSTEM!!!
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient w SMO1
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce LIFO
Klient obsluzony w 3 gniezdzie
Klient w SMO2
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w SMO3
Klient w SMO1
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce PRIORYTETOWEJ
Klient znajduje sie w kolejce FIFO Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO Klient obsluzony w 1 gniezdzie
Projekt - Podstawy Symulacji Strona 7
Klient znajduje sie w kolejce PRIORYTETOWEJ !!!KLIENT OPUSCIL SYSTEM!!!
Klient znajduje sie w kolejce FIFO Klient znajduje sie w kolejce FIFO
Klient w SMO1 Klient obsluzony w 1 gniezdzie
Klient obsluzony w 3 gniezdzie Klient znajduje sie w kolejce PRIORYTETOWEJ
Klient znajduje sie w kolejce FIFO Klient obsluzony w 3 gniezdzie
Klient znajduje sie w SMO3 !!!KLIENT OPUSCIL SYSTEM!!!
Klient obsluzony w 1 gniezdzie Klient znajduje sie w SMO3
Klient znajduje sie w kolejce LIFO Klient obsluzony w 3 gniezdzie
Klient w SMO2 !!!KLIENT OPUSCIL SYSTEM!!!
Klient znajduje sie w kolejce FIFO
Klient w SMO1 ******************************************************************
Klient znajduje sie w kolejce FIFO S T A T Y S T Y K I
Klient znajduje sie w kolejce FIFO ******************************************************************
Klient obsluzony w 1 gniezdzie Sredni czas przebywania zgloszenia w systemie wynosi: 10.387065; Odchylenie
Klient znajduje sie w kolejce LIFO standardowe: 3.515962
Klient w SMO1 Sredni czas przebywania zgloszenia w SMO1 wynosi: 4.032524; Odchylenie
Klient znajduje sie w kolejce FIFO standardowe: 3.120331
Klient obsluzony w 2 gniezdzie Sredni czas przebywania zgloszenia w SMO2 wynosi: 5.759998; Odchylenie
!!!KLIENT OPUSCIL SYSTEM!!! standardowe: 0.579219
Klient w SMO2 Sredni czas przebywania zgloszenia w SMO3 wynosi: 10.544457; Odchylenie
Klient znajduje sie w kolejce FIFO standardowe: 2.419292
Klient znajduje sie w kolejce FIFO ******************************************************************
Klient obsluzony w 3 gniezdzie Srednia liczba zajetych kanalow w SMO1 wynosi: 0.708364; Odchylenie
Klient znajduje sie w kolejce FIFO standardowe: 0.454516
Klient znajduje sie w kolejce FIFO Srednia liczba zajetych kanalow w SMO2 wynosi: 0.445603; Odchylenie
Klient znajduje sie w kolejce FIFO standardowe: 0.497032
Klient znajduje sie w kolejce FIFO Srednia liczba zajetych kanalow w SMO3 wynosi: 0.793639; Odchylenie
Klient obsluzony w 2 gniezdzie standardowe: 0.404693
!!!KLIENT OPUSCIL SYSTEM!!! ******************************************************************
Klient znajduje sie w kolejce FIFO Srednia liczba zgloszen w kolejce FIFO wynosi: 26.489005; Odchylenie
Klient obsluzony w 1 gniezdzie standardowe: 14.651615
Klient znajduje sie w kolejce LIFO Srednia liczba zgloszen w kolejce LIFO wynosi: 3.145126; Odchylenie
Klient w SMO2 standardowe: 1.641815
Klient znajduje sie w kolejce FIFO Srednia liczba zgloszen w kolejce priorytetowej wynosi: 3.629279; Odchylenie
Klient w SMO1 standardowe: 1.690808
Klient znajduje sie w kolejce FIFO ******************************************************************
Klient znajduje sie w kolejce FIFO Prawdopodobienstwo obsluzenia zgloszenia w SMO1: 0.255744
Klient obsluzony w 1 gniezdzie Prawdopodobienstwo obsluzenia zgloszenia w SMO2: 0.850359
Klient znajduje sie w kolejce PRIORYTETOWEJ Prawdopodobienstwo obsluzenia zgloszenia w SMO3: 0.715126
Klient znajduje sie w SMO3 ******************************************************************
Klient znajduje sie w kolejce FIFO *************************************************
Klient w SMO1 !!!!!!!!!!K O N I E C S Y M U L A C J I!!!!!!!!!!
Klient obsluzony w 2 gniezdzie *************************************************
Koniec programu? tak(t)/nie(n)
Projekt - Podstawy Symulacji Strona 8
(**************KLIENT************)
Kod programu:
KlientObj = OBJECT(RandomObj)
KolejkaID: INTEGER;
MAIN MODULE genio; P1,P2,P3: REAL;
CzasWe,CzasWy : REAL;
FROM StatMod IMPORT SREAL, TSREAL, TSINTEGER, RStatObj, RTimedStatObj, CzasWeDoKol : REAL;
ITimedStatObj; J,K : REAL;
FROM RandMod IMPORT RandomObj; PriorytKlienta : INTEGER;
FROM SimMod IMPORT SimTime, StartSimulation, StopSimulation, TriggerObj, KolejkaFifo : FIFOObj;
Interrupt; KolejkaLifo : LIFOObj;
FROM GrpMod IMPORT QueueObj, StackObj, RankedObj; KolejkaPrio : PriorytObj;
VAR
MONCzasPrzebyw : SREAL; ASK METHOD Init (IN ziarno, prior : INTEGER; IN j,k : REAL; IN
MONCzasPrzebywSMO1, MONCzasPrzebywSMO2, MONCzasPrzebywSMO3: SREAL; kolfifo : FIFOObj; IN kollifo : LIFOObj;
MONKol1Zgl, MONKol2Zgl, MONKol3Zgl : TSINTEGER; IN kolprio: PriorytObj);
MONKol1Wyj, MONKol2Wyj, MONKol3Wyj : TSINTEGER; ASK METHOD ZmienPstwo;
MONZajKanalSMO1, MONZajKanalSMO2, MONZajKanalSMO3 : TSINTEGER; ASK METHOD ZmienKolejkaID(IN kolejkaid : INTEGER);
Niecierpliwi : TSINTEGER; TELL METHOD Niecierpliwosc;
ASK METHOD ZmienCzasWeDoKol (IN czas : REAL);
END OBJECT;
TYPE
SystemObj = OBJECT; FORWARD; (*********KOLEJKA FIFO***********)
FIFOObj = OBJECT; FORWARD; FIFOObj = OBJECT(QueueObj)
LIFOObj = OBJECT; FORWARD; Smo : SMONormalObj;
PriorytObj = OBJECT; FORWARD; Klient: KlientObj;
SMONormalObj = OBJECT; FORWARD;
SMOJednosObj = OBJECT; FORWARD; ASK METHOD Init (IN smo : SMONormalObj);
SMOTriangleObj = OBJECT; FORWARD; ASK METHOD Dodaj(IN klient : KlientObj);
GeneratorErlangObj = OBJECT; FORWARD; ASK METHOD Usun (IN klient : KlientObj);
END OBJECT;
(**************SYSTEM************)
SystemObj = OBJECT(RandomObj) (********KOLEJKA LIFO*************)
IloscWygen, MaxZgl : INTEGER; LIFOObj = OBJECT(StackObj)
Kol1 : FIFOObj; Smo: SMOJednosObj;
Kol2 : LIFOObj; Klient : KlientObj;
Kol3 : PriorytObj; Dlugosc : INTEGER;
Gen : GeneratorErlangObj;
Smo1 : SMONormalObj; ASK METHOD Init(IN dl : INTEGER; IN smo : SMOJednosObj);
Smo2 : SMOJednosObj; ASK METHOD Dodaj (IN klient: KlientObj);
Smo3 : SMOTriangleObj; ASK METHOD Usun (IN klient : KlientObj);
END OBJECT;
ASK METHOD Init (IN maxzgl : INTEGER; IN kol1 : FIFOObj; IN kol2 :
LIFOObj; (*******KOLEJKA PRIORYTETOWA*******)
IN Kol3 : PriorytObj; IN gen : GeneratorErlangObj; IN smo1 : PriorytObj = OBJECT(RankedObj)
SMONormalObj; IN smo2 : SMOJednosObj; IN smo3, Smo : SMOTriangleObj;
trojk : SMOTriangleObj; IN j,k,l, r,i, a,b, g1 : REAL; IN g2: Klient : KlientObj;
INTEGER; IN dlkol2, z: INTEGER);
ASK METHOD Init (IN smo : SMOTriangleObj);
ASK METHOD ZwiekszWyg; ASK METHOD Dodaj (IN klient: KlientObj);
ASK METHOD Start; ASK METHOD Usun (IN klient : KlientObj);
ASK METHOD ObjTerminate; OVERRIDE
END OBJECT; ASK METHOD Rank(IN k1, k2 : ANYOBJ):INTEGER;
END OBJECT;
Projekt - Podstawy Symulacji Strona 9
 A: REAL;
(*******SMO O ROZKLADZIE NORMALNYM**********) B: REAL;
SMONormalObj = OBJECT(TriggerObj) ASK METHOD Init(IN smoid, iloscstanow, ziarno : INTEGER; IN a,b:
System : SystemObj; REAL;
KolejkaPrzed : FIFOObj; IN kolza:LIFOObj; IN kolprzed : LIFOObj; IN system : SystemObj);
KolejkaZa1 : LIFOObj; TELL METHOD Obslugiwanie;
KolejkaZa2 : PriorytObj; OVERRIDE
Generator : RandomObj; ASK METHOD ObjTerminate;
Trojk : SMOTriangleObj; END OBJECT;
SmoID : INTEGER;
IloscStanowisk : INTEGER;
IloscZajetych : INTEGER; (************GENERATOR - ROZKLAD ERLANGA************)
R,I : REAL; GeneratorErlangObj = OBJECT(RandomObj)
System : SystemObj;
ASK METHOD Init(IN smoid, iloscstanow, ziarno : INTEGER; IN r,i : Kolejka : LIFOObj;
REAL; KolejkaFIFO : FIFOObj;
IN kolza1 :LIFOObj; IN kolza2 : PriorytObj; IN kolprzed : KolejkaPrior : PriorytObj;
FIFOObj; IN system : SystemObj; G1: REAL;
IN trojk : SMOTriangleObj); G2: INTEGER;
TELL METHOD Obslugiwanie; ASK METHOD Init(IN kolejkaprior : PriorytObj; IN kolejkalifo :
OVERRIDE LIFOObj;IN kolejkafifo : FIFOObj;
ASK METHOD ObjTerminate; IN ziarno : INTEGER ;IN g1 : REAL; IN g2: INTEGER; IN system
END OBJECT; : SystemObj);
TELL METHOD StworzKlienta;
(*******SMO O ROZKLADZIE TROJKATNYM**********) END OBJECT;
SMOTriangleObj = OBJECT(TriggerObj)
System : SystemObj;
KolejkaPrzed : PriorytObj; (**********I M P L E M E N T A C J A O B I E K T O W**********)
KolejkaZa : FIFOObj;
Generator : RandomObj; (*******SYSTEM*******)
SmoID : INTEGER; OBJECT SystemObj;
IloscStanowisk : INTEGER;
IloscZajetych : INTEGER; ASK METHOD Init (IN maxzgl : INTEGER; IN kol1 : FIFOObj; IN kol2 :
J: REAL; LIFOObj;
K: REAL; IN kol3 : PriorytObj; IN gen : GeneratorErlangObj; IN smo1 :
L: REAL; SMONormalObj; IN smo2 : SMOJednosObj;
IN smo3, trojk : SMOTriangleObj; IN j,k,l,r,i, a,b,g1 : REAL;
ASK METHOD Init (IN smoid, iloscstanow, ziarno : INTEGER; IN g2: INTEGER; IN dlkol2,z : INTEGER);
IN j,k,l: REAL; IN kolza: FIFOObj; IN kolprzed : PriorytObj;
IN system : SystemObj); BEGIN
TELL METHOD Obslugiwanie; ASK SELF TO SetSeed(z);
OVERRIDE NEW(kol1);
ASK METHOD ObjTerminate; NEW(kol2);
END OBJECT; NEW(kol3);
NEW(gen);
(*********SMO O ROZKLADZIE JEDNOSTAJNYM********) NEW(smo1);
SMOJednosObj = OBJECT(TriggerObj) NEW(smo2);
System : SystemObj; NEW(smo3);
KolejkaPrzed : LIFOObj; Kol1:=kol1;
KolejkaZa : LIFOObj; Kol2:=kol2;
Generator : RandomObj; Kol3:=kol3;
SmoID : INTEGER; Smo1:=smo1;
IloscStanowisk : INTEGER; Smo2:=smo2;
IloscZajetych : INTEGER; Smo3:=smo3;
Projekt - Podstawy Symulacji Strona 10
 Gen := gen; P2 := ASK SELF TO UniformReal(1.0, 100.0);
MaxZgl:=maxzgl; P3 := ASK SELF TO UniformReal(1.0, 100.0);
IloscWygen:=0; KolejkaFifo := kolfifo;
KolejkaLifo := kollifo;
ASK Kol1 TO Init(smo1); KolejkaPrio := kolprio;
ASK Kol2 TO Init(dlkol2, smo2); CzasWe := SimTime;
ASK Kol3 TO Init(smo3); END METHOD;
ASK Gen TO Init(kol3, kol2, kol1, ASK SELF TO UniformInt (1,
100) ,ASK SELF TO UniformReal(1.0,5.0), ASK METHOD ZmienPstwo;
ASK SELF TO UniformInt(5,15),SELF); BEGIN
ASK Smo1 TO Init(1,2, ASK SELF TO UniformInt(1,100),r,i, P1 := ASK SELF TO UniformReal(1.0, 100.0);
kol2, kol3, kol1, SELF, trojk ); P2 := ASK SELF TO UniformReal(1.0, 100.0);
ASK Smo2 TO Init(2,3, ASK SELF TO UniformInt(1,100),a,b, P3 := ASK SELF TO UniformReal(1.0, 100.0);
kol2, kol2,SELF); END METHOD;
ASK Smo3 TO Init(3,4, ASK SELF TO UniformInt(1,100),j,k,l,
kol1, kol3, SELF); ASK METHOD ZmienKolejkaID (IN kolejkaid : INTEGER);
END METHOD; BEGIN
KolejkaID := kolejkaid;
ASK METHOD Start; END METHOD;
BEGIN
TELL Gen TO StworzKlienta; TELL METHOD Niecierpliwosc;
TELL Smo1 TO Obslugiwanie; VAR
TELL Smo2 TO Obslugiwanie; czas : REAL;
TELL Smo3 TO Obslugiwanie; BEGIN
END METHOD;
IF KolejkaID=1
ASK METHOD ZwiekszWyg; czas := ABS(ASK SELF TO Exponential(1.0/ASK
BEGIN SELF TO UniformReal(1.0,20.0)));
INC(IloscWygen); WAIT DURATION(czas);
END METHOD; ASK KolejkaFifo TO RemoveThis(SELF);
ON INTERRUPT;
ASK METHOD ObjTerminate; END WAIT;
BEGIN ELSIF KolejkaID=2
DISPOSE(Kol1); czas := ABS(ASK SELF TO Erlang(ASK SELF TO
DISPOSE(Kol2); UniformReal(1.0,20.0),ASK SELF TO UniformInt(1,20)));
DISPOSE(Kol3); WAIT DURATION(czas);
DISPOSE(Gen); ASK KolejkaLifo TO RemoveThis(SELF);
DISPOSE(Smo1); ON INTERRUPT;
DISPOSE(Smo2); END WAIT;
DISPOSE(Smo3); ELSIF KolejkaID=3
END METHOD; czas := ABS(ASK SELF TO Normal(ASK SELF TO
END OBJECT; UniformReal(1.0,20.0),ASK SELF TO UniformReal(1.0,10.0)));
WAIT DURATION(czas);
ASK KolejkaPrio TO RemoveThis(SELF);
(*********KLIENT**********) ON INTERRUPT;
OBJECT KlientObj; END WAIT;
ASK METHOD Init (IN ziarno, prior : INTEGER; IN j,k : REAL; IN END IF;
kolfifo : FIFOObj; IN kollifo : LIFOObj; IN kolprio: PriorytObj); INC (Niecierpliwi);
BEGIN
SetSeed (ziarno);
PriorytKlienta := prior; END METHOD;
J := j;
K := k; ASK METHOD ZmienCzasWeDoKol (IN czas:REAL);
P1 := ASK SELF TO UniformReal(1.0, 100.0); BEGIN
Projekt - Podstawy Symulacji Strona 11
 CzasWeDoKol := czas; DISPOSE(klient);
END METHOD; DEC(MONKol2Zgl);
END OBJECT; END METHOD;
END OBJECT;
(*******KOLEJKA FIFO**********)
OBJECT FIFOObj; (*******KOLEJKA PRIORYTETOWA*******)
ASK METHOD Init ( IN smo : SMONormalObj); OBJECT PriorytObj;
BEGIN ASK METHOD Init ( IN smo: SMOTriangleObj);
Smo := smo; BEGIN
END METHOD; Smo :=smo;
END METHOD;
ASK METHOD Dodaj (IN klient : KlientObj);
BEGIN ASK METHOD Dodaj(IN klient: KlientObj);
Add(klient); BEGIN
ASK klient TO ZmienCzasWeDoKol(SimTime); Add(klient);
ASK klient TO ZmienKolejkaID(1); ASK klient TO ZmienCzasWeDoKol(SimTime);
OUTPUT("Klient znajduje sie w kolejce FIFO"); ASK klient TO ZmienKolejkaID(3);
TELL klient TO Niecierpliwosc; OUTPUT("Klient znajduje sie w kolejce PRIORYTETOWEJ");
INC(MONKol1Zgl); TELL klient TO Niecierpliwosc;
ASK Smo TO Release; INC(MONKol3Zgl);
END METHOD; ASK Smo TO Release;
END METHOD;
ASK METHOD Usun(IN klient: KlientObj);
BEGIN ASK METHOD Usun (IN klient : KlientObj);
ASK SELF TO RemoveThis(klient); BEGIN
DISPOSE (klient); ASK SELF TO RemoveThis(klient);
DEC(MONKol1Zgl); DISPOSE (klient);
END METHOD; DEC (MONKol3Zgl);
END OBJECT; END METHOD;
(********KOLEJKA LIFO********) ASK METHOD Rank (IN k1, k2 : ANYOBJ):INTEGER;
OBJECT LIFOObj; VAR
ASK METHOD Init(IN dl : INTEGER; IN smo : SMOJednosObj); klient1, klient2 :KlientObj;
BEGIN BEGIN
Smo:= smo; klient1 := k1;
Dlugosc := dl; klient2 := k2;
END METHOD; IF klient1.PriorytKlienta > klient2.PriorytKlienta
RETURN -1;
ASK METHOD Dodaj (IN klient: KlientObj); ELSIF klient1.PriorytKlienta = klient2.PriorytKlienta
BEGIN RETURN 0;
IF numberIn < Dlugosc ELSE RETURN 1;
Add (klient); END IF;
ASK klient TO ZmienCzasWeDoKol(SimTime); END METHOD;
ASK klient TO ZmienKolejkaID(2); END OBJECT;
OUTPUT("Klient znajduje sie w kolejce LIFO");
TELL klient TO Niecierpliwosc; (********SMO O ROZKLADZIE TROJKATNYM********)
INC(MONKol2Zgl); OBJECT SMOTriangleObj;
ASK Smo TO Release; ASK METHOD Init(IN smoid, iloscstanow, ziarno : INTEGER; IN j,k,l :
END IF; REAL; IN kolza:FIFOObj;
END METHOD; IN kolprzed : PriorytObj; IN system: SystemObj);
BEGIN
ASK METHOD Usun (IN klient: KlientObj); SmoID := smoid;
BEGIN IloscStanowisk := iloscstanow;
ASK SELF TO RemoveThis(klient); IloscZajetych := 0;
Projekt - Podstawy Symulacji Strona 12
 J := j;
K := k; (******SMO O ROZKLADZIE NORMALNYM**********)
L := l; OBJECT SMONormalObj;
KolejkaPrzed := kolprzed;
KolejkaZa :=kolza; ASK METHOD Init(IN smoid, iloscstanow, ziarno: INTEGER; IN r,i: REAL;
System :=system; IN kolza1 :LIFOObj; IN kolza2: PriorytObj; IN kolprzed :
NEW(Generator); FIFOObj;IN system : SystemObj;
ASK Generator TO SetSeed(ziarno); IN trojk : SMOTriangleObj);
END METHOD; BEGIN
SmoID :=smoid;
TELL METHOD Obslugiwanie; Trojk := trojk;
VAR IloscStanowisk :=iloscstanow;
klient: KlientObj; IloscZajetych:=0;
t: REAL; I:= i;
BEGIN R:=r;
IF IloscStanowisk > IloscZajetych KolejkaPrzed := kolprzed;
IF (ASK KolejkaPrzed TO numberIn) > 0 KolejkaZa1 := kolza1;
OUTPUT("Klient znajduje sie w SMO3"); KolejkaZa2 := kolza2;
INC(MONZajKanalSMO3); System := system;
NEW(Generator);
INC(IloscZajetych); ASK Generator TO SetSeed(ziarno);
klient := ASK KolejkaPrzed TO Remove; END METHOD;
ASK SELF TO Release;
Interrupt (klient,"Niecierpliwosc"); TELL METHOD Obslugiwanie;
t:= ABS(ASK Generator TO Triangular(J,K,L)); VAR
WAIT DURATION(t); klient: KlientObj;
END WAIT; t : REAL;
MONCzasPrzebywSMO3 := SimTime -klient.CzasWeDoKol; BEGIN
OUTPUT("Klient obsluzony w 3 gniezdzie"); IF IloscStanowisk > IloscZajetych
INC(MONKol3Wyj); IF (ASK KolejkaPrzed TO numberIn) > 0
IF (ASK klient TO P3)>= 50.0 OUTPUT("Klient w SMO1");
ASK klient TO ZmienPstwo; INC(MONZajKanalSMO1);
ASK KolejkaZa TO Dodaj(klient);
ELSE INC(IloscZajetych);
MONCzasPrzebyw := SimTime-klient.CzasWe; klient := ASK KolejkaPrzed TO Remove;
DISPOSE(klient); Interrupt(klient,"Niecierpliwosc");
OUTPUT("!!!KLIENT OPUSCIL SYSTEM!!!"); t := ABS(ASK Generator TO Normal(R,I));
END IF; WAIT DURATION(t);
DEC(IloscZajetych); END WAIT;
DEC(MONZajKanalSMO3); MONCzasPrzebywSMO1 := SimTime-klient.CzasWeDoKol;
ELSE OUTPUT("Klient obsluzony w 1 gniezdzie");
WAIT FOR SELF TO Fire; INC(MONKol1Wyj);
END WAIT; IF klient.P1 >= 50.0
END IF; WHILE KolejkaZa1.numberIn = KolejkaZa1.Dlugosc
END IF; WAIT FOR Trojk TO Fire();
END WAIT;
TELL SELF TO Obslugiwanie; END WHILE;
END METHOD; ASK KolejkaZa1 TO Dodaj(klient);
ELSE
ASK METHOD ObjTerminate; ASK KolejkaZa2 TO Dodaj(klient);
BEGIN END IF;
DISPOSE(Generator); DEC(IloscZajetych);
END METHOD; DEC(MONZajKanalSMO1);
END OBJECT; ELSE
Projekt - Podstawy Symulacji Strona 13
 WAIT FOR SELF TO Fire; ASK klient TO ZmienPstwo;
END WAIT; ASK KolejkaZa TO Dodaj(klient);
END IF; ELSE
END IF; MONCzasPrzebyw := SimTime-klient.CzasWe;
DISPOSE(klient);
TELL SELF TO Obslugiwanie; OUTPUT("!!!KLIENT OPUSCIL SYSTEM!!!");
END METHOD; END IF;
DEC(IloscZajetych);
ASK METHOD ObjTerminate; DEC(MONZajKanalSMO2);
BEGIN ELSE
DISPOSE(Generator); WAIT FOR SELF TO Fire;
END METHOD; END WAIT;
END OBJECT; END IF;
END IF;
(********SMO O ROZKLADZIE JEDNOSTAJNYM**********)
OBJECT SMOJednosObj; TELL SELF TO Obslugiwanie;
ASK METHOD Init (IN smoid, iloscstanow, ziarno : INTEGER; IN a,b: END METHOD;
REAL;
IN kolza:LIFOObj; IN kolprzed : LIFOObj; IN system : ASK METHOD ObjTerminate;
SystemObj); BEGIN
BEGIN DISPOSE(Generator);
SmoID := smoid; END METHOD;
IloscStanowisk :=iloscstanow; END OBJECT;
IloscZajetych := 0;
A :=a; (******GENERATOR O ROZKLADZIE ERLANGA*********)
B :=b; OBJECT GeneratorErlangObj;
KolejkaPrzed :=kolprzed; ASK METHOD Init (IN kolejkaprior :PriorytObj; IN kolejkalifo :
KolejkaZa :=kolza; LIFOObj; IN kolejkafifo: FIFOObj;
System := system; IN ziarno : INTEGER; IN g1: REAL; IN g2 : INTEGER; IN
NEW(Generator); system: SystemObj);
ASK Generator TO SetSeed(ziarno); BEGIN
END METHOD; Kolejka := kolejkalifo;
KolejkaFIFO:=kolejkafifo;
TELL METHOD Obslugiwanie; KolejkaPrior:= kolejkaprior;
VAR SetSeed(ziarno);
klient : KlientObj; System:=system;
t: REAL; G1 :=g1;
BEGIN G2 :=g2;
IF IloscStanowisk > IloscZajetych END METHOD;
IF (ASK KolejkaPrzed TO numberIn) >0
OUTPUT("Klient w SMO2"); TELL METHOD StworzKlienta;
INC(MONZajKanalSMO2); VAR
t: REAL;
INC(IloscZajetych); klient1,klient2,klient3 : KlientObj;
klient := ASK KolejkaPrzed TO Remove; BEGIN
Interrupt(klient, "Niecierpliwosc"); WHILE System.IloscWygen < System.MaxZgl-1
t := ABS(ASK Generator TO UniformReal(A,B)); t := ABS(ASK SELF TO Erlang(G1, G2));
WAIT DURATION(t); WAIT DURATION(t);
END WAIT; END WAIT;
MONCzasPrzebywSMO2 := SimTime- klient.CzasWeDoKol; NEW(klient1);
MONCzasPrzebyw := SimTime -klient.CzasWe; ASK System TO ZwiekszWyg;
OUTPUT("Klient obsluzony w 2 gniezdzie"); ASK klient1 TO Init(ASK SELF TO UniformInt (1, 100),
INC(MONKol2Wyj); ASK SELF TO UniformInt(1, 100), ASK SELF TO
IF (ASK klient TO P2)>= 80.0 UniformReal(1.0, 10.0), ASK SELF TO UniformReal(1.0, 10.0),KolejkaFIFO,
Projekt - Podstawy Symulacji Strona 14
 Kolejka, KolejkaPrior); OUTPUT("***Pierwszy (min) parametr dla SMO o rozkladzie Trojkatnym:
ASK KolejkaFIFO TO Dodaj(klient1); ");
INPUT(j);
END WHILE; OUTPUT("Drugi (mean) parametr dla SMO o rozkladzie Trojkatnym: ");
END METHOD; INPUT(k);
END OBJECT; OUTPUT("***Trzeci (max) parametr dla SMO o rozkladzie Trojkatnym: ");
INPUT(l);
VAR OUTPUT("**********************************");
System : SystemObj; OUTPUT("S T A R T S Y M U L A C J I");
Kolejka1 : FIFOObj; OUTPUT("**********************************");
Kolejka2 : LIFOObj;
Kolejka3 : PriorytObj; NEW(System);
SMO1 : SMONormalObj; ASK System TO
SMO2 : SMOJednosObj; Init(maxzgl+1,Kolejka1,Kolejka2,Kolejka3,Gen,SMO1,SMO2,SMO3,trojk,
SMO3, trojk : SMOTriangleObj; j,k,l,r,i,a,b,g1, g2, dlkol2,z);
Gen : GeneratorErlangObj; ASK System TO Start;
maxzgl : INTEGER; StartSimulation;
dlkol2, z : INTEGER; StopSimulation;
j,k,l : REAL; M1:=GETMONITOR(MONCzasPrzebyw,RStatObj);
r,i : REAL; M2:=GETMONITOR(MONCzasPrzebywSMO1,RStatObj);
a,b,g1 : REAL; M3:=GETMONITOR(MONCzasPrzebywSMO2,RStatObj);
g2 : INTEGER; M4:=GETMONITOR(MONCzasPrzebywSMO3,RStatObj);
M1,M2,M3,M4 : RStatObj; M5:=GETMONITOR(MONZajKanalSMO1,ITimedStatObj);
M5,M6,M7,M8,M9,M10,M11,M12,M13,M14 : ITimedStatObj; M6:=GETMONITOR(MONZajKanalSMO2,ITimedStatObj);
key : CHAR; M7:=GETMONITOR(MONZajKanalSMO3,ITimedStatObj);
M8:=GETMONITOR(MONKol1Zgl,ITimedStatObj);
BEGIN M9:=GETMONITOR(MONKol2Zgl,ITimedStatObj);
M10:=GETMONITOR(MONKol3Zgl,ITimedStatObj);
REPEAT M12:=GETMONITOR(MONKol1Wyj, ITimedStatObj);
OUTPUT("*******************************"); M13:=GETMONITOR(MONKol2Wyj, ITimedStatObj);
OUTPUT("Wprowadzanie parametrow symulacji"); M14:=GETMONITOR(MONKol3Wyj, ITimedStatObj);
OUTPUT("*******************************"); M11:=GETMONITOR(Niecierpliwi,ITimedStatObj);
OUTPUT("***Ilosc klientow: "); OUTPUT(" ");
INPUT(maxzgl); OUTPUT("*************************************************************
OUTPUT("Dlugosc kolejki:"); *****");
INPUT(dlkol2); OUTPUT("S T A T Y S T Y K I");
OUTPUT("*************************************************************
OUTPUT("***Parametr 'k' dla generatora o rozkladzie Erlanga: "); *****");
INPUT(g1); OUTPUT("Sredni czas przebywania zgloszenia w systemie wynosi: ",ASK
OUTPUT("Parametr 'lambda' dla generatora o rozkladzie Erlanga: "); M1 TO Mean,"; Odchylenie standardowe: ",ASK M1 TO StdDev);
INPUT(g2); OUTPUT("Sredni czas przebywania zgloszenia w SMO1 wynosi: ",ASK M2 TO
Mean,"; Odchylenie standardowe: ", ASK M2 TO StdDev);
OUTPUT("***Pierwszy parametr dla SMO o rozkladzie Normalnym: "); OUTPUT("Sredni czas przebywania zgloszenia w SMO2 wynosi: ",ASK M3 TO
INPUT(r); Mean,"; Odchylenie standardowe: ", ASK M3 TO StdDev);
OUTPUT("Drugi parametr dla SMO o rozkladzie Normalnym: "); OUTPUT("Sredni czas przebywania zgloszenia w SMO3 wynosi: ",ASK M4 TO
INPUT(i); Mean,"; Odchylenie standardowe: ", ASK M4 TO StdDev);
OUTPUT("*************************************************************
OUTPUT("***Pierwszy parametr dla SMO o rozkladzie Jednostajnym:"); *****");
INPUT(a); OUTPUT("Srednia liczba zajetych kanalow w SMO1 wynosi: ",ASK M5 TO
OUTPUT("Drugi parametr dla SMO o rozkladzie Jednostajnym:"); Mean,"; Odchylenie standardowe: ", ASK M5 TO StdDev);
INPUT(b); OUTPUT("Srednia liczba zajetych kanalow w SMO2 wynosi: ",ASK M6 TO
Mean,"; Odchylenie standardowe: ", ASK M6 TO StdDev);
Projekt - Podstawy Symulacji Strona 15
 OUTPUT("Srednia liczba zajetych kanalow w SMO3 wynosi: ",ASK M7 TO
Mean,"; Odchylenie standardowe: ", ASK M7 TO StdDev);
OUTPUT("*************************************************************
*****");
OUTPUT("Srednia liczba zgloszen w kolejce FIFO wynosi: ",ASK M8 TO
Mean,"; Odchylenie standardowe: ", ASK M8 TO StdDev);
OUTPUT("Srednia liczba zgloszen w kolejce LIFO wynosi: ",ASK M9 TO
Mean,"; Odchylenie standardowe: ", ASK M9 TO StdDev);
OUTPUT("Srednia liczba zgloszen w kolejce priorytetowej wynosi: ",ASK
M10 TO Mean,"; Odchylenie standardowe: ", ASK M10 TO StdDev);
OUTPUT("*************************************************************
*****");
OUTPUT("Prawdopodobienstwo obsluzenia zgloszenia w SMO1: ",ASK M12 TO
Mean / ASK M8 TO Mean);
OUTPUT("Prawdopodobienstwo obsluzenia zgloszenia w SMO2: ",ASK M13 TO
Mean / ASK M9 TO Mean);
IF (ASK M10 TO Mean) > 0.0
OUTPUT("Prawdopodobienstwo obsluzenia zgloszenia w SMO3: ",ASK M14 TO
Mean / ASK M10 TO Mean);
ELSE
OUTPUT("Prawdopodobienstwo obsluzenia zgloszenia w SMO3: 0");
END IF;
OUTPUT("*************************************************************
*****");
OUTPUT("*************************************************");
OUTPUT("!!!!!!!!!!K O N I E C S Y M U L A C J I!!!!!!!!!!");
OUTPUT("*************************************************");
OUTPUT("Koniec programu? tak(t)/nie(n) ");
INPUT(key);
UNTIL UPPER(key)<>'N';
END MODULE.
Projekt - Podstawy Symulacji Strona 16