इस सवाल के जवाब में कि किसी वस्तु के क्षेत्रों तक पहुंच की तुलना में एक सरणी तत्व तक पहुंच क्यों तेज है

अभी हाल ही में, प्रिय लान ने जावा में उत्परिवर्तनीय संख्याओं के बारे में एक अद्भुत पोस्ट लिखी: http://habrahabr.ru/post/151887/
उनके पोस्ट पर एक टिप्पणी में, मैंने उल्लेख किया कि यदि प्रदर्शन महत्वपूर्ण है, तो आप रैपर को एक एकल-तत्व सरणी के साथ बदल सकते हैं, सरणी तत्व तक पहुंच एक उदाहरण फ़ील्ड से मान निकालने की तुलना में तेजी से होती है।
मुझे एक और प्रदर्शन श्वेत पत्र पढ़ने के बाद सूर्य से यह स्टीरियोटाइप विरासत में मिला। वहां लिखा गया था कि स्थानीय चर सबसे तेजी से एक्सेस किया जाता है, उसके बाद एक स्थिर फ़ील्ड, फिर एक एरे तत्व और इस इंस्टेंस फ़ील्ड सूची को बंद कर देता है।
सौभाग्य से, वे मेरे शब्द पर विश्वास नहीं करते थे और इस लेख को लिखने का यही कारण था।
लेख जूनियर्स के लिए अभिप्रेत नहीं है, पाठक को जावा, एएसएम x86 और बायटेकोड को जानना चाहिए।


यह समझने के लिए कि किसी ऑब्जेक्ट फ़ील्ड तक पहुँच की तुलना में किसी ऐरे तत्व तक पहुँच तेज़ है या नहीं, आप यह कर सकते हैं:

1. एक सिंथेटिक प्रदर्शन परीक्षण लिखें
2. समझें कि वास्तव में सरणी के पीछे क्या है [0] और यह

मैंने दूसरा तरीका चुना, सिंथेटिक परीक्षणों से पहले से ही बीमार। सबसे पहले, हम एक परीक्षण वर्ग फेंकेंगे।

package numbers; public class TestNumbers { public static void main(String[] args) { test(new IntNumField()); test(IntNumArray.create()); } private static final void test(int[] mutableInt2) { for (int index = 10000; index-- > 0;) { IntNumArray.inc(mutableInt2); } } private static final void test(IntNumField mutableInt1) { for (int index = 10000; index-- > 0;) { mutableInt1.inc(); } } public static final class IntNumField { protected int value; public int getValue() { return value; } public void setValue(int value) { this.value = value; } public final void inc() { this.value++; } } public static final class IntNumArray { public static final int[] create() { return new int[1]; } public static final int get(int[] array) { return array[0]; } public static final void set(int[] array, int value) { array[0] = value; } public static final void inc(int[] array) { array[0]++; } } } 

IntNumField वर्ग ऑब्जेक्ट के क्षेत्र के साथ काम करता है, और IntNumArray, जैसा कि मैंने सुझाव दिया, एक एकल सरणी के साथ। प्रत्येक कक्षा में एक इंक विधि होती है जो हमारे एक परिवर्तनशील द्वारा वृद्धि करती है। परीक्षण विधियों में, inc के प्रत्येक संस्करण को 10,000 बार कहा जाता है - ताकि विधि को संकलित करने की गारंटी हो।

लेकिन पहले, बायोटेक पर एक नज़र डालें:

 ~$ javap -c numbers/TestNumbers$IntNumField public int getValue(); Code: 0: aload_0 1: getfield #18; //Field value:I 4: ireturn public void setValue(int); Code: 0: aload_0 1: iload_1 2: putfield #18; //Field value:I 5: return public final void inc(); Code: 0: aload_0 1: dup 2: getfield #18; //Field value:I 5: iconst_1 6: iadd 7: putfield #18; //Field value:I 10: return 

प्राप्त विधि में, सब कुछ सरल है, इसे लोड करें और स्टैक पर मूल्य मान को धक्का दें। बाकी सब उसी के बारे में है, सिवाय इसके कि inc इसे अनुकूलित करने के लिए डुप का उपयोग करता है।
अब देखते हैं कि IntNumArray क्लास में हमारा क्या इंतजार है:

 ~$ javap -c numbers/TestNumbers$IntNumArray public static final int get(int[]); Code: 0: aload_0 1: iconst_0 2: iaload 3: ireturn public static final void set(int[], int); Code: 0: aload_0 1: iconst_0 2: iload_1 3: iastore 4: return public static final void inc(int[]); Code: 0: aload_0 1: iconst_0 2: dup2 3: iaload 4: iconst_1 5: iadd 6: iastore 7: return 

उसी चीज़ के बारे में, सिवाय इसके कि getfield को iconst_0 और iaload द्वारा बदल दिया जाता है। खैर, यह अभी भी समझ से बाहर है, इसलिए कोडांतरक पर एक नज़र डालें जो विशेष मापदंडों का उपयोग करके इंक तरीकों के लिए हॉटस्पॉट उत्पन्न करेगा:

 ~$ java -XX:+UnlockDiagnosticVMOptions -XX:CompileThreshold=10000 -XX:+PrintAssembly numbers.TestNumbers # {method} 'inc' '()V' in 'numbers/TestNumbers$IntNumField' # [sp+0x20] (sp of caller) 0x02141a87: cmp 0x4(%ecx),%eax 0x02141a8a: jne 0x020dd100 ; {runtime_call} [Verified Entry Point] 0x02141a90: mov %eax,0xffffc000(%esp) 0x02141a97: push %ebp 0x02141a98: sub $0x18,%esp ;*aload_0 ; - numbers.TestNumbers$IntNumField::inc@0 (line 50) 0x02141a9b: mov 0x8(%ecx),%esi ;*getfield value ; - numbers.TestNumbers$IntNumField::inc@2 (line 50) 0x02141a9e: inc %esi 0x02141a9f: mov %esi,0x8(%ecx) ;*putfield value ; - numbers.TestNumbers$IntNumField::inc@7 (line 50) 0x02141aa2: add $0x18,%esp 0x02141aa5: pop %ebp 0x02141aa6: test %eax,0x1b0100 ; {poll_return} 0x02141aac: ret # {method} 'inc' '([I)V' in 'numbers/TestNumbers$IntNumArray' # parm0: ecx = '[I' # [sp+0x20] (sp of caller) 0x02141c80: mov %eax,0xffffc000(%esp) 0x02141c87: push %ebp 0x02141c88: sub $0x18,%esp ;*aload_0 ; - numbers.TestNumbers$IntNumArray::inc@0 (line 71) 0x02141c8b: cmpl $0x0,0x8(%ecx) ; implicit exception: dispatches to 0x02141cb7 0x02141c92: jbe 0x02141cc1 0x02141c98: mov 0xc(%ecx),%esi ;*iaload ; - numbers.TestNumbers$IntNumArray::inc@3 (line 71) 0x02141c9b: inc %esi 0x02141c9c: cmpl $0x0,0x8(%ecx) 0x02141ca3: jbe 0x02141ccd 0x02141ca9: mov %esi,0xc(%ecx) ;*iastore ; - numbers.TestNumbers$IntNumArray::inc@6 (line 71) 0x02141cac: add $0x18,%esp 0x02141caf: pop %ebp 0x02141cb0: test %eax,0x1b0100 ; {poll_return} 0x02141cb6: ret 

मुझे कोड संरेखण और [अपवाद हैंडलर] अनुभाग में कोड का एक गुच्छा जैसी चीजों को फेंककर दोनों तरीकों को काटना पड़ा।
यदि आप बारीकी से देखते हैं, तो दोनों विधियाँ स्टैक पर मान बढ़ाने के लिए inc% esi का उपयोग करती हैं। केवल अलग

 mov 0x8(%ecx),%esi ;*getfield value 

और

 cmpl $0x0,0x8(%ecx) ; implicit exception: dispatches to 0x02141cb7 jbe 0x02141cc1 mov 0xc(%ecx),%esi ;*iaload 

कोड के दूसरे टुकड़े में पहली दो पंक्तियाँ एक जाँच है कि सूचकांक 0 सरणी की सीमा से आगे नहीं जाता है (0 <array.length)। यह इस वजह से है कि यह पता चला है कि मैं गलत था, इससे भी बदतर, एक ही चेक नीचे दो लाइनें होती है ... यह संभावना नहीं है कि यह धीमा होगा, लेकिन निश्चित रूप से यह ऑब्जेक्ट के क्षेत्र तक पहुंच से तेज नहीं होगा।

संदेह करने के लिए धन्यवाद, मुझे लगता है कि यह न केवल हम दोनों के लिए दिलचस्प है। आप सुरक्षित रूप से रैपर वर्ग और ओओपी के सभी आकर्षण का उपयोग कर सकते हैं।

PS मैंने अभी भी एक प्रदर्शन बेंचमार्क लॉन्च किया है, कोई अंतर नहीं है।