एलएलवीएम के विल्स में विलम्ब करते हुए , मैंने अप्रत्याशित रूप से खुद के लिए खोज की: कोड का अनुकूलन कितना दिलचस्प है। इसलिए, मैंने आपके साथ संकलन में अनुकूलन के बारे में समीक्षा लेखों की एक श्रृंखला के रूप में अपनी टिप्पणियों को साझा करने का निर्णय लिया। इन लेखों में मैं अनुकूलन कार्य के सिद्धांतों को "चबाने" की कोशिश करूंगा और उदाहरणों पर विचार करना सुनिश्चित करूंगा।
मैं "समझ की जटिलता" के बढ़ते क्रम में अनुकूलन बनाने की कोशिश करूंगा, लेकिन यह अत्यंत व्यक्तिपरक है।
और एक और बात: कुछ नाम और शर्तें अच्छी तरह से स्थापित नहीं हैं और उनका उपयोग "किसी-जैसे" द्वारा किया जाता है, इसलिए मैं आपको कई विकल्प दूंगा, लेकिन मैं दृढ़ता से अनुशंसा करता हूं कि आप अंग्रेजी शब्दों का उपयोग करें।

---

प्रविष्टि

(छोड़ने के लिए अनुकूलन प्रकारों के बारे में काफी सिद्धांत)

इससे पहले कि हम महान विचारों और एल्गोरिदम में गोता लगाते हैं, चलो सिद्धांत के साथ थोड़ा ऊब जाते हैं: हम यह पता लगाएंगे कि अनुकूलन क्या हैं, वे क्या हैं और वे क्या हैं या नहीं हैं।
सबसे पहले, आइए एक परिभाषा दें ( विकिपीडिया से ):

प्रोग्राम कोड ऑप्टिमाइज़ेशन प्रोग्राम का एक संशोधन है जो एक कार्यक्षमता कंपाइलर या दुभाषिया द्वारा किया जाता है ताकि कार्यक्षमता में परिवर्तन या कार्यक्षमता के बिना उनकी विशेषताओं में सुधार हो सके।

इस परिभाषा में अंतिम तीन शब्द बहुत महत्वपूर्ण हैं: कोई फर्क नहीं पड़ता कि कार्यक्रम की विशेषताओं का अनुकूलन कैसे सुधारता है, इसे किसी भी परिस्थिति में कार्यक्रम के मूल अर्थ को संरक्षित करना होगा। इसलिए, उदाहरण के लिए, जीसीसी में अनुकूलन के विभिन्न स्तर हैं (मैं दृढ़ता से अनुशंसा करता हूं कि आप इन लिंक का पालन करें) ।

हम और आगे बढ़ते हैं: अनुकूलन मशीन-स्वतंत्र (उच्च-स्तर) और मशीन-निर्भर (निम्न-स्तर) हैं । वर्गीकरण का अर्थ नामों से स्पष्ट है, मशीन-निर्भर अनुकूलन में कंक्रीट आर्किटेक्चर की विशिष्ट विशेषताओं का उपयोग किया जाता है, उच्च-स्तरीय अनुकूलन में, वे कोड संरचना के स्तर पर होते हैं।

ऑप्टिमाइज़ेशन को भी वर्गीकृत किया जा सकता है, उनके आवेदन के आधार पर, स्थानीय (ऑपरेटर, ऑपरेटरों का आधार, आधार इकाई), इंट्रा-प्रक्रिया, अंतर-प्रक्रिया, इंट्रा-मॉड्यूल और ग्लोबल (पूरे कार्यक्रम का अनुकूलन, "विधानसभा के दौरान अनुकूलन", "लिंक-टाइम अनुकूलन" )।

मुझे लगता है कि आप अब सो गए हैं, चलो सिद्धांत के इस हिस्से को समाप्त करते हैं और खुद को अनुकूलन के बारे में सोचना शुरू करते हैं ...

---

लगातार तह

(स्थिरांक कम / कम करें)

संकलक में सबसे सरल, सबसे प्रसिद्ध और सबसे आम अनुकूलन। "फोल्डिंग कॉन्स्टेंट्स" की प्रक्रिया में एक्सप्रेशन्स (या सबएक्सप्रेस) की खोज शामिल है जिसमें केवल कॉन्स्टेंट शामिल हैं। इस तरह के भावों की गणना संकलन चरण में की जाती है और परिणामी कोड में गणना मूल्य में "ढह" जाते हैं।

एक उदाहरण पर विचार करें ( सिर से मक्खी का आविष्कार, पूरी तरह से सिंथेटिक, तुच्छ, अमूर्त, अर्थहीन, वास्तविकता से दूर, आदि ... और सभी उदाहरण इस तरह होंगे):

अनुकूलन से पहले	अनुकूलन के बाद
#include <stdlib.h> int main(int argc, char **argv) { struct point { int x; int y; } p; int a = 32*32; int b = 32*32*4; long int c; // c = (a + b) * (4*4*sizeof(p) - 2 + 32); return 0; }	#include <stdlib.h> int main(int argc, char **argv) { struct point { int x; int y; } p; int a = 1024; // 32 * 32 int b = 4096; // 32 * 32 * 4 long int c; // 16 = 4*4, 30 = -2 + 32 c = (a + b) * (16*sizeof(p) + 30); return 0; }

ऐसा लगता है कि यह ठीक हो गया है और अनुकूलन पूरा हो गया है, लेकिन वास्तव में कंपाइलर चालाक हो गए हैं और आगे बढ़ गए हैं। तथ्य यह है कि इस मामले में, संरचना "p" आकार ( sizeof ) भी एक स्थिर है, और संकलक इसके बारे में जानते हैं, इसलिए हम प्राप्त करते हैं:

आकार का विस्तार करें	हम पतन को पूरा करते हैं
... c = (a + b) * (16*8 + 30); ...	... c = (a + b) * 158; ...

ठीक है ... कुछ प्रोसेसर चक्र, यह अनुकूलन निश्चित रूप से हमें बचाता है।
यदि हमारा कोड एक सार सिंथेटिक ट्री ( एएसटी ) के रूप में प्रस्तुत किया जाता है तो सब कुछ काफी सरल है। फिर, संख्यात्मक अभिव्यक्तियों और उप-अभिव्यक्तियों को खोजने के लिए, केवल समान मान वाले समान स्तर (यानी, एक सामान्य पूर्वज होने) के पेड़ के नोड्स की खोज करने के लिए पर्याप्त है। तब मूल (पैरेंट) में मान का पतन हो सकता है। स्पष्टता के लिए, किसी एक भाव के लिए एक पेड़ के सरल उदाहरण पर विचार करें, हमारे "int a = 32*32;" :



यही है, हमारे एएसटी पेड़ की पुनरावृत्ति करके, हम ऐसे सभी स्थिर भावों को ध्वस्त कर सकते हैं। वैसे, संख्याओं के साथ उदाहरण को फिर से सरलीकृत किया जाता है, संख्याओं के साथ संचालन के बजाय, स्ट्रिंग्स (संघटन) के साथ संचालन या तार और संख्याओं के साथ संचालन हो सकता है (पायथन के " '-' * 10 " के अनुरूप) या स्रोत भाषा द्वारा समर्थित किसी भी अन्य डेटा प्रकारों के स्थिरांक। प्रोग्रामिंग।

---

लगातार प्रसार

(स्थिरांक का प्रसार)

यह अनुकूलन आमतौर पर "निरंतर तह" (क्योंकि वे एक दूसरे के पूरक हैं) के संयोजन में वर्णित है, लेकिन यह अभी भी एक अलग अनुकूलन है। "स्थिरांक के प्रसार" की प्रक्रिया में उन अभिव्यक्तियों की खोज शामिल है जो निष्पादन के किसी भी संभावित मार्ग पर स्थिर रहेंगी (इस अभिव्यक्ति का उपयोग करने से पहले) और इन मूल्यों के साथ उनका प्रतिस्थापन। वास्तव में, यह सुनने में जितना आसान लगता है, उससे कहीं अधिक सरल है - चलो वही उदाहरण लेते हैं जो हमने पहले ही उपयोग कर लिया है, लेकिन इस तथ्य को ध्यान में रखते हुए कि हम पहले ही "निरंतर तह" का अनुकूलन करके इस पर चल चुके हैं:

अनुकूलन से पहले	अनुकूलन के बाद
#include <stdlib.h> int main(int argc, char **argv) { struct point { int x; int y; } p; int a = 1024; int b = 4096; long int c; // c = (a + b) * 94; return 0; }	#include <stdlib.h> int main(int argc, char **argv) { struct point { int x; int y; } p; int a = 1024; int b = 4096; long int c; // c = (1024 + 4096) * 94 c = 481280; return 0; }

यही है, हमारे मूल कार्यक्रम में, सामान्य तौर पर, किसी भी गणना करने के लिए आवश्यक नहीं था। क्या हुआ था? यह सरल है ... चूंकि चर "a" और "b" के मान उनकी घोषणा और गणना में मूल्य "c" उपयोग के बीच किसी भी तरह से नहीं बदल सकते हैं, संकलक अभिव्यक्ति में अपने मूल्यों को प्रतिस्थापित कर सकते हैं और इसका मूल्यांकन कर सकते हैं।
यही है, संकलक को प्रत्येक अभिव्यक्ति की जांच करने की आवश्यकता है कि क्या इसका मूल्य हमेशा स्थिर रहेगा (या बल्कि, चाहे वह बदल सकता है)। चलो स्केच करने की कोशिश करते हैं:



मान लीजिए कि संकलक अगले अनुकूलन रन के दौरान चर "a" और "b" के उपयोग का पता लगाता है। जैसा कि आरेख से देखा जा सकता है, ब्लॉक ए में चर "b" और ब्लॉक बी में चर "b" घोषित करने के बाद, न तो एक और न ही दूसरे चर का उपयोग करने से पहले बाद के ब्लॉक (ए, बी, सी) में मूल्य बदल सकते हैं। यह मामला तुच्छ है, क्योंकि पूरा कार्यक्रम रैखिक है और तथाकथित आधार इकाई ( बीबी ) है । लेकिन आधार इकाई में एक चर की "परिवर्तनशीलता" निर्धारित करने के लिए एल्गोरिथ्म सभी से बहुत दूर है। एक कार्यक्रम में सशर्त निर्माण, लूप, बिना शर्त कूद शामिल हो सकते हैं। फिर, एक चर की "परिवर्तनशीलता" निर्धारित करने के लिए, आधार ब्लॉक के साथ एक निर्देशित ग्राफ बनाना आवश्यक है, किनारों - बेस ब्लॉकों के बीच नियंत्रण का हस्तांतरण। इस ग्राफ को कंट्रोल फ्लो ग्राफ ( CFG ) कहा जाता है और इसका उपयोग कई अनुकूलन को लागू करने के लिए किया जाता है। इस कॉलम में, आप उन सभी बुनियादी ब्लॉकों को परिभाषित कर सकते हैं, जिन्हें चर के आरंभ से इसके उपयोग तक जाने और प्रत्येक ब्लॉक के लिए निर्धारित करने की आवश्यकता है कि क्या चर का मान इसमें बदल सकता है। यदि इसे बदलना असंभव है, तो संकलक आसानी से एक स्थिर के साथ अपने मूल्य को बदल सकता है।
लगातार प्रसार और लगातार मोड़ आमतौर पर कई बार चलते हैं जब तक कि वे प्रोग्राम कोड में कोई बदलाव नहीं करते हैं।

---

प्रचार प्रसार की प्रति

(प्रतियों का वितरण)

और यह दो पिछले अनुकूलन का एक साथी है, लगभग जुड़वां भाई "लगातार तह", जो एक बहुत ही समान काम करता है, लेकिन आपको अनावश्यक (मध्यवर्ती) चर असाइनमेंट से छुटकारा दिलाता है, अभिव्यक्ति में मध्यवर्ती चर की जगह। यह सबसे सरल उदाहरण के साथ अधिक स्पष्ट होगा:

अनुकूलन से पहले	अनुकूलन के बाद
int calc(int x, int y) { int a = x; int b = y; return a * a + b * b; }	int calc(int x, int y) { // // return x * x + y * y; }

---

डेड कोड एलिमिनेशन (DCE)

(दुर्गम कोड का उन्मूलन / बहिष्करण)

प्रदर्शन अनुकूलन के संदर्भ में एक बहुत ही सरल, लेकिन, दुर्भाग्य से, थोड़ा सुधार। यह सरल है: कोड जिसे प्रोग्राम में उपयोग नहीं किया जा सकता है उसे हटाया जा सकता है। आइए देखते हैं "कोड के डेड लोड " के कुछ उदाहरण:

अनुकूलन से पहले	अनुकूलन के बाद
#include <stdlib.h> #include <stdio.h> int main(int argc, char **argv) { while(true) { printf("Hi, I'm very hardy code =) !"); } printf("Hi, I'm dead code =( !"); return 0; }	#include <stdlib.h> #include <stdio.h> int main(int argc, char **argv) { while(true) { printf("Hi, I'm very hardy code =) !"); } // Here there was a dead code return 0; }

जैसा कि आप देख सकते हैं, लाइन " printf("Hi, I'm dead code =( !"); "किसी भी परिस्थिति में अप्राप्य है: या तो कार्यक्रम अंतहीन रूप से चलता है, या यह" जबरदस्ती समाप्त होता है। "चलिए एक दो और उदाहरण देते हैं:

अनुकूलन से पहले	अनुकूलन के बाद
#include <stdlib.h> #include <stdio.h> int main(int argc, char **argv) { int y = 0; int x; scanf("%d", &x); if (x >= 10) { printf("x >= 10 \n"); return 0; } else { printf("x < 10 \n"); return 0; } printf("x = %d \n", &x); }	#include <stdlib.h> #include <stdio.h> int main(int argc, char **argv) { // Here there was a dead code int x; scanf("%d", &x); if (x >= 10) { printf("x >= 10 \n"); return 0; } else { printf("x < 10 \n"); return 0; } // Here there was a dead code }

मुझे लगता है कि यहां सब कुछ टिप्पणी के बिना भी स्पष्ट है: लाइन " printf("x = %d \n", &x); " साथ ही पिछले उदाहरण में, किसी भी प्रोग्राम निष्पादन पथ के लिए अप्राप्य है, और मुख्य फ़ंक्शन की पहली पंक्ति में घोषित चर y नहीं करता है। उपयोग नहीं किया।
खैर, इस अनुकूलन के लिए अंतिम उदाहरण:

अनुकूलन से पहले	अनुकूलन के बाद
#include <stdlib.h> int sum(int x, int y) { return x + y; } int sub(int x, int y) { return x - y; } int main(int argc, char **argv) { return sum(2, 2); }	#include <stdlib.h> int sum(int x, int y) { return x + y; } // // // // int main(int argc, char **argv) { return sum(2, 2); }

और फिर, सब कुछ सरल है: कार्यक्रम में किसी भी स्थान पर उप फ़ंक्शन को नहीं बुलाया जाता है, इसलिए आप इसे से छुटकारा पा सकते हैं।
एक ओर, प्रोग्राम में "डेड कोड" बहुत आसानी से कंट्रोल फ्लो ग्राफ का उपयोग करके पाया जाता है। यदि प्रोग्राम में मृत कोड है, तो ग्राफ या तो असंगत होगा और आप ग्राफ के अलग-अलग टुकड़े "फेंक" सकते हैं। दूसरी ओर, खाते के अंकगणित और कई अन्य बारीकियों को ध्यान में रखना आवश्यक है - यह हमेशा यह निर्धारित करना संभव नहीं है कि कोई कोड "मृत" है या नहीं।

---

सामान्य उप-अभिव्यक्ति उन्मूलन (CSE)

(आम उपसंहारों का उन्मूलन)

बहुत उपयोगी और "सुंदर" अनुकूलन। इसमें निम्नलिखित शामिल हैं: यदि आप दो या अधिक बार किसी अभिव्यक्ति की गणना का उपयोग करते हैं, तो इसे एक बार गणना की जा सकती है, और फिर इसका उपयोग करके सभी अभिव्यक्तियों में प्रतिस्थापित किया जा सकता है। खैर, हम एक उदाहरण के बिना कहाँ हैं:

अनुकूलन से पहले	अनुकूलन के बाद
int calc(int x, int y) { int a = (x + y) * (x - y) - x * y; int b = x * (x + y) - y * (x - y); return (a * b + x - y) * (a * b + x + y); }	int calc(int x, int y) { int tmp1 = x + y; int tmp2 = x - y; int a = tmp1 * tmp2 - x * y; int b = x * tmp1 - y * tmp2; int tmp3 = a * b; return (tmp3 + tmp2) * (tmp3 + tmp1); }

हां, यह अनुकूलित कोड बहुत बुरा और अधिक बोझिल लग रहा है, लेकिन यह "अनावश्यक गणना" (एक बार एक्स और वाई को जोड़ने और घटाने के बजाय तीन बार, एक बार और बी को एक साथ दो बार जोड़ना) से मुक्त है। अब कल्पना करें कि यह अनुकूलन एक बड़े कंप्यूटिंग प्रोग्राम के भाग के रूप में सीपीयू समय को कितना बचाता है।

---

पुनश्च वास्तव में, मैं प्रत्येक अनुकूलन के लिए आरेख देना चाहता था, लेकिन मुझे माफ करना, मेरे पास केवल दो ड्रा थे।
PPS मुझे आरेख और रेखांकन बनाने के लिए एक CONVENIENT सेवा बताएं।
PPPS जारी रखा जाए?