Calcul des temps moyens et affichage des résultats finaux
Dans cette étape finale, nous allons calculer le temps d'attente moyen et le temps de réponse moyen pour tous les processus. Ces moyennes sont des métriques importantes pour évaluer l'efficacité d'un algorithme d'ordonnancement.
Modifions notre fichier fcfs.cpp pour ajouter ces calculs et terminer notre programme :
#include <iostream>
#include <iomanip> // For formatted output
using namespace std;
int main() {
cout << "FCFS Scheduling Algorithm Implementation" << endl;
cout << "----------------------------------------" << endl;
// Variables declaration
int n; // Number of processes
int burst_time[20]; // Array to store burst time of each process
int waiting_time[20]; // Array to store waiting time of each process
int turnaround_time[20]; // Array to store turnaround time of each process
int total_waiting_time = 0;
int total_turnaround_time = 0;
float avg_waiting_time = 0.0;
float avg_turnaround_time = 0.0;
// Get the number of processes from the user
cout << "\nEnter the number of processes (maximum 20): ";
cin >> n;
// Input validation
if (n <= 0 || n > 20) {
cout << "Invalid number of processes. Please enter a value between 1 and 20." << endl;
return 1;
}
// Get burst time for each process
cout << "\nEnter the Burst Time for each process:" << endl;
for (int i = 0; i < n; i++) {
cout << "Process P" << i + 1 << ": ";
cin >> burst_time[i];
// Input validation for burst time
if (burst_time[i] <= 0) {
cout << "Burst time must be a positive integer. Please restart the program." << endl;
return 1;
}
}
// Calculate waiting time for each process
waiting_time[0] = 0; // First process has 0 waiting time
for (int i = 1; i < n; i++) {
waiting_time[i] = 0;
// Add burst times of all previous processes
for (int j = 0; j < i; j++) {
waiting_time[i] += burst_time[j];
}
}
// Calculate turnaround time for each process and total times
cout << "\nProcess\tBurst Time\tWaiting Time\tTurnaround Time" << endl;
cout << "----------------------------------------------------" << endl;
for (int i = 0; i < n; i++) {
turnaround_time[i] = burst_time[i] + waiting_time[i];
total_waiting_time += waiting_time[i];
total_turnaround_time += turnaround_time[i];
cout << "P" << i + 1 << "\t" << burst_time[i] << "\t\t"
<< waiting_time[i] << "\t\t" << turnaround_time[i] << endl;
}
// Calculate average waiting time and average turnaround time
avg_waiting_time = (float)total_waiting_time / n;
avg_turnaround_time = (float)total_turnaround_time / n;
// Display the results with two decimal places
cout << fixed << setprecision(2);
cout << "\nAverage Waiting Time: " << avg_waiting_time << " time units" << endl;
cout << "Average Turnaround Time: " << avg_turnaround_time << " time units" << endl;
// Visual representation of the FCFS schedule (Gantt chart in text)
cout << "\nGantt Chart:" << endl;
cout << " ";
for (int i = 0; i < n; i++) {
for (int j = 0; j < burst_time[i]; j++) {
cout << "--";
}
}
cout << endl << "|";
for (int i = 0; i < n; i++) {
for (int j = 0; j < burst_time[i] - 1; j++) {
cout << " ";
}
cout << "P" << i + 1;
for (int j = 0; j < burst_time[i] - 1; j++) {
cout << " ";
}
cout << "|";
}
cout << endl << " ";
for (int i = 0; i < n; i++) {
for (int j = 0; j < burst_time[i]; j++) {
cout << "--";
}
}
cout << endl;
cout << "0";
int current_time = 0;
for (int i = 0; i < n; i++) {
current_time += burst_time[i];
for (int j = 0; j < burst_time[i] * 2 - 1; j++) {
cout << " ";
}
if (current_time < 10) cout << " ";
cout << current_time;
}
cout << endl;
return 0;
}
Comprenons ce que nous avons ajouté :
- Deux nouvelles variables :
avg_waiting_time et avg_turnaround_time pour stocker les temps moyens.
- Des calculs pour les temps moyens :
- Temps d'attente moyen = Temps d'attente total / Nombre de processus
- Temps de réponse moyen = Temps de réponse total / Nombre de processus
- Une sortie formatée pour afficher les temps moyens avec deux décimales.
- Un simple diagramme de Gantt basé sur du texte pour visualiser l'ordonnancement FCFS :
- Chaque processus est représenté par son identifiant (P1, P2, etc.)
- La largeur de chaque bloc de processus est proportionnelle à son temps d'exécution
- Des marqueurs de temps sont affichés en bas
Compilons et exécutons notre programme final :
g++ fcfs.cpp -o fcfs
./fcfs
Essayez d'entrer les mêmes données que précédemment :
3
5
9
4
Vous devriez voir une sortie similaire à :
FCFS Scheduling Algorithm Implementation
----------------------------------------
Enter the number of processes (maximum 20): 3
Enter the Burst Time for each process:
Process P1: 5
Process P2: 9
Process P3: 4
Process Burst Time Waiting Time Turnaround Time
----------------------------------------------------
P1 5 0 5
P2 9 5 14
P3 4 14 18
Average Waiting Time: 6.33 time units
Average Turnaround Time: 12.33 time units
Gantt Chart:
--------------------
| P1 | P2 | P3 |
--------------------
0 5 14 18
En examinant les résultats :
- Temps d'attente moyen : (0 + 5 + 14) / 3 = 6,33 unités de temps
- Temps de réponse moyen : (5 + 14 + 18) / 3 = 12,33 unités de temps
Le diagramme de Gantt représente visuellement comment les processus sont ordonnancés au fil du temps :
- P1 s'exécute de 0 à 5
- P2 s'exécute de 5 à 14
- P3 s'exécute de 14 à 18
Cela termine notre implémentation de l'algorithme d'ordonnancement FCFS. Vous pouvez expérimenter avec différents nombres de processus et temps d'exécution pour voir comment cela affecte le temps d'attente moyen et le temps de réponse moyen.
