பெரும்பாலான நிரல்கள் அல்லது செயலிகள் ஒற்றைஇழையைக் (single-threaded) கொண்டவையாகவே இருக்கின்றன. பலவிழைகளைக் (multi-threaded) கொண்ட நிரல்களில், இவ்விழைகள், ஒருகோப்பினை அணுகவோ, இணையத்திற்காகவோ காத்திருப்பதிலேயே நேரத்தை செலவழிக்கின்றன.
இயல்பாகவே மனிதமூளை தான்செய்யவேண்டிய செயல்களை ஒன்றன்பின் ஒன்றாக செய்யவே திட்டமிடுகிறது. நம் எல்லோருக்கும் பரிச்சயமான சுவையானவொரு ரொட்டி தயாரிக்கும் எடுத்துக்காட்டுடன் இதைப்புரிந்துகொள்ளலாம். இதற்கான படிநிலைகள்:
[code lang=”javascript”]
ரொட்டியை எடுக்கவேண்டும்.
இருதுண்டுகளை வாட்டுவதற்கான சாதனத்தில் இடவேண்டும்.
வாட்டுமளவைத் தெரிவுசெய்யவேண்டும்.
வாட்டுவதைத்தொடங்குவதற்கான பொத்தானை அழுத்தவேண்டும்.
வாட்டப்பட்ட ரொட்டி குதித்துவரும்வரை பொறுத்திருக்கவேண்டும்.
ரொட்டித்துண்டுகளை வெளியிலெடுக்கவேண்டும்.
வெண்ணெயை வெளியிலெடுக்கவேண்டும்.
வெண்ணெயைத் தேய்ப்பதற்கான கத்தியையெடுக்கவேண்டும்.
ரொட்டியில் வெண்ணெய் தடவவேண்டும்.
[/code]
இவ்வெடுத்துக்காட்டில் ஒன்றையொன்று சாராத இருவேறு வேலைகள் உள்ளன: ரொட்டியை வாட்டுவதற்கான வேலைகள், வெண்ணெய் தடவுவதற்கான வேலைகள்.
இப்படிநிலையின் முதல் ஆறு படிகளைச்செய்யும் நேரத்தில், 7 மற்றும் 8ம் படிகளையும் செய்துமுடித்துவிடலாம். 1-6 மற்றும் 7-8 ஆகியன ஒன்றையொன்று சாராத படிநிலைகள்.
ஆனால், இதைச்செயல்படுத்தத்தொடங்கும்போது தான் சிக்கலும் தொடங்குகிறது.
முதலாம் இழை:
[code lang=”javascript”]
ரொட்டியை எடுக்கவேண்டும்.
இருதுண்டுகளை வாட்டுவதற்கான சாதனத்தில் இடவேண்டும்.
வாட்டுமளவைத் தெரிவுசெய்யவேண்டும்.
வாட்டுவதைத்தொடங்குவதற்கான பொத்தானை அழுத்தவேண்டும்.
வாட்டப்பட்ட ரொட்டி குதித்துவரும்வரை பொறுத்திருக்கவேண்டும்.
ரொட்டித்துண்டுகளை வெளியிலெடுக்கவேண்டும்.
[/code]
இரண்டாம் இழை:
[code lang=”javascript”]
வெண்ணெயை வெளியிலெடுக்கவேண்டும்.
வெண்ணெயைத் தேய்ப்பதற்கான கத்தியையெடுக்கவேண்டும்.
முதலாம் இழை தன் வேலையை முடிக்கும்வரை காத்திருக்கவேண்டும்.
ரொட்டியில் வெண்ணெய் தடவவேண்டும்.
[/code]
இங்கே நமக்குப்பலகேள்விகள் உதிக்கின்றன.
- முதலாம் இழை வெற்றிகரமாக முடியவில்லையெனில், இரண்டாம் இழையின் நிலையென்ன?
- இவ்விரு இழைகளையும் எவ்வாறு ஒருங்கிணைப்பது?
- வெண்ணெய்தடவிய ரொட்டியைத்தயாரித்தது யார்? முதலிழையா? இரண்டாமிழையா? இரண்டுமா?
இதுபோன்ற சிக்கல்களுக்குள் சிக்கிக்கொள்ளாமல், ஒற்றைஇழைகொண்டதாகவே நமது நிரலையெழுதுவது எளிதானகாரியம். ஆனால், நமது நிரலின் இயக்குதிறனை அதிகரிக்கவேண்டுமானால், நாம் பல்லிழையாக்கத்தைக் கையாளுவதைத்தவிர வேறுவழியில்லை.
பல்லிழையாக்கத்தில் இருமுக்கிய பிரச்சனைகள் உள்ளன.
- பல்லிழையாக்க நிரலை எழுதுவதும், படிப்பதும், சோதிப்பதும், வழுக்களைக்கண்டறிந்து திருத்துவதும் சவாலான காரியம்.
- பலமொழிகளில் பல்லிழையாக்கத்திற்கான ஆதரவு இருப்பதில்லை. ஆதரவிருக்கும் மொழிகளில் மிகமோசமாக செயல்படுத்தப்பட்டுள்ளன.
ஒருவேளை, இயங்குவரிசை (order of execution) முக்கியமில்லாதபோது, அனைத்து செயல்களும் ஒரேநேரத்தில் இணையாக செய்யப்பட்டால், எப்படியிருக்கும்?
இதைக்கேட்பதற்கு கேலியாக இருந்தாலும், செயல்படுத்தும்போது அதிக குழப்பத்தைத் தருவதில்லை. எல்ம் மொழியில் ஓர் எடுத்துக்காட்டுடன் இதைப்புரிந்துகொள்ளலாம்.
[code lang=”ruby”]
buildMessage message value =
let
upperMessage =
String.toUpper message
quotedValue =
"’" ++ value ++ "’"
in
upperMessage ++ ": " ++ quotedValue
[/code]
இங்கே, buildMessage என்ற செயற்கூறு message, value என்ற இரு உருபுகளை ஏற்கிறது. இச்செயற்கூறு, கொடுக்கப்பட்ட messageஐ ஆங்கிலத்தின் பெரியஎழுத்துகளில் மாற்றி, “:” குறியீட்டைச்சேர்த்து, கொடுக்கப்பட்ட valueஐ ஒற்றைமேற்கோள்குறிக்குள் அடைத்து, ஒருசெய்தியைக் கட்டமைத்துத்தருகிறது.
இங்கே upperMessage, quotedValueஆகியன ஒன்றுக்கொன்று சம்பந்தமில்லாத, ஒன்றையொன்று சாராத செயற்கூறுகள். ஒன்றையொன்று சாராத செயற்கூறுகளை அடையாளம்காண, இருமுக்கியவிதிகளைப் பயன்படுத்தவேண்டும்.
- ஒருசெயற்கூற்றின் விடையை, மற்றொரு செயற்கூற்றுக்கு உள்ளீடாகக்கொடுத்தால் அவை ஒன்றையொன்று சார்ந்திருக்கின்றன. முதல்செயற்கூற்றினை இயக்கிமுடித்தபின்னரே இரண்டாம்செயற்கூற்றை இயக்கமுடியும். சாராச்செயற்கூறுகளில், ஒருசெயற்கூற்றின் விடையை, மற்றொரு செயற்கூறு உள்ளீடாகப்பெறக்கூடாது.
- சாராச்செயற்கூறுகள், தூயசெயற்கூறுகளாக இருக்கவேண்டும். தூயசெயற்கூறுகளாக இல்லாதபட்சத்தில் அவற்றின் சாராத்தன்மையை நம்மால் ஊகிக்கமுடியாது. இதனாலேயே, பிறமொழிகளில் இயங்குவரிசை முக்கியத்துவம் பெறுகிறது.
நமது எடுத்துக்காட்டில், upperMessage, quotedValue என்ற இருசெயற்கூறுகளும் தூயசெயற்கூறுகளாகவும், ஒன்றன்வெளியீட்டை மற்றது உள்ளீடாக ஏற்காமலும் உள்ளதால் இவை ஒன்றையொன்று சாராச்செயற்கூறுகளாகின்றன.
எனவே இவற்றை எந்தவரிசையில் இயக்கினாலும், நாம் எதிர்பார்த்த பலனைப்பெறமுடியும்.
செயற்கூறிய நிரலாக்கமொழிகளில், இதுபோன்ற சாராச்செயற்கூறுகளின் இயக்கவரிசையை, நிரல்பெயர்ப்பியால், நிரலர்களின் துணையின்றி, நிச்சயிக்கமுடியும்.
CPUக்களின் வேகத்தில் அதிகமாற்றமில்லாமல், பலகருக்களைக்கொண்ட வன்பொருள்களில், நிரலை இயக்கும்போது, அவற்றின் முழுத்திறனையும் பயன்படுத்த, செயற்கூறிய நிரலாக்கத்தால், வெகுஇயல்பாக, முடிகிறது.
மூலம்: Charles Scalfani எழுதிய கட்டுரைத்தொடரின் தமிழாக்கம். அவரது அனுமதியோடு மொழிபெயர்க்கப்பட்டுள்ளது.