Merge branch 'main' of https://git.kb28.ch/HEL/OS-Lab-Scheduler

executionRRtest.csv

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

performanceRRtest.csv

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

simulator.c

@@ -2,7 +2,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#define RR_QUANTUM 2
+#define RR_QUANTUM 1
 #define CNTXT_SWITCH 1
 int MAX_PROCESSES = 0;
 
@@ -380,62 +380,71 @@ 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 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
-    int finished_processes = 0; // Compteur pour le nombre de processus terminés
+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) { // Boucle principale jusqu'à ce que tous les processus soient terminés
-        int process_found = 0; // Indicateur pour savoir si un processus prêt a été trouvé
-        struct pinfo *current_process = processes; // Pointeur pour parcourir la liste des processus
+    while (finished_processes < MAX_PROCESSES) {
+        int process_found = 0; // Indicateur de processus trouvé
+        struct pinfo *current_process = processes;
 
-        while (current_process != NULL) { // Boucle pour parcourir tous les processus
-            // Vérifiez si le processus est prêt à s'exécuter
-            if (current_process->state != FINISHED && current_process->arrival_time <= current_time) { // Vérifie si le processus n'est pas fini et est arrivé
-                process_found = 1; // Un processus prêt à s'exécuter a été trouvé
+        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é
 
-                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
-                current_time += time_slice; // Incrémente le temps actuel par la tranche de temps
-                current_process->remaining_time -= time_slice; // Diminue le temps restant du processus
+                // Simule l'exécution
+                current_time += time_slice;
+                current_process->remaining_time -= time_slice;
 
-                // Calculer les temps d'attente pour les autres processus
-                struct pinfo *other_process = processes; // Pointeur pour parcourir à nouveau la liste des processus
-                while (other_process != NULL) { // Boucle pour parcourir tous les autres processus
-                    if (other_process->state != FINISHED && other_process != current_process && other_process->arrival_time <= current_time) { // Vérifie si l'autre processus est prêt
-                        other_process->wait_time += time_slice; // Augmente le temps d'attente des autres processus
+                // 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; // Passe au processus suivant
+                    other_process = other_process->next_pinfo;
                 }
 
-                // Gérer les statistiques de préemption
-                if (current_process->remaining_time == 0) { // Vérifie si le processus est terminé
-                    current_process->state = FINISHED; // Met à jour l'état du processus à fini
-                    finished_processes++; // Incrémente le compteur de processus terminés
-                    current_process->turnaround_time = current_time - current_process->arrival_time; // Calcule le temps de turnaround
+                // 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
-                    current_process->nb_time_pre_empted++; // Incrémente le compteur de préemptions pour le processus actuel
-                    perf.total_nr_ctxt_switch++; // Incrémente le nombre total de commutations de contexte
+                    // 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);
+                    }
                 }
 
-                // 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
-                       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
+           
+
+
+            current_process = current_process->next_pinfo;
         }
 
-        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
+        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
-    return perf; // Renvoie la structure de performance
+    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) {
@@ -585,7 +594,7 @@ void write_file(struct pinfo * process, struct perf_info * perf) {
 }
 
 struct pinfo * read_file() {
-    FILE * file = fopen("tasks.csv", "r");
+    FILE * file = fopen("tasks RR.csv", "r");
     unsigned long buf_size = sizeof(char) * 64;
     char * line = (char *) malloc(buf_size);
     char * pid_str;

tasks RR.csv

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