കംപൈൽ ടൈം
| പ്രോഗ്രാം എക്സിക്യൂഷൻ |
|---|
| പൊതുവായ ആശയങ്ങൾ |
|
| ടൈപ്പ്സ് ഓഫ് കോഡ് |
| കംപലേഷൻ സ്ട്രാറ്റെജീസ് |
|
| ശ്രദ്ധേയമായ റൺടൈമുകൾ |
|
| ശ്രദ്ധേയമായ കംപൈലറുകളും ടൂൾചെയിനുകളും |
|
കമ്പ്യൂട്ടർ സയൻസിൽ, കംപൈൽ ടൈം എന്നത് പ്രോഗ്രാമിന്റെ സോഴ്സ് കോഡ് ബൈനറി നിർദേശങ്ങളായി മാറ്റുന്ന സമയത്തെയാണ് സൂചിപ്പിക്കുന്നത്. ഈ സമയം കംപൈലർ പ്രോഗ്രാമിന്റെ പിശകുകൾ പരിശോധിക്കുകയും മെഷീൻ കോഡായി മാറ്റുകയും ചെയ്യും[1]. ഇത് പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ സംഭവിക്കുന്ന കാര്യങ്ങളുമായി (റൺടൈം) ബന്ധപ്പെട്ടതല്ല. ഉദാഹരണത്തിന്, കംപൈൽ സമയത്ത് പ്രോഗ്രാമിലെ പിശകുകൾ കാണിച്ചുതരുന്നു, എന്നാൽ റൺടൈമിൽ ആ പ്രോഗ്രാമിന്റെ ഫലങ്ങൾ ലഭിക്കും. ഉദാഹരണത്തിന്, കംപൈൽ-ടൈം റിക്വയർമെന്റ് എന്നതിന്റെ അർത്ഥം, സോഴ്സ് കോഡ് കംപൈലിന് മുമ്പ് പ്രോഗ്രാമിംഗ് ഭാഷയുടെ ചട്ടങ്ങൾ പാലിക്കണം. കംപൈൽ-ടൈം പ്രോപ്പർട്ടീസിന്റെ അർത്ഥം, കംപൈലർ പ്രോഗ്രാമിന്റെ പിശകുകൾ പ്രഥമ ഘട്ടത്തിൽ തന്നെ കണ്ടെത്തുകയും, ടൈപ്പ് ചെക്കിംഗും സിന്റാക്സ്(സിന്റാക്സ് എന്നത്, ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയിൽ കോഡ് എഴുതാനുള്ള ചട്ടങ്ങൾ അല്ലെങ്കിൽ നിയമങ്ങൾ ആണ്. ഉദാഹരണം:സി ഭാഷയിൽ സെമികോളൻ (;) ഉപയോഗിച്ച് ഓരോ വാചകവും അവസാനിപ്പിക്കണം എന്നത് ഒരു സിന്റാക്സ് ചട്ടമാണ്. കംപൈൽ സമയത്ത് സിന്റാക്സ് തെറ്റുകൾ കണ്ടുപിടിച്ച് പരിഹരിക്കണം, അല്ലെങ്കിൽ പ്രോഗ്രാം കംപൈൽ ചെയ്യില്ല.)സാധുതയും ഉറപ്പാക്കുകയും ചെയ്യുന്നു. പ്രോഗ്രാമിന്റെ സ്ഥിരമായ മൂല്യങ്ങൾ മുൻകൂട്ടി കണക്കാക്കുന്നതിനാൽ പ്രവർത്തനക്ഷമത വർധിക്കുന്നു. ഇതിലൂടെ പ്രോഗ്രാം മെച്ചപ്പെടുത്തുകയും പ്രവർത്തന സുതാര്യത ഉറപ്പാക്കുകയും ചെയ്യുന്നു.
കംപൈൽ ടൈം / ഏർലി ബൈൻഡിംഗ് vs റൺ ടൈം
[തിരുത്തുക]കംപൈൽ-ടൈം പ്രോഗ്രാമിന്റെ രൂപം തീർക്കുന്നതിനും പ്രവർത്തന രീതി നിശ്ചയിക്കുന്ന സമയമാണ്. പ്രോഗ്രാം തയ്യാറായ ശേഷം, റൺ-ടൈം എന്ന് പറയുന്നത് പ്രോഗ്രാം പ്രവർത്തിക്കുന്ന സമയമാണ്, ഈ സമയത്ത് പ്രോഗ്രാം എങ്ങനെ പ്രവർത്തിക്കണമെന്നതും, സ്രോതസുകൾ എങ്ങനെ ഉപയോഗിക്കണമെന്നതും പ്രോഗ്രാമിന്റെ പ്രവർത്തനത്തെ അനുസരിച്ച് മാറാം. അതായത്, കംപൈൽ-ടൈമിൽ പ്രോഗ്രാമിന്റെ സ്രഷ്ടാവ് (ഡെവലപ്പർ) പ്രോഗ്രാം എഴുതിയ ശേഷം, പ്രോഗ്രാമിന്റെ അടിസ്ഥാന ഘടനയും പ്രവർത്തന രീതിയും കംപൈലർ പരിശോധിക്കുന്നു[2].
അവലോകനം
[തിരുത്തുക]കംപൈലറുകളിൽ സാധാരണയായി മൂന്ന് പ്രധാന ഘട്ടങ്ങൾ ഉണ്ടായിരിക്കും, കൂടാതെ ഇവ കംപൈൽ സമയത്ത് നടക്കുന്നു: സിന്റാക്സ് വിശകലനം, സെമാന്റിക് വിശകലനം, കോഡ് ജനറേഷൻ തുടങ്ങിയവ. സിന്റാക്സ് വിശകലനത്തിൽ, കോഡ് ശരിയായി എഴുതിയിട്ടുണ്ടോ എന്ന് പരിശോധിക്കുന്നു. സെമാന്റിക് വിശകലനത്തിൽ, കോഡിന്റെ അർത്ഥവും നിയമങ്ങളും ശരിയാണോ എന്ന് ഉറപ്പാക്കുന്നു. അതിനു ശേഷം, കോഡ് കമ്പ്യൂട്ടർക്ക് മനസ്സിലാക്കാൻ കഴിയുന്ന രൂപത്തിൽ മാറ്റി കോഡ് ജനറേഷൻ നടത്തുന്നു[3]. സോഴ്സ് കോഡിലെ കോൺസ്റ്റന്റ് എക്സ്പ്രഷനുകൾ(കോൺസ്റ്റന്റ് എക്സ്പ്രഷനുകൾ എന്നു പറഞ്ഞാൽ, പ്രോഗ്രാമിൽ നിർദ്ദിഷ്ടമായി നിശ്ചിതമായ മൂല്യം നൽകുന്ന എക്സ്പ്രഷനുകളാണ്. ഉദാഹരണം: `5 + 3`, `Hello`, അല്ലെങ്കിൽ `10 * 2` ഇതൊക്കെ കോൺസ്റ്റന്റ് എക്സ്പ്രഷനുകളായി കണക്കാക്കാം. ഇവ കംപൈൽ സമയത്ത് തന്നെ ഗണനം ചെയ്യാൻ സാധിക്കും, ഇത് പ്രോഗ്രാമിന്റെ പ്രകടനക്ഷമത മെച്ചപ്പെടുത്താൻ സഹായിക്കുന്നു.) കംപൈൽ സമയത്ത് തന്നെ പരിശോധിച്ച് മൂല്യം നിശ്ചയിക്കാൻ കംപൈൽ-ടൈം എക്സിക്യൂഷൻ ഉപയോഗിക്കുന്നു. ഇത് കോഡിൽ നിലനിൽക്കുന്ന സ്റ്റാറ്റിക് മൂല്യങ്ങളെ(സ്റ്റാറ്റിക് മൂല്യങ്ങൾ എന്നത് കോഡിൽ ഒരിക്കൽ നിശ്ചയിച്ചാൽ പ്രോഗ്രാം പ്രവർത്തനത്തിന്റെ തുടർച്ചയിൽ മാറാതിരുന്ന മൂല്യങ്ങളെയാണ് സൂചിപ്പിക്കുന്നത്. ഉദാഹരണം: `const int x = 10;` എന്നതിൽ `x` ഒരു സ്റ്റാറ്റിക് മൂല്യമാണ്. ഇവ കംപൈൽ സമയത്ത് തന്നെ ഗണനം ചെയ്യപ്പെടുന്നുണ്ട്, അതിനാൽ റൺടൈമിൽ പ്രോഗ്രാമിന്റെ വേഗത ഉയരുന്നു.) സംഖ്യകൾ തമ്മിൽ കണക്കുകൂട്ടലുകൾ നടത്തി ഒറ്റ മൂല്യമായി ചുരുക്കും. ഇതിലൂടെ പ്രോഗ്രാമിന്റെ എക്സിക്യൂഷൻ സമയവും മേന്മയും മെച്ചപ്പെടുത്താൻ കഴിയും. ഇത് പ്രോഗ്രാമിന്റെ ശരിയായ പ്രവർത്തനത്തിന് നിർബന്ധമായില്ലെങ്കിലും, റൺടൈം പ്രകടനക്ഷമത മെച്ചപ്പെടുത്താൻ സഹായിക്കുന്നു.
പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഉപയോഗിച്ച് കോഡ് ഉണ്ടാക്കുമ്പോൾ ചില നിയമങ്ങൾ പാലിക്കണമെന്ന് ആവശ്യപ്പെടുന്നു. ഉദാഹരണത്തിന്, ഓരോ ഡാറ്റയ്ക്കും എത്ര മെമ്മറി ആവശ്യമാണ് എന്ന് കോഡിൽ നിന്ന് കണ്ടെത്താൻ കഴിയണം. ഈ നിയമങ്ങൾ പാലിച്ചാലേ കോഡ് ശരിയായി പ്രവർത്തിക്കൂ.
ഒരു പ്രോഗ്രാം ഭാവിയിൽ പിഴവ് വരാതെ പ്രവർത്തിക്കുമോ എന്ന് ചില കാര്യങ്ങൾ നമുക്ക് പ്രോഗ്രാം എഴുതുന്ന സമയത്ത് തന്നെ പരിശോധിക്കാൻ കഴിയും. ഉദാഹരണത്തിന്, ഒരു അറേയിൽ ഉള്ള നമ്പറുകൾക്കു പുറത്ത് ഉള്ളത് പരീക്ഷിക്കാൻ പോകുന്നുണ്ടോ, അല്ലെങ്കിൽ പ്രോഗ്രാം ഒന്നും ചെയ്യാതെ തടസ്സപ്പെടുമോ എന്ന് പരിശോധിക്കുക. ഇതിലൂടെ പ്രോഗ്രാം സുരക്ഷിതവും ശരിയായതും ആക്കാം.
കംപൈൽ-ടൈം പ്രോഗ്രാമിനെ മെഷീൻ ഭാഷയിലേക്ക് പരിഭാഷപ്പെടുത്തുന്നതിന് മുമ്പ് നടക്കുന്ന ഘട്ടമാണ്, ഇത് ലിങ്ക്-ടൈമിന് (ഒരുകൂടി കംപൈൽ ചെയ്ത ഫയലുകൾ തമ്മിൽ ബന്ധിപ്പിക്കുന്ന ഘട്ടം) മുൻപും റൺടൈമിന് (പ്രോഗ്രാം പ്രവർത്തിക്കുന്ന സമയം) മുൻപുമാണ്. ഡൈനാമിക് കംപൈലേഷൻ നടക്കുമ്പോൾ, പ്രോഗ്രാമിന്റെ അവസാന മാറ്റങ്ങൾ റൺടൈമിലാണ് നടക്കുന്നത്. അതായത്, ചില പ്രോഗ്രാമുകൾ പ്രവർത്തിക്കുന്നതിനിടെ മാത്രമേ യഥാർത്ഥ മെഷീൻ ഭാഷയിൽ മാറ്റപ്പെടൂ.
കംപൈൽ-ടൈമിലും ലിങ്ക്-ടൈമിലും ചില പ്രവർത്തനങ്ങൾ മാറ്റിപ്പറയുന്നതിലൂടെ ഉൽപാദന പ്രക്രിയ വേഗത്തിലാക്കാൻ കഴിയും, പ്രത്യേകിച്ച് കമ്പൈൽ-ടൈമിൽ സാധാരണയായി നടത്തേണ്ട പ്രവർത്തനങ്ങൾ ലിങ്ക്-ടൈമിലേക്ക് മാറ്റുമ്പോൾ ഇത് എക്സിക്യൂട്ടബിൾ സൃഷ്ടിക്കാൻ വേണ്ടി ലിങ്ക്-ടൈമിൽ അധിക പ്രവർത്തനങ്ങൾ ആവശ്യമാക്കും, പക്ഷേ റൺടൈമിൽ ഇത് യാതൊരു ദോഷവും വരുത്തില്ല. ഉദാഹരണത്തിന്, ചില ഫംഗ്ഷൻ നിർവചനങ്ങൾ കംപൈൽ-ടൈമിൽ പരിശോധിക്കുന്നതിനുപകരം, ലിങ്ക്-ടൈമിൽ പരിശോധിക്കുന്നത് കമ്പൈൽ സമയവും പ്രക്രിയാ വേഗവും വർധിപ്പിക്കും. ഇത് പ്രോഗ്രാമിന്റെ വികസന സമയം കുറയ്ക്കുകയും, പ്രവർത്തനക്ഷമത നിലനിർത്തുകയും ചെയ്യുന്നു[4].
അവലംബം
[തിരുത്തുക]- ↑ "A History of Computer Programming Languages" (in ഇംഗ്ലീഷ്). Retrieved 2022-12-25.
- ↑ "runtime-vs-compile-time". Retrieved 16 Dec 2024.
- ↑ "phases-of-a-compiler". Retrieved 16 Dec 2024.
- ↑ "Difference between compile time linking and run time linking". Retrieved 16 Dec 2024.