Den forebyggende versjonen av Shortest Job First (SJF)-planlegging kalles Shortest Remaining Time First (SRTF). I SRTF velges prosessen med minst tid igjen å fullføre. Den kjørende prosessen fortsetter til den er ferdig eller en ny prosess med kortere gjenværende tid kommer, noe som sikrer at den raskeste etterbehandlingsprosessen alltid får prioritet.
Eksempel på SJF-algoritme:
Scenario 1: Prosesser med samme ankomsttid
Eksempel: Vurder følgende tabell over ankomsttid og eksplosjonstid for tre prosesser P1 P2 og P3 .
| Behandle | Burst Time | Ankomsttid |
|---|---|---|
| P1 | 6 ms | 0 ms |
| P2 | 8 ms | 0 ms |
| P3 | 5 ms | 0 ms |
Trinn-for-trinn utførelse:
- Tid 0-5 (P3) : P3 kjører i 5 ms (total tid igjen: 0 ms) da den har kortest gjenværende tid igjen.
- Tid 5-11 (P1) : P1 kjører i 6 ms (total tid igjen: 0 ms) da den har kortest gjenværende tid igjen.
- Tid 11-19 (P2) : P2 kjører i 8 ms (total tid igjen: 0 ms) da den har kortest gjenværende tid igjen.
Gantt-diagram:
intelligent idé vs formørkelse
La oss nå beregne gjennomsnittet ventetid og snu tid:
Som vi vet
- Vendetid = Gjennomføringstid - ankomsttid
- Ventetid = Snutid - sprengningstid
| Behandle | Ankomsttid (PÅ) | Burst Time java mens tilstand (BT) | Fullføringstid (CT) | Omløpstid (TAT) | Ventetid (WT) |
|---|---|---|---|---|---|
| P1 | 6 | 11 | 11-0 = 11 | 11-6 = 5 | |
| P2 | np polstring | 8 | 19 | 19-0 = 19 | 19-8 = 11 |
| P3 | 5 | 5 | 5-0 = 5 | 5-5 = 0 |
Nå
- Gjennomsnittlig snutid = (11 + 19 + 5)/3 = 11,6 ms
- Gjennomsnittlig ventetid = (5 + 0 + 11 )/3 = 16/3 = 5,33 ms
Scenario 2: Prosesser med forskjellige ankomsttider
Tenk på følgende tabell over ankomsttid og bruddtid for tre prosesser P1 P2 og P3.
| Behandle | Burst Time | Ankomsttid |
|---|---|---|
| P1 | 6 ms | 0 ms |
| P2 | 3 ms | 1 ms |
| P3 | 7 ms | 2 ms |
Trinn-for-trinn utførelse:
forskjellen mellom firma og selskap
- Tid 0-1 (P1) : P1 kjører i 1 ms (total tid igjen: 5 ms) da den har kortest gjenværende tid igjen.
- Tid 1-4 (P2) : P2 går i 3 ms (total tid igjen: 0 ms) da den har kortest gjenværende tid igjen blant P1 og P2.
- Tid 4-9 (P1) : P1 kjører i 5 ms (total tid igjen: 0 ms) da den har kortest gjenværende tid igjen blant P1 og P3.
- Tid 9-16 (P3) : P3 kjører i 7 ms (total tid igjen: 0 ms) da den har kortest gjenværende tid igjen.
Gantt-diagram:
La oss nå beregne gjennomsnittet ventetid og snu tid:
| Behandle | Ankomsttid (AT) | Burst Time (BT) | Fullføringstid (CT) | Omløpstid (TAT) | Ventetid (WT) |
|---|---|---|---|---|---|
| P1 | css overgangsopasitet | 6 | 9 | 9-0 = 9 | 9-6 = 3 |
| P2 | 1 | 3 | 4 | 4-1 = 3 | 3-3 = 0 |
| P3 | 2 | 7 | 16 | 16-2 = 14 | 14-7 = 7 |
- Gjennomsnittlig snutid = (9 + 14 + 3)/3 = 8,6 ms
- Gjennomsnittlig ventetid = (3 + 0 + 7)/3 = 10/3 = 3,33 ms
Implementering av SRTF Algoritme
Trinn 1: Legg inn antall prosesser med ankomsttid og bruddtid.
Trinn 2: Initialiser gjenværende tider (bursttider) gjeldende tid = 0 og tellere.
Trinn 3: Legg til prosesser som har kommet inn i klarkøen ved hver tidsenhet.
Trinn 4: Velg prosessen med kortest gjenværende tid (forhindre hvis en kortere kommer).
Trinn 5: Utfør den valgte prosessen for 1 enhet, reduser gjenværende tid og øk gjeldende tid.
Trinn 6: Hvis en prosess fullføres:
- Omløpstid = Fullføringstid − Ankomsttid
- Ventetid = Omløpstid − Burst Time
Trinn 7: Gjenta trinn 3–6 til alle prosesser er fullført.
Trinn 8: Beregn gjennomsnittlig ventetid og behandlingstid.
Trinn 9: Vis vente- og behandlingstider for fullføring for hver prosess sammen med gjennomsnitt.
Kodeimplementering
Programmet for å implementere korteste gjenværende tid først er som følger:
C++#include
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)
Produksjon
Enter number of processes: Avg WT: -nan Avg TAT: -nan
Fordeler med SRTF Planlegging
- Minimerer gjennomsnittlig ventetid : SRTF reduserer gjennomsnittlig ventetid ved å prioritere prosesser med kortest gjenværende utførelsestid.
- Effektiv for korte prosesser : Kortere prosesser fullføres raskere, noe som forbedrer systemets generelle reaksjonsevne.
- Ideell for tidskritiske systemer : Det sikrer at tidssensitive prosesser utføres raskt.
Ulemper med SRTF Planlegging
- Utsulting av lange prosesser : Lengre prosesser kan bli forsinket på ubestemt tid hvis kortere prosesser fortsetter å komme.
- Vanskelig å forutsi sprengningstider : Nøyaktig prediksjon av prosessbruddstider er utfordrende og påvirker planleggingsbeslutninger.
- Høy overhead : Hyppig kontekstbytte kan øke overhead og redusere systemytelsen.
- Ikke egnet for sanntidssystemer : Sanntidsoppgaver kan bli utsatt for forsinkelser på grunn av hyppige forkjøp.