🕞 ™️ 🥇 एलएलवीएम के साथ कोड प्रोफाइलिंग 🏂🏿 👨🏼‍🔧 🛬

गैर-निर्धारकवाद का अभिशाप

एलएलवीएम पास लिखने का मेरा पहला प्रयास - मुझे ये सेग्लॉटी पसंद है

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

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

प्रेरणा

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

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

एलएलवीएम बायटेकोड

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

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

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

क्लैंग C ++ कोड को LLVM IR में परिवर्तित करता है, जिसे बाद में LLVM बैकएंड द्वारा मशीन कोड में बदल दिया जाता है।

क्लैंग एलएलवीएम का सीमांत है। चूंकि हमें कोड को मापने के लिए एक क्रॉस-प्लेटफ़ॉर्म विधि की आवश्यकता है, इसलिए हम बाइनरी कोड लिख नहीं सकते। LLVM IR, हालांकि, प्लेटफ़ॉर्म स्वतंत्र है, क्योंकि यह कोड का केवल एक मध्यवर्ती प्रतिनिधित्व है। एलएलवीएम पुस्तकालयों के साथ इंस्ट्रूमेंटिंग आईआर कोड एक सरल क्रॉस-प्लेटफॉर्म समाधान है।

निर्णय

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

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

अब हम इसकी कोशिश क्यों नहीं करते? यह कोड वर्ण योगदानकर्ता द्वारा प्रदान किया गया कोड का एक स्निपेट है:

// Make the soldiers who aren't patrolling attack the enemy for (int i = NUM_SOLDIERS / 2; i < NUM_SOLDIERS; ++i) { auto &soldier = state.soldiers[i]; if (soldier.hp == 0) // If this soldier is dead, skip it continue; for (auto enemy_soldier : state.enemy_soldiers) { if (enemy_soldier.hp != 0) { // Ensure your prospective target has // not already been slain soldier.soldier_target = enemy_soldier.id; break; } } }

Github लिंक: https://gist.github.com/JHurricane96/8c9c3a45ec5e969de4d9fecb47ebef69#file-player_code-cpp

इस तथ्य का उपयोग करते हुए कि आधार इकाई में केवल एक इनपुट बिंदु (पहला निर्देश) है, हम इस टुकड़े को निम्नलिखित आधार इकाइयों में विभाजित कर सकते हैं:

 //-------------------------------- BB 1 ---------------------------------- for (int i = NUM_SOLDIERS / 2; i < NUM_SOLDIERS; ++i) { //-------------------------------- BB 2 ---------------------------------- auto &soldier = state.soldiers[i]; if (soldier.hp == 0) //-------------------------------- BB 3 ---------------------------------- continue; //-------------------------------- BB 4 ---------------------------------- for (auto enemy_soldier : state.enemy_soldiers) { //-------------------------------- BB 5 ---------------------------------- if (enemy_soldier.hp != 0) { //-------------------------------- BB 6 ---------------------------------- soldier.soldier_target = enemy_soldier.id; break; //-------------------------------- BB 7 ---------------------------------- } } }

जीथब लिंक
इससे हमें यह समझने में मदद मिली कि बुनियादी ब्लॉक कैसे काम करते हैं, अब आइए LLVM IR में इस एल्गोरिदम को देखें:

 ; <label>:140: ; preds = %181, %139 %141 = load i32, i32* %19, align 4 %142 = sext i32 %141 to i64 %143 = icmp slt i64 %142, 20 br i1 %143, label %144, label %184 ; <label>:144: ; preds = %140 %145 = getelementptr inbounds %"struct.player_state::State", %"struct.player_state::State"* %2, i32 0, i32 1 %146 = load i32, i32* %19, align 4 %147 = sext i32 %146 to i64 %148 = call dereferenceable(72) %"struct.player_state::Soldier"* @_ZNSt5arrayIN12player_state7SoldierELm20EEixEm( %"struct.std::array.10"* %145, i64 %147) #3 store %"struct.player_state::Soldier"* %148, %"struct.player_state::Soldier"** %20, align 8 %149 = load %"struct.player_state::Soldier"*, %"struct.player_state::Soldier"** %20, align 8 %150 = getelementptr inbounds %"struct.player_state::Soldier", %"struct.player_state::Soldier"* %149, i32 0, i32 2 %151 = load i64, i64* %150, align 8 %152 = icmp eq i64 %151, 0 br i1 %152, label %153, label %154 ; <label>:153: ; preds = %144 br label %181

जीथब लिंक

यदि आप ध्यान से देखेंगे, तो आप देखेंगे कि ऊपर का कोड टुकड़ा LLVM IR में संकलित C ++ कोड टुकड़ा का पहला तीन खंड है (प्रत्येक पंक्ति आधार ब्लॉक की शुरुआत है)।

LLVM में लाइब्रेरीज़ हैं जो हमें "पास" लिखने की अनुमति देती हैं - कोड जो LLVM IR को बदल सकता है। LLVM API हमें मॉड्यूल, फ़ंक्शंस और बेस ब्लॉक्स के माध्यम से पुनरावृत्ति करके LLVM IR को आसानी से पढ़ने और विश्लेषण करने की अनुमति देता है, और मशीन कोड में संकलित करने से पहले LLVM IR को संशोधित करता है।

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

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

हमारे साधन आईआर इस तरह काम करता है:

 ; <label>:140: ; preds = %181, %139 %141 = load i32, i32* %19, align 4 %142 = sext i32 %141 to i64 %143 = icmp slt i64 %142, 20 call void @_Z14IncrementCountm(i32 4) br i1 %143, label %144, label %184 ; <label>:144: ; preds = %140 %145 = getelementptr inbounds %"struct.player_state::State", %"struct.player_state::State"* %2, i32 0, i32 1 %146 = load i32, i32* %19, align 4 %147 = sext i32 %146 to i64 %148 = call dereferenceable(72) %"struct.player_state::Soldier"* @_ZNSt5arrayIN12player_state7SoldierELm20EEixEm( %"struct.std::array.10"* %145, i64 %147) #3 store %"struct.player_state::Soldier"* %148, %"struct.player_state::Soldier"** %20, align 8 %149 = load %"struct.player_state::Soldier"*, %"struct.player_state::Soldier"** %20, align 8 %150 = getelementptr inbounds %"struct.player_state::Soldier", %"struct.player_state::Soldier"* %149, i32 0, i32 2 %151 = load i64, i64* %150, align 8 %152 = icmp eq i64 %151, 0 call void @_Z14IncrementCountm(i32 10) br i1 %152, label %153, label %154 ; <label>:153: ; preds = %144 call void @_Z14IncrementCountm(i32 1) br label %181

जीथब लिंक

जैसा कि हम देख सकते हैं, अंतिम विवरण से ठीक पहले प्रत्येक बेस ब्लॉक के अंत में एक IncrementCount कॉल किया जाता है। IncrementCount के साथ काम करने वाले स्थिर इंट का उपयोग करके, हम प्रत्येक प्रतिभागी के कदम के अंत में निर्देशों की संख्या प्राप्त कर सकते हैं। यह विधि नियतात्मक और क्रॉस-प्लेटफॉर्म है, जैसा कि यदि हम कंपाइलर के समान संस्करण और समान झंडे का उपयोग करते हैं तो समान एलएलवीएम आईआर उत्पन्न करने के लिए समान स्रोत कोड की गारंटी दी जाती है।

निष्कर्ष

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

आप यहाँ पास का स्रोत कोड प्राप्त कर सकते हैं ।

एलएलवीएम के साथ कोड प्रोफाइलिंग

गैर-निर्धारकवाद का अभिशाप

प्रेरणा

एलएलवीएम बायटेकोड

निर्णय

निष्कर्ष

More articles: