1. CODE:
#include
#include
struct task{//process
int id;//pid
int bt;//burst time
int at;//arrival time
int pr;//priority
};
typedef struct task Task;
typedef Task *TaskPtr;
struct qnode{//a node in the run/ready queue
Task data;//process
struct qnode *nextPtr;
};
typedef struct qnode Qnode;
typedef Qnode *QnodePtr;
void enqueue(QnodePtr *headPtr, QnodePtr *tailPtr,Task task);
Task dequeue(QnodePtr *headPtr, QnodePtr *tailPtr);
int isEmpty(QnodePtr headPtr);
void enqueue(QnodePtr *headPtr, QnodePtr *tailPtr,Task task){
QnodePtr newNodePtr = malloc( sizeof( Qnode));
if(newNodePtr !=NULL){
newNodePtr->data = task;
newNodePtr->nextPtr = NULL;
}
QnodePtr current = *headPtr, prev = NULL;
while(current!=NULL && task.bt>=(current->data).bt){
prev = current;
current = current->nextPtr;
}
if(prev==NULL){
newNodePtr->nextPtr= *headPtr;
*headPtr=newNodePtr;
}
2. else{
newNodePtr->nextPtr=prev->nextPtr;
prev->nextPtr=newNodePtr;
}
if(newNodePtr->nextPtr==NULL){
*tailPtr = newNodePtr;
}
}
Task dequeue(QnodePtr *headPtr, QnodePtr *tailPtr){
Task value;
QnodePtr tempPtr;
value = (*headPtr)->data;
tempPtr = *headPtr;
*headPtr = (*headPtr)->nextPtr;
if(*headPtr == NULL){
*tailPtr = NULL;
}
free (tempPtr);
return value;
}
int isEmpty(QnodePtr headPtr){
return headPtr == NULL;
}
///////////////////////////////////////////////
struct event{//an event event
int type;//event type 0:arrival, 1: departure
int time;//event time
Task task;//the process
};
typedef struct event Event;
typedef Event *EventPtr;
struct eventQnode{//an node in the events list
Event data;//the event
struct eventQnode *nextPtr;
};
typedef struct eventQnode EventQnode;
3. typedef EventQnode *EventQnodePtr;
void enqueueevent(EventQnodePtr *headPtr, EventQnodePtr *tailPtr,Event e);
Event dequeueevent(EventQnodePtr *headPtr, EventQnodePtr *tailPtr);
int isEmptyEQ(EventQnodePtr headPtr);
void displayEvents(EventQnodePtr currentPtr);
void enqueueevent(EventQnodePtr *headPtr, EventQnodePtr *tailPtr,Event se){
EventQnodePtr newNodePtr = malloc( sizeof( EventQnode));
if(newNodePtr !=NULL){
newNodePtr->data = se;
newNodePtr->nextPtr = NULL;
}
EventQnodePtr current = *headPtr, prev = NULL;
while(current!=NULL && se.time>(current->data).time){//find the insert position in order of
time
prev = current;
current = current->nextPtr;
}
while(current!=NULL && se.time==(current->data).time && se.type<(current-
>data).type){//then find the insert position in order of event's type
prev = current;
current = current->nextPtr;
}
if(prev==NULL){
newNodePtr->nextPtr= *headPtr;
*headPtr=newNodePtr;
}
else{
newNodePtr->nextPtr=prev->nextPtr;
prev->nextPtr=newNodePtr;
}
if(newNodePtr->nextPtr==NULL){
*tailPtr = newNodePtr;
}
}
Event dequeueevent(EventQnodePtr *headPtr, EventQnodePtr *tailPtr){
4. Event value;
EventQnodePtr tempPtr;
value = (*headPtr)->data;
tempPtr = *headPtr;
*headPtr = (*headPtr)->nextPtr;
if(*headPtr == NULL){
*tailPtr = NULL;
}
free (tempPtr);
return value;
}
int isEmptyEQ(EventQnodePtr headPtr){
return headPtr == NULL;
}
void displayEvents(EventQnodePtr currentPtr){
if(currentPtr==NULL)
printf("The event list is empty ... ");
else{
printf("The event list is: ");
Event tempevent;
while(currentPtr!=NULL){
printf(" time: %d, type : %d : task(id:%d,bt:%d) ",
(currentPtr->data).time, (currentPtr->data).type, (currentPtr->data).task.at,(currentPtr-
>data).task.bt);
currentPtr=currentPtr->nextPtr;
}
}
}
///////////////////////////////////////////////
const int MAXTASKS = 10;
const int MAXBURSTTIME = 70;
const int IAT = 30;
void main(){
QnodePtr rqheadPtr=NULL, rqtailPtr=NULL;//the run/ready queue
EventQnodePtr eventsQheadPtr=NULL, eventsQtailPtr=NULL;//the event queue/list
5. Task task;//the process structure
Event event;//the event structure
int prevat = 0, i;//set the previous arrival time to zero
for(i=0;i
Solution
#include
#include
#include
class cpuschedule
{
int n,bu[20];
float twt,awt,wt[20],tat[20];
public:
void Getdata();
void fcfs();
void sjf();
void roundrobin();
};
//Getting no of processes and Burst time
void cpuschedule::Getdata()
{
int i;
cout<<“Enter the no of processes:”;
cin>>n;
for(i=1;i<=n;i++)
{
cout<<“ Enter The BurstTime for Process p”<>bu[i];
}
}
//First come First served Algorithm
void cpuschedule::fcfs()
{
int i,b[10];
float sum=0.0;
6. twt=0.0;
for(i=1;i<=n;i++)
{
b[i]=bu[i];
cout<<“ Burst time for process p”<=1;i–)
{
for(j=2;j<=n;j++)
{
if(b[j-1]>b[j])
{
temp=b[j-1];
b[j-1]=b[j];
b[j]=temp;
}
}
}
wt[1]=0;
for(i=2;i<=n;i++)
{
wt[i]=b[i-1]+wt[i-1];
}
for(i=1;i<=n;i++)
{
twt=twt+wt[i];
tat[i]=b[i]+wt[i];
sum+=tat[i];
}
awt=twt/n;
sum=sum/n;
cout<<“ Total Waiting Time=”<>tq;
//TO find the dimension of the Round robin array
m=max/tq+1;
//initializing Round robin array
for(i=1;i<=n;i++)
{
for(j=1;j<=m;j++)
