ഒപ്റ്റിമൈസിംഗ് കംപൈലർ
ഒപ്റ്റിമൈസിംഗ് കംപൈലർ എന്നത് പ്രോഗ്രാമിന്റെ പ്രവർത്തനവും കാര്യക്ഷമതയും മെച്ചപ്പെടുത്താൻ രൂപകൽപ്പന ചെയ്ത ഒരു പ്രത്യേകതയുള്ള കംപൈലറാണ്. പ്രോഗ്രാമിന്റെ പ്രവർത്തന സമയം കുറയ്ക്കുക, മെമ്മറി ഉപയോഗം കുറയ്ക്കുക, സ്റ്റോറേജ് വലുപ്പം ചുരുക്കുക, പവർ ഉപഭോഗം കുറയ്ക്കുക മുതലായ ലക്ഷ്യങ്ങൾക്കായാണ് അനുയോജ്യമായ കോഡ് നിർമ്മിക്കുന്നതിന് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത്[1]. ഒപ്റ്റിമൈസേഷൻ എന്നത് കോഡിന്റെ അടിസ്ഥാന അർത്ഥത്തിൽ ഒരു മാറ്റവും വരുത്താതെ, അത് കൂടുതൽ വേഗത്തിൽ പ്രവർത്തിക്കാൻ, മെമ്മറി കുറച്ച് ഉപയോഗിക്കാൻ, കുറഞ്ഞ സ്ഥലം വേണ്ടതായി മാറ്റാൻ, അല്ലെങ്കിൽ മറ്റ് കാര്യക്ഷമത ലക്ഷ്യങ്ങൾ പൂർത്തിയാക്കാൻ സഹായിക്കുന്ന പ്രക്രിയയാണ്. ഇത് സാങ്കേതികമായി ഒപ്റ്റിമൈസിംഗ് ട്രാൻസ്ഫോർമേഷനുകൾ പടിപടിയായി നടപ്പാക്കപ്പെടുന്നു. ഓരോ ട്രാൻസ്ഫോർമേഷനും കോഡ് മാറ്റി അതിന്റെ പ്രവർത്തനം മെച്ചപ്പെടുത്തുമ്പോഴും, അർത്ഥപരമായ സമാനത (semantic equivalence) നിലനിർത്തുകയാണ് പ്രധാനമായ ലക്ഷ്യം. ഉദാഹരണത്തിന്, ഒരു പണി ചെയ്യാൻ കൂടുതൽ വേഗത്തിലും എളുപ്പത്തിലും എത്തിച്ചേരാൻ മികച്ച പാത കണ്ടെത്തുന്നതുപോലെയാണ് കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നത്. ഇതോടെ കോഡിംഗിന് ചെലവാകുന്ന സമയം കുറയും, പക്ഷേ ഫലത്തിൽ മാറ്റമൊന്നും ഉണ്ടാവില്ല.
പ്രായോഗികമായി, ലഭ്യമായ മെമ്മറി എത്രയാണ്, പ്രോഗ്രാമർ കോഡ് മാറ്റാൻ എത്ര സമയം കാത്തിരിക്കുമെന്നതുപോലുള്ള കാര്യങ്ങൾ ഉൾപ്പെടെ, കംപൈലർ നൽകുന്ന മെച്ചപ്പെടുത്തലുകൾക്ക് ഒരു പരിധി വെക്കുന്നു. കംപൈലറിന് ചില ഒപ്റ്റിമൈസേഷൻ പ്രശ്നങ്ങളുണ്ടെന്ന് ഗവേഷണങ്ങൾ സൂചിപ്പിക്കുന്നു, ഉദാഹരണത്തിന് എൻപി-കമ്പ്ലീറ്റ്(NP-complete) എന്നത് ഒപ്റ്റിമൈസേഷൻ പ്രശ്നങ്ങൾ അത്ര എളുപ്പത്തിൽ പരിഹരിക്കാനാവാത്തതാണ്. നിർണയിക്കാൻ കഴിയാത്തത് (Undecidable) എന്നാൽ, ഒരു പ്രശ്നത്തിന് ഒരു നിശ്ചിത പരിഹാരമില്ലെന്ന് അർത്ഥം. ആ പ്രശ്നം എത്ര ശ്രമം നടത്തി നോക്കിയാലും, അതിന്റെ ഉത്തരം കണ്ടെത്താൻ സാധിക്കില്ല.[2]. ഒപ്റ്റിമൈസേഷൻ സാധാരണയായി ഒരു പ്രശ്നത്തിന് മികച്ച പരിഹാരം കണ്ടെത്താനായി ശ്രമിക്കുമ്പോഴും, എല്ലാ കാര്യങ്ങളും ഒരുമിച്ച് പരിഹരിക്കാൻ സാധിക്കില്ല. ഉദാഹരണത്തിന്, ഒരു പ്രോഗ്രാമിന്റെ വേഗത വർധിപ്പിക്കാൻ ശ്രമിക്കുമ്പോൾ, ഇത് കൂടുതൽ മെമ്മറി ഉപയോഗിക്കേണ്ടി വരാം. അതിനാൽ, ഓപ്റ്റിമൈസേഷൻ എന്നത് ഒരു പ്രശ്നത്തിൽ സാധ്യമായത്ര മികച്ച ഫലം കണ്ടെത്താൻ ശ്രമിക്കുന്ന രീതി മാത്രമാണ്. എന്നാൽ ഇത് എല്ലാ വിഷയങ്ങളിലും ഒരേ സമയം പരമാവധി ഫലപ്രാപ്തി നേടുമെന്ന് പ്രതീക്ഷിക്കരുത്. ഒരു കാര്യം മെച്ചപ്പെടുത്തുമ്പോൾ, മറ്റൊരു കാര്യം കുറയാനുള്ള സാധ്യത ഉണ്ടാവാം, എന്നാൽ ഇത് എല്ലായ്പ്പോഴും ഏറ്റവും മികച്ച ഫലമാകണമെന്നില്ല. എന്തായാലും, സാധാരണ ഉപയോഗത്തിലുള്ള പ്രോഗ്രാമുകൾക്കായി വേഗതയോ മെമ്മറിയോ കുറക്കുന്നതുപോലുള്ള കാര്യങ്ങളിൽ മെച്ചപ്പെടുത്തൽ നേടാൻ ഇത് സഹായിക്കും[3].
വർഗ്ഗീകരണം
തിരുത്തുകലോക്കൽ vs. ഗ്ലോബൽ സ്കോപ്പ്
തിരുത്തുകഒപ്റ്റിമൈസേഷൻ ചെയ്യുമ്പോൾ കോഡിന്റെ എത്ര ഭാഗം പരിഗണിക്കണമെന്നത് സ്കോപ്പ്(scope) ആണ് വ്യക്തമാക്കുന്നത്. ചിലപ്പോൾ ഒരു ചെറിയ ഭാഗം മാത്രം (ഉദാ. ഒരു ഫങ്ഷൻ), അല്ലെങ്കിൽ പ്രോഗ്രാമിന്റെ മുഴുവൻ ഭാഗം വരെ ഉൾപ്പെടാം. ലോക്കൽ സ്കോപ്പ് ഒപ്റ്റിമൈസേഷൻസ്, ബേസിക് ബ്ലോക്കിനുള്ളിലെ വിവരങ്ങൾ ഉപയോഗിച്ച് അനാവശ്യമായ ഓപ്പറേഷനുകൾ നീക്കം ചെയ്യുകയും, കൽക്കുലേഷനുകൾ കംപൈൽ-ടൈമിൽ തന്നെ നടത്തുകയും ചെയ്യുന്നു. ഇതിന്റെ ഉദാഹരണങ്ങൾ ഡെഡ് കോഡ് എലിമിനേഷൻ, കൺസ്റ്റന്റ് ഫോൾഡിംഗ്, കോമൺ സബ്എക്സ്പ്രഷൻ എലിമിനേഷൻ എന്നിവയാണ്[4].
ബേസിക് ബ്ലോക്കുകളിൽ (Basic blocks) കൺട്രോൾ ഫ്ലോ ഇല്ലാത്ത കോഡ് ഭാഗങ്ങളായിരിക്കും, ബേസിക് ബ്ലോക്കുകളിൽ നിയന്ത്രണ പ്രവാഹം(Control flow-നിയന്ത്രണ പ്രവാഹം പ്രോഗ്രാമിലെ കോഡ് എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് നിർണ്ണയിക്കുന്ന പ്രക്രിയയാണ്. ഇത് if, for, while പോലുള്ള ഉപയോഗിച്ച് ഡിസിഷൻസ്, ലൂപ്പുകൾ, അല്ലെങ്കിൽ ഫംഗ്ഷൻ കോളുകൾ വഴി നിയന്ത്രിക്കപ്പെടുന്നു. കോഡിന്റെ എക്സിക്യൂഷൻ ഓർഡറിംഗ്, കണ്ടീഷണൽസ്(conditionals), ജമ്പുകൾ എന്നിവ നിയന്ത്രണ പ്രവാഹത്തിന്റെ ഭാഗമാണ്.) ഇല്ലാത്തതിനാൽ, ഒപ്റ്റിമൈസേഷൻ ചെയ്യാൻ സാധിക്കുന്നത് എളുപ്പമാണ്, കാരണം കുറച്ചുകൂടിയ വിശകലനം മാത്രം ആവശ്യമാണ്. ഇതുകൊണ്ട് പ്രോഗ്രാമിന്റെ സമയം, സ്റ്റോറേജ് (Storage) മുതലയാവ കുറയുന്നു. എങ്കിലും, ജമ്പുകൾ (jumps) ഉള്ളിടത്ത്, ഒരു ബ്ലോക്കിൽ നിന്ന് മറ്റൊന്നിലേക്ക് വിവരം മാറ്റാൻ കഴിയില്ല, കാരണം ഓരോ ബ്ലോക്കും സ്വതന്ത്രമായി പ്രവർത്തിക്കുന്നു.
അവലംബം
തിരുത്തുക- ↑ Godbolt, Matt (November 12, 2019). "Optimizations in C++ Compilers". ACM Queue. Vol. 17, no. 5.
- ↑ "Lecture 15: NP-completeness, Optimization and Separation" (PDF). IE 511: Integer Programming, Spring 2021.
- ↑ Aho, Alfred V.; Sethi, Ravi; Ullman, Jeffrey D. (1986). Compilers: Principles, Techniques, and Tools. Reading, Massachusetts: Addison-Wesley. ISBN 0-201-10088-6.
- ↑ Cooper, Keith D.; Torczon, Linda (2003) [2002-01-01]. Engineering a Compiler. Morgan Kaufmann. pp. 404, 407. ISBN 978-1-55860-698-2.