பைதான் மல்டிபிராசசிங் ஃபார்-லூப்

மல்டிபிராசசிங் என்பது மல்டித்ரெடிங்குடன் ஒப்பிடத்தக்கது. இருப்பினும், த்ரெடிங்கிற்குப் பயன்படுத்தப்படும் ஜிஐஎல் காரணமாக ஒரு நொடியில் ஒரு நூலை மட்டுமே இயக்க முடியும் என்பதில் இது வேறுபடுகிறது. மல்டிபிராசசிங்  என்பது பல CPU கோர்களில் தொடர்ச்சியாக செயல்பாடுகளைச் செய்யும் செயல்முறையாகும். இழைகளை இணையாக இயக்க முடியாது. இருப்பினும், பல்வேறு செயலாக்கமானது செயல்முறைகளை நிறுவி, பல்வேறு CPU கோர்களில் ஒரே நேரத்தில் இயக்க அனுமதிக்கிறது. லூப், ஃபார்-லூப் போன்றவை பெரும்பாலும் பயன்படுத்தப்படும் ஸ்கிரிப்டிங் மொழிகளில் ஒன்றாகும். முன்னரே தீர்மானிக்கப்பட்ட எண்ணிக்கையிலான மறு செய்கைகள் போன்ற ஒரு அளவுகோலை அடையும் வரை, பல்வேறு தரவைப் பயன்படுத்தி அதே வேலையை மீண்டும் செய்யவும். லூப் ஒவ்வொரு மறு செய்கையையும் ஒவ்வொன்றாக நிறைவேற்றுகிறது.

எடுத்துக்காட்டு 1:  பைதான் மல்டிபிராசசிங் தொகுதியில் ஃபார்-லூப்பைப் பயன்படுத்துதல்

இந்த எடுத்துக்காட்டில், for-loop மற்றும் Python multiprocessing module class செயல்முறையைப் பயன்படுத்துகிறோம். பைதான் மல்டிபிராசஸிங் ஃபார்-லூப் எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் விரைவாகப் புரிந்துகொள்ள, நாங்கள் மிகவும் நேரடியான உதாரணத்துடன் தொடங்குகிறோம். த்ரெடிங் தொகுதியுடன் ஒப்பிடக்கூடிய இடைமுகத்தைப் பயன்படுத்தி, மல்டிபிராசசிங் செயல்முறைகளை உருவாக்குகிறது.

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

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

அடுத்து, 'func' எனப்படும் பயனர் வரையறுக்கப்பட்ட செயல்பாட்டை வரையறுக்கிறோம். இது ஒரு பயனரால் வரையறுக்கப்பட்ட செயல்பாடு என்பதால், நாங்கள் அதற்கு எங்கள் விருப்பப்படி ஒரு பெயரை வழங்குகிறோம். இந்த செயல்பாட்டின் உடலின் உள்ளே, 'பொருள்' மாறியை ஒரு வாதம் மற்றும் 'கணிதம்' மதிப்பாக அனுப்புகிறோம். அடுத்து, 'அச்சு()' செயல்பாட்டை அழைக்கிறோம், 'பொதுவான பொருளின் பெயர்' மற்றும் மதிப்பைக் கொண்ட அதன் 'பொருள்' வாதத்தை கடந்து. பின்னர், பின்வரும் கட்டத்தில், 'if name== _main_' ஐப் பயன்படுத்துகிறோம், இது கோப்பு ஒரு தொகுதியாக இறக்குமதி செய்யப்படும் போது குறியீட்டை இயக்குவதைத் தடுக்கிறது மற்றும் உள்ளடக்கம் ஸ்கிரிப்டாக செயல்படுத்தப்படும்போது மட்டுமே அவ்வாறு செய்ய உங்களை அனுமதிக்கிறது.

நீங்கள் தொடங்கும் நிபந்தனைப் பிரிவு பெரும்பாலான சூழ்நிலைகளில் உங்கள் கோப்பு ஸ்கிரிப்டாக இயங்கும் போது மட்டுமே செயல்படுத்தப்பட வேண்டிய உள்ளடக்கத்தை வழங்குவதற்கான இடமாக கருதப்படலாம். பின்னர், நாங்கள் வாதப் பொருளைப் பயன்படுத்துகிறோம் மற்றும் அதில் 'அறிவியல்', 'ஆங்கிலம்' மற்றும் 'கணினி' போன்ற சில மதிப்புகளை சேமித்து வைக்கிறோம். செயல்முறைக்கு பின்வரும் படிநிலையில் 'செயல்முறை1[]' என்ற பெயர் வழங்கப்படுகிறது. பின்னர், செயல்பாட்டில் உள்ள செயல்பாட்டை அழைக்க 'செயல்முறை(இலக்கு=func)' ஐப் பயன்படுத்துகிறோம். செயல்பாட்டை அழைக்க இலக்கு பயன்படுத்தப்படுகிறது, மேலும் இந்த செயல்முறையை 'P' மாறியில் சேமிக்கிறோம்.

அடுத்து, 'func' செயல்பாட்டில் இருக்கும் பட்டியலின் முடிவில் ஒரு உருப்படியைச் சேர்க்கும் 'append()' செயல்பாட்டை அழைக்க 'process1' ஐப் பயன்படுத்துகிறோம். செயல்முறை 'P' மாறியில் சேமிக்கப்படுவதால், இந்த செயல்பாட்டிற்கு 'P' ஐ அதன் வாதமாக அனுப்புகிறோம். இறுதியாக, செயல்முறையைத் தொடங்க 'P' உடன் 'start()' செயல்பாட்டைப் பயன்படுத்துகிறோம். அதன் பிறகு, 'பொருள்' வாதத்தை வழங்கும்போது மீண்டும் முறையை இயக்குகிறோம் மற்றும் பாடத்தில் 'for' ஐப் பயன்படுத்துகிறோம். பின்னர், 'செயல்முறை1' மற்றும் 'சேர் ()' முறையைப் பயன்படுத்தி, நாங்கள் செயல்முறையைத் தொடங்குகிறோம். செயல்முறை இயங்குகிறது மற்றும் வெளியீடு திரும்பும். செயல்முறை பின்னர் 'சேர் ()' நுட்பத்தைப் பயன்படுத்தி முடிக்கச் சொல்லப்படுகிறது. “சேர் ()” செயல்முறையை அழைக்காத செயல்முறைகள் வெளியேறாது. ஒரு முக்கியமான விஷயம் என்னவென்றால், செயல்முறையின் மூலம் நீங்கள் ஏதேனும் வாதங்களை வழங்க விரும்பினால், 'args' முக்கிய அளவுரு பயன்படுத்தப்பட வேண்டும்.

இப்போது, ​​'func' செயல்பாட்டிற்குள் நாம் அனுப்பும் 'கணிதம்' பாடத்திற்கான மதிப்பை அனுப்புவதன் மூலம் அறிக்கை முதலில் காட்டப்படுவதை வெளியீட்டில் காணலாம், ஏனெனில் அதை முதலில் 'செயல்முறை' செயல்பாட்டைப் பயன்படுத்தி அழைக்கிறோம். பின்னர், முடிவில் சேர்க்கப்படும் பட்டியலில் ஏற்கனவே இருந்த மதிப்புகளைக் கொண்டிருக்க “append()” கட்டளையைப் பயன்படுத்துகிறோம். பின்னர், 'அறிவியல்', 'கணினி', 'ஆங்கிலம்' ஆகியவை வழங்கப்பட்டன. ஆனால், நீங்கள் பார்க்க முடியும் என, மதிப்புகள் சரியான வரிசையில் இல்லை. ஏனென்றால், செயல்முறை முடிந்தவுடன் அவர்கள் விரைவாகச் செய்து தங்கள் செய்தியைப் புகாரளிக்கின்றனர்.

எடுத்துக்காட்டு 2: வரிசைக்கான லூப்பை மல்டிபிராசஸிங் பேரலல் ஃபார்-லூப்பாக மாற்றுதல்

இந்த எடுத்துக்காட்டில், மல்டிபிராசசிங் லூப் பணியானது இணையான ஃபார்-லூப் பணியாக மாற்றப்படுவதற்கு முன் தொடர்ச்சியாக செயல்படுத்தப்படுகிறது. for-loops ஐப் பயன்படுத்தி அவை நிகழும் வரிசையில் சேகரிப்பு அல்லது சரம் போன்ற வரிசைகளை நீங்கள் சுழற்சி செய்யலாம்.

இப்போது, ​​குறியீட்டை செயல்படுத்த ஆரம்பிக்கலாம். முதலில், நேர தொகுதியிலிருந்து 'தூக்கத்தை' இறக்குமதி செய்கிறோம். நேரத் தொகுதியில் உள்ள “ஸ்லீப்()” நடைமுறையைப் பயன்படுத்தி, நீங்கள் விரும்பும் வரை அழைப்புத் தொடரை இயக்குவதை இடைநிறுத்தலாம். பின்னர், சீரற்ற தொகுதியிலிருந்து 'ரேண்டம்' ஐப் பயன்படுத்துகிறோம், 'func' என்ற பெயருடன் ஒரு செயல்பாட்டை வரையறுக்கிறோம், மேலும் 'argu' என்ற முக்கிய சொல்லை அனுப்புகிறோம். பின்னர், “val” ஐப் பயன்படுத்தி ஒரு சீரற்ற மதிப்பை உருவாக்கி, அதை “ரேண்டம்” என அமைக்கிறோம். பின்னர், “ஸ்லீப்()” முறையைப் பயன்படுத்தி சிறிது காலத்திற்குத் தடுத்து, “val” ஐ அளவுருவாக அனுப்புவோம். பின்னர், ஒரு செய்தியை அனுப்ப, நாங்கள் 'அச்சு ()' முறையை இயக்குகிறோம், 'தயார்' மற்றும் 'arg' என்ற முக்கிய வார்த்தைகளை அதன் அளவுருவாகக் கடந்து, 'உருவாக்கப்பட்ட' மற்றும் 'val' ஐப் பயன்படுத்தி மதிப்பை அனுப்புகிறோம்.

இறுதியாக, நாங்கள் 'ஃப்ளஷ்' ஐப் பயன்படுத்தி, அதை 'உண்மை' என அமைக்கிறோம். பைத்தானின் அச்சு செயல்பாட்டில் உள்ள ஃப்ளஷ் விருப்பத்தைப் பயன்படுத்தி வெளியீட்டை இடையகப்படுத்தலாமா வேண்டாமா என்பதை பயனர் தீர்மானிக்க முடியும். இந்த அளவுருவின் False இன் இயல்புநிலை மதிப்பு வெளியீடு இடையகப்படுத்தப்படாது என்பதைக் குறிக்கிறது. நீங்கள் அதை உண்மை என அமைத்தால், வெளியீடு ஒரு தொடர் வரிகளாக காட்டப்படும். பின்னர், நுழைவு புள்ளிகளைப் பாதுகாக்க “if name== main” ஐப் பயன்படுத்துகிறோம். அடுத்து, வேலையை வரிசையாகச் செய்கிறோம். இங்கே, வரம்பை '10' ஆக அமைத்துள்ளோம், அதாவது 10 மறு செய்கைகளுக்குப் பிறகு சுழற்சி முடிவடைகிறது. அடுத்து, 'print()' செயல்பாட்டை அழைக்கிறோம், அதை 'தயார்' உள்ளீட்டு அறிக்கையை அனுப்பவும், மேலும் 'flush=True' விருப்பத்தைப் பயன்படுத்தவும்.

நாம் குறியீட்டை இயக்கும் போது, ​​லூப் செயல்பாடு '10' முறை இயக்கப்படுவதை நீங்கள் இப்போது பார்க்கலாம். இது குறியீட்டு பூஜ்ஜியத்தில் தொடங்கி, குறியீட்டு ஒன்பதில் முடிவடையும், 10 முறை திரும்பும். ஒவ்வொரு செய்தியிலும் ஒரு பணி எண் உள்ளது, இது ஒரு செயல்பாட்டு எண்ணாகும், இது நாம் 'arg' மற்றும் உருவாக்க எண்ணாக அனுப்புகிறோம்.

இந்த தொடர் சுழற்சியானது இப்போது மல்டிபிராசசிங் பேரலல் ஃபார்-லூப்பாக மாற்றப்படுகிறது. நாங்கள் அதே குறியீட்டைப் பயன்படுத்துகிறோம், ஆனால் பல செயலாக்கத்திற்கான சில கூடுதல் நூலகங்கள் மற்றும் செயல்பாடுகளுக்குச் செல்கிறோம். எனவே, நாம் முன்பு விளக்கியது போல், மல்டிபிராசஸிங்கிலிருந்து செயல்முறையை இறக்குமதி செய்ய வேண்டும். அடுத்து, 'func' எனப்படும் ஒரு செயல்பாட்டை உருவாக்கி, ஒரு சீரற்ற எண்ணைப் பெற, 'val=random' ஐப் பயன்படுத்துவதற்கு முன், 'arg' என்ற முக்கிய சொல்லை அனுப்புவோம்.

பின்னர், ஒரு செய்தியைக் காட்ட “அச்சு()” முறையைத் தேர்ந்தெடுத்து, சிறிது நேரம் தாமதப்படுத்த “val” அளவுருவைக் கொடுத்த பிறகு, நுழைவு புள்ளிகளைப் பாதுகாக்க “if name= main” செயல்பாட்டைப் பயன்படுத்துகிறோம். அதன்பிறகு, நாம் ஒரு செயல்முறையை உருவாக்கி, செயல்பாட்டில் உள்ள செயல்பாட்டை 'செயல்முறை' பயன்படுத்தி அழைக்கிறோம் மற்றும் 'இலக்கு=func' ஐ அனுப்புகிறோம். பின்னர், 'func', 'arg' ஆகியவற்றைக் கடந்து, 'm' மதிப்பைக் கடந்து, '10' வரம்பைக் கடக்கிறோம், அதாவது '10' மறு செய்கைகளுக்குப் பிறகு லூப் செயல்பாட்டை நிறுத்துகிறது. பின்னர், 'செயல்முறை' உடன் 'தொடக்க ()' முறையைப் பயன்படுத்தி செயல்முறையைத் தொடங்குகிறோம். பின்னர், செயல்முறையை செயல்படுத்துவதற்கு காத்திருக்கவும், பின்னர் அனைத்து செயல்முறைகளையும் முடிக்கவும் 'சேர் ()' முறையை அழைக்கிறோம்.

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

முடிவுரை

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