IOS प्लेटफॉर्म के लिए गेम्स का अनुकूलन। कोड वैश्वीकरण

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

यह लेख सम्मेलन की रिपोर्ट के रूप में शुरू हुआ, जो 24.11 को आयोजित किया जाएगा। IPhone अनुकूलन युक्तियों का खजाना यहां पाया जा सकता है । निम्नलिखित लेख इस प्रस्तुति से सामग्री की चौड़ाई और गहराई का विस्तार करेंगे।

नीयन क्या है? NEON ARM प्रोसेसर में इस्तेमाल होने वाला एक सामान्य-उद्देश्य वाला SIMD इंजन है। बोर्ड पर प्रत्येक में 128 बिट्स के 16 रजिस्टर हैं, जिन्हें 64 बिट्स के 32 रजिस्टरों के रूप में माना जा सकता है। NEON VFP के साथ अपने रजिस्टरों को साझा करता है, हालांकि इसकी अपनी अलग पाइपलाइन है। एसएसई के साथ, डेटा को 16 बाइट्स द्वारा संरेखित किया जाना चाहिए। नियॉन को यह भी पता है कि बिना डेटा के कैसे काम करना है, लेकिन आमतौर पर यह 2 गुना धीमा होता है।

नीयन के साथ काम कर सकते हैं:

• हस्ताक्षरित \ अहस्ताक्षरित 8 \ 16 \ 32 \ 64-बिट पूर्णांक डेटा प्रकार;
• एकल सटीक फ्लोटिंग पॉइंट नंबर - 32-बिट फ्लोट।

यह गेम सहित मल्टीमीडिया कार्यों के लिए बहुत अच्छा है।

आइए मुख्य एक से शुरू करें - हर आधुनिक मोबाइल सिस्टम का दिल, एक चिप या SoC पर एक सिस्टम (सिस्टम ऑन चिप)। यह ज्ञात है कि iOS A डिवाइस चिप पर Apple A श्रृंखला के सिस्टम - A4, A5, A5x, A6 और A6x का उपयोग करते हैं। इन चिप्स के सबसे महत्वपूर्ण विनिर्देश तालिका में दिए गए हैं:

सीपीयू विनिर्देशों	ए 4	A5	A5X	ए 6
आर्किटेक्चर	ARMv7	ARMv7	ARMv7	ARMv7
कोर	कोर्टेक्स ए 8	कोर्टेक्स ए 9	कोर्टेक्स ए 9	खुद का विकास
# कोर	1	2	2	2
फ्रीक्वेंसी, मेगाहर्ट्ज	800	1000	1000	1300
विस्तार	VFPv3 (VFPLite), नीयन	VFPv3, नीयन	VFPv3, नीयन	VFPv4, नीयन
GPU विनिर्देशों
आदर्श	पावरवीआर एसजीएक्स 535	PowerVR SGX 543MP2	पावरवीआर एसजीएक्स 543 एमपी 4	पावरवीआर एसजीएक्स 543 एमपी 3
फ्रीक्वेंसी, मेगाहर्ट्ज	200	200	200	266

* नोट: नीयन सीपीयू आवृत्ति पर चलता है

यह देखना आसान है कि GPU की तुलना में NEON की आवृत्ति में 5 गुना वृद्धि हुई है! बेशक, इसका मतलब यह नहीं है कि हमें GPU - IPC, पाइपलाइन, आदि की तुलना में प्रदर्शन में 5 गुना वृद्धि मिलेगी। महत्वपूर्ण हैं। लेकिन NEON में एक फीचर किलर है - यह एक साथ 4 32-बिट फ्लोट्स को प्रोसेस कर सकता है, जबकि PowerVR SGX केवल एक है। ऐसा लगता है कि PowerVR SGX 5-सीरीज़ के SIMD रजिस्टरों की लंबाई 64 बिट्स है, क्योंकि GPU एक साथ 4 अर्ध-सटीक फ़्लोट्स (16 बिट्स) को संसाधित कर सकता है। एक उदाहरण पर विचार करें:

highp vec4 v1, v2; highp float s1, s2; //  v2 = (v1 * s1) * s2; //v1 * s1      – 4 ,       s2,     -  4 . //8    //  v2 = v1 * (s1 * s2); //s1 * s2 – 1    ;  * v1 – 4   . //5    

अब GPU वेक्टर इंजन पर निष्पादित एक अन्य उदाहरण पर विचार करें:

 mediump vec4 v1, v2, v3; highp vec4 s1, s2, s3; v3 = v1 * v2; //    – 1  s3 = s1 * s2; //    – 4  

आपको अपने डेटा के लिए एक हाई स्पेसियर की आवश्यकता होगी, उदाहरण के लिए, कोने की स्थिति। नीयन से लाभ यहाँ स्पष्ट है।

अब चलिए NEON के एक और लाभ पर चलते हैं। PowerVR SGX 5 सीरीज़ को USSE के लिए जाना जाता है , जो एक shader प्रोसेसर है जो इस बात से कोई फर्क नहीं पड़ता है कि किस प्रकार के shader को प्रोसेस करना है, वर्टेक्स या पिक्सेल। इसका मतलब यह है कि प्रोग्रामर के पास एक निश्चित बिजली बजट है और यह उसके ऊपर है कि वह यह तय करे कि उसे वर्सेटेक्स या पिक्सेल प्रोसेसिंग पर खर्च करना है या नहीं। यह वह जगह है जहां नीयन बचाव के लिए आता है - यह आपका नया शीर्ष प्रोसेसर है। आप सोच सकते हैं कि मैं यहां ट्रोलफेस डालना भूल गया, लेकिन यह सब बहुत गंभीर है। लगभग हर मोबाइल सिस्टम का प्रदर्शन फिल दर से सीमित है, विशेषकर 2 डी गेम्स में, विशेषकर आजकल स्क्रीन रिज़ॉल्यूशन के लिए दौड़। नीयन के लिए सभी वर्टेक्स प्रोसेसिंग को स्थानांतरित करना, आप पिक्सेल प्रसंस्करण के लिए संसाधनों को मुक्त करते हैं। इसके अलावा, NEON ड्रॉ कॉल की संख्या को कम करने में मदद करेगा - विश्व समन्वय में एक बैच के सभी कोने की स्थिति की गणना करें और एन कॉल को एक कॉल में ड्रा करें।

थ्योरी खत्म हो गई है! अब चलो कट्टर करने के लिए! NEON का लाभ उठाने के कई तरीके हैं:

• कंपाइलर को आपके लिए कोड वेक्टर करना चाहिए। बुरा तरीका। कंपाइलर वेक्टर हो सकता है ... या यह वेक्टर नहीं हो सकता है। यहां तक ​​कि अगर कंपाइलर कोड को वेक्टर करता है, तो यह इस तथ्य से बहुत दूर है कि यह सबसे अच्छा कोड होगा। लेकिन, दूसरी ओर, इस विधि को आपके हिस्से पर किसी भी प्रयास की आवश्यकता नहीं है, और आप लाभ प्राप्त कर सकते हैं। लेकिन फिर भी, आपको संकलक पर आंख बंद करके भरोसा नहीं करना चाहिए, लेकिन मैन्युअल रूप से कम से कम सबसे महत्वपूर्ण कोड को वेक्टर करना चाहिए।
• नीयन कोडक। और यहाँ वह, कट्टर है। सच्ची जेडी का रास्ता और वह सब। हमें डार्क मैजिक सीखना होगा, एआरएम मैनुअल आदि पर रातें बितानी होंगी। यह भी ध्यान में रखने योग्य है कि ARM और Thumb-2 मोड में NEON कोड काम करता है।
• नियोन आंतरिक (x86 के लिए एसएसई के समान)। असेंबलर के विपरीत, जहां कंपाइलर मूर्खतापूर्ण रूप से सम्मिलित करता है कि उसे क्या दिया गया था, आंतरिकता को अनुकूलित किया जाएगा। उनके साथ रहना बहुत आसान है - निर्देशों का समय अध्ययन करने की आवश्यकता नहीं है, पाइप के ठहराव से बचने के लिए उन्हें फेरबदल करें, आदि।
• पहले से ही वेक्टर कोड के साथ उपयोग करें - GLKMath, गणित नियॉन।

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

सभी डेटा एक VBO में संग्रहीत किया जाता है। अद्यतन विधि एक यादृच्छिक स्थिति के ModelView मैट्रिक्स द्वारा प्रक्षेपण मैट्रिक्स को गुणा करती है। अगला, प्रत्येक स्प्राइट के प्रत्येक शीर्ष को परिणामी ModelViewProjection मैट्रिक्स द्वारा गुणा किया जाएगा। प्रत्येक शीर्ष की अंतिम स्थिति को केवल शीर्ष shader में gl_Position को पास किया जाएगा। सभी डेटा 16 बाइट्स की सीमा से जुड़ा हुआ है।

विधि अद्यतन कोड:

 void Update() { GLKMatrix4 modelviewMat = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, }; const u32 QUADS_COUNT = 10000; const u32 VERTS_PER_QUAD = 4; const float Y_DELTA = 420.0f / QUADS_COUNT; //     Y float vertDelta = Y_DELTA; for (int i = 0; i < QUADS_COUNT * VERTS_PER_QUAD; i += VERTS_PER_QUAD) { float randX = random() % 260; //     modelviewMat.m[12] = randX; modelviewMat.m[13] = vertDelta; float32x4x4_t mvp; Matrix4ByMatrix4((float32x4x4_t*)proj.m, (float32x4x4_t*)modelviewMat.m, &mvp); for (int j = 0; j < 4; ++j) { Matrix4ByVec4(&mvp, &squareVertices[j], &data[i + j].pos); } vertDelta += Y_DELTA; } glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STREAM_DRAW); } 

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

कॉपी पेस्ट GLKMath के साथ:

 static __inline__ GLKVector4 GLKMatrix4MultiplyVector4(GLKMatrix4 matrixLeft, GLKVector4 vectorRight) { float32x4x4_t iMatrix = *(float32x4x4_t *)&matrixLeft; float32x4_t v; iMatrix.val[0] = vmulq_n_f32(iMatrix.val[0], (float32_t)vectorRight.v[0]); iMatrix.val[1] = vmulq_n_f32(iMatrix.val[1], (float32_t)vectorRight.v[1]); iMatrix.val[2] = vmulq_n_f32(iMatrix.val[2], (float32_t)vectorRight.v[2]); iMatrix.val[3] = vmulq_n_f32(iMatrix.val[3], (float32_t)vectorRight.v[3]); iMatrix.val[0] = vaddq_f32(iMatrix.val[0], iMatrix.val[1]); iMatrix.val[2] = vaddq_f32(iMatrix.val[2], iMatrix.val[3]); v = vaddq_f32(iMatrix.val[0], iMatrix.val[2]); return *(GLKVector4 *)&v; } static __inline__ GLKMatrix4 GLKMatrix4Multiply(GLKMatrix4 matrixLeft, GLKMatrix4 matrixRight) { float32x4x4_t iMatrixLeft = *(float32x4x4_t *)&matrixLeft; float32x4x4_t iMatrixRight = *(float32x4x4_t *)&matrixRight; float32x4x4_t m; m.val[0] = vmulq_n_f32(iMatrixLeft.val[0], vgetq_lane_f32(iMatrixRight.val[0], 0)); m.val[1] = vmulq_n_f32(iMatrixLeft.val[0], vgetq_lane_f32(iMatrixRight.val[1], 0)); m.val[2] = vmulq_n_f32(iMatrixLeft.val[0], vgetq_lane_f32(iMatrixRight.val[2], 0)); m.val[3] = vmulq_n_f32(iMatrixLeft.val[0], vgetq_lane_f32(iMatrixRight.val[3], 0)); m.val[0] = vmlaq_n_f32(m.val[0], iMatrixLeft.val[1], vgetq_lane_f32(iMatrixRight.val[0], 1)); m.val[1] = vmlaq_n_f32(m.val[1], iMatrixLeft.val[1], vgetq_lane_f32(iMatrixRight.val[1], 1)); m.val[2] = vmlaq_n_f32(m.val[2], iMatrixLeft.val[1], vgetq_lane_f32(iMatrixRight.val[2], 1)); m.val[3] = vmlaq_n_f32(m.val[3], iMatrixLeft.val[1], vgetq_lane_f32(iMatrixRight.val[3], 1)); m.val[0] = vmlaq_n_f32(m.val[0], iMatrixLeft.val[2], vgetq_lane_f32(iMatrixRight.val[0], 2)); m.val[1] = vmlaq_n_f32(m.val[1], iMatrixLeft.val[2], vgetq_lane_f32(iMatrixRight.val[1], 2)); m.val[2] = vmlaq_n_f32(m.val[2], iMatrixLeft.val[2], vgetq_lane_f32(iMatrixRight.val[2], 2)); m.val[3] = vmlaq_n_f32(m.val[3], iMatrixLeft.val[2], vgetq_lane_f32(iMatrixRight.val[3], 2)); m.val[0] = vmlaq_n_f32(m.val[0], iMatrixLeft.val[3], vgetq_lane_f32(iMatrixRight.val[0], 3)); m.val[1] = vmlaq_n_f32(m.val[1], iMatrixLeft.val[3], vgetq_lane_f32(iMatrixRight.val[1], 3)); m.val[2] = vmlaq_n_f32(m.val[2], iMatrixLeft.val[3], vgetq_lane_f32(iMatrixRight.val[2], 3)); m.val[3] = vmlaq_n_f32(m.val[3], iMatrixLeft.val[3], vgetq_lane_f32(iMatrixRight.val[3], 3)); return *(GLKMatrix4 *)&m; } 

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

कोडांतरक दृष्टिकोण:

 inline void Matrix4ByVec4(float32x4x4_t* __restrict__ mat, const float32x4_t* __restrict__ vec, float32x4_t* __restrict__ result) { asm ( "vldmia %0, { d24-d31 } \n\t" "vld1.32 {q1}, [%1]\n\t" "vmul.f32 q0, q12, d2[0]\n\t" "vmla.f32 q0, q13, d2[1]\n\t" "vmla.f32 q0, q14, d3[0]\n\t" "vmla.f32 q0, q15, d3[1]\n\t" "vstmia %2, { q0 }" : : "r" (mat), "r" (vec), "r" (result) : "memory", "q0", "q1", "q8", "q9", "q10", "q11" ); } inline void Matrix4ByMatrix4(const float32x4x4_t* __restrict__ m1, const float32x4x4_t* __restrict__ m2, float32x4x4_t* __restrict__ r) { asm ( "vldmia %1, { q0-q3 } \n\t" "vldmia %2, { q8-q11 }\n\t" "vmul.f32 q12, q8, d0[0]\n\t" "vmul.f32 q13, q8, d2[0]\n\t" "vmul.f32 q14, q8, d4[0]\n\t" "vmul.f32 q15, q8, d6[0]\n\t" "vmla.f32 q12, q9, d0[1]\n\t" "vmla.f32 q13, q9, d2[1]\n\t" "vmla.f32 q14, q9, d4[1]\n\t" "vmla.f32 q15, q9, d6[1]\n\t" "vmla.f32 q12, q10, d1[0]\n\t" "vmla.f32 q13, q10, d3[0]\n\t" "vmla.f32 q14, q10, d5[0]\n\t" "vmla.f32 q15, q10, d7[0]\n\t" "vmla.f32 q12, q11, d1[1]\n\t" "vmla.f32 q13, q11, d3[1]\n\t" "vmla.f32 q14, q11, d5[1]\n\t" "vmla.f32 q15, q11, d7[1]\n\t" "vstmia %0, { q12-q15 }" : : "r" (result), "r" (m2), "r" (m1) : "memory", "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15" ); } 

कोडांतरक से परिचित न होने वाले व्यक्ति के लिए, सब कुछ बहुत डरावना लगता है - मैं खुद ऐसा हूं, मैं केवल NEON कोडांतरक को समझ सकता हूं। लेकिन वास्तव में, यहां सब कुछ सरल है - q1-q15 , वास्तव में, नीयन रजिस्टर हैं। vldmia \ vld1.32 - निर्देश डाउनलोड करें; vstmia - स्मृति में संरक्षण; vmul.f32 \ vmla.f32 - गुणा करें और जोड़ें।

आंतरिक विधि:

 inline void Matrix4ByVec4(float32x4x4_t* __restrict__ mat, const float32x4_t* __restrict__ vec, float32x4_t* __restrict__ result) { (*result) = vmulq_n_f32((*mat).val[0], (*vec)[0]); (*result) = vmlaq_n_f32((*result), (*mat).val[1], (*vec)[1]); (*result) = vmlaq_n_f32((*result), (*mat).val[2], (*vec)[2]); (*result) = vmlaq_n_f32((*result), (*mat).val[3], (*vec)[3]); } inline void Matrix4ByMatrix4(const float32x4x4_t* __restrict__ m1, const float32x4x4_t* __restrict__ m2, float32x4x4_t* __restrict__ r) { (*r).val[0] = vmulq_n_f32((*m1).val[0], vgetq_lane_f32((*m2).val[0], 0)); (*r).val[1] = vmulq_n_f32((*m1).val[0], vgetq_lane_f32((*m2).val[1], 0)); (*r).val[2] = vmulq_n_f32((*m1).val[0], vgetq_lane_f32((*m2).val[2], 0)); (*r).val[3] = vmulq_n_f32((*m1).val[0], vgetq_lane_f32((*m2).val[3], 0)); (*r).val[0] = vmlaq_n_f32((*r).val[0], (*m1).val[1], vgetq_lane_f32((*m2).val[0], 1)); (*r).val[1] = vmlaq_n_f32((*r).val[1], (*m1).val[1], vgetq_lane_f32((*m2).val[1], 1)); (*r).val[2] = vmlaq_n_f32((*r).val[2], (*m1).val[1], vgetq_lane_f32((*m2).val[2], 1)); (*r).val[3] = vmlaq_n_f32((*r).val[3], (*m1).val[1], vgetq_lane_f32((*m2).val[3], 1)); (*r).val[0] = vmlaq_n_f32((*r).val[0], (*m1).val[2], vgetq_lane_f32((*m2).val[0], 2)); (*r).val[1] = vmlaq_n_f32((*r).val[1], (*m1).val[2], vgetq_lane_f32((*m2).val[1], 2)); (*r).val[2] = vmlaq_n_f32((*r).val[2], (*m1).val[2], vgetq_lane_f32((*m2).val[2], 2)); (*r).val[3] = vmlaq_n_f32((*r).val[3], (*m1).val[2], vgetq_lane_f32((*m2).val[3], 2)); (*r).val[0] = vmlaq_n_f32((*r).val[0], (*m1).val[3], vgetq_lane_f32((*m2).val[0], 3)); (*r).val[1] = vmlaq_n_f32((*r).val[1], (*m1).val[3], vgetq_lane_f32((*m2).val[1], 3)); (*r).val[2] = vmlaq_n_f32((*r).val[2], (*m1).val[3], vgetq_lane_f32((*m2).val[2], 3)); (*r).val[3] = vmlaq_n_f32((*r).val[3], (*m1).val[3], vgetq_lane_f32((*m2).val[3], 3)); } 

GLKMath में लगभग समान कोड, लेकिन मामूली अंतर हैं। स्पष्टीकरण: vmulq_n_f32 - एक स्केलर द्वारा एक वेक्टर का गुणन; vgetq_lane_f32 - एक मैक्रो जो एक वेक्टर से एक स्केलर का चयन करता है; vmlaq_n_f32 - एक स्केलर से गुणा करें और जोड़ें। यह कोड आंतरिक में कोडांतरक का प्रतिबिंब है। आइए देखें कि वह उसकी तुलना में खुद को कैसे दिखाएगा।

मैंने iPod टच 4 पर एक परीक्षण किया। तालिका में अद्यतन फ़ंक्शन के रूपरेखा परिणाम हैं:

दृष्टिकोण	निष्पादन समय, एमएस	CPU लोड,%
एफपीयू	6058 + 5067 *	35-38
GLKMath	2789	20-23
कोडांतरक	5304	23-25
Intrinsiki	2803	18-20

* इंस्ट्रूमेंट्स से स्क्रीनशॉट में , आप देख सकते हैं कि Matrix4ByMatrix4 फ़ंक्शन इनबिल्ड नहीं है।

यहां एक और टिप है - आक्रामक रूप से अपने प्रदर्शन-महत्वपूर्ण कोड को इनलाइन करें। ऐसे मामलों में नियमित रूप से इनलाइन पर __attribute __ ((always_inline)) को प्राथमिकता दें।

अद्यतन परिणाम तालिका:

दृष्टिकोण	निष्पादन समय, एमएस	CPU लोड,%
एफपीयू ने बल दिया	6209	25-28
GLKMath	2789	20-23
कोडांतरक	5304	23-25
Intrinsiki	2803	18-20

मजबूर इनलाइन ने बहुत अच्छा प्रदर्शन को बढ़ावा दिया! आइए देखें कि ऑटो-वेक्टरकरण कोड खुद को कैसे दिखाएगा। हमें बस इतना करना है कि परियोजना सेटिंग्स में अन्य सी फ्लैग के लिए केवल -mllvm –vectorize –mllvm -bb-वेक्टर-एलाइड-केवल- जोड़ें।

परिणामों की अंतिम तालिका:

दृष्टिकोण	निष्पादन समय, एमएस	निष्पादन समय (वेक्टर), एमएस	CPU लोड,%	CPU लोड (वेक्टर),%
एफपीयू ने बल दिया	6209	5028	25-28	22-24
GLKMath	2789	2776	20-23	20-23
कोडांतरक	5304	5291	23-25	22-24
Intrinsiki	2803	2789	18-20	18-20

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


जायजा लेने का समय आ गया है। कई निष्कर्ष निकाले जा सकते हैं:

• एलएलवीएम में इंजीनियरों ने एक उत्कृष्ट कार्य किया। नतीजतन, संकलक अच्छी तरह से अनुकूलित आंतरिक कोड उत्पन्न करता है। मैंने एक साल पहले इसी तरह का परीक्षण किया था जब एक्सकोड में एकमात्र कंपाइलर जीसीसी 4.2 था और इसने एफपीयू कोड की तुलना में केवल 10-15% प्रदर्शन लाभ प्राप्त किया था। यह बहुत अच्छी खबर है - कोडांतरक सीखने की कोई आवश्यकता नहीं है और मैं इसके बारे में अविश्वसनीय रूप से खुश हूं!
• क्लैंग कंपाइलर ऑटो-वेक्टराइज़ कोड में सक्षम है। एक प्रोग्रामर के लिए, यह सिर्फ 4 शब्द लिखकर एक प्रदर्शन बोनस है। मैं और क्या कह सकता हूं सिवाय इसके कि यह एक अच्छी बात है?
• नियॉन कोड नियमित सी कोड की तुलना में प्रदर्शन में बहुत अच्छा बढ़ावा देता है - 2.22 बार! अनुकूलन के परिणामस्वरूप, GPU के पक्ष में इन बहुत वर्टीकल्स को कॉपी करने से वर्टेक्स प्रोसेसिंग तेज़ हो गया है! यदि आप मेम्ची असेंबलर को देखते हैं, तो आप देख सकते हैं कि NEON कोड का भी उपयोग किया जाता है। कॉर्टेक्स ए 8 में हार्डवेयर घुन की कमी धीमी कोड का कारण लगती है।
• इन सभी निम्न स्तरीय चीजों को सीखना समय के लायक है, खासकर यदि आपका लक्ष्य पेशेवर बनना है।

संदर्भ

www.arm.com/products/processors/technologies/neon.php
blogs.arm.com/software-enablement/161-coding-for-neon-part-1-load-and-stores
code.google.com/p/math-neon
llvm.org/devmtg/2012-04-12/Slides/Hal_Finkel.pdf
डेमो प्रोजेक्ट