plik

Wojskowa Akademia Techniczna

Im. Jarosława Dąbrowskiego

Przedmiot:

PODSTAWY SYMULACJI

Sprawozdanie z projektu

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

Wykonał: szer. pchor. Piotr Jakubowski

Grupa: I8C1S1

Zadanie:

Napisad program symulujący SMO jak na rysunku:

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

a) rozkład zmiennych T

: (nrDz + i) mod 6 + 1;

b) rozkład zmiennych O

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

c) L

: (nrDz + i) mod 2 + 1;

d) AL

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

e) R

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

f) M

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

g) Blokowanie zgłoszeo 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;

– zmienna losowa oznaczająca czas pomiędzy kolejnymi napływami zgłoszeo 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śd paczki zgłoszeo (wchodzących w tej samej chwili) j-tego strumienia;

– prawdopodobieostwa przemieszczenia się zgłoszenia po danym łuku;

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

AL.

– algorytmy kolejek (w przypadku istnienia kolejki z priorytetami należy przyjąd, że zgłoszenia posiadają

priorytety);

SMO

1. Rozkłady zmiennych losowych:

1.1.  Wykładniczy
1.2.  Erlanga
1.3.  Normalny
1.4.  Jednostajny
1.5.  Trójkątny
1.6.  Weibulla

2. Długości kolejek pojedynczych SMO

2.1. ograniczone (możliwe straty)
2.2. nieograniczone

3. Algorytm kolejek:

3.1.  FIFO
3.2.  LIFO
3.3.  Z priorytetami

4. Liczba stanowisk obsługi w gniazdach (1-M)
5. Ilośd zgłoszeo jednocześnie napływających do systemu (1-R)
Pozostałe dane należy określad na początku symulacji. Dane wejściowe i wyniki odczytywane/zapisywane z/do
pliku.

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



Dane

NrDz= 11.

a) rozkład zmiennych Tj: (nrDz + i) mod 6 + 1;
T1=1; rozkład Wykładniczy (Exponential(1.0/lambda)) ; czas pomiędzy kolejnymi napływami zgłoszeo do
systemu z generatora 1
T2 =2; rozkład Erlanga (Erlang(lo,hi)) ; czas pomiędzy kolejnymi napływami zgłoszeo do systemu z generatora 2

b) rozkład zmiennych Oi: (nrDz + i + 1) mod 6 + 1;
O1=2 ; rozkład Erlang (Erlang(mean,k))
O2=3 ; rozkład Normal (Normal(mean,sigma))
O3=4 ; rozkład Jednostajny (Uniform(lo,hi))

c) Li: (nrDz + i) mod 2 + 1; długości kolejek
L1=1 => kolejka ograniczona
L2=2 => kolejka nieograniczona
L3=1 => kolejka ograniczona

d) ALi: (nrDz + i + 2) mod 3 + 1; algorytmy kolejek
AL1=3;Z priorytetami
AL2=1; FIFO
AL3=2; LIFO

e) Rj = (nrDz + i + 5) mod 3 + 1; ; rozkład wielkości paczki zgłoszonego
R1=3 ; rozkład Normalny
R2=1 ; rozkład Wykładniczy (Exponential(1.0/lambda))

f) Mi = (nrDz + i + 2) mod 4 + 1; liczba stanowisk obsługi w gniazdach
M1 =3;
M2 =4;
M3 =1;

g) Klienci niecierpliwi w SMOi : Ni = (nrDz + i) mod 4 (ograniczony czas oczekiwania na rozpoczęcie obsługi);
N1 = 0; klienci cierpliwi;
N2 = 1; klienci niecierpliwi z R2=3 ; rozkład Wykładniczy ( Exponential(1.0/lambda))
N3 = 2; klienci niecierpliwi z R3=1 ; rozkład Erlanga (Erlang(mean,k))



Charakterystyka używanych rozkładów

Rozkład Weibulla

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

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

Rozkład wykładniczy

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

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

Rozkład Erlanga

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



k – określający kształt



λ – współczynnik

Funkcja gęstości:

Rozkład normalny

Wzór na gęstośd prawdopodobieostwa

Rozkład jednostajny



Kod źródłowy

MAIN MODULE PJ;

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

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

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

FROM

SimMod

IMPORT

StartSimulation,SimTime,StopSimulation,ResetSimTime,TriggerObj,

Interrupt;
  { żeby móc symulowad }

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

FROM MathMod IMPORT CEIL;


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

{STRUKTURY}

  AlgorytmKolejkowania = (FIFO,LIFO,Priorytetowa);


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

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

{DEFINICJE OBIEKTOW}

  KlientObj = OBJECT(RandomObj)
  id : INTEGER;
  priorytet : INTEGER;
  wKolejce:REAL;
  wSystemie:REAL;
  ASK METHOD Init ( IN i:INTEGER; IN p:INTEGER);
  ASK METHOD WszedlDoKolejki();
  ASK METHOD WszedlDoSystemu();

  TELL METHOD Czeka(IN s: SystemObj; IN k:KolejkaObj; IN t:REAL);
  END OBJECT;

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

  GniazdoObj = OBJECT(RandomObj)
  system:SystemObj;
  kolejkaWE : KolejkaObj;
  kolejkaWY : KolejkaObj;
  id:INTEGER;
  obslugiwany:KlientObj;
  czas:SREAL;
  liczbaStanowisk:TSINTEGER;
  liczbaZajetych:TSINTEGER;
  pstwo : REAL; {prawdopodobienstwo powrotu do gniazda}
  par1 : REAL;
  par2 : REAL;
  par3 : INTEGER;

  ASK  METHOD  Init(  IN  i:INTEGER;  IN  s:SystemObj;IN  kwy:KolejkaObj;IN  kwe:KolejkaObj;IN
ls:INTEGER;IN p1:REAL;IN p2:REAL;IN p3:INTEGER;IN ps:REAL;IN se:INTEGER);
  TELL METHOD Obsluz();
  END OBJECT;

{----------------------------------------------------------------------------------------}
  KolejkaPriorytetowaObj = OBJECT(StatRankedObj)
  OVERRIDE
      ASK METHOD Rank(IN a : ANYOBJ; IN b : ANYOBJ) : INTEGER;
  END OBJECT;

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

  KolejkaObj = OBJECT
  system         : SystemObj;
  gniazdo        : GniazdoObj;
  rodzaj         : AlgorytmKolejkowania;
  dlugosc        : INTEGER; { 0 oznacza kolejke nieskonczona }
  liczbaKlientow : TSINTEGER;  { to bedzie obliczane }
  kolejka        : BStatGroupObj;  { tu będą przechowywani klienci }
  czasCierpliwosciKlienta:REAL;   { czas cierpliwości klienta jest zależny od kolejki }

  ASK METHOD Init(   IN s:SystemObj; IN g:GniazdoObj;  IN r:AlgorytmKolejkowania;  IN dl:INTEGER);
  ASK METHOD Dodaj(  IN s:SystemObj; IN k:KlientObj);
  ASK METHOD Usun(IN k:KlientObj):KlientObj;
  END OBJECT;

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

  GeneratorObj = OBJECT(RandomObj);
  system : SystemObj;
  kolejka : KolejkaObj;      { kolejka z którą związany jest generator }
  id : INTEGER;     { id generatora (do wypisywania np.) }

  par11 : REAL;   {parametry do generatora (p3 jest do Erlanga)}
  par21 : REAL;
  par22 : INTEGER;
  par31 : REAL; {parametry zmiennej losowej ocznaczającej wielkośd paczki}
  par32 : REAL;

  liczbaJuzWygenerowanych : INTEGER;
  liczbaZgloszenDoWygenerowania : INTEGER;
  maxWielkoscPaczki : INTEGER;
  ASK METHOD Init( IN i : INTEGER; IN s : SystemObj; IN k : KolejkaObj; IN p11 : REAL; IN p21 : REAL;
IN p22 : INTEGER;IN p31 : REAL;IN p32 : REAL;IN lzdw : INTEGER;IN mwp : INTEGER;IN se : INTEGER
);      { inicjowanie zmiennych obiektu }
  TELL METHOD Wygeneruj();     { generowanie zgłoszeo }
  END OBJECT;

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

SystemObj = OBJECT
czasPrzebywaniaZgloszenia:SREAL;
liczbaZgloszen:TSINTEGER;
liczbaObsluzonychZgloszen:INTEGER;
liczbaWygenerowanych:INTEGER;
ASK METHOD Wlacz();
ASK METHOD Zwieksz();
ASK METHOD CzasWejscia(IN k:KlientObj);
ASK METHOD KlientWyszedl(IN k:KlientObj; IN zostalObsluzony:BOOLEAN);
  END OBJECT;

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

  OBJECT GeneratorObj;
  ASK METHOD Init( IN i : INTEGER;

IN s : SystemObj;

IN k : KolejkaObj;

IN p11 : REAL;

IN p21 : REAL;

IN p22 : INTEGER;

IN p31 : REAL;

IN p32 : REAL;

IN lzdw : INTEGER;

IN mwp : INTEGER;

IN se : INTEGER );

  BEGIN
      id := i;
      system := s;
    kolejka := k;
      par11 := p11;
      par21 := p21;
      par22 := p22;
      par31 := p31;
      par32 := p32;
      liczbaJuzWygenerowanych := 0;

      liczbaZgloszenDoWygenerowania := lzdw;
      maxWielkoscPaczki := mwp;
      SetSeed(se);
  END METHOD;

  TELL METHOD Wygeneruj();
  VAR
      t : REAL;
      k : KlientObj;
      wp : INTEGER; { wielkosc paczki }
      i: INTEGER; { zmienna iteracyjna }
  BEGIN
      WHILE liczbaJuzWygenerowanych < liczbaZgloszenDoWygenerowania
        CASE id

{ w zależności od id losuje czas pomiędzy zgłoszeniami i wielkosc paczki }

          WHEN 1:
            t := ASK SELF TO Exponential( par11 );
            wp := CEIL(Normal(par31,par32));

WHEN 2:

            t := ASK SELF TO Erlang( par21, par22 );
            wp := CEIL(Exponential(par31));
        END CASE;
        IF t < 0.0     { żeby nie wyszedł ujemny czas }
          t := 0.0;
        END IF;
        WAIT DURATION t
        END WAIT;
        IF wp < 0
          wp := 0;
   END IF;
        FOR i:=0 TO wp { wygeneruj tyle zgloszen,jaka jest wielkosc paczki }
          NEW (k);     { utworz nowego klienta }
          liczbaJuzWygenerowanych  :=  liczbaJuzWygenerowanych  +  1;    {zwieksz  lczbe  juz
wygenerowanych}
          ASK k TO Init (liczbaJuzWygenerowanych,UniformInt(1,5)); { przekaz id i losuj priorytet}
          ASK system TO Zwieksz;

ASK system TO CzasWejscia(k);

ASK kolejka TO Dodaj(system, k);

        END FOR;
      END WHILE;
  END METHOD;
  END OBJECT;

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

  OBJECT KolejkaPriorytetowaObj;
  ASK METHOD Rank(IN a,b : ANYOBJ) : INTEGER;
  VAR
      k1 : KlientObj;
      k2 : KlientObj;
  BEGIN
      k1 := a;

    k2 := b;
      IF ASK k1 TO priorytet < ASK k2 TO priorytet
        RETURN -1;
      END IF;
      IF ASK k1 TO priorytet > ASK k2 TO priorytet
        RETURN 1;
      END IF;
      RETURN 0;
  END METHOD;
  END OBJECT;

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

  OBJECT KlientObj;
  ASK METHOD Init ( IN i:INTEGER; IN p:INTEGER);
  BEGIN
      id := i;
      priorytet := p;
  END METHOD;

  TELL METHOD Czeka(IN s: SystemObj; IN k:KolejkaObj; IN t:REAL);
      VAR
      self:KlientObj;
  BEGIN
      IF t>0.0; { jak t = 0 klient jest baaardzo cierpliwy }
      WAIT DURATION t;
      self := ASK k TO Usun(SELF); { popros kolejke o usuniecie z niej siebie }
      ASK s TO KlientWyszedl(SELF, FALSE); { niech klient poinformuje system że zostal odrzucony}
      ON INTERRUPT;
      END WAIT;
      END IF;
  END METHOD;

  ASK METHOD WszedlDoKolejki();
  BEGIN
      wKolejce := SimTime;
  END METHOD;

  ASK METHOD WszedlDoSystemu();
  BEGIN
      wSystemie := SimTime;
  END METHOD;

  END OBJECT;

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

  OBJECT KolejkaObj;
  ASK METHOD Init(IN s:SystemObj;IN g:GniazdoObj;IN r:AlgorytmKolejkowania;IN dl:INTEGER);
  VAR
      kPrio:KolejkaPriorytetowaObj;
      kFIFO:StatQueueObj;

      kLIFO:StatStackObj;
  BEGIN
      system    := s;
      gniazdo   := g;
      rodzaj    := r;
      dlugosc   := dl;
      liczbaKlientow := 0;
      CASE rodzaj   { utworz odpowiedni rodzaj kolejki i ustaw czasy cierpliwości klientów }
        WHEN Priorytetowa:   { to jest pierwsza }
          NEW(kPrio);
          kolejka:=kPrio;
          czasCierpliwosciKlienta:=0.0;
        WHEN FIFO:           { druga }
          NEW(kFIFO);
          kolejka:=kFIFO;
          czasCierpliwosciKlienta:=1.0;
        WHEN LIFO:           { trzecia }
          NEW(kLIFO);
          kolejka:=kLIFO;
          czasCierpliwosciKlienta:=2.0;
      END CASE;
  END METHOD;

  ASK METHOD Dodaj(IN s:SystemObj;IN k:KlientObj);
  VAR
  BEGIN
      IF dlugosc > 0

{ jeżeli kolejka jest ograniczona }

IF liczbaKlientow < dlugosc

{ ale jest jeszcze miejsce na klienta }

          ASK k TO WszedlDoKolejki();
          ASK kolejka TO Add(k);   {wejscie klienta do kolejki}
          TELL k TO Czeka ( s, SELF, czasCierpliwosciKlienta );

          liczbaKlientow := liczbaKlientow + 1;

          IF ( ASK gniazdo TO liczbaZajetych ) < ( ASK gniazdo TO liczbaStanowisk )
            TELL gniazdo TO Obsluz();
          END IF;
        ELSE
          ASK system TO KlientWyszedl(k,FALSE);
        END IF;
      ELSE
        ASK k TO WszedlDoKolejki();
        ASK kolejka TO Add(k);

        liczbaKlientow := liczbaKlientow + 1;

        IF ( ASK gniazdo TO liczbaZajetych ) < ( ASK gniazdo TO liczbaStanowisk )
          TELL gniazdo TO Obsluz();
        END IF;
      END IF;
  END METHOD;

  ASK  METHOD  Usun(IN  k:KlientObj):KlientObj;    {usuwanie  klienta  z  kolejki,  zwraca  usunietego
klienta}
  VAR
      temp : KlientObj;
  BEGIN
      IF liczbaKlientow > 0

IF k = NILOBJ

temp := ASK kolejka TO Remove();

ELSE

ASK kolejka TO RemoveThis(k);

temp := k;

END IF;

        liczbaKlientow := liczbaKlientow - 1;
        RETURN temp;
      ELSE
        RETURN NILOBJ;
      END IF;
  END METHOD;
  END OBJECT;

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

  OBJECT GniazdoObj;
  ASK  METHOD  Init(  IN  i:INTEGER;IN  s:SystemObj;IN  kwy:KolejkaObj;IN  kwe:KolejkaObj;IN
ls:INTEGER; IN p1:REAL; IN p2:REAL; IN p3:INTEGER; IN ps:REAL;IN se:INTEGER     );
  BEGIN
      system := s;
      id := i;
      liczbaStanowisk := ls;
      kolejkaWE := kwe;
      kolejkaWY := kwy;
      pstwo := ps;
      par1 := p1;
      par2 := p2;
      par3 := p3;
      liczbaZajetych := 0;
  czas := 0.0;
      SetSeed(se);
  END METHOD;

  TELL METHOD Obsluz();
  VAR
      cz : REAL;
  BEGIN
      IF (((ASK kolejkaWE TO liczbaKlientow) > 0) AND (liczbaStanowisk > liczbaZajetych))
        liczbaZajetych := liczbaZajetych + 1;

        CASE id

{ przeczekaj obsluge }

          WHEN 1:
            cz := Erlang(par1,par3);
          WHEN 2:
            cz := Normal(par1,par2);

          WHEN 3:
            cz := UniformReal(par1,par2);
        END CASE;
        IF cz<0.0
          cz := 0.0;
        END IF;

        obslugiwany := ASK kolejkaWE TO Usun(NILOBJ);
        Interrupt(obslugiwany, "Czeka");

        WAIT DURATION cz;
        END WAIT;

czas := SimTime - (ASK obslugiwany TO wKolejce);

IF Sample() > pstwo;

IF ASK SELF TO id = 1; { z pierwszej sie nie wracają }

ASK kolejkaWY TO Dodaj(system, obslugiwany);

ELSE

            ASK system TO KlientWyszedl(obslugiwany, TRUE);
          END IF;
          liczbaZajetych := liczbaZajetych -1;
        ELSE

ASK kolejkaWE TO Dodaj(system, obslugiwany);

END IF;

      Obsluz();
      {TELL SELF TO Obsluz()}
  END IF;
  END METHOD;
END OBJECT;

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

  OBJECT SystemObj;

  ASK METHOD Wlacz();
  BEGIN
      czasPrzebywaniaZgloszenia := 0.0;
      liczbaZgloszen := 0;
      liczbaObsluzonychZgloszen := 0;
      liczbaWygenerowanych := 0;
  END METHOD;

  ASK METHOD CzasWejscia(IN k : KlientObj);
  BEGIN
      ASK k TO WszedlDoSystemu;
      liczbaZgloszen := liczbaZgloszen + 1;
  END METHOD;

  ASK METHOD KlientWyszedl(IN k:KlientObj; IN obs:BOOLEAN);
  BEGIN
      czasPrzebywaniaZgloszenia := (SimTime-(ASK k TO wSystemie));

      IF obs
        liczbaObsluzonychZgloszen := liczbaObsluzonychZgloszen + 1; { jeden obsluzony wiecej }
      ELSE

{ nie zostal obsluzony }

      END IF;
        liczbaZgloszen := liczbaZgloszen - 1;
  END METHOD;

  ASK METHOD Zwieksz();
  BEGIN

liczbaWygenerowanych := liczbaWygenerowanych +1;

  END METHOD;

  END OBJECT;

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

  VAR
  System:SystemObj;
  Generator1,Generator2:GeneratorObj;
  Gniazdo1,Gniazdo2,Gniazdo3:GniazdoObj;
  Kol1,Kol2,Kol3:KolejkaObj;

  pstwo2 : REAL;
  pstwo3 : REAL;
  gen1par1 : REAL; { wykladniczy }
  gen2par1  : REAL; { Erlanga     }
  gen2par2  : INTEGER;

  gen1parP1  : REAL; { parametry generowanych wielkosci paczek normalny i wykladniczy}
  gen1parP2  : REAL;
  gen2parP1  : REAL;

  gnia1par1 : REAL;  { Erlanga }
  gnia1par2 : INTEGER;

  gnia2par1 : REAL;  { normalny }
  gnia2par2 : REAL;

  gnia3par1 : REAL;  { jednostajny }
   gnia3par2 : REAL;

  dlugoscKol1,dlugoscKol3:INTEGER;
  Klient:KlientObj;

  doWygenerowania : INTEGER;

  MonCzas,MonCzasSMO1,MonCzasSMO2,MonCzasSMO3:RStatObj;

MonLiczbaZgloszenSys,MonLiczbaZajetychGn1,MonLiczbaZajetychGn2,MonLiczbaZajetychGn3,MonZ
gloszenWKolejce1,MonZgloszenWKolejce2,MonZgloszenWKolejce3:ITimedStatObj;
  pstwoObsluzenia:REAL;

  gen1Seed,gen2Seed:INTEGER;

  temp:CHAR;

  BEGIN

  pstwo2 := 0.1;
  pstwo3 := 0.1;
  gen1par1 := 4.1;
  gen2par1 := 4.0;
  gen2par2  := 1;

  gen1parP1 := 3.2;
  gen1parP2 := 3.3;
  gen2parP1 := 4.0;

  gnia1par1 := 60.2;
  gnia1par2 := 1;

  gnia2par1 := 3.3;  { normalny }
  gnia2par2 := 1.2;

  gnia3par1 := 1.1;  { jednostajny }
  gnia3par2 := 6.2;

  dlugoscKol1 := 40;
  dlugoscKol3 := 40;

  doWygenerowania := 1230;

  gen1Seed := 123;
  gen2Seed := 21;


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

  OUTPUT("                          PODAJ PARAMETRY:                         ");
  OUTPUT("*******************************************************************");
  OUTPUT("");

  REPEAT
      OUTPUT("Dlugosc kolejki nr 1 (>0):");
      INPUT(dlugoscKol1);
  UNTIL(dlugoscKol1>1);

  REPEAT
      OUTPUT("Dlugosc kolejki nr 3 (>0) :");
      INPUT(dlugoscKol3);
  UNTIL(dlugoscKol3>1);

  REPEAT
      OUTPUT("Ilosc klientow do wygenerowania przez kazdy z generatorow  (>0): ");
      INPUT( doWygenerowania );
  UNTIL(doWygenerowania>1);

  REPEAT
      OUTPUT("Prawdopodobienstwo powrotu do gniazda 2: ");
      INPUT(pstwo2);
  UNTIL( (pstwo2>0.0) AND (pstwo2<1.0) );

  REPEAT
      OUTPUT("Prawdopodobienstwo powrotu do gniazda 3: ");
      INPUT(pstwo3);
  UNTIL( (pstwo3>0.0) AND (pstwo3<1.0) );

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

  OUTPUT("                   PARAMETRY GENERATORA NR 1:                      ");
  OUTPUT("*******************************************************************");
  OUTPUT("");

  REPEAT
      OUTPUT("Podaj wartosc oczekiwana rozkladu wykladniczego generatora nr 1: ");
      INPUT(gen1par1);
  UNTIL( gen1par1>0.0 );

  REPEAT
      OUTPUT("Podaj wartosc oczekiwana rozkladu normalnego generowanych paczek zgłoszen nr 1: ");
      INPUT(gen1parP1);
  UNTIL( gen1parP1>0.0 );

  REPEAT
      OUTPUT("Podaj odchylenie standartowe rozkladu normalnego generowanych paczek zgłoszen nr
1: ");
      INPUT(gen1parP2);
  UNTIL( gen1parP2>0.0 );

  OUTPUT("Podaj ziarno dla pierwszego generatora");
  INPUT(gen1Seed);

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

  OUTPUT("                   PARAMETRY GENERATORA NR 2:                      ");
  OUTPUT("*******************************************************************");
  OUTPUT("");

REPEAT
      OUTPUT("Podaj wartosc oczekiwana rozkladu Erlanga: ");
      INPUT(gen2par1);
  UNTIL( gen2par1>0.0 );

  REPEAT
      OUTPUT("Podaj liczbę stopni swobody generatora 2 rozkladu Erlanga: ");
      INPUT(gen2par2);
  UNTIL( gen2par2>=1 );

  REPEAT
      OUTPUT("Podaj w.oczekiwana rozkladu wykladniczego generowanych paczek zgloszen: ");
      INPUT(gen2parP1);
  UNTIL( gen2parP1>=0.0 );

  OUTPUT("Podaj ziarno dla drugiego generatora");
  INPUT(gen2Seed);

  OUTPUT("Parametry gniazda nr 1:");
  OUTPUT("");

  REPEAT
      OUTPUT("Podaj wartosc oczekiwana rozkladu wykladniczego");
      INPUT(gnia2par1);
  UNTIL( gnia2par1>=0.0 );

  OUTPUT("Parametry gniazda nr 2:");
  OUTPUT("");

  REPEAT
      OUTPUT("Podaj wartosc oczekwana rozkladu normalnego: ");
      INPUT(gnia2par1);
  UNTIL( gnia2par1>=0.0 );

  REPEAT
      OUTPUT("Podaj odchylenie standartowe rozkladu normalnego: ");
      INPUT(gnia2par2);
  UNTIL( gnia2par2>=0.0 );

  OUTPUT("Parametry gniazda nr 3:");
  OUTPUT("");

  REPEAT
      OUTPUT("Podaj parametr min rozkladu jednostajnego: ");
      INPUT(gnia3par1);
  UNTIL( gnia3par1>=0.0 );

  REPEAT
      OUTPUT("Podaj parametr max rozkladu jednostajnego (>min): ");
      INPUT(gnia3par2);
  UNTIL( gnia3par2 >= gnia3par1 );

NEW(System);
NEW(Gniazdo1);
NEW(Gniazdo2);
NEW(Gniazdo3);
NEW(Kol1);
NEW(Kol2);
NEW(Kol3);
NEW(Generator1) ;
NEW(Generator2) ;

ASK System TO Wlacz();

ASK Kol1 TO Init (System, Gniazdo1, Priorytetowa, dlugoscKol1);
ASK Kol2 TO Init (System, Gniazdo2, FIFO , 0);
ASK Kol3 TO Init (System, Gniazdo3, LIFO, dlugoscKol3);

ASK Generator1 TO Init(1,System, Kol1,gen1par1, 0.0,0  ,gen1parP1,gen1parP2,doWygenerowania,
3, gen1Seed);
ASK

Generator2

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

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.