La version préemptive de la planification SJF (Shortest Remaining Time First) est appelée Shortest Remaining Time First (SRTF). Dans SRTF, le processus ayant le moins de temps pour se terminer est sélectionné pour être exécuté. Le processus en cours se poursuit jusqu'à ce qu'il se termine ou qu'un nouveau processus avec un temps restant plus court arrive, garantissant que le processus de finition le plus rapide est toujours prioritaire.

Exemple d'algorithme SJF :

Scénario 1 : processus avec la même heure d'arrivée

Exemple: Considérez le tableau suivant de l'heure d'arrivée et du temps de rafale pour trois processus P1 P2 et P3 .

Exécution étape par étape :

1. Temps 0-5 (P3) : P3 fonctionne pendant 5 ms (temps total restant : 0 ms) car il lui reste le temps restant le plus court.
2. Temps 5-11 (P1) : P1 fonctionne pendant 6 ms (temps total restant : 0 ms) car il lui reste le temps restant le plus court.
3. Heure 11-19 (P2) : P2 fonctionne pendant 8 ms (temps total restant : 0 ms) car il lui reste le temps restant le plus court.

Diagramme de Gantt :

aryen khan

Calculons maintenant la moyenne temps d'attente et faire demi-tour temps:

Comme nous le savons

• Temps de retournement = Heure d'achèvement - heure d'arrivée
• Temps d'attente = Temps de retournement - temps de rafale

Maintenant 

• Délai d'exécution moyen = (11 + 19 + 5)/3 = 11,6 ms
• Temps d'attente moyen = (5 + 0 + 11 )/3 = 16/3 = 5,33 ms

Scénario 2 : processus avec des heures d'arrivée différentes

Considérez le tableau suivant de l'heure d'arrivée et du temps de rafale pour trois processus P1 P2 et P3.

Exécution étape par étape :

1. Temps 0-1 (P1) : P1 fonctionne pendant 1 ms (temps total restant : 5 ms) car il lui reste le temps restant le plus court.
2. Temps 1-4 (P2) : P2 fonctionne pendant 3 ms (temps total restant : 0 ms) car il lui reste le temps restant le plus court entre P1 et P2.
3. Temps 4-9 (P1) : P1 fonctionne pendant 5 ms (temps total restant : 0 ms) car il lui reste le temps restant le plus court entre P1 et P3.
4. Heure 9-16 (P3) : P3 fonctionne pendant 7 ms (temps total restant : 0 ms) car il lui reste le temps restant le plus court.

Diagramme de Gantt :

Calculons maintenant la moyenne temps d'attente et faire demi-tour temps:

liste de liens en Java

• Délai d'exécution moyen = (9 + 14 + 3)/3 = 8,6 ms
• Temps d'attente moyen = (3 + 0 + 7 )/3 = 10/3 = 3,33 ms

Implémentation de l'algorithme SRTF

Étape 1 : Saisissez le nombre de processus avec l’heure d’arrivée et l’heure de rafale.
Étape 2 : Initialiser les temps restants (temps de rafale) temps actuel = 0 et compteurs.
Étape 3 : À chaque unité de temps, ajoutez les processus arrivés dans la file d'attente prête.
Étape 4 : Sélectionnez le processus avec le temps restant le plus court (préemptez si un plus court arrive).
Étape 5 : Exécute le processus sélectionné pendant 1 unité, réduit son temps restant et incrémente le temps actuel.
Étape 6 : Si un processus se termine :

• Temps d'exécution = Heure d'achèvement - Heure d'arrivée
• Temps d'attente = Temps d'exécution - Temps de rafale

Étape 7 : Répétez les étapes 3 à 6 jusqu'à ce que tous les processus soient terminés.
Étape 8 : Calculez le temps d’attente moyen et le délai d’exécution.
Étape 9 : Affichez les délais d'attente et d'exécution pour chaque processus ainsi que les moyennes.

Implémentation du code

Le programme visant à mettre en œuvre le temps restant le plus court en premier est le suivant :

#include    #include  #include    using namespace std; struct Process {  int id arrivalTime burstTime remainingTime waitingTime turnaroundTime completionTime; }; int main() {  int n currentTime = 0 completed = 0;  cout << 'Enter number of processes: ';  cin >> n;  vector<Process> p(n);    for (int i = 0; i < n; i++) {  p[i].id = i + 1;  cin >> p[i].arrivalTime >> p[i].burstTime;  p[i].remainingTime = p[i].burstTime;  }  while (completed < n) {  int idx = -1;  for (int i = 0; i < n; i++) {  if (p[i].arrivalTime <= currentTime && p[i].remainingTime > 0 && (idx == -1 || p[i].remainingTime < p[idx].remainingTime)) {  idx = i;  }  }  if (idx != -1) {  p[idx].remainingTime--;  currentTime++;  if (p[idx].remainingTime == 0) {  p[idx].completionTime = currentTime;  p[idx].turnaroundTime = currentTime - p[idx].arrivalTime;  p[idx].waitingTime = p[idx].turnaroundTime - p[idx].burstTime;  completed++;  }  } else {  currentTime++;  }  }  double totalWT = 0 totalTAT = 0;  for (auto &proc : p) {  totalWT += proc.waitingTime;  totalTAT += proc.turnaroundTime;  cout << 'P' << proc.id << ' CT: ' << proc.completionTime << ' WT: ' << proc.waitingTime << ' TAT: ' << proc.turnaroundTime << endl;  }  cout << 'Avg WT: ' << totalWT / n << ' Avg TAT: ' << totalTAT / n << endl; } 

import java.util.*; class Process {  int id arrivalTime burstTime remainingTime waitingTime turnaroundTime completionTime;  public Process(int id int arrivalTime int burstTime) {  this.id = id;  this.arrivalTime = arrivalTime;  this.burstTime = burstTime;  this.remainingTime = burstTime;  } } public class SRTF {  public static void main(String[] args) {  Scanner sc = new Scanner(System.in);  int n = sc.nextInt();  Process[] processes = new Process[n];    for (int i = 0; i < n; i++) {  int arrivalTime = sc.nextInt() burstTime = sc.nextInt();  processes[i] = new Process(i + 1 arrivalTime burstTime);  }  Arrays.sort(processes Comparator.comparingInt(p -> p.arrivalTime));  int currentTime = 0 completed = 0;  while (completed < n) {  int idx = -1;  for (int i = 0; i < n; i++) {  if (processes[i].arrivalTime <= currentTime && processes[i].remainingTime > 0 && (idx == -1 || processes[i].remainingTime < processes[idx].remainingTime)) {  idx = i;  }  }  if (idx != -1) {  processes[idx].remainingTime--;  currentTime++;  if (processes[idx].remainingTime == 0) {  processes[idx].completionTime = currentTime;  processes[idx].turnaroundTime = currentTime - processes[idx].arrivalTime;  processes[idx].waitingTime = processes[idx].turnaroundTime - processes[idx].burstTime;  completed++;  }  } else {  currentTime++;  }  }  double totalWT = 0 totalTAT = 0;  for (Process p : processes) {  totalWT += p.waitingTime;  totalTAT += p.turnaroundTime;  System.out.println('P' + p.id + ' CT: ' + p.completionTime + ' WT: ' + p.waitingTime + ' TAT: ' + p.turnaroundTime);  }  System.out.println('Avg WT: ' + totalWT / n + ' Avg TAT: ' + totalTAT / n);  } } 

class Process: def __init__(self id arrival_time burst_time): self.id = id self.arrival_time = arrival_time self.burst_time = burst_time self.remaining_time = burst_time def srtf(processes): current_time completed = 0 0 while completed < len(processes): idx = -1 for i p in enumerate(processes): if p.arrival_time <= current_time and p.remaining_time > 0 and (idx == -1 or p.remaining_time < processes[idx].remaining_time): idx = i if idx != -1: processes[idx].remaining_time -= 1 current_time += 1 if processes[idx].remaining_time == 0: processes[idx].completion_time = current_time processes[idx].turnaround_time = current_time - processes[idx].arrival_time processes[idx].waiting_time = processes[idx].turnaround_time - processes[idx].burst_time completed += 1 else: current_time += 1 def print_results(processes): total_wt total_tat = 0 0 for p in processes: total_wt += p.waiting_time total_tat += p.turnaround_time print(f'P{p.id} CT: {p.completion_time} WT: {p.waiting_time} TAT: {p.turnaround_time}') print(f'Avg WT: {total_wt / len(processes)} Avg TAT: {total_tat / len(processes)}') n = int(input('Enter number of processes: ')) processes = [Process(i + 1 *map(int input(f'Enter arrival and burst time for P{i + 1}: ').split())) for i in range(n)] srtf(processes) print_results(processes) 

Enter number of processes: Avg WT: -nan Avg TAT: -nan 

Avantages du SRTF Planification

1. Minimise le temps d'attente moyen : SRTF réduit le temps d'attente moyen en donnant la priorité aux processus ayant le temps d'exécution restant le plus court.
2. Efficace pour les processus courts : Les processus plus courts sont exécutés plus rapidement, améliorant ainsi la réactivité globale du système.
3. Idéal pour les systèmes à temps critique : Il garantit que les processus urgents sont exécutés rapidement.

Inconvénients du SRTF Planification

1. Manque de longs processus : Des processus plus longs peuvent être retardés indéfiniment si des processus plus courts continuent d'arriver.
2. Difficile de prédire les heures de rafale : La prévision précise des temps de rafale des processus est un défi et affecte les décisions de planification.
3. Frais généraux élevés : Des changements de contexte fréquents peuvent augmenter la surcharge et ralentir les performances du système.
4. Ne convient pas aux systèmes en temps réel : Les tâches en temps réel peuvent subir des retards en raison de préemptions fréquentes.