Einführung
In diesem Lab werden wir lernen, wie man den Round Robin Scheduling Algorithmus (Rundrobin-Scheduling-Algorithmus) in C++ implementiert. Der Round Robin Scheduling Algorithmus ist ein präemptiver Algorithmus, bei dem ein Prozess für ein festes Zeitintervall, das als Zeitquantum bekannt ist, ausgeführt wird. Wenn der Prozess seine Ausführung innerhalb des Zeitquants abgeschlossen hat, wird er beendet. Andernfalls wird er an das Ende der Warteschlange verschoben.
Erstellen Sie eine neue C++-Datei
Zuerst erstellen Sie eine neue C++-Datei im Verzeichnis ~/project. Sie können sie round_robin.cpp nennen.
cd ~/project
touch round_robin.cpp
Inkludieren Sie die erforderlichen Bibliotheken
Binden Sie die erforderlichen Bibliotheken in die Datei round_robin.cpp ein.
#include <iostream>
using namespace std;
Definieren Sie die main()-Funktion
Definieren Sie die main()-Funktion und initialisieren Sie die Prozess-IDs (Prozessidentifikatoren), die Burst-Zeiten (Ausführungszeiten), das Zeitquantum und die Anzahl der Prozesse.
int main()
{
// Process IDs
int processes[] = { 1, 2, 3, 4 };
// Burst time of all processes
int burst_time[] = { 5, 9, 6, 8 };
// Time quantum
int quantum = 2;
// Number of processes
int n = sizeof processes / sizeof processes[0];
return 0;
}
Implementieren Sie die Funktion zur Berechnung der Wartezeit
Die Funktion findWaitingTime() wird verwendet, um die Wartezeit für alle Prozesse zu berechnen. Diese Funktion ist so definiert, dass sie die Prozesse im Round-Robin-Verfahren durchläuft.
void findWaitingTime(int processes[], int n, int bt[], int wt[], int quantum)
{
// Make a copy of burst times bt[] to store remaining
// burst times.
int rem_bt[n];
for (int i = 0; i < n; i++)
rem_bt[i] = bt[i];
int t = 0; // Current time
// Keep traversing processes in round-robin manner
// until all of them are not done.
while (1) {
bool done = true;
// Traverse all processes one by one repeatedly
for (int i = 0; i < n; i++) {
// If burst time of a process is greater than 0
// then only need to process further
if (rem_bt[i] > 0) {
done = false; // There is a pending process
/* If remaining burst time is greater than
quantum then decrease the time slice
from remaining burst time */
if (rem_bt[i] > quantum) {
// Increase the value of t i.e. shows
// how much time a process has been processed
t += quantum;
// Decrease the burst_time of current process
// by quantum
rem_bt[i] -= quantum;
}
/* If remaining burst time is smaller than
or equal to quantum then the remaining
burst time for this process is 0.*/
else {
// Increase the value of t i.e. shows
// how much time a process has been processed
t += rem_bt[i];
// Waiting time is current time minus time
// used by this process
wt[i] = t - bt[i];
// As the process gets fully executed
// make its remaining burst time = 0
rem_bt[i] = 0;
}
}
}
// If all processes are done
if (done == true)
break;
}
}
Implementieren Sie die Funktion zur Berechnung der Antwortzeit
Die Funktion findTurnAroundTime() wird verwendet, um die Antwortzeit (Turnaround-Zeit) für alle Prozesse zu berechnen.
void findTurnAroundTime(int processes[], int n,
int bt[], int wt[], int tat[])
{
// calculating turnaround time by adding
// bt[i] + wt[i]
for (int i = 0; i < n; i++)
tat[i] = bt[i] + wt[i];
}
Implementieren Sie die Funktion zur Berechnung der durchschnittlichen Zeit
Die Funktion findavgTime() wird verwendet, um die durchschnittliche Wartezeit und die durchschnittliche Antwortzeit (Turnaround-Zeit) für alle Prozesse zu berechnen.
void findavgTime(int processes[], int n, int bt[],
int quantum)
{
int wt[n], tat[n], total_wt = 0, total_tat = 0;
// Function to find waiting time of all processes
findWaitingTime(processes, n, bt, wt, quantum);
// Function to find turn around time for all processes
findTurnAroundTime(processes, n, bt, wt, tat);
// Display processes along with all details
cout << "Processes "
<< " Burst time "
<< " Waiting time "
<< " Turn around time\n";
// Calculate total waiting time and total turn
// around time
for (int i = 0; i < n; i++) {
total_wt = total_wt + wt[i];
total_tat = total_tat + tat[i];
cout << " " << i + 1 << "\t\t" << bt[i] << "\t "
<< wt[i] << "\t\t " << tat[i] << endl;
}
cout << "Average waiting time = "
<< (float)total_wt / (float)n;
cout << "\nAverage turn around time = "
<< (float)total_tat / (float)n;
}
Rufen Sie die Funktion findavgTime() auf
Rufen Sie die findavgTime()-Funktion auf, um die durchschnittliche Wartezeit und die durchschnittliche Antwortzeit (Turnaround-Zeit) für die Prozesse zu berechnen.
int main()
{
int processes[] = { 1, 2, 3, 4 };
// Burst time of all processes
int burst_time[] = { 5, 9, 6, 8 };
// Time quantum
int quantum = 2;
// Number of processes
int n = sizeof processes / sizeof processes[0];
// Function to find average time
findavgTime(processes, n, burst_time, quantum);
return 0;
}
Um den Code in einem Terminal auszuführen, führen Sie den folgenden Befehl im Verzeichnis ~/project aus.
g++ round_robin.cpp -o round_robin &&./round_robin
Zusammenfassung
In diesem Lab haben wir gelernt, wie man den Round-Robin-Scheduling-Algorithmus (Rotierendes Verfahren zur Prozessplanung) in C++ implementiert. Dieser Algorithmus wird verwendet, um Prozesse in einem Betriebssystem für ein Zeitintervall, das als Zeitquantum (Time Quantum) bekannt ist, zu planen. Wir haben auch gesehen, wie man die durchschnittliche Wartezeit und die durchschnittliche Antwortzeit (Turnaround-Zeit) für eine Gruppe von Prozessen berechnet.
