🙌 💤 🍼 साइकिल अनुकूलन तकनीकों का परिचय ⚛️ 😞 ✍🏾

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

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

किन कारणों से चक्र में कार्यक्रम की गति में कमी हो सकती है?

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

स्वीप साइकिल

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

को	के बाद	नंबर 2 के बाद
`for ( int i = 0; i < iN; i++){ res *= a[i]; }`	`for ( int i = 0; i < iN; i+=3){ res = a[i]; res = a[i+1]; res *= a[i+2]; }`	`for ( int i = 0; i < iN; i+=3){ res1 = a[i]; res2 = a[i+1]; res3 = a[i+2]; } res = res1 res2 * res3;`

निम्नलिखित कुंजियों को gcc में लागू किया जा सकता है: -funroll-all-loops -funroll-loops ।

साइकिल एकीकरण

चक्र में लंबे समय तक चलने वाले निर्देश हो सकते हैं, जैसे कि वर्गमूल निकालना। या कई लूप हैं जो सूचकांकों के समान अंतराल पर चलते हैं। इसलिए, निष्पादन वाले उपकरणों के अधिक संतुलित भार के लिए चक्रों को संयोजित करना उचित है।

को	के बाद
`for ( int i = 0; i < iN; i++){ a[i] = b[i] - 5; } for ( int i = 0; i < iN-1; i++){ d[i] = e[i] * 3; }`	`for ( int i = 0; i < iN-1; i++){ a[i] = b[i] - 5; d[i] = e[i] * 3; } a[iN-1] = b[iN-1] - 5;`

चक्र काटना

इस अनुकूलन का उपयोग तब किया जाता है जब लूप का शरीर बड़ा होता है और चर पर्याप्त रजिस्टर नहीं होते हैं। इसलिए, डेटा को पहले कैश में धकेल दिया जाता है, और यदि सब कुछ पूरी तरह से खराब है, तो रैम को। और रैम तक पहुंच ~ 300 प्रोसेसर चक्र है, और L2 तक पहुंच केवल ~ 10 है। एक बड़े कदम के साथ स्मृति तक पहुंच कार्यक्रम को धीमा कर देती है। यह 2 ^{एन के} वेतन वृद्धि में स्मृति के माध्यम से "चलना" के लिए इष्टतम है, जहां एन एक काफी छोटी संख्या है (<7)।

को	के बाद
`for ( int j = 0; j < jN; j++){ for ( int k = 0; k < kN; k++){ for ( int m = 0; m < mN; m++){ i = j * k + m; a[i] = b[i] * c[i] + f[i]/e[i]+ x[i] - y[i] + z[i]/r[i] + d[i] * x[i]; } } }`	`for ( int j = 0; j < jN; j++){ for ( int k = 0; k < kN; k++){ double tmp; for ( int m = 0; m < mN; m++){ i = j * k + m; tmp = b[i] * c[i] + f[i]/e[i]; a[i] = tmp - y[i] + z[i]/r[i] + (d[i] + 1) * x[i]; } } }`

स्वैप चक्र

नेस्टेड लूप्स में, नेस्टिंग का क्रम महत्वपूर्ण है। इसलिए, आपको यह याद रखना चाहिए कि एरे को मेमोरी में कैसे संग्रहीत किया जाता है। एक क्लासिक उदाहरण: c / c ++ स्टोर मैट्रिसेस लाइन बाय लाइन, और फोरट्रान - कॉलम में।

को	के बाद
`for ( int i = 0; i < iN; i++){ for ( int j = 0; j < jN; j++){ for ( int k = 0; k < kN; k++){ c[i][j] = c[i][j] + a[i][k] * b[k][j]; } } }`	`for ( int i = 0; i < iN; i++){ for ( int k = 0; k < kN; k++){ for ( int j = 0; j < jN; j++){ c[i][j] = c[i][j] + a[i][k] * b[k][j]; } } }`

अब सरणी को क्रमिक रूप से कॉल करें।

ब्लॉक में चक्रों का विभाजन

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

को	के बाद
`for ( int i = 0; i < iN; i++){ for ( int j = 0; j < jN; j++){ a[i][j] = a[i][j] + b[i][j]; } }`	`// int iBlk, jBlk; for ( int k = 0; k < iN/iBlk; k++){ for ( int m = 0; m < jN/jBlk; m++){ for ( int i = k * iBlk; i < ((k + 1) * iBlk); i++){ for ( int j = m * jBlk; j < ((m + 1) * jBlk); j++){ a[i][j] = a[i][j] + b[i][j]; } } } }`

इस सिद्धांत के बारे में एमपीआई तकनीक काम करती है: यह बड़े सरणियों को ब्लॉक में विभाजित करती है और उन्हें व्यक्तिगत प्रोसेसर में भेजती है।

निर्भरता का संकल्प

सबसे अच्छा उपाय है छुटकारा पाना। लेकिन सभी निर्भरताओं के साथ यह काम नहीं करेगा।

for ( int i = 1; i < N; i++){ a[i] = a[i-1] + 1; }

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

सशर्त बातचीत

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

एक निष्कर्ष के बजाय

यदि आप एक जटिल प्रोग्राम बनाते हैं जो बहुत अधिक प्रोसेसर समय लेगा, तो

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

मैं आपको इस लेख को पढ़ने की सलाह भी देता हूं।
अपने स्वयं के अनुभव से, मैं कह सकता हूं कि अनुकूलन के सक्षम उपयोग से कई बार कार्यक्रम की गति में सुधार हो सकता है।

यदि आप स्वयं अनुकूलन का अभ्यास करना चाहते हैं, तो पाई नंबर की गणना करने का प्रयास करें:
संख्या पाई की गणना के लिए अभिन्न

निम्नलिखित एक बुरा कोड है।

long N = 10000000; double dx, sum, x; sum = 0.0; x = 0.0; dx = 1.0 / ( double ) N; for ( long i = 0; i < N; i++){ sum += 4.0 / (1.0 + x * x); x += dx; } double pi = dx * sum;

मैंने किस बारे में बात नहीं की: संगणना का वैश्वीकरण (SSE निर्देश); प्रीफ़ैच के बारे में जो स्मृति के साथ काम करना आसान बनाते हैं। यदि "रुचि रखने वाले" लोग हैं, तो मैं चक्रों के वैश्वीकरण के बारे में एक अलग लेख लिखूंगा।

हाइलाइटिंग सोर्स कोड हाइलाइटर ।

साइकिल अनुकूलन तकनीकों का परिचय