ఆపరేటింగ్ సిస్టమ్స్ పరిచయం

హే హబ్ర్! నేను మీ దృష్టికి కథనాల శ్రేణిని తీసుకురావాలనుకుంటున్నాను - నా అభిప్రాయం ప్రకారం ఒక ఆసక్తికరమైన సాహిత్యం యొక్క అనువాదాలు - OSTEP. ఈ మెటీరియల్ unix-వంటి ఆపరేటింగ్ సిస్టమ్‌ల పనిని చాలా లోతుగా చర్చిస్తుంది, అవి ప్రక్రియలు, వివిధ షెడ్యూలర్‌లు, మెమరీ మరియు ఆధునిక OSని రూపొందించే ఇతర సారూప్య భాగాలతో పని చేస్తాయి. మీరు ఇక్కడ అన్ని పదార్థాల అసలైనదాన్ని చూడవచ్చు ఇక్కడ. అనువాదం వృత్తిపరంగా (చాలా స్వేచ్ఛగా) జరిగిందని దయచేసి గమనించండి, కానీ నేను సాధారణ అర్థాన్ని నిలుపుకున్నానని ఆశిస్తున్నాను.

ఈ విషయంపై ల్యాబ్ పనిని ఇక్కడ చూడవచ్చు:
- అసలు: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- అసలు: github.com/remzi-arpacidusseau/ostep-code
- నా వ్యక్తిగత అనుసరణ: github.com/bykvaadm/OS/tree/master/ostep

మీరు ఇక్కడ నా ఛానెల్‌ని కూడా చూడవచ్చు ఐ =)

ప్రోగ్రామ్ ఆపరేషన్

ప్రోగ్రామ్ నడుస్తున్నప్పుడు ఏమి జరుగుతుంది? నడుస్తున్న ప్రోగ్రామ్ ఒక సాధారణ పనిని చేస్తుంది - ఇది సూచనలను అమలు చేస్తుంది. ప్రతి సెకను, RAM నుండి ప్రాసెసర్ ద్వారా మిలియన్ల కొద్దీ మరియు బహుశా బిలియన్ల కొద్దీ సూచనలు తిరిగి పొందబడతాయి, అది వాటిని డీకోడ్ చేస్తుంది (ఉదాహరణకు, ఈ సూచనలు ఏ రకానికి చెందినవో అది గుర్తిస్తుంది) మరియు వాటిని అమలు చేస్తుంది. ఇది రెండు సంఖ్యలను జోడించడం, మెమరీని యాక్సెస్ చేయడం, పరిస్థితిని తనిఖీ చేయడం, ఫంక్షన్‌కు దూకడం మొదలైనవి కావచ్చు. ఒక సూచనను అమలు చేసిన తర్వాత, ప్రాసెసర్ మరొకదానిని అమలు చేయడానికి కొనసాగుతుంది. కాబట్టి సూచనల తర్వాత సూచన, ప్రోగ్రామ్ ముగిసే వరకు అవి అమలు చేయబడతాయి.
ఈ ఉదాహరణ సహజంగా సరళీకృతంగా పరిగణించబడుతుంది - వాస్తవానికి, ప్రాసెసర్‌ను వేగవంతం చేయడానికి, ఆధునిక హార్డ్‌వేర్ సూచనలను వెలుపల అమలు చేయడానికి, సాధ్యమయ్యే ఫలితాలను లెక్కించడానికి, సూచనలను ఏకకాలంలో అమలు చేయడానికి మరియు ఇలాంటి ఉపాయాలను అనుమతిస్తుంది.

వాన్ న్యూమాన్ మోడల్ ఆఫ్ కంప్యూటేషన్

మేము వివరించిన ఆపరేషన్ యొక్క సరళీకృత రూపం కంప్యూటింగ్ యొక్క వాన్ న్యూమాన్ మోడల్ వలె ఉంటుంది. వాన్ న్యూమాన్ కంప్యూటర్ సిస్టమ్స్ యొక్క మార్గదర్శకులలో ఒకరు, అతను గేమ్ థియరీ రచయితలలో ఒకడు. ప్రోగ్రామ్ నడుస్తున్నప్పుడు, ఇతర ఈవెంట్‌ల సమూహం జరుగుతుంది, అనేక ఇతర ప్రక్రియలు మరియు మూడవ-పక్షం లాజిక్ పని, దీని యొక్క ముఖ్య ఉద్దేశ్యం సిస్టమ్ యొక్క లాంచ్, ఆపరేషన్ మరియు నిర్వహణను సులభతరం చేయడం.
ప్రోగ్రామ్‌లను సులభంగా అమలు చేయడానికి (లేదా ఒకే సమయంలో బహుళ ప్రోగ్రామ్‌లను అమలు చేయడానికి అనుమతించడం) బాధ్యత వహించే సాఫ్ట్‌వేర్ సమితి ఉంది, ఇది ప్రోగ్రామ్‌లను ఒకే మెమరీని పంచుకోవడానికి మరియు విభిన్న పరికరాలతో కమ్యూనికేట్ చేయడానికి అనుమతిస్తుంది. ఇటువంటి సాఫ్ట్‌వేర్ (సాఫ్ట్‌వేర్)ని తప్పనిసరిగా ఆపరేటింగ్ సిస్టమ్ అని పిలుస్తారు మరియు సిస్టమ్ సరిగ్గా మరియు సమర్ధవంతంగా పని చేస్తుందో లేదో పర్యవేక్షించడం, అలాగే ఈ సిస్టమ్ యొక్క నిర్వహణ సౌలభ్యాన్ని నిర్ధారించడం వంటివి దీని విధుల్లో ఉన్నాయి.

ఆపరేటింగ్ సిస్టమ్

ఆపరేటింగ్ సిస్టమ్, OSగా సంక్షిప్తీకరించబడింది, ఇది కంప్యూటర్ వనరులను నిర్వహించడానికి మరియు కంప్యూటర్‌తో వినియోగదారు పరస్పర చర్యను నిర్వహించడానికి రూపొందించబడిన పరస్పర సంబంధం ఉన్న ప్రోగ్రామ్‌ల సమితి..
OS అత్యంత ముఖ్యమైన సాంకేతికత ద్వారా మొదటి స్థానంలో దాని ప్రభావాన్ని సాధిస్తుంది - టెక్నిక్ వర్చువలైజేషన్. OS భౌతిక వనరుతో (ప్రాసెసర్, మెమరీ, డిస్క్, మొదలైనవి) సంకర్షణ చెందుతుంది మరియు దానిని మరింత సాధారణ, మరింత శక్తివంతమైన మరియు సులభంగా ఉపయోగించగల రూపంగా మారుస్తుంది. అందువల్ల, సాధారణ అవగాహన కోసం, మీరు ఆపరేటింగ్ సిస్టమ్‌ను వర్చువల్ మెషీన్‌తో చాలా స్థూలంగా పోల్చవచ్చు.
ఆపరేటింగ్ సిస్టమ్‌కు ఆదేశాలను అందించడానికి వినియోగదారులను అనుమతించడానికి మరియు తద్వారా వర్చువల్ మెషీన్ యొక్క సామర్థ్యాలను (ప్రోగ్రామ్‌ను అమలు చేయడం, మెమరీని కేటాయించడం, ఫైల్‌ను యాక్సెస్ చేయడం మరియు మొదలైనవి) ఉపయోగించడానికి, ఆపరేటింగ్ సిస్టమ్ అని పిలువబడే కొన్ని ఇంటర్‌ఫేస్‌లను అందిస్తుంది. API (అప్లికేషన్ ప్రోగ్రామింగ్ ఇంటర్‌ఫేస్) మరియు దీనికి మీరు కాల్‌లు చేయవచ్చు (కాల్). ఒక సాధారణ ఆపరేటింగ్ సిస్టమ్ వందలాది సిస్టమ్ కాల్‌లను చేయడానికి అనుమతిస్తుంది.
చివరగా, వర్చువలైజేషన్ బహుళ ప్రోగ్రామ్‌లను అమలు చేయడానికి అనుమతిస్తుంది (అందువలన CPU భాగస్వామ్యం చేయడం), మరియు ఏకకాలంలో వాటి సూచనలను మరియు డేటాను యాక్సెస్ చేయడం (తద్వారా మెమరీని భాగస్వామ్యం చేయడం), మరియు డిస్క్‌లను యాక్సెస్ చేయడం (తద్వారా I/O పరికరాలను భాగస్వామ్యం చేయడం) ), ఆపరేటింగ్ సిస్టమ్‌ని కూడా అంటారు. రిసోర్స్ మేనేజర్. ప్రతి ప్రాసెసర్, డిస్క్ మరియు మెమరీ సిస్టమ్ యొక్క వనరు, కాబట్టి ఆపరేటింగ్ సిస్టమ్ యొక్క పాత్రలలో ఒకటి ఈ వనరులను నిర్వహించడం, సమర్థవంతంగా, నిజాయితీగా లేదా దీనికి విరుద్ధంగా, ఈ ఆపరేటింగ్ సిస్టమ్ యొక్క పనిని బట్టి చేస్తుంది. రూపొందించబడింది.

CPU వర్చువలైజేషన్

కింది ప్రోగ్రామ్‌ను పరిగణించండి:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

ఇది ఏ ప్రత్యేక చర్యలను చేయదు, వాస్తవానికి, ఇది చేసేదంతా ఒక ఫంక్షన్ అని పిలుస్తారు స్పిన్(), దీని పని సమయ తనిఖీ ద్వారా చక్రం తిప్పడం మరియు ఒక సెకను గడిచిన తర్వాత తిరిగి రావడం. అందువల్ల, వినియోగదారు ఆర్గ్యుమెంట్‌గా పాస్ చేసిన స్ట్రింగ్‌ను ఇది నిరవధికంగా పునరావృతం చేస్తుంది.
ఈ ప్రోగ్రామ్‌ని అమలు చేసి, "A" అక్షరాన్ని వాదనగా పాస్ చేద్దాం. ఫలితం ప్రత్యేకంగా ఆసక్తికరంగా లేదు - సిస్టమ్ "A" అక్షరాన్ని క్రమానుగతంగా ప్రదర్శించే ప్రోగ్రామ్‌ను అమలు చేస్తుంది.
ఇప్పుడు ఒకే ప్రోగ్రామ్‌లోని అనేక సందర్భాలు రన్ అవుతున్నప్పుడు ఎంపికను ప్రయత్నిద్దాం, కానీ దానిని స్పష్టంగా చేయడానికి వేర్వేరు అక్షరాలను అవుట్‌పుట్ చేయండి. ఈ సందర్భంలో, ఫలితం కొంత భిన్నంగా ఉంటుంది. మాకు ఒక ప్రాసెసర్ ఉన్నప్పటికీ, ప్రోగ్రామ్ ఏకకాలంలో అమలు చేయబడుతుంది. అది ఎలా జరుగుతుంది? కానీ ఆపరేటింగ్ సిస్టమ్, హార్డ్వేర్ సామర్థ్యాల సహాయం లేకుండా కాదు, ఒక భ్రమను సృష్టిస్తుంది. సిస్టమ్ బహుళ వర్చువల్ ప్రాసెసర్‌లను కలిగి ఉందనే భ్రమ, ఒకే భౌతిక ప్రాసెసర్‌ని సిద్ధాంతపరంగా అనంతమైన సంఖ్యగా మారుస్తుంది మరియు తద్వారా అకారణంగా ప్రోగ్రామ్‌లను ఏకకాలంలో అమలు చేయడానికి అనుమతిస్తుంది. ఈ భ్రమ అంటారు CPU వర్చువలైజేషన్.
ఈ చిత్రం అనేక ప్రశ్నలను లేవనెత్తుతుంది, ఉదాహరణకు, అనేక ప్రోగ్రామ్‌లు ఒకే సమయంలో అమలు చేయాలనుకుంటే, ఏది ప్రారంభించబడుతుంది? OS యొక్క "విధానాలు" ఈ ప్రశ్నకు బాధ్యత వహిస్తాయి. OSలో అనేక చోట్ల విధానాలు ఉపయోగించబడతాయి మరియు ఇలాంటి ప్రశ్నలకు సమాధానాలు ఇవ్వబడతాయి మరియు OS అమలు చేసే ప్రాథమిక విధానాలు. అందువల్ల OS యొక్క పాత్ర రిసోర్స్ మేనేజర్‌గా ఉంటుంది.

మెమరీ వర్చువలైజేషన్

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

malloc() కాల్

కింది ప్రోగ్రామ్‌ను పరిగణించండి, ఇది కాల్‌ని ఉపయోగించి మెమరీ ప్రాంతాన్ని కేటాయిస్తుంది malloc () (https://youtu.be/jnlKRnoT1m0):

కార్యక్రమం అనేక పనులను చేస్తుంది. మొదట, ఇది కొంత మెమరీని కేటాయిస్తుంది (లైన్ 7), ఆపై కేటాయించిన సెల్ (లైన్ 9) చిరునామాను ప్రింట్ చేస్తుంది, కేటాయించిన మెమరీ యొక్క మొదటి స్లాట్‌కు సున్నాని వ్రాస్తుంది. తరువాత, ప్రోగ్రామ్ లూప్‌లోకి ప్రవేశిస్తుంది, దీనిలో "p" వేరియబుల్‌లోని చిరునామాలో మెమరీలో నిల్వ చేయబడిన విలువను పెంచుతుంది. ఇది స్వయంగా ప్రాసెస్ IDని కూడా ప్రింట్ చేస్తుంది. ప్రతి రన్నింగ్ ప్రాసెస్‌కి ప్రాసెస్ ID ప్రత్యేకంగా ఉంటుంది. అనేక కాపీలను ప్రారంభించిన తరువాత, మేము ఆసక్తికరమైన ఫలితంపై పొరపాట్లు చేస్తాము: మొదటి సందర్భంలో, మీరు ఏమీ చేయకపోతే మరియు అనేక కాపీలను అమలు చేస్తే, చిరునామాలు భిన్నంగా ఉంటాయి. అయితే ఇది మన సిద్ధాంతం కిందకు రాదు! ఆధునిక పంపిణీలు డిఫాల్ట్‌గా మెమరీ రాండమైజేషన్ ప్రారంభించబడినందున సరైనది. ఇది నిలిపివేయబడితే, మేము ఆశించిన ఫలితాన్ని పొందుతాము - ఏకకాలంలో నడుస్తున్న రెండు ప్రోగ్రామ్‌ల మెమరీ చిరునామాలు సరిపోతాయి.

ఫలితంగా, రెండు స్వతంత్ర ప్రోగ్రామ్‌లు తమ స్వంత ప్రైవేట్ అడ్రస్ స్పేస్‌లతో పనిచేస్తాయని తేలింది, అవి ఫిజికల్ మెమరీలో ఆపరేటింగ్ సిస్టమ్ ద్వారా మ్యాప్ చేయబడతాయి.. అందువల్ల, ఒక ప్రోగ్రామ్‌లోని మెమరీ చిరునామాల ఉపయోగం ఇతరులను ఏ విధంగానూ ప్రభావితం చేయదు మరియు ప్రతి ప్రోగ్రామ్‌కు దాని స్వంత భౌతిక మెమరీని కలిగి ఉన్నట్లు అనిపిస్తుంది, దానికి పూర్తిగా ఇవ్వబడింది. అయితే వాస్తవికత ఏమిటంటే, ఫిజికల్ మెమరీ అనేది ఆపరేటింగ్ సిస్టమ్ ద్వారా నిర్వహించబడే భాగస్వామ్య వనరు.

స్థిరత్వం

ఆపరేటింగ్ సిస్టమ్స్‌లోని మరో ముఖ్యమైన అంశం -- స్థిరత్వం. ఒకే ప్రోగ్రామ్‌లో ఒకే సమయంలో అనేక విషయాలతో పనిచేసేటప్పుడు సంభవించే సిస్టమ్‌లోని సమస్యల గురించి మాట్లాడేటప్పుడు ఈ పదం ఉపయోగించబడుతుంది. ఆపరేటింగ్ సిస్టమ్‌లోనే స్థిరత్వ సమస్యలు తలెత్తుతాయి. మునుపటి మెమరీ మరియు ప్రాసెసర్ వర్చువలైజేషన్ ఉదాహరణలలో, OS ఒకే సమయంలో అనేక విషయాలను నిర్వహిస్తుందని మేము గ్రహించాము - ఇది మొదటి ప్రక్రియను ప్రారంభిస్తుంది, తరువాత రెండవది మరియు మొదలైనవి. ఇది ముగిసినట్లుగా, ఈ ప్రవర్తన కొన్ని సమస్యలకు దారి తీస్తుంది. కాబట్టి, ఉదాహరణకు, ఆధునిక బహుళ-థ్రెడ్ ప్రోగ్రామ్‌లు అటువంటి ఇబ్బందులను అనుభవిస్తాయి.

కింది ప్రోగ్రామ్‌ను పరిగణించండి:

ప్రధాన ఫంక్షన్‌లోని ప్రోగ్రామ్ కాల్‌ని ఉపయోగించి రెండు థ్రెడ్‌లను సృష్టిస్తుంది pthread_create(). ఈ ఉదాహరణలో, థ్రెడ్‌ని ఇతర ఫంక్షన్‌లతో పాటు అదే మెమరీ స్థలంలో నడుస్తున్న ఫంక్షన్‌గా భావించవచ్చు, అదే సమయంలో ఒకటి కంటే ఎక్కువ ఫంక్షన్‌లు స్పష్టంగా నడుస్తాయి. ఈ ఉదాహరణలో, ప్రతి థ్రెడ్ ఫంక్షన్‌ను ప్రారంభిస్తుంది మరియు అమలు చేస్తుంది worker() ఇది కేవలం వేరియబుల్‌ను పెంచుతుంది,.

ఈ ప్రోగ్రామ్‌ను 1000 ఆర్గ్యుమెంట్‌తో రన్ చేద్దాం. మీరు ఊహించినట్లుగా, ప్రతి థ్రెడ్ వేరియబుల్‌ని 2000 సార్లు పెంచినందున ఫలితం 1000 అయి ఉండాలి. అయితే, ప్రతిదీ చాలా సులభం కాదు. మరింత పునరావృతాల పరిమాణంతో ప్రోగ్రామ్‌ను అమలు చేయడానికి ప్రయత్నిద్దాం.

ఒక సంఖ్యను ఇన్‌పుట్ చేయడం ద్వారా, ఉదాహరణకు, 100000, అవుట్‌పుట్‌ను 200000 సంఖ్యగా చూడాలని మేము ఆశిస్తున్నాము. అయితే, మనం 100000 సంఖ్యను చాలాసార్లు అమలు చేస్తే, మనకు సరైన సమాధానం కనిపించడమే కాకుండా, వేర్వేరు తప్పు సమాధానాలు కూడా వస్తాయి. సంఖ్యను పెంచడానికి, మూడు ఆపరేషన్లు అవసరం అనే వాస్తవంలో సమాధానం ఉంది - మెమరీ నుండి సంఖ్యను సంగ్రహించడం, పెంచడం, ఆపై సంఖ్యను తిరిగి వ్రాయడం. ఈ సూచనలన్నీ పరమాణుపరంగా అమలు చేయబడనందున (అన్నీ ఒకే సమయంలో), ఇలాంటి వింతలు జరగవచ్చు. ఈ సమస్యను ప్రోగ్రామింగ్‌లో అంటారు జాతి పరిస్థితి. తెలియని సమయంలో తెలియని శక్తులు మీ కార్యకలాపాల్లో దేనినైనా ప్రభావితం చేయగలవు.

మూలం: www.habr.com