logo

TechCodeview

Најкраће преостало време прво (превентивни СЈФ) алгоритам за заказивање

Превентивна верзија заказивања Најпре најкраћи посао (СЈФ) назива се најпре најкраће преостало време (СРТФ). У СРТФ-у се бира процес са најмање преосталог времена до завршетка. Процес покретања се наставља све док се не заврши или док не стигне нови процес са краћим преосталим временом, осигуравајући да најбржи завршни процес увек има приоритет.

Пример СЈФ алгоритма:

Сценарио 1: Процеси са истим временом доласка

Пример: Размотрите следећу табелу времена доласка и времена пражњења за три процеса П1 П2 и П3 .

Процес Бурст Тиме Време доласка
 П1   6 мс0 мс
 П2 8 мс0 мс
 П3 5 мс0 мс

Извођење корак по корак:



  1. Време 0-5 (П3) : П3 ради 5 мс (укупно преостало време: 0 мс) пошто му је преостало најкраће време.
  2. Време 5-11 (П1) : П1 ради 6 мс (укупно преостало време: 0 мс) пошто му је преостало најкраће време.
  3. Време 11-19 (П2) : П2 ради 8 мс (укупно преостало време: 0 мс) пошто му је преостало најкраће време.

Гантов графикон:


селен туториал јава

Сада хајде да израчунамо просек време чекања и окренути се време:

Као што знамо

  • Окрени време = Време завршетка - време доласка
  • Време чекања = Време окретања - време пуцања
Процес  

Време доласка

(АТ)

Бурст Тиме

(БТ)

Време завршетка (ЦТ)Време преокрета (ТАТ)Време чекања (ВТ)
 П1  

понављање мапе у Јави

6

1111-0 = 1111-6 = 5
 П2

8

1919-0 = 1919-8 = 11
 П3

5

55-0 = 55-5 = 0

Сада 

гимп извоз као јпг
  • Просечно време преокрета = (11 + 19 + 5)/3 = 11,6 мс
  • Просечно време чекања = (5 + 0 + 11 )/3 = 16/3 = 5,33 мс

Сценарио 2: Процеси са различитим временима доласка

Размотрите следећу табелу времена доласка и времена пражњења за три процеса П1 П2 и П3.

Процес Бурст Тиме Време доласка
 П1   6 мс0 мс
 П2 3 мс1 мс
 П3 7 мс2 мс

Извођење корак по корак:

  1. Време 0-1 (П1) : П1 ради 1 мс (укупно преостало време: 5 мс) пошто му је преостало најкраће време.
  2. Време 1-4 (П2) : П2 ради 3 мс (укупно преостало време: 0 мс) пошто има најкраће преостало време између П1 и П2.
  3. Време 4-9 (П1) : П1 ради 5 мс (укупно преостало време: 0 мс) пошто има најкраће преостало време између П1 и П3.
  4. Време 9-16 (П3) : П3 ради 7 мс (укупно преостало време: 0 мс) пошто му је преостало најкраће време.

Гантов графикон:

Сада хајде да израчунамо просек време чекања и окренути се време:

Процес  

Време доласка (АТ)

Бурст Тиме (БТ)

нп.где
Време завршетка (ЦТ)Време преокрета (ТАТ)Време чекања (ВТ)
 П1  

6

99-0 = 99-6 = 3
 П2

1

јава додавање у низ

3

44-1 = 33-3 = 0
 П3

2

7

1616-2 = 1414-7 = 7
  • Просечно време преокрета = (9 + 14 + 3)/3 = 8,6 мс
  • Просечно време чекања = (3 + 0 + 7 )/3 = 10/3 = 3,33 мс

Имплементација СРТФ алгоритма

1. корак: Унесите број процеса са временом доласка и временом рафала.
2. корак: Иницијализујте преостала времена (бурст тиме) тренутно време = 0 и бројаче.
Корак 3: У свакој временској јединици додајте процесе који су стигли у ред чекања.
4. корак: Изаберите процес са најкраћим преосталим временом (преузмите ако стигне краћи).
5. корак: Извршите изабрани процес за 1 јединицу, смањите преостало време и повећајте тренутно време.
Корак 6: Ако се процес заврши:

  • Време преокрета = Време завршетка − Време доласка
  • Време чекања = Време преокрета − Време рафала

7. корак: Понављајте кораке 3–6 док се сви процеси не заврше.
Корак 8: Израчунајте просечно време чекања и време обраде.
9. корак: Прикажите време чекања завршетка и обрта за сваки процес заједно са просецима.

Имплементација кода

Програм за имплементацију најкраћег преосталог времена је следећи:

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)

Излаз 
Enter number of processes: Avg WT: -nan Avg TAT: -nan

Предности СРТФ-а Планирање

  1. Минимизира просечно време чекања : СРТФ смањује просечно време чекања тако што даје приоритет процесима са најкраћим преосталим временом извршења.
  2. Ефикасан за кратке процесе : Краћи процеси се брже завршавају побољшавајући укупни одзив система.
  3. Идеалан за системе који су критични по времену : Обезбеђује да се процеси осетљиви на време извршавају брзо.

Недостаци СРТФ-а Планирање

  1. Изгладњивање дугих процеса : Дужи процеси могу бити одложени на неодређено време ако краћи процеси стално пристижу.
  2. Времена пуцања је тешко предвидети : Прецизно предвиђање времена пуцања процеса је изазовно и утиче на одлуке о распореду.
  3. Хигх Оверхеад : Честа промена контекста може повећати оптерећење и успорити перформансе система.
  4. Није погодно за системе у реалном времену : Задаци у реалном времену могу имати кашњења због честих предумишљаја.
Креирај квиз