क्या सरणी की लंबाई C # में स्थानीय चर में संग्रहित की जानी चाहिए?

मैंने देखा कि लोग अक्सर इस तरह से निर्माण का उपयोग करते हैं:

var length = array.Length; for (int i = 0; i < length; i++) {    //do smth } 

उन्हें लगता है कि प्रत्येक पुनरावृत्ति पर Array.Length को कॉल करने से CLR को कोड निष्पादित करने में अधिक समय लगेगा। इससे बचने के लिए वे एक स्थानीय चर में लंबाई मान संग्रहीत करते हैं।
आइए पता करें (एक बार और सभी के लिए!) यदि यह एक व्यवहार्य बात है या अस्थायी चर का उपयोग करना समय की बर्बादी है।

शुरू करने के लिए, आइए इन C # विधियों की जाँच करें:

 public int WithoutVariable() {   int sum = 0;   for (int i = 0; i < array.Length; i++) {       sum += array[i];   }   return sum; } public int WithVariable() {   int sum = 0;   int length = array.Length;   for (int i = 0; i < length; i++) {       sum += array[i];   }   return sum; } 

जेआईटी कम्पाइलर द्वारा (.NET फ्रेमवर्क 4.7.2 के लिए लेगेजिट-एक्स 86 के तहत संसाधित किया गया) इस प्रकार दिखता है:


यह नोटिस करना मामूली है कि उनके पास कोडांतरक निर्देशों की सटीक संख्या समान है - 15. यहां तक ​​कि इन निर्देशों का तर्क भी लगभग एक जैसा है। चक्र को जारी रखना चाहिए या नहीं, इस पर चर और तुलना के क्रम में थोड़ा अंतर है। हम नोट कर सकते हैं कि दोनों मामलों में सरणी की लंबाई चक्र से पहले दो बार दर्ज की गई है:

• 0 (arrayLength) की जांच करने के लिए
  
• चक्र स्थिति (arrayLength2) की जांच के लिए अस्थायी चर में।
  

यह पता चला है कि दोनों विधियाँ सटीक एक ही कोड में संकलित होंगी, लेकिन पहले वाला तेजी से लिखा गया है, भले ही निष्पादन समय के संदर्भ में कोई लाभ नहीं है।
उपरोक्त कोड कोड ने मुझे कुछ विचारों के लिए प्रेरित किया और मैंने कुछ और तरीकों की जाँच करने का निर्णय लिया:

 public int WithoutVariable() {   int sum = 0;   for(int i = 0; i < array.Length; i++) {       sum += array[i] + array.Length;   }   return sum; } public int WithVariable() {   int sum = 0;   int length = array.Length;   for(int i = 0; i < length; i++) {       sum += array[i] + length;   }   return sum; } 

अब वर्तमान तत्व और सरणी लंबाई को जोड़ा जा रहा है, लेकिन पहले मामले में सरणी की लंबाई हर बार अनुरोध की जा रही है, और दूसरे मामले में इसे एक स्थानीय चर में एक बार सहेजा जाता है। आइए इन तरीकों के कोड कोड को देखें:


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

int arrayLength2 = localRefToArray । लंबाई ;
Mov edi , dword ptr [ edx + 4 ]
अगर ( i> = arrayLength2 ) नई IndexOutOfRangeException ( ) फेंक दें ;
cmp ecx edi
जा ०४ बी १२ डी ३ ९

सभी चार विधियों में एक अंतर्निर्मित सरणी सीमा की जाँच है और यह सरणी के प्रत्येक तत्व के लिए निष्पादित की गई है।

हम पहले से ही पहले निष्कर्ष निकाल सकते हैं: चक्र को तेज करने की कोशिश करने के लिए एक अतिरिक्त चर का उपयोग करना समय की बर्बादी है, क्योंकि कंपाइलर वैसे भी आपके लिए यह करेगा। एक लंबाई सरणी को एक चर में संग्रहीत करने का एकमात्र कारण कोड को अधिक पठनीय बनाना है।

ForEach पूरी तरह से एक और स्थिति है। निम्नलिखित तीन तरीकों पर विचार करें:

 public int ForEachWithoutLength() {   int sum = 0;   foreach (int i in array) {       sum += i;   }   return sum; } public int ForEachWithLengthWithoutLocalVariable() {   int sum = 0;   foreach (int i in array) {       sum += i + array.Length;   }   return sum; } public int ForEachWithLengthWithLocalVariable() {   int sum = 0;   int length = array.Length;   foreach (int i in array) {       sum += i + length;   }   return sum; } 

और यहाँ JIT के बाद का कोड है:




पहली बात जो दिमाग में आती है वह यह है कि यह चक्र के मुकाबले कम कोडांतरक निर्देश लेता है (उदाहरण के लिए, साधारण तत्व योग के लिए इसे 12 निर्देशों के लिए लिया गया था, लेकिन 15 के लिए )।

कुल मिलाकर, यहां 1 मिलियन-तत्व सरणियों के लिए बनाम फ़ॉरच बेंचमार्क के परिणाम हैं:

 sum+=array[i]; 

और के लिए

 sum+=array[i] + array.Length; 

ForEach के माध्यम से बहुत जल्दी सरणी के माध्यम से चलता है। क्यों? यह जानने के लिए, हमें JIT के बाद कोड की तुलना करने की आवश्यकता है:


आइए ForEachWithoutLength को देखें। सरणी की लंबाई केवल एक बार अनुरोध की गई है और सरणी सीमाओं के लिए कोई जांच नहीं है। ऐसा इसलिए होता है क्योंकि ForEach चक्र पहले संग्रह के अंदर संग्रह को बदलने को प्रतिबंधित करता है, और दूसरा कभी भी संग्रह के बाहर नहीं जाएगा। उसके कारण, JIT चेक ऐरे की सीमाओं को हटा सकती है।

अब ForEachWithLengthWIthoutLocalVariable को ध्यान से देखें। केवल एक ही अजीब हिस्सा है, जहां योग + = लंबाई पहले से स्थानीय चर सरणी को सहेजने के लिए नहीं होती है, लेकिन एक नए के लिए जो ऐप हर बार मेमोरी से अनुरोध करता है। इसका मतलब है कि, सरणी लंबाई के लिए N + 1 मेमोरी अनुरोध होगा, जहां N एक सरणी लंबाई है।

और अब हम ForEachWithLengthWithLocalVariable में आते हैं। कोड लंबाई लंबाई की हैंडलिंग को छोड़कर, पिछले उदाहरण की तरह ही है। कंपाइलर ने एक बार फिर एक स्थानीय वैरिएबल एरेलेवेन्थ उत्पन्न किया है जो यह जाँचने के लिए उपयोग किया जाता है कि एरे खाली है या नहीं, लेकिन कंपाइलर ने अभी भी ईमानदारी से हमारी बताई हुई स्थानीय वैरिएबल लंबाई को बचाया है, और यही वह है जिसका उपयोग चक्र के अंदर समाकलन में किया जाता है। यह पता चला है कि यह विधि केवल दो बार मेमोरी से सरणी की लंबाई का अनुरोध करती है। अंतर वास्तविक दुनिया में नोटिस करने के लिए बहुत कठिन है।

सभी मामलों में, कोडांतरक कोड इतना सरल निकला क्योंकि विधियाँ स्वयं सरल हैं। यदि विधियों में अधिक पैरामीटर होते हैं, तो इसे स्टैक के साथ काम करना होगा, चर को रजिस्टरों के बाहर स्टोर मिल सकता है, अधिक जांचें होंगी, लेकिन मुख्य तर्क समान रहेगा: सरणी लंबाई के लिए एक स्थानीय चर पेश करना केवल है अधिक पठनीय कोड बनाने के लिए उपयोगी। यह भी पता चला है कि Foreach अक्सर के लिए की तुलना में तेजी से सरणी के माध्यम से चलता है।