இயக்க முறைமைகளுக்கான அறிமுகம்

வணக்கம், ஹப்ர்! எனது கருத்தில் சுவாரஸ்யமான ஒரு இலக்கியத்தின் தொடர்ச்சியான கட்டுரைகள்-மொழிபெயர்ப்புகளை உங்கள் கவனத்திற்கு முன்வைக்க விரும்புகிறேன் - OSTEP. இந்த பொருள் யுனிக்ஸ் போன்ற இயக்க முறைமைகளின் வேலையை மிகவும் ஆழமாக ஆராய்கிறது, அதாவது, செயல்முறைகள், பல்வேறு திட்டமிடுபவர்கள், நினைவகம் மற்றும் நவீன 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 ஒரு இயற்பியல் வளத்துடன் (செயலி, நினைவகம், வட்டு, முதலியன) தொடர்பு கொள்கிறது மற்றும் அதை மிகவும் பொதுவான, மிகவும் சக்திவாய்ந்த மற்றும் பயன்படுத்த எளிதான வடிவமாக மாற்றுகிறது. எனவே, ஒரு பொதுவான புரிதலுக்காக, நீங்கள் ஒரு மெய்நிகர் இயந்திரத்துடன் இயக்க முறைமையை மிகவும் தோராயமாக ஒப்பிடலாம்.
பயனர்கள் இயக்க முறைமைக்கு கட்டளைகளை வழங்குவதற்கும், மெய்நிகர் இயந்திரத்தின் திறன்களைப் பயன்படுத்துவதற்கும் (ஒரு நிரலை இயக்குதல், நினைவகத்தை ஒதுக்கீடு செய்தல், ஒரு கோப்பை அணுகுதல் மற்றும் பல), இயக்க முறைமை சில இடைமுகங்களை வழங்குகிறது ஏபிஐ (பயன்பாட்டு நிரலாக்க இடைமுகம்) மற்றும் நீங்கள் அழைப்புகளை மேற்கொள்ளலாம் (அழைப்பு). ஒரு பொதுவான இயங்குதளம் நூற்றுக்கணக்கான கணினி அழைப்புகளைச் செய்ய அனுமதிக்கிறது.
இறுதியாக, மெய்நிகராக்கம் பல நிரல்களை இயக்க அனுமதிக்கிறது (இதனால் 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" மாறியில் உள்ள முகவரியில் நினைவகத்தில் சேமிக்கப்பட்ட மதிப்பை அதிகரிக்கிறது. இது தானே செயல்முறை ஐடியையும் அச்சிடுகிறது. ஒவ்வொரு இயங்கும் செயல்முறைக்கும் செயல்முறை ஐடி தனித்துவமானது. பல நகல்களை அறிமுகப்படுத்திய பிறகு, ஒரு சுவாரஸ்யமான முடிவில் நாங்கள் தடுமாறுவோம்: முதல் வழக்கில், நீங்கள் ஒன்றும் செய்யாமல் பல நகல்களை இயக்கினால், முகவரிகள் வித்தியாசமாக இருக்கும். ஆனால் இது எங்கள் கோட்பாட்டின் கீழ் வராது! சரி, ஏனெனில் நவீன விநியோகங்களில் நினைவக ரேண்டமைசேஷன் இயல்பாகவே இயக்கப்பட்டது. இது முடக்கப்பட்டிருந்தால், எதிர்பார்த்த முடிவைப் பெறுவோம் - ஒரே நேரத்தில் இயங்கும் இரண்டு நிரல்களின் நினைவக முகவரிகள் பொருந்தும்.

இதன் விளைவாக, இரண்டு சுயாதீன நிரல்கள் அவற்றின் சொந்த தனிப்பட்ட முகவரி இடைவெளிகளுடன் செயல்படுகின்றன, அவை இயற்பியல் நினைவகத்தில் இயக்க முறைமையால் வரைபடமாக்கப்படுகின்றன.. எனவே, ஒரு நிரலுக்குள் நினைவக முகவரிகளைப் பயன்படுத்துவது மற்றவர்களை எந்த வகையிலும் பாதிக்காது, மேலும் ஒவ்வொரு நிரலுக்கும் அதன் சொந்த இயற்பியல் நினைவகம் உள்ளது, அது முற்றிலும் கொடுக்கப்பட்டுள்ளது. இருப்பினும், உண்மை என்னவென்றால், இயற்பியல் நினைவகம் என்பது இயக்க முறைமையால் நிர்வகிக்கப்படும் பகிரப்பட்ட வளமாகும்.

நிலைத்தன்மையும்

இயக்க முறைமைகளில் உள்ள முக்கியமான தலைப்புகளில் மற்றொன்று - நிலைத்தன்மையும். ஒரே நிரலுக்குள் ஒரே நேரத்தில் பல விஷயங்களுடன் பணிபுரியும் போது ஏற்படும் கணினியில் ஏற்படும் சிக்கல்களைப் பற்றி பேசும்போது இந்த சொல் பயன்படுத்தப்படுகிறது. இயக்க முறைமையில் கூட நிலைத்தன்மை சிக்கல்கள் எழுகின்றன. முந்தைய நினைவகம் மற்றும் செயலி மெய்நிகராக்க எடுத்துக்காட்டுகளில், OS ஒரே நேரத்தில் பல விஷயங்களை நிர்வகிக்கிறது என்பதை நாங்கள் உணர்ந்தோம் - இது முதல் செயல்முறையைத் தொடங்குகிறது, பின்னர் இரண்டாவது, மற்றும் பல. அது மாறியது போல், இந்த நடத்தை சில சிக்கல்களுக்கு வழிவகுக்கும். எனவே, எடுத்துக்காட்டாக, நவீன பல-திரிக்கப்பட்ட திட்டங்கள் இத்தகைய சிரமங்களை அனுபவிக்கின்றன.

பின்வரும் திட்டத்தைக் கவனியுங்கள்:

முக்கிய செயல்பாட்டில் உள்ள நிரல் அழைப்பைப் பயன்படுத்தி இரண்டு நூல்களை உருவாக்குகிறது pthread_create(). இந்த எடுத்துக்காட்டில், ஒரு நூல் மற்ற செயல்பாடுகளுடன் ஒரே நினைவகத்தில் இயங்கும் ஒரு செயல்பாடாகக் கருதப்படலாம், அதே நேரத்தில் ஒன்றுக்கும் மேற்பட்ட செயல்பாடுகள் தெளிவாக இயங்குகின்றன. இந்த எடுத்துக்காட்டில், ஒவ்வொரு நூலும் செயல்பாட்டைத் தொடங்கி செயல்படுத்துகிறது worker() இது மாறியை எளிமையாக அதிகரிக்கிறது,.

இந்த நிரலை 1000 வாதத்துடன் இயக்குவோம். நீங்கள் யூகித்தபடி, ஒவ்வொரு திரியும் மாறியை 2000 மடங்கு அதிகரிப்பதால், முடிவு 1000 ஆக இருக்க வேண்டும். இருப்பினும், எல்லாம் அவ்வளவு எளிதல்ல. நிரலை அதிக அளவு மீண்டும் மீண்டும் செய்ய முயற்சிப்போம்.

உதாரணமாக, 100000 என்ற எண்ணை உள்ளீடு செய்வதன் மூலம், அவுட்புட்டை 200000 என்ற எண்ணாகப் பார்க்கலாம். இருப்பினும், 100000 என்ற எண்ணை பலமுறை இயக்கினால், சரியான பதிலைப் பார்ப்பது மட்டுமல்லாமல், வெவ்வேறு தவறான பதில்களையும் பெறுவோம். எண்ணை அதிகரிக்க, மூன்று செயல்பாடுகள் தேவை என்பதில் பதில் உள்ளது - நினைவகத்திலிருந்து எண்ணைப் பிரித்தெடுத்தல், அதிகரிப்பு, பின்னர் எண்ணை மீண்டும் எழுதுதல். இந்த அறிவுறுத்தல்கள் அனைத்தும் அணுக்கருவாக (அனைத்தும் ஒரே நேரத்தில்) செயல்படுத்தப்படாததால், இது போன்ற விசித்திரமான விஷயங்கள் நடக்கலாம். இந்த சிக்கல் நிரலாக்கத்தில் அழைக்கப்படுகிறது இனம் நிலை. அறியப்படாத தருணத்தில் தெரியாத சக்திகள் உங்கள் செயல்பாட்டின் செயல்திறனை பாதிக்கலாம்.

ஆதாரம்: www.habr.com