प्रोग्रामर अपराध की धारणा या संकलक कभी-कभी "सुस्त" क्यों होता है

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


मैं विंडोज के लिए इंटेल कंपाइलर का उपयोग करूंगा, लेकिन मुझे लगता है कि इसी तरह की समस्याओं के कारण लूप ऑप्टिमाइज़ेशन वाले सभी ऑप्टिमाइज़िंग कंपाइलर्स के उपयोगकर्ताओं और डेवलपर्स के लिए सिरदर्द होता है, इसलिए मुझे उम्मीद है कि यह पोस्ट सभी प्रोग्रामर के लिए उपयोगी होगी। मेरा मानना ​​है कि पाठक के पास इंटरप्रोसेक्शुअल विश्लेषण के बारे में कुछ बुनियादी विचार हैं, इसलिए मैं इस विश्लेषण की संभावनाओं का उल्लेख करूंगा कि यह क्या है और यह कैसे काम करता है।

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

पाश पहचान

लूप क्रमचय अनुकूलन करने के लिए, संकलक को पहले लूप को पहचानना और वर्गीकृत करना होगा। मुख्य लूप ऑप्टिमाइज़ेशन केवल एक निश्चित संख्या में पुनरावृत्तियों के साथ लूप पर लागू होते हैं, जिसमें क्रमिक रूप से बदलते हुए वेरिएबल्स बदलते हैं (और, परिणामस्वरूप, लूप के बाहर कोई संक्रमण नहीं होता है और अज्ञात फ़ंक्शन को कॉल करता है)। उदाहरण के लिए, एक निश्चित फ़ंक्शन फू में स्थित सरल छोरों का एक सेट पर विचार करें:

extern int unknown(); int gn,gi; typedef struct vector { float *array; int lbound; int ubound; } vec; int foo(int n, float *a, vec *v) { int i,j; int b[100]; // 1 loop for(i=0;i<gn;i++) a[i] = 0; // 2 loop for(gi=0;gi<n;gi++) a[gi]=0; // 3 loop for(i=0;i<n;i=i*3) b[i]=0; // 4 loop for(i=0;i<n;i++) { j=unknown(); b[i]=j; } // 5 loop for(i=0;i<n;i++) { if(b[i] !=0) break; b[i] = 1; } // 6 loop for(i=0;i<n&&i<gn;i++) b[i] = i; // 7 loop for(i=0;i<n;i++) { if(gn) break; else b[i] = 0; } // 8 loop for(i=0;i<n;i++) { if(i>n) goto exit; b[i] = 100; } // 9 loop for(i=v->lbound;i<v->ubound;i++) { v->array[i]=i; } exit: return b[10]; } 

क्या कंपाइलर ने इन छोरों को पहचान लिया है और क्या इसका पता लगाने का कोई तरीका है? मुझे स्पष्ट विधि (डेवलपर्स के लिए आंतरिक डंप का उपयोग करने के लिए छोड़कर) नहीं पता है, लेकिन ऑटो-वेक्टर के संचालन पर एक रिपोर्ट जारी करने से संबंधित एक दिलचस्प अप्रत्यक्ष तरीका है / Qvec-report2 स्विच का उपयोग करना। / Qvec_report स्विच का उपयोग इस तरह किया जाता है:

/ Qvec- रिपोर्ट [n]
वेक्टराइज़र डायग्नोस्टिक जानकारी की नियंत्रण राशि
n = 0 कोई नैदानिक ​​जानकारी नहीं
n = 1 वेक्टरकृत छोरों को इंगित करें (सक्षम होने पर DEFAULT)
n = 2 वेक्टरकृत / गैर-वेक्टरकृत छोरों को दर्शाता है
n = 3 वेक्टरकृत / गैर-वेक्टरकृत लूप और निषेध को इंगित करता है
डेटा निर्भरता की जानकारी
...

यदि आप फ़ाइल को डिफ़ॉल्ट विकल्पों और / Qvec_report2 स्विच के साथ संकलित करते हैं, तो कंपाइलर निम्नलिखित जानकारी प्रदर्शित करेगा:

icl -Qvec_report2 test_loops.c
.. \ test_loops.c (34): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: गैरमानक लूप एक वैरिएशन उम्मीदवार नहीं है।
.. \ test_loops.c (41): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: गैरमानक लूप एक वैरिएशन उम्मीदवार नहीं है।
.. \ test_loops.c (45): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: गैरमानक लूप एक वैरिएशन उम्मीदवार नहीं है।
.. \ test_loops.c (53): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: गैरमानक लूप एक वैरिएशन उम्मीदवार नहीं है।
.. \ test_loops.c (16): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: गैरमानक लूप एक वैरिएशन उम्मीदवार नहीं है।
.. \ test_loops.c (20): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: गैरमानक लूप एक वैरिएशन उम्मीदवार नहीं है।
.. \ test_loops.c (24): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: गैरमानक लूप एक वैरिएशन उम्मीदवार नहीं है।
.. \ test_loops.c (28): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: गैरमानक लूप एक वैरिएशन उम्मीदवार नहीं है।
.. \ test_loops.c (60): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: गैरमानक लूप एक वैरिएशन उम्मीदवार नहीं है।

वाक्यांश गैरमानक लूप का मतलब है कि चक्र में लूप ऑप्टिमाइज़ेशन करने के लिए गलत संरचना है। क्या कारण है कि संकलक लूपों को पहचान और वर्गीकृत नहीं कर सका?
पहला चक्र: वैश्विक चर "gn" का उपयोग चक्र से बाहर निकलने के लिए किया जाता है। प्रत्येक पुनरावृत्ति पर, मेमोरी को सूचक "ए" के माध्यम से संशोधित किया जाता है। सैद्धांतिक रूप से, यह सूचक "gn" को संदर्भित कर सकता है और लूप से बाहर निकलने की स्थिति प्रत्येक पुनरावृत्ति पर बदल सकती है।
दूसरा चक्र: समान स्थिति वैश्विक चर "gi" के उपयोग के साथ जुड़ी होती है क्योंकि चक्र का पुनरावृत्त चर। सूचक के माध्यम से एक पुनरावृत्ति चर को कुछ पुनरावृत्ति में बदला जा सकता है।
3 चक्र: पुनरावृति चर nonlinearly बदलता है।
4 लूप: लूप के अंदर एक अज्ञात फ़ंक्शन को कॉल करें। इस तरह के एक कॉल में, उदाहरण के लिए, कार्यक्रम से बाहर हो सकते हैं।
5 वां चक्र: ऐसी कई स्थितियां हैं जिनके तहत चक्र का निष्पादन बाधित हो सकता है। यानी ऐसे लूप के पुनरावृत्तियों की संख्या को संकलन समय पर निर्धारित नहीं किया जा सकता है।
6 लूप: कंपाइलर लूप से बाहर निकलने के लिए जटिल स्थिति को पार्स नहीं कर सकता। "Gn" वैश्विक का उपयोग करना यहाँ एक बाधा नहीं है, क्योंकि स्थानीय सरणी "b" को लूप में काम किया जा रहा है, और इस चर को ऑपरेशन के दौरान नहीं बदला जा सकता है।
7 वां लूप: लूप के अंदर सशर्त कूद आपको पुनरावृत्तियों की संख्या निर्धारित करने से रोकता है। संक्रमण पुनरावृत्ति चर से स्वतंत्र है, और यहां संकलक लूप से सशर्त संक्रमण को बाहर निकाल सकता है। लेकिन स्पष्ट रूप से इसके लिए आपको पहले चक्र को पहचानना होगा।
8 लूप: गोटो का उपयोग लूप के बाहर जाने से इस तरह के लूप के पुनरावृत्तियों की संख्या अनिश्चित हो जाती है। हालांकि ऐसा कोई संक्रमण नहीं हो सकता है, लेकिन इस समस्या को भी लूप मान्यता चरण से पहले ही हल किया जाना था।
9 वें चक्र: एक बहुत ही विशिष्ट मामला। सरणी फ़ील्ड सैद्धांतिक रूप से लाउंड या ऑबाउंड फ़ील्ड को संदर्भित कर सकती है। यह एक कारण है कि एसटीएल पुस्तकालय से विभिन्न कंटेनरों को संसाधित करने में समस्याएं हैं, जैसे कि वेक्टर।

लूप को वर्गीकृत करने में उपर्युक्त अधिकांश कठिनाइयाँ स्मृति (मेमोरी में गड़बड़ी) के साथ काम करते समय अस्पष्टता को हल करने की समस्या से जुड़ी होती हैं। इस समस्या को हल करने के लिए, कंपाइलर प्रोग्रामिंग भाषाओं के मानकों और इंटरप्रोडेक्टोरल विश्लेषण के परिणामों के दोनों प्रावधानों का उपयोग करता है। चूँकि मेरे उदाहरण में, इंटरप्रोडेक्टोरल विश्लेषण का उपयोग पूर्ण सीमा तक नहीं किया गया है (डिफ़ॉल्ट रूप से, Intel कंपाइलर –Qip का उपयोग करता है, अर्थात, संकलित स्रोत फ़ाइल से केवल फ़ंक्शन का विश्लेषण करता है), कंपाइलर को मुख्य रूप से केवल C और C + भाषा मानकों के नियमों का उपयोग करना होता है +, जो एक ही मेमोरी को संदर्भित करने वाली विभिन्न वस्तुओं के आयोजन के लिए पर्याप्त अवसर के साथ प्रोग्रामर प्रदान करते हैं।

आप उन प्रोग्रामर के लिए निम्नलिखित इच्छाएं तैयार कर सकते हैं जो अपने कार्यक्रमों को अनुकूलित करते समय सबसे अच्छा परिणाम प्राप्त करना चाहते हैं:
1.) लूप व्यवहार को परिभाषित करने वाले निर्माणों में वैश्विक चर और संकेत का उपयोग न करें। यदि आवश्यक हो, तो स्थानीय चर सेट करें।
2.) सरलीकृत करें, जहां संभव हो, लूप से बाहर निकलने की स्थिति। उदाहरण के लिए, चक्र 6 में, "n" और "gn" के लिए सबसे छोटे मूल्य की पूर्व-गणना करना और बाद में बाहर निकलने की स्थिति में इसका उपयोग करना संभव था।
3.) लूप के बाहर सशर्त कूद से बचें।
4.) -Qansi_alias विकल्प का उपयोग करें यदि आप अपने कार्यक्रमों में एएनएसआई अलियासिंग नियमों का उल्लंघन नहीं करते हैं। ये नियम बताते हैं कि असंगत प्रकारों के संकेत कभी भी एक ही मेमोरी को संदर्भित नहीं कर सकते हैं। यानी संकलन के दौरान इस विकल्प को सेट करके, आप संकलक को स्मृति के साथ काम करते समय अस्पष्टता को हल करने के लिए टाइप जानकारी का उपयोग करने की क्षमता देते हैं। इस मामले में, आप संकलक को यह बताते हैं कि आपके कार्यक्रम में संकेत केवल उनके स्वयं के या संगत प्रकारों की वस्तुओं को संदर्भित करते हैं।
5.) अक्सर, तर्कों को फ़ंक्शन में दिए गए सूचक तर्क होते हैं। C99 मानक ने पॉइंटर्स के लिए नए प्रकार के प्रतिबंधित को पेश किया। पॉइंटर्स की प्रतिबंध योग्यता का मतलब है कि ऐसे पॉइंटर्स द्वारा इंगित किया गया डेटा ऑब्जेक्ट्स को इंटरसेक्ट करने के लिए इंगित नहीं करता है। उपरोक्त उदाहरण में, इस क्लासिफायर का उपयोग करके फ़ंक्शन फू का वर्णन होगा: int foo (int n, float * प्रतिबंधित एक, vec * प्रतिबंधित v)। इस कार्यक्षमता का उपयोग करने के लिए, आपको संकलन में –Qstd = c99 विकल्प जोड़ना होगा।
6.) अपनी परियोजना का आयोजन करते समय, साझा कार्यों को एक स्रोत फ़ाइल में रखें और इस स्रोत फ़ाइल में ऑब्जेक्ट्स और फ़ंक्शंस के दायरे को सीमित करने के लिए स्थिर विशेषता का उपयोग करें। यह –Qip विकल्प के साथ प्रभावी इंटरप्रोडेक्टोरल विश्लेषण की संभावनाओं को बेहतर बनाता है। आगे देखते हुए, मैं यह नोट करना चाहूंगा कि -Qipo का एक पूर्ण इंटरप्रोड्यूसियल विश्लेषण बहुत उपयोगी है, लेकिन संकलन के लिए आवश्यक संसाधनों और संकलन समय को काफी बढ़ाता है। इसलिए, परियोजना के सक्षम संगठन के साथ, -Qip विकल्प -QQo के प्रदर्शन को प्रदान करते हुए एक बहुत ही उपयोगी विकल्प हो सकता है।
7.) क्रॉस-प्रक्रिया विश्लेषण और अनुकूलन (-Qipo) को सक्षम करने के लिए विकल्प का उपयोग करें। यह विकल्प, उदाहरण के लिए, यह निर्धारित करने की अनुमति देता है कि क्या पता एक चर से लिया गया था। यदि यह स्थापित करना संभव है कि चर का पता कभी नहीं लिया गया था, तो यह बहुत ही सरलता को अस्वीकार करता है। इसके अलावा, इंटरप्रोडेक्टल विश्लेषण में पॉइंटर्स द्वारा संदर्भित वस्तुओं (स्थानीय और वैश्विक अंक-से विश्लेषण ) और कार्यों के गुणों के बारे में जानकारी एकत्र करना शामिल है। फ़ंक्शन के शरीर का प्रतिस्थापन (इनलाइनिंग) इस तथ्य को जन्म दे सकता है कि फ़ंक्शन कॉल के साथ चक्र "अच्छा" हो जाता है और इसे अनुकूलित किया जा सकता है। यह सब आंशिक रूप से -Qip के लिए सच है।

अच्छी तरह से और नहीं सी + + के प्रशंसकों के लिए एक छोटे से सिंथेटिक परीक्षण सी + + के प्रशंसकों को नाराज करने के लिए।

 #include <stdlib.h> class Array { public: Array(int n); ~Array() { free(Objects);}; void initArray(int x); int nobjects; int *Objects; }; Array::Array(int n) { nobjects = n; Objects = (int*) malloc(nobjects*sizeof(int)); } void Array::initArray(int x) { for(int i=0;i<nobjects;i++) Objects[i] = x; } 

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

icl -Qvec_report2 -Qansi_alias test_loops.cpp -c
test_loops.cpp (18): (col। 2) टिप्पणी: लूप वेक्टर नहीं किया गया था: अमानक लूप एक वैक्टर नहीं है।

संकलक को यहाँ डर है कि वस्तुओं को लिखते समय, nobjects चर को बदला जा सकता है। नतीजतन, लूप को मान्यता नहीं दी जाती है। –Qansi_alias विकल्प मदद नहीं करता है, क्योंकि ऑब्जेक्ट और नॉबजेक्ट्स पॉइंटर एक ही प्रकार के हैं। यदि यह फ़ाइल प्रोजेक्ट का हिस्सा थी और हम प्रोजेक्ट को –Qipo विकल्प के साथ बनाएंगे, तो कंपाइलर इस लूप को पहचान और वेक्टर करेगा यदि यह साबित होता है कि ये ऑब्जेक्ट्स मेमोरी में ओवरलैप नहीं कर सकते हैं।
यहां आपको इस तथ्य पर ध्यान देना चाहिए कि यदि आप लूप से बाहर निकलने की स्थिति में किसी प्रकार के nobjects के वर्ग के सदस्य का उपयोग करते हैं, तो संकलक यह देखता है-> nobjects। लूप से पहले इस ऑब्जेक्ट को लोकल वेरिएबल से रिप्लेस करना लूप की पहचान को आसान करेगा।

 void Array::initArray(int x) { int n=nobjects; for(int i=0;i<n;i++) Objects[i] = x; } 

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

मैं यह भी ध्यान देना चाहूंगा कि चक्रों के घोंसले के मामले में, एक अपरिचित आंतरिक चक्र स्वचालित रूप से सभी चक्रों की अस्वीकृति की ओर जाता है। लूप सॉकेट पर कुछ लूप संचालन होते हैं, उदाहरण के लिए, लूप इंटरचेंज। हालांकि, प्रदर्शन के लिए नेस्टिंग लूप बहुत उपयोगी हो सकते हैं।

अनुमेय अनुकूलन के लिए अनुमति मानदंड

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

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

 void foo(float * restrict a, float * restrict b, int n, int offset) { int i,j; for(i=0;i<n;i++) { a[i] = a[i+offset]; b[i] = b[i+offset]; } return; } 

icl -Qstd = c99 -Qvec_report3 test_loops.c -c
est_loops.c (4): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: वेक्टर निर्भरता का अस्तित्व।
.. \ test_loops.c (6): (कॉलोनी। 4) टिप्पणी: वेक्टर निर्भरता: माना जाता है कि बी लाइन 6 और बी लाइन 6 के बीच ANTI निर्भरता।
.. \ test_loops.c (6): (कॉलोनी। 4) टिप्पणी: वेक्टर निर्भरता: माना जाता है कि बी लाइन 6 और बी लाइन 6 के बीच फ्लो निर्भरता।
.. \ test_loops.c (6): (कॉलोनी। 4) टिप्पणी: वेक्टर निर्भरता: माना जाता है कि बी लाइन 6 और बी लाइन 6 के बीच फ्लो निर्भरता।
।
.. \ test_loops.c (5): (कर्नल। 4) टिप्पणी: वेक्टर निर्भरता: मान लिया गया कि पंक्ति 5 और पंक्ति 5 के बीच ANTI निर्भरता।
.. \ test_loops.c (5): (कर्नल। 4) टिप्पणी: वेक्टर निर्भरता: एक पंक्ति 5 और एक पंक्ति 5 के बीच प्रवाह निर्भरता।
.. \ test_loops.c (5): (कर्नल। 4) टिप्पणी: वेक्टर निर्भरता: एक पंक्ति 5 और एक पंक्ति 5 के बीच प्रवाह निर्भरता।
.. \ test_loops.c (5): (कर्नल। 4) टिप्पणी: वेक्टर निर्भरता: मान लिया गया कि पंक्ति 5 और पंक्ति 5 के बीच ANTI निर्भरता।

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

8) लूप से पहले #pragma ivdep का उपयोग करें यदि, लूप के आपके ज्ञान के अनुसार, कोई निर्भरता नहीं हो सकती है। प्राग्म का उपयोग लूप को पहचानने में भी मदद कर सकता है।

एक अन्य व्यापक रूप से ज्ञात मामला जिसके साथ कंपाइलर के पास निर्भरता से निपटने का कोई मौका नहीं है, उदाहरण के लिए वेक्टर इंडेक्सिंग का उपयोग करने का मामला है:

 void foo(int n, float * restrict a, float * restrict b, int * restrict ind) { int i; for(i=0;i<n;i++) a[ind[i]] += b[i]; } 

icl -Qstd = c99 -Qvec_report2 test_loops.c -c
.. \ test_loops.c (4): (कॉल 1) टिप्पणी: लूप वेक्टर नहीं किया गया था: वेक्टर निर्भरता का अस्तित्व।
.. \ test_loops.c (5): (col। 3) टिप्पणी: वेक्टर निर्भरता: मान लिया गया कि पंक्ति 5 और पंक्ति 5 के बीच ANTI निर्भरता है।
.. \ test_loops.c (5): (col। 3) टिप्पणी: वेक्टर निर्भरता: एक पंक्ति 5 और एक पंक्ति 5 के बीच प्रवाह निर्भरता।
.. \ test_loops.c (5): (col। 3) टिप्पणी: वेक्टर निर्भरता: एक पंक्ति 5 और एक पंक्ति 5 के बीच प्रवाह निर्भरता।
.. \ test_loops.c (5): (col। 3) टिप्पणी: वेक्टर निर्भरता: मान लिया गया कि पंक्ति 5 और पंक्ति 5 के बीच ANTI निर्भरता है।

इंड सरणी में डुप्लिकेट मान हो सकते हैं, और फिर वास्तव में लूप निर्भरताएं होंगी जो विभिन्न अनुकूलन को रोकती हैं। इस मामले में, #pragma ivdep भी संकलक की मदद करता है।
सामान्य तौर पर, इस तरह के कई अलग-अलग मामले हैं, लेकिन मुझे उम्मीद है कि सामान्य तौर पर मेरा विचार स्पष्ट है।

निष्कर्ष:

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