सीपीयू स्तर पर कौन से ऑपकोड तेजी से होते हैं? [बन्द है]


19

हर प्रोग्रामिंग लैंग्वेज में ऐसे ऑप्सोड्स के सेट होते हैं जो दूसरों के लिए अनुशंसित होते हैं। मैंने गति के क्रम में उन्हें यहाँ सूचीबद्ध करने का प्रयास किया है।

  1. बिटवाइज़
  2. पूर्णांक जोड़ / घटाव
  3. पूर्णांक गुणा / भाग
  4. तुलना
  5. बहाव को काबू करें
  6. फ्लोट एडिशन / घटाव
  7. फ्लोट गुणा / भाग

जहां आपको उच्च-प्रदर्शन कोड की आवश्यकता होती है, वहां सीएमडी निर्देश या अधिक कुशल नियंत्रण प्रवाह, डेटा प्रकार आदि का उपयोग करने के लिए सी ++ को विधानसभा में हाथ से अनुकूलित किया जा सकता है, इसलिए मैं यह समझने की कोशिश कर रहा हूं कि क्या डेटा प्रकार (int32 / float32 / float64) या इस्तेमाल किया आपरेशन ( *, +, &) सीपीयू स्तर पर प्रदर्शन प्रभावित करता है।

  1. सीपीयू पर एक एकल गुणा एक जोड़ से धीमी है?
  2. MCU सिद्धांत में आप सीखते हैं कि opcodes की गति को निष्पादित करने के लिए लगने वाले CPU चक्रों की संख्या से निर्धारित होता है। तो क्या इसका मतलब है कि 4 चक्रों को गुणा करना और 2 को जोड़ना है?
  3. वास्तव में बुनियादी गणित और नियंत्रण प्रवाह opcodes की गति विशेषताएं क्या हैं?
  4. यदि दो ऑपकोड्स को निष्पादित करने के लिए समान संख्या में चक्र लेते हैं, तो दोनों को किसी भी प्रदर्शन लाभ / हानि के बिना विनिमेय रूप से इस्तेमाल किया जा सकता है?
  5. X86 CPU प्रदर्शन के बारे में आप जो भी अन्य तकनीकी जानकारी साझा कर सकते हैं वह काबिले तारीफ है

17
यह समय से पहले अनुकूलन की तरह लगता है, और याद रखें कि संकलक आउटपुट नहीं करता है कि आप क्या टाइप करते हैं, और आप वास्तव में असेंबली लिखना नहीं चाहते हैं जब तक कि आपके पास वास्तव में भी नहीं है।
रॉय टी।

3
फ्लोट गुणन और विभाजन पूरी तरह से अलग चीजें हैं, आपको उन्हें एक ही श्रेणी में नहीं रखना चाहिए। N-बिट संख्याओं के लिए, गुणन एक O (n) प्रक्रिया है, और विभाजन O (nlogn) प्रक्रिया है। यह आधुनिक सीपीयू पर गुणा की तुलना में लगभग 5 गुना धीमा बनाता है।
sam hocevar

1
एकमात्र वास्तविक उत्तर "प्रोफ़ाइल इट" है।
तेतरीद

1
रॉय के जवाब पर विस्तार करते हुए, हाथ का अनुकूलन विधानसभा लगभग हमेशा एक शुद्ध नुकसान होने वाला है जब तक कि आप वास्तव में असाधारण नहीं हैं। आधुनिक सीपीयू बहुत जटिल जानवर हैं और अच्छे अनुकूलन वाले कंपाइलर कोड परिवर्तनों को खींचते हैं जो पूरी तरह से गैर-स्पष्ट हैं और हाथ से कोड करने के लिए तुच्छ नहीं हैं। यहां तक ​​कि SSE / SIMD के लिए, हमेशा C / C ++ में हमेशा इंट्रिंसिक्स का उपयोग करें, और संकलक को आपके उपयोग को अनुकूलित करने दें। कच्ची असेंबली का उपयोग करना कंपाइलर ऑप्टिमाइज़ेशन को अक्षम करता है और आप बड़ा खो देते हैं।
शॉन मिडिलडविच

SIMD का उपयोग करने के लिए आपको असेंबली को हैंड-ऑप्टिमाइज़ करने की आवश्यकता नहीं है। स्थिति के आधार पर अनुकूलित करने के लिए SIMD बहुत उपयोगी है, लेकिन SSE2 का उपयोग करने के लिए ज्यादातर मानक सम्मेलन (यह GCC और MSVC पर कम से कम काम करता है) है। जहां तक ​​आपकी सूची का सवाल है, एक आधुनिक सुपरसर्कर मल्टी-पाइपलाइन्ड प्रोसेसर, डेटा निर्भरता और रजिस्टर दबाव के कारण कच्चे पूर्णांक और कभी-कभी फ्लोटिंग पॉइंट प्रदर्शन की तुलना में अधिक समस्याएं होती हैं; डेटा इलाके का भी यही हाल है। वैसे, पूर्णांक विभाजन एक आधुनिक x86 पर गुणा के समान है
OrgnlDave

जवाबों:


26

एग्नर फॉग के ऑप्टिमाइज़ेशन गाइड बहुत बढ़िया हैं। उसके पास सभी हाल ही के x86 सीपीयू डिज़ाइन (जहाँ तक इंटेल पेंटियम है) के माइक्रोआर्किटेक्चर पर गाइड टेबल, इंस्ट्रक्शन टाइमिंग के टेबल और डॉक्स हैं। Https://stackoverflow.com/tags/x86/info से जुड़े कुछ अन्य संसाधन भी देखें

बस मज़े के लिए, मैं कुछ सवालों के जवाब दूंगा (हाल के इंटेल सीपीयू से नंबर)। ऑप्स की पसंद कोड के अनुकूलन का प्रमुख कारक नहीं है (जब तक कि आप विभाजन से बच नहीं सकते।)

सीपीयू पर एक एकल गुणा एक जोड़ से धीमी है?

हाँ (जब तक कि यह 2 की शक्ति से न हो)। (3-4x विलंबता, इंटेल पर केवल प्रति घड़ी थ्रूपुट के साथ।) इससे बचने के लिए अपने रास्ते से बहुत दूर न जाएं, हालांकि, चूंकि यह 2 या 3 के रूप में तेज़ है।

वास्तव में बुनियादी गणित और नियंत्रण प्रवाह opcodes की गति विशेषताएं क्या हैं?

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

यदि दो ऑपकोड्स को निष्पादित करने के लिए समान संख्या में चक्र लेते हैं, तो दोनों को किसी भी प्रदर्शन लाभ / हानि के बिना विनिमेय रूप से इस्तेमाल किया जा सकता है?

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

X86 CPU प्रदर्शन के बारे में आप जो भी अन्य तकनीकी जानकारी साझा कर सकते हैं वह काबिले तारीफ है

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

इसके अलावा, http://www.realworldtech.com/haswell-cpu/ (और पहले के डिजाइनों के समान) मजेदार है अगर आपको सीपीयू डिजाइन पसंद है।

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

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

  • 0.5 से 1 बिटवाइज / इंटीजर एडिक्शन / सबट्रेक्शन /
    शिफ्ट और रोटेट (कम्पाइल-टाइम कास्ट काउंट) /
    इन सभी के वेक्टर वर्जन (1 से 4 प्रति चक्र थ्रूपुट, 1 साइकल लेटेंसी)
  • 1 वेक्टर मिनट, अधिकतम, तुलना-बराबर, तुलना-अधिक (मुखौटा बनाने के लिए)
  • 1.5 वेक्टर फेरबदल। हैसवेल और नए में केवल एक फेरबदल पोर्ट होता है, और मुझे लगता है कि यदि आपको कोई आवश्यकता हो तो बहुत अधिक फेरबदल करना आम बात है, इसलिए कम फेरबदल का उपयोग करने के बारे में सोच को प्रोत्साहित करने के लिए मैं इसे थोड़ा अधिक बढ़ा रहा हूं। वे स्वतंत्र नहीं हैं, esp। यदि आपको मेमोरी से pshufb कंट्रोल मास्क की आवश्यकता है।
  • 1.5 लोड / स्टोर (L1 कैश हिट। विलंबता विलंबता से बेहतर)
  • 1.75 पूर्णांक गुणा (3c विलंबता / इंटेल पर 1c tput प्रति एक, AMD पर 4c lat और केवल 2c tput में से एक)। छोटे स्थिरांक LEA और / या ADD / SUB / पारी का उपयोग करके भी सस्ते हैं । लेकिन निश्चित रूप से संकलन-समय की स्थिरांक हमेशा अच्छे होते हैं , और अक्सर अन्य चीजों में अनुकूलन कर सकते हैं। (और एक लूप में गुणा करें अक्सर कंपाइलर द्वारा tmp += 7लूप के बजाय ताकत को कम किया जा सकता हैtmp = i*7 )
  • 1.75 कुछ 256 बी वेक्टर शफल (इंस पर अतिरिक्त विलंबता जो एवीएक्स वेक्टर के 128 बी लेन के बीच डेटा को स्थानांतरित कर सकता है)। (या राइजेन पर 3 से 7 जहां लेन पार करने वाले फेरबदल के लिए कई और उफ की जरूरत होती है)
  • 2 fp ऐड / सब (और उसी के वेक्टर संस्करण) (1 या 2 प्रति चक्र थ्रूपुट, 3 से 5 चक्र विलंबता)। धीमी गति से हो सकता है यदि आप विलंबता पर अड़चन डालते हैं, उदाहरण के लिए केवल 1 sumचर के साथ एक सरणी को जोड़ दें। (मैं इस वजन कर सकते हैं और fp mul 1 से कम या उपयोग-केस के आधार पर 5 के रूप में उच्च)।
  • 2 वेक्टर एफपी मॉल या एफएमए। (x * y + z, mul या ऐड के समान सस्ता है यदि आप FMA सपोर्ट सक्षम हैं)।
  • 2 वेक्टर तत्वों में सामान्य-उद्देश्य रजिस्टर सम्मिलित करना / निकालना_mm_insert_epi8 , आदि)
  • 2.25 वेक्टर इंट मुल (16-बिट एलिमेंट्स या pmaddubsw कर रहे हैं 8 * 8 -> 16-बिट)। स्केलर की तुलना में बेहतर थ्रूपुट के साथ, स्काईलेक पर सस्ता
  • 2.25 बदलाव / परिवर्तनशील गणना (2c विलंबता, इंटेल पर प्रति 2c थ्रूपुट, AMD पर तेजी से या BMI2 के साथ)
  • २.५ बिना शाखा के तुलना ( y = x ? a : b, या y = x >= 0) ( test / setccया cmov)
  • 3 इंट-> फ्लोट रूपांतरण
  • 3 पूरी तरह से नियंत्रण प्रवाह (अनुमानित शाखा, कॉल, रिटर्न) की भविष्यवाणी की।
  • 4 वेक्टर इंट मुल (32-बिट एलिमेंट्स) (2 उफ, हसवेल पर 10 सी विलंबता)
  • 4 पूर्णांक विभाजन या %एक संकलन-समय स्थिरांक (2 की गैर-शक्ति) द्वारा।
  • 7 वेक्टर क्षैतिज ऑप्स (जैसे PHADDवेक्टर के भीतर मान जोड़ना)
  • 11 (वेक्टर) एफपी डिवीजन (10-13 सी विलंबता, प्रति 7c थ्रूपुट या बदतर)। (अगर शायद ही कभी इस्तेमाल किया जा सकता है, लेकिन सस्ते हो सकता है, लेकिन एफपी म्यू से थ्रूपुट 6 से 40x खराब है)
  • 13? नियंत्रण प्रवाह (खराब-पूर्वानुमानित शाखा, शायद 75% अनुमानित)
  • 13 इंट डिवीजन ( हाँ वास्तव में , यह एफपी डिवीजन की तुलना में धीमा है, और वेक्टर नहीं कर सकता है)। (ध्यान दें कि कम्पाइलर एक स्थूल / शिफ्ट का उपयोग करके एक स्थिर से विभाजित होते हैं / एक जादू स्थिरांक के साथ जोड़ते हैं , और 2 की शक्तियों द्वारा div / mod बहुत सस्ते होते हैं।)
  • 16 (वेक्टर) एफपी वर्गर्ट
  • 25? लोड (L3 कैश हिट)। (कैश-मिस स्टोर लोड से सस्ते हैं।)
  • 50? FP ट्रिगर / ऍक्स्प / लॉग। यदि आपको बहुत अधिक ऍक्स्प / लॉग की आवश्यकता है और पूर्ण सटीकता की आवश्यकता नहीं है, तो आप एक छोटी बहुपद और / या एक तालिका के साथ गति के लिए सटीकता का व्यापार कर सकते हैं। आप SIMD वेक्टराइज़ भी कर सकते हैं।
  • 50-80? हमेशा -mispredenced शाखा, 15-20 चक्र की लागत
  • 200-400? लोड / स्टोर (कैश मिस)
  • 3000 ??? फ़ाइल से पृष्ठ पढ़ें (OS डिस्क कैश हिट) (यहां नंबर बना रहे हैं)
  • 20000 ??? डिस्क रीड पेज (ओएस डिस्क-कैश मिस, फास्ट एसएसडी) (पूरी तरह से बनाया गया नंबर)

मैंने इसे पूरी तरह से अनुमान के आधार पर बनाया है । अगर कुछ गलत लगता है, तो यह इसलिए है क्योंकि मैं एक अलग उपयोग-केस, या एक संपादन त्रुटि के बारे में सोच रहा था।

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

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

यदि एफपी डिवीजन जैसा "धीमा" ऑपरेशन बहुत सस्ता हो सकता है अगर आसपास का कोड सीपीयू को अन्य काम में व्यस्त रखता है । (वेक्टर FP div या sqrt प्रत्येक 1 यूओपी हैं, उनके पास केवल खराब विलंबता और थ्रूपुट है। वे केवल डिवाइड यूनिट को ब्लॉक करते हैं, न कि पूरे निष्पादन पोर्ट को जो कि ऑन है। इंटीगर डिव कई यूओपी हैं।) इसलिए यदि आपके पास केवल एक एफपी डिवाइड है। प्रत्येक ~ 20 mul और जोड़ने के लिए, और वहाँ सीपीयू के लिए अन्य काम करना है (उदाहरण के लिए एक स्वतंत्र लूप पुनरावृत्ति), फिर FP div की "लागत" एक FP mul के समान हो सकती है। यह संभवतः कुछ सबसे अच्छा उदाहरण है जो कम थ्रूपुट है जब यह सब आप कर रहे हैं, लेकिन अन्य कोड के साथ बहुत अच्छी तरह से मिश्रण करता है (जब विलंबता कोई कारक नहीं है), कम कुल उफ़ की वजह से।

ध्यान दें कि पूर्णांक विभाजन लगभग आसपास के कोड के अनुकूल नहीं है: हसवेल पर, यह 9 यूओपी है, जिसमें प्रति 8-11c थ्रूपुट और 22-29c विलंबता है। (64 बिट डिवीजन ज्यादा धीमी है, यहां तक ​​कि स्काईलेक पर भी।) इसलिए लेटेंसी और थ्रूपुट संख्या एफपी डिव के समान है, लेकिन एफपी डिव केवल एक यूओपी है।

थ्रूपुट, विलंबता और कुल उफ़ के लिए शिलालेखों के संक्षिप्त अनुक्रम का विश्लेषण करने के उदाहरणों के लिए, मेरे कुछ SO उत्तर देखें:

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


4 पर "अनुमानित शाखा" समझ में आता है - 20-25 पर "पूर्वानुमानित शाखा" वास्तव में क्या होनी चाहिए? (मैंने सोचा था कि गलत-भविष्यवाणी की गई शाखाएं (13 के आसपास सूचीबद्ध) उससे कहीं अधिक महंगी थीं, लेकिन वास्तव में इस पृष्ठ पर हूं, ताकि सच्चाई के करीब कुछ सीख सकूं - महान तालिका के लिए धन्यवाद!)
मैट

@ मैट: मुझे लगता है कि यह एक संपादन त्रुटि थी और इसे "गलत शाखा" माना जाता था। यह बात बताने के लिए धन्यवाद। ध्यान दें कि 13 एक अपूर्ण-पूर्वानुमानित शाखा के लिए है, न कि हमेशा-गलत शाखा, इसलिए मैंने स्पष्ट किया है। मैंने फिर से हाथ से किया और कुछ संपादन किया। : पी
पीटर कॉर्ड्स

16

यह प्रश्न में सीपीयू पर निर्भर करता है, लेकिन आधुनिक सीपीयू के लिए सूची कुछ इस प्रकार है:

  1. बिटवाइज़, जोड़, घटाव, तुलना, गुणा
  2. विभाजन
  3. नियंत्रण प्रवाह (उत्तर 3 देखें)

सीपीयू के आधार पर 64 बिट डेटा प्रकारों के साथ काम करने के लिए काफी टोल हो सकता है।

आपके सवाल:

  1. बिल्कुल नहीं या आधुनिक सीपीयू पर सराहना नहीं। सीपीयू पर निर्भर।
  2. वह जानकारी कुछ ऐसी है जैसे 20 से 30 साल पुरानी (स्कूल बेकार है, आपको अब सबूत मिल गया है), आधुनिक सीपीयू प्रति घड़ी निर्देश की एक चर संख्या को संभालते हैं, कितने शेड्यूलर के साथ आने पर निर्भर करते हैं।
  3. डिवीजन बाकी की तुलना में थोड़ा धीमा है, यदि शाखा भविष्यवाणी सही है, तो यह नियंत्रण प्रवाह बहुत तेज है और अगर यह गलत है (20 चक्रों की तरह, सीपीयू पर निर्भर है)। नतीजा यह है कि बहुत सारे कोड मुख्य रूप से नियंत्रण प्रवाह द्वारा सीमित हैं। ifक्या आप यथोचित अंकगणित के साथ कर सकते हैं के साथ मत करो ।
  4. कोई भी निर्देश कितने चक्र लेता है, इसकी कोई निश्चित संख्या नहीं है, लेकिन कभी-कभी दो अलग-अलग निर्देश समान रूप से प्रदर्शन कर सकते हैं, उन्हें दूसरे संदर्भ में डाल सकते हैं और शायद वे नहीं करते हैं, उन्हें एक अलग सीपीयू पर चलाएं और आपको एक 3 परिणाम देखने की संभावना है।
  5. नियंत्रण प्रवाह के शीर्ष पर अन्य बड़े समय का प्लास्टर कैश मिस होता है, जब भी आप डेटा को पढ़ने की कोशिश करते हैं जो सीपीयू कैश में नहीं है तो उसे मेमोरी से लाने के लिए इंतजार करना होगा। सामान्य तौर पर आपको सभी जगह से डेटा निकालने के बजाय एक साथ एक दूसरे के बगल में डेटा टुकड़ों को संभालने की कोशिश करनी चाहिए।

और अंत में, यदि आप एक गेम बना रहे हैं, तो इस सब के बारे में बहुत अधिक चिंता न करें, सीपीयू चक्रों को काटने की तुलना में एक अच्छा गेम बनाने पर बेहतर ध्यान केंद्रित करें।


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

2
मैं सिर्फ अंतिम भाग पर अधिक जोर देता हूँ - एक अच्छा खेल बनाओ। यह कोड को स्पष्ट करने में मदद करता है - यही वजह है कि 3. केवल तब लागू होता है जब आप वास्तव में एक प्रदर्शन समस्या को मापते हैं। जरूरत पड़ने पर उन इफ्स को कुछ बेहतर में बदलना हमेशा आसान होता है। दूसरी ओर, 5. मुश्किल है - मैं निश्चित रूप से सहमत हूं कि यह एक ऐसा मामला है जहां आप वास्तव में पहले सोचना चाहते हैं, क्योंकि आमतौर पर इसका मतलब है कि वास्तुकला को बदलना।
लुआन

3

मैंने पूर्णांक संचालन के बारे में एक परीक्षण किया, डायन ने x64_64 पर एक लाख बार लूप किया, संक्षिप्त निष्कर्ष पर पहुंचें, जैसे नीचे,

जोड़ें --- 116 माइक्रोसेकंड

उप ---- 116 माइक्रोसेकंड

mul ---- 1036 माइक्रोसेकंड

div ---- 13037 माइक्रोसेकंड

ऊपर दिए गए डेटा ने लूप द्वारा प्रेरित ओवरहेड को पहले ही कम कर दिया है,


2

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

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


+1, आश्रित भार (पॉइंटर चेज़िंग) एक बड़ी बात है। एक कैश मिस शुरू होने से भविष्य के लोड को भी रोक देगा। उड़ान में मुख्य मेमोरी से कई लोड होने के बाद एक से अधिक बेहतर बैंडविड्थ देता है जिसमें एक सेशन को पूरी तरह से पूरा करने के लिए पिछले की आवश्यकता होती है।
पीटर कॉर्ड्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.