రౌండ్ రాబిన్ షెడ్యూలింగ్


కఠినత స్థాయి మీడియం
తరచుగా అడుగుతుంది అమెజాన్ <span style="font-family: Mandali; ">ఫేస్‌బుక్ </span> గూగుల్ మైక్రోసాఫ్ట్
అల్గారిథం ఆపరేటింగ్ సిస్టమ్స్

రౌండ్ రాబిన్ షెడ్యూలింగ్ FCFS కు చాలా పోలి ఉంటుంది. RR మరియు FCFS షెడ్యూలింగ్ మధ్య ఉన్న తేడా ఏమిటంటే, RR ప్రీమిటివ్ షెడ్యూల్ అయితే ఎఫ్‌సిఎఫ్‌ఎస్ ప్రీమిటివ్ షెడ్యూల్. ప్రతి ప్రక్రియకు కేటాయించబడుతుంది CPU ఒకే సారి స్లైస్ కోసం సిద్ధంగా క్యూలో. ఇక్కడ, a సిద్ధంగా క్యూ వృత్తాకార క్యూతో సమానంగా ఉంటుంది. ప్రతిసారీ స్లైస్ 10 నుండి 100 ఎంఎస్‌ల మధ్య ఉంటుంది. ఈ వాస్తవం కారణంగా, దీనిని టైమ్ స్లైస్ షెడ్యూలింగ్ అంటారు.

RR షెడ్యూలింగ్ యొక్క విధానం క్రింది విధంగా ఉంది:

  1. క్యూ చివరికి కొత్త ప్రక్రియ జోడించబడుతుంది.
  2. ది ప్రక్రియ క్యూ ముందు నుండి అమలు కోసం ఎంపిక చేయబడింది.
  3. టైమర్ వన్-టైమ్ స్లైస్ తర్వాత అంతరాయం కలిగించడానికి సెట్ చేయబడింది.
  4. ఒక సారి స్లైస్ తరువాత, ప్రక్రియ పూర్తవుతుంది లేదా క్యూ చివరికి తరలించబడుతుంది

కాబట్టి ఈ క్రింది విధంగా రెండు కేసులు ఉండవచ్చు:

  1. మొదటి సందర్భంలో, ప్రాసెస్ CPU పేలుడు సమయం ఒకే టైమ్ స్లైస్ కంటే తక్కువగా ఉంటుంది, అప్పుడు ఈ ప్రక్రియ పూర్తిగా అమలు చేయబడుతుంది మరియు CPU ని విడుదల చేస్తుంది మరియు తదుపరి ప్రక్రియ అమలు అవుతుంది
  2. రెండవ సందర్భంలో, ఒకేసారి స్లైస్ వద్ద అంతరాయం ఏర్పడుతుంది. కాంటెక్స్ట్ స్విచ్ సహాయంతో, CPU తదుపరి ప్రక్రియకు కేటాయించబడుతుంది మరియు ఈ ప్రక్రియ క్యూ యొక్క తోకకు తరలించబడుతుంది, తరువాత తదుపరి ప్రక్రియ అమలు అవుతుంది.

ఉదాహరణ

రౌండ్ రాబిన్ షెడ్యూలింగ్

టైమ్ స్లైస్ యొక్క పరిమాణం 4ms గా ఉండనివ్వండి, P1 మొదటి 4ms కోసం CPU ని తీసుకుంటుంది. ఆ తరువాత, ఒక అంతరాయం ఏర్పడుతుంది మరియు P1 సిద్ధంగా ఉన్న క్యూ యొక్క తోకలో ఉంచబడుతుంది. P2 4ms కోసం అమలు చేయబడుతుంది, తరువాత అది సిద్ధంగా ఉన్న క్యూ యొక్క తోకలో ఉంచబడుతుంది. ఆ తరువాత P3 4ms కొరకు అమలు చేయబడుతుంది, తరువాత అది పూర్తవుతుంది మరియు అంతరాయం లేకుండా CPU ని విడుదల చేస్తుంది. మళ్ళీ P1 యొక్క మలుపు 4ms కోసం వస్తుంది. ఈ ప్రక్రియ కొనసాగుతుంది.

కింది ప్రక్రియ కోసం గాంట్ చార్ట్ ఇలా ఉంటుంది:

రౌండ్ రాబిన్ షెడ్యూలింగ్

P1 = 0 + 8 + 1 = 9ms ప్రాసెస్ కోసం వేచి ఉన్న సమయం

ఇప్పుడు, P2 = 4 + 8 = 12ms ప్రాసెస్ కోసం వేచి ఉన్న సమయం

P3 = 8ms ప్రాసెస్ కోసం వేచి ఉన్న సమయం

మొత్తం నిరీక్షణ సమయం = 29 ని

సగటు నిరీక్షణ సమయం = 29/3 = 9.67 ని

RR షెడ్యూలింగ్ యొక్క పనితీరు సమయం స్లైస్ పరిమాణంపై ఆధారపడి ఉంటుంది. టైమ్ స్లైస్ చాలా పెద్దదిగా ఉంటే, అప్పుడు RR FCFS లాగా ఉంటుంది. టైమ్ స్లైస్ చాలా తక్కువగా ఉంటే, అప్పుడు RR అనేది ప్రాసెస్ షేరింగ్ లాగా ఉంటుంది, ఒక ప్రక్రియ వేచి ఉండటానికి చాలా సమయం పడుతుంది.

RR షెడ్యూలింగ్ యొక్క ప్రయోజనాలు

  1. ఇది సమయం భాగస్వామ్యానికి మద్దతు ఇస్తుంది.
  2. ఆర్ఆర్ క్వాంటం ఉపయోగిస్తుంది.
  3. ఇది బహుళ ప్రక్రియలను నిర్వహించగలదు.
  4. ప్రాసెస్ పేలుడు సమయం క్వాంటం కంటే తక్కువగా ఉంటే, ఆ ప్రక్రియ మొదటి క్వాంటంలో అమలు అవుతుంది.

ఆర్ఆర్ షెడ్యూలింగ్ యొక్క ప్రతికూలతలు

  1. పేలుడు సమయం క్వాంటం కంటే పెద్దదిగా ఉంటే ప్రాసెస్ ఎగ్జిక్యూషన్ నెమ్మదిగా ఉంటుంది.
  2. క్వాంటం పెద్దగా ఉంటే, అది FCFS గా పనిచేస్తుంది.
  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

సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

ఓ (ఎస్) ఇక్కడ అన్ని ఇన్పుట్ ప్రక్రియల పేలుడు సమయాన్ని సూచిస్తుంది.

అంతరిక్ష సంక్లిష్టత

ఓ (ఎస్) ఇక్కడ అన్ని ఇన్పుట్ ప్రక్రియల పేలుడు సమయాన్ని సూచిస్తుంది.

సూచన