ఆపరేటింగ్ సిస్టమ్స్ పరిచయం
హలో, హబ్ర్! నేను మీ దృష్టికి వ్యాసాల శ్రేణిని అందించాలనుకుంటున్నాను - నా అభిప్రాయంలో ఆసక్తికరమైన ఒక సాహిత్యం యొక్క అనువాదాలు - OSTEP. ఈ పదార్థం యునిక్స్ లాంటి ఆపరేటింగ్ సిస్టమ్‌ల పనిని చాలా లోతుగా పరిశీలిస్తుంది, అవి ప్రక్రియలు, వివిధ షెడ్యూలర్‌లు, మెమరీ మరియు ఆధునిక OSని రూపొందించే ఇతర సారూప్య భాగాలతో పని చేస్తాయి. మీరు ఇక్కడ అన్ని మెటీరియల్స్ యొక్క అసలైనదాన్ని చూడవచ్చు . అనువాదం వృత్తిపరంగా (చాలా స్వేచ్ఛగా) జరిగిందని దయచేసి గమనించండి, కానీ నేను సాధారణ అర్థాన్ని నిలుపుకున్నానని ఆశిస్తున్నాను.
ఈ విషయంపై ల్యాబ్ పనిని ఇక్కడ చూడవచ్చు:
ఇతర భాగాలు:
మీరు ఇక్కడ నా ఛానెల్‌ని కూడా చూడవచ్చు =)
షెడ్యూలర్‌తో పరిచయం
సమస్య యొక్క సారాంశం: షెడ్యూలర్ విధానాన్ని ఎలా అభివృద్ధి చేయాలి
అంతర్లీన షెడ్యూలర్ పాలసీ ఫ్రేమ్‌వర్క్‌లను ఎలా రూపొందించాలి? కీలక అంచనాలు ఏమిటి? ఏ కొలమానాలు ముఖ్యమైనవి? ప్రారంభ కంప్యూటింగ్ సిస్టమ్‌లలో ఏ ప్రాథమిక పద్ధతులు ఉపయోగించబడ్డాయి?
పని భారం అంచనాలు
సాధ్యమయ్యే విధానాలను చర్చించే ముందు, ముందుగా సిస్టమ్‌లో నడుస్తున్న ప్రక్రియల గురించి కొన్ని సరళీకృత డైగ్రెషన్‌లను చేద్దాం, వీటిని సమిష్టిగా పిలుస్తారు. పనిభారం. వర్క్‌లోడ్‌ను నిర్వచించడం అనేది పాలసీలను రూపొందించడంలో కీలకమైన భాగం మరియు పనిభారం గురించి మీకు ఎంత ఎక్కువ తెలిస్తే, మీరు రాయగలిగే విధానం అంత మెరుగ్గా ఉంటుంది.
సిస్టమ్‌లో నడుస్తున్న ప్రక్రియల గురించి ఈ క్రింది అంచనాలను చేద్దాం, కొన్నిసార్లు దీనిని కూడా పిలుస్తారు ఉద్యోగాలు (పనులు). దాదాపు ఈ ఊహలన్నీ వాస్తవికమైనవి కావు, కానీ ఆలోచన అభివృద్ధికి అవసరమైనవి.
- ప్రతి పని ఒకే సమయంలో నడుస్తుంది,
- అన్ని పనులు ఏకకాలంలో సెట్ చేయబడ్డాయి,
- కేటాయించిన పని పూర్తయ్యే వరకు పని చేస్తుంది,
- అన్ని పనులు CPUని మాత్రమే ఉపయోగిస్తాయి,
- ప్రతి పని యొక్క రన్నింగ్ టైమ్ తెలుస్తుంది.
షెడ్యూలర్ మెట్రిక్స్
లోడ్ గురించిన కొన్ని అంచనాలతో పాటు, విభిన్న షెడ్యూలింగ్ విధానాలను పోల్చడానికి మరొక సాధనం అవసరం: షెడ్యూలర్ మెట్రిక్స్. మెట్రిక్ అనేది ఏదో కొలమానం. షెడ్యూలర్‌లను పోల్చడానికి ఉపయోగించే అనేక కొలమానాలు ఉన్నాయి.
ఉదాహరణకు, మేము అనే మెట్రిక్‌ని ఉపయోగిస్తాము మలుపు సమయం (టర్నరౌండ్ సమయం). టాస్క్ టర్నరౌండ్ సమయం పనిని పూర్తి చేసే సమయం మరియు సిస్టమ్‌లో టాస్క్ రాక సమయం మధ్య వ్యత్యాసంగా నిర్వచించబడింది.
Tturnarround=Tcompletion−Tarrival
అన్ని పనులు ఒకే సమయంలో వచ్చినట్లు మేము భావించాము కాబట్టి, Ta=0 మరియు ఆ విధంగా Tt=Tc. మనం పై అంచనాలను మార్చినప్పుడు ఈ విలువ సహజంగా మారుతుంది.
మరో మెట్రిక్ - న్యాయంగా (న్యాయం, నిజాయితీ). ఉత్పాదకత మరియు సరసత తరచుగా ప్రణాళికలో వ్యతిరేక లక్షణాలను కలిగి ఉంటాయి. ఉదాహరణకు, షెడ్యూలర్ పనితీరును ఆప్టిమైజ్ చేయవచ్చు, కానీ ఇతర టాస్క్‌లు అమలు అయ్యే వరకు వేచి ఉండే ఖర్చుతో, తద్వారా సరసత తగ్గుతుంది.
ఫస్ట్ ఇన్ ఫస్ట్ అవుట్ (FIFO)
మేము అమలు చేయగల అత్యంత ప్రాథమిక అల్గోరిథం FIFO లేదా మొదట వచ్చిన (ఇన్), మొదట అందించిన (అవుట్). ఈ అల్గోరిథం అనేక ప్రయోజనాలను కలిగి ఉంది: ఇది అమలు చేయడం చాలా సులభం మరియు ఇది మా అన్ని అంచనాలకు సరిపోతుంది మరియు పనిని బాగా చేస్తుంది.
ఒక సాధారణ ఉదాహరణ చూద్దాం. 3 పనులు ఏకకాలంలో సెట్ చేయబడ్డాయి అనుకుందాం. అయితే టాస్క్ A అన్నింటి కంటే కొంచెం ముందుగానే వచ్చిందని అనుకుందాం, కనుక ఇది C కి సంబంధించి B లాగానే ఇతరుల కంటే ముందుగానే అమలు జాబితాలో కనిపిస్తుంది. వాటిలో ప్రతి ఒక్కటి 10 సెకన్ల పాటు అమలు చేయబడుతుందని అనుకుందాం. ఈ సందర్భంలో ఈ పనులను పూర్తి చేయడానికి సగటు సమయం ఎంత?
విలువలను లెక్కించడం ద్వారా - 10+20+30 మరియు 3 ద్వారా విభజించడం ద్వారా, మేము సగటు ప్రోగ్రామ్ అమలు సమయాన్ని 20 సెకన్లకు సమానం చేస్తాము.
ఇప్పుడు మన ఊహలను మార్చుకోవడానికి ప్రయత్నిద్దాం. ప్రత్యేకించి, ఊహ 1 మరియు అందువలన మేము ఇకపై ప్రతి పనిని అమలు చేయడానికి ఒకే సమయం తీసుకుంటామని భావించము. ఈసారి FIFO పనితీరు ఎలా ఉంటుంది?
FIFO అల్గోరిథం యొక్క ఉత్పాదకతపై వేర్వేరు పని అమలు సమయాలు చాలా ప్రతికూల ప్రభావాన్ని చూపుతాయి. టాస్క్ A పూర్తి కావడానికి 100 సెకన్లు పడుతుందని, B మరియు Cలు ఒక్కొక్కటి 10 సెకన్లు తీసుకుంటాయని అనుకుందాం.
బొమ్మ నుండి చూడగలిగినట్లుగా, సిస్టమ్ యొక్క సగటు సమయం (100+110+120)/3=110. ఈ ప్రభావం అంటారు కాన్వాయ్ ప్రభావం, రిసోర్స్ యొక్క కొంతమంది స్వల్పకాలిక వినియోగదారులు భారీ వినియోగదారుని తర్వాత క్యూలో ఉన్నప్పుడు. నిండు కార్ట్‌తో మీ ముందు కస్టమర్ ఉన్నప్పుడు కిరాణా దుకాణం వద్ద లైన్ లాగా ఉంటుంది. సమస్యకు ఉత్తమ పరిష్కారం నగదు రిజిస్టర్‌ను మార్చడానికి ప్రయత్నించడం లేదా విశ్రాంతి మరియు లోతుగా ఊపిరి పీల్చుకోవడం.
చిన్నదైన జాబ్ ఫస్ట్
హెవీవెయిట్ ప్రక్రియలతో ఇలాంటి పరిస్థితిని ఎలాగైనా పరిష్కరించడం సాధ్యమేనా? ఖచ్చితంగా. మరొక రకమైన ప్రణాళిక అంటారుచిన్నదైన జాబ్ ఫస్ట్ (SJF). దీని అల్గోరిథం కూడా చాలా ప్రాచీనమైనది - పేరు సూచించినట్లుగా, చిన్నదైన టాస్క్‌లు ఒకదాని తర్వాత ఒకటి ప్రారంభించబడతాయి.
ఈ ఉదాహరణలో, అదే ప్రక్రియలను అమలు చేయడం వల్ల వచ్చే ఫలితం సగటు ప్రోగ్రామ్ టర్నరౌండ్ సమయంలో మెరుగుపడుతుంది మరియు ఇది సమానంగా ఉంటుంది 50 కి బదులుగా 110, ఇది దాదాపు 2 రెట్లు మెరుగైనది.
అందువల్ల, అన్ని పనులు ఒకే సమయంలో వస్తాయనే ఊహకు, SJF అల్గోరిథం అత్యంత అనుకూలమైన అల్గారిథమ్‌గా కనిపిస్తుంది. అయినప్పటికీ, మా అంచనాలు ఇప్పటికీ వాస్తవికంగా కనిపించడం లేదు. ఈసారి మేము ఊహ 2ని మారుస్తాము మరియు ఈ సమయంలో టాస్క్‌లు ఎప్పుడైనా ఉండవచ్చని మరియు అన్నీ ఒకే సమయంలో ఉండవని ఊహించండి. ఇది ఏ సమస్యలకు దారి తీస్తుంది?
టాస్క్ A (100c) ముందుగా వచ్చి అమలు చేయడం ప్రారంభిస్తుందని ఊహించుకుందాం. t=10 వద్ద, టాస్క్‌లు B మరియు C చేరుకుంటాయి, వీటిలో ప్రతి ఒక్కటి 10 సెకన్లు పడుతుంది. కాబట్టి సగటు అమలు సమయం (100+(110-10)+(120-10))3 = 103. దీన్ని మెరుగుపరచడానికి షెడ్యూలర్ ఏమి చేయవచ్చు?
ముందుగా పూర్తి చేయడానికి తక్కువ సమయం (STCF)
పరిస్థితిని మెరుగుపరచడానికి, ప్రోగ్రామ్ ప్రారంభించబడి, పూర్తయ్యే వరకు అమలు చేయబడుతుందని మేము ఊహ 3ని వదిలివేస్తాము. అదనంగా, మాకు హార్డ్‌వేర్ మద్దతు అవసరం మరియు మీరు ఊహించినట్లుగా, మేము ఉపయోగిస్తాము టైమర్ నడుస్తున్న పనికి అంతరాయం కలిగించడానికి మరియు సందర్భం మారడం. అందువలన, షెడ్యూలర్ టాస్క్‌లు B, C వచ్చిన క్షణంలో ఏదైనా చేయగలడు - టాస్క్ Aని అమలు చేయడం ఆపివేసి, B మరియు C టాస్క్‌లను ప్రాసెసింగ్‌లో ఉంచండి మరియు అవి పూర్తయిన తర్వాత, ప్రక్రియను అమలు చేయడం కొనసాగించండి. అటువంటి షెడ్యూలర్‌ని అంటారు. STCFలేదా ముందుగా ముందస్తు ఉద్యోగం.
ఈ ప్లానర్ యొక్క ఫలితం క్రింది ఫలితం అవుతుంది: ((120-0)+(20-10)+(30-10))/3=50. అందువలన, అటువంటి షెడ్యూలర్ మా పనులకు మరింత అనుకూలమైనది.
మెట్రిక్ ప్రతిస్పందన సమయం
ఈ విధంగా, టాస్క్‌ల రన్నింగ్ టైమ్ మరియు ఈ టాస్క్‌లు CPUని మాత్రమే ఉపయోగిస్తాయని మనకు తెలిస్తే, STCF ఉత్తమ పరిష్కారం అవుతుంది. మరియు ఒకప్పుడు ప్రారంభ కాలంలో, ఈ అల్గోరిథంలు చాలా బాగా పనిచేశాయి. అయినప్పటికీ, వినియోగదారు ఇప్పుడు ఎక్కువ సమయం టెర్మినల్ వద్ద గడుపుతున్నారు మరియు ఉత్పాదక ఇంటరాక్టివ్ అనుభవాన్ని ఆశించారు. కాబట్టి కొత్త మెట్రిక్ పుట్టింది - ప్రతిస్పందన సమయం (స్పందన).
ప్రతిస్పందన సమయం క్రింది విధంగా లెక్కించబడుతుంది:
Tresponse=Tfirstrun−Tarrival
కాబట్టి, మునుపటి ఉదాహరణకి, ప్రతిస్పందన సమయం: A=0, B=0, C=10 (abg=3,33).
మరియు అదే సమయంలో 3 పనులు వచ్చే పరిస్థితిలో STCF అల్గోరిథం అంత మంచిది కాదని తేలింది - చిన్న పనులు పూర్తిగా పూర్తయ్యే వరకు వేచి ఉండవలసి ఉంటుంది. కాబట్టి టర్న్‌అరౌండ్ టైమ్ మెట్రిక్‌కు అల్గారిథమ్ మంచిది, కానీ ఇంటరాక్టివిటీ మెట్రిక్‌కు చెడుగా ఉంటుంది. మీరు టెర్మినల్ వద్ద కూర్చొని ఎడిటర్‌లో అక్షరాలను టైప్ చేయడానికి ప్రయత్నిస్తుంటే మరియు 10 సెకన్ల కంటే ఎక్కువ వేచి ఉండాల్సి వస్తే ఊహించండి ఎందుకంటే వేరే పని CPUని తీసుకుంటుంది. ఇది చాలా ఆహ్లాదకరమైనది కాదు.
కాబట్టి మేము మరొక సమస్యను ఎదుర్కొంటున్నాము - ప్రతిస్పందన సమయానికి సున్నితంగా ఉండే షెడ్యూలర్‌ను ఎలా నిర్మించగలము?
రౌండ్ రాబిన్
ఈ సమస్యను పరిష్కరించడానికి ఒక అల్గోరిథం అభివృద్ధి చేయబడింది రౌండ్ రాబిన్ (RR). ప్రాథమిక ఆలోచన చాలా సులభం: టాస్క్‌లు పూర్తయ్యే వరకు వాటిని అమలు చేయడానికి బదులుగా, మేము టాస్క్‌ను కొంత సమయం వరకు (టైమ్ స్లైస్ అని పిలుస్తారు) అమలు చేస్తాము, ఆపై క్యూ నుండి మరొక పనికి మారతాము. అన్ని పనులు పూర్తయ్యే వరకు అల్గోరిథం దాని పనిని పునరావృతం చేస్తుంది. ఈ సందర్భంలో, ప్రోగ్రామ్ యొక్క నడుస్తున్న సమయం తప్పనిసరిగా టైమర్ ప్రక్రియకు అంతరాయం కలిగించే సమయానికి బహుళంగా ఉండాలి. ఉదాహరణకు, ప్రతి x=10msకి టైమర్ ప్రాసెస్‌కు అంతరాయం కలిగిస్తే, ప్రాసెస్ ఎగ్జిక్యూషన్ విండో పరిమాణం 10కి గుణకారంగా ఉండాలి మరియు 10,20 లేదా x*10 అయి ఉండాలి.
ఒక ఉదాహరణను చూద్దాం: ABC టాస్క్‌లు సిస్టమ్‌లో ఏకకాలంలో వస్తాయి మరియు వాటిలో ప్రతి ఒక్కటి 5 సెకన్ల పాటు అమలు చేయాలనుకుంటున్నాయి. SJF అల్గోరిథం ప్రతి పనిని మరొక పనిని ప్రారంభించే ముందు పూర్తి చేస్తుంది. దీనికి విరుద్ధంగా, లాంచ్ విండో = 1sతో RR అల్గోరిథం క్రింది విధంగా విధులను నిర్వహిస్తుంది (Fig. 4.3):
(SJF ఎగైన్ (బాడ్ ఫర్ రెస్పాన్స్ టైమ్)
(రౌండ్ రాబిన్ (ప్రతిస్పందన సమయానికి మంచిది)
RR అల్గారిథమ్‌కి సగటు ప్రతిస్పందన సమయం (0+1+2)/3=1, అయితే SJF (0+5+10)/3=5.
RR కోసం టైమ్ విండో చాలా ముఖ్యమైన పరామితి అని భావించడం తార్కికం; ఇది చిన్నది, ప్రతిస్పందన సమయం ఎక్కువ. అయితే, మీరు దీన్ని చాలా చిన్నదిగా చేయకూడదు, ఎందుకంటే సందర్భాన్ని మార్చే సమయం మొత్తం పనితీరులో కూడా పాత్ర పోషిస్తుంది. అందువలన, అమలు విండో సమయం ఎంపిక OS వాస్తుశిల్పిచే సెట్ చేయబడుతుంది మరియు దానిలో అమలు చేయడానికి ప్రణాళిక చేయబడిన పనులపై ఆధారపడి ఉంటుంది. సందర్భాన్ని మార్చడం అనేది సమయాన్ని వృథా చేసే ఏకైక సేవా ఆపరేషన్ కాదు - రన్నింగ్ ప్రోగ్రామ్ చాలా ఇతర విషయాలపై పనిచేస్తుంది, ఉదాహరణకు, వివిధ కాష్‌లు, మరియు ప్రతి స్విచ్‌తో ఈ వాతావరణాన్ని సేవ్ చేయడం మరియు పునరుద్ధరించడం అవసరం, దీనికి చాలా సమయం పడుతుంది. సమయం.
మేము ప్రతిస్పందన సమయ మెట్రిక్ గురించి మాత్రమే మాట్లాడుతున్నట్లయితే RR గొప్ప షెడ్యూలర్. అయితే ఈ అల్గారిథమ్‌తో టాస్క్ టర్నరౌండ్ టైమ్ మెట్రిక్ ఎలా ప్రవర్తిస్తుంది? పై ఉదాహరణను పరిగణించండి, A, B, C = 5s యొక్క ఆపరేటింగ్ సమయం మరియు అదే సమయంలో వచ్చినప్పుడు. టాస్క్ A 13కి, B 14కి, C 15కి ముగుస్తుంది మరియు సగటు టర్నరౌండ్ సమయం 14సె. అందువలన, RR అనేది టర్నోవర్ మెట్రిక్ కోసం చెత్త అల్గోరిథం.
మరింత సాధారణ పరంగా, ఏదైనా RR-రకం అల్గోరిథం సరసమైనది; ఇది CPU సమయాన్ని అన్ని ప్రక్రియల మధ్య సమానంగా విభజిస్తుంది. అందువలన, ఈ కొలమానాలు నిరంతరం పరస్పరం విభేదిస్తాయి.
ఈ విధంగా, మనకు అనేక విరుద్ధమైన అల్గారిథమ్‌లు ఉన్నాయి మరియు అదే సమయంలో ఇంకా అనేక అంచనాలు మిగిలి ఉన్నాయి - పని సమయం తెలుసు మరియు పని CPUని మాత్రమే ఉపయోగిస్తుంది.
I/Oతో కలపడం
అన్నింటిలో మొదటిది, ప్రక్రియ CPUని మాత్రమే ఉపయోగిస్తుందని ఊహ 4ని తీసివేద్దాం; సహజంగా, ఇది అలా కాదు మరియు ప్రక్రియలు ఇతర పరికరాలను యాక్సెస్ చేయగలవు.
ఏదైనా ప్రక్రియ I/O ఆపరేషన్‌ను అభ్యర్థించిన క్షణం, ప్రక్రియ బ్లాక్ చేయబడిన స్థితిలోకి ప్రవేశిస్తుంది, I/O పూర్తయ్యే వరకు వేచి ఉంటుంది. I/O హార్డ్ డ్రైవ్‌కు పంపబడితే, అటువంటి ఆపరేషన్ అనేక ms లేదా అంతకంటే ఎక్కువ సమయం పట్టవచ్చు మరియు ఈ సమయంలో ప్రాసెసర్ నిష్క్రియంగా ఉంటుంది. ఈ సమయంలో, షెడ్యూలర్ ఏదైనా ఇతర ప్రక్రియతో ప్రాసెసర్‌ను ఆక్రమించవచ్చు. షెడ్యూలర్ తీసుకోవలసిన తదుపరి నిర్ణయం ప్రక్రియ దాని I/Oని ఎప్పుడు పూర్తి చేస్తుంది. ఇది జరిగినప్పుడు, అంతరాయం ఏర్పడుతుంది మరియు OS I/O అని పిలిచే ప్రక్రియను సిద్ధంగా ఉన్న స్థితిలో ఉంచుతుంది.
అనేక సమస్యల ఉదాహరణను చూద్దాం. వాటిలో ప్రతిదానికి 50ms CPU సమయం అవసరం. అయినప్పటికీ, మొదటిది ప్రతి 10మి.లకు I/Oని యాక్సెస్ చేస్తుంది (ఇది ప్రతి 10msకి కూడా అమలు చేయబడుతుంది). మరియు ప్రాసెస్ B కేవలం I/O లేకుండా 50ms ప్రాసెసర్‌ని ఉపయోగిస్తుంది.
ఈ ఉదాహరణలో మేము STCF షెడ్యూలర్‌ని ఉపయోగిస్తాము. A వంటి ప్రక్రియను ప్రారంభించినట్లయితే షెడ్యూలర్ ఎలా ప్రవర్తిస్తాడు? అతను ఈ క్రింది వాటిని చేస్తాడు: మొదట అతను పూర్తిగా A ప్రక్రియను పూర్తి చేస్తాడు, ఆపై Bని ప్రాసెస్ చేస్తాడు.
ఈ సమస్యను పరిష్కరించడానికి సాంప్రదాయిక విధానం ఏమిటంటే, ప్రాసెస్ A యొక్క ప్రతి 10 ms సబ్‌టాస్క్‌ను ఒక ప్రత్యేక పనిగా పరిగణించడం. అందువలన, STJF అల్గారిథమ్‌తో ప్రారంభించినప్పుడు, 50 ms టాస్క్ మరియు 10 ms టాస్క్ మధ్య ఎంపిక స్పష్టంగా ఉంటుంది. అప్పుడు, సబ్‌టాస్క్ A పూర్తయినప్పుడు, ప్రాసెస్ B మరియు I/O ప్రారంభించబడతాయి. I/O పూర్తయిన తర్వాత, ప్రాసెస్ Bకి బదులుగా 10ms ప్రాసెస్ Aని మళ్లీ ప్రారంభించడం ఆచారంగా ఉంటుంది. ఈ విధంగా, అతివ్యాప్తిని అమలు చేయడం సాధ్యమవుతుంది, ఇక్కడ CPU మరొక ప్రక్రియ ద్వారా ఉపయోగించబడుతుంది, మొదటిది వేచి ఉంది I/O. మరియు ఫలితంగా, సిస్టమ్ బాగా ఉపయోగించబడుతుంది - ఇంటరాక్టివ్ ప్రక్రియలు I/O కోసం వేచి ఉన్న సమయంలో, ఇతర ప్రక్రియలు ప్రాసెసర్‌లో అమలు చేయబడతాయి.
ఒరాకిల్ ఇక లేదు
ఇప్పుడు టాస్క్ యొక్క రన్నింగ్ టైమ్ తెలిసిందనే ఊహను వదిలించుకోవడానికి ప్రయత్నిద్దాం. ఇది మొత్తం జాబితాలో సాధారణంగా చెత్త మరియు అత్యంత అవాస్తవమైన ఊహ. వాస్తవానికి, సగటు సాధారణ OSలో, OSకి సాధారణంగా టాస్క్‌ల అమలు సమయం గురించి చాలా తక్కువ తెలుసు, కాబట్టి పనిని అమలు చేయడానికి ఎంత సమయం పడుతుందో తెలియకుండా మీరు షెడ్యూలర్‌ను ఎలా నిర్మించగలరు? బహుశా మేము ఈ సమస్యను పరిష్కరించడానికి కొన్ని RR సూత్రాలను ఉపయోగించవచ్చా?
ఫలితం
మేము టాస్క్ షెడ్యూలింగ్ యొక్క ప్రాథమిక ఆలోచనలను పరిశీలించాము మరియు షెడ్యూలర్‌ల యొక్క 2 కుటుంబాలను చూశాము. మొదటిది ముందుగా చిన్నదైన పనిని ప్రారంభిస్తుంది మరియు తద్వారా టర్నరౌండ్ సమయాన్ని పెంచుతుంది, రెండవది అన్ని పనుల మధ్య సమానంగా నలిగిపోతుంది, ప్రతిస్పందన సమయాన్ని పెంచుతుంది. ఇతర కుటుంబానికి చెందిన అల్గారిథమ్‌లు బాగున్న చోట రెండు అల్గారిథమ్‌లు చెడ్డవి. CPU మరియు I/O యొక్క సమాంతర వినియోగం పనితీరును ఎలా మెరుగుపరుస్తుందో కూడా మేము చూశాము, కానీ OS క్లైర్‌వాయెన్స్‌తో సమస్యను పరిష్కరించలేదు. మరియు తదుపరి పాఠంలో మనం తక్షణ గతాన్ని చూసే మరియు భవిష్యత్తును అంచనా వేయడానికి ప్రయత్నించే ప్లానర్‌ని చూస్తాము. మరియు దీనిని బహుళ-స్థాయి ఫీడ్‌బ్యాక్ క్యూ అంటారు.
మూలం: www.habr.com