C语言循环带输出
带有输出的C循环程序
循环是一种CPU调度算法，它以循环顺序将相等部分的资源分配给每个进程，并处理所有进程而没有优先级。在循环中，每个进程获取切片的固定时间间隔以利用资源或执行其称为时间量子或时间切片的任务。如果某些循环机制在给定的时隙中执行，则它们将被抢占，而其他进程将返回就绪队列，并等待以预定的时隙以循环顺序运行，直到它们完成任务。通过对 CPU 调度的每个进程的匮乏CPU 。
Round Robin CPU调度算法
步骤1: 根据所有进程在就绪队列中的到达时间来组织所有进程。准备队列的队列结构基于FIFO结构来执行所有CPU进程。
步骤2: 现在，我们从就绪队列中推送第一个进程以执行其固定时间的任务，由到达队列的每个进程分配。
步骤3: 如果该进程由于已停止而无法在定义的时间间隔或时隙内完成其任务另一个进程由于到达下一个进程的到达时间而从就绪队列中推送以执行其任务。因此，CPU保存了该进程的先前状态，这有助于从中断点恢复。(如果剩余进程的突发时间，则将进程推入就绪队列的末尾。)
步骤4: 同样，调度程序从就绪队列中选择另一个进程来执行其任务。当某个进程在某个时隙内完成其任务时，该进程将不再继续执行，因为该进程的突发时间已完成。
步骤5: 同样，我们重复所有步骤直到工作完成为止。
循环赛的特征
这是一种抢先算法。
它在所有进程之间共享相等的时间间隔以完成其任务。
这是一种无饥饿的CPU调度算法。因此，它被称为最公平，最简单的算法。
优势
它没有面临任何饥饿问题或车队影响。
每个进程都享有与CPU公平分配相同的优先级。
实现CPU调度算法很容易。
每个新流程都会在到达下一个流程的到达时间时添加到就绪队列的末尾。
每个过程都以循环顺序执行，它们共享一个固定的时隙或时间量。
轮循调度算法中的每个过程都有机会在给定的量子周期后重新调度。
缺点
如果时间量较小，则在进程之间进行上下文切换会花费更多时间。
执行最重要的过程没有任何特殊的优先级。
由于时间间隔短，大型进程的等待时间更长。
算法的性能取决于时间量。
该过程的响应时间较长，这是因为对时间量子的切片较大。
对于循环算法中的所有进程来说，获取正确的时隙或量子量都是非常困难的。
Round Robin CPU调度示例:
让我们通过一个示例来了解Round Robin的概念。假设我们有五个过程P1，P2，P3，P4和P5、下表列出了每个进程的到达时间和突发时间，如下所示。时间量是三个单位。
| Process |
Arrival Time (AT) |
Burst Time (BT) |
| P1 |
0 |
8 |
| P2 |
5 |
2 |
| P3 |
1 |
7 |
| P4 |
6 |
3 |
| P5 |
8 |
5 |
现在，我们必须为Round Robin CPU Scheduler创建就绪队列和甘特图。
就绪队列: P1 ，P3，P1，P2，P4，P3，P5，P1，P3，P5
这是甘特图:
步骤1: : 在时间0处，进程P1进入就绪队列并开始执行定义的时隙3、在时间片的3个单位内，另一个进程P3到达就绪队列，因为其到达时间为1、
步骤2: 现在，进行处理P3以3个单位的时隙开始执行，而进程P1必须等待。在执行过程P3之后，过程P1再次在时隙3中恢复执行。
步骤3: 在执行过程P1的过程中，又有两个过程P2和P4到达准备开始执行队列。由于进程P2首先出现，因此它将在执行P4之后以时间间隔2单位执行。
步骤4: 在这里，P4已以3个时隙执行，由于BT(突发时间)为2，因此其任务已完成。因此，它不会进入就绪队列。
步骤5: 之后，从时隙3的就绪队列，然后进程P5到达时隙3、
步骤6: 同时，执行进程P5，进程P1和P3必须等待就绪
第7步: 。现在，从就绪队列中获取进程P1，并开始在时隙2执行，因为它只需要2个BT即可完成其任务。因此，它将不会进入准备队列以进一步执行。
步骤8: 现在，由于仅需要1个BT来完成其时隙，因此在时隙1执行了进程P3、
第9步: 。由于仅需要2个BT来完成其任务，因此对时隙2执行了最终过程P5、
查找完成时间的重要术语，周转时间(TAT)，响应时间(RT)和等待时间(WT)。
完成时间: 它定义进程完成其执行的时间。
周转时间: 它定义完成时间(CT)与到达时间(AT)之间的时间差。
周转时间(TAT)=完成时间(CT)-到达时间(AT)
等待时间: 它定义了请求操作与获取资源之间的总时间。
等待时间(WT)=周转时间(TAT)-突发时间(BT)
响应时间: 这是定义系统对流程的响应的时间。
| Process |
Arrival Time |
Burst Time |
Completion Time |
Turn Around Time |
Waiting Time |
Response Time |
| P1 |
0 |
8 |
22 |
22 |
14 |
0 |
| P2 |
5 |
2 |
11 |
6 |
4 |
4 |
| P3 |
1 |
7 |
23 |
22 |
15 |
2 |
| P4 |
6 |
3 |
14 |
8 |
5 |
5 |
| P5 |
8 |
5 |
25 |
17 |
12 |
9 |
过程P1 = 22，P2 = 11，P3 = 23，P4 = 14和P5 = 25的完成时间。
P1的完成时间=完成时间(CT)-P2的到达时间= 22-0 = 22
P2的到达时间= 11-5 = 6
P3的到达时间= 23-1 = 22
P4的到达时间= 14-6 = 8
P5的周转时间= 25-8 = 17
P1的等待时间=周转时间(TAT)-爆发时间(BT)
22-8 = 14
P2的等待时间= 6-2 = 4
P3的等待时间= 22-7 = 15
P4的等待时间= 8-3 = 5
P5的等待时间= 17-5 = 12
平均等待时间=(14 + 4 + 15 + 5 + 12)/5 = 50/5 = 10
平均周转时间=(22 + 6 + 22 + 8 + 17)/5 = 75/5 = 15
具有顺序到达时间的Round Robin CPU调度示例
让我们了解另一个Round Robin示例: 顺序到达时间。在这里，我们有四个过程P1，P2，P3和P4、下表列出了每个进程的到达时间和突发时间，如下所示。时间量为 6 个单位。
| Process |
Arrival Time |
Burst Time |
| P1 |
0 |
8 |
| P2 |
1 |
5 |
| P3 |
2 |
10 |
| P4 |
3 |
11 |
这是甘特图:
步骤1: : 在时间0处，进程P1进入就绪队列，并以6个时间单位执行其任务。在时间片的6个单位期间，另一个进程P2，P3和P4进入就绪队列。之后，进程P1将返回到就绪队列的末尾并等待其执行。
步骤2: 现在，进程P2在5个时隙开始执行。突发时间(BT)为5，它不会进入就绪队列以进一步执行。
步骤3: 在该过程之后，P3将开始执行，爆发时间为10，但时间段为6个单位。因此，它在定义的时限内执行其任务，并添加到就绪队列的末尾。
第4步: 之后，进程P4开始执行，该过程已经爆发时间11，但时间量是6个单位。它只执行6秒钟的任务，然后添加到就绪队列的末尾。
步骤5: 执行P4之后，现在P1将再次开始执行2个单位或秒，并且过程P1终止或结束。同样，过程P1的完整执行，然后是P3，将在突发时间4开始其剩余的执行，并且该过程完成。
步骤6: P3，现在过程P4在剩余的5个时隙中执行，过程结束。
| Process |
Arrival Time |
Burst Time |
Completion Time |
Turn Around Time |
Waiting Time |
| P1 |
0 |
8 |
25 |
25 |
17 |
| P2 |
1 |
5 |
11 |
10 |
5 |
| P3 |
2 |
10 |
29 |
27 |
17 |
| P4 |
3 |
11 |
34 |
31 |
20 |
现在，我们找到完成情况，周转时间，等待时间以及平均 TAT 和等待时间。
完成情况P1的完成时间为: 25
P2的完成时间为: 11
P3的完成时间为: 29
P4的完成时间为: 34
转大约时间: 完成时间(CT)-到达时间(AT)
对于流程P1: 25-0 = 25
对于流程P2: 11-1 = 10
对于流程P3: 29-2 = 27
对于流程P4: 34-3 = 31
平均周转时间为:(25 + 10 + 27 + 31)/4 = 23.25
流程等待时间:
P1 = 25-8 = 17
P2 = 10-5 = 5
P3 = 27-10 = 17
P4 = 31-11 = 20
平均等待时间为: (17 + 5 + 17 + 20)/4 = 59/4 = 14.75
编写循环程序用C语言进行CPU调度。
#include<stdio.h>
#include<conio.h>
void main()
{
// initlialize the variable name
int i, NOP, sum=0,count=0, y, quant, wt=0, tat=0, at[10], bt[10], temp[10];
float avg_wt, avg_tat;
printf(" Total number of process in the system: ");
scanf("%d", &NOP);
y = NOP; // Assign the number of process to variable y
// Use for loop to enter the details of the process like Arrival time and the Burst Time
for(i=0; i<NOP; i++)
{
printf("\n Enter the Arrival and Burst time of the Process[%d]\n", i+1);
printf(" Arrival time is: \t"); // Accept arrival time
scanf("%d", &at[i]);
printf(" \nBurst time is: \t"); // Accept the Burst time
scanf("%d", &bt[i]);
temp[i] = bt[i]; // store the burst time in temp array
}
// Accept the Time qunat
printf("Enter the Time Quantum for the process: \t");
scanf("%d", &quant);
// Display the process No, burst time, Turn Around Time and the waiting time
printf("\n Process No \t\t Burst Time \t\t TAT \t\t Waiting Time ");
for(sum=0, i = 0; y!=0; )
{
if(temp[i] <= quant && temp[i] > 0) // define the conditions
{
sum = sum + temp[i];
temp[i] = 0;
count=1;
}
else if(temp[i] > 0)
{
temp[i] = temp[i]-quant;
sum = sum + quant;
}
if(temp[i]==0 && count==1)
{
y--; //decrement the process no.
printf("\nProcess No[%d] \t\t %d\t\t\t\t %d\t\t\t %d", i+1, bt[i], sum-at[i], sum-at[i]-bt[i]);
wt = wt+sum-at[i]-bt[i];
tat = tat+sum-at[i];
count =0;
}
if(i==NOP-1)
{
i=0;
}
else if(at[i+1]<=sum)
{
i++;
}
else
{
i=0;
}
}
// represents the average waiting time and Turn Around time
avg_wt = wt * 1.0/NOP;
avg_tat = tat * 1.0/NOP;
printf("\n Average Turn Around Time: \t%f", avg_wt);
printf("\n Average Waiting Time: \t%f", avg_tat);
getch();
}
输出:
