zad1

/*** Branislav Nikolic,e13592
Modelovati konkurentni program koji simulira ponasanje jednog aerodroma.
 Aerodrom koriste avioni (MALI, SREDNJI, VELIKI) koji sa njega uzlecu i slecu.
 Kontrolu nad pristupom aerodromskom pistom vrsi kontrolni toranj.
 Kontrolni toranj vrsi rasporedjivanje poletanja i sletanja. Aerodrom poseduje jednu pistu.

Ukoliko avion polece/slece on proverava da li je kontrolni toranj slobodan.
Ukoliko jeste zauzima ga (tako da ga ni jedan drugi avion nakon toga ne moze koristiti)
 i od kontrolnog tornja trazi dozvolu za poletanje/sletanje na pistu.
  Nakon toga avion ceka odgovor od kontrolnog tornja. Kada avion primi odobrenje kontrolnog tornja avion
  koristi pistu i polece/slece. Poletanje sa aerodroma traje
  3 sekunde (MALI), 5 sekundi (SREDNJI), 8 sekundi (VELIKI).
  Sletanje na aerodrom traje 2 sekunde (MALI), 4 sekunde (SREDNJI), 7 sekundi (VELIKI).
   Nakon poletanja ili sletanja avion oslobadja kontrolni toranj da bi mogli da ga koriste i drugi avioni.

Nit avion treba da vrati trenutke kada je zatrazio (poletanje ili sletanje),
kada mu je odobreno (poletanje ili sletanje) i kada je zavrsio date operacije.

Nit kontrolni toranj sluzi za opsluzivanje poletanja i sletanja na aerodrom.
 Kontrolni toranj ceka da ga neki avion zauzme i da mu prosledi zahtev za poletanje ili sletanje.
 Kada dobije zahtev kontrolni tornj ceka jednu sekundu da obradi podatke o avionu i nakon toga odobrava poletanje ili sletanje.
*/

#include<iostream>
#include<thread>
#include<string>

using namespace std;
using namespace chrono;

int rand_sync() {
static mutex mx;
lock_guard<mutex> l(mx);
return rand();
}

enum tip_aviona {MALI=0, SREDNJI, VELIKI};
enum tip_zahteva {POLETANJE=0, SLETANJE};
enum tip_niti {AVION=0, TORANJ};

string nazivi[2][2] = {{"Poleteo","poletanje"},{"Sleteo","sletanje"}};
string tipoviAviona[3] = {"Learjet","Airbus","Jumbo Jet"};

struct vremena {
monotonic_clock::time_point zatrazio;
monotonic_clock::time_point odobreno;
monotonic_clock::time_point zavrsio;
};

class Aerodrom {
    private:
        mutex m;
        bool toranj_slobodan;

        condition_variable mali;
        condition_variable srednji;
        condition_variable veliki;
        condition_variable toranj;
    public:
        Aerodrom():toranj_slobodan(true){}

        vremena zahtev_aviona(tip_zahteva tip_z, tip_aviona tip_a){
            vremena v;
                v.zatrazio = monotonic_clock::now();

                   unique_lock<mutex>l(m);

                   if(tip_a==MALI){

                       while(toranj_slobodan==false)
                            mali.wait(l);

                         toranj_slobodan=false;
                         v.odobreno = monotonic_clock::now();

                        if(tip_z==POLETANJE)  {this_thread::sleep_for( seconds(3) );}
                            else if(tip_z==SLETANJE){this_thread::sleep_for( seconds(2) );}

                            v.zavrsio =monotonic_clock::now();
                            toranj_slobodan=true;
                            mali.notify_one();
                         }

                        else if(tip_a==SREDNJI){

                            while(toranj_slobodan==false)
                                srednji.wait(l);

                           toranj_slobodan=false;
                            v.odobreno = monotonic_clock::now();

                          if(tip_z==POLETANJE){this_thread::sleep_for(seconds(5));}
                             else if(tip_z==SLETANJE){this_thread::sleep_for(seconds(4));}

                            v.zavrsio =monotonic_clock::now();
                            toranj_slobodan=true;
                            srednji.notify_one();
                         }
                   else if(tip_a==VELIKI){
                        while(toranj_slobodan==false)
                                veliki.wait(l);

                        toranj_slobodan=false;
                         v.odobreno = monotonic_clock::now();

                        if(tip_z==POLETANJE){this_thread::sleep_for(seconds(8));}
                             else if(tip_z==SLETANJE){this_thread::sleep_for(seconds(7));}

                            v.zavrsio =monotonic_clock::now();
                            toranj_slobodan=true;
                            veliki.notify_one();
                   }
        return v;
        }

        void rasporediPoletanjaISletanja(){
                unique_lock<mutex>l(m);
                    while(toranj_slobodan==true)
                        toranj.wait(l);

                    toranj_slobodan=true;
                    this_thread::sleep_for(seconds(1));
                    toranj.notify_one();
        }

};

mutex term_mx;

void avion(Aerodrom & ae, int broj_aviona, tip_zahteva tip_z, tip_aviona tip_a) {
this_thread::sleep_for(seconds((rand_sync()%10)+1)); //radi slucajnog dolaska aviona na aerodrom
vremena vr = ae.zahtev_aviona(tip_z,tip_a);
duration<double, milli> cekao = vr.odobreno - vr.zatrazio;
duration<double,milli> izvrsavao = vr.zavrsio -vr.odobreno;
lock_guard<mutex> l(term_mx);
cout << "Avion " << broj_aviona << " tipa " << tipoviAviona[tip_a] << " cekao je na odobrenje " << cekao.count() << " milisekundi. "
<< nazivi[tip_z][AVION] << " je za " << izvrsavao.count() << " milisekundi. " << endl;

}

void kontrolniToranj(Aerodrom & ae) {
for (;;) {
ae.rasporediPoletanjaISletanja();
}
}
const size_t UKUPNO=15;
int main(){
    Aerodrom a;

    thread t[UKUPNO];
    //void avion(Aerodrom & ae, int broj_aviona, tip_zahteva tip_z, tip_aviona tip_a)
        thread k = thread(kontrolniToranj,ref(a));
        k.detach();

            for(size_t i=0; i<UKUPNO; ++i)
                t[i]= thread(avion, ref(a), i+1, tip_zahteva(i%2), tip_aviona(i%3));

            for(size_t i=0; i<UKUPNO; ++i)
                t[i].join();



}