/*
A termelésinformatikai alapjai c. tantrárgy GEIAK150-B
Miskolci Egyetem, Alkalmazott Informatikai Intézeti Tanszék
Dr. Kulcsár Gyula, egyetemi docens

TIA gyakorlat 02
Egy eroforrást tartalmazó gyártócella ütemezése.
Az ütemezés célja a befejezési idők összegének minimalizálása,
ezáltal az átlagos készletszint minimalizálása.
Az SPT (Shortest Processing Time) műveleti idő szerint nemcsökkenő munkasorrend
optimális ütemtervet eredményez.

TIA gyakorlat 03
TIA 4. gyakorlat
ovábbfejlesztés: Határidős munkák utemezése a legnagyobb késés minimalizálása érdekében.
Egygépes termelésiütemezési feladat.
Minden munkának saját határideje van.
Az ütemezés célja a legnagyobb késés minimalizálása.
EDD Earliest Due Date (határidő szerint nemcsökkenő munkasorrend)
A megoldás optimális ütemtervet eredményez.

-------------------------------------------------------------------------------
*/

#include<stdio.h>
#include<stdlib.h>

//---------------------------------------------------------------------------
#define N_of_ObjF 4   //celfuggvenyek szama

typedef struct {
                int id;  //azonosito
                long ProcT; //muveleti ido
                long StartT; //inditasi idopont
                long EndT;   //befejezesi idopont
                long L;      //keses
                long d;      //hatarido
               }T_JOB;

void Simulation( T_JOB* job, int NJ, int* s, long t0);
void Evalute( T_JOB* job, int NJ, double* obj_f );
void print_obj_f( double* obj_f );
void SPT_rule( T_JOB* job, int NJ, int* s);
void EDD_rule( T_JOB* job, int NJ, int* s);
void print_execution_details( T_JOB* job, int NJ, int* s);






int main(int argc, char* argv[])
{
  int NJ; //munkak szama, number of jobs
  T_JOB* job;  //munkak dinamikusan letrehozott tombje
  int* s;      //utemterv
  int i;       //munka indexe
  double obj_f[ N_of_ObjF ];  //N_of_ObjF darab celfuggveny

  printf("\n SPT utemezesi szabaly demo");
  printf("\n Munkak szam = ");
  scanf("%d", &NJ);  //ellenorzes nincs

  //mem. foglalas
  job = (T_JOB*) calloc( NJ, sizeof( T_JOB ) );  //strukturatomb
  s = (int*) calloc( NJ, sizeof( int ) );  //int tomb

  //termelesinformatikai rendszer
  //veletlenszeru adatokkal helyettesitjuk
  for ( i=0; i<NJ; i++ )
    {
      job[i].id = i;  //decimalis azonosito
      job[i].ProcT = 1 + rand() % 100; //veletlenszam
      job[i].d = 1 + (NJ-i)*5 + rand() % 50; 
      //printf("\n ProcT=%ld", job[i].ProcT);
      s[i] = i;  //ad-hoc sorrend
    }

  //ad-hoc sorrend
  printf("\n\n Ad-hoc sorrend");
  Simulation( job, NJ, s, 0);
  Evalute( job, NJ, obj_f );
  print_obj_f( obj_f );

  //SPT sorrend
  /*
  rendezes
  szimulacio
  ertekeles
  eredmeny megjelenitese
  */
  printf("\n \n SPT rendezes");
  SPT_rule( job, NJ, s);
  Simulation( job, NJ, s, 0);
  Evalute( job, NJ, obj_f );
  print_obj_f( obj_f );

  //EDD
  printf("\n \n EDD rendezes");
  EDD_rule( job, NJ, s);
  Simulation( job, NJ, s, 0);
  Evalute( job, NJ, obj_f );
  print_obj_f( obj_f );
  print_execution_details( job, NJ, s);



  //mem. felszabaditas
  free( job );
  free( s );

  getch();  //biil.
  return 0;
}

void Simulation( T_JOB* job, int NJ, int* s, long t0)
{
  //vegrahajtas szimulacioja
  //s mutatja a sorrendet
  //az eroforras egyidejuleg csak egyetlen munkan dolgozhat
  //az atallitas ideje bele van integralva a muveleti idobbe

  int pos;
  for( pos=0; pos<NJ; pos++ )
     {
       if ( pos == 0 ) //kezdo muvelet
            job[ s[pos] ].StartT = t0; //ref. idopontban indul
       else
            job[ s[pos] ].StartT = job[ s[pos-1] ].EndT;

       job[s[pos]].EndT=job[s[pos]].StartT+job[s[pos]].ProcT;

       //printf("\n %d \t %ld \t %ld \t %ld", pos, job[ s[pos] ].StartT, job[ s[pos] ].ProcT, job[ s[pos] ].EndT);
     }
}

void Evalute( T_JOB* job, int NJ, double* obj_f )
{
   double Na;    //atlagos keszletszin WIP work in process
   double Cmax;  //befejezesi idopont, completion time
   double Csum = 0;  //munkak befejezesi idopontjainak osszege, sum of job completion time
   double Lmax;  //legnagyobb keses

   int i;
   for ( i=0; i<NJ; i++ )
     {
       //BUG =
       Csum += job[i].EndT;

       if ( i==0 )
          Cmax = job[i].EndT;
       else
            if ( Cmax < job[i].EndT )
                 Cmax = job[i].EndT;

       job[i].L = job[i].EndT - job[i].d; //keses = befejezes - hatarido
       if ( i==0 )
          Lmax = job[i].L;
       else
            if ( Lmax < job[i].L )
                 Lmax = job[i].L;
     }

     Na = Csum / Cmax;

   obj_f[0] = Cmax;
   obj_f[1] = Csum;
   obj_f[2] = Na;
   obj_f[3] = Lmax;
}

void print_obj_f( double* obj_f )
{
   printf("\n Celfuggveny ertekek:");
   printf("\n Cmax = %lf ", obj_f[0]);
   printf("\n Csum = %lf ", obj_f[1]);
   printf("\n WIP = %lf ", obj_f[2]);
   printf("\n Lmax = %lf ", obj_f[3]);


}

void SPT_rule( T_JOB* job, int NJ, int* s)
{
  //rendezes ProcT alapjan nemcsokkeno sorrendbe

  int i, j, index, temp;

  for ( i=0; i<NJ; i++)
     s[i] = i;

  for ( i=0; i<NJ-1; i++)
   {
    index = i;
    for ( j=i+1; j<NJ; j++)
      {
         if ( job[ s[index] ].ProcT > job[ s[j] ].ProcT )
             index = j;
      }

    if ( index != i )
     {  //i pozicioban levo elem es az index pozicioban levo elem csereje
        temp = s[ index ];
        s[ index ] = s[ i ];
        s[ i ] = temp;
     }
   }
}

void EDD_rule( T_JOB* job, int NJ, int* s)
{
  //rendezes d (hatarido) alapjan nemcsokkeno sorrendbe

  int i, j, index, temp;

  for ( i=0; i<NJ; i++)
     s[i] = i;

  for ( i=0; i<NJ-1; i++)
   {
    index = i;
    for ( j=i+1; j<NJ; j++)
      {
         if ( job[ s[index] ].d > job[ s[j] ].d )
             index = j;
      }

    if ( index != i )
     {  //i pozicioban levo elem es az index pozicioban levo elem csereje
        temp = s[ index ];
        s[ index ] = s[ i ];
        s[ i ] = temp;
     }
   }
}

void print_execution_details( T_JOB* job, int NJ, int* s)
{
  //vegrahajtas adatainak megjelenitese

   int i;

   printf("\n\n Muveletek vegrahajtasa");
   printf("\n \t # \t munka \t indul \t muv. \t bef. \t hatar \t keses");
   for ( i=0; i<NJ; i++ )
      printf("\n\t %d \t %d \t %ld \t %ld \t %ld \t %ld \t %ld",
             i,
             s[i],
            job[ s[i] ].StartT,
             job[ s[i] ].ProcT,
             job[ s[i] ].EndT,
             job[ s[i] ].d,
             job[ s[i] ].L );

}