HEL/OS-Lab-Scheduler
1
0
Fork 0
Code Pull Requests Activity

Compare commits

base: HEL:aee7447c210df6fc3ab3b73408dc21d576d4a6fb
Branches Tags
HEL:main
..
compare: HEL:5509743101146b5edb250159c7cdf6be59f5ee04
Branches Tags
HEL:main

No commits in common. "aee7447c210df6fc3ab3b73408dc21d576d4a6fb" and "5509743101146b5edb250159c7cdf6be59f5ee04" have entirely different histories.
aee7447c21 ... 5509743101

3 changed files with 11 additions and 226 deletions
Show Stats Expand all files Collapse all files

10
executionPr.csv
View File

@ -1,10 +0,0 @@
1,10,0,0
2,40,0,0
3,50,30,0
4,211,201,0
5,30,0,0
6,40,20,0
7,191,141,1
8,30,0,0
9,101,91,0
10,61,1,0
1 1 10 0 0
2 2 40 0 0
3 3 50 30 0
4 4 211 201 0
5 5 30 0 0
6 6 40 20 0
7 7 191 141 1
8 8 30 0 0
9 9 101 91 0
10 10 61 1 0

1
performancePr.csv
View File

@ -1 +0,0 @@
291,1,1
1 291 1 1

226
simulator.c
View File

@ -9,7 +9,6 @@
enum pstate {
WAITING,
READY,
RUNNING,
FINISHED
};
@ -28,17 +27,6 @@ struct pinfo {
struct pinfo * next_pinfo;
};
int n_processes(struct pinfo * head) {
int n = 0;
while (head != NULL) {
n++;
head = head->next_pinfo;
}
return n;
}
struct perf_info {
int total_time;
int total_nr_ctxt_switch;
@ -109,202 +97,6 @@ struct perf_info schedule_FCFS(struct pinfo * processes) {
return perf;
}
struct prio_list {
struct pinfo ** proc;
int length;
};
/**
* Pops and returns the last element (highest priority) of the given priority list
*
* Returns NULL if the list is empty
*/
struct pinfo * prio_list_pop(struct prio_list * list) {
if (list->length == 0) {
return NULL;
}
list->length--;
return *(list->proc + list->length);
}
/**
* Adds the given process in the priority list at
* the appropriate place (according to its priority)
*/
void prio_list_add(struct prio_list * list, struct pinfo * proc) {
struct pinfo * proc2;
int idx = 0;
// Find first element (from the right) with lower priority
for (int i=list->length-1; i>=0; i--) {
proc2 = *(list->proc + i);
if (proc2->priority > proc->priority) {
idx = i+1;
break;
}
}
// Shift elements
for (int j=list->length-1; j>=idx; j--) {
*(list->proc + j + 1) = *(list->proc + j);
}
*(list->proc + idx) = proc;
list->length++;
}
/**
* Creates a new priority list
*/
struct prio_list * create_prio_list(int max_size) {
struct pinfo ** processes = (struct pinfo **) malloc(sizeof(struct pinfo *) * max_size);
struct prio_list * list = (struct prio_list *) malloc(sizeof(struct prio_list));
list->length = 0;
list->proc = processes;
return list;
}
/**
* Returns the last element (highest priority) of the given priority list
*/
struct pinfo * prio_list_last(struct prio_list * list) {
return *(list->proc + list->length - 1);
}
/**
* Prints the pids of the processes in the given priority list
*/
void prio_list_print(struct prio_list * list) {
printf("queue: ");
for (int i=0; i < list->length; i++) {
if (i != 0) {
printf(", ");
}
printf("%d", (*(list->proc + i))->id);
}
printf("\n");
}
struct perf_info schedule_Pr(struct pinfo * processes) {
struct perf_info perf = {0, 0, 0};
int current_time = 0;
struct pinfo * current = NULL;
struct pinfo * next = processes;
int N = n_processes(processes);
printf("N = %d\n", N);
struct prio_list * queue = create_prio_list(N);
int finished = 0;
while (finished != N) {
printf("\nCurrent time: %d / ", current_time);
if (current != NULL) {
printf("Current: %d / ", current->id);
} else {
printf("Current: none / ");
}
if (next != NULL) {
printf("Next: %d\n", next->id);
} else {
printf("Next: none\n");
}
if (current == NULL) {
printf("No running process: running %d\n", next->id);
current = next;
current->state = RUNNING;
next = next->next_pinfo;
} else if (next != NULL) {
next->state = READY;
prio_list_print(queue);
printf("Processing next process (%d)\n", next->id);
// If current finished before next
while (current != NULL && current_time + current->remaining_time <= next->arrival_time) {
printf(" Process %d finished before next\n", current->id);
current->state = FINISHED;
current_time += current->remaining_time;
current->turnaround_time = current_time - current->arrival_time;
current->remaining_time = 0;
finished++;
current = prio_list_pop(queue);
}
if (current != NULL) {
printf("Removing time from current process\n");
current->remaining_time -= next->arrival_time - current_time;
current->turnaround_time += next->arrival_time - current_time;
}
if (next->arrival_time > current_time) {
current_time = next->arrival_time;
}
next->state = READY;
// If no running process, immediately run next process
if (current == NULL) {
printf("Queue is empty, running next process %d\n", next->id);
current = next;
current->state = RUNNING;
next = next->next_pinfo;
} else if (next->priority < current->priority) {
// Preempt current process
printf("Next process (%d) has higher priority\n", next->id);
if (current->state == RUNNING) {
printf(" Preempting current process (%d)\n", current->id);
current->nb_time_pre_empted++;
current_time += CNTXT_SWITCH;
perf.total_nr_ctxt_switch++;
}
current->state = READY;
prio_list_add(queue, current);
// Run process with higher priority
current = next;
current->state = RUNNING;
next = next->next_pinfo;
} else {
printf("Adding next process (%d) to list\n", next->id);
prio_list_add(queue, next);
next = next->next_pinfo;
}
if (current != NULL) {
current->state = RUNNING;
}
} else {
printf("No new processes, emptying queue\n");
while (current != NULL) {
printf("Completing process %d\n", current->id);
current->state = FINISHED;
current_time += current->remaining_time;
current->turnaround_time = current_time - current->arrival_time;
current->remaining_time = 0;
finished++;
current = prio_list_pop(queue);
if (current != NULL) {
current->state = RUNNING;
}
}
}
}
perf.total_time = current_time;
perf.total_time_ctxt_switch = perf.total_nr_ctxt_switch * CNTXT_SWITCH;
return perf;
}
void compute_waiting_time(struct pinfo * processes) {
while (processes != NULL) {
processes->wait_time = processes->turnaround_time - processes->execution_time;
processes = processes->next_pinfo;
}
}
struct perf_info schedule_RR(struct pinfo *processes) { // Déclaration de la fonction schedule_RR qui prend un pointeur vers une liste de processus
struct perf_info perf = {0, 0, 0}; // Initialisation de la structure de performance avec des valeurs à zéro
int current_time = 0; // Variable pour suivre le temps actuel
@ -363,9 +155,10 @@ struct perf_info schedule_RR(struct pinfo *processes) { // Déclaration de la fo
return perf; // Renvoie la structure de performance
}
void write_file(struct pinfo * process, struct perf_info * perf) {
FILE *myStream_execution = fopen("executionPr.csv", "w");
FILE *myStream_performance = fopen("performancePr.csv", "w");
FILE *myStream_execution = fopen("executionRR.csv", "w");
FILE *myStream_performance = fopen("performanceRR.csv", "w");
if (myStream_execution == NULL || myStream_performance == NULL) {
perror("Erreur à l'ouverture des fichiers");
@ -390,6 +183,12 @@ void write_file(struct pinfo * process, struct perf_info * perf) {
fclose(myStream_performance);
}
struct pinfo * read_file() {
FILE * file = fopen("tasks.csv", "r");
unsigned long buf_size = sizeof(char) * 64;
@ -448,11 +247,8 @@ void free_processes(struct pinfo * next) {
int main() {
struct pinfo * processes = read_file();
//struct perf_info perf = schedule_FCFS(processes);
//struct perf_info perf = schedule_RR(processes);
struct perf_info perf = schedule_Pr(processes);
compute_waiting_time(processes);
//struct perf_info perf = schedule_FCFS(processes); // Remise en place de FCFS
struct perf_info perf = schedule_RR(processes);
write_file(processes, &perf);