Кругової це алгоритм планування ЦП, де кожному процесу циклічно призначається фіксований часовий інтервал. Це превентивна версія алгоритму планування ЦП «першим прийшов, першим обслужено».
файли Linux
- Алгоритм ЦП Round Robin зазвичай зосереджується на техніці розподілу часу.
- Період часу, протягом якого дозволяється виконувати процес або завдання в методі випередження, називається часом квантовий .
- Кожному процесу або завданням, присутнім у черзі готовності, призначається ЦП на цей квант часу, якщо виконання процесу завершено протягом цього часу, тоді процес буде кінець інакше процес повернеться до стіл очікування і зачекайте на наступний хід, щоб завершити виконання.
Характеристики алгоритму циклічного планування ЦП
- Це просто, легко впровадити та не потребує голоду, оскільки всі процеси отримують справедливу частку ЦП.
- Одна з найбільш часто використовуваних технік в Планування ЦП є ядром.
- Це є превентивний оскільки процесам призначається ЦП лише на фіксований проміжок часу.
- Недоліком цього є більші витрати на перемикання контексту.
Переваги алгоритму планування CPU Round Robin
- Існує справедливість, оскільки кожен процес отримує рівну частку ЦП.
- Новостворений процес додається в кінець черги готових.
- Циклічний планувальник зазвичай використовує розподіл часу, надаючи кожному завданню часовий інтервал або квант.
- Під час циклічного планування різним завданням приділяється певний проміжок часу.
- Кожен процес отримує можливість перепланувати через певний квантовий час у цьому плануванні.
Недоліки циклічного алгоритму планування ЦП
- Існує більший час очікування та час відповіді.
- Низька пропускна здатність.
- Є перемикачі контексту.
- Діаграма Ганта виглядає занадто великою (якщо квантовий час менший для планування. Наприклад: 1 мс для великого планування.)
- Часоємне планування для малих квантів.
Приклади для демонстрації роботи Кругової Алгоритм планування
Приклад-1: Розглянемо наступну таблицю часу прибуття та часу пакету для чотирьох процесів P1, P2, P3 і P4 і дано Квант часу = 2
| процес | Час вибуху | Час прибуття |
|---|---|---|
| P1 | 5 мс | 0 мс |
| P2 | 4 мс | 1 мс |
| P3 | 2 мс | 2 мс |
| P4 | 1 мс | 4 мс |
Алгоритм циклічного планування ЦП працюватиме на основі кроків, як зазначено нижче:
У момент часу = 0,
- Виконання починається з процесу P1, який має час пакету 5.
- Тут кожен процес виконується протягом 2 мілісекунд ( Час Квантовий період ). P2 і P3 все ще в черзі.
| Примірник часу | процес | Час прибуття | Готова черга | Запущена черга | Час виконання | Початковий час вибуху | Залишився вибух час |
|---|---|---|---|---|---|---|---|
| 0-2 мс | P1 | 0 мс | P2, P3 | P1 | 2 мс | 5 мс | 3 мс |
У момент часу = 2,
- Процеси P1 і P3 надходять до черги готовності, і P2 починає виконуватися для TQ період
| Примірник часу | процес | Час прибуття | Готова черга | Запущена черга | Час виконання | Початковий час вибуху | Залишився вибух час |
|---|---|---|---|---|---|---|---|
| 2-4 мс | P1 | 0 мс | P3, P1 | P2 | 0 мс | 3 мс | 3 мс |
| P2 | 1 мс | 2 мс | 4 мс | 2 мс |
У момент часу = 4,
- Процес P4 надходить у готова черга ,
- Потім P3 виконується для TQ період.
| Примірник часу | процес | Час прибуття | Готова черга | Запущена черга | Час виконання | Початковий час вибуху | Залишився вибух час |
|---|---|---|---|---|---|---|---|
| 4-6 мс | P1 | 0 мс | P1, P4, P2 | P3 | 0 мс | 3 мс | 3 мс |
| P2 | 1 мс | 0 мс | 2 мс | 2 мс | |||
| P3 | 2 мс | 2 мс | 2 мс | 0 мс |
У момент часу = 6,
- Процес P3 завершує своє виконання
- Процес P1 починає виконуватися для TQ період як наступний у б.
| Примірник часу | процес | Час прибуття | Готова черга | Запущена черга | Час виконання | Початковий час вибуху | Залишився вибух час |
|---|---|---|---|---|---|---|---|
| 6-8 мс | P1 | 0 мс | P4, P2 | P1 | 2 мс | 3 мс | 1 мс |
| P2 | 1 мс | 0 мс | 2 мс | 2 мс |
У момент часу = 8,
- Процес P4 починає виконуватися, він не виконуватиметься Час Квантовий період оскільки він має час вибуху = 1
- Отже, він виконуватиметься лише 1 мс.
| Примірник часу | процес | Час прибуття | Готова черга | Запущена черга | Час виконання | Початковий час вибуху | Залишився вибух час |
|---|---|---|---|---|---|---|---|
| 8-9 мс | P1 | 0 мс | P2, P1 | P4 | 0 мс | 3 мс | 1 мс |
| P2 | 1 мс | 0 мс | 2 мс | 2 мс | |||
| P4 | 4 мс | 1 мс | 1 мс | 0 мс |
У момент часу = 9,
- Процес P4 завершує своє виконання
- Процес P2 починає виконуватися для TQ період як наступний в готова черга
| Примірник часу | процес | Час прибуття | Готова черга | Запущена черга | Час виконання | Початковий час вибуху | Залишився вибух час |
|---|---|---|---|---|---|---|---|
| 9-11 мс | P1 | 0 мс | P1 | P2 | 0 мс | 3 мс | 1 мс |
| P2 | 1 мс | 2 мс | 2 мс | 0 мс |
У момент часу = 11,
- Процес P2 завершує своє виконання.
- Процес P1 починає виконуватися, він виконуватиметься лише 1 мс
| Примірник часу | процес | Час прибуття | Готова черга | Запущена черга | Час виконання | Початковий час вибуху | Залишився вибух час |
|---|---|---|---|---|---|---|---|
| 11-12 мс | P1 | 0 мс | P1 | 1 мс | 1 мс | 0 мс |
У момент часу = 12,
- Процес P1 завершує своє виконання.
- Загальне виконання процесів буде таким, як показано нижче:
| Примірник часу | процес | Час прибуття | Готова черга | Запущена черга | Час виконання | Початковий час вибуху | Залишився вибух час |
|---|---|---|---|---|---|---|---|
| 0-2 мс | P1 | 0 мс | P2, P3 | P1 | 2 мс | 5 мс | 3 мс |
| 2-4 мс | P1 | 0 мс | P3, P1 | P2 | 0 мс | 3 мс | 3 мс |
| P2 | 1 мс | 2 мс | 4 мс | 2 мс | |||
| 4-6 мс | P1 | 0 мс | P1, P4, P2 | P3 | 0 мс | 3 мс | 3 мс |
| P2 | 1 мс | 0 мс | 2 мс | 2 мс | |||
| P3 | 2 мс | 2 мс | 2 мс | 0 мс | |||
| 6-8 мс | P1 | 0 мс | P4, P2 | P1 | 2 мс | 3 мс | 1 мс |
| P2 | 1 мс | 0 мс | 2 мс | 2 мс | |||
| 8-9 мс | P1 | 0 мс | P2, P1 | P4 | 0 мс | 3 мс | 1 мс |
| P2 | 1 мс | 0 мс | 2 мс | 2 мс | |||
| P4 | 4 мс | 1 мс | 1 мс | 0 мс | |||
| 9-11 мс | P1 | 0 мс | P1 | P2 | 0 мс | 3 мс | 1 мс |
| P2 | 1 мс | 2 мс | 2 мс | 0 мс | |||
| 11-12 мс | P1 | 0 мс | P1 | 1 мс | 1 мс | 0 мс |
Діаграма Ганта буде наступним:
Діаграма Ганта для циклічного алгоритму планування
Як обчислити наведений нижче час у Round Robin за допомогою програми?
- Час завершення: Час, коли процес завершує своє виконання.
- Час обороту: Різниця в часі між часом завершення та часом прибуття. Час обробки = час завершення – час прибуття
- Час очікування (W.T): Різниця в часі між часом повороту та часом розриву.
Час очікування = час обороту – час вибуху
Тепер обчислимо середнє значення час очікування і розвернутися час:
| процеси | AT | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 5 | 12 | 12-0 = 12 | 12-5 = 7 |
| P2 | 1 | 4 | одинадцять | 11-1 = 10 | 10-4 = 6 |
| P3 | 2 | 2 | 6 | 6-2 = 4 | 4-2 = 2 |
| P4 | 4 | 1 | 9 | 9-4 = 5 | 5-1 = 4 |
тепер,
- Середній час обороту = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
- Середній час очікування = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7
приклад 2: Розглянемо наступну таблицю часу надходження та часу вибуху для трьох процесів P1, P2 та P3 і задано Квант часу = 2
| процес | Час вибуху | Час прибуття |
|---|---|---|
| P1 | 10 мс | 0 мс |
| P2 | 5 мс | 0 мс |
| P3 | 8 мс | 0 мс |
Так само Діаграма Ганта для цього прикладу:
Діаграма Ганта, приклад 2
Тепер обчислимо середнє значення час очікування і розвернутися час:
| процеси | AT | BT | CT | TAT | WT |
|---|---|---|---|---|---|
| P1 | 0 | 10 | 23 | 23-0 = 23 | 23-10 = 13 |
| P2 | 0 | 5 | п'ятнадцять | 15-0 = 15 | 15-5 = 10 |
| P3 | 0 | 8 | двадцять один | 21-0 = 21 | 21-8 = 13 |
Загальний час обертання = 59 мс
Так, Середній час обороту = 59/3 = 19,667 мсІ загальний час очікування = 36 мс
Так, Середній час очікування = 36/3 = 12,00 мс
Програма для кругового планування з часом прибуття як 0 для всіх процесів
Кроки для визначення часу очікування всіх процесів
- Створіть масив rem_bt[] щоб відстежувати час, що залишився, для процесів. Цей масив спочатку є копією bt[] (масив разів пакетів)
- Створіть інший масив вага [] зберігати час очікування процесів. Ініціалізуйте цей масив як 0.
- Час ініціалізації: t = 0
- Продовжуйте проходити всі процеси, поки вони не завершені. Виконайте наступне для i’th процес, якщо це ще не зроблено.
- Якщо rem_bt[i]> quantum
- t = t + квант
- rem_bt[i] -= сума;
- Else // Останній цикл цього процесу
- t = t + rem_bt[i];
- wt[i] = t – bt[i]
- rem_bt[i] = 0; // Цей процес закінчено
Коли ми маємо час очікування, ми можемо обчислити час обертання tat[i] процесу як суму очікування та пакетного часу, тобто wt[i] + bt[i].
Нижче наведено реалізацію вищевказаних кроків.
C++
// C++ program for implementation of RR scheduling> #include> using> namespace> std;> // Function to find the waiting time for all> // processes> void> findWaitingTime(>int> processes[],>int> n,> >int> bt[],>int> wt[],>int> quantum)> {> >// Make a copy of burst times bt[] to store remaining> >// burst times.> >int> rem_bt[n];> >for> (>int> i = 0 ; i rem_bt[i] = bt[i]; int t = 0; // Current time // Keep traversing processes in round robin manner // until all of them are not done. while (1) { bool done = true; // Traverse all processes one by one repeatedly for (int i = 0 ; i { // If burst time of a process is greater than 0 // then only need to process further if (rem_bt[i]>0) { done = false; // Існує незавершений процес if (rem_bt[i]> quantum) { // Збільшити значення t, тобто показує // скільки часу процес оброблявся t += quantum; // Зменшити burst_time поточного процесу // на quantum rem_bt[i] -= quantum; } // Якщо час пакету менший або дорівнює // кванту. Останній цикл для цього процесу else { // Збільшити значення t, тобто показує // скільки часу оброблено процес t = t + rem_bt[i]; // Час очікування – це поточний час мінус час // використаний цим процесом wt[i] = t - bt[i]; // Коли процес буде повністю виконано // зробіть час, що залишився, рівним 0 rem_bt[i] = 0; } } } // Якщо всі процеси виконано if (done == true) break; } } // Функція для обчислення часу виконання void findTurnAroundTime(int processs[], int n, int bt[], int wt[], int tat[]) { // обчислення часу виконання шляхом додавання // bt[i] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Функція для обчислення середнього часу void findavgTime(int processs[], int n, int bt[ ], int quantum) { int wt[n], tat[n], total_wt = 0, total_tat = 0; // Функція для пошуку часу очікування всіх процесів findWaitingTime(processes, n, bt, wt, quantum); Функція визначення часу виконання для всіх процесів findTurnAroundTime(processes, n, bt, wt, tat); // Відображення процесів разом із усіма деталями cout<< 'PN '<< ' BT ' << ' WT ' << ' TAT
'; // Calculate total waiting time and total turn // around time for (int i=0; i { total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; cout << ' ' << i+1 << ' ' << bt[i] <<' ' << wt[i] <<' ' << tat[i] < } cout << 'Average waiting time = ' << (float)total_wt / (float)n; cout << '
Average turn around time = ' << (float)total_tat / (float)n; } // Driver code int main() { // process id's int processes[] = { 1, 2, 3}; int n = sizeof processes / sizeof processes[0]; // Burst time of all processes int burst_time[] = {10, 5, 8}; // Time quantum int quantum = 2; findavgTime(processes, n, burst_time, quantum); return 0; }> |
>
>
Java
java pgm
// Java program for implementation of RR scheduling> public> class> GFG> {> >// Method to find the waiting time for all> >// processes> >static> void> findWaitingTime(>int> processes[],>int> n,> >int> bt[],>int> wt[],>int> quantum)> >{> >// Make a copy of burst times bt[] to store remaining> >// burst times.> >int> rem_bt[] =>new> int>[n];> >for> (>int> i =>0> ; i rem_bt[i] = bt[i]; int t = 0; // Current time // Keep traversing processes in round robin manner // until all of them are not done. while(true) { boolean done = true; // Traverse all processes one by one repeatedly for (int i = 0 ; i { // If burst time of a process is greater than 0 // then only need to process further if (rem_bt[i]>0) { done = false; // Існує незавершений процес if (rem_bt[i]> quantum) { // Збільшити значення t, тобто показує // скільки часу процес оброблявся t += quantum; // Зменшити burst_time поточного процесу // на quantum rem_bt[i] -= quantum; } // Якщо час пакету менше або дорівнює // кванту. Останній цикл для цього процесу else { // Збільшити значення t, тобто показує // скільки часу оброблено процес t = t + rem_bt[i]; // Час очікування – це поточний час мінус час // використаний цим процесом wt[i] = t - bt[i]; // Коли процес буде повністю виконано // зробіть час, що залишився, рівним 0 rem_bt[i] = 0; } } } // Якщо всі процеси виконано if (done == true) break; } } // Метод обчислення часу виконання static void findTurnAroundTime(int processs[], int n, int bt[], int wt[], int tat[]) { // обчислення часу виконання шляхом додавання // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Метод обчислення середнього часу static void findavgTime(int processs[], int n, int bt[], int quantum) { int wt[] = new int[n], int total_wt = 0, total_tat = 0; // Функція для пошуку часу очікування всіх процесів findWaitingTime( процеси, n, bt, wt, quantum); // Функція для визначення часу обороту для всіх процесів findTurnAroundTime(processes, n, bt, wt, tat); // Відображення процесів разом із усіма деталями System.out.println( 'PN ' + ' B ' + ' WT ' + ' TAT' // Розрахунок загального часу очікування та загального часу черги // для (int i=0; i { total_wt = total_wt + wt[i]; total_tat + tat[i]; System.out.println(' ' + (i+1) + ' ' +' ' + wt[i] +' ' + tat[i]); } System.out.println('Середній час очікування = ' + (float)total_wt / (float)n); System.out.println('Середній час обороту = ' + (float)total_tat / (float)n); } // Метод драйвера public static void main(String[] args) { // ідентифікатор процесу int processs[] = { 1, 2, 3}; int n = процеси.довжина; // Час вибуху всіх процесів int burst_time[] = {10, 5, 8}; // Квант часу int quantum = 2; findavgTime(процеси, n, burst_time, квант); } }> |
>
>
Python3
# Python3 program for implementation of> # RR scheduling> # Function to find the waiting time> # for all processes> def> findWaitingTime(processes, n, bt,> >wt, quantum):> >rem_bt>=> [>0>]>*> n> ># Copy the burst time into rt[]> >for> i>in> range>(n):> >rem_bt[i]>=> bt[i]> >t>=> 0> # Current time> ># Keep traversing processes in round> ># robin manner until all of them are> ># not done.> >while>(>1>):> >done>=> True> ># Traverse all processes one by> ># one repeatedly> >for> i>in> range>(n):> > ># If burst time of a process is greater> ># than 0 then only need to process further> >if> (rem_bt[i]>>0>) :> >done>=> False> # There is a pending process> > >if> (rem_bt[i]>квант) :> > ># Increase the value of t i.e. shows> ># how much time a process has been processed> >t>+>=> quantum> ># Decrease the burst_time of current> ># process by quantum> >rem_bt[i]>->=> quantum> > ># If burst time is smaller than or equal> ># to quantum. Last cycle for this process> >else>:> > ># Increase the value of t i.e. shows> ># how much time a process has been processed> >t>=> t>+> rem_bt[i]> ># Waiting time is current time minus> ># time used by this process> >wt[i]>=> t>-> bt[i]> ># As the process gets fully executed> ># make its remaining burst time = 0> >rem_bt[i]>=> 0> > ># If all processes are done> >if> (done>=>=> True>):> >break> > # Function to calculate turn around time> def> findTurnAroundTime(processes, n, bt, wt, tat):> > ># Calculating turnaround time> >for> i>in> range>(n):> >tat[i]>=> bt[i]>+> wt[i]> # Function to calculate average waiting> # and turn-around times.> def> findavgTime(processes, n, bt, quantum):> >wt>=> [>0>]>*> n> >tat>=> [>0>]>*> n> ># Function to find waiting time> ># of all processes> >findWaitingTime(processes, n, bt,> >wt, quantum)> ># Function to find turn around time> ># for all processes> >findTurnAroundTime(processes, n, bt,> >wt, tat)> ># Display processes along with all details> >print>(>'Processes Burst Time Waiting'>,> >'Time Turn-Around Time'>)> >total_wt>=> 0> >total_tat>=> 0> >for> i>in> range>(n):> >total_wt>=> total_wt>+> wt[i]> >total_tat>=> total_tat>+> tat[i]> >print>(>' '>, i>+> 1>,>' '>, bt[i],> >' '>, wt[i],>' '>, tat[i])> >print>(>'
Average waiting time = %.5f '>%>(total_wt>/>n) )> >print>(>'Average turn around time = %.5f '>%> (total_tat>/> n))> > # Driver code> if> __name__>=>=>'__main__'>:> > ># Process id's> >proc>=> [>1>,>2>,>3>]> >n>=> 3> ># Burst time of all processes> >burst_time>=> [>10>,>5>,>8>]> ># Time quantum> >quantum>=> 2>;> >findavgTime(proc, n, burst_time, quantum)> # This code is contributed by> # Shubham Singh(SHUBHAMSINGH10)> |
>
>
C#
порівняти з рядком
// C# program for implementation of RR> // scheduling> using> System;> public> class> GFG {> > >// Method to find the waiting time> >// for all processes> >static> void> findWaitingTime(>int> []processes,> >int> n,>int> []bt,>int> []wt,>int> quantum)> >{> > >// Make a copy of burst times bt[] to> >// store remaining burst times.> >int> []rem_bt =>new> int>[n];> > >for> (>int> i = 0 ; i rem_bt[i] = bt[i]; int t = 0; // Current time // Keep traversing processes in round // robin manner until all of them are // not done. while(true) { bool done = true; // Traverse all processes one by // one repeatedly for (int i = 0 ; i { // If burst time of a process // is greater than 0 then only // need to process further if (rem_bt[i]>0) { // Існує незавершений процес done = false; if (rem_bt[i]> quantum) { // Збільшити значення t, тобто // показує, скільки часу процес // оброблявся t += quantum; // Зменшити burst_time // поточного процесу на quantum rem_bt[i] -= quantum; } // Якщо час пакету менший за // або дорівнює кванту. Останній цикл // для цього процесу else { // Збільшити значення t, тобто // показує, скільки часу процес // був оброблений t = t + rem_bt[i]; // Час очікування поточний // час мінус час, використаний // цим процесом wt[i] = t - bt[i]; // Коли процес буде повністю // виконано, залиште його // пакетний час = 0 rem_bt[i] = 0; } } } // Якщо всі процеси виконано if (done == true) break; } } // Метод обчислення часу виконання static void findTurnAroundTime(int []processes, int n, int []bt, int []wt, int []tat) { // обчислення часу виконання шляхом додавання // bt[i ] + wt[i] for (int i = 0; i tat[i] = bt[i] + wt[i]; } // Метод обчислення середнього часу static void findavgTime(int []processes, int n, int) []bt, int quantum) { int []wt = new int[n]; int []tat = new int[n]; int total_wt = 0; // Функція для пошуку часу очікування для всіх процеси findWaitingTime(processes, n, bt, wt, quantum); // Функція для визначення часу обороту // для всіх процесів findTurnAroundTime(processes, n, bt, wt, tat); // Показує процеси разом із усіма деталями Console.WriteLine('Processes ' + ' Burst time ' + ' Waiting time ' + ' Turnround time'); // Розрахунок загального часу очікування та загального часу обороту // для (int i = 0; i { total_wt + wt[i]; total_tat + tat[i]; Console.WriteLine(' ' + (i+1) + ' ' + bt[i] ] + ' ' + wt[i] +' ' + tat[i]); } Console.WriteLine('Середній час очікування = ' + (float)total_wt / (float)n); Console.Write('Середній час обертання = ' + (float)total_tat / (float)n); } // Метод драйвера public static void Main() { // ідентифікатор процесу int []processes = { 1, 2, 3}; int n = процеси.Довжина; // Час вибуху всіх процесів int []burst_time = {10, 5, 8}; // Квант часу int quantum = 2; findavgTime(процеси, n, burst_time, квант); } } // Цей код надав nitin mittal.> |
>
>
Javascript
> >// JavaScript program for implementation of RR scheduling> >// Function to find the waiting time for all> >// processes> >const findWaitingTime = (processes, n, bt, wt, quantum) =>{> >// Make a copy of burst times bt[] to store remaining> >// burst times.> >let rem_bt =>new> Array(n).fill(0);> >for> (let i = 0; i rem_bt[i] = bt[i]; let t = 0; // Current time // Keep traversing processes in round robin manner // until all of them are not done. while (1) { let done = true; // Traverse all processes one by one repeatedly for (let i = 0; i // If burst time of a process is greater than 0 // then only need to process further if (rem_bt[i]>0) { done = false; // Існує незавершений процес if (rem_bt[i]> quantum) { // Збільшити значення t, тобто показує // скільки часу процес оброблявся t += quantum; // Зменшити burst_time поточного процесу // на quantum rem_bt[i] -= quantum; } // Якщо час пакету менше або дорівнює // кванту. Останній цикл для цього процесу else { // Збільшити значення t, тобто показує // скільки часу оброблено процес t = t + rem_bt[i]; // Час очікування – це поточний час мінус час // використаний цим процесом wt[i] = t - bt[i]; // Коли процес буде повністю виконано // зробіть час, що залишився, рівним 0 rem_bt[i] = 0; } } } // Якщо всі процеси виконано if (done == true) break; } } // Функція для обчислення часу виконання const findTurnAroundTime = (processes, n, bt, wt, tat) => { // обчислення часу виконання шляхом додавання // bt[i] + wt[i] for (let i = 0; i tat[i] + wt[i]; // Функція для обчислення середнього часу const findavgTime = (processes, n, bt, quantum) => { let wt = new Array(n). fill(0), tat = new Array(n).fill(0); let total_wt = 0, total_tat = 0; // Функція для пошуку часу очікування всіх процесів findWaitingTime(processes, n, bt, wt, quantum); // Функція визначення часу обороту для всіх процесів findTurnAroundTime(processes, n, bt, wt, tat); Обчисліть загальний час очікування та загальний час черги // для (нехай i = 0; i total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; document.write(`${i + 1} ${) bt[i]} ${tat[i]} `); `Середній час очікування = ${total_wt / n}`); = ${total_tat / n}`); } // Код драйвера // ідентифікатор процесу, процеси = [1, 2, 3]; нехай n = процеси.довжина; // Час пакету всіх процесів let burst_time = [10, 5, 8]; // Квант часу let quantum = 2; findavgTime(процеси, n, burst_time, квант); // Цей код створено rakeshsahni> |
>
>Вихід
PN BT WT TAT 1 10 13 23 2 5 10 15 3 8 13 21 Average waiting time = 12 Average turn around time = 19.6667>
Програма для кругового розкладу з нульовим часом прибуття, різним і однаковим часом прибуття
C++
java ітерація карти
#include> #include> using> namespace> std;> struct> Process {> >int> AT, BT, ST[20], WT, FT, TAT, pos;> };> int> quant;> int> main() {> >int> n, i, j;> >// Taking Input> >cout <<>'Enter the no. of processes: '>;> >cin>> n;> >Process p[n];> >cout <<>'Enter the quantum: '> << endl;> >cin>> кількість;> >cout <<>'Enter the process numbers: '> << endl;> >for> (i = 0; i cin>> p[i].pos; cout<< 'Enter the Arrival time of processes: ' << endl; for (i = 0; i cin>> p[i].AT; cout<< 'Enter the Burst time of processes: ' << endl; for (i = 0; i cin>> p[i].BT; // Оголошення змінних int c = n, s[n][20]; float time = 0, mini = INT_MAX, b[n], a[n]; // Ініціалізація масивів пакетів і часу прибуття int index = -1; for (i = 0; i b[i] = p[i].BT; a[i] = p[i].AT; for (j = 0; j<20; j++) { s[i][j] = -1; } } int tot_wt, tot_tat; tot_wt = 0; tot_tat = 0; bool flag = false; while (c != 0) { mini = INT_MAX; flag = false; for (i = 0; i float p = time + 0.1; if (a[i] <= p && mini>a[i] && b[i]> 0) { index = i; міні = a[i]; прапор = вірно; } } // if at =1 then цикл виходить, отже встановлюється прапор на false if (!flag) { time++; продовжити; } // обчислення часу початку j = 0; while (s[індекс][j] != -1) { j++; } if (s[index][j] == -1) { s[index][j] = час; p[індекс].ST[j] = час; } якщо (b[індекс]<= quant) { time += b[index]; b[index] = 0; } else { time += quant; b[index] -= quant; } if (b[index]>0) { a[індекс] = час + 0,1; } // обчислення часу прибуття, пакету, кінцевого часу if (b[index] == 0) { c--; p[index].FT = час; p[індекс].WT = p[індекс].FT - p[індекс].AT - p[індекс].BT; tot_wt += p[index].WT; p[індекс].TAT = p[індекс].BT + p[індекс].WT; tot_tat += p[index].TAT; } } // кінець циклу while // Друк результату cout<< 'Process number '; cout << 'Arrival time '; cout << 'Burst time '; cout << ' Start time'; j = 0; while (j != 10) { j += 1; cout << ' '; } cout << ' Final time'; cout << ' Wait Time '; cout << ' TurnAround Time' << endl; for (i = 0; i cout << p[i].pos << ' '; cout << p[i].AT << ' '; cout << p[i].BT << ' '; j = 0; int v = 0; while (s[i][j] != -1) { cout << p[i].ST[j] << ' '; j++; v += 3; } while (v != 40) { cout << ' '; v += 1; } cout << p[i].FT << ' '; cout << p[i].WT << ' '; cout << p[i].TAT << endl; } // Calculating average wait time and turnaround time double avg_wt, avg_tat; avg_wt = tot_wt / static_cast |
>
>
C
динамічний масив у java
#include> #include> #include> struct> P{> int> AT,BT,ST[20],WT,FT,TAT,pos;> };> int> quant;> int> main(){> int> n,i,j;> // Taking Input> printf>(>'Enter the no. of processes :'>);> scanf>(>'%d'>,&n);> struct> P p[n];> > printf>(>'Enter the quantum
'>);> scanf>(>'%d'>,&quant);> printf>(>'Enter the process numbers
'>);> for>(i=0;i scanf('%d',&(p[i].pos)); printf('Enter the Arrival time of processes
'); for(i=0;i scanf('%d',&(p[i].AT)); printf('Enter the Burst time of processes
'); for(i=0;i scanf('%d',&(p[i].BT)); // Declaring variables int c=n,s[n][20]; float time=0,mini=INT_MAX,b[n],a[n]; // Initializing burst and arrival time arrays int index=-1; for(i=0;i b[i]=p[i].BT; a[i]=p[i].AT; for(j=0;j<20;j++){ s[i][j]=-1; } } int tot_wt,tot_tat; tot_wt=0; tot_tat=0; bool flag=false; while(c!=0){ mini=INT_MAX; flag=false; for(i=0;i float p=time+0.1; if(a[i]a[i] && b[i]>0){ index=i; міні=a[i]; прапор = вірно; } } // if at =1 then цикл виходить, отже встановлюється прапор на false if(!flag){ time++; продовжити; } //обчислення часу початку j=0; while(s[index][j]!=-1){ j++; } if(s[index][j]==-1){ s[index][j]=час; p[індекс].ST[j]=час; } if(b[індекс]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[індекс]=час+0,1; } // обчислення часу прибуття, пакету, кінцевого if(b[index]==0){ c--; p[index].FT=час; p[індекс].WT=p[індекс].FT-p[індекс].AT-p[індекс].BT; tot_wt+=p[index].WT; p[індекс].TAT=p[індекс].BT+p[індекс].WT; tot_tat+=p[index].TAT; } } // кінець циклу while // Друк виведених даних printf('Номер процесу '); printf('Час прибуття'); printf('Час вибуху '); printf(' Час початку'); j=0; while(j!=10){ j+=1; printf(' '); } printf(' Остаточний час'); printf(' Час очікування '); printf(' Час виконання
'); for(i=0;i printf('%d ',p[i].pos); printf('%d ',p[i].AT); printf ('%d',p[i].BT); int v=0; while(s[i][j]!=-1){ printf('%d ' ,p[j]); v+=3; printf(''); printf('%d ',p[i].FT); printf('%d ',p[i].WT); printf('%d
',p[i].TAT) } // Розрахунок середнього часу очікування та часу обробки double avg_wt=tot_wt/(float)n; //Друк середнього часу очікування printf('Середній час очікування час: %lf
',avg_wt); |
>Enter the number of processes : 4 Enter the time quanta : 2 Enter the process numbers : 1 2 3 4 Enter the arrival time of the processes : 0 1 2 3 Enter the burst time of the processes : 5 4 2 1 Program No. Arrival Time Burst Time Wait Time TurnAround Time 1 0 5 7 12 2 1 4 6 10 3 2 2 2 4 4 3 1 5 6 Average wait time : 5 Average Turn Around Time : 8>
Програма для циклічного планування з різним часом прибуття для всіх процесів
Щоб отримати детальну інформацію про реалізацію алгоритму випереджувального кругового циклу з різними часами надходження для всіх процесів, див. Програма для кругового розкладу з різним часом прибуття .
Висновок
Підсумовуючи, циклічне планування процесора є справедливим і випереджальним алгоритмом, який виділяє фіксований квант часу для кожного процесу, забезпечуючи рівний доступ до ЦП. Його легко реалізувати, але це може призвести до збільшення накладних витрат на перемикання контексту. Хоча це сприяє справедливості та запобігає голоду, це може призвести до довшого часу очікування та зниження пропускної здатності, залежно від кванту часу. Ефективне впровадження програми дозволяє розраховувати ключові показники, як-от час завершення, час виконання та час очікування, допомагаючи в оцінці та оптимізації ефективності.