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

Bugg

Browse Source
This commit is contained in:
florian.sauzeat 2024-10-15 15:04:55 +02:00
parent 1e66a95fbd
commit df8f5a5f78
4 changed files with 63 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
executionRRtest.csv Normal file
View File

@ -0,0 +1,5 @@
1,6,3,2
2,10,5,4
3,5,3,1
4,9,4,4
5,8,3,4
1 1 6 3 2
2 2 10 5 4
3 3 5 3 1
4 4 9 4 4
5 5 8 3 4

1
performanceRRtest.csv Normal file
View File

@ -0,0 +1 @@
20,15,15
1 20 15 15

94
simulator.c
View File

@ -2,7 +2,7 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#define RR_QUANTUM 2 #define RR_QUANTUM 1
#define CNTXT_SWITCH 1 #define CNTXT_SWITCH 1
int MAX_PROCESSES = 0; int MAX_PROCESSES = 0;
@ -305,67 +305,77 @@ void compute_waiting_time(struct pinfo * processes) {
} }
} }
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 schedule_RR(struct pinfo *processes) {
struct perf_info perf = {0, 0, 0}; // Initialisation de la structure de performance avec des valeurs à zéro struct perf_info perf = {0, 0, 0}; // Initialisation de la structure de performance
int current_time = 0; // Variable pour suivre le temps actuel int current_time = 0; // Temps actuel
int finished_processes = 0; // Compteur pour le nombre de processus terminés int finished_processes = 0; // Compteur de processus terminés
while (finished_processes < MAX_PROCESSES) { // Boucle principale jusqu'à ce que tous les processus soient terminés while (finished_processes < MAX_PROCESSES) {
int process_found = 0; // Indicateur pour savoir si un processus prêt a été trouvé int process_found = 0; // Indicateur de processus trouvé
struct pinfo *current_process = processes; // Pointeur pour parcourir la liste des processus struct pinfo *current_process = processes;
while (current_process != NULL) { // Boucle pour parcourir tous les processus while (current_process != NULL) {
// Vérifiez si le processus est prêt à s'exécuter // Vérifie si le processus est prêt à être exécuté
if (current_process->state != FINISHED && current_process->arrival_time <= current_time) { // Vérifie si le processus n'est pas fini et est arrivé if (current_process->state != FINISHED && current_process->arrival_time <= current_time) {
process_found = 1; // Un processus prêt à s'exécuter a été trouvé process_found = 1; // Un processus prêt a été trouvé
int time_slice = (current_process->remaining_time < RR_QUANTUM) ? current_process->remaining_time : RR_QUANTUM; // Calcule la tranche de temps à exécuter // 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;
// Simuler l'exécution // Simule l'exécution
current_time += time_slice; // Incrémente le temps actuel par la tranche de temps current_time += time_slice;
current_process->remaining_time -= time_slice; // Diminue le temps restant du processus current_process->remaining_time -= time_slice;
// Calculer les temps d'attente pour les autres processus // Mise à jour du temps d'attente des autres processus
struct pinfo *other_process = processes; // Pointeur pour parcourir à nouveau la liste des processus struct pinfo *other_process = processes;
while (other_process != NULL) { // Boucle pour parcourir tous les autres processus while (other_process != NULL) {
if (other_process->state != FINISHED && other_process != current_process && other_process->arrival_time <= current_time) { // Vérifie si l'autre processus est prêt if (other_process->state != FINISHED && other_process != current_process && other_process->arrival_time <= current_time) {
other_process->wait_time += time_slice; // Augmente le temps d'attente des autres processus other_process->wait_time += time_slice;
} }
other_process = other_process->next_pinfo; // Passe au processus suivant other_process = other_process->next_pinfo;
} }
// Gérer les statistiques de préemption // Gestion des statistiques de préemption
if (current_process->remaining_time == 0) { // Vérifie si le processus est terminé if (current_process->remaining_time == 0) {
current_process->state = FINISHED; // Met à jour l'état du processus à fini current_process->state = FINISHED; // Marquer le processus comme terminé
finished_processes++; // Incrémente le compteur de processus terminés finished_processes++; // Incrémenter le compteur des processus terminés
current_process->turnaround_time = current_time - current_process->arrival_time; // Calcule le temps de turnaround current_process->turnaround_time = current_time - current_process->arrival_time; // Calculer le temps de turnaround
} else { } else {
// Incrémenter le nombre de préemptions // Incrémenter le nombre de préemptions uniquement si le processus est interrompu avant de terminer
current_process->nb_time_pre_empted++; // Incrémente le compteur de préemptions pour le processus actuel if (time_slice == RR_QUANTUM) {
perf.total_nr_ctxt_switch++; // Incrémente le nombre total de commutations de contexte 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 // Débogage : Afficher les informations du processus
printf("Processus %d: remaining_time=%d, nb_time_pre_empted=%d\n", // Affiche les informations de débogage pour le processus actuel 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->id, current_process->remaining_time, current_process->nb_time_pre_empted);
} }
current_process = current_process->next_pinfo; // Passe au processus suivant dans la liste
} }
if (!process_found) { // Vérifie si aucun processus prêt n'a été trouvé
// Aucun processus prêt, avancer le temps }
current_time++; // Incrémente le temps actuel si aucun processus n'est prêt
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; // Enregistre le temps total écoulé dans la structure de performance perf.total_time = current_time;
return perf; // Renvoie la structure de performance perf.total_time_ctxt_switch = perf.total_nr_ctxt_switch * CNTXT_SWITCH;
return perf;
} }
void write_file(struct pinfo * process, struct perf_info * perf) { void write_file(struct pinfo * process, struct perf_info * perf) {
FILE *myStream_execution = fopen("executionRR1.csv", "w"); FILE *myStream_execution = fopen("executionRRtest.csv", "w");
FILE *myStream_performance = fopen("performanceRR1.csv", "w"); FILE *myStream_performance = fopen("performanceRRtest.csv", "w");
if (myStream_execution == NULL || myStream_performance == NULL) { if (myStream_execution == NULL || myStream_performance == NULL) {
perror("Erreur à l'ouverture des fichiers"); perror("Erreur à l'ouverture des fichiers");
@ -391,7 +401,7 @@ void write_file(struct pinfo * process, struct perf_info * perf) {
} }
struct pinfo * read_file() { struct pinfo * read_file() {
FILE * file = fopen("tasks.csv", "r"); FILE * file = fopen("tasks RR.csv", "r");
unsigned long buf_size = sizeof(char) * 64; unsigned long buf_size = sizeof(char) * 64;
char * line = (char *) malloc(buf_size); char * line = (char *) malloc(buf_size);
char * pid_str; char * pid_str;

5
tasks RR.csv Normal file
View File

@ -0,0 +1,5 @@
1 0 3 3
2 1 5 2
3 3 2 1
4 9 5 3
5 12 5 1
1 1 0 3 3
2 2 1 5 2
3 3 3 2 1
4 4 9 5 3
5 5 12 5 1