இயக்க முறைமைகளுக்கான அறிமுகம்
ஹே ஹப்ர்! எனது கருத்தில் ஒரு சுவாரஸ்யமான இலக்கியத்தின் தொடர்ச்சியான கட்டுரைகள்-மொழிபெயர்ப்புகளை உங்கள் கவனத்திற்குக் கொண்டு வர விரும்புகிறேன் - OSTEP. இந்த பொருள் யுனிக்ஸ் போன்ற இயக்க முறைமைகளின் வேலையை மிகவும் ஆழமாக விவாதிக்கிறது, அதாவது, செயல்முறைகள், பல்வேறு திட்டமிடுபவர்கள், நினைவகம் மற்றும் நவீன OS ஐ உருவாக்கும் பிற ஒத்த கூறுகளுடன் வேலை செய்கிறது. அனைத்து பொருட்களின் அசல் தன்மையையும் இங்கே காணலாம் . மொழிபெயர்ப்பானது தொழில்சார்ந்த முறையில் (மிகவும் சுதந்திரமாக) செய்யப்பட்டது என்பதைக் கவனத்தில் கொள்ளவும், ஆனால் நான் பொதுவான அர்த்தத்தைத் தக்க வைத்துக் கொண்டேன் என்று நம்புகிறேன்.
இந்த விஷயத்தில் ஆய்வக வேலைகளை இங்கே காணலாம்:
மற்ற பாகங்கள்:
எனது சேனலையும் நீங்கள் பார்க்கலாம் =)
அலாரம்! இந்த விரிவுரைக்கு ஒரு ஆய்வகம் உள்ளது! பார்
செயல்முறை API
யுனிக்ஸ் அமைப்பில் ஒரு செயல்முறையை உருவாக்குவதற்கான உதாரணத்தைப் பார்ப்போம். இது இரண்டு கணினி அழைப்புகள் மூலம் நிகழ்கிறது முள் கரண்டி() и exec().
கால் ஃபோர்க்()
ஃபோர்க்() அழைப்பை உருவாக்கும் திட்டத்தைக் கவனியுங்கள். அதன் செயல்பாட்டின் முடிவு பின்வருமாறு இருக்கும்.
முதலில், முக்கிய () செயல்பாட்டை உள்ளிட்டு, சரத்தை திரையில் அச்சிடுகிறோம். வரியில் செயல்முறை அடையாளங்காட்டி உள்ளது, இது அசலில் அழைக்கப்படுகிறது என்பது PID அல்லது செயல்முறை அடையாளங்காட்டி. இந்த அடையாளங்காட்டி UNIX இல் ஒரு செயல்முறையைக் குறிக்கப் பயன்படுத்தப்படுகிறது. அடுத்த கட்டளை fork() ஐ அழைக்கும். இந்த கட்டத்தில், செயல்முறையின் கிட்டத்தட்ட சரியான நகல் உருவாக்கப்பட்டது. OS ஐப் பொறுத்தவரை, கணினியில் ஒரே நிரலின் 2 பிரதிகள் இயங்குவது போல் தெரிகிறது, இது ஃபோர்க்() செயல்பாட்டிலிருந்து வெளியேறும். புதிதாக உருவாக்கப்பட்ட குழந்தை செயல்முறை (அதை உருவாக்கிய பெற்றோர் செயல்முறை தொடர்பாக) இனி செயல்படுத்தப்படாது, இது முக்கிய() செயல்பாட்டிலிருந்து தொடங்குகிறது. குழந்தை செயல்முறை என்பது பெற்றோர் செயல்முறையின் சரியான நகல் அல்ல என்பதை நினைவில் கொள்ள வேண்டும்; குறிப்பாக, அதன் சொந்த முகவரி இடம், அதன் சொந்த பதிவேடுகள், இயங்கக்கூடிய வழிமுறைகளுக்கான அதன் சொந்த சுட்டிக்காட்டி மற்றும் பல. எனவே, ஃபோர்க்() செயல்பாட்டின் அழைப்பாளருக்குத் திரும்பிய மதிப்பு வேறுபட்டதாக இருக்கும். குறிப்பாக, பெற்றோர் செயல்முறை குழந்தை செயல்முறையின் PID மதிப்பை திரும்பப் பெறும், மேலும் குழந்தை 0 க்கு சமமான மதிப்பைப் பெறும். இந்த ரிட்டர்ன் குறியீடுகளைப் பயன்படுத்தி, நீங்கள் செயல்முறைகளைப் பிரித்து ஒவ்வொன்றையும் அதன் சொந்த வேலையைச் செய்யும்படி கட்டாயப்படுத்தலாம். . இருப்பினும், இந்த திட்டத்தை செயல்படுத்துவது கண்டிப்பாக வரையறுக்கப்படவில்லை. 2 செயல்முறைகளாகப் பிரித்த பிறகு, OS அவற்றைக் கண்காணிக்கத் தொடங்குகிறது, அத்துடன் அவற்றின் வேலையைத் திட்டமிடுகிறது. ஒற்றை மைய செயலியில் செயல்படுத்தப்பட்டால், செயல்முறைகளில் ஒன்று, இந்த விஷயத்தில் பெற்றோர் தொடர்ந்து செயல்படுவார்கள், பின்னர் குழந்தை செயல்முறை கட்டுப்பாட்டைப் பெறும். மறுதொடக்கம் செய்யும் போது, நிலைமை வேறுபட்டிருக்கலாம்.
அழைப்பு காத்திரு()
பின்வரும் திட்டத்தை கவனியுங்கள். இந்த திட்டத்தில், அழைப்பு இருப்பதால் காத்திரு() குழந்தை செயல்முறை முடிவடையும் வரை பெற்றோர் செயல்முறை எப்போதும் காத்திருக்கும். இந்த வழக்கில், திரையில் கண்டிப்பாக வரையறுக்கப்பட்ட உரை வெளியீட்டைப் பெறுவோம்
exec() அழைப்பு
சவாலைக் கருத்தில் கொள்ளுங்கள் exec(). முற்றிலும் மாறுபட்ட நிரலை இயக்க விரும்பும்போது இந்த கணினி அழைப்பு பயனுள்ளதாக இருக்கும். இங்கே நாம் அழைப்போம் execvp() வார்த்தை எண்ணும் நிரலான wc நிரலை இயக்க. exec() எனப்படும் போது என்ன நடக்கும்? இந்த அழைப்பு இயங்கக்கூடிய கோப்பின் பெயர் மற்றும் சில அளவுருக்கள் வாதங்களாக அனுப்பப்படுகிறது. அதன் பிறகு இந்த இயங்கக்கூடிய கோப்பிலிருந்து குறியீடு மற்றும் நிலையான தரவு ஏற்றப்பட்டு, குறியீட்டுடன் அதன் சொந்தப் பிரிவு மேலெழுதப்படும். ஸ்டாக் மற்றும் ஹீப் போன்ற மீதமுள்ள நினைவக பகுதிகள் மீண்டும் தொடங்கப்படுகின்றன. அதன் பிறகு, OS நிரலை இயக்கி, வாதங்களின் தொகுப்பை அனுப்புகிறது. எனவே நாங்கள் புதிய செயல்முறையை உருவாக்கவில்லை, தற்போது இயங்கும் நிரலை மற்றொரு இயங்கும் நிரலாக மாற்றியுள்ளோம். descendant இல் exec() அழைப்பை இயக்கிய பிறகு, அசல் நிரல் இயங்கவில்லை என்பது போல் தோன்றும்.
யூனிக்ஸ் ஷெல்லுக்கு இந்த ஸ்டார்ட்அப் சிக்கல் முற்றிலும் இயல்பானது, மேலும் அந்த ஷெல் அழைத்த பிறகு குறியீட்டை இயக்க அனுமதிக்கிறது முள் கரண்டி(), ஆனால் அழைப்புக்கு முன் exec(). அத்தகைய குறியீட்டின் உதாரணம், அதைத் தொடங்குவதற்கு முன், தொடங்கப்படும் நிரலின் தேவைகளுக்கு ஏற்ப ஷெல் சூழலை சரிசெய்வதாகும்.
ஓடு - ஒரு பயனர் நிரல். அவள் உங்களுக்கு அழைப்பிதழைக் காட்டி, அதில் ஏதாவது எழுதுவதற்காக காத்திருக்கிறாள். பெரும்பாலான சந்தர்ப்பங்களில், நீங்கள் ஒரு நிரலின் பெயரை அங்கு எழுதினால், ஷெல் அதன் இருப்பிடத்தைக் கண்டுபிடித்து, ஃபோர்க்() முறையை அழைக்கும், பின்னர் ஒரு புதிய செயல்முறையை உருவாக்க சில வகையான exec() ஐ அழைக்கும் மற்றும் அதை பயன்படுத்தி முடிவடையும் வரை காத்திருக்கும் காத்திருக்க () அழைப்பு. குழந்தை செயல்முறை வெளியேறும் போது, ஷெல் காத்திருப்பு() அழைப்பிலிருந்து திரும்பும் மற்றும் வரியில் மீண்டும் அச்சிட்டு அடுத்த கட்டளை உள்ளிடப்படும் வரை காத்திருக்கும்.
ஃபோர்க்() & exec() பிளவு ஷெல் பின்வரும் விஷயங்களைச் செய்ய அனுமதிக்கிறது, எடுத்துக்காட்டாக:
wc கோப்பு > new_file.
இந்த எடுத்துக்காட்டில், wc நிரலின் வெளியீடு ஒரு கோப்பிற்கு திருப்பி விடப்படுகிறது. ஷெல் இதை அடைவதற்கான வழி மிகவும் எளிமையானது - அழைப்பதற்கு முன் ஒரு குழந்தை செயல்முறையை உருவாக்குவதன் மூலம் exec(), ஷெல் நிலையான வெளியீட்டை மூடிவிட்டு கோப்பை திறக்கிறது புதிய_கோப்பு, இதனால், மேலும் இயங்கும் நிரலிலிருந்து அனைத்து வெளியீடுகளும் wc திரைக்குப் பதிலாக ஒரு கோப்பிற்கு திருப்பி விடப்படும்.
யூனிக்ஸ் குழாய் பைப்() அழைப்பைப் பயன்படுத்தும் வித்தியாசத்துடன், அதே வழியில் செயல்படுத்தப்படுகின்றன. இந்த வழக்கில், செயல்முறையின் வெளியீட்டு ஸ்ட்ரீம் கர்னலில் அமைந்துள்ள குழாய் வரிசையில் இணைக்கப்படும், மற்றொரு செயல்முறையின் உள்ளீட்டு ஸ்ட்ரீம் இணைக்கப்படும்.
ஆதாரம்: www.habr.com