हां, आपके डेटा के संरेखण और व्यवस्था दोनों प्रदर्शन में बड़ा अंतर ला सकते हैं, न केवल कुछ प्रतिशत बल्कि कुछ सैकड़ों से कई प्रतिशत तक।
यदि आप पर्याप्त लूप चलाते हैं, तो यह लूप, दो निर्देश द्रव्य लें।
.globl ASMDELAY
ASMDELAY:
subs r0,r0,#1
bne ASMDELAY
bx lr
कैश के साथ और उसके बिना, और शाखा भविष्यवाणी में कैश के साथ और बिना संरेखण के साथ और आप एक महत्वपूर्ण राशि (टाइमर टिक) द्वारा उन दो निर्देशों के प्रदर्शन को भिन्न कर सकते हैं:
min max difference
00016DDE 003E025D 003C947F
एक प्रदर्शन परीक्षण आप बहुत आसानी से खुद कर सकते हैं। परीक्षण के तहत कोड के आसपास नोड्स जोड़ें या निकालें, समय की सटीक कार्य करें, कैश लाइनों के किनारों को छूने के लिए पते की एक विस्तृत श्रृंखला के साथ परीक्षण के तहत निर्देशों को स्थानांतरित करें, आदि।
डेटा एक्सेस के साथ एक ही तरह की बात। कुछ आर्किटेक्चर आपको बिना डेटा एक्सेस के (बिना उदाहरण के लिए पता 0x1001 पर एक 32 बिट रीड का प्रदर्शन) के बारे में शिकायत करते हैं। उनमें से कुछ आप गलती को अक्षम कर सकते हैं और प्रदर्शन को हिट कर सकते हैं। अन्य लोग जो बिना किसी पहुंच के अनुमति देते हैं, आपको केवल प्रदर्शन हिट मिलता है।
यह कभी-कभी "निर्देश" होता है लेकिन अधिकांश समय यह घड़ी / बस चक्र होता है।
विभिन्न लक्ष्यों के लिए gcc में मेम्पेकी कार्यान्वयन देखें। मान लीजिए कि आप एक संरचना की नकल कर रहे हैं जो 0x43 बाइट्स है, तो आप एक कार्यान्वयन पा सकते हैं जो एक बाइट को 0x42 से कॉपी करता है, फिर 0x40 बाइट को बड़े कुशल चंक्स में कॉपी करता है, फिर अंतिम 0x2 यह दो अलग-अलग बाइट्स के रूप में या 16 बिट ट्रांसफर के रूप में हो सकता है। संरेखण और लक्ष्य खेल में आते हैं यदि स्रोत और गंतव्य पते 0x1003 और 0x2003 एक ही संरेखण पर हैं, तो आप एक बाइट कर सकते हैं, फिर 0x40 बड़े विखंडू में तो 0x2, लेकिन यदि एक 0x1002 और दूसरा 0x1003 है, तो यह हो जाता है असली बदसूरत और असली धीमी।
ज्यादातर समय यह बस चक्र है। या तबादलों की संख्या बदतर। एआरएम की तरह 64 बिट वाइड डेटा बस के साथ एक प्रोसेसर लें, और 0x1004 पते पर चार शब्द स्थानांतरण (पढ़ें या लिखें, एलडीएम या एसटीएम) करें, यह एक शब्द संरेखित पता है, और पूरी तरह से कानूनी है, लेकिन अगर बस 64 है बिट्स वाइड यह संभावना है कि एकल निर्देश इस मामले में तीन स्थानान्तरण में बदल जाएगा 0x1004 पर 32 बिट, 0x1008 पर 64 बिट और 0x100A पर 32 बिट। लेकिन अगर आपके पास एक ही निर्देश था, लेकिन 0x1008 पते पर यह 0x1008 पते पर एक एकल चार शब्द हस्तांतरण कर सकता है। प्रत्येक हस्तांतरण में एक सेटअप समय जुड़ा हुआ है। तो 0x1004 से 0x1008 पते का अंतर अपने आप में कई बार तेज हो सकता है, यहां तक कि / esp जब कैश का उपयोग करते हैं और सभी कैश हिट होते हैं।
बोलते हुए, भले ही आप पता 0x1000 बनाम 0x0FFC पर पढ़े जाने वाले दो शब्द करते हैं, 0x0FFC कैश मिस के साथ दो कैश लाइन का कारण बनने वाला है, जहां 0x1000 एक कैश लाइन है, आपके पास वैसे भी एक यादृच्छिक के लिए पढ़ी गई कैश लाइन का दंड है पहुँच (उपयोग करने से अधिक डेटा पढ़ना) लेकिन फिर वह दोगुना हो जाता है। आपकी संरचनाएं कैसे संरेखित होती हैं या आपके डेटा को सामान्य रूप से और उस डेटा को एक्सेस करने की आपकी आवृत्ति आदि, कैश थ्रैशिंग का कारण बन सकती हैं।
आप अपना डेटा स्ट्रिपिंग समाप्त कर सकते हैं जैसे कि आप डेटा को संसाधित करते हैं जिससे आप बेदखली पैदा कर सकते हैं, आप वास्तविक बदकिस्मत प्राप्त कर सकते हैं और अपने कैश के केवल एक अंश का उपयोग करके समाप्त कर सकते हैं और जैसे ही आप इसके माध्यम से कूदते हैं डेटा का अगला बूँद एक पूर्व बूँद के साथ टकराता है । स्रोत कोड आदि में अपने डेटा या पुन: व्यवस्थित कार्यों को मिलाकर, आप टकराव पैदा कर सकते हैं या हटा सकते हैं, क्योंकि सभी कैश नहीं बनाए जाते हैं क्योंकि संकलक आपकी मदद करने के लिए नहीं जा रहा है। यहां तक कि प्रदर्शन हिट या सुधार का पता लगाने के लिए आप पर है।
प्रदर्शन में सुधार करने के लिए हमने जो भी चीजें जोड़ी हैं, वे व्यापक डेटा busses, पाइपलाइनों, कैश, शाखा भविष्यवाणी, कई निष्पादन इकाइयों / रास्तों आदि में सबसे अधिक बार मदद करेंगे, लेकिन इन सभी में कमजोर स्पॉट होते हैं, जिनका जानबूझकर या आकस्मिक रूप से शोषण किया जा सकता है। इसके बारे में संकलक या पुस्तकालय बहुत कम कर सकते हैं, यदि आप प्रदर्शन में रुचि रखते हैं तो आपको ट्यून करने की आवश्यकता है और सबसे बड़ी ट्यूनिंग कारकों में से एक कोड और डेटा का संरेखण है, न कि केवल 32, 64, 128, 256 पर संरेखित करना। थोड़ी सी सीमाएँ, लेकिन यह भी कि जहाँ चीजें एक-दूसरे के सापेक्ष होती हैं, आप भारी मात्रा में उपयोग किए जाने वाले डेटा या फिर से उपयोग किए गए डेटा को उसी कैश तरीके से लैंड नहीं करना चाहते हैं, वे प्रत्येक अपना स्वयं का चाहते हैं। कम्पाइलर एक सुपर स्केलर आर्किटेक्चर के लिए निर्देशों के आदेश देने में मदद कर सकते हैं, एक-दूसरे के सापेक्ष निर्देशों को फिर से व्यवस्थित कर सकते हैं और न ही,
सबसे बड़ी निगरानी यह धारणा है कि प्रोसेसर अड़चन है। एक दशक या उससे अधिक के लिए सच नहीं है, प्रोसेसर को खिलाना समस्या है और यही वह जगह है जहां संरेखण प्रदर्शन हिट, कैश थ्रेशिंग, आदि जैसे मुद्दे खेलने में आते हैं। स्रोत कोड स्तर पर भी थोड़ा काम करने के साथ, एक संरचना में डेटा को फिर से व्यवस्थित करना, चर / संरचना की घोषणाओं का आदेश देना, स्रोत कोड के भीतर कार्यों का क्रम और डेटा को संरेखित करने के लिए थोड़ा अतिरिक्त कोड, कई बार प्रदर्शन में सुधार कर सकते हैं या अधिक।