Wojskowa   Akademia   Techniczna 

im. Jarosława Dąbrowskiego 

 

 

 

 

 

PODSTAWY SYMULACJI 

Sprawozdanie z Projektu 

Temat: Program symulujący działanie sieci SMO. 

 

 

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

 

 

 

 

 

 

 

 

Wykonał:   Marcin Przerwa 

 

 

 

 

Grupa:  

I7G2S1 

1.  Treśd zadania 3. 

 
 

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

j

: (nrDz + i) mod 6 + 1; 

b)  rozkład zmiennych O

i

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

c)  L

i

: (nrDz + i) mod 2 + 1; 

d)  AL

i

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

e)  R

j

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

f)  M

i

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

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

i

 : N

i

 = (nrDz + i)  mod 4 (ograniczony czas oczekiwania na rozpoczęcie 

obsługi); 

gdzie: 

i – numer SMO; 

j – numer strumienia; 

T

j

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

strumienia; 

p

k

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

L

i

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

AL.

i

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

posiadają priorytety); 

1.  Rozkłady zmiennych losowych: 

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

2.  Długości kolejek pojedynczych SMO 

SMO 

O

2 

SMO 

O

3 

SMO 

O

1 

T

1 

p

2 

p

3 

T

2 

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. 

2.  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łoszeo 

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

 
 
 
 

 

3.  Sposób rozwiązania. 

 

 

 

 

 

 

 
 

4.  Kod źródłowy. 

MAIN MODULE Przerwa; 
 
FROM IOMod IMPORT ReadKey; 
  { Zatrzymuje ostatni ekran dla użytkownika } 
 
FROM RandMod IMPORT RandomObj ,FetchSeed; 
  { generowanie liczb pseudolosowych} 
 
FROM SimMod IMPORT StartSimulation,SimTime,StopSimulation,ResetSimTime,TriggerObj, Interrupt; 
 
FROM StatMod IMPORT SINTEGER,RStatObj,SREAL,TSINTEGER,ITimedStatObj; 
 
FROM GrpMod IMPORT StatQueueObj,StatStackObj,StatRankedObj,BStatGroupObj; 
  { podstawowe struktury danych } 
 
FROM MathMod IMPORT CEIL; 
  { ceil wykorzystanie do zaokrągleo wielkości paczki } 
 
 
 
 
 
 
 
 

                             {TYPY} 
{**********************************************************************************} 
TYPE 
 
 

 

{STRUKTURY} 

 
  AlgorytmKolejkowania = (FIFO,LIFO,Priorytetowa); 
    { dla czytelności (lepsze niż np. INTEGERY) } 
 
 
  GeneratorObj = OBJECT; FORWARD; 
  KlientObj = OBJECT; FORWARD; 
  KolejkaObj = OBJECT; FORWARD; 
  GniazdoObj = OBJECT; FORWARD; 
  SystemObj = OBJECT; FORWARD; 
    { definicje wyprzedzające } 
 
 
 

 

{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  
          NEW (k);     { utworz nowego klienta } 
          liczbaJuzWygenerowanych := liczbaJuzWygenerowanych + 1;  {zwieksz lczbe juz wygenerowanych} 
          ASK k TO Init (liczbaJuzWygenerowanych,UniformInt(1,5));  
          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;  
 

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

 { nie zostal obsluzony } 

      END IF; 
        liczbaZgloszen := liczbaZgloszen - 1; 
    END METHOD;  
 
    ASK METHOD Zwieksz(); 
    BEGIN 
 

liczbaWygenerowanych := liczbaWygenerowanych +1; 

    END METHOD; 
 
  END OBJECT; 
 
{**********************************************************************************} 
 
  VAR 
    System:SystemObj; 
    Generator1,Generator2:GeneratorObj; 
    Gniazdo1,Gniazdo2,Gniazdo3:GniazdoObj; 
    Kol1,Kol2,Kol3:KolejkaObj; 
 
    pstwo2 : REAL; 
    pstwo3 : REAL; 
    gen1par1 : REAL; { wykladniczy } 
    gen2par1  : REAL; { Erlanga     } 
    gen2par2  : INTEGER; 
 
    gen1parP1  : REAL; { parametry generowanych wielkosci paczek normalny i wykladniczy} 
    gen1parP2  : REAL; 
    gen2parP1  : REAL; 
 
    gnia1par1 : REAL;  { Erlanga } 
    gnia1par2 : INTEGER; 
 
    gnia2par1 : REAL;  { normalny } 
    gnia2par2 : REAL; 
   

    gnia3par1 : REAL;  { jednostajny } 
    gnia3par2 : REAL; 
 
    dlugoscKol1,dlugoscKol3:INTEGER; 
    Klient:KlientObj; 
 
    doWygenerowania : INTEGER; 
     
    MonCzas,MonCzasSMO1,MonCzasSMO2,MonCzasSMO3:RStatObj; 
    
MonLiczbaZgloszenSys,MonLiczbaZajetychGn1,MonLiczbaZajetychGn2,MonLiczbaZajetychGn3,MonZgloszenWKolejce1,MonZgloszenWKole
jce2,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("********************** Marcin Przerwa I7G2S1 **********************"); 
    OUTPUT("*******************************************************************"); 
    OUTPUT("");   
 
    OUTPUT("*******************************************************************");   

 

    OUTPUT("************************* PODAJ PARAMETRY: ************************"); 
    OUTPUT("*******************************************************************"); 
    OUTPUT(""); 
 
    REPEAT 
      OUTPUT("Dlugosc kolejki nr 1 (>0):"); 
      INPUT(dlugoscKol1); 
    UNTIL(dlugoscKol1>1); 
 
    REPEAT 
      OUTPUT("Dlugosc kolejki nr 3 (>0) :"); 
      INPUT(dlugoscKol3); 
    UNTIL(dlugoscKol3>1); 
 
    REPEAT 
      OUTPUT("Ilosc klientow do wygenerowania przez kazdy z generatorow  (>0): "); 

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

 

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

 

 
    REPEAT 
      OUTPUT("Podaj wartosc oczekiwana rozkladu normalnego generowanych paczek zgłoszen nr 1: "); 
      INPUT(gen1parP1); 
    UNTIL( gen1parP1>0.0 ); 
 
 
    REPEAT 
      OUTPUT("Podaj odchylenie standartowe rozkladu normalnego generowanych paczek zgłoszen nr 1: "); 
      INPUT(gen1parP2); 
    UNTIL( gen1parP2>0.0 ); 
 
 
    OUTPUT("Podaj ziarno dla pierwszego generatora"); 
    INPUT(gen1Seed); 
 
 
    OUTPUT("*******************************************************************");   

 

    OUTPUT("******************* PARAMETRY GENERATORA NR 2: ********************"); 
    OUTPUT("*******************************************************************"); 
    OUTPUT(""); 
 
    REPEAT 
      OUTPUT("Podaj wartosc oczekiwana rozkladu Erlanga: "); 
      INPUT(gen2par1); 
    UNTIL( gen2par1>0.0 ); 
 
    REPEAT 
      OUTPUT("Podaj liczbę stopni swobody generatora 2 rozkladu Erlanga: "); 
      INPUT(gen2par2); 
    UNTIL( gen2par2>=1 ); 
 
 
    REPEAT 
      OUTPUT("Podaj w.oczekiwana rozkladu wykladniczego generowanych paczek zgloszen: "); 
      INPUT(gen2parP1); 
    UNTIL( gen2parP1>=0.0 ); 
 
 
    OUTPUT("Podaj ziarno dla drugiego generatora"); 
    INPUT(gen2Seed); 
 

 

 
    OUTPUT("Parametry gniazda nr 1:"); 
    OUTPUT(""); 
 
    REPEAT 
      OUTPUT("Podaj wartosc oczekiwana rozkladu wykladniczego"); 

      INPUT(gnia2par1); 
    UNTIL( gnia2par1>=0.0 ); 
 
 
    OUTPUT("Parametry gniazda nr 2:"); 
    OUTPUT(""); 
 
    REPEAT 
      OUTPUT("Podaj wartosc oczekwana rozkladu normalnego: "); 
      INPUT(gnia2par1); 
    UNTIL( gnia2par1>=0.0 ); 
 
    REPEAT 
      OUTPUT("Podaj odchylenie standartowe rozkladu normalnego: "); 
      INPUT(gnia2par2); 
    UNTIL( gnia2par2>=0.0 ); 
 
    OUTPUT("Parametry gniazda nr 3:"); 
    OUTPUT(""); 
 
    REPEAT 
      OUTPUT("Podaj parametr min rozkladu jednostajnego: "); 
      INPUT(gnia3par1); 
    UNTIL( gnia3par1>=0.0 ); 
 
    REPEAT 
      OUTPUT("Podaj parametr max rozkladu jednostajnego (>min): "); 
      INPUT(gnia3par2); 
    UNTIL( gnia3par2 >= gnia3par1 ); 
 
 
   NEW(System); 
   NEW(Gniazdo1);  
   NEW(Gniazdo2); 
   NEW(Gniazdo3);     
   NEW(Kol1); 
   NEW(Kol2); 
   NEW(Kol3); 
   NEW(Generator1) ; 
   NEW(Generator2) ; 
 
   ASK System TO Wlacz(); 
 
   ASK Kol1 TO Init (System, Gniazdo1, Priorytetowa, dlugoscKol1);     
   ASK Kol2 TO Init (System, Gniazdo2, FIFO , 0);  
   ASK Kol3 TO Init (System, Gniazdo3, LIFO, dlugoscKol3); 
 
   ASK Generator1 TO Init(1,System, Kol1,gen1par1, 0.0,0  ,gen1parP1,gen1parP2,doWygenerowania, 3, gen1Seed); 
   ASK Generator2 TO Init(2,System, Kol3,0.0     ,gen2par1,gen2par2 ,gen2parP1,0.0,doWygenerowania, 1, gen2Seed); 
 
   ASK Gniazdo1 TO Init(1, System, Kol2,   Kol1, 1,gnia1par1, 0.0,gnia1par2, 0.0,gen1Seed); 
   ASK Gniazdo2 TO Init(2, System, NILOBJ, Kol2, 2,gnia2par1,gnia2par2,0, pstwo2,gen2Seed); 
   ASK Gniazdo3 TO Init(3, System, NILOBJ, Kol3, 3,gnia3par1,gnia3par2,0, pstwo3,gen1Seed+gen2Seed); 
 
 
   TELL Generator1 TO Wygeneruj(); 
   TELL Generator2 TO Wygeneruj(); 
 
   StartSimulation; 
 
 
   MonCzas := GETMONITOR(ASK System TO czasPrzebywaniaZgloszenia,RStatObj);  
   MonCzasSMO1 := GETMONITOR(ASK Gniazdo1 TO czas,RStatObj); 
   MonCzasSMO2 := GETMONITOR(ASK Gniazdo2 TO czas,RStatObj); 
   MonCzasSMO3 := GETMONITOR(ASK Gniazdo3 TO czas,RStatObj);    
   MonLiczbaZgloszenSys := GETMONITOR(ASK System TO liczbaZgloszen,ITimedStatObj); 
   MonLiczbaZajetychGn1 := GETMONITOR(ASK Gniazdo1 TO liczbaZajetych,ITimedStatObj); 
   MonLiczbaZajetychGn2 := GETMONITOR(ASK Gniazdo2 TO liczbaZajetych,ITimedStatObj); 
   MonLiczbaZajetychGn3 := GETMONITOR(ASK Gniazdo3 TO liczbaZajetych,ITimedStatObj); 
   MonZgloszenWKolejce1 := GETMONITOR(ASK Kol1 TO liczbaKlientow,ITimedStatObj); 
   MonZgloszenWKolejce2 := GETMONITOR(ASK Kol2 TO liczbaKlientow,ITimedStatObj); 

   MonZgloszenWKolejce3 := GETMONITOR(ASK Kol3 TO liczbaKlientow,ITimedStatObj); 
 
   pstwoObsluzenia := FLOAT(ASK System TO liczbaObsluzonychZgloszen)/FLOAT(ASK System TO liczbaWygenerowanych); 
 
 
   OUTPUT(""); 
   OUTPUT("||||====================================|||"); 
   OUTPUT("|||||||| WYNIKI DZIALANIA SYMULACJI: ||||||"); 
   OUTPUT("||||====================================|||"); 
   OUTPUT(""); 
   OUTPUT("|||Liczba wygenerowanych: ",ASK System TO liczbaWygenerowanych); 
   OUTPUT(""); 
   OUTPUT("|||Czas przebywania zgloszenia w systemie:"); 
   OUTPUT("|||Wartosc srednia ",ASK MonCzas TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonCzas TO StdDev); 
   OUTPUT(""); 
   OUTPUT("|||Czas przebywania zgloszenia w SMO 1:"); 
   OUTPUT("|||Wartosc srednia ",ASK MonCzasSMO1 TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonCzasSMO1 TO StdDev); 
   OUTPUT(""); 
   OUTPUT("|||Czas przebywania zgloszenia w SMO 2:"); 
   OUTPUT("|||Wartosc srednia ",ASK MonCzasSMO2 TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonCzasSMO2 TO StdDev); 
   OUTPUT(""); 
   OUTPUT("|||Czas przebywania zgloszenia w SMO 3:"); 
   OUTPUT("|||Wartosc srednia ",ASK MonCzasSMO3 TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonCzasSMO3 TO StdDev); 
   OUTPUT("");  
 
   OUTPUT("|||Liczba klientow w systemie: "); 
   OUTPUT("|||Wartosc srednia ",ASK MonLiczbaZgloszenSys TO Mean); 
   OUTPUT("|||Odchylenie standardowe",ASK MonLiczbaZgloszenSys TO StdDev); 
   OUTPUT(""); 
 
   OUTPUT("|||Liczba zajetych kanalow w gniezdzie 1:"); 
   OUTPUT("|||Wartosc srednia ",ASK MonLiczbaZajetychGn1 TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonLiczbaZajetychGn1 TO StdDev); 
   OUTPUT(""); 
   OUTPUT("|||Liczba zajetych kanalow w gniezdzie 2:"); 
   OUTPUT("|||Wartosc srednia ",ASK MonLiczbaZajetychGn2 TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonLiczbaZajetychGn2 TO StdDev); 
   OUTPUT(""); 
   OUTPUT("|||Liczba zajetych kanalow w gniezdzie 3:"); 
   OUTPUT("|||Wartosc srednia ",ASK MonLiczbaZajetychGn3 TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonLiczbaZajetychGn3 TO StdDev); 
   OUTPUT(""); 
 
   OUTPUT("|||Liczba klientow w kolejce 1 (priorytetowej):"); 
   OUTPUT("|||Wartosc srednia ",ASK MonZgloszenWKolejce1 TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonZgloszenWKolejce1 TO StdDev); 
   OUTPUT(""); 
   OUTPUT("|||Liczba klientow w kolejce 2 (FIFO):"); 
   OUTPUT("|||Wartosc srednia ",ASK MonZgloszenWKolejce2 TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonZgloszenWKolejce2 TO StdDev); 
   OUTPUT(""); 
   OUTPUT("|||Liczba klientow w kolejce 3 (LIFO):"); 
   OUTPUT("|||Wartosc srednia ",ASK MonZgloszenWKolejce3 TO Mean); 
   OUTPUT("|||Odchylenie standardowe: ",ASK MonZgloszenWKolejce3 TO StdDev); 
   OUTPUT(""); 
 
   OUTPUT("|||Prawdopodobienstwo obsluzenia klienta w systemie: ",pstwoObsluzenia);  
   OUTPUT(""); 
     
   DISPOSE(Kol1); 
   DISPOSE(Kol2); 
   DISPOSE(Kol3); 
   DISPOSE(Generator1); 
   DISPOSE(Generator2); 
   DISPOSE(Gniazdo1); 
   DISPOSE(Gniazdo2); 
   DISPOSE(Gniazdo3); 

   DISPOSE(System); 
 
   OUTPUT("Nacisnij cos, aby zakonczyc program."); 
   temp := ReadKey; 
    
END MODULE;