आधुनिक (पाइपलाइन/सुपरस्कालर) प्रोसेसर पर x86 प्रतिनिधि निर्देशों का प्रदर्शन

Question

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

मैं समझ सकता हूं कि क्यों इंटेल मूल रूप से प्रतिनिधि निर्देशों को लागू करता था जब प्रोसेसर केवल एक समय में एक निर्देश चलाते थे, लेकिन क्या अब उनका उपयोग करने का कोई फायदा है?

एक लूप के साथ जो अधिक निर्देशों को संकलित करता है, वहां पाइपलाइन को भरने और/या ऑर्डर जारी करने के लिए और कुछ भी है। क्या आधुनिक प्रोसेसर इन rep-prefixed निर्देशों के लिए अनुकूलित करने के लिए बनाया गया है, या आधुनिक कोड में शायद ही कभी निर्देशों का उपयोग किया जाता है कि वे निर्माताओं के लिए महत्वपूर्ण नहीं हैं?

Answer 1

एएमडी और इंटेल के अनुकूलन मार्गदर्शिका दोनों में इस तरह के प्रश्नों के लिए बहुत सी जगह दी गई है।

• AMD Software Optimization Guide (Sep/2005), खंड 8.3, स्नातकोत्तर: अलग सीपीयू पीढ़ियों, अलग ढंग से व्यवहार उदाहरण के लिए - इस क्षेत्र में दी गयी सलाह की वैधता "आधा जीवन" है। 167:
  स्ट्रिंग ऑपरेशंस करते समय आरईपी उपसर्ग का उपयोग करने से बचें, खासकर जब स्मृति के ब्लॉक की प्रतिलिपि बनाते हैं।
• AMD Software Optimization Guide (Apr/2011), धारा 9.3, पृष्ठ। 148:
  स्ट्रिंग ऑपरेशंस करते समय आरईपी उपसर्ग को का उपयोग करें।

Intel Architecture Optimization Manual पर तालिका 7-2 (rep stosd सहित) विभिन्न ब्लॉक प्रति तकनीकों के लिए प्रदर्शन की तुलना आंकड़े देता है। मेमोरी कॉपी रूटीन के संबंधित प्रदर्शन, पृष्ठ। 7-37f।, विभिन्न CPUs के लिए, और फिर एक पर सबसे तेज़ क्या हो सकता है दूसरों पर सबसे तेज़ नहीं हो सकता है।

कई मामलों के लिए, हालिया x86 CPUs (जिसमें "स्ट्रिंग" एसएसई 4.2 ऑपरेशंस है) सिम इकाई के माध्यम से स्ट्रिंग ऑपरेशन कर सकते हैं, this investigation देखें।

इस सब पर अनुवर्ती करने के लिए (और/या चीजें फिर से बदलते समय खुद को अद्यतन रखें), Agner Fog's Optimization guides/blogs पढ़ें।

Answer 2

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

छोटे तारों (शायद लगभग 16 बाइट्स) के लिए इसे सरल निर्देशों के साथ मैन्युअल रूप से करने के लिए संभवतः तेज़ है, क्योंकि यह अधिक जटिल तकनीकों की सेटअप लागत से बचाता है (और निश्चित आकार तारों के लिए आसानी से अनलॉक किया जा सकता है)। मध्यम आकार के तारों के लिए (शायद 16 बाइट्स से 4 कीबीबी तक) "आरईपी MOVSD" जैसे कुछ (कुछ गलत तरीके से गलत होने पर "MOVSB" निर्देशों को फेंक दिया गया है) सबसे अच्छा होने की संभावना है।

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

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

Answer 3

चूंकि किसी ने आपको कोई संख्या नहीं दी है, इसलिए मैं आपको कुछ कचरा कलेक्टर बेंचमार्क करके पाया है जो बहुत ही गड़बड़ है। प्रतिलिपि बनाने के लिए मेरी वस्तुओं 60% 16 बाइट लंबाई में हैं और शेष 30% 500 - 8000 बाइट्स हैं या तो।

• पूर्वशर्त: दोनों dst, src और n 8.
• प्रोसेसर के गुणकों हैं: AMD Phenom (टीएम) द्वितीय X6 1090T प्रोसेसर 64 बिट/लिनक्स

यहाँ मेरी तीन memcpy वेरिएंट हैं:

हाथ कोडित जबकि पाश:

if (n == 16) { 
    *dst++ = *src++; 
    *dst++ = *src++; 
} else { 
    size_t n_ptrs = n/sizeof(ptr); 
    ptr *end = dst + n_ptrs; 
    while (dst < end) { 
     *dst++ = *src++; 
    } 
} 

(ptruintptr_t पर उपनाम है)। समय: 101.16%

rep movsb

if (n == 16) { 
    *dst++ = *src++; 
    *dst++ = *src++; 
} else { 
    asm volatile("cld\n\t" 
       "rep ; movsb" 
       : "=D" (dst), "=S" (src) 
       : "c" (n), "D" (dst), "S" (src) 
       : "memory"); 
} 

समय: 103.22%

rep movsq

if (n == 16) { 
    *dst++ = *src++; 
    *dst++ = *src++; 
} else { 
    size_t n_ptrs = n/sizeof(ptr); 
    asm volatile("cld\n\t" 
       "rep ; movsq" 
       : "=D" (dst), "=S" (src) 
       : "c" (n_ptrs), "D" (dst), "S" (src) 
       : "memory"); 
} 

समय: 100.00%

req movsq एक छोटे अंतर से जीत।