/*******************************************************************

* C implementation of Pre-emptive Priority based process scheduling

* lower numerical value indicates higher priority
* AUTHOR : AHMAD F.
* Date : 2009.AUG.21
* Version : 0.0
* ******************************************************************
*/

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

/*
* Globals
*/

int nprocess = 0; // holds total number of processes

struct node {
int PID;

int ArrivalTime;
int BurstTime;
int Priority;

int RemBurst;

int WaitingTime;

struct node *ptr;

};

typedef struct node NODE;

/*
* function prototypes
*/

NODE *ReadProcessData(void);
void SimulatePriority(NODE*);
NODE *GetNextProcess(NODE*,int,int);
void makewait(NODE*,NODE*,int,int);
void SsortLL(NODE*);
void PrintLL(NODE*);
void PrintGChart(int[100][2],int);

int main()
{
NODE *start;

start = ReadProcessData();

SimulatePriority(start);

exit(EXIT_SUCCESS);

} // end of main

/**
* entry point of function ReadProcessData()
*/

NODE *ReadProcessData(void)
{
NODE *start;
NODE *temp;
NODE *NEW;

FILE *fp;

int pid,atime,btime,priority;

start = (NODE*)malloc(sizeof(NODE));

if(!start)
{
printf("\nError in memiry allocation");
exit(EXIT_FAILURE);
}

start->ptr = NULL;

temp = start;

fp = fopen("priority.txt","r");
if(fp == NULL)
{
printf("\nerror openong file \"priority.txt\"");
exit(EXIT_FAILURE);
}

while(1)
{
fscanf(fp,"%d %d %d %d",&pid,&atime,&btime,&priority);

if(feof(fp))
{
fclose(fp);
break;
}

NEW = (NODE*)malloc(sizeof(NODE));

if(!NEW)
{
printf("\nMemory allocation failed");
fclose(fp);
exit(EXIT_FAILURE);
}
NEW->ptr = NULL;

NEW->PID = pid;
NEW->ArrivalTime = atime;
NEW->BurstTime = btime;
NEW->Priority = priority;
NEW->RemBurst = btime;
NEW->WaitingTime = 0;

temp->ptr = NEW;
temp = temp->ptr;
nprocess++;
}

return(start);

} //end of ReadProcessData()

/*
* Entry point of function SimulatePriority()
*/

void SimulatePriority(NODE *list)

{
NODE *current;
int ctime = 0; //absolute clock time
int cpriority = 9999; //priority of current process
int Tslice = 1; //quantum of time slice
int ncomplete = 0; //no of terminated process
int GanttArray[100][2]; //An array to store Gantt chart info
int index = 0;

while( ncomplete != nprocess)

{
current = GetNextProcess(list,ctime,cpriority);

if( current == NULL )

{
ctime += Tslice;
cpriority = 9999;
continue;

GanttArray[index][0] = -1;
GanttArray[index][1] = ctime;
index++;
}

/** if current != NULL **/

GanttArray[index][0] = current->PID;
GanttArray[index][1] = ctime;
index++;

/*
* priority is now the priority of current
* process
*/

cpriority = current->Priority;

/** All processes that have arrived

* but not terminated
* except for the current process
* must wait one time slice
*/
makewait(list,current,ctime,Tslice);

/*
* decrease remaining burst time
* of current process by one
* time slice
*/
current->RemBurst -= Tslice;

/*
* increment clock time
*/
ctime += Tslice;

/*
* check if the current process
* has no more burst remaining
*
*/

if( current->RemBurst == 0)
{
ncomplete++;
cpriority = 9999;
}
} //End of while

SsortLL(list); //sort the list according to arrival time

PrintLL(list); //Print scheduling data
PrintGChart(GanttArray,index);

} //end of SimulatePriority()

/*
* Entry point of makewait()
*/

void makewait(NODE *list, NODE *current, int ctime, int Tslice)

{
NODE *temp = list->ptr;
while( temp != NULL )
{
/*
* ifthe process has arrived
*/

if( temp->ArrivalTime <= ctime )

{
/*
* if the process has not terminated
*/

if(temp->RemBurst != 0)
{
/*
* if the process is not the
* one in execution
*/

if(temp != current)
{
/*
* make this process wait
* for a time slice
*/

temp->WaitingTime += Tslice;

} //end of if#3
} //end of if#2
} //end of if #1

temp = temp->ptr;

} //end of while

} //end of makewait()

/*
* entry point for GetNextProcess()
*/
NODE *GetNextProcess(NODE *list,int ctime, int priority)
{
NODE *temp;
NODE *next = NULL; //next process by default is NULL

temp = list->ptr;

while( temp != NULL)

{
/*
* if this process has arrived
*/
if(temp->ArrivalTime <= ctime)
{
/*
* but this process has not terminated
*/

if(temp->RemBurst != 0 )
{
/*
* if this process has a priority
* greater than or equal to
* the current priority
*/
if(temp->Priority <= priority )
{
/*
* then current process should
* be the next process
*/

next = temp;
priority = next->Priority;
} //end of if#3

} //end of if #2

} //end of if #1

temp = temp->ptr;

} //end of while

return(next);
} //end of GetNextProcess()

/*
* entry point for SsortLL()
*/
void SsortLL(NODE *list)
{
NODE *temp1 = list->ptr;
NODE *temp2;
NODE *swapbuf;

swapbuf = (NODE*)malloc(sizeof(NODE));

if(!swapbuf)
{
printf("\nError allocating memory to swapbuf");
exit(EXIT_FAILURE);
}

while(temp1->ptr != NULL)
{
temp2 = temp1->ptr;

while(temp2 != NULL)
{
if(temp2->ArrivalTime < temp1->ArrivalTime)
{
*swapbuf = *temp1;
*temp1 = *temp2;
*temp2 = *swapbuf;
}

temp2 = temp2->ptr;
}

temp1 = temp1->ptr;
}

} //End of SsortLL()
/*
* Entry point for PrintLL()
*/

void PrintLL(NODE *list)

{
NODE *temp = list->ptr;
int tatime;
float avg_tatime = 0;
float avg_wtime = 0;

printf("\n%3s%15s%15s%15s%15s%15s\n","PID","Arr. Time","Burst time"

,"Priority","Waiting Time","Trn-arnd Tim");

while( temp != NULL)

{
printf("\n%3d",temp->PID);
printf("%15d",temp->ArrivalTime);
printf("%15d",temp->BurstTime);
printf("%15d",temp->Priority);
printf("%15d",temp->WaitingTime);

tatime = temp->WaitingTime + temp->BurstTime;

printf("%15d",tatime);

avg_wtime += temp->WaitingTime;
avg_tatime += tatime;

temp = temp->ptr;
}

printf("\nAvg waiting time = %f",avg_wtime/nprocess);

printf("\nAvg turn-around time = %f",avg_tatime/nprocess);

printf("\n");
} //end of PrintLL()

/*
* entrypoint for printGChart()
*/

void PrintGChart(int a[100][2],int i)

{
int count;
int j;
printf("\n\n");

printf("[%d]--P%d--",a[0][1],a[0][0]);
for(count=1 ; count<i; count++)
{
if(a[count][0] != a[count-1][0])
{
printf("[%d]",a[count][1]);

if(a[count][0] == -1)
{
printf("%4d","idle");
}

else
{
printf("--P%d--",a[count][0]);
}
}
}
printf("[%d]",a[i-1][1]+1);
printf("\n");
}