-
Notifications
You must be signed in to change notification settings - Fork 0
/
schedule.c
346 lines (309 loc) · 14.6 KB
/
schedule.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int global_time = 0;
int total_wait=0;
int total_turnaround=0;
int process_count=0;
//TODO
//all processes must have their own all_instr so that they can store remaining time for the spesific instruction they are executing
//close the process files after premption so that you can opean them again
//implement class convertion after a number of timequantum burst (for example 3 timequantum burst for silver to gold)
// Define the instruction execution times
//fazladan context switch time ekliyor olabilir , enqueue yaptıktan sonra qsort edip yeni bir tane alıyor aldığı aynı process ise eklemesin ???
//eğer aynı priority olanlar arasında time quantum olsun istiyorsan p harfi önüne bir fazlasını ekle string comparisonda aşağıya gitsin o
struct Instruction {
char name[10];
int exec_time;
};
// Define a process
struct Process {
char name[10];
int executionTime;
int priority;
char classType[10];
int arrivalTime;
int currentLine;
int timequantum;
int remaining_burst;
struct Instruction *pr_instruct; //array of instructions for each process to store remaining time for each instruction
};
// Comparison function for sorting processes based on priority and arrival time
int compareProcesses(const void *a, const void *b) {
const struct Process *p1 = (const struct Process *)a;
const struct Process *p2 = (const struct Process *)b;
// least arrival time first , if arrival times are equal then least priority first , if priorities are equal then least name first
if (p1->arrivalTime < p2->arrivalTime)
{
return -1;
}
else if (p1->arrivalTime > p2->arrivalTime)
{
return 1;
}
else if (p1->priority < p2->priority)
{
return 1; //higher priority first
}
else if (p1->priority > p2->priority)
{
return -1;
}
else
{
return strcmp(p1->name, p2->name);
}
}
// Structure for the ready queue
struct ReadyQueue
{
struct Process processes[50];
int front;
int rear;
};
// Function to check if the ready queue is empty
int isReadyQueueEmpty(struct ReadyQueue *queue)
{
return queue->front == -1;
}
// Function to enqueue a process into the ready queue
void enqueue(struct ReadyQueue *queue, struct Process process)
{
if (queue->front == -1)
{
queue->front = 0;
}
queue->rear++;
queue->processes[queue->rear] = process;
}
// Function to dequeue a process from the ready queue
struct Process dequeue(struct ReadyQueue *queue)
{
struct Process process = queue->processes[queue->front];
if (queue->front == queue->rear)
{
queue->front = -1;
queue->rear = -1;
}
else
{
queue->front++;
}
return process;
}
int main()
{
// Read instruction times
struct Instruction instr;
// exactly 20 instructions
struct Instruction all_instr[21];
FILE *instructionFile = fopen("instructions.txt", "r");
// for each line in the file, read the instruction name and execution tim
int i = 0;
while (fscanf(instructionFile, "%s %d", instr.name, &instr.exec_time) == 2)
{
// store the instructions in an array
all_instr[i] = instr;
i++;
printf("%s %d\n", instr.name, instr.exec_time);
}
// Read processes from definition.txt and store in the ready queue
FILE *definitionFile = fopen("Example_Inputs_Outputs/def6.txt", "r");
struct ReadyQueue readyQueue;
readyQueue.front = -1;
readyQueue.rear = -1;
int num_of_proc=0;
i = 0;
while (fscanf(definitionFile, "%s %d %d %s", readyQueue.processes[i].name, &readyQueue.processes[i].priority, &readyQueue.processes[i].arrivalTime, readyQueue.processes[i].classType) == 4)
{
// execution time is not assigned yet
readyQueue.processes[i].currentLine = 1; // Start execution from the first line,1 yaptım öyle devam ettim sonra
readyQueue.processes[i].pr_instruct = all_instr; //assign the instruction array to the process later change during preemption
if (strcmp(readyQueue.processes[i].classType, "SILVER") == 0)
{
readyQueue.processes[i].timequantum = 80;
readyQueue.processes[i].remaining_burst = 3;
}
else if (strcmp(readyQueue.processes[i].classType, "GOLD") == 0)
{
readyQueue.processes[i].timequantum = 120;
readyQueue.processes[i].remaining_burst = 5;
}
else if (strcmp(readyQueue.processes[i].classType, "PLATINUM") == 0)
{
readyQueue.processes[i].timequantum = 120;
readyQueue.processes[i].remaining_burst = 8000;
}
else
{
printf("Invalid class type\n");
exit(1);
}
// Enqueue the process into the ready queue
enqueue(&readyQueue, readyQueue.processes[i]);
i++;
num_of_proc=i;
process_count=i;
}
fclose(definitionFile);
printf("Processes are :\n");
for (int i = readyQueue.front; i <= readyQueue.rear; i++)
{
printf("%s %d %d %s\n", readyQueue.processes[i].name, readyQueue.processes[i].priority, readyQueue.processes[i].arrivalTime, readyQueue.processes[i].classType);
}
// Sort the processes array based on priority and arrival time
qsort(readyQueue.processes, num_of_proc, sizeof(struct Process), compareProcesses);
printf("Sorted processes are :\n");
for (int i = readyQueue.front; i <= readyQueue.rear; i++)
{
printf("%s %d %d %s\n", readyQueue.processes[i].name, readyQueue.processes[i].priority, readyQueue.processes[i].arrivalTime, readyQueue.processes[i].classType);
}
int check_point = 0;
// Scheduler
while (!isReadyQueueEmpty(&readyQueue))
{ //CONTEXT SWİTCH OCCURED
global_time += 10; //bunu bazen arttırmaya gerek olmayabilir
printf("CONTEXT SWITCH \n");
// Dequeue the next process from the ready queue
int is_platinum=0;
struct Process currentProcess = dequeue(&readyQueue);
struct Instruction* process_instruction_counts = currentProcess.pr_instruct;
printf("DEQUEUED PROCESS %s at %d ms\n", currentProcess.name, global_time);
if (strcmp(currentProcess.classType, "PLATINUM") == 0)
{
is_platinum=1;
}
// Use processes list as a ready queue
if (!isReadyQueueEmpty(&readyQueue))
{
// Not the last process
struct Process nextProcess = readyQueue.processes[readyQueue.front];
check_point = nextProcess.arrivalTime; //decide at this point what to do (preempt or not)
}
else
{
// Last process
printf("Last process it must to without preemption \n");
check_point = global_time + 10000;
}
//open the file of current process named currentProcess.name.txt
char filename[20];
strcpy(filename, currentProcess.name);
strcat(filename, ".txt");
FILE* processFile = fopen(filename, "r");// begin to read from current line of the process start from where we left
int lineNumber = 1;
while (lineNumber < currentProcess.currentLine){
char temp[100];
if (fgets(temp, sizeof(temp), processFile) == NULL){ //change the pointer to the line we want to read
fprintf(stderr, "Error reading process file %s this is currentline %d", filename,currentProcess.currentLine);
exit(EXIT_FAILURE);
}
lineNumber++;
}
int preemption=0;
while (!preemption){ //for each processes each instruction
char instructionName[10];
fscanf(processFile, "%s", instructionName); //take the instruction at the line currentProcess.currentLine
printf("Acurrent line is %d , current instr is %s \n",currentProcess.currentLine,instructionName);
//find the instruction in the array of instructions
for (int i = 0; i < 21; i++) {
if (strcmp(process_instruction_counts[i].name, instructionName) == 0) {
printf("found instruction %s\n", instructionName);
//execute the found instruction
if (process_instruction_counts[i].exec_time > currentProcess.timequantum && !is_platinum) {//we can preempt plaitnums if they exceed time quantum
//preempt the process
preemption=1;
currentProcess.remaining_burst--;
//go on with the updated value
//update the current line of the process
//currentProcess.currentLine++; yine buradan devam edeceği için arttırma line ı
//update the execution time of the process
currentProcess.executionTime += currentProcess.timequantum;
//update the execution time of the instruction
process_instruction_counts[i].exec_time -= currentProcess.timequantum;
//update the timequantum of the process
currentProcess.timequantum = 0;
//enqueue the process into the ready queue
enqueue(&readyQueue, currentProcess); //enqueue the process into the ready queue
//sort the ready queue
qsort(readyQueue.processes, num_of_proc, sizeof(struct Process), compareProcesses);
//update the global time
global_time += currentProcess.timequantum;
//update the timequantum of the process
printf("Preempting process %s at %d ms\n", currentProcess.name, global_time);
}
else if(global_time+process_instruction_counts[i].exec_time>check_point && !is_platinum){ //do not preempt platinum
//bu instructionı da execute et sonra bitir , diğerini al
preemption=1;
currentProcess.currentLine++;
//update the execution time of the process
//currentProcess.executionTime += check_point-global_time;
currentProcess.executionTime += process_instruction_counts[i].exec_time;
//update the execution time of the instruction
//all_instr[i].exec_time -= check_point-global_time; //for example if it was 100 and we preempted after 20ms , the instr will continue from 80
//enqueue the process into the ready queue
enqueue(&readyQueue, currentProcess); //enqueue the process into the ready queue
//sort the ready queue
qsort(readyQueue.processes, num_of_proc, sizeof(struct Process), compareProcesses);
//update the global time
//global_time += check_point-global_time;
global_time += process_instruction_counts[i].exec_time; //o andaki instr yi execute ettik
printf("Preempting process %s at %d ms\n", currentProcess.name, global_time);
}
else{
//current instruction is totally safe to execute,no preemption , also if the process is a platinum its all instruction will be in here
printf("Executing instruction %s for %d ms\n", instructionName, process_instruction_counts[i].exec_time);
global_time += process_instruction_counts[i].exec_time;
//update the current line of the process
currentProcess.currentLine++;
//update the execution time of the process
currentProcess.executionTime += process_instruction_counts[i].exec_time;
}
//check if the process is finished
printf("finish check this is the instr name : %s new line num is %d\n",instructionName,currentProcess.currentLine);
if(strcmp(instructionName,"exit")==0) { //or instructionName is exit
//process is finished
printf("Process %s is finished\n", currentProcess.name);
//calculate turnaround time
int turnaroundTime = global_time - currentProcess.arrivalTime;
total_turnaround+=turnaroundTime;
printf("Turnaround time for process %s is %d ms\n", currentProcess.name, turnaroundTime);
//calculate waiting time
int waitingTime = turnaroundTime - currentProcess.executionTime+1;
total_wait+=waitingTime;
printf("GLOBAL and turnaround and execution %d %d %d \n",global_time,turnaroundTime,currentProcess.executionTime);
printf("Waiting time for process %s is %d ms\n", currentProcess.name, waitingTime);
num_of_proc--; //bir tane process artık azaldı qsort için daha az sayı verilemli
//delete from the ready queue
for (int i = readyQueue.front; i <= readyQueue.rear; i++)
{
if (strcmp(readyQueue.processes[i].name, currentProcess.name) == 0)
{
for (int j = i; j < readyQueue.rear; j++)
{
readyQueue.processes[j] = readyQueue.processes[j + 1];
}
readyQueue.rear--;
break;
}
}
}
}
}
//instruction arayan for bitti,eğer platinium loop devam etmeli diğer instruction için ama eğer
if (strcmp(instructionName,"exit")==0){
break;
}
else {
continue;
}
}
// Implement the execution logic here based on the given instructions
// Update the process information (e.g., current line, priority, etc.) after execution
// Check if the process is finished or preempted
// If a new process arrives during execution, add it to the array and re-sort
}
printf("Average waiting time is %f ms\n", (float)total_wait /process_count);
printf("Average turnaround time is %f ms\n", (float)total_turnaround / process_count);
return 0;
}