logo

TechCodeview

Pirmiausia trumpiausias likęs laikas (prevencinis SJF) planavimo algoritmas

Išankstinė trumpiausio darbo pradžia (SJF) planavimo versija vadinama trumpiausiu likusiu laiku pirmiausia (SRTF). SRTF pasirenkamas paleisti procesas, kuriam iki pabaigos liko mažiausiai laiko. Vykdomas procesas tęsiasi tol, kol baigiasi arba atsiranda naujas procesas su trumpesniu likusiu laiku, todėl pirmenybė visada teikiama greičiausiam užbaigimo procesui.

SJF algoritmo pavyzdys:

1 scenarijus: procesai su tuo pačiu atvykimo laiku

Pavyzdys: Apsvarstykite toliau pateiktą trijų procesų atvykimo laiko ir serijos trukmės lentelę P1 P2 ir P3 .

Procesas Burst Time Atvykimo laikas
 P1   6 ms0 ms
 P2 8 ms0 ms
 P3 5 ms0 ms

Žingsnis po žingsnio vykdymas:



  1. Laikas 0–5 (P3) : P3 veikia 5 ms (bendras likęs laikas: 0 ms), nes liko trumpiausias laikas.
  2. Laikas 5–11 (P1) : P1 veikia 6 ms (bendras likęs laikas: 0 ms), nes liko trumpiausias laikas.
  3. Laikas 11–19 (P2) : P2 veikia 8 ms (bendras likęs laikas: 0 ms), nes liko trumpiausias laikas.

Ganto diagrama:


rdbms

Dabar paskaičiuokime vidurkį laukimo laiko ir apsisukti laikas:

Kaip žinome

  • Apsisukimo laikas = Užbaigimo laikas – atvykimo laikas
  • Laukimo laikas = Apsisukimo laikas – serijos laikas
Procesas  

Atvykimo laikas

(AT)

Burst Time

metus į ketvirčius

(BT)

Užbaigimo laikas (KT)Apsisukimo laikas (TAT)Laukimo laikas (WT)
 P1  

6

1111-0 = 1111-6 = 5
 P2

pitono gyvatė vs anakonda

8

1919-0 = 1919-8 = 11
 P3

5

55-0 = 55-5 = 0

Dabar 

  • Vidutinis apsisukimo laikas = (11 + 19 + 5)/3 = 11,6 ms
  • Vidutinis laukimo laikas = (5 + 0 + 11) / 3 = 16/3 = 5,33 ms

2 scenarijus: procesai su skirtingu atvykimo laiku

Apsvarstykite toliau pateiktą trijų procesų P1 P2 ir P3 atvykimo laiko ir serijos trukmės lentelę.

Procesas Burst Time Atvykimo laikas
 P1   6 ms0 ms
 P2 3 ms1 ms
 P3 7 ms2 ms

Žingsnis po žingsnio vykdymas:

kitaip jei bash
  1. Laikas 0–1 (P1) : P1 veikia 1 ms (bendras likęs laikas: 5 ms), nes liko trumpiausias laikas.
  2. Laikas 1–4 (P2) : P2 veikia 3 ms (bendras likęs laikas: 0 ms), nes liko trumpiausias laikas tarp P1 ir P2.
  3. Laikas 4–9 (P1) : P1 veikia 5 ms (bendras likęs laikas: 0 ms), nes liko trumpiausias laikas tarp P1 ir P3.
  4. Laikas 9–16 (P3) : P3 veikia 7 ms (bendras likęs laikas: 0 ms), nes liko trumpiausias laikas.

Ganto diagrama:

Dabar paskaičiuokime vidurkį laukimo laiko ir apsisukti laikas:

Procesas  

Atvykimo laikas (AT)

serijos laikas (BT)

Užbaigimo laikas (KT)Apsisukimo laikas (TAT)Laukimo laikas (WT)
 P1  

nepakeičiamas sąrašas

6

99-0 = 99-6 = 3
 P2

1

3

44-1 = 33-3 = 0
 P3

2

7

1616-2 = 1414-7 = 7
  • Vidutinis apsisukimo laikas = (9 + 14 + 3) / 3 = 8,6 ms
  • Vidutinis laukimo laikas = (3 + 0 + 7)/3 = 10/3 = 3,33 ms

SRTF algoritmo įgyvendinimas

1 veiksmas: Įveskite procesų skaičių su atvykimo laiku ir serijos trukme.
2 veiksmas: Inicijuoti likusį laiką (sujungimo laiką), dabartinį laiką = 0 ir skaitiklius.
3 veiksmas: Prie kiekvieno laiko vieneto pridėkite procesus, kurie atėjo į paruoštų eilę.
4 veiksmas: Pasirinkite procesą, kurio likęs laikas yra trumpiausias (iš anksto, jei ateina trumpesnis).
5 veiksmas: Vykdykite pasirinktą procesą 1 vienetui, sumažinkite likusį laiką ir padidinkite esamą laiką.
6 veiksmas: Jei procesas baigtas:

  • Apdorojimo laikas = užbaigimo laikas − atvykimo laikas
  • Laukimo laikas = apyvartos laikas − serijos laikas

7 veiksmas: Kartokite 3–6 veiksmus, kol bus baigti visi procesai.
8 veiksmas: Apskaičiuokite vidutinį laukimo ir apyvartos laiką.
9 veiksmas: Rodyti kiekvieno proceso užbaigimo laukimo ir apyvartos laiką kartu su vidurkiais.

Kodo įgyvendinimas

Programa, skirta įgyvendinti trumpiausią likusį laiką, yra tokia:

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)

Išvestis 
Enter number of processes: Avg WT: -nan Avg TAT: -nan

SRTF privalumai Planavimas

  1. Sumažina vidutinį laukimo laiką : SRTF sumažina vidutinį laukimo laiką, suteikdama pirmenybę procesams, kurių vykdymo laikas yra trumpiausias.
  2. Veiksmingas trumpiems procesams : trumpesni procesai užbaigiami greičiau, pagerinant bendrą sistemos reagavimą.
  3. Idealiai tinka laiko kritinėms sistemoms : Tai užtikrina, kad laikui jautrūs procesai būtų vykdomi greitai.

SRTF trūkumai Planavimas

  1. Ilgų procesų badas : Ilgesni procesai gali būti atidėti neribotam laikui, jei vis atsiranda trumpesnių procesų.
  2. Sunku numatyti sprogimo laiką : Tikslus proceso eigos laiko numatymas yra sudėtingas ir turi įtakos planavimo sprendimams.
  3. Aukštos pridėtinės išlaidos : Dažnas konteksto perjungimas gali padidinti išlaidas ir sulėtinti sistemos veikimą.
  4. Netinka realaus laiko sistemoms : Užduotys realiuoju laiku gali vėluoti dėl dažnų prevencijų.
Sukurti viktoriną