logo

TechCodeview

Önce En Kısa Kalan Süre (Önleyici SJF) Planlama Algoritması

Önce En Kısa İş (SJF) planlamasının öncelikli sürümüne İlk Önce Kalan Kısa Süre (SRTF) adı verilir. SRTF'de bitmesine en az süre kalan süreç çalıştırılmak üzere seçilir. Çalışan süreç bitene kadar devam eder veya kalan süresi daha kısa olan yeni bir süreç gelene kadar en hızlı bitirme işleminin her zaman öncelikli olmasını sağlar.

SJF Algoritması Örneği:

Senaryo 1: Aynı Varış Saatine Sahip Süreçler

Örnek: Üç süreç için aşağıdaki varış zamanı ve patlama süresi tablosunu göz önünde bulundurun P1 P2 ve P3 .

İşlem Patlama Zamanı Varış Zamanı
 P1   6 ms0 ms
 P2 8 ms0 ms
 P3 5 ms0 ms

Adım Adım Yürütme:



  1. Zaman 0-5 (P3) : P3, kalan en kısa süreye sahip olduğundan 5 ms (kalan toplam süre: 0 ms) çalışır.
  2. Zaman 5-11 (P1) : P1 kalan en kısa süreye sahip olduğundan 6 ms (kalan toplam süre: 0 ms) çalışır.
  3. Zaman 11-19 (P2) : P2, kalan en kısa süreye sahip olduğundan 8 ms (kalan toplam süre: 0 ms) çalışır.

Gantt şeması:


Java'da dize neden değişmez?

Şimdi ortalamayı hesaplayalım bekleme süresi ve arkanı dön zaman:

bildiğimiz gibi

  • Geri dönüş zamanı = Tamamlanma zamanı – varış zamanı
  • Bekleme Süresi = Geri dönüş süresi - patlama süresi
İşlem  

Varış Zamanı

Linux'ta klasörü yeniden adlandırma

(AT)

Patlama Zamanı

(BT)

Tamamlanma Süresi (CT)Geri Dönüş Süresi (TAT)Bekleme Süresi (WT)
 P1  

6

asal sayı Java
1111-0 = 1111-6 = 5
 P2

8

1919-0 = 1919-8 = 11
 P3

5

55-0 = 55-5 = 0

Şimdi 

  • Ortalama Dönüş Süresi = (11 + 19 + 5)/3 = 11,6 ms
  • Ortalama bekleme süresi = (5 + 0 + 11 )/3 = 16/3 = 5,33 ms

Senaryo 2: Farklı Varış Sürelerine Sahip Süreçler

Üç süreç P1 P2 ve P3 için aşağıdaki varış zamanı ve patlama süresi tablosunu göz önünde bulundurun.

üçlü kış
İşlem Patlama Zamanı Varış Zamanı
 P1   6 ms0 ms
 P2 3 ms1 ms
 P3 7 ms2 ms

Adım Adım Yürütme:

  1. Süre 0-1 (P1) : P1, kalan en kısa süreye sahip olduğundan 1 ms (kalan toplam süre: 5 ms) çalışır.
  2. Zaman 1-4 (P2) : P2, P1 ve P2 arasında kalan en kısa süreye sahip olduğundan 3 ms çalışır (kalan toplam süre: 0 ms).
  3. Zaman 4-9 (P1) : P1, P1 ve P3 arasında kalan en kısa süreye sahip olduğundan 5 ms çalışır (kalan toplam süre: 0 ms).
  4. Zaman 9-16 (P3) : P3, kalan en kısa süreye sahip olduğundan 7 ms (kalan toplam süre: 0 ms) çalışır.

Gantt şeması:

Şimdi ortalamayı hesaplayalım bekleme süresi ve arkanı dön zaman:

İşlem  

Varış Saati (AT)

Patlama Süresi (BT)

Tamamlanma Süresi (CT)Geri Dönüş Süresi (TAT)Bekleme Süresi (WT)
 P1  

6

99-0 = 99-6 = 3
 P2

1

3

44-1 = 33-3 = 0
 P3

2

java'da dizi.sort

7

1616-2 = 1414-7 = 7
  • Ortalama Dönüş Süresi = (9 + 14 + 3)/3 = 8,6 ms
  • Ortalama bekleme süresi = (3 + 0 + 7 )/3 = 10/3 = 3,33 ms

SRTF Algoritmasının Uygulanması

1. Adım: Varış zamanı ve patlama süresiyle birlikte işlem sayısını girin.
Adım 2: Kalan süreleri (patlama süreleri) mevcut süre = 0 ve sayaçları başlatın.
3. Adım: Her seferinde hazır kuyruğuna gelen işlemleri birim ekleyin.
Adım 4: Kalan süresi en kısa olan işlemi seçin (daha kısa bir süre gelirse önleyin).
Adım 5: Seçilen işlemi 1 birim için yürütün, kalan süreyi azaltın ve mevcut süreyi artırın.
Adım 6: Bir işlem tamamlanırsa:

  • Geri Dönüş Süresi = Tamamlanma Süresi − Varış Süresi
  • Bekleme Süresi = Geri Dönüş Süresi − Patlama Süresi

Adım 7: Tüm işlemler tamamlanana kadar 3-6 arasındaki adımları tekrarlayın.
Adım 8: Ortalama bekleme süresini ve geri dönüş süresini hesaplayın.
Adım 9: Ortalamalarla birlikte her işlem için tamamlanma bekleme ve geri dönüş sürelerini görüntüleyin.

Kod Uygulaması

En Kısa Kalan Sürenin İlk Uygulama Programı aşağıdaki gibidir:

C++ 
#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; }
Java 
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);  } }
Python 
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)

Çıkış 
Enter number of processes: Avg WT: -nan Avg TAT: -nan

SRTF'nin Avantajları Planlama

  1. Ortalama Bekleme Süresini En Aza İndirir : SRTF, kalan yürütme süresi en kısa olan işlemlere öncelik vererek ortalama bekleme süresini azaltır.
  2. Kısa Süreçler için Verimli : Daha kısa süreçler daha hızlı tamamlanır ve genel sistem yanıt verme hızı artırılır.
  3. Zamanın Kritik Olduğu Sistemler için İdeal : Zamana duyarlı süreçlerin hızlı bir şekilde yürütülmesini sağlar.

SRTF'nin dezavantajları Planlama

  1. Uzun Süreçlerin Açlığı : Daha kısa süreçler gelmeye devam ederse, daha uzun süreçler süresiz olarak gecikebilir.
  2. Patlama Zamanlarını Tahmin Etmek Zor : Proses patlama sürelerinin doğru tahmini zordur ve planlama kararlarını etkiler.
  3. Yüksek Yük : Sık bağlam değiştirme, yükü artırabilir ve sistem performansını yavaşlatabilir.
  4. Gerçek Zamanlı Sistemlere Uygun Değil : Gerçek zamanlı görevler, sık sık yapılan ön alımlar nedeniyle gecikmelere maruz kalabilir.
Test Oluştur