674 lines
21 KiB
C
674 lines
21 KiB
C
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#define RR_QUANTUM 1
|
|
#define CNTXT_SWITCH 1
|
|
int MAX_PROCESSES = 0;
|
|
|
|
enum pstate {
|
|
WAITING,
|
|
READY,
|
|
RUNNING,
|
|
FINISHED
|
|
};
|
|
|
|
struct pinfo {
|
|
int id;
|
|
int arrival_time;
|
|
int execution_time;
|
|
int priority;
|
|
|
|
int wait_time;
|
|
int turnaround_time;
|
|
int remaining_time;
|
|
int nb_time_pre_empted; // Ajouté pour compter les préemptions
|
|
enum pstate state;
|
|
|
|
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;
|
|
int total_time_ctxt_switch;
|
|
};
|
|
|
|
void print_perf(struct perf_info * perf) {
|
|
printf("Total time: %d\n", perf->total_time);
|
|
printf("Total number of context switches: %d\n", perf->total_nr_ctxt_switch);
|
|
printf("Total time spent on context switching: %d\n", perf->total_time_ctxt_switch);
|
|
}
|
|
|
|
void print_pinfo(struct pinfo * info) {
|
|
printf("<Process {\n");
|
|
printf(" PID: %d\n", info->id);
|
|
printf(" Arrival time: %d\n", info->arrival_time);
|
|
printf(" Execution time: %d\n", info->execution_time);
|
|
printf(" Priority: %d\n", info->priority);
|
|
printf(" Wait time: %d\n", info->wait_time);
|
|
printf(" Turnaround time: %d\n", info->turnaround_time);
|
|
printf(" Remaining time: %d\n", info->remaining_time);
|
|
printf(" NEXT -> %p\n", info->next_pinfo);
|
|
printf("}>\n");
|
|
}
|
|
|
|
void print_processes(struct pinfo * processes) {
|
|
while (processes != NULL) {
|
|
print_pinfo(processes);
|
|
processes = processes->next_pinfo;
|
|
}
|
|
}
|
|
|
|
struct pinfo * create_process(int id, int arrival_time, int execution_time, int priority) {
|
|
struct pinfo * info = malloc(sizeof(struct pinfo));
|
|
info->id = id;
|
|
info->arrival_time = arrival_time;
|
|
info->execution_time = execution_time;
|
|
info->priority = priority;
|
|
info->wait_time = 0;
|
|
info->turnaround_time = 0;
|
|
info->remaining_time = execution_time;
|
|
info->nb_time_pre_empted = 0; // Initialiser le nombre de préemptions
|
|
info->state = WAITING;
|
|
info->next_pinfo = NULL;
|
|
return info;
|
|
}
|
|
|
|
// Méthode de planification FCFS
|
|
struct perf_info schedule_FCFS(struct pinfo * processes) {
|
|
int current_time = 0;
|
|
struct pinfo * process = processes;
|
|
|
|
struct perf_info perf = {0, 0, 0};
|
|
|
|
while (process != NULL) {
|
|
int wait_time = current_time - process->arrival_time;
|
|
if (wait_time < 0) {
|
|
wait_time = 0;
|
|
}
|
|
process->wait_time = wait_time;
|
|
process->turnaround_time = process->execution_time + process->wait_time;
|
|
current_time = process->arrival_time + process->turnaround_time;
|
|
|
|
process = process->next_pinfo;
|
|
}
|
|
perf.total_time = current_time;
|
|
|
|
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 remtime_list {
|
|
struct pinfo ** proc;
|
|
int length;
|
|
};
|
|
|
|
/**
|
|
* Pops and returns the last element (shortest remaining time) of the given remtime list
|
|
*
|
|
* Returns NULL if the list is empty
|
|
*/
|
|
struct pinfo * remtime_list_pop(struct remtime_list * list) {
|
|
if (list->length == 0) {
|
|
return NULL;
|
|
}
|
|
|
|
list->length--;
|
|
return *(list->proc + list->length);
|
|
}
|
|
|
|
/**
|
|
* Adds the given process in the remtime list at
|
|
* the appropriate place (according to its remaining time)
|
|
*/
|
|
void remtime_list_add(struct remtime_list * list, struct pinfo * proc) {
|
|
struct pinfo * proc2;
|
|
int idx = 0;
|
|
|
|
// Find first element (from the right) with longer remaining time
|
|
for (int i=list->length-1; i>=0; i--) {
|
|
proc2 = *(list->proc + i);
|
|
if (proc2->remaining_time > proc->remaining_time) {
|
|
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 remtime list
|
|
*/
|
|
struct remtime_list * create_remtime_list(int max_size) {
|
|
struct pinfo ** processes = (struct pinfo **) malloc(sizeof(struct pinfo *) * max_size);
|
|
struct remtime_list * list = (struct remtime_list *) malloc(sizeof(struct remtime_list));
|
|
list->length = 0;
|
|
list->proc = processes;
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* Returns the last element (shortest remaining time) of the given remtime list
|
|
*/
|
|
struct pinfo * remtime_list_last(struct remtime_list * list) {
|
|
return *(list->proc + list->length - 1);
|
|
}
|
|
|
|
/**
|
|
* Prints the pids of the processes in the given remtime list
|
|
*/
|
|
void remtime_list_print(struct remtime_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) {
|
|
struct perf_info perf = {0, 0, 0}; // Initialisation de la structure de performance
|
|
int current_time = 0; // Temps actuel
|
|
int finished_processes = 0; // Compteur de processus terminés
|
|
|
|
while (finished_processes < MAX_PROCESSES) {
|
|
int process_found = 0; // Indicateur de processus trouvé
|
|
struct pinfo *current_process = processes;
|
|
|
|
while (current_process != NULL) {
|
|
// Vérifie si le processus est prêt à être exécuté
|
|
if (current_process->state != FINISHED && current_process->arrival_time <= current_time) {
|
|
process_found = 1; // Un processus prêt a été trouvé
|
|
|
|
// Détermine la tranche de temps à exécuter (quantum ou le temps restant, selon le moindre)
|
|
int time_slice = (current_process->remaining_time < RR_QUANTUM) ? current_process->remaining_time : RR_QUANTUM;
|
|
|
|
// Simule l'exécution
|
|
current_time += time_slice;
|
|
current_process->remaining_time -= time_slice;
|
|
|
|
// Mise à jour du temps d'attente des autres processus
|
|
struct pinfo *other_process = processes;
|
|
while (other_process != NULL) {
|
|
if (other_process->state != FINISHED && other_process != current_process && other_process->arrival_time <= current_time) {
|
|
other_process->wait_time += time_slice;
|
|
}
|
|
other_process = other_process->next_pinfo;
|
|
}
|
|
|
|
// Gestion des statistiques de préemption
|
|
if (current_process->remaining_time == 0) {
|
|
current_process->state = FINISHED; // Marquer le processus comme terminé
|
|
finished_processes++; // Incrémenter le compteur des processus terminés
|
|
current_process->turnaround_time = current_time - current_process->arrival_time; // Calculer le temps de turnaround
|
|
} else {
|
|
// Incrémenter le nombre de préemptions uniquement si le processus est interrompu avant de terminer
|
|
if (time_slice == RR_QUANTUM) {
|
|
current_process->nb_time_pre_empted++; // Incrémente le compteur de préemptions
|
|
perf.total_nr_ctxt_switch++; // Incrémente le compteur des commutations de contexte
|
|
|
|
|
|
// Débogage : Afficher les informations du processus
|
|
printf("Current time %d: Processus %d: remaining_time=%d, nb_time_pre_empted=%d\n", 1 ,
|
|
current_process->id, current_process->remaining_time, current_process->nb_time_pre_empted);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
current_process = current_process->next_pinfo;
|
|
}
|
|
|
|
if (!process_found) {
|
|
current_time++; // Si aucun processus n'est prêt, incrémente le temps
|
|
}
|
|
}
|
|
|
|
perf.total_time = current_time;
|
|
perf.total_time_ctxt_switch = perf.total_nr_ctxt_switch * CNTXT_SWITCH;
|
|
return perf;
|
|
}
|
|
|
|
struct perf_info schedule_SRTF(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 remtime_list * queue = create_remtime_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;
|
|
remtime_list_print(queue);
|
|
printf("Processing next process (%d)\n", next->id);
|
|
int delta = next->arrival_time - current_time;
|
|
|
|
// If current finished before next
|
|
while (current != NULL && current->remaining_time <= delta) {
|
|
printf(" (%d) Process %d finished before next\n", current_time, current->id);
|
|
current->state = FINISHED;
|
|
current_time += current->remaining_time;
|
|
delta = next->arrival_time - current_time;
|
|
current->turnaround_time = current_time - current->arrival_time;
|
|
current->remaining_time = 0;
|
|
finished++;
|
|
current = remtime_list_pop(queue);
|
|
}
|
|
|
|
if (current != NULL) {
|
|
printf("Removing time from current process (%d)\n", current->id);
|
|
current->remaining_time -= delta;
|
|
current->state = RUNNING;
|
|
printf(" New remaining time %d\n", current->remaining_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->remaining_time < current->remaining_time) {
|
|
// Preempt current process
|
|
printf("Next process (%d) has shorter remaining time\n", next->id);
|
|
if (current->state == RUNNING) {
|
|
printf(" Preempting current process (%d)\n", current->id);
|
|
current->nb_time_pre_empted++;
|
|
current->remaining_time -= next->arrival_time - current_time;
|
|
current_time += CNTXT_SWITCH;
|
|
perf.total_nr_ctxt_switch++;
|
|
}
|
|
current->state = READY;
|
|
remtime_list_add(queue, current);
|
|
|
|
// Run process with shortest remaining time
|
|
current = next;
|
|
current->state = RUNNING;
|
|
next = next->next_pinfo;
|
|
} else {
|
|
printf("Adding next process (%d) to list\n", next->id);
|
|
remtime_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 = remtime_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 write_file(struct pinfo * process, struct perf_info * perf) {
|
|
FILE *myStream_execution = fopen("executionSRTF.csv", "w");
|
|
FILE *myStream_performance = fopen("performanceSRTF.csv", "w");
|
|
|
|
if (myStream_execution == NULL || myStream_performance == NULL) {
|
|
perror("Erreur à l'ouverture des fichiers");
|
|
return;
|
|
}
|
|
|
|
while (process != NULL) {
|
|
fprintf(myStream_execution, "%d,%d,%d,%d\n",
|
|
process->id,
|
|
process->turnaround_time,
|
|
process->wait_time,
|
|
process->nb_time_pre_empted);
|
|
process = process->next_pinfo;
|
|
}
|
|
fclose(myStream_execution);
|
|
|
|
fprintf(myStream_performance, "%d,%d,%d\n",
|
|
perf->total_time,
|
|
perf->total_nr_ctxt_switch,
|
|
perf->total_time_ctxt_switch);
|
|
|
|
fclose(myStream_performance);
|
|
}
|
|
|
|
struct pinfo * read_file() {
|
|
FILE * file = fopen("tasks RR.csv", "r");
|
|
unsigned long buf_size = sizeof(char) * 64;
|
|
char * line = (char *) malloc(buf_size);
|
|
char * pid_str;
|
|
char * arrival_str;
|
|
char * execution_str;
|
|
char * prio_str;
|
|
|
|
struct pinfo * first = NULL;
|
|
struct pinfo * last = NULL;
|
|
struct pinfo * process;
|
|
|
|
while (fgets(line, buf_size, file)) {
|
|
|
|
MAX_PROCESSES += 1;
|
|
pid_str = strtok(line, " ");
|
|
arrival_str = strtok(NULL, " ");
|
|
execution_str = strtok(NULL, " ");
|
|
prio_str = strtok(NULL, " ");
|
|
|
|
process = create_process(
|
|
atoi(pid_str),
|
|
atoi(arrival_str),
|
|
atoi(execution_str),
|
|
atoi(prio_str)
|
|
);
|
|
|
|
// Si la liste n'est pas initialisée
|
|
if (first == NULL) {
|
|
first = process;
|
|
}
|
|
|
|
// Si un élément est déjà dans la liste
|
|
if (last != NULL) {
|
|
last->next_pinfo = process;
|
|
}
|
|
last = process;
|
|
|
|
print_pinfo(process);
|
|
}
|
|
free(line);
|
|
fclose(file);
|
|
|
|
printf("Maximum des processus : %d\n", MAX_PROCESSES);
|
|
return first;
|
|
|
|
}
|
|
|
|
void free_processes(struct pinfo * next) {
|
|
struct pinfo * cur;
|
|
while (next != NULL) {
|
|
cur = next;
|
|
next = cur->next_pinfo;
|
|
free(cur);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
struct perf_info perf = schedule_SRTF(processes);
|
|
|
|
compute_waiting_time(processes);
|
|
|
|
write_file(processes, &perf);
|
|
print_processes(processes);
|
|
print_perf(&perf);
|
|
|
|
free_processes(processes);
|
|
|
|
return 0;
|
|
}
|