I0E1S1 Kamil Maślanka Projekt PSy, I0E1S1 Kamil Maślanka sprawozdanie projekt, Microsoft Word

Wojskowa Akademia Techniczna

Podstawy Symulacji

Temat: Program symulujący działanie sieci SMO Zadanie laboratoryjne 1

Prowadzący: dr inż. Jarosław Rulka Wykonał: Kamil Maślanka

Nr 8

Grupa: I0E1S1

Zadanie laboratoryjne 1

Treść zadania:

Napisać program symulujący działanie sieci SMO jak na rysunku:

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

rozkład zmiennych T_j: (nrDz + i) mod 6 + 1;
rozkład zmiennych O_i: (nrDz + i + 1) mod 6 + 1;
L_i: (nrDz + i) mod 2 + 1;
AL_i: (nrDz + i + 2) mod 3 + 1;
R_j = (nrDz + i + 5) mod 3 + 1;
M_i = (nrDz + i + 2) mod 4 + 1;
Blokowanie zgłoszeń 1. SMO;
Klienci niecierpliwi w SMO_i : N_i = (nrDz + i) mod 4 (ograniczony czas oczekiwania na rozpoczęcie obsługi);
Awaryjność kolejki nr i: i = nrDz mod 3 +1 (należy przyjąć wykładnicze rozkłady czasów bezawaryjnej „pracy” kolejki i jej naprawy, elementy kolejki w wyniku awarii są tracone);

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

Rozkłady zmiennych losowych:

Wykładniczy
Erlanga
Normalny
Jednostajny
Trókątny
Weibulla

Długości kolejek pojedynczych SMO

ograniczone (możliwe straty)
nieograniczone

Algorytm kolejek:

FIFO
LIFO
Z priorytetami

Liczba stanowisk obsługi w gniazdach (1-M)
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 generowania komunikatów w trakcie przebiegu symulacji.

Dane wyliczone dla numeru 8:

T₁ - rozkład jednostajny

T₂ - rozkład trójkątny

O₁ - rozkład trójkątny

O₂ - rozkład Weibulla

O₃ - rozkład wykładniczy

L₁ - nieograniczona

L₂ - ograniczona

L₃ - nieograniczona

AL₁ - z priorytetami

AL₂ - FIFO

AL₃ - LIFO

R₁ - rozkład normalny

R₂- rozkład wykładniczy

M₁ = 3

M₂ = 1

M₃ = 2

N₁ - rozkład wykładniczy

N₂ - rozkład Erlanga

N₃ - rozkład normalny

Opis rozkładów użytych w programie.

Rozkład normalny

Gęstość prawdopodobieństwa:

0x01 graphic

dwuparametrowy o parametrach:

µ - wartość oczekiwana

σ - odchylenie standardowe

Rozkład wykładniczy

Gęstość prawdopodobieństwa:

0x01 graphic

Dystrybuanta:

0x01 graphic

λ - wartość oczekiwana

Rozkład Erlanga:

Gęstość:

0x01 graphic

o parametrach:

k > 0

λ >0

Rozkład jedostajny:

0x01 graphic

Wykorzystane wzory, których użyto do monitorowania systemu:

Średnia z próby n-elementowej:

0x01 graphic

Odchylenie standardowe z próby n-elementowej:

0x01 graphic

Estymator wartości średniej ważonej czasem:

0x01 graphic

Estymator odchylenia standardowego ważony czasem:

0x01 graphic

Sposób rozwiązania zadania

Do rozwiązania zadania zaimplementowano następujące typy obiektów

- obiekt użyty do monitorowania zmiennych (MonitorObiekt) w programie, używany do podsumowania wyników symulacji

- tablica obiektów GeneratorObiekt, reprezentujących generatory

- obiektów GniazdoObiekt, reprezentujących gniazda

- Kolejka1Obiekt: obiekt reprezentujący pierwszą kolejke: nieograniczona, z priorytetami

- Kolejka2Obiekt: obiekt reprezentujący drugą kolejke: ograniczona, FIFO

- Kolejka3Obiekt: obiekt reprezentujący trzecią kolejke: nieograniczona, LIFO(stos) Każdy z wyżej wymienionych obiektów został wyposażony w niezbędne metody do przeprowadzenia symulacji.

Przebieg symulacji:

- Wywołanie funkcji obiektu GeneratorObiekt: Generuj(); - funkcja odpowiedzialna za właściwe wygenerowanie klienta

- Wywołanie funkcji obiektu Kolejka(1..2)Obiekt: Wstaw(Klient);-funkcja odpowiedzialna za umieszczenie klienta w kolejce 1 lub 2.

- Wywołanie funkcji obiektu GniazdoObiekt: Obsluga(SELF);- funkcja odpowiedzialna za obsługę klienta w gnieździe

- Wywołanie funkcji obiektu Kolejka3Obiekt: Wstaw(Klient);-funkcja odpowiedzialna za umieszczenie klienta w kolejce 3

- Wywołanie funkcji obiektu GniazdoObiekt: Obsluga(SELF);- funkcja odpowiedzialna za obsługę klienta w gnieździe, usunięcie klienta z SMO.

Podczas każdorazowego wywołania każdej z funcji aktualizowane są odpowiednie zmienne znajdujące się w monitorach, umożliwiające policzenie charakterystyk po zakończeniu symulacji.

Charakterystyki były wyliczane z następujących wzorów:

Średnia z próby n-elementowej:

0x01 graphic

Odchylenie standardowe z próby n-elementowej:

0x01 graphic

Estymator wartości średniej ważonej czasem:

0x01 graphic

Estymator odchylenia standardowego ważony czasem:

0x01 graphic

Kod programu:

MAIN MODULE projm;

FROM RandMod IMPORT RandomObj;

FROM SimMod IMPORT StartSimulation, SimTime,ResetSimTime, StopSimulation;

FROM GrpMod IMPORT QueueObj, StackObj,RankedObj,BasicGroupObj;

FROM StatMod IMPORT RStatObj,ITimedStatObj,IStatObj,TSINTEGER,SINTEGER,TSREAL,SREAL;

FROM SimMod IMPORT Interrupt,TriggerObj;

FROM IOMod IMPORT StreamObj, ALL FileUseType;

{############################################## Definicje obiektow uzytkownika }

TYPE

GeneratorObiekt = OBJECT; FORWARD; Kolejka1Obiekt = OBJECT; FORWARD; Kolejka2Obiekt = OBJECT; FORWARD; Kolejka3Obiekt = OBJECT; FORWARD; GniazdoObiekt = OBJECT; FORWARD;

KlientObiekt = OBJECT; FORWARD; MonitorObiekt = OBJECT; FORWARD;

{############################################## Uzywane zmienne } VAR

Generator: ARRAY INTEGER OF GeneratorObiekt;

Kolejka1Prior: Kolejka1Obiekt; Kolejka2FIFO: Kolejka2Obiekt; Kolejka3LIFO: Kolejka3Obiekt;

Gniazdo: ARRAY INTEGER OF GniazdoObiekt;

Monitor: MonitorObiekt;

{############################################## Deklaracje obiektow } TYPE

GeneratorObiekt = OBJECT; Random: RandomObj; czykom: INTEGER;

NrGeneratora: INTEGER;{Numer utworzonego generatora}

{parametry okreslajace czas miedzy naplywaniem zgloszen do systemu} ParametrRozkladuGeneratora1: REAL;

ParametrRozkladuGeneratora2: REAL; ParametrRozkladuGeneratora3: REAL;

{parametry okreslajace wielkosc paczki zgloszen do systemu} ParametrRozkladuPaczki1: REAL;

ParametrRozkladuPaczki2: REAL;

Czas:REAL;

Klient: KlientObiekt; LiczbaKlientowDoWygenerowania: INTEGER; Monitor: MonitorObiekt;

ASK METHOD Init(IN Ran: RandomObj;IN ParRozGen1, ParRozGen2, ParRozGen3: REAL; IN KlientowDoGen: INTEGER;

IN ParRozPacz1, ParRozPacz2:REAL; IN Mon: MonitorObiekt; IN NrGen: INTEGER; IN c:INTEGER);

TELL METHOD Generuj();

END OBJECT;

GniazdoObiekt = OBJECT; Random: RandomObj;

NrGniazda, Kanaly, Aktywne, czykom: INTEGER;

ParametrRozkladuGniazda1, ParametrRozkladuGniazda2, ParametrRozkladuGniazda3: REAL;

Prawdopodobienstwo: REAL; Trigger: TriggerObj; Monitor: MonitorObiekt;

ASK METHOD Init(IN Ran: RandomObj;IN ParRozGniaz1, ParRozGniaz2, ParRozGniaz3: REAL; IN Kan, Akt: INTEGER;

IN Prawd: REAL; IN Trig: TriggerObj; IN Mon:

MonitorObiekt; IN NrGenerat: INTEGER;IN c:INTEGER); TELL METHOD Obsluga(IN kolejka: BasicGroupObj);

END OBJECT;

Kolejka1Obiekt = OBJECT(RankedObj);{### Obiekt kolejki nr 1 - priorytetowa

###}

Cierpliwosc1, Cierpliwosc2: REAL; Licznik: TSINTEGER;

NrKolejki, Pojemnosc: INTEGER; Random: RandomObj;

Trigger: TriggerObj; Monitor: MonitorObiekt;

ASK METHOD Wstaw(INOUT elem: KlientObiekt);

ASK METHOD Init(IN ra: RandomObj; IN Poj: INTEGER; IN Trig: TriggerObj; IN m: MonitorObiekt;

IN Cierp1: REAL; IN Cierp2: REAL; IN NrKol: INTEGER);

OVERRIDE

ASK METHOD Rank(IN a:ANYOBJ;IN b:ANYOBJ):INTEGER; ASK METHOD ObjTerminate();

ASK METHOD Remove():ANYOBJ;

ASK METHOD RemoveThis(IN kto: ANYOBJ); END OBJECT;

Kolejka2Obiekt = OBJECT(QueueObj);{### Obiekt kolejki nr 2 - FIFO ###} Cierpliwosc1, Cierpliwosc2: REAL;

Licznik: TSINTEGER;

NrKolejki, Pojemnosc: INTEGER; Random: RandomObj;

Trigger: TriggerObj;

Monitor: MonitorObiekt;

ASK METHOD Wstaw(INOUT elem: KlientObiekt);

ASK METHOD Init(IN ra: RandomObj; IN Poj: INTEGER; IN Trig: TriggerObj; IN m: MonitorObiekt;

IN Cierp1: REAL; IN Cierp2: REAL; IN NrKol: INTEGER);

OVERRIDE

ASK METHOD ObjTerminate(); ASK METHOD Remove():ANYOBJ;

ASK METHOD RemoveThis(IN kto: ANYOBJ);

END OBJECT;

Kolejka3Obiekt = OBJECT(StackObj);{### Obiekt kolejki nr 3 - LIFO ###} Cierpliwosc1, Cierpliwosc2: REAL;

Licznik: TSINTEGER;

NrKolejki, Pojemnosc: INTEGER; Random: RandomObj;

Trigger: TriggerObj; Monitor: MonitorObiekt;

ASK METHOD Wstaw(INOUT elem: KlientObiekt);

ASK METHOD Init(IN ra: RandomObj; IN Poj: INTEGER; IN Trig: TriggerObj; IN m: MonitorObiekt;

IN Cierp1: REAL; IN Cierp2: REAL; IN NrKol: INTEGER);

OVERRIDE

ASK METHOD ObjTerminate(); ASK METHOD Remove():ANYOBJ;

ASK METHOD RemoveThis(IN kto: ANYOBJ); END OBJECT;

KlientObiekt = OBJECT{### Obiekt klienta ###} Priorytet: INTEGER;

czasWe: REAL;

czasWe1: REAL; czasWe2: REAL; czasWe3: REAL;

numer,czykom: INTEGER;

Monitor: MonitorObiekt;

ASK METHOD Init(IN m: MonitorObiekt; IN c: INTEGER); ASK METHOD UstawPriorytet(IN pr: INTEGER);

TELL METHOD Niecierpliwosc(IN nrSmo: INTEGER; IN czas: REAL; IN kol: BasicGroupObj);

ASK METHOD zapiszCzas(IN nrSmo: INTEGER; IN taj: REAL);

END OBJECT;

MonitorObiekt = OBJECT

numer: INTEGER;

licznikArray : ARRAY [1..4] OF TSINTEGER;{### monitory zliczajace klientow w smo ###}

liczKlient: TSINTEGER;

KlientWchodzacyArray : ARRAY [1..4] OF INTEGER;{### monitory zliczajace klientow wchodzacych ###}

KlientWychodzacyArray : ARRAY [1..4] OF INTEGER;{### monitory zliczajace klientow wychodzacych ###}

LiczbaKlientowWkolejceArray : ARRAY [1..4] OF TSINTEGER;{### monitory zliczajace klientow w kolejkach ###}

SredniCzaswSMOnrArray : ARRAY [1..4] OF SREAL;{### monitory zliczajace czas przebywania klientow w smo ###}

ZajetyKanalArray : ARRAY [1..4] OF TSINTEGER;{### monitory zliczajace

zajete kanaly ###}

PrawdopodobienstwoObslugiArray : ARRAY [1..4] OF REAL;{### zmienne przechowujace obliczone pstwo obslugi ###}

SredniaLiczbaKlientowWsmoNrArray : ARRAY [1..4] OF SREAL;{### monitory

przechwoujace srednie liczby klientow w smo ###} SredniaLiczbaKlientowWsmoNrDevArray : ARRAY [1..4] OF SREAL;{### monitory

przechwoujace odchylenia stand liczby klientow w smo ###}

SredniaCzasPobytuWsmoNrArray : ARRAY [1..4] OF SREAL;{### monitory przechwoujace srednie czasu pobytu w smo ###}

SredniaCzasPobytuWsmoNrDevArray : ARRAY [1..4] OF SREAL; {### monitory przechwoujace odchylenia stand czasu pobytu w smo ###}

SredniaLiczbaZajetegoKanaluArray : ARRAY [1..4] OF SREAL;{### monitory przechwoujace srednia liczbe zajetych kanalow###}

SredniaLiczbaZajetegoKanaluDevArray : ARRAY [1..4] OF SREAL;{### monitory

przechwoujace odchylenie stand liczby zajetych kanalow ###} SredniaLiczbaKlientowWkolejceArray : ARRAY [1..4] OF SREAL;{### monitory

przechwoujace srednia liczbe klientow w kolejkach ###} OdchStandLiczbaKlientowWkolejceArray : ARRAY [1..4] OF SREAL;{###

monitory przechwoujace odchylenie stand liczby klientow w kolejkach ###} SrednieprawdopodobienstwoObslugiArray : ARRAY [1..4] OF SREAL;{###

monitory przechwoujace srednia prawdopodobienstwoObslugi obslugi ###} OdchStandsredniaLiczbaKlientowWsmoNrArray : ARRAY [1..4] OF SREAL;{###

monitory przechowywujace srednia liczbe klientow ###}

ASK METHOD InitMon(); {### inicjacja monitora ###}

ASK METHOD SredniaLiczbaKlientow(IN nrSmo: INTEGER; IN licz: REAL);{###

zbiera sredni licznik klientow ###}

ASK METHOD OdchStanLiczbyKlientow(IN nrSmo: INTEGER; IN licz: REAL);{###

zbiera odchylenie stand licznika klientow ###}

ASK METHOD SredniCzasPobytu(IN nrSmo: INTEGER; IN licz: REAL);{### zbiera sredni czas pobytu w systemie ###}

ASK METHOD odchStandPobytu(IN nrSmo: INTEGER; IN licz: REAL); {###

zbiera odchylenie stand czasu pobytu w systemie ###}

ASK METHOD SreniaLiczbaZajetychK(IN nrSmo: INTEGER; IN licz: REAL); {###

zbiera srednia liczbe zajetych kanalow ###}

ASK METHOD OdchStandLiczbyZajetychK(IN nrSmo: INTEGER; IN licz: REAL);{### zbiera odchylenie stand liczby zajetych kanalow ###}

ASK METHOD SredniaDlugoscKol(IN nrSmo: INTEGER; IN licz: REAL);{###

zbiera sredni liczbe klientow w kolejkach ###}

ASK METHOD OdchStanDlugoscKol(IN nrSmo: INTEGER; IN licz: REAL);{###

zbiera odchylenie stand liczby klientow w kolejkach ###}

ASK METHOD getprawdopodobienstwoObslugi(IN nrSmo:INTEGER;IN licz:REAL);

ASK METHOD IleKlientWchodzacych(IN nrSmo: INTEGER);{### zlicza klientow wchodzacych do systemu ###}

ASK METHOD IleKlientWychodzacych(IN nrSmo:INTEGER);{### zlicza klientow wychodzacych z systemu ###}

ASK METHOD PrawdopodobienstwoObslugi(IN nrSmo: INTEGER);{### zlicza pstwo obslugi ###}

ASK METHOD ZmniejszLiczbeKlientow(IN nrSmo: INTEGER);{### modyfikacja

licznika klientow ###}

ASK METHOD ZwiekszLiczbeKlientow(IN nrSmo: INTEGER);{### modyfikacja licznika klientow ###}

ASK METHOD ZmniejszLiczbeKlientowWKol(IN nrSmo: INTEGER);{### modyfikacja

licznika klientow w kolejkach ###}

ASK METHOD ZwiekszLiczbeKlientowWKol(IN nrSmo: INTEGER);{### modyfikacja licznika klientow w kolejkach ###}

ASK METHOD ZmniejszLiczbeKlientowKan(IN nrSmo: INTEGER);{### modyfikacja licznika zajetych kanalow ###}

ASK METHOD ZwiekszLiczbeKlientowKan(IN nrSmo: INTEGER);{### modyfikacja licznika zajetych kanalow ###}

ASK METHOD liczSredni(IN numer:INTEGER; IN czas:REAL);{### zlicza czas przebywania klienta w smo ###}

END OBJECT;

OBJECT MonitorObiekt; ASK METHOD InitMon();

BEGIN NEW(licznikArray,1..4); NEW(KlientWchodzacyArray,1..4); NEW(KlientWychodzacyArray,1..4); NEW(LiczbaKlientowWkolejceArray,1..4); NEW(SredniCzaswSMOnrArray,1..4); NEW(ZajetyKanalArray,1..4); NEW(PrawdopodobienstwoObslugiArray,1..4); NEW(SredniaLiczbaKlientowWsmoNrArray,1..4); NEW(SredniaLiczbaKlientowWsmoNrDevArray,1..4); NEW(SredniaCzasPobytuWsmoNrArray,1..4); NEW(SredniaCzasPobytuWsmoNrDevArray,1..4); NEW(SredniaLiczbaZajetegoKanaluArray,1..4); NEW(SredniaLiczbaZajetegoKanaluDevArray,1..4); NEW(SredniaLiczbaKlientowWkolejceArray,1..4); NEW(OdchStandLiczbaKlientowWkolejceArray,1..4); NEW(SrednieprawdopodobienstwoObslugiArray,1..4); NEW(OdchStandsredniaLiczbaKlientowWsmoNrArray,1..4); licznikArray[1]:=0;

licznikArray[2]:=0;

licznikArray[3]:=0; licznikArray[4]:=0; END METHOD;

ASK METHOD IleKlientWchodzacych(IN nrSmo: INTEGER); BEGIN

numer:=nrSmo;

KlientWchodzacyArray[numer+1]:=KlientWchodzacyArray[numer+1]+1; END METHOD;

ASK METHOD IleKlientWychodzacych(IN nrSmo: INTEGER); BEGIN

numer:=nrSmo; KlientWychodzacyArray[numer+1]:=KlientWychodzacyArray[numer+1]+1;

END METHOD;

ASK METHOD PrawdopodobienstwoObslugi(IN nrSmo: INTEGER); BEGIN

numer:=nrSmo; IF numer = 0

KlientWchodzacyArray[2]+KlientWchodzacyArray[3]+KlientWchodzacyArray[4] > 0

PrawdopodobienstwoObslugiArray[1]:=FLOAT(KlientWychodzacyArray[2]+Kli entWychodzacyArray[3]+KlientWychodzacyArray[4])

/FLOAT(KlientWchodzacyArray[2]+KlientWchodzacyArray[3]+KlientWchodzacyArray

[4]); ELSE

PrawdopodobienstwoObslugiArray[1]:=0.0; END IF;

ELSE

IF KlientWchodzacyArray[numer+1] > 0

PrawdopodobienstwoObslugiArray[numer+1]:=FLOAT(KlientWychodzacyArray[numer+

1])/FLOAT(KlientWchodzacyArray[numer+1]); ELSE

PrawdopodobienstwoObslugiArray[numer+1]:=0.0; END IF;

END IF;

END METHOD;

ASK METHOD ZmniejszLiczbeKlientow(IN nrSmo: INTEGER); BEGIN

numer:=nrSmo;

licznikArray[numer+1]:=licznikArray[numer+1]-1; END METHOD;

ASK METHOD ZwiekszLiczbeKlientow(IN nrSmo: INTEGER); BEGIN

numer:=nrSmo;

licznikArray[numer+1]:=licznikArray[numer+1]+1;

END METHOD;

ASK METHOD ZwiekszLiczbeKlientowWKol(IN nrSmo: INTEGER); BEGIN

numer:=nrSmo;

LiczbaKlientowWkolejceArray[numer+1]:=LiczbaKlientowWkolejceArray[numer+1]+

END METHOD;

ASK METHOD ZmniejszLiczbeKlientowWKol(IN nrSmo: INTEGER); BEGIN

numer:=nrSmo;

LiczbaKlientowWkolejceArray[numer+1]:=LiczbaKlientowWkolejceArray[numer+1]-

END METHOD;

ASK METHOD ZmniejszLiczbeKlientowKan(IN nrSmo: INTEGER); BEGIN

numer:=nrSmo; ZajetyKanalArray[numer+1]:=ZajetyKanalArray[numer+1]-1;

END METHOD;

ASK METHOD ZwiekszLiczbeKlientowKan(IN nrSmo: INTEGER); BEGIN

numer:=nrSmo; ZajetyKanalArray[numer+1]:=ZajetyKanalArray[numer+1]+1;

END METHOD;

ASK METHOD liczSredni(IN nrSmo: INTEGER; IN czas:REAL); BEGIN

numer := nrSmo; SredniCzaswSMOnrArray[numer+1]:= czas;

END METHOD;

ASK METHOD SredniaLiczbaKlientow(IN nrSmo: INTEGER; IN licz: REAL); BEGIN

numer:=nrSmo; SredniaLiczbaKlientowWsmoNrArray[numer+1]:=licz;

END METHOD;

ASK METHOD OdchStanLiczbyKlientow(IN nrSmo: INTEGER; IN licz: REAL); BEGIN

numer:=nrSmo;

OdchStandsredniaLiczbaKlientowWsmoNrArray[numer+1]:=licz; END METHOD;

ASK METHOD SredniCzasPobytu(IN nrSmo: INTEGER; IN licz: REAL); BEGIN

numer:=nrSmo; SredniaCzasPobytuWsmoNrArray[numer+1]:=licz;

END METHOD;

ASK METHOD odchStandPobytu(IN nrSmo: INTEGER; IN licz: REAL); BEGIN

numer:=nrSmo; SredniaCzasPobytuWsmoNrDevArray[numer + 1]:=licz;

END METHOD;

ASK METHOD SreniaLiczbaZajetychK(IN nrSmo: INTEGER; IN licz: REAL); BEGIN

numer:=nrSmo; SredniaLiczbaZajetegoKanaluArray[numer+1]:=licz;

END METHOD;

ASK METHOD OdchStandLiczbyZajetychK(IN nrSmo: INTEGER; IN licz: REAL); BEGIN

numer:=nrSmo;

SredniaLiczbaZajetegoKanaluDevArray[numer+1]:=licz; END METHOD;

ASK METHOD SredniaDlugoscKol(IN nrSmo: INTEGER; IN licz: REAL); BEGIN

numer:=nrSmo; SredniaLiczbaKlientowWkolejceArray[numer+1]:=licz;

END METHOD;

ASK METHOD OdchStanDlugoscKol(IN nrSmo: INTEGER; IN licz: REAL); BEGIN

numer:=nrSmo; OdchStandLiczbaKlientowWkolejceArray[numer+1]:=licz;

END METHOD;

ASK METHOD getprawdopodobienstwoObslugi(IN nrSmo:INTEGER;IN licz:REAL); BEGIN

numer:=nrSmo;

SrednieprawdopodobienstwoObslugiArray[numer+1]:=licz; END METHOD;

END OBJECT;

OBJECT KlientObiekt;

ASK METHOD UstawPriorytet(IN pr: INTEGER); BEGIN

Priorytet:= pr; END METHOD;

ASK METHOD Init(IN m: MonitorObiekt;IN c: INTEGER); BEGIN

Monitor:= m;

czykom:=c; END METHOD;

TELL METHOD Niecierpliwosc(IN nrSmo: INTEGER; IN czas: REAL; IN kol: BasicGroupObj);

BEGIN

numer:=nrSmo;

WAIT DURATION ABS(czas); ON INTERRUPT;

RETURN;

END WAIT;

ASK kol TO RemoveThis(SELF);

ASK Monitor TO ZmniejszLiczbeKlientow(nrSmo); ASK Monitor TO ZmniejszLiczbeKlientow(0);

ASK Monitor TO ZmniejszLiczbeKlientowWKol(nrSmo); ASK Monitor TO ZmniejszLiczbeKlientowWKol(0);

IF czykom=1

OUTPUT("::: Zniecierpliwiony klient w kolejce ",nrSmo," czas ", SimTime);

END IF; DISPOSE(SELF);

END METHOD;

ASK METHOD zapiszCzas(IN nrSmo: INTEGER; IN taj: REAL); BEGIN

numer:=nrSmo; IF (numer = 0)

czasWe:=taj; ELSIF numer=1

czasWe1:=taj; ELSIF numer=2

czasWe2:=taj; ELSIF numer=3

czasWe3:=taj; END IF;

END METHOD;

END OBJECT;

OBJECT GniazdoObiekt;

ASK METHOD Init(IN Ran: RandomObj;IN prg1, prg2, prg3: REAL; IN kan, akt: INTEGER;

IN prawdopodobienstwoObslugi: REAL; IN trig: TriggerObj; IN m: MonitorObiekt;IN nrg: INTEGER; IN c:INTEGER);

BEGIN

czykom := c; Random := Ran; ParametrRozkladuGniazda1:=prg1; ParametrRozkladuGniazda2:=prg2;

ParametrRozkladuGniazda3:=prg3; Kanaly:= kan;

Aktywne:= akt; Trigger := trig; Monitor:=m;

Prawdopodobienstwo:=prawdopodobienstwoObslugi; NrGniazda:=nrg;

END METHOD;

TELL METHOD Obsluga(IN kol: BasicGroupObj); VAR

t: REAL;

klient: KlientObiekt; BEGIN

WHILE ASK kol TO numberIn > 0 klient:= ASK kol TO Remove;

IF czykom = 1

OUTPUT("##Obsluga"); END IF;

ASK Monitor TO ZmniejszLiczbeKlientowWKol(0);

ASK Monitor TO ZmniejszLiczbeKlientowWKol(NrGniazda); Aktywne:=Aktywne+1;

ASK Monitor TO ZwiekszLiczbeKlientowKan(NrGniazda); ASK Monitor TO ZwiekszLiczbeKlientowKan(0);

IF NrGniazda=1

Interrupt(klient,"Niecierpliwosc");

t:= ASK Random TO Triangular(ParametrRozkladuGniazda1,ParametrRozkladuGniazda2,ParametrRozkla duGniazda3);

WAIT DURATION ABS(t);

ON INTERRUPT END WAIT;

IF ( ASK Random TO UniformReal(0.0, 1.0) > Prawdopodobienstwo

);

numberIn)

ASK Monitor TO ZmniejszLiczbeKlientow(0); ASK Monitor TO ZmniejszLiczbeKlientow(1); Aktywne:=Aktywne-1;

ASK Monitor TO ZmniejszLiczbeKlientowKan(1);

ASK Monitor TO ZmniejszLiczbeKlientowKan(0); ASK Kolejka1Prior TO Wstaw(klient);

ELSE

WHILE(ASK Kolejka3LIFO TO Pojemnosc = ASK Kolejka3LIFO TO

IF czykom = 1

OUTPUT("### blokowanie SMO 1."); END IF;

WAIT FOR Trigger TO Fire(); ON INTERRUPT;

END WAIT; END WHILE;

ASK Monitor TO IleKlientWychodzacych(1);

ASK Monitor TO liczSredni(1,SimTime-ASK klient TO czasWe1); ASK Monitor TO ZmniejszLiczbeKlientow(1);

Aktywne:=Aktywne-1;

ASK Monitor TO ZmniejszLiczbeKlientowKan(1); ASK Monitor TO ZmniejszLiczbeKlientowKan(0);

IF czykom = 1

OUTPUT("####Klient zostal obsluzony w SMO ",NrGniazda,", w czasie ", SimTime);

END IF;

ASK Kolejka3LIFO TO Wstaw(klient); END IF;

ELSIF NrGniazda=2

Interrupt(klient,"Niecierpliwosc");

t:= ASK Random TO Weibull(ParametrRozkladuGniazda1, ParametrRozkladuGniazda2);

WAIT DURATION ABS(t); ON INTERRUPT

END WAIT;

ASK Monitor TO IleKlientWychodzacych(2);

ASK Monitor TO liczSredni(2,SimTime-ASK klient TO czasWe1); ASK Monitor TO ZmniejszLiczbeKlientow(2);

Aktywne:=Aktywne-1;

ASK Monitor TO ZmniejszLiczbeKlientowKan(2); ASK Monitor TO ZmniejszLiczbeKlientowKan(0); IF czykom = 1

OUTPUT("####Klient zostal obsluzony w SMO ",NrGniazda,", w

czasie ", SimTime); END IF;

ASK Kolejka3LIFO TO Wstaw(klient);

ELSIF NrGniazda=3

Interrupt(klient,"Niecierpliwosc");

t:= ASK Random TO Exponential(ParametrRozkladuGniazda1); WAIT DURATION ABS(t);

ON INTERRUPT END WAIT;

IF ( ASK Random TO UniformReal(0.0, 1.0)>Prawdopodobienstwo); ASK Monitor TO ZmniejszLiczbeKlientow(0);

ASK Monitor TO ZmniejszLiczbeKlientow(3); Aktywne:=Aktywne-1;

ASK Monitor TO ZmniejszLiczbeKlientowKan(3); ASK Monitor TO ZmniejszLiczbeKlientowKan(0); ASK Kolejka2FIFO TO Wstaw(klient);

ELSE

ASK Monitor TO IleKlientWychodzacych(3); ASK Monitor TO IleKlientWychodzacych(0);

ASK Monitor TO liczSredni(3,SimTime-ASK klient TO czasWe1);

ASK Monitor TO liczSredni(0,SimTime-ASK klient TO czasWe); ASK Monitor TO ZmniejszLiczbeKlientow(3);

Aktywne:=Aktywne-1;

ASK Monitor TO ZmniejszLiczbeKlientowKan(3); ASK Monitor TO ZmniejszLiczbeKlientowKan(0);

IF czykom = 1

OUTPUT("####Klient zostal obsluzony w SMO ",NrGniazda,", w czasie ", SimTime);

END IF; DISPOSE(klient); END IF;

END IF; END WHILE;

END METHOD;

END OBJECT;

OBJECT GeneratorObiekt; TELL METHOD Generuj; VAR

Klient: KlientObiekt;

paczkaInt1: INTEGER; ileDoKonca1: INTEGER; paczkaReal1: REAL;

i: INTEGER; j: INTEGER; sumaPacz1: INTEGER; czas1: REAL;

BEGIN

sumaPacz1:=0;

WHILE (sumaPacz1<LiczbaKlientowDoWygenerowania) {### sprawdzenie czy suma klientow generowanych w paczkach jest rowna liczbie klientow do wygenerowania###}

IF (NrGeneratora=1)

paczkaReal1:= ASK Random TO Normal(ParametrRozkladuPaczki1, ParametrRozkladuPaczki2);

ELSIF (NrGeneratora=2)

paczkaReal1:= ASK Random TO Exponential(ABS(ParametrRozkladuPaczki1));

END IF;

paczkaInt1:=TRUNC(ABS(paczkaReal1)); sumaPacz1:=sumaPacz1+paczkaInt1; ileDoKonca1:=LiczbaKlientowDoWygenerowania-sumaPacz1; IF ileDoKonca1<0

paczkaInt1:=paczkaInt1+ileDoKonca1; END IF;

IF (NrGeneratora=1)

czas1:= ASK Random TO UniformReal(ParametrRozkladuGeneratora1, ParametrRozkladuGeneratora2);

ELSIF (NrGeneratora=2)

czas1:= ASK Random TO Triangular(ParametrRozkladuGeneratora1, ParametrRozkladuGeneratora2, ParametrRozkladuGeneratora3);

END IF;

WAIT DURATION ABS(czas1) ON INTERRUPT

END WAIT;

FOR j:=1 TO paczkaInt1

NEW (Klient);

ASK Monitor TO IleKlientWchodzacych(0);

ASK Klient TO UstawPriorytet( ASK Random TO UniformInt(0,10));

ASK Klient TO Init(Monitor,czykom); Czas:=SimTime;

ASK Klient TO zapiszCzas(0,Czas);

IF czykom = 1

OUTPUT("#####Generator nr ",NrGeneratora," generuje klienta, czas = ", SimTime);

END IF;

IF NrGeneratora=1

ASK Kolejka1Prior TO Wstaw(Klient);

ELSIF NrGeneratora=2

ASK Kolejka2FIFO TO Wstaw(Klient); END IF;

END FOR; END WHILE;

END METHOD;

ASK METHOD Init(IN Ran: RandomObj; IN prg1: REAL; IN prg2: REAL; IN prg3: REAL; IN lk: INTEGER; IN prp1:REAL; IN prp2:REAL; IN m: MonitorObiekt; IN nrgen: INTEGER; IN c: INTEGER);

BEGIN

czykom:=c; Random:= Ran; ParametrRozkladuPaczki1:= prp1; ParametrRozkladuPaczki2:= prp2; Monitor:=m; ParametrRozkladuGeneratora1:= prg1; ParametrRozkladuGeneratora2:= prg2; ParametrRozkladuGeneratora3:= prg3; LiczbaKlientowDoWygenerowania:= lk; NrGeneratora:=nrgen;

END METHOD;

END OBJECT;

OBJECT Kolejka1Obiekt;

ASK METHOD Wstaw(INOUT elem: KlientObiekt); BEGIN

Add(elem);

ASK Monitor TO IleKlientWchodzacych(1);

ASK Monitor TO ZwiekszLiczbeKlientowWKol(0); ASK Monitor TO ZwiekszLiczbeKlientowWKol(1); ASK elem TO zapiszCzas(1,SimTime);

ASK Monitor TO ZwiekszLiczbeKlientow(0); ASK Monitor TO ZwiekszLiczbeKlientow(1); Licznik:=Licznik+1;

TELL elem TO Niecierpliwosc(NrKolejki,ASK Random TO

Exponential(Cierpliwosc1),SELF);

IF ASK Gniazdo[NrKolejki] TO Aktywne < ASK Gniazdo[NrKolejki] TO Kanaly

TELL Gniazdo[NrKolejki] TO Obsluga(SELF);

END IF; END METHOD;

ASK METHOD Init(IN ra: RandomObj; IN poj: INTEGER; IN trig: TriggerObj; IN m: MonitorObiekt; IN par1cie: REAL; IN par2cie: REAL; IN nrk: INTEGER);

BEGIN

Cierpliwosc1 := par1cie; Cierpliwosc2 := par2cie; Pojemnosc:= poj;

Random := ra;

Monitor:= m; Licznik:= 0; Trigger:= trig; NrKolejki:= nrk;

END METHOD;

ASK METHOD Rank(IN a:ANYOBJ;IN b:ANYOBJ):INTEGER; VAR

Klient1:KlientObiekt; Klient2:KlientObiekt;

BEGIN

Klient1:=a; Klient2:=b;

IF ASK Klient1 TO Priorytet < ASK Klient2 TO Priorytet

RETURN -1; END IF;

IF ASK Klient1 TO Priorytet > ASK Klient2 TO Priorytet

RETURN 1; END IF; RETURN 0;

END METHOD;

ASK METHOD ObjTerminate(); VAR

elem:ANYOBJ; BEGIN

FOREACH elem IN SELF RemoveThis(elem); DISPOSE(elem);

END FOREACH;

INHERITED ObjTerminate();

END METHOD;

ASK METHOD RemoveThis(IN kto: ANYOBJ); BEGIN

INHERITED RemoveThis(kto); END METHOD;

ASK METHOD Remove(): ANYOBJ; BEGIN

ASK Trigger TO Release; RETURN INHERITED Remove();

END METHOD; END OBJECT;

OBJECT Kolejka2Obiekt;

ASK METHOD Wstaw(INOUT elem: KlientObiekt); BEGIN

IF numberIn<Pojemnosc

Add(elem);

ASK Monitor TO IleKlientWchodzacych(2);

ASK Monitor TO ZwiekszLiczbeKlientowWKol(0); ASK Monitor TO ZwiekszLiczbeKlientowWKol(2); ASK elem TO zapiszCzas(2,SimTime);

ASK Monitor TO ZwiekszLiczbeKlientow(0); ASK Monitor TO ZwiekszLiczbeKlientow(2); Licznik:=Licznik+1;

TELL elem TO Niecierpliwosc(NrKolejki,ASK Random TO Erlang(ABS(Cierpliwosc1), ABS(TRUNC(Cierpliwosc2))),SELF);

IF ASK Gniazdo[NrKolejki] TO Aktywne < ASK Gniazdo[NrKolejki] TO

Kanaly

TELL Gniazdo[NrKolejki] TO Obsluga(SELF); END IF;

ELSE

DISPOSE(elem); END IF;

END METHOD;

ASK METHOD Init(IN ra: RandomObj; IN poj: INTEGER; IN trig: TriggerObj;

IN m: MonitorObiekt; IN par1cie: REAL; IN par2cie: REAL; IN nrk: INTEGER); BEGIN

Cierpliwosc1 := par1cie; Cierpliwosc2 := par2cie; Pojemnosc := poj;

Random := ra;

Monitor := m; Trigger := trig; Licznik := 0; NrKolejki := nrk;

END METHOD;

ASK METHOD ObjTerminate(); VAR

elem:ANYOBJ; BEGIN

FOREACH elem IN SELF RemoveThis(elem); DISPOSE(elem);

END FOREACH;

INHERITED ObjTerminate(); END METHOD;

ASK METHOD RemoveThis(IN kto: ANYOBJ); BEGIN

INHERITED RemoveThis(kto);

END METHOD;

ASK METHOD Remove():ANYOBJ; BEGIN

ASK Trigger TO Release; RETURN INHERITED Remove();

END METHOD;

END OBJECT;

OBJECT Kolejka3Obiekt;

ASK METHOD Wstaw(INOUT elem: KlientObiekt); BEGIN

Add(elem);

ASK Monitor TO IleKlientWchodzacych(3);

ASK Monitor TO ZwiekszLiczbeKlientowWKol(0); ASK Monitor TO ZwiekszLiczbeKlientowWKol(3); ASK elem TO zapiszCzas(3,SimTime);

ASK Monitor TO ZwiekszLiczbeKlientow(0);

ASK Monitor TO ZwiekszLiczbeKlientow(3); Licznik:=Licznik+1;

TELL elem TO Niecierpliwosc(NrKolejki,ASK Random TO

Normal(ABS(Cierpliwosc1), ABS(Cierpliwosc2)),SELF);

IF ASK Gniazdo[NrKolejki] TO Aktywne < ASK Gniazdo[NrKolejki] TO Kanaly

TELL Gniazdo[NrKolejki] TO Obsluga(SELF); END IF;

END METHOD;

BEGIN

Cierpliwosc1 := par1cie; Cierpliwosc2 := par2cie; Pojemnosc := poj;

Random := ra;

Trigger := trig; Monitor := m; Licznik := 0; NrKolejki := nrk;

END METHOD;

ASK METHOD ObjTerminate(); VAR

elem:ANYOBJ; BEGIN

FOREACH elem IN SELF RemoveThis(elem); DISPOSE(elem);

END FOREACH;

INHERITED ObjTerminate(); END METHOD;

ASK METHOD RemoveThis(IN kto: ANYOBJ); BEGIN

INHERITED RemoveThis(kto); END METHOD;

ASK METHOD Remove():ANYOBJ; BEGIN

ASK Trigger TO Release; RETURN INHERITED Remove();

END METHOD;

END OBJECT;

VAR

Ran: RandomObj; Trigg:TriggerObj;

textLine:STRING;

ch,ch2: CHAR;

par1cie1, par2cie1, par1cie2, par2cie2, par1gen1, par2gen1, pac1gen1, pac2gen1:REAL;

parwykladniczy,parametrpierwszyErlang, parametrdrugiErlang, parametr1Normal, parametr2Normal, parametr1jednostajny, parametr2jednostajny, parametr1Normal2, parametr2Normal2: REAL;

partr1,partr2,partr3, parwykl1:REAL;

ile1gen1:INTEGER; liczbaK: INTEGER; liczbaK2: INTEGER;

par1gen2, par2gen2, pac1gen2, pac2gen2:REAL;

ile1gen2:INTEGER;

par1gni1, par2gni1, par3gni1, par1gni2, par2gni2, par3gni2, par1gni3, par2gni3, par3gni3: REAL;

ile1kol1, ile1kol2, ile1kol3, czykom:INTEGER;

trojkat1, trojkat2,trojkat3: REAL; weibul1, weibul2: REAL; wykladniczy: REAL;

dataFile: StreamObj;

str: STRING; BEGIN

NEW(Trigg); NEW(Ran); NEW(Monitor); NEW(Kolejka1Prior); NEW(Kolejka2FIFO); NEW(Kolejka3LIFO); NEW(Gniazdo, 1..3); NEW(Gniazdo[1]); NEW(Gniazdo[2]); NEW(Gniazdo[3]); NEW(Generator, 1..2); NEW(Generator[1]); NEW(Generator[2]); NEW(dataFile);

{### wczytanie danych z pliku Dane.txt ###} ASK dataFile TO Open("Dane.txt", Input);

ASK dataFile TO ReadLine(str); ASK dataFile TO ReadLine(str);

ASK dataFile TO ReadReal(parwykladniczy);ASK dataFile TO ReadLine(str); ASK dataFile TO ReadLine(str);

ASK dataFile TO ReadReal(parametrpierwszyErlang);ASK dataFile TO ReadLine(str);