optimization - Does this code fill the CPU cache? -

मेरे पास एक ही कार्यक्षमता प्रोग्राम करने के दो तरीके हैं I

विधि 1:

  doTheWork (int कार्रवाई) {के लिए (int i = 0 i & lt; 1000000000; ++ i) {doAction (कार्रवाई); }}  

विधि 2:

  doTheWork (int कार्रवाई) {स्विच (कार्रवाई) {मामला 1: के लिए (int i = 0 i & lt; 1000000000 ; ++ i) {doAction & lt; 1 & gt; (); }         टूटना; मामले 2: के लिए (इंट आई = 0 आई & lt; 1000000000; ++ i) {doAction & lt; 2 & gt; (); }         टूटना; // ----------------------------------------------- / / ... (यहां 1000000 मामले हैं) // ------------------------------------- ---------- केस 1000000: के लिए (इंट आई = 0 आई एंड एलटी; 1000000000; ++ आई) {doAction & lt; 1000000 & gt; (); }         टूटना; }}  

मान लें कि फ़ंक्शन doAction (int क्रिया) और फ़ंक्शन टेम्पलेट & lt; int Action & gt; DoAction () में लगभग 10 लाइनें कोड शामिल हैं जो संकलन-समय पर रेखांकित होंगे। कॉलिंग doAction (#) को doAction और lt; # & gt; () कार्यक्षमता में है, लेकिन गैर-templated doAction (int value) के लिए समयावधि है कुछ टेम्पलेट & lt; int मान & gt; DoAction () , चूंकि कुछ अच्छा अनुकूलन कोड में किया जा सकता है जब तर्क मूल्य को संकलन समय पर जाना जाता है।

तो मेरा सवाल है, कोड के सभी लाखों पंक्तियों को सीपीयू एल 1 कैश (और अधिक) को टेम्पलेट किए गए फ़ंक्शन के मामले में भरें (और इस प्रकार प्रदर्शन में काफी गिरावट आई), या केवल doAction & lt; # & gt; () वर्तमान में चल रहे लूप के अंदर कैश्ड हो रहा है?

< P> यह वास्तविक कोड आकार पर निर्भर करता है - वास्तविक कोड के 10 लाइनों का कोड बहुत कम या अधिक हो सकता है - और निश्चित रूप से।

हालांकि, विधि 2 हिंसक इस दशकों का उल्लंघन अंगूठे का नियम: निर्देश सस्ता हैं, स्मृति पहुंच नहीं है।

स्केलेबिलिटी सीमा

आपका ऑप्टिमाइज़ेशन आमतौर पर रैखिक हैं - आप 10, 20 को भी दाग ​​सकते हैं, यहां तक ​​कि 30% निष्पादन समय। कैश की सीमा को मारना बेहद अलाइनलाइन है - जैसा कि "ईंट की दीवार में चलना" गैर-रेखीय है।

जैसे ही आपका कोड आकार काफी दूसरी / तीसरे स्तर कैश के आकार से अधिक हो जाता है, विधि 2 में बड़ा समय खो जाएगा उच्च अंत उपभोक्ता प्रणाली के निम्नलिखित अनुमान से पता चलता है:

• DDR3-1333 के साथ 10667MB / s शिखर स्मृति बैंडविड्थ,
• इंटेल कोर i7 चरम ब्रेक के लिए प्रति निर्देश 10667 एमबी / 75000 एम = 0.14 बाइट देता है - कुछ भी बड़ा है, और मुख्य मेमोरी CPU के साथ नहीं रख सकते ।

  ठेठ x86 निर्देश आकार 1. 2. चक्रों में क्रियान्वित 2..3 बाइट्स हैं (अब, दी गई, यह जरूरी नहीं कि एक ही निर्देश है, क्योंकि x86 निर्देश विभाजित हैं। फिर भी ...) सामान्य x 64 अनुदेश लंबाई भी बड़ी हैं

  आपकी कैश कितना मदद करती है?
  मुझे निम्न संख्या मिली (अलग स्रोत, इसलिए इसकी तुलना करना कठिन है): i7 नेहलेम एल 2 कैश (256 के,> 200 जीबी / एस बैंडविड्थ) जो लगभग x 86 निर्देशों के साथ रख सकते थे, लेकिन संभवत: x 64 के साथ नहीं।

  इसके अलावा, आपका एल 2 कैश पूरी तरह से किक जाएगा यदि

  • आप सही हैं
  • इस कोर पर कोई थ्रेड निष्पादित नहीं है

  यह देखते हुए कि, आप बहुत पहले खो सकते हैं, खासकर CPU / छोटे कैश के साथ बोर्ड।