Round Robin on suorittimen ajoitusalgoritmi, jossa jokaiselle prosessille osoitetaan syklisesti kiinteä aikaväli. Se on ennaltaehkäisevä versio First come First Serve CPU Scheduling -algoritmista.

ohjelmointi c-taulukoissa

• Round Robin CPU Algorithm keskittyy yleensä Time Sharing -tekniikkaan.
• Aikaa, jonka prosessin tai työn sallitaan suorittaa ennaltaehkäisevässä menetelmässä, kutsutaan ajaksi kvantti .
• Jokaiselle valmiusjonossa olevalle prosessille tai työlle osoitetaan CPU kyseiselle aikakvantille, jos prosessin suoritus on valmis tuona aikana, prosessi loppu muuten prosessi palaa takaisin odotuspöytä ja odota seuraavaa vuoroaan suorittaaksesi suorituksen.

Round Robin -suorittimen ajoitusalgoritmin ominaisuudet

• Se on yksinkertainen, helppo toteuttaa ja ilman nälkää, koska kaikki prosessit saavat kohtuullisen osan suorittimesta.
• Yksi yleisimmin käytetyistä tekniikoista CPU-aikataulu on ydin.
• se on ennaltaehkäisevä koska prosesseille osoitetaan CPU vain kiinteän ajan enintään.
• Sen haittapuoli on enemmän kontekstin vaihtamista.

Round Robin -suorittimen ajoitusalgoritmin edut

• On oikeudenmukaista, koska jokainen prosessi saa yhtä suuren osan suorittimesta.
• Äskettäin luotu prosessi lisätään valmiin jonon loppuun.
• Round-robin-aikataulutin käyttää yleensä aikajakoa, jolloin jokaiselle työlle annetaan aikaväli tai kvantti.
• Kiertovuoroista ajoitusta suoritettaessa eri töille varataan tietty aika.
• Jokaisella prosessilla on mahdollisuus ajoittaa uudelleen tietyn kvanttiajan jälkeen tässä aikataulussa.

Round Robin -suorittimen ajoitusalgoritmin haitat

• On suurempi odotusaika ja vastausaika.
• Suorituskyky on alhainen.
• Siellä on kontekstikytkimet.
• Gantt-kaavio näyttää tulevan liian suurelta (jos kvanttiaikaa on vähemmän aikataulutukseen. Esimerkiksi: 1 ms suurille ajoituksille.)
• Aikaa vievää aikataulutusta pienelle kvantille.

Esimerkkejä toimimisesta Round Robin Aikataulutusalgoritmi

Esimerkki-1: Harkitse seuraavaa taulukkoa neljän prosessin saapumisajasta ja purskeajasta P1, P2, P3 ja P4 ja annettu Aikakvantti = 2

Round Robin CPU Scheduling Algorithm toimii alla mainittujen vaiheiden perusteella:

hetkellä = 0,

• Suoritus alkaa prosessilla P1, jonka purskeaika on 5.
• Tässä jokainen prosessi suoritetaan 2 millisekuntia ( Aikakvanttijakso ). P2 ja P3 ovat edelleen odotusjonossa.

Aikana = 2,

• Prosessit P1 ja P3 saapuvat valmiusjonoon ja P2 alkaa suorittaa TQ ajanjaksoa

Aikana = 4,

• Prosessi P4 saapuu valmis jono ,
• Sitten P3 suorittaa TQ ajanjaksoa.

Aika = 6,

• Prosessi P3 suorittaa suorituksensa loppuun
• Prosessi P1 alkaa suorittaa TQ jakso, kuten se on seuraavana kohdassa b.

Aika = 8,

• Prosessi P4 alkaa suorittaa, sitä ei suoriteta Aika Kvanttijakso koska sillä on puhkeamisaika = 1
• Siksi se toimii vain 1 ms.

Aika = 9,

• Prosessi P4 suorittaa suorituksensa loppuun
• Prosessi P2 alkaa suorittaa TQ kauden seuraavana valmis jono

Aika = 11,

• Prosessi P2 suorittaa suorituksensa loppuun.
• Prosessi P1 alkaa suorittaa, se suoritetaan vain 1 ms

Aika = 12,

• Prosessi P1 suorittaa suorituksensa loppuun.
• Prosessien yleinen toteutus on seuraava:

Gantt-kaavio tulee olemaan seuraava:

Gantt-kaavio Round Robin -aikataulutusalgoritmille

Kuinka laskea alla olevat ajat Round Robinissa ohjelman avulla?

• Valmistumisaika: Aika, jolloin prosessi saa suorituksensa loppuun.
• Kääntymisaika: Aika Ero valmistumisajan ja saapumisajan välillä. Kääntymisaika = valmistumisaika – saapumisaika
• Odotusaika (W.T): Aika Kääntymisajan ja purskeusajan välinen ero.
  Odotusaika = Kääntymisaika – Sarjakuvausaika

Nyt lasketaan keskiarvo odotusaika ja käänny ympäri aika:

Nyt,

• Keskimääräinen Kääntymisaika = (12 + 10 + 4 + 5)/4 = 31/4 = 7,7
• Keskimääräinen odotusaika = (7 + 6 + 2 + 4)/4 = 19/4 = 4,7

Esimerkki 2: Tarkastellaan seuraavaa taulukkoa saapumisajasta ja purskeajasta kolmelle prosessille P1, P2 ja P3 ja annettu Aikakvantti = 2

Samalla lailla, Gantt-kaavio tälle esimerkille:

Gantt-kaavio esimerkiksi 2

Nyt lasketaan keskiarvo odotusaika ja käänny ympäri aika:

Kokonaiskiertoaika = 59 ms
Niin, Keskimääräinen kiertoaika = 59/3 = 19,667 ms

Ja kokonais odotusaika = 36 ms
Niin, Keskimääräinen odotusaika = 36/3 = 12,00 ms

Ohjelma Round Robin -aikataulutukseen, jonka saapumisaika on 0 kaikille prosesseille

Vaiheet kaikkien prosessien odotusaikojen löytämiseksi

• Luo taulukko rem_bt[] seurataksesi prosessien jäljellä olevaa purskeusaikaa. Tämä matriisi on alun perin kopio bt[]:stä (purske kertaa array)
• Luo toinen taulukko wt[] tallentaa prosessien odotusajat. Alusta tämä taulukko 0:ksi.
• Alustusaika: t = 0
• Jatka kaikkien prosessien läpikulkua, kun niitä ei ole tehty. Seuraa minä'th prosessi, jos sitä ei ole vielä tehty.
  • Jos rem_bt[i]> kvantti
    • t = t + kvantti
    • rem_bt[i] - = määrä;
  • Else // Tämän prosessin viimeinen jakso
    • t = t + rem_bt[i];
    • wt[i] = t – bt[i]
    • rem_bt[i] = 0; // Tämä prosessi on ohi

Kun meillä on odotusajat, voimme laskea prosessin kääntymisajan tat[i] odotus- ja purskeaikojen summana, eli wt[i] + bt[i].
Alla on yllä olevien vaiheiden toteutus.

C++

>

>

Java

lataa autocad 2019 englanti mediafire

>

>

kokoelmat java

Python 3

>

>

C#

> 
    
   
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 > >// 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) { tehty = epätosi; // On odottava prosessi if (rem_bt[i]> quantum) { // Kasvata t:n arvoa eli näyttää // kuinka kauan prosessia on käsitelty t += kvantti;  // Pienennä nykyisen prosessin purskeen_aikaa // kvantti rem_bt[i] -= kvantti;  } // Jos purskeaika on pienempi tai yhtä suuri kuin // kvantti. Viimeinen jakso tälle prosessille else { // Kasvata t:n arvoa eli näyttää // kuinka kauan prosessia on käsitelty t = t + rem_bt[i];  // Odotusaika on nykyinen aika miinus aika // jota tämä prosessi käyttää wt[i] = t - bt[i];  // Kun prosessi suoritetaan täysin // tee sen jäljellä oleva purskeaika = 0 rem_bt[i] = 0;  } } } // Jos kaikki prosessit on tehty if (done == true) break;  } } // Kääntymisajan laskemistoiminto const findTurnAroundTime = (prosessit, n, bt, wt, tat) => { // läpimenoajan laskeminen lisäämällä // bt[i] + wt[i] for (olkoon i = 0; i tat[i] = bt[i] + wt[i] } // Keskimääräisen ajan laskeminen const. fill(0), tat = new Array(n).fill(0) anna total_wt = 0, total_tat = 0 // Funktio kaikkien prosessien odotusajan etsimiseen findOdotusaika(prosessit, n, bt, wt, kvantti); // Kääntymisajan etsiminen kaikille prosesseille findTurnAroundTime(processes, n, bt, wt, tat // Näytä prosessit yhdessä kaikkien yksityiskohtien kanssa document.write(`Prosessit Burst time Waiting time `); Laske kokonais odotusaika ja kokonaiskäännös // kiertoaika kohteelle (olkoon i = 0; i total_wt = total_wt + wt[i]; total_tat = total_tat + tat[i]; document.write(`${i + 1} ${ bt[i]} ${wt[i]} ${tat[i]} `); } document.write(`Keskimääräinen odotusaika = ${total_wt / n}`); = ${total_tat / n}`);  } // Ohjainkoodi // prosessitunnuksen prosessit = [1, 2, 3];  olkoon n = prosessit.pituus;  // Kaikkien prosessien purskeaika anna burst_time = [10, 5, 8];  // Aikakvantti olkoon kvantti = 2;  findavgTime(prosessit, n, purskeen_aika, kvantti);  // Tämän koodin tarjoaa rakeshsahni>>
 
 
 
 
    
java ja swing
 
> 
    
 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>
 
    Ohjelma Round Robin -aikataulutukseen, jossa saapumisaika on nolla, eri ja samat saapumisajat    
 
C++
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 #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>> kvantti;> >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;  // Muuttujien ilmoittaminen int c = n, s[n][20];  float time = 0, mini = INT_MAX, b[n], a[n];  // Purske- ja saapumisaikataulukoiden alustus 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) { indeksi = i;  mini = a[i];  lippu = tosi;  } } // jos at =1, silmukka lähtee, joten aseta lippu arvoon false if (!lippu) { aika++;  jatkaa;  } // lasketaan alkamisaika j = 0;  while (s[indeksi][j] != -1) { j++;  } if (s[indeksi][j] == -1) { s[indeksi][j] = aika;  p[indeksi].ST[j] = aika;  } jos (b[index]<= quant) {  time += b[index];  b[index] = 0;  } else {  time += quant;  b[index] -= quant;  }  if (b[index]>0) { a[indeksi] = aika + 0,1;  } // lasketaan saapumis-, purske-, loppuajat if (b[index] == 0) { c--;  p[indeksi].FT = aika;  p[indeksi].WT = p[indeksi].FT - p[indeksi].AT - p[indeksi].BT;  tot_wt += p[indeksi].WT;  p[indeksi].TAT = p[indeksi].BT + p[indeksi].WT;  tot_tat += p[indeksi].TAT;  } } // while-silmukan loppu // Tulostustulostus<< '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(n);  avg_tat = tot_tat / static_cast(n);  // Tulostetaan keskimääräinen odotusaika ja läpimenoaika<< 'The average wait time is: ' << avg_wt << endl;  cout << 'The average TurnAround time is: ' << avg_tat << endl;  return 0; }>
 
 
 
 
    
 
>
 
    
 
>
 
 
C
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 #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){ indeksi=i;  mini=a[i];  lippu = tosi;    } } // jos =1, silmukka lähtee, joten aseta lippu arvoon false if(!flag){ aika++;  jatkaa; } //aloitusajan laskeminen j=0; while(s[indeksi][j]!=-1){ j++; } if(s[indeksi][j]==-1){ s[indeksi][j]=aika; p[indeksi].ST[j] = aika; } if(b[index]<=quant){ time+=b[index]; b[index]=0; } else{ time+=quant; b[index]-=quant; } if(b[index]>0){ a[indeksi] = aika+0,1; } // saapumis-,purske-,lopullisten aikojen laskeminen if(b[index]==0){ c--; p[indeksi].FT = aika; p[indeksi].WT=p[indeksi].FT-p[indeksi].AT-p[indeksi].BT; tot_wt+=p[indeksi].WT; p[indeksi].TAT=p[indeksi].BT+p[indeksi].WT; tot_tat+=p[indeksi].TAT; } } // while-silmukan loppu // Tulostustulos printf('Prosessinumero '); printf('Saapumisaika '); printf('Burst time '); printf('	Aloitusaika'); j = 0; while(j!=10){ j+=1; printf(' '); } printf('		Lopullinen aika'); printf('	Odotusaika '); printf('	Kääntymisaika 
'); for(i=0;i printf('%d 		',p[i].pos); printf('%d 		',p[i].AT); printf ('%d 	',p[i].BT j=0 while(s[i][j]!=-1){ printf('%d '); ,p[i].ST[j] } while(v!=40){ printf('%d 		; ',p[i].FT); printf('%d 		',p[i].WT); } //Keskimääräisen odotusajan ja läpimenoajan laskeminen double avg_wt,avg_tat=tot_wt/(float)n //Keskimääräinen odotusaika ja odotusaika; aika on: %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>
 
    Ohjelma Round Robin -aikataulutukseen eri saapumisajoilla kaikille prosesseille    
 
Katso Preemptive Round Robin -algoritmin yksityiskohtainen toteutus eri saapumisajoilla kaikille prosesseille: Ohjelma Round Robin -aikatauluille eri saapumisajoilla .
 
Johtopäätös
 
Yhteenvetona voidaan todeta, että Round Robin -suorittimen ajoitus on oikeudenmukainen ja ennaltaehkäisevä algoritmi, joka varaa jokaiselle prosessille kiinteän aikakvantin, mikä varmistaa tasavertaisen prosessorin pääsyn. Se on yksinkertainen toteuttaa, mutta voi johtaa korkeampiin kontekstin vaihtamiseen. Vaikka se edistää oikeudenmukaisuutta ja ehkäisee nälänhätää, se voi johtaa pitempiin odotusaikoihin ja alentuneeseen läpimenoon aikamäärästä riippuen. Tehokas ohjelman toteutus mahdollistaa tärkeimpien mittareiden, kuten valmistumisajan, läpimenoajan ja odotusajan, laskemisen, mikä auttaa suorituskyvyn arvioinnissa ja optimoinnissa.