logo

TechCodeview

Алгоритм планування з найкоротшим часом, що залишився (попереджувальний SJF).

Упереджувальна версія планування найкоротшого завдання спочатку (SJF) називається спочатку найкоротшим залишковим часом (SRTF). У SRTF для запуску вибирається процес із найменшим часом до завершення. Запущений процес продовжується, доки він не завершиться або не прийде новий процес із меншим часом, що залишився, гарантуючи, що найшвидший завершальний процес завжди матиме пріоритет.

Приклад алгоритму SJF:

Сценарій 1: процеси з однаковим часом надходження

приклад: Розглянемо наступну таблицю часу прибуття та часу пакету для трьох процесів P1 P2 і P3 .

процес Час вибуху Час прибуття
 P1   6 мс0 мс
 P2 8 мс0 мс
 P3 5 мс0 мс

Поетапне виконання:



  1. Час 0-5 (P3) : P3 працює протягом 5 мс (загальний час, що залишився: 0 мс), оскільки він має найкоротший час, що залишився.
  2. Час 5-11 (P1) : P1 працює протягом 6 мс (загальний час, що залишився: 0 мс), оскільки він має найкоротший час, що залишився.
  3. Час 11-19 (P2) : P2 працює протягом 8 мс (загальний час, що залишився: 0 мс), оскільки він має найкоротший час, що залишився.

Діаграма Ганта:


скільки там фільмів місія неможлива

Тепер розрахуємо середнє значення час очікування і розвернутися час:

Як ми знаємо

  • Час повороту = Час завершення - час прибуття
  • Час очікування = Час обернутися - час лопнути
процес  

Час прибуття

java версія linux

(AT)

Час вибуху

(BT)

Час завершення (CT)Термін виконання (TAT)Час очікування (WT)
 P1  

6

1111-0 = 1111-6 = 5
 P2

8

1919-0 = 1919-8 = 11
 P3

strsep c

5

55-0 = 55-5 = 0

Зараз 

  • Середній час обороту = (11 + 19 + 5)/3 = 11,6 мс
  • Середній час очікування = (5 + 0 + 11 )/3 = 16/3 = 5,33 мс

Сценарій 2: процеси з різним часом надходження

Розглянемо наступну таблицю часу прибуття та часу пакету для трьох процесів P1 P2 та P3.

процес Час вибуху Час прибуття
 P1   6 мс0 мс
 P2 3 мс1 мс
 P3 7 мс2 мс

Поетапне виконання:

  1. Час 0-1 (P1) : P1 працює протягом 1 мс (загальний час, що залишився: 5 мс), оскільки він має найкоротший час, що залишився.
  2. Час 1-4 (P2) : P2 працює протягом 3 мс (загальний час, що залишився: 0 мс), оскільки він має найменший час, що залишився серед P1 і P2.
  3. Час 4-9 (P1) : P1 працює протягом 5 мс (загальний час, що залишився: 0 мс), оскільки він має найкоротший час, що залишився серед P1 і P3.
  4. Час 9-16 (P3) : P3 працює протягом 7 мс (загальний час, що залишився: 0 мс), оскільки він має найкоротший час, що залишився.

Діаграма Ганта:

Тепер розрахуємо середнє значення час очікування і розвернутися час:

актор Ранбір Капур вік
процес  

Час прибуття (AT)

Час вибуху (BT)

Час завершення (CT)Термін виконання (TAT)Час очікування (WT)
 P1  

6

99-0 = 99-6 = 3
 P2

1

3

44-1 = 33-3 = 0
 P3

2

Редьярд Кіплінг якщо пояснення

7

1616-2 = 1414-7 = 7
  • Середній час обороту = (9 + 14 + 3)/3 = 8,6 мс
  • Середній час очікування = (3 + 0 + 7 )/3 = 10/3 = 3,33 мс

Реалізація алгоритму SRTF

крок 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

Переваги SRTF Планування

  1. Мінімізує середній час очікування : SRTF скорочує середній час очікування шляхом визначення пріоритетів процесів із найкоротшим часом виконання.
  2. Ефективний для коротких процесів : більш короткі процеси завершуються швидше, покращуючи загальну швидкість реакції системи.
  3. Ідеально підходить для критичних до часу систем : це забезпечує швидке виконання процесів, чутливих до часу.

Недоліки SRTF Планування

  1. Голодування тривалих процесів : Довші процеси можуть бути відкладені на невизначений термін, якщо коротші процеси надходять.
  2. Важко передбачити час вибуху : Точне передбачення тривалості пакетів процесів є складним і впливає на рішення щодо планування.
  3. Високі накладні витрати : Часте перемикання контексту може збільшити витрати та сповільнити продуктивність системи.
  4. Не підходить для систем реального часу : Завдання в реальному часі можуть затримуватися через часті випередження.
Створіть вікторину