diff --git a/executionFCFS.csv b/executionFCFS.csv new file mode 100644 index 0000000..2bc9a35 --- /dev/null +++ b/executionFCFS.csv @@ -0,0 +1,10 @@ +1,10,0,0 +2,40,0,0 +3,50,30,0 +4,30,20,0 +5,40,10,0 +6,50,30,0 +7,90,40,0 +8,90,60,0 +9,50,40,0 +10,90,30,0 diff --git a/executionRR.csv b/executionRR.csv new file mode 100644 index 0000000..7c4c0c1 --- /dev/null +++ b/executionRR.csv @@ -0,0 +1,10 @@ +1,10,0,4 +2,84,44,19 +3,42,24,9 +4,22,14,4 +5,94,66,14 +6,66,48,9 +7,148,100,24 +8,98,70,14 +9,30,22,4 +10,90,32,29 diff --git a/performanceFCFS.csv b/performanceFCFS.csv new file mode 100644 index 0000000..12ff7e7 --- /dev/null +++ b/performanceFCFS.csv @@ -0,0 +1 @@ +290,0,0 diff --git a/performanceRR.csv b/performanceRR.csv new file mode 100644 index 0000000..fc78dc5 --- /dev/null +++ b/performanceRR.csv @@ -0,0 +1 @@ +290,130,0 diff --git a/results.csv b/results.csv new file mode 100644 index 0000000..1f04bcb --- /dev/null +++ b/results.csv @@ -0,0 +1,11 @@ +PID,Arrival Time,Execution Time,Wait Time,Turnaround Time,Remaining Time +1,0,10,6,14,0 +2,20,40,545,129,0 +3,30,20,123,54,0 +4,60,10,42,33,0 +5,80,30,709,140,0 +6,90,20,295,90,0 +7,100,50,2016,196,0 +8,130,30,739,131,0 +9,180,10,60,46,0 +10,200,60,1694,143,0 diff --git a/simulator.c b/simulator.c index 39a5411..74251ad 100644 --- a/simulator.c +++ b/simulator.c @@ -4,6 +4,7 @@ #define RR_QUANTUM 2 #define CNTXT_SWITCH 1 +#define MAX_PROCESSES 10 enum pstate { WAITING, @@ -21,7 +22,7 @@ struct pinfo { int wait_time; int turnaround_time; int remaining_time; - int n_preempted; + int nb_time_pre_empted; // Ajouté pour compter les préemptions enum pstate state; struct pinfo * next_pinfo; @@ -79,12 +80,13 @@ struct pinfo * create_process(int id, int arrival_time, int execution_time, int info->wait_time = 0; info->turnaround_time = 0; info->remaining_time = execution_time; - info->n_preempted = 0; + 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; @@ -253,7 +255,7 @@ struct perf_info schedule_Pr(struct pinfo * processes) { printf("Next process (%d) has higher priority\n", next->id); if (current->state == RUNNING) { printf(" Preempting current process (%d)\n", current->id); - current->n_preempted++; + current->nb_time_pre_empted++; current_time += CNTXT_SWITCH; perf.total_nr_ctxt_switch++; } @@ -303,6 +305,91 @@ 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 + + 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 (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é + + int time_slice = (current_process->remaining_time < RR_QUANTUM) ? current_process->remaining_time : RR_QUANTUM; // Calcule la tranche de temps à exécuter + + // 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 + + // 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 + } + other_process = other_process->next_pinfo; // Passe au processus suivant + } + + // 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 + } 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 + } + + // 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 + } + + 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 + } + } + + perf.total_time = current_time; // Enregistre le temps total écoulé dans la structure de performance + return perf; // Renvoie la structure de performance +} + +void write_file(struct pinfo * process, struct perf_info * perf) { + 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"); + 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.csv", "r"); unsigned long buf_size = sizeof(char) * 64; @@ -329,12 +416,12 @@ struct pinfo * read_file() { atoi(prio_str) ); - // If linked list not initialized + // Si la liste n'est pas initialisée if (first == NULL) { first = process; } - // If there is an element in list + // Si un élément est déjà dans la liste if (last != NULL) { last->next_pinfo = process; } @@ -347,10 +434,6 @@ struct pinfo * read_file() { return first; } -void write_file(struct pinfo * process, struct perf_info * perf) { - // TODO -} - void free_processes(struct pinfo * next) { struct pinfo * cur; while (next != NULL) { @@ -360,19 +443,20 @@ 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); - //write_file(processes, &perf); - print_processes(processes); - print_perf(&perf); + write_file(processes, &perf); free_processes(processes); return 0; -} \ No newline at end of file +} diff --git a/tempCodeRunnerFile b/tempCodeRunnerFile new file mode 100755 index 0000000..58ee3b3 Binary files /dev/null and b/tempCodeRunnerFile differ