गोल रॉबिन वेळापत्रक


अडचण पातळी मध्यम
वारंवार विचारले ऍमेझॉन फेसबुक Google मायक्रोसॉफ्ट
अल्गोरिदम कार्यकारी प्रणाल्या

राऊंड रॉबिन शेड्यूलिंग हे एफसीएफएससारखेच आहे. आरआर आणि एफसीएफएस शेड्यूलिंग दरम्यान फक्त फरक आहे, आरआर प्रीपेक्टिव आहे शेड्युलिंग तर एफसीएफएस प्री-प्रीपेक्टिव्ह शेड्यूलिंग नसते. प्रत्येक प्रक्रिया करण्यासाठी वाटप केले जाते सीपीयू एकाच वेळी कापण्यासाठी तयार रांगेत. येथे, ए तयार रांग गोलाकार रांगेसारखे आहे. प्रत्येक वेळी स्लाइस 10 ते 100 एमएस दरम्यान असते. या वस्तुस्थितीमुळे, याला टाइम स्लाइस शेड्यूलिंग म्हटले जाते.

आरआर शेड्यूलिंगची प्रक्रिया खालीलप्रमाणे आहेः

  1. रांगेच्या शेवटी एक नवीन प्रक्रिया जोडली गेली आहे.
  2. अगोदर निर्देश केलेल्या बाबीसंबंधी बोलताना प्रक्रिया रांगेतून पुढे अंमलबजावणीसाठी निवडले जाते.
  3. टाईमर एक वेळ स्लाइस नंतर व्यत्यय आणला आहे.
  4. एक वेळ स्लाइस केल्यानंतर, प्रक्रिया पूर्ण होते किंवा रांगेच्या शेवटी हलविली जाते

म्हणून खालीलप्रमाणे दोन प्रकरणे असू शकतातः

  1. पहिल्या प्रकरणात, प्रक्रिया सीपीयू फोडण्याची वेळ एकाच वेळेच्या स्लाइसपेक्षा कमी असते, त्यानंतर प्रक्रिया पूर्णपणे कार्यान्वित होईल आणि सीपीयू सोडेल आणि पुढील प्रक्रिया कार्यान्वित होईल.
  2. दुसर्‍या प्रकरणात, एकाच वेळी स्लाइसमध्ये एक व्यत्यय येतो. कॉन्टेक्स्ट स्विचच्या मदतीने, सीपीयू नंतरच्या प्रक्रियेस वाटप केले जाईल आणि ही प्रक्रिया रांगेच्या शेपटीवर हलविली जाईल त्यानंतर पुढील प्रक्रिया कार्यान्वित होईल.

उदाहरण

गोल रॉबिन वेळापत्रक

टाईम स्लाइसचा आकार 4ms असा होऊ द्या, पी 1 प्रथम 4ms साठी सीपीयू घेते. त्यानंतर, एक व्यत्यय उद्भवतो आणि पी 1 तयार रांगेच्या शेपटीत ठेवला जातो. पी 2 4 एमएस साठी चालविला जातो नंतर ते तयार रांगेच्या शेपटीत ठेवले जाते. त्यानंतर पी 3 4 एमएस कार्यान्वित केले जाते, त्यानंतर ते पूर्ण होते आणि सीपीयू कोणत्याही व्यत्ययाशिवाय सोडते. पुन्हा पी 1 चे वळण 4 मीटरसाठी येते. ही प्रक्रिया सुरूच आहे.

पुढील प्रक्रियेसाठी गॅन्ट चार्ट खालीलप्रमाणे असेल:

गोल रॉबिन वेळापत्रक

प्रक्रियेसाठी प्रतीक्षा वेळ पी 1 = 0 + 8 + 1 = 9 एस

आता, प्रक्रियेसाठी प्रतीक्षा वेळ P2 = 4 + 8 = 12ms

प्रक्रियेसाठी प्रतीक्षा वेळ पी 3 = 8 एमएस

एकूण प्रतीक्षा वेळ = 29 मि

प्रतीक्षा करण्याचा सरासरी वेळ = २ / / = = .29 ..3 मि

आरआर शेड्यूलिंगची कामगिरी वेळ स्लाइसच्या आकारावर अवलंबून असते. जर वेळ स्लाइस खूप मोठी असेल तर आरआर एफसीएफएस प्रमाणेच आहे. जर वेळ स्लाइस खूपच लहान असेल तर आरआर प्रक्रिया प्रक्रिया सामायिक करण्यासारखेच आहे, प्रक्रियेस प्रतीक्षा करण्यास बराच वेळ लागेल.

आरआर शेड्यूलिंगचे फायदे

  1. हे वेळ सामायिक करण्यास समर्थन देते.
  2. आरआर क्वांटम वापरतो.
  3. हे एकाधिक प्रक्रिया हाताळू शकते.
  4. जर प्रक्रियेचा स्फोट वेळ क्वांटमपेक्षा लहान असेल तर प्रक्रिया पहिल्या क्वांटममध्ये कार्यवाही करते.

आरआर शेड्यूलिंगचे तोटे

  1. क्रॅस्टची वेळ क्वांटमपेक्षा मोठी असल्यास प्रक्रिया अंमलबजावणी हळू होते.
  2. क्वांटम मोठा असल्यास ते एफसीएफएस म्हणून कार्य करते.
  3. मोठ्या प्रक्रियेस लहान प्रक्रियेचा शेवट होण्याची प्रतीक्षा करावी लागणार आहे.

अंमलबजावणी

राउंड रॉबिन शेड्यूलिंगसाठी सी प्रोग्राम

#include<stdio.h>
#include<conio.h>
int main()
{
    int n,i,qt,count=0,temp,sq=0,bt[10],wt[10],tat[10],rem_bt[10];
    //n signifies number of process
    //i is for using loops
    //qt denotes Quantum Time
    //count denotes when one process is completed
    //temp and sq are temproray variables
    //bt[10] denotes burst time
    //wt[10] denotes waiting time
    //tat[10] denotes turnaround time
    //rem_bt[10] denotes remaining burst time
    float awt=0,atat=0;
    //awt represents average waiting time
    //atat represents average turnaround time
    printf("Enter number of process (upto 10) = ");
    scanf("%d",&n);
    printf("Enter burst time of process\n");
    for (i=0;i<n;i++)
    {
        printf("P%d = ",i+1);
        scanf("%d",&bt[i]);
        rem_bt[i]=bt[i];
    }
    printf("Enter quantum time ");
    scanf("%d",&qt);
    while(1)
    {
        for (i=0,count=0;i<n;i++)
        {
            temp=qt;
            if(rem_bt[i]==0)
            {
                count++;
                continue;
            }
            if(rem_bt[i]>qt)//changing the value of remaining burst time
                rem_bt[i]=rem_bt[i]-qt;
            else
                if(rem_bt[i]>=0)//if process is exhausted then setting remaining burst time tozero
                {
                    temp=rem_bt[i];
                    rem_bt[i]=0;
                }
                sq=sq+temp; //calculating turnaround time
                tat[i]=sq;
        }
        if(n==count)//breaking the loop when all process are exhausted
            break;
    }
    printf("\nProcess\tBurst Time\tTurnaround Time\tWaiting Time\n");
    for(i=0;i<n;i++)
    {
        wt[i]=tat[i]-bt[i];
        awt=awt+wt[i];
        atat=atat+tat[i];
        printf("\n%d\t%d\t\t%d\t\t%d",i+1,bt[i],tat[i],wt[i]);
    }
    awt=awt/n;
    atat=atat/n;
    printf("\nAverage waiting Time = %f\n",awt);
    printf("Average turnaround time = %f",atat);
    return 0;
}
Enter number of process (upto 10) = 3
Enter burst time of process
P1 = 21
P2 = 5
P3 = 4
Enter quantum time 4
Process	Burst Time	Turnaround Time	Waiting Time

1	20		29		9
2	5		17		12
3	4		12		8
Average waiting Time = 9.666667
Average turnaround time = 19.333334

राउंड रॉबिन शेड्यूलिंगसाठी जावा प्रोग्राम

import java.util.Scanner;

class main
{
  public static void main(String args[])
  {
    int n,i,qt,count=0,temp,sq=0,bt[],wt[],tat[],rem_bt[];
    float awt=0,atat=0;

    bt = new int[10];
    wt = new int[10];
    tat = new int[10];
    rem_bt = new int[10];

    Scanner s=new Scanner(System.in);

    System.out.print("Enter number of process (upto 10) = ");
    n = s.nextInt();

    System.out.print("Enter burst time of process\n");
    for (i=0;i<n;i++)
    {
      System.out.print("P"+i+" = ");
      bt[i] = s.nextInt();
      rem_bt[i] = bt[i];
    }
    System.out.print("Enter quantum time = ");
    qt = s.nextInt();

    while(true)
    {
      for (i=0,count=0;i<n;i++)
      {
        temp = qt;

        if(rem_bt[i] == 0)
        {
          count++;
          continue;
        }

        if(rem_bt[i]>qt)
          rem_bt[i]= rem_bt[i] - qt;
        else
          if(rem_bt[i]>=0)
          {
            temp = rem_bt[i];
            rem_bt[i] = 0;
          }
          sq = sq + temp;
          tat[i] = sq;
      }
      if(n == count)
      break;
    }
    System.out.print("\nProcess\tBurst Time\tTurnaround Time\tWaiting Time\n");
    for(i=0;i<n;i++)
        {
            wt[i]=tat[i]-bt[i];
            awt=awt+wt[i];
            atat=atat+tat[i];
            System.out.print("\n  "+(i+1)+"\t  "+bt[i]+"\t\t   "+tat[i]+"\t\t   "+wt[i]);
        }
        awt=awt/n;
        atat=atat/n;
        System.out.println("\nAverage waiting Time = "+awt);
        System.out.println("Average turnaround time = "+atat);
  }
}
Enter number of process (upto 10) = 3 
Enter burst time of process 
P1 = 29 
P2 = 51 
P3 = 42 
Enter quantum time 6
Process	Burst Time	Turnaround Time	Waiting Time

  1	  29		   77		   48
  2	  51		   122		   71
  3	  42		   113		   71
Average waiting Time = 63.333332
Average turnaround time = 104.0

गुंतागुंत विश्लेषण

वेळ कॉम्प्लेक्सिटी

ओ (एस) जेथे एस सर्व इनपुट प्रक्रियेच्या बर्स्ट वेळेची बेरीज दर्शवते.

स्पेस कॉम्प्लेक्सिटी

ओ (एस) जेथे एस सर्व इनपुट प्रक्रियेच्या बर्स्ट वेळेची बेरीज दर्शवते.

संदर्भ