Microsoft Word - PSY-projekt.doc

Projekt - Podstawy Symulacji

Strona 1

Wojskowa Akademia Techniczna

im. Jarosława Dąbrowskiego

P o d s t a w y S y m u l a c j i

P r o j e k t

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

Wykonał:

Kamil Piersa

I7G2S1

Projekt - Podstawy Symulacji

Strona 2

Zadanie:

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

: (nrDz + i) mod 6 + 1; T1 =2

b) rozkład zmiennych O

: (nrDz + i + 1) mod 6 + 1; O1=3, O2=4, O3= 5

c) L

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

d) AL

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

e) R

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

f) M

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

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

: N

= (nrDz + i) mod 4 (ograniczony czas oczekiwania na rozpoczęcie obsługi);

gdzie:
i – numer SMO;
j – numer strumienia;
T

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

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

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

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

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

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

AL.

– 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

SMO

1-p

Projekt - Podstawy Symulacji

Strona 3

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:

= rozkład Erlanga

Paczka R1 = 1

Rozkłady zmiennych losowych oznaczających czas obsługi pojedynczego zgłoszenia w gnieździe:

– rozkład Normalny

– rozkład Jednostajny

– rozkład Trójkątny

Długości kolejek SMO:

– nieograniczona

– ograniczona

– nieograniczona

Projekt - Podstawy Symulacji

Strona 4

Algorytmy kolejek:

– FIFO

– LIFO

– Z priorytetami

Zmienne losowe oznaczające czas niecierpliwości zgłoszenia:

– rozkład Wykładniczy

– rozkład Erlanga

– rozkład Normalny

Liczba stanowisk obsługi:

– 2

– 3

– 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 5

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 6

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ądź  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 7

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.

Przykład działania programu:

*******************************
Wprowadzanie parametrow symulacji
*******************************
***Ilosc klientow:
40
Dlugosc kolejki:
4
***Parametr 'k' dla generatora o rozkladzie Erlanga:
1
Parametr 'lambda' dla generatora o rozkladzie Erlanga:
2
***Pierwszy parametr dla SMO o rozkladzie Normalnym:
3
Drugi parametr dla SMO o rozkladzie Normalnym:
4
***Pierwszy parametr dla SMO o rozkladzie Jednostajnym:
5
Drugi parametr dla SMO o rozkladzie Jednostajnym:
6
***Pierwszy (min) parametr dla SMO o rozkladzie Trojkatnym:
7
Drugi (mean) parametr dla SMO o rozkladzie Trojkatnym:
8
***Trzeci (max) parametr dla SMO o rozkladzie Trojkatnym:
9
**********************************
S T A R T  S Y M U L A C J I
**********************************
Klient znajduje sie w kolejce FIFO
Klient w SMO1
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce LIFO
Klient w SMO2
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 PRIORYTETOWEJ

Klient znajduje sie w SMO3
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 PRIORYTETOWEJ
Klient w SMO1
Klient obsluzony w 2 gniezdzie
!!!KLIENT OPUSCIL SYSTEM!!!
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 3 gniezdzie
!!!KLIENT OPUSCIL SYSTEM!!!
Klient znajduje sie w SMO3
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce LIFO
Klient w SMO1
Klient w SMO2
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce PRIORYTETOWEJ
Klient znajduje sie w kolejce FIFO
Klient w SMO1
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 2 gniezdzie
!!!KLIENT OPUSCIL SYSTEM!!!
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 3 gniezdzie
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w SMO3
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO

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 8

Klient znajduje sie w kolejce PRIORYTETOWEJ
Klient znajduje sie w kolejce FIFO
Klient w SMO1
Klient obsluzony w 3 gniezdzie
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w SMO3
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce LIFO
Klient w SMO2
Klient znajduje sie w kolejce FIFO
Klient w SMO1
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce LIFO
Klient w SMO1
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 2 gniezdzie
!!!KLIENT OPUSCIL SYSTEM!!!
Klient w SMO2
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 3 gniezdzie
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 2 gniezdzie
!!!KLIENT OPUSCIL SYSTEM!!!
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce LIFO
Klient w SMO2
Klient znajduje sie w kolejce FIFO
Klient w SMO1
Klient znajduje sie w kolejce FIFO
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce PRIORYTETOWEJ
Klient znajduje sie w SMO3
Klient znajduje sie w kolejce FIFO
Klient w SMO1
Klient obsluzony w 2 gniezdzie

!!!KLIENT OPUSCIL SYSTEM!!!
Klient znajduje sie w kolejce FIFO
Klient obsluzony w 1 gniezdzie
Klient znajduje sie w kolejce PRIORYTETOWEJ
Klient obsluzony w 3 gniezdzie
!!!KLIENT OPUSCIL SYSTEM!!!
Klient znajduje sie w SMO3
Klient obsluzony w 3 gniezdzie
!!!KLIENT OPUSCIL SYSTEM!!!

******************************************************************
S T A T Y S T Y K I
******************************************************************
Sredni czas przebywania zgloszenia w systemie wynosi: 10.387065; Odchylenie
standardowe: 3.515962
Sredni czas przebywania zgloszenia w SMO1 wynosi: 4.032524; Odchylenie
standardowe: 3.120331
Sredni czas przebywania zgloszenia w SMO2 wynosi: 5.759998; Odchylenie
standardowe: 0.579219
Sredni czas przebywania zgloszenia w SMO3 wynosi: 10.544457; Odchylenie
standardowe: 2.419292
******************************************************************
Srednia liczba zajetych kanalow w SMO1 wynosi: 0.708364; Odchylenie
standardowe: 0.454516
Srednia liczba zajetych kanalow w SMO2 wynosi: 0.445603; Odchylenie
standardowe: 0.497032
Srednia liczba zajetych kanalow w SMO3 wynosi: 0.793639; Odchylenie
standardowe: 0.404693
******************************************************************
Srednia liczba zgloszen w kolejce FIFO wynosi: 26.489005; Odchylenie
standardowe: 14.651615
Srednia liczba zgloszen w kolejce LIFO wynosi: 3.145126; Odchylenie
standardowe: 1.641815
Srednia liczba zgloszen w kolejce priorytetowej wynosi: 3.629279; Odchylenie
standardowe: 1.690808
******************************************************************
Prawdopodobienstwo obsluzenia zgloszenia w SMO1: 0.255744
Prawdopodobienstwo obsluzenia zgloszenia w SMO2: 0.850359
Prawdopodobienstwo obsluzenia zgloszenia w SMO3: 0.715126
******************************************************************
*************************************************
!!!!!!!!!!K O N I E C S Y M U L A C J I!!!!!!!!!!
*************************************************

Koniec programu? tak(t)/nie(n)

Projekt - Podstawy Symulacji

Strona 9

Kod programu:

MAIN MODULE genio;

FROM StatMod IMPORT SREAL, TSREAL, TSINTEGER, RStatObj, RTimedStatObj,
ITimedStatObj;
FROM RandMod IMPORT RandomObj;
FROM SimMod IMPORT SimTime, StartSimulation, StopSimulation, TriggerObj,
Interrupt;
FROM GrpMod IMPORT QueueObj, StackObj, RankedObj;

VAR

MONCzasPrzebyw : SREAL;

MONCzasPrzebywSMO1, MONCzasPrzebywSMO2, MONCzasPrzebywSMO3: SREAL;

MONKol1Zgl, MONKol2Zgl, MONKol3Zgl : TSINTEGER;

MONKol1Wyj, MONKol2Wyj, MONKol3Wyj : TSINTEGER;

MONZajKanalSMO1, MONZajKanalSMO2, MONZajKanalSMO3 : TSINTEGER;

Niecierpliwi : TSINTEGER;

TYPE

SystemObj = OBJECT; FORWARD;

FIFOObj = OBJECT; FORWARD;

LIFOObj = OBJECT; FORWARD;

PriorytObj = OBJECT; FORWARD;

SMONormalObj = OBJECT; FORWARD;

SMOJednosObj = OBJECT; FORWARD;

SMOTriangleObj = OBJECT; FORWARD;

GeneratorErlangObj = OBJECT; FORWARD;

(**************SYSTEM************)
SystemObj = OBJECT(RandomObj)

IloscWygen, MaxZgl : INTEGER;

Kol1 : FIFOObj;

Kol2 : LIFOObj;

Kol3 : PriorytObj;

Gen : GeneratorErlangObj;

Smo1 : SMONormalObj;

Smo2 : SMOJednosObj;

Smo3 : SMOTriangleObj;

ASK METHOD Init (IN maxzgl : INTEGER; IN kol1 : FIFOObj; IN kol2 :

LIFOObj;

IN Kol3 : PriorytObj; IN gen : GeneratorErlangObj; IN smo1 :

SMONormalObj; IN smo2 : SMOJednosObj; IN smo3,

trojk : SMOTriangleObj; IN j,k,l, r,i, a,b, g1 : REAL; IN g2:

INTEGER; IN dlkol2, z: INTEGER);

ASK METHOD ZwiekszWyg;

ASK METHOD Start;

ASK METHOD ObjTerminate;

END OBJECT;

(**************KLIENT************)
KlientObj = OBJECT(RandomObj)

KolejkaID: INTEGER;

P1,P2,P3: REAL;

CzasWe,CzasWy : REAL;

CzasWeDoKol : REAL;

J,K : REAL;

PriorytKlienta : INTEGER;

KolejkaFifo

: FIFOObj;

KolejkaLifo

: LIFOObj;

KolejkaPrio

: PriorytObj;

ASK METHOD Init (IN ziarno, prior : INTEGER; IN j,k : REAL; IN

kolfifo : FIFOObj; IN kollifo : LIFOObj;

IN kolprio: PriorytObj);

ASK METHOD ZmienPstwo;

ASK METHOD ZmienKolejkaID(IN kolejkaid : INTEGER);

TELL METHOD Niecierpliwosc;

ASK METHOD ZmienCzasWeDoKol (IN czas : REAL);

END OBJECT;

(*********KOLEJKA FIFO***********)
FIFOObj = OBJECT(QueueObj)

Smo : SMONormalObj;

Klient: KlientObj;

ASK METHOD Init (IN smo : SMONormalObj);

ASK METHOD Dodaj(IN klient : KlientObj);

ASK METHOD Usun (IN klient : KlientObj);

END OBJECT;

(********KOLEJKA LIFO*************)
LIFOObj = OBJECT(StackObj)

Smo: SMOJednosObj;

Klient : KlientObj;

Dlugosc : INTEGER;

ASK METHOD Init(IN dl : INTEGER; IN smo : SMOJednosObj);

ASK METHOD Dodaj (IN klient: KlientObj);

ASK METHOD Usun (IN klient : KlientObj);

END OBJECT;

(*******KOLEJKA PRIORYTETOWA*******)
PriorytObj = OBJECT(RankedObj)

Smo : SMOTriangleObj;

Klient : KlientObj;

ASK METHOD Init (IN smo : SMOTriangleObj);

ASK METHOD Dodaj (IN klient: KlientObj);

ASK METHOD Usun (IN klient : KlientObj);

OVERRIDE

ASK METHOD Rank(IN k1, k2 : ANYOBJ):INTEGER;

END OBJECT;

Projekt - Podstawy Symulacji

Strona 10

(*******SMO O ROZKLADZIE NORMALNYM**********)

SMONormalObj = OBJECT(TriggerObj)

System : SystemObj;

KolejkaPrzed : FIFOObj;

KolejkaZa1 : LIFOObj;

KolejkaZa2 : PriorytObj;

Generator : RandomObj;

Trojk

: SMOTriangleObj;

SmoID : INTEGER;

IloscStanowisk : INTEGER;

IloscZajetych : INTEGER;

R,I : REAL;

ASK METHOD Init(IN smoid, iloscstanow, ziarno : INTEGER; IN r,i :

REAL;

IN kolza1 :LIFOObj; IN kolza2 : PriorytObj; IN kolprzed :

FIFOObj; IN system : SystemObj;

IN trojk : SMOTriangleObj);

TELL METHOD Obslugiwanie;

OVERRIDE

ASK METHOD ObjTerminate;

END OBJECT;

(*******SMO O ROZKLADZIE TROJKATNYM**********)
SMOTriangleObj = OBJECT(TriggerObj)

System : SystemObj;

KolejkaPrzed : PriorytObj;

KolejkaZa : FIFOObj;

Generator : RandomObj;

SmoID : INTEGER;

IloscStanowisk : INTEGER;

IloscZajetych : INTEGER;

J: REAL;

K: REAL;

L: REAL;

ASK METHOD Init (IN smoid, iloscstanow, ziarno : INTEGER;

IN j,k,l: REAL; IN kolza: FIFOObj; IN kolprzed : PriorytObj;

IN system : SystemObj);

TELL METHOD Obslugiwanie;

OVERRIDE

ASK METHOD ObjTerminate;

END OBJECT;

(*********SMO O ROZKLADZIE JEDNOSTAJNYM********)
SMOJednosObj = OBJECT(TriggerObj)

System : SystemObj;

KolejkaPrzed : LIFOObj;

KolejkaZa : LIFOObj;

Generator : RandomObj;

SmoID : INTEGER;

IloscStanowisk : INTEGER;

IloscZajetych : INTEGER;

A: REAL;

B: REAL;

ASK METHOD Init(IN smoid, iloscstanow, ziarno : INTEGER; IN a,b:

REAL;

IN kolza:LIFOObj; IN kolprzed : LIFOObj; IN system : SystemObj);

TELL METHOD Obslugiwanie;

OVERRIDE

ASK METHOD ObjTerminate;

END OBJECT;

(************GENERATOR - ROZKLAD ERLANGA************)
GeneratorErlangObj = OBJECT(RandomObj)

System : SystemObj;

Kolejka : LIFOObj;

KolejkaFIFO : FIFOObj;

KolejkaPrior : PriorytObj;

G1: REAL;

G2: INTEGER;

ASK METHOD Init(IN kolejkaprior : PriorytObj; IN kolejkalifo :

LIFOObj;IN kolejkafifo : FIFOObj;

IN ziarno : INTEGER ;IN g1 : REAL; IN g2: INTEGER; IN system

: SystemObj);

TELL METHOD StworzKlienta;

END OBJECT;

(**********I M P L E M E N T A C J A O B I E K T O W**********)

(*******SYSTEM*******)
OBJECT SystemObj;

ASK METHOD Init (IN maxzgl : INTEGER; IN kol1 : FIFOObj; IN kol2 :

LIFOObj;

IN kol3 : PriorytObj; IN gen : GeneratorErlangObj; IN smo1 :

SMONormalObj; IN smo2 : SMOJednosObj;

IN smo3, trojk : SMOTriangleObj; IN j,k,l,r,i, a,b,g1 : REAL;

IN g2: INTEGER; IN dlkol2,z : INTEGER);

BEGIN

ASK SELF TO SetSeed(z);

NEW(kol1);

NEW(kol2);

NEW(kol3);

NEW(gen);

NEW(smo1);

NEW(smo2);

NEW(smo3);

Kol1:=kol1;

Kol2:=kol2;

Kol3:=kol3;

Smo1:=smo1;

Smo2:=smo2;

Smo3:=smo3;

Projekt - Podstawy Symulacji

Strona 11

Gen := gen;

MaxZgl:=maxzgl;

IloscWygen:=0;

ASK Kol1 TO Init(smo1);

ASK Kol2 TO Init(dlkol2, smo2);

ASK Kol3 TO Init(smo3);

ASK Gen TO Init(kol3, kol2, kol1, ASK SELF TO UniformInt (1,

100) ,ASK SELF TO UniformReal(1.0,5.0),

ASK SELF TO UniformInt(5,15),SELF);

ASK Smo1 TO Init(1,2, ASK SELF TO UniformInt(1,100),r,i,

kol2, kol3, kol1, SELF, trojk );

ASK Smo2 TO Init(2,3, ASK SELF TO UniformInt(1,100),a,b,

kol2, kol2,SELF);

ASK Smo3 TO Init(3,4, ASK SELF TO UniformInt(1,100),j,k,l,

kol1, kol3, SELF);

END METHOD;

ASK METHOD Start;

BEGIN

TELL Gen TO StworzKlienta;

TELL Smo1 TO Obslugiwanie;

TELL Smo2 TO Obslugiwanie;

TELL Smo3 TO Obslugiwanie;

END METHOD;

ASK METHOD ZwiekszWyg;

BEGIN

INC(IloscWygen);

END METHOD;

ASK METHOD ObjTerminate;

BEGIN

DISPOSE(Kol1);

DISPOSE(Kol2);

DISPOSE(Kol3);

DISPOSE(Gen);

DISPOSE(Smo1);

DISPOSE(Smo2);

DISPOSE(Smo3);

END METHOD;

END OBJECT;

(*********KLIENT**********)
OBJECT KlientObj;

ASK METHOD Init (IN ziarno, prior : INTEGER; IN j,k : REAL; IN

kolfifo : FIFOObj; IN kollifo : LIFOObj; IN kolprio: PriorytObj);

BEGIN

SetSeed (ziarno);

PriorytKlienta := prior;

J := j;

K := k;

P1 := ASK SELF TO UniformReal(1.0, 100.0);

P2 := ASK SELF TO UniformReal(1.0, 100.0);

P3 := ASK SELF TO UniformReal(1.0, 100.0);

KolejkaFifo := kolfifo;

KolejkaLifo := kollifo;

KolejkaPrio := kolprio;

CzasWe := SimTime;

END METHOD;

ASK METHOD ZmienPstwo;

BEGIN

P1 := ASK SELF TO UniformReal(1.0, 100.0);

P2 := ASK SELF TO UniformReal(1.0, 100.0);

P3 := ASK SELF TO UniformReal(1.0, 100.0);

END METHOD;

ASK METHOD ZmienKolejkaID (IN kolejkaid : INTEGER);

BEGIN

KolejkaID := kolejkaid;

END METHOD;

TELL METHOD Niecierpliwosc;

VAR

czas : REAL;

BEGIN

IF KolejkaID=1

czas := ABS(ASK SELF TO Exponential(1.0/ASK

SELF TO UniformReal(1.0,20.0)));

WAIT DURATION(czas);

ASK KolejkaFifo TO RemoveThis(SELF);

ON INTERRUPT;

END WAIT;

ELSIF KolejkaID=2

czas := ABS(ASK SELF TO Erlang(ASK SELF TO

UniformReal(1.0,20.0),ASK SELF TO UniformInt(1,20)));

WAIT DURATION(czas);

ASK KolejkaLifo TO RemoveThis(SELF);

ON INTERRUPT;

END WAIT;

ELSIF KolejkaID=3

czas := ABS(ASK SELF TO Normal(ASK SELF TO

UniformReal(1.0,20.0),ASK SELF TO UniformReal(1.0,10.0)));

WAIT DURATION(czas);

ASK KolejkaPrio TO RemoveThis(SELF);

ON INTERRUPT;

END WAIT;

END IF;

INC (Niecierpliwi);

END METHOD;

ASK METHOD ZmienCzasWeDoKol (IN czas:REAL);

BEGIN

Projekt - Podstawy Symulacji

Strona 12

CzasWeDoKol := czas;

END METHOD;

END OBJECT;

(*******KOLEJKA FIFO**********)
OBJECT FIFOObj;

ASK METHOD Init ( IN smo : SMONormalObj);

BEGIN

Smo := smo;

END METHOD;

ASK METHOD Dodaj (IN klient : KlientObj);

BEGIN

Add(klient);

ASK klient TO ZmienCzasWeDoKol(SimTime);

ASK klient TO ZmienKolejkaID(1);

OUTPUT("Klient znajduje sie w kolejce FIFO");

TELL klient TO Niecierpliwosc;

INC(MONKol1Zgl);

ASK Smo TO Release;

END METHOD;

ASK METHOD Usun(IN klient: KlientObj);

BEGIN

ASK SELF TO RemoveThis(klient);

DISPOSE (klient);

DEC(MONKol1Zgl);

END METHOD;

END OBJECT;

(********KOLEJKA LIFO********)
OBJECT LIFOObj;

ASK METHOD Init(IN dl : INTEGER; IN smo : SMOJednosObj);

BEGIN

Smo:= smo;

Dlugosc := dl;

END METHOD;

ASK METHOD Dodaj (IN klient: KlientObj);

BEGIN

IF numberIn < Dlugosc

Add (klient);

ASK klient TO ZmienCzasWeDoKol(SimTime);

ASK klient TO ZmienKolejkaID(2);

OUTPUT("Klient znajduje sie w kolejce LIFO");

TELL klient TO Niecierpliwosc;

INC(MONKol2Zgl);

ASK Smo TO Release;

END IF;

END METHOD;

ASK METHOD Usun (IN klient: KlientObj);

BEGIN

ASK SELF TO RemoveThis(klient);

DISPOSE(klient);

DEC(MONKol2Zgl);

END METHOD;

END OBJECT;

(*******KOLEJKA PRIORYTETOWA*******)
OBJECT PriorytObj;

ASK METHOD Init ( IN smo: SMOTriangleObj);

BEGIN

Smo :=smo;

END METHOD;

ASK METHOD Dodaj(IN klient: KlientObj);

BEGIN

Add(klient);

ASK klient TO ZmienCzasWeDoKol(SimTime);

ASK klient TO ZmienKolejkaID(3);

OUTPUT("Klient znajduje sie w kolejce PRIORYTETOWEJ");

TELL klient TO Niecierpliwosc;

INC(MONKol3Zgl);

ASK Smo TO Release;

END METHOD;

ASK METHOD Usun (IN klient : KlientObj);

BEGIN

ASK SELF TO RemoveThis(klient);

DISPOSE (klient);

DEC (MONKol3Zgl);

END METHOD;

ASK METHOD Rank (IN k1, k2 : ANYOBJ):INTEGER;

VAR

klient1, klient2 :KlientObj;

BEGIN

klient1 := k1;

klient2 := k2;

IF klient1.PriorytKlienta > klient2.PriorytKlienta

RETURN -1;

ELSIF klient1.PriorytKlienta = klient2.PriorytKlienta

RETURN 0;

ELSE RETURN 1;

END IF;

END METHOD;

END OBJECT;

(********SMO O ROZKLADZIE TROJKATNYM********)
OBJECT SMOTriangleObj;

ASK METHOD Init(IN smoid, iloscstanow, ziarno : INTEGER; IN j,k,l :

REAL; IN kolza:FIFOObj;

IN kolprzed : PriorytObj; IN system: SystemObj);

BEGIN

SmoID := smoid;

IloscStanowisk := iloscstanow;

IloscZajetych := 0;

Projekt - Podstawy Symulacji

Strona 13

J := j;

K := k;

L := l;

KolejkaPrzed := kolprzed;

KolejkaZa :=kolza;

System :=system;

NEW(Generator);

ASK Generator TO SetSeed(ziarno);

END METHOD;

TELL METHOD Obslugiwanie;

VAR

klient: KlientObj;

t: REAL;

BEGIN

IF IloscStanowisk > IloscZajetych

IF (ASK KolejkaPrzed TO numberIn) > 0

OUTPUT("Klient znajduje sie w SMO3");

INC(MONZajKanalSMO3);

INC(IloscZajetych);

klient := ASK KolejkaPrzed TO Remove;

ASK SELF TO Release;

Interrupt (klient,"Niecierpliwosc");

t:= ABS(ASK Generator TO Triangular(J,K,L));

WAIT DURATION(t);

END WAIT;

MONCzasPrzebywSMO3 := SimTime -klient.CzasWeDoKol;

OUTPUT("Klient obsluzony w 3 gniezdzie");

INC(MONKol3Wyj);

IF (ASK klient TO P3)>= 50.0

ASK klient TO ZmienPstwo;

ASK KolejkaZa TO Dodaj(klient);

ELSE

MONCzasPrzebyw := SimTime-klient.CzasWe;

DISPOSE(klient);

OUTPUT("!!!KLIENT OPUSCIL SYSTEM!!!");

END IF;

DEC(IloscZajetych);

DEC(MONZajKanalSMO3);

ELSE

WAIT FOR SELF TO Fire;

END WAIT;

END IF;

TELL SELF TO Obslugiwanie;

END METHOD;

ASK METHOD ObjTerminate;

BEGIN

DISPOSE(Generator);

END METHOD;

END OBJECT;

(******SMO O ROZKLADZIE NORMALNYM**********)
OBJECT SMONormalObj;

ASK METHOD Init(IN smoid, iloscstanow, ziarno: INTEGER; IN r,i: REAL;

IN kolza1 :LIFOObj; IN kolza2: PriorytObj; IN kolprzed :

FIFOObj;IN system : SystemObj;

IN trojk : SMOTriangleObj);

BEGIN

SmoID :=smoid;

Trojk := trojk;

IloscStanowisk :=iloscstanow;

IloscZajetych:=0;

I:= i;

R:=r;

KolejkaPrzed := kolprzed;

KolejkaZa1 := kolza1;

KolejkaZa2 := kolza2;

System := system;

NEW(Generator);

ASK Generator TO SetSeed(ziarno);

END METHOD;

TELL METHOD Obslugiwanie;

VAR

klient: KlientObj;

t : REAL;

BEGIN

IF IloscStanowisk > IloscZajetych

IF (ASK KolejkaPrzed TO numberIn) > 0

OUTPUT("Klient w SMO1");

INC(MONZajKanalSMO1);

INC(IloscZajetych);

klient := ASK KolejkaPrzed TO Remove;

Interrupt(klient,"Niecierpliwosc");

t := ABS(ASK Generator TO Normal(R,I));

WAIT DURATION(t);

END WAIT;

MONCzasPrzebywSMO1 := SimTime-klient.CzasWeDoKol;

OUTPUT("Klient obsluzony w 1 gniezdzie");

INC(MONKol1Wyj);

IF klient.P1 >= 50.0

WHILE KolejkaZa1.numberIn = KolejkaZa1.Dlugosc

WAIT FOR Trojk TO Fire();

END WAIT;

END WHILE;

ASK KolejkaZa1 TO Dodaj(klient);

ELSE

ASK KolejkaZa2 TO Dodaj(klient);

END IF;

DEC(IloscZajetych);

DEC(MONZajKanalSMO1);

ELSE

Projekt - Podstawy Symulacji

Strona 14

WAIT FOR SELF TO Fire;

END WAIT;

END IF;

TELL SELF TO Obslugiwanie;

END METHOD;

ASK METHOD ObjTerminate;

BEGIN

DISPOSE(Generator);

END METHOD;

END OBJECT;

(********SMO O ROZKLADZIE JEDNOSTAJNYM**********)
OBJECT SMOJednosObj;

ASK METHOD Init (IN smoid, iloscstanow, ziarno : INTEGER; IN a,b:

REAL;

IN kolza:LIFOObj; IN kolprzed : LIFOObj; IN system :

SystemObj);

BEGIN

SmoID := smoid;

IloscStanowisk :=iloscstanow;

IloscZajetych := 0;

A :=a;

B :=b;

KolejkaPrzed :=kolprzed;

KolejkaZa :=kolza;

System := system;

NEW(Generator);

ASK Generator TO SetSeed(ziarno);

END METHOD;

TELL METHOD Obslugiwanie;

VAR

klient : KlientObj;

t: REAL;

BEGIN

IF IloscStanowisk > IloscZajetych

IF (ASK KolejkaPrzed TO numberIn) >0

OUTPUT("Klient w SMO2");

INC(MONZajKanalSMO2);

INC(IloscZajetych);

klient := ASK KolejkaPrzed TO Remove;

Interrupt(klient, "Niecierpliwosc");

t := ABS(ASK Generator TO UniformReal(A,B));

WAIT DURATION(t);

END WAIT;

MONCzasPrzebywSMO2 := SimTime- klient.CzasWeDoKol;

MONCzasPrzebyw := SimTime -klient.CzasWe;

OUTPUT("Klient obsluzony w 2 gniezdzie");

INC(MONKol2Wyj);

IF (ASK klient TO P2)>= 80.0

ASK klient TO ZmienPstwo;

ASK KolejkaZa TO Dodaj(klient);

ELSE

MONCzasPrzebyw := SimTime-klient.CzasWe;

DISPOSE(klient);

OUTPUT("!!!KLIENT OPUSCIL SYSTEM!!!");

END IF;

DEC(IloscZajetych);

DEC(MONZajKanalSMO2);

ELSE

WAIT FOR SELF TO Fire;

END WAIT;

END IF;

TELL SELF TO Obslugiwanie;

END METHOD;

ASK METHOD ObjTerminate;

BEGIN

DISPOSE(Generator);

END METHOD;

END OBJECT;

(******GENERATOR O ROZKLADZIE ERLANGA*********)
OBJECT GeneratorErlangObj;

ASK METHOD Init (IN kolejkaprior :PriorytObj; IN kolejkalifo :

LIFOObj; IN kolejkafifo: FIFOObj;

IN ziarno : INTEGER; IN g1: REAL; IN g2 : INTEGER; IN

system: SystemObj);

BEGIN

Kolejka := kolejkalifo;

KolejkaFIFO:=kolejkafifo;

KolejkaPrior:= kolejkaprior;

SetSeed(ziarno);

System:=system;

G1 :=g1;

G2 :=g2;

END METHOD;

TELL METHOD StworzKlienta;

VAR

t: REAL;

klient1,klient2,klient3 : KlientObj;

BEGIN

WHILE System.IloscWygen < System.MaxZgl-1

t := ABS(ASK SELF TO Erlang(G1, G2));

WAIT DURATION(t);

END WAIT;

NEW(klient1);

ASK System TO ZwiekszWyg;

ASK klient1 TO Init(ASK SELF TO UniformInt (1, 100),

ASK SELF TO UniformInt(1, 100),

ASK SELF TO

UniformReal(1.0, 10.0), ASK SELF TO UniformReal(1.0, 10.0),KolejkaFIFO,

Projekt - Podstawy Symulacji

Strona 15

Kolejka, KolejkaPrior);

ASK KolejkaFIFO TO Dodaj(klient1);

END WHILE;

END METHOD;

END OBJECT;

VAR

System : SystemObj;

Kolejka1 : FIFOObj;

Kolejka2 : LIFOObj;

Kolejka3 : PriorytObj;

SMO1 : SMONormalObj;

SMO2 : SMOJednosObj;

SMO3, trojk : SMOTriangleObj;

Gen : GeneratorErlangObj;

maxzgl : INTEGER;

dlkol2, z : INTEGER;

j,k,l : REAL;

r,i : REAL;

a,b,g1 : REAL;

g2 : INTEGER;

M1,M2,M3,M4 : RStatObj;

M5,M6,M7,M8,M9,M10,M11,M12,M13,M14 : ITimedStatObj;

key : CHAR;

BEGIN

REPEAT

OUTPUT("*******************************");

OUTPUT("Wprowadzanie parametrow symulacji");

OUTPUT("*******************************");

OUTPUT("***Ilosc klientow: ");

INPUT(maxzgl);

OUTPUT("Dlugosc kolejki:");

INPUT(dlkol2);

OUTPUT("***Parametr 'k' dla generatora o rozkladzie Erlanga: ");

INPUT(g1);

OUTPUT("Parametr 'lambda' dla generatora o rozkladzie Erlanga: ");

INPUT(g2);

OUTPUT("***Pierwszy parametr dla SMO o rozkladzie Normalnym: ");

INPUT(r);

OUTPUT("Drugi parametr dla SMO o rozkladzie Normalnym: ");

INPUT(i);

OUTPUT("***Pierwszy parametr dla SMO o rozkladzie Jednostajnym:");

INPUT(a);

OUTPUT("Drugi parametr dla SMO o rozkladzie Jednostajnym:");

INPUT(b);

OUTPUT("***Pierwszy (min) parametr dla SMO o rozkladzie Trojkatnym:

");

INPUT(j);

OUTPUT("Drugi (mean) parametr dla SMO o rozkladzie Trojkatnym: ");

INPUT(k);

OUTPUT("***Trzeci (max) parametr dla SMO o rozkladzie Trojkatnym: ");

INPUT(l);

OUTPUT("**********************************");

OUTPUT("S T A R T S Y M U L A C J I");

OUTPUT("**********************************");

NEW(System);

ASK System TO

Init(maxzgl+1,Kolejka1,Kolejka2,Kolejka3,Gen,SMO1,SMO2,SMO3,trojk,

j,k,l,r,i,a,b,g1, g2, dlkol2,z);

ASK System TO Start;

StartSimulation;

StopSimulation;

M1:=GETMONITOR(MONCzasPrzebyw,RStatObj);

M2:=GETMONITOR(MONCzasPrzebywSMO1,RStatObj);

M3:=GETMONITOR(MONCzasPrzebywSMO2,RStatObj);

M4:=GETMONITOR(MONCzasPrzebywSMO3,RStatObj);

M5:=GETMONITOR(MONZajKanalSMO1,ITimedStatObj);

M6:=GETMONITOR(MONZajKanalSMO2,ITimedStatObj);

M7:=GETMONITOR(MONZajKanalSMO3,ITimedStatObj);

M8:=GETMONITOR(MONKol1Zgl,ITimedStatObj);

M9:=GETMONITOR(MONKol2Zgl,ITimedStatObj);

M10:=GETMONITOR(MONKol3Zgl,ITimedStatObj);

M12:=GETMONITOR(MONKol1Wyj, ITimedStatObj);

M13:=GETMONITOR(MONKol2Wyj, ITimedStatObj);

M14:=GETMONITOR(MONKol3Wyj, ITimedStatObj);

M11:=GETMONITOR(Niecierpliwi,ITimedStatObj);

OUTPUT(" ");

OUTPUT("*************************************************************

*****");

OUTPUT("S T A T Y S T Y K I");

OUTPUT("*************************************************************

*****");

OUTPUT("Sredni czas przebywania zgloszenia w systemie wynosi: ",ASK

M1 TO Mean,"; Odchylenie standardowe: ",ASK M1 TO StdDev);

OUTPUT("Sredni czas przebywania zgloszenia w SMO1 wynosi: ",ASK M2 TO

Mean,"; Odchylenie standardowe: ", ASK M2 TO StdDev);

OUTPUT("Sredni czas przebywania zgloszenia w SMO2 wynosi: ",ASK M3 TO

Mean,"; Odchylenie standardowe: ", ASK M3 TO StdDev);

OUTPUT("Sredni czas przebywania zgloszenia w SMO3 wynosi: ",ASK M4 TO

Mean,"; Odchylenie standardowe: ", ASK M4 TO StdDev);

OUTPUT("*************************************************************

*****");

OUTPUT("Srednia liczba zajetych kanalow w SMO1 wynosi: ",ASK M5 TO

Mean,"; Odchylenie standardowe: ", ASK M5 TO StdDev);

OUTPUT("Srednia liczba zajetych kanalow w SMO2 wynosi: ",ASK M6 TO

Mean,"; Odchylenie standardowe: ", ASK M6 TO StdDev);

Projekt - Podstawy Symulacji

Strona 16

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.