public void dodaj(Zgloszenie zglaszam)
{
//Zgloszenie nowy = new Zgloszenie(ileKanlowDlaZgloszenia, maksCzasOczekiwaniaZgloszenia);
wskaznik++;
if (pojemnosc == 0)
{
wskaznik--;
return;
}
if (wskaznik == 1)
{
element[0] = zglaszam;
return;
}
if (wskaznik > 1 && wskaznik < pojemnosc)
{
element[wskaznik - 1] = zglaszam;
}
else
{
wskaznik--;
return;
}
}
public void usunDanyElement(int wsk)
{
Zgloszenie[] zgloszenieNowe = new Zgloszenie[3 * pojemnosc];
int j = 0;
while (j != wsk)
{
zgloszenieNowe[j] = element[j];
j++;
}
while (j != pojemnosc - 1)
{
zgloszenieNowe[j] = element[wsk + 1];
j++;
}
element = zgloszenieNowe;
wskaznik--;
}
public void symulacja()
{
double temp;
double[] kolejkaCzas = new double[rozmiarKolejki];
Array.Resize(ref czasPolaczenia, liczbaKanalow);
Console.WriteLine("Podaj czas symulacji: ");
temp = double.Parse(Console.ReadLine());
czasSymulacji = TimeSpan.FromMilliseconds(temp);
aktualnyCzas = new TimeSpan(0,0,0,0,0);
int st=0;
int k, liczbaKanalow_temp = liczbaKanalow, indeksZgloszeniaWsystemie, biezacyRozmiarFifo;
int[] liczbaKanSystem = new int[liczbaKanalow];
TimeSpan[] czasWsystemie =new TimeSpan[liczbaKanalow];
TimeSpan[] czasWkolejce = new TimeSpan[rozmiarKolejki];
TimeSpan[] odstep = new TimeSpan[liczbaStrumieni];
zgloszenie = new Zgloszenie[liczbaStrumieni];
Zgloszenie[] zgloszenieWsystemie = new Zgloszenie[liczbaKanalow];
Zgloszenie zgloszenieWfifo;
kolejka = new Fifo(rozmiarKolejki);
liczbaOdrzuconych = 0;
iloscOdwiedzenSystemu = 0;
indeksZgloszeniaWsystemie = 0;
liczbaZgloszen=0;
iloscZgloszenWFifo = 0;
liczbaZgloszenNaWiazce = 0;
do
{
przypisanieRozkladow();
for (int i = 0; i < liczbaStrumieni; i++)
{
strumien[i] = new Strumien(czasPomiedzyZgloszeniami[i], czasPolaczenia[i], liczbaKanalowZgloszenia[i], maxCzasOczekiwania[i]);
}
for (int i = 0; i < liczbaStrumieni; i++)
{
czasPolaczenia[i] = 0;
Zgloszenie zgl = new Zgloszenie();
lista.dodaj(zgl, aktualnyCzas);
if(odstep[i] == TimeSpan.Zero)
{
liczbaZgloszen++;
zgloszenie[i] = lista.usun();
zgloszenie[i].ilosc_kanalow = strumien[i].liczbaKanalowZwroc();
zgloszenie[i].czas_trwania = strumien[i].czasPolaczeniaZwroc();
zgloszenie[i].maks_czas_oczekiwania = strumien[i].czasOczekiwaniaZwroc();
czasPomiedzyZgloszeniami[i] = strumien[i].czasDoNastepnegoZwroc();
odstep[i] = TimeSpan.FromMilliseconds(czasPomiedzyZgloszeniami[i]);
//sprawdzamy zawartosc kolejki
if (kolejka.zwrocRozmiar() == 0)
k = 1;
else if (kolejka.zwrocRozmiar() == rozmiarKolejki) k = 2;
else k = 3;
switch (k)
{
case 1: //przypadek, gdy kolejka jest pusta (jesli kanaly wolne to wrzucamy, jesli nie to do kolejki)
if (liczbaKanalow_temp >= zgloszenie[i].iloscKanalowZwroc())
{
iloscOdwiedzenSystemu++;//zmienna do statystyki
liczbaKanalow_temp = liczbaKanalow_temp - zgloszenie[i].iloscKanalowZwroc();
indeksZgloszeniaWsystemie = 0;
while (liczbaKanSystem[indeksZgloszeniaWsystemie] != 0)
{
indeksZgloszeniaWsystemie++;
}
liczbaKanSystem[indeksZgloszeniaWsystemie] = zgloszenie[i].iloscKanalowZwroc();
czasWsystemie[indeksZgloszeniaWsystemie] = TimeSpan.FromMilliseconds(zgloszenie[i].czas_trwania); ///sprawdzic
czasPolaczenia[indeksZgloszeniaWsystemie] = zgloszenie[i].czasTrwaniaZwroc();//?
statystyki.zwiekszCzasObslugi(czasWsystemie[indeksZgloszeniaWsystemie]);
liczbaZgloszenNaWiazce++; //zmienna do statystyki
st++;
}
else
{
if(st != 0)
{
statystyki.zwiekszZajetoscWiazki();
st = 0;
}
kolejka.dodaj(zgloszenie[i]);
if (kolejka.zwrocRozmiar() != 0)
{
iloscZgloszenWFifo++;//zmienna do statystyki
czasWkolejce[kolejka.zwrocRozmiar() - 1] = TimeSpan.FromMilliseconds(zgloszenie[i].maksCzasOczekiwaniaZwroc());
if (kolejka.zwrocRozmiar() == rozmiarKolejki - 1)
{
statystyki.zwiekszZajetoscKolejki();
}
}
else
liczbaOdrzuconych++;//zmienna do statystyki
}
break;
case 2: //kolejka pelna, zgloszenie odrzucone
liczbaOdrzuconych++;
break;
case 3: //wrzucanie do bufora
kolejka.dodaj(zgloszenie[i]);
if (kolejka.zwrocRozmiar() != 0)
{
iloscZgloszenWFifo++;
czasWkolejce[i] = TimeSpan.FromMilliseconds(zgloszenie[i].maksCzasOczekiwaniaZwroc());
if (kolejka.zwrocRozmiar() == rozmiarKolejki - 1)
{
statystyki.zwiekszZajetoscKolejki();
}
}
else
liczbaOdrzuconych++;
break;
}
}
}
// nastepnym etapem jest porownywanie najpierw czasow odstepu na strumieniach, potem czasow trwania polaczenia w systemie, porownania najmniejszych
// wynikow ze soba, uzyskanym wynikiem jest najkrotszy czas od danej chwili czasu, ktory bedzie wyznacznikiem nastepnego kroku symulacji
//porownywanie czasow
TimeSpan nastepnyEtap = new TimeSpan();
for (int i = 0; i < liczbaStrumieni - 1; i ++) //porownanie czasow odstepu
{
if (liczbaStrumieni > 1 && odstep[i+1] != TimeSpan.Zero)
{
if (odstep[i].CompareTo(odstep[i + 1]) < 0)
{
nastepnyEtap = odstep[i];
}
else
{
nastepnyEtap = odstep[i+1];
}
}
else
{
nastepnyEtap = odstep[i];
}
}
TimeSpan nastepnyEtap2 = new TimeSpan();
for (int i = 0; i < iloscOdwiedzenSystemu; i++) //porownanie czasow trwania polaczenia w systemie
{
if (czasWsystemie[1] != TimeSpan.Zero)
{
if (iloscOdwiedzenSystemu > 1 && czasWsystemie[i + 1] != TimeSpan.Zero)
{
if (i > 0)
{
if (nastepnyEtap2.CompareTo(czasWsystemie[i + 1]) < 0)
{
;
}
else
{
nastepnyEtap2 = czasWsystemie[i + 1];
}
}
else
{
if (czasWsystemie[i].CompareTo(czasWsystemie[i + 1]) < 0)
{
nastepnyEtap2 = czasWsystemie[i];
}
else
{
nastepnyEtap2 = czasWsystemie[i + 1];
}
}
}
else
{
if (nastepnyEtap2.CompareTo(czasWsystemie[i + 1]) < 0)
;
else
{
if (czasWsystemie[i + 1] != TimeSpan.Zero && i != 0)
nastepnyEtap2 = czasWsystemie[i + 1];
}
if (i == 0)
nastepnyEtap2 = czasWsystemie[0];
}
}
else
{
nastepnyEtap2 = czasWsystemie[0];
}
}
if (nastepnyEtap.CompareTo(nastepnyEtap2) < 0 && nastepnyEtap != TimeSpan.Zero)
{
aktualnyCzas = aktualnyCzas + nastepnyEtap;
Zgloszenie doWyrzucenia;
//odejmowanie najkrotszego czasu dla czasow odstepu
for (int i = 0; i <liczbaStrumieni;i++)
{
odstep[i] = odstep[i] - nastepnyEtap;// TimeSpan.FromMilliseconds(czasPomiedzyZgloszeniami[i]);
}
//odejmowanie najkrotszego czasu dla czasow w systemie
for (int i = 0; i < iloscOdwiedzenSystemu; i++)
{
if (czasWsystemie[i] != TimeSpan.FromMilliseconds(0.0))
{
czasWsystemie[i] = czasWsystemie[i] - nastepnyEtap;
}
}
TimeSpan wyrzuc;
//obsluzenie czasowe w kolejce: sprawdzenie czy maksczas oczekiwania nie zostalprzekroczony, jesli nie to zwykle odejmowanie
if (kolejka.zwrocRozmiar() != 0)
{
doWyrzucenia = kolejka.zwrocElementKolejki(kolejka.zwrocRozmiar() - 1);
wyrzuc = TimeSpan.FromMilliseconds(doWyrzucenia.maksCzasOczekiwaniaZwroc());
if (wyrzuc <= nastepnyEtap)
{
liczbaOdrzuconych++;
kolejka.usun();
}
else
{
for (int i = 0; i < kolejka.zwrocRozmiar(); i++)
{
czasWkolejce[i] = TimeSpan.FromMilliseconds(doWyrzucenia.maksCzasOczekiwaniaZwroc()) - nastepnyEtap;
}
}
}
}
else //przypadek, gdy najkrtoszym czasem jest jeden z czasow trwania obslugi polaczenia na kanalach
//wtedy dane zgloszenie konczy transmisje i, jezeli liczba kanalow zgloszenia ostatniego w kolejce
//jest niewieksza niz ilosc kanalow dostepnych, wtedy dane zgloszenie obslugujemy i zwalniamy miejsce w kolejce
{
if (nastepnyEtap2 != TimeSpan.Zero) //przypadek gdy czasy polaczenia w systemie byly krotsze, wtedy wszystkie sa wyzerowane
{
aktualnyCzas = aktualnyCzas + nastepnyEtap2;
//odejmowanie najkrotszego czasu dla czasow odstepu
for (int i = 0; i < liczbaStrumieni; i++)
{
odstep[i] = odstep[i] - nastepnyEtap2;
}
//obsluga czasow w systemie
for (int j = 0; j < indeksZgloszeniaWsystemie + 1; j++)
{
if (czasWsystemie[j] != TimeSpan.Zero)
{
czasWsystemie[j] = czasWsystemie[j] - nastepnyEtap2;
}
}
for (int j = 0; j < indeksZgloszeniaWsystemie + 1; j++)
{
if (czasWsystemie[j] == TimeSpan.Zero)
{
if (j != indeksZgloszeniaWsystemie)
{
for (int i = 0; i < indeksZgloszeniaWsystemie; i++)
{
TimeSpan tmp;
int ttmp = liczbaKanSystem[i];
tmp = czasWsystemie[i];
if (tmp > TimeSpan.Zero)
{
;
}
else
{
liczbaKanSystem[i] = liczbaKanSystem[i + 1];
liczbaKanSystem[i + 1] = ttmp;
czasWsystemie[i] = czasWsystemie[i + 1];
czasWsystemie[i + 1] = tmp;
}
}
}
}
}
if (czasWsystemie[indeksZgloszeniaWsystemie] == TimeSpan.Zero)
{
iloscOdwiedzenSystemu--;
liczbaKanalow_temp = liczbaKanalow_temp + liczbaKanSystem[indeksZgloszeniaWsystemie];
liczbaKanSystem[indeksZgloszeniaWsystemie] = 0;
}
biezacyRozmiarFifo = kolejka.zwrocRozmiar();
if (biezacyRozmiarFifo != 0)
{
zgloszenieWfifo = kolejka.zwrocElementKolejki(biezacyRozmiarFifo - 1);
if (zgloszenieWfifo.iloscKanalowZwroc() <= liczbaKanalow_temp)// jesli element kolejki ma zapotrzebowanie kanalowe niewieksze od zwolnionego, to zostaje obsluzony przez system
{
zgloszenieWfifo = kolejka.usun();
iloscOdwiedzenSystemu++;
indeksZgloszeniaWsystemie = 0;
while (liczbaKanSystem[indeksZgloszeniaWsystemie] != 0)
{
indeksZgloszeniaWsystemie++;
}
liczbaKanSystem[indeksZgloszeniaWsystemie] = zgloszenieWfifo.iloscKanalowZwroc();
czasWsystemie[indeksZgloszeniaWsystemie] = TimeSpan.FromMilliseconds(zgloszenieWfifo.czasTrwaniaZwroc()); ///sprawdzic
czasPolaczenia[indeksZgloszeniaWsystemie] = zgloszenieWfifo.czasTrwaniaZwroc();//?
statystyki.zwiekszCzasObslugi(czasWsystemie[indeksZgloszeniaWsystemie]);
liczbaZgloszenNaWiazce++;
liczbaKanalow_temp = liczbaKanalow_temp - zgloszenieWfifo.iloscKanalowZwroc();
}
else if (TimeSpan.FromMilliseconds(zgloszenieWfifo.maksCzasOczekiwaniaZwroc()) <= nastepnyEtap2)
{
kolejka.usun();
liczbaOdrzuconych++;
}
}
}
else // jesli wszystkie czasy polaczenia zerowe, wtedy -- czasy odstepu
{
aktualnyCzas = aktualnyCzas + nastepnyEtap;
Zgloszenie doWyrzucenia;
//odejmowanie najkrotszego czasu dla czasow odstepu
for (int i = 0; i < liczbaStrumieni; i++)
{
odstep[i] = odstep[i] - nastepnyEtap;// TimeSpan.FromMilliseconds(czasPomiedzyZgloszeniami[i]);
}
//odejmowanie najkrotszego czasu dla czasow w systemie
for (int i = 0; i < iloscOdwiedzenSystemu; i++)
{
if (czasWsystemie[i] != TimeSpan.FromMilliseconds(0.0))
{
czasWsystemie[i] = czasWsystemie[i] - nastepnyEtap;
}
}
//obsluzenie czasowe w kolejce: sprawdzenie czy maksczas oczekiwania nie zostalprzekroczony, jesli nie to zwykle odejmowanie
if (kolejka.zwrocRozmiar() != 0)
{
for (int i = 0; i < kolejka.zwrocRozmiar(); i++)
{
doWyrzucenia = kolejka.zwrocElementKolejki(i);
if (TimeSpan.FromMilliseconds(doWyrzucenia.maksCzasOczekiwaniaZwroc()) <= nastepnyEtap)
{
liczbaOdrzuconych++;
kolejka.usunDanyElement(i);
}
else
{
czasWkolejce[i] = TimeSpan.FromMilliseconds(doWyrzucenia.maksCzasOczekiwaniaZwroc()) - nastepnyEtap;
}
}
}
}
}
}
while(czasSymulacji >= aktualnyCzas);
sredniaZajetoscWiazki = statystyki.zajetoscWiazkiZwroc(liczbaZgloszenNaWiazce);
sredniCzasObslugi = statystyki.sredniCzasObslugiZwroc();
sredniaZajetoscKolejki = statystyki.zajetoscKolejkiZwroc(iloscZgloszenWFifo);
statystyki.obliczPstwoOdrzucenia(liczbaZgloszen, liczbaOdrzuconych);
prawdopodobienstwoOdrzucenia = statystyki.pstwoOdrzuceniaZwroc();
zapisz();
}
//konstruktor domyslny
public Symulacja()
{
//wczytywanie wszystkich parametrow
wczytywanie();
//inicjacje parametrow
lista = new Kolejka.DrzewoTurniejowe<Zgloszenie,TimeSpan>();
aktualnyCzas = new TimeSpan();
czasSymulacji = new TimeSpan();
strumien = new Strumien[liczbaStrumieni];
statystyki = new Statystyki();
przypisanieRozkladow();
for(int i = 0; i < liczbaStrumieni; i++)
{
strumien[i] = new Strumien(czasPomiedzyZgloszeniami[i], czasPolaczenia[i], liczbaKanalowZgloszenia[i], maxCzasOczekiwania[i]);
}
Random random = new Random();
for(int x = 0; x < 2; x++)
{
for (int i = 0; i<liczbaStrumieni; i++)
{
if( x % liczbaStrumieni == 0)
{
Zgloszenie zgloszenie = new Zgloszenie();
lista.dodaj(zgloszenie, aktualnyCzas);
TimeSpan nowy = new TimeSpan(0,0,0,0,random.Next(0, 10));
aktualnyCzas = aktualnyCzas + nowy;
}
else
{
Zgloszenie zgloszenie = new Zgloszenie();
lista.dodaj(zgloszenie, aktualnyCzas);
TimeSpan nowy = new TimeSpan(0, 0, 0, 0, random.Next(0, 10));
aktualnyCzas = aktualnyCzas + nowy;
}
}
}
}