సి ప్రోగ్రామింగ్‌లో రౌండ్ రాబిన్ షెడ్యూలింగ్

ఈ వ్యాసంలో, రౌండ్-రాబిన్ షెడ్యూలింగ్ అల్గోరిథం అని పిలువబడే షెడ్యూలింగ్ అల్గోరిథం గురించి నేర్చుకుంటాము, రౌండ్-రాబిన్ అంటే ఏమిటి? ప్రోగ్రామ్ రాయడం ఎలా? మొదలైనవి ప్రారంభిద్దాం.

ప్రారంభ పిడిఎఫ్ కోసం సేల్స్ఫోర్స్ డెవలపర్ ట్యుటోరియల్

• రౌండ్ రాబిన్ షెడ్యూలింగ్ అంటే ఏమిటి?
• రౌండ్ రాబిన్ షెడ్యూలింగ్ అల్గోరిథం
• కోడ్
• ప్రయోజనాలు మరియు అప్రయోజనాలు

రౌండ్ రాబిన్ షెడ్యూలింగ్ అంటే ఏమిటి?

రౌండ్ రాబిన్ షెడ్యూలింగ్ అనేది CPU వినియోగాన్ని షెడ్యూల్ చేయడానికి సిస్టమ్ ఉపయోగించే షెడ్యూలింగ్ అల్గోరిథం. ఇది ప్రీమిటివ్ అల్గోరిథం. క్వాంటం అని పిలువబడే ప్రతి అభ్యర్థనతో అనుబంధించబడిన నిర్ణీత సమయ స్లైస్ ఉంది. జాబ్ షెడ్యూలర్ ప్రస్తుతం అమలు చేయబడుతున్న ఉద్యోగం యొక్క పురోగతిని ఆదా చేస్తుంది మరియు ఇచ్చిన సమయం క్వాంటం కోసం ఒక నిర్దిష్ట ప్రక్రియను అమలు చేసినప్పుడు క్యూలో ఉన్న తదుపరి ఉద్యోగానికి వెళుతుంది.

ఏ ప్రక్రియ కూడా ఎక్కువ కాలం CPU ని కలిగి ఉండదు. స్విచ్చింగ్‌ను కాంటెక్స్ట్ స్విచ్ అంటారు. ఇది బహుశా ఉత్తమ షెడ్యూలింగ్ అల్గోరిథంలలో ఒకటి. ఈ అల్గోరిథం యొక్క సామర్థ్యం క్వాంటం విలువపై ఆధారపడి ఉంటుంది.

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

• మనకు మొదట క్యూ ఉంది, ఇక్కడ ప్రక్రియలు మొదట అమర్చబడి ఉంటాయి.
• ప్రతి ప్రక్రియను అమలు చేయడానికి ఒక క్వాంటం విలువ కేటాయించబడుతుంది.
• మొదటి ప్రక్రియ క్వాంటం విలువ ముగిసే వరకు అమలు చేయబడుతుంది. దీని తరువాత, అంతరాయం ఏర్పడుతుంది మరియు రాష్ట్రం సేవ్ చేయబడుతుంది.
• CPU తరువాత తదుపరి ప్రక్రియకు వెళుతుంది మరియు అదే పద్ధతిని అనుసరిస్తుంది.
• అన్ని ప్రక్రియలు ముగిసే వరకు అదే దశలు పునరావృతమవుతాయి.

ఉదాహరణ కోడ్‌ను పరిశీలించండి

# int main () {int i, limit, total = 0, x, counter = 0, time_quantum int wait_time = 0, turnaround_time = 0, రాక_సమయం [10], burst_time [10], టెంప్ [10] ఫ్లోట్ యావరేజ్_వైట్_టైమ్, యావరేజ్_టర్నరౌండ్_టైమ్ printf ('n మొత్తం ప్రక్రియల సంఖ్యను నమోదు చేయండి: t') scanf ('% d', & పరిమితి) x = పరిమితి (i = 0 i0) {temp [i] = temp [i] - time_quantum total = total + time_quantum} if (temp [i] == 0 && counter == 1) {x-- printf ('nProcess [% d] tt% dtt ? = టర్నరౌండ్_టైమ్ + మొత్తం - రాక_టైమ్ [i] కౌంటర్ = 0} if (i == పరిమితి - 1) {i = 0} లేకపోతే (రాక_ సమయం [i + 1]<= total) { i++ } else { i = 0 } } average_wait_time = wait_time * 1.0 / limit average_turnaround_time = turnaround_time * 1.0 / limit printf('nnAverage Waiting Time:t%f', average_wait_time) printf('nAvg Turnaround Time:t%fn', average_turnaround_time) return 0 }

అవుట్పుట్:

వివరణ:

పై కోడ్‌లో, మేము వినియోగదారుల ప్రక్రియల సంఖ్యను మరియు రాక సమయాన్ని నమోదు చేయమని అడుగుతాము మరియు ప్రతి ప్రక్రియకు పేలుడు సమయం. మేము అప్పుడు రౌండ్-రాబిన్ అల్గోరిథం ఉపయోగించి వేచి ఉన్న సమయాన్ని మరియు సమయాన్ని మలుపులు లెక్కిస్తాము.

ఇక్కడ ప్రధాన భాగం సమయం మరియు వేచి ఉన్న సమయాన్ని మలుపు లెక్కించడం. తీసుకున్న మొత్తం సమయాన్ని జోడించి, రాక సమయాన్ని తీసివేయడం ద్వారా సమయం చుట్టూ తిరగబడుతుంది.

రాక సమయాన్ని తీసివేసి, మొత్తం నుండి పేలిన సమయాన్ని మరియు వేచి ఉన్న సమయాన్ని t0 జోడించడం ద్వారా వేచి ఉన్న సమయం లెక్కించబడుతుంది. రౌండ్-రాబిన్ షెడ్యూలింగ్ ఈ విధంగా జరుగుతుంది.

ప్రయోజనాలు:

• నిర్ణయం తీసుకోవటానికి తక్కువ ఓవర్ హెడ్.
• ఇతర అల్గోరిథంల మాదిరిగా కాకుండా, ఇది అన్ని ప్రక్రియలకు సమాన ప్రాధాన్యత ఇస్తుంది.
• ఈ ప్రక్రియలో ఆకలి చాలా అరుదుగా సంభవిస్తుంది.

నష్టాలు:

• తరచుగా మారడం వలన క్వాంటం విలువ తక్కువగా ఉంటే వ్యవస్థ యొక్క సామర్థ్యం తగ్గుతుంది.
• క్వాంటం విలువ ఎక్కువగా ఉంటే సిస్టమ్ స్పందించదు.

దీనితో, మేము ఈ వ్యాసం ముగింపుకు వచ్చాము.

సూడోకోడ్ సి ++ ను విలీనం చేయండి

మీరు ఈ సమాచారం మరియు సహాయకరంగా ఉన్నారని నేను ఆశిస్తున్నాను, ఇలాంటి అంశాలపై మరిన్ని ట్యుటోరియల్స్ కోసం వేచి ఉండండి. మీరు మా శిక్షణా కార్యక్రమాన్ని కూడా చూడవచ్చుj క్వెరీపై దాని వివిధ అనువర్తనాలతో పాటు లోతైన జ్ఞానాన్ని పొందండి, మీరు చేయవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో ప్రత్యక్ష ఆన్‌లైన్ శిక్షణ కోసం.పై కోడ్‌ను వేర్వేరు తీగలతో మరియు మార్పులతో అమలు చేయండి. ఇప్పుడు, పాయింటర్‌కు సంబంధించిన అన్ని ముఖ్య అంశాలపై మాకు మంచి అవగాహన ఉంది.

మాకు ప్రశ్న ఉందా? ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో వాటిని పేర్కొనండి మరియు మేము మీ వద్దకు తిరిగి వస్తాము.