UI arr16 arrays int arrays की तुलना में तेज़ी से क्यों दिखते हैं?

Question

ऐसा लगता है कि int[] के दो एरे जोड़ने पर UInt16[] के दो सरणी जोड़ने पर सी # तेज है। यह मुझे कोई समझ नहीं आता है, क्योंकि मैंने माना होगा कि सरणी शब्द-संरेखित होंगी, और इस प्रकार int[] को CPU से कम काम की आवश्यकता होगी, नहीं?

मैं नीचे परीक्षण कोड भाग गया, और निम्न परिणाम है:

Int for 1000 took 9896625613 tick (4227 msec) 
UInt16 for 1000 took 6297688551 tick (2689 msec) 

परीक्षण कोड निम्नलिखित है:

1. एक बार a और b, नामित दो सरणियों बनाता है।
2. उन्हें एक बार यादृच्छिक डेटा से भरता है।
3. स्टॉपवॉच शुरू करता है।
4. a और b, आइटम-दर-आइटम जोड़ता है। यह 1000 बार किया जाता है।
5. स्टॉपवॉच को रोकता है।
6. रिपोर्ट करता है कि यह कितना समय लगा।

यह int[] a, b और UInt16 a,b के लिए किया जाता है। और प्रत्येक समय मैं कोड चलाता हूं, UInt16 सरणी के परीक्षण int सरणी से 30% -50% कम समय लेते हैं। क्या आप इसे मुझे समझा सकते हैं?

यहाँ कोड यदि आप अगर खुद के लिए कोशिश करना चाहते है,:

public static UInt16[] GenerateRandomDataUInt16(int length) 
{ 
    UInt16[] noise = new UInt16[length]; 
    Random random = new Random((int)DateTime.Now.Ticks); 
    for (int i = 0; i < length; ++i) 
    { 
     noise[i] = (UInt16)random.Next(); 
    } 

    return noise; 
} 

public static int[] GenerateRandomDataInt(int length) 
{ 
    int[] noise = new int[length]; 
    Random random = new Random((int)DateTime.Now.Ticks); 
    for (int i = 0; i < length; ++i) 
    { 
     noise[i] = (int)random.Next(); 
    } 

    return noise; 
} 

public static int[] AddInt(int[] a, int[] b) 
{ 
    int len = a.Length; 
    int[] result = new int[len]; 
    for (int i = 0; i < len; ++i) 
    { 
     result[i] = (int)(a[i] + b[i]); 
    } 
    return result; 
} 

public static UInt16[] AddUInt16(UInt16[] a, UInt16[] b) 
{ 
    int len = a.Length; 
    UInt16[] result = new UInt16[len]; 
    for (int i = 0; i < len; ++i) 
    { 
     result[i] = (ushort)(a[i] + b[i]); 
    } 
    return result; 
} 


public static void Main() 
{ 
    int count = 1000; 
    int len = 128 * 6000; 

    int[] aInt = GenerateRandomDataInt(len); 
    int[] bInt = GenerateRandomDataInt(len); 

    Stopwatch s = new Stopwatch(); 
    s.Start(); 
    for (int i=0; i<count; ++i) 
    { 
     int[] resultInt = AddInt(aInt, bInt); 
    } 
    s.Stop(); 
    Console.WriteLine("Int for " + count 
       + " took " + s.ElapsedTicks + " tick (" 
       + s.ElapsedMilliseconds + " msec)"); 

    UInt16[] aUInt16 = GenerateRandomDataUInt16(len); 
    UInt16[] bUInt16 = GenerateRandomDataUInt16(len); 

    s = new Stopwatch(); 
    s.Start(); 
    for (int i=0; i<count; ++i) 
    { 
     UInt16[] resultUInt16 = AddUInt16(aUInt16, bUInt16); 
    } 
    s.Stop(); 
    Console.WriteLine("UInt16 for " + count 
       + " took " + s.ElapsedTicks + " tick (" 
       + s.ElapsedMilliseconds + " msec)"); 


} 

Answer 1

क्या होता है कि आप एक रिसाव अमूर्तता देखते हैं। UInt16 आधा स्मृति लेता है जो int करता है (16 बनाम 32 बिट)।

इसका मतलब है कि int16 सरणी द्वारा कब्जा कर लिया गया स्मृति क्षेत्र int32 करता है जो क्षेत्रफल का आधा हिस्सा लेता है। तो उस क्षेत्र में से अधिक प्रोसेसर कैश में फिट हो सकता है और इस प्रकार बहुत जल्दी पहुंचा जा सकता है।

आप उस प्रोसेसर पर उस कोड को आजमा सकते हैं जिसमें अधिक कैश है और अंतर छोटा होने की संभावना है।

भी बहुत बड़े सरणी के साथ प्रयास करें।

1) तुम भी परिणामी की पीढ़ी समय कर रहे हैं array..so यह देखने के लिए यह कितना समय ले लिया दिलचस्प होगा करने के लिए सिर्फ परिणाम सरणी पारित हो कि बनाने बनाम जोड़ने के लिए कारकों में से

Answer 2

सरणी शब्द गठबंधन कर रहे हैं, लेकिन वहाँ कोई कारण नहीं क्यों सरणी में प्रविष्टियों शब्द गठबंधन होना चाहिए।

Answer 3

बस एक एसडब्ल्यूएजी: UInt16 सरणी के छोटे मेमोरी उपयोग में स्मृति विशेषताओं में सुधार हुआ है (जीसी, कैश, जो और जानता है)। चूंकि बहुत सारे आवंटन प्रतीत नहीं होते हैं, मुझे लगता है कि कैश मुख्य कारक है।

इसके अलावा, आपको यह ध्यान रखना चाहिए कि बेंचमार्किंग एक मुश्किल व्यवसाय हो सकता है - ऐसा लगता है कि आपके समय शायद कुछ जेआईटी संकलन सहित हैं, जो परिणाम को कम कर सकते हैं। आप UInt16 सरणी के साथ int सरणी का परीक्षण करने के आदेश को उलटाने का प्रयास कर सकते हैं और देख सकते हैं कि समय के साथ पालन करें या नहीं।

जॉन स्कीट ने एक सरल बेंचमार्क ढांचे को (या था) किया था जब उसने इन प्रभावों को ध्यान में रखने की कोशिश की थी। मुझे नहीं पता कि यह अभी भी उपलब्ध है (या यहां तक ​​कि लागू भी है); शायद वह टिप्पणी करेगा।

Answer 4

युगल पीछे

2) यह देखना दिलचस्प होगा कि आईएल क्या उत्पन्न हुआ है। चूंकि आपका कोड बहुत सरल है (पुनरावृत्त और जोड़ता है), संकलक इसे अनुकूलित कर सकता है, शायद एक बड़े रजिस्टर में एकाधिक uint16 को भर रहा है और प्रति निर्देश

Answer 5

मैं .NET में विशेषज्ञ नहीं हूं लेकिन मैं दो की जांच करूंगा बातें:

1. बड़ा सरणी (प्रकार int के एन तत्वों) पासिंग और अधिक समय तो एन ushort तत्वों की सरणी लेता है। यह विभिन्न आकार के सरणी और कोडिंग की शैली का उपयोग करके परीक्षण किया जा सकता है - प्रश्न पर मेरी टिप्पणी देखें)। आपके परीक्षणों से संख्या इस सिद्धांत के अनुरूप है :)। जाँच बह निकला बिना -
2. दो ushort चर जोड़ना प्रकार int का परिणाम के साथ दो int जोड़ने के रूप में लागू किया जा सकता। और मुझे लगता है कि कोड कोड में अपवाद (ओवरफ्लो अपवाद सहित) समय लेने वाली कार्य है। इसे .NET दस्तावेज़ में चेक किया जा सकता है।