जीसीसी प्रोफाइल-निर्देशित अनुकूलन

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

PGO में निम्नलिखित प्रकार के अनुकूलन शामिल हो सकते हैं ( स्रोत ):

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

मैं GCC संकलक का उपयोग करते समय PGO चलाने के सबसे आसान तरीके के बारे में बात करूँगा। जीसीसी में पीजीओ के लिए समर्थन दो झंडे -fprofile-generate और -fprofile-use द्वारा प्रदान किया गया है। सामान्य संकलन योजना इस प्रकार है:

1. सभी अनुकूलन झंडे और -फ्रीफाइल-जेनरेट ध्वज के साथ प्रोग्राम को संकलित करें। यह ध्वज संकलक और लिंकर दोनों के लिए निर्धारित होना चाहिए। उदाहरण के लिए, इस तरह:
   

   g ++ -O3 -march = native -mtune = native -fprofile-generate -Wall -c -fmessage-length = 0 -MMD -MP -MF "src / pgo-1.d" -MT - src / pgo-1.d "-ओ" src / pgo-1.o "" ../src/pgo-1.cpp "
   g ++ -fprofile-generate -o "pgo-1" ./src/pgo-1.o
   

   
   
2. सफल संकलन के बाद, सबसे विशिष्ट उपयोग के मामले के साथ कार्यक्रम का परीक्षण रन करना आवश्यक है। यदि सब कुछ सही ढंग से किया जाता है, तो परीक्षण रन के परिणामस्वरूप, जीसीडीए एक्सटेंशन के साथ एक आंकड़े फ़ाइल दिखाई देगी ।
3. सभी ऑप्टिमाइज़ेशन फ़्लैग और -fprofile-use ध्वज के साथ प्रोग्राम को संकलित करें। यह ध्वज संकलक और लिंकर दोनों के लिए निर्धारित होना चाहिए। उदाहरण के लिए, इस तरह:
   

   g ++ -O3 -march = native -mtune = native -fprofile-use -Wall -c -fmessage-length = 0 -MMD -MP -MF "src / pgo-1.d" -MT - src / pgo-1.d "-ओ" src / pgo-1.o "" ../src/pgo-1.cpp "
   g ++ -fprofile-use -o "pgo-1" ./src/pgo-1.o
   

   
   इस स्थिति में, जीसीई चरण 2 में बनाई गई सांख्यिकी फ़ाइल का उपयोग करेगा, या रिपोर्ट करेगा कि फ़ाइल नहीं मिली।

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

एक साधारण उदाहरण के साथ पीजीओ की प्रभावशीलता पर विचार करें। अध्ययन कार्यक्रम का कोड:

# किंकर्तव्यविमूढ़ <iostream>
# अलग करना <एल्गोरिथम>
# अलग करना <stdlib.h>

const size_t MB = 1024 * 1024 ;
size_t MOD = 0 ;

अहस्ताक्षरित चार अनूठे ( ) {
स्थिर अहस्ताक्षरित चार नंबर = 0 ;
रिटर्न ++ नंबर % MOD ;
}

int main ( int argc, char ** argv ) {
अगर ( argc < 3 ) {
वापसी 1 ;
}

size_t BLOCK_SIZE = atoi ( argv [ 1 ] ) * MB ;
MOD = atoi ( argv [ 2 ] ) ;

अहस्ताक्षरित चार * कचरा = ( अहस्ताक्षरित चार * ) मॉलोक ( BLOCK_SIZE ) ;

std :: generate_n ( कचरा, BLOCK_SIZE, uniqueNumber ) ;
std :: सॉर्ट ( कचरा, कचरा + BLOCK_SIZE ) ;

मुक्त ( कचरा ) ;

वापसी 0 ;
}

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

./prog 32 3 - योजना के अनुसार भरा हुआ 32MB का आकार बनायेगा: {1, 2, 1, 2, ...}। फिर इसे छांटेगा।

./prog 16 7 - योजना के अनुसार भरा हुआ 16MB आकार का एक सरणी बनाएगा: {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, ...}। फिर इसे छांटेगा।

इस प्रकार, विभिन्न मापदंडों को सेट करके, हम इस सरणी और संसाधित डेटा के आकार को सॉर्ट करते समय सशर्त संक्रमण को ट्रिगर करने की आवृत्ति को प्रभावित कर सकते हैं। इसके लिए धन्यवाद, हम पहले वर्णित सशर्त शाखा अनुकूलन का परीक्षण कर सकते हैं । एक मुश्किल स्क्रिप्ट लिखने के बाद, मैंने विभिन्न मापदंडों के साथ 1792 परीक्षण किए और उन्हें नीचे दिए गए ग्राफ़ में घटा दिया। सरणी का आकार भिन्न था: {2, 4, 8, 16, 32, 128, 256}, और भाजक {1..256}।

उत्पादकता लाभ (संचित)

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

उत्पादकता लाभ (सरल)

Y अक्ष एक गैर-अनुकूलित कार्यक्रम के सापेक्ष प्रदर्शन लाभ का प्रतिशत दर्शाता है। एक्स-एक्सिस इस्तेमाल किए गए डिवाइडर को दिखाता है।

पूर्ण प्रदर्शन

Y अक्ष पर नीचे दिए गए रेखांकन सेकंड में कार्यक्रम का निष्पादन समय और एक्स अक्ष पर उपयोग किए गए विभाजक को दिखाते हैं। किंवदंती में, -PGO का अर्थ है अनुकूलन के बिना, अनुकूलन के साथ + PGO।

निष्कर्ष

इस विशेष कार्यक्रम के लिए, पीजीओ-आधारित अनुकूलन अत्यंत उपयोगी है और 5-25% की स्थिर प्रदर्शन वृद्धि प्रदान करता है।

सोर्स कोड वाली फाइल, टेस्ट स्क्रिप्ट और ग्राफिंग स्क्रिप्ट डाउनलोड की जा सकती है।

संग्रह की संरचना इस प्रकार है:

pgo-1 / fprofile-generate - -fprofile-generate फ्लैग के साथ बिल्ड स्क्रिप्ट बनाएं
pgo-1 / fprofile-use - एक निर्माण स्क्रिप्ट को -fprofile-use ध्वज के साथ बनाएँ
pgo-1 / रिलीज़ - नियमित संस्करण के निर्माण के लिए स्क्रिप्ट बनाएं
pgo-1 / src - स्रोत कोड
pgo-1 / graph.pl - चार्ट पीढ़ी स्क्रिप्ट (सुपर_लॉग फ़ाइल पढ़ता है)
pgo-1 / run.sh - परीक्षण चक्र शुरू करने के लिए स्क्रिप्ट

graph.pl एक लॉग फ़ाइल के साथ काम करता है जिसका प्रारूप रन.श कमांड के आउटपुट से मेल खाता है
उदाहरण के लिए, आप इस तरह से भाग सकते हैं:

./run.sh> लॉग 2> और 1
टेल लॉग | grep -A2 PGO

युपीडी। परीक्षण परियोजना को झंडे के साथ बनाया गया था -O3 -ार्च = मूल -mtune = मूल PGO के बिना, और -O3 -ch = मूल -mtune = मूल निवासी PGO के साथ। सभी रेखांकन -O3 -march = देशी -mtune = देशी के सापेक्ष वृद्धि दर्शाते हैं।

दर्पण लेख