16 बाइट सी # में संरचना के लिए अनुशंसित आकार क्यों है?

Question

मैंने कैवलिना पुस्तक (एनईटी अनुप्रयोगों के विकास और डिजाइन पर सिफारिशों) को पढ़ा।

वह कहता है कि एक अच्छी तरह से डिज़ाइन की गई संरचना आकार में 16 बाइट से कम होना चाहिए (प्रदर्शन उद्देश्यों के लिए)।

यह वास्तव में क्यों है?

और (अधिक महत्वपूर्ण) अगर मैं 3.5 (जल्द ही .NET 4.0 होने के लिए) मेरे नेट चलाने Windows के तहत Core i7 पर 64-बिट आवेदन मैं एक ही दक्षता के साथ बड़ा struct हो सकता है   7 x64 (इस सीमा सीपीयू है/ओएस आधारित)?

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

Answer 1

केवल आप जानते हैं कि आपके प्रोग्राम में आपके structs का उपयोग कैसे किया जा रहा है। लेकिन अगर कुछ और नहीं है, तो आप हमेशा अपने लिए इसका परीक्षण कर सकते हैं। उदाहरण के लिए, अगर यह अक्सर अन्य कार्यों के लिए पारित किया गया है, पर निम्न बातें स्पष्ट करना हो सकता है:

class MainClass 
{ 
    static void Main() 
    { 
     Struct64 s1 = new Struct64(); 
     Class64 c1 = new Class64(); 
     DoStuff(s1); 
     DoStuff(c1); 
     Stopwatch sw = new Stopwatch(); 
     sw.Start(); 
     for (int i = 0; i < 10000; i++) 
     { 
      s1 = DoStuff(s1); 
     } 
     sw.Stop(); 
     Console.WriteLine("Struct {0}", sw.ElapsedTicks); 
     sw.Reset(); 

     sw.Start(); 
     for (int i = 0; i < 10000; i++) 
     { 
      c1 = DoStuff(c1); 
     } 
     sw.Stop(); 
     Console.WriteLine("Class {0}", sw.ElapsedTicks); 
     sw.Reset(); 

     Console.ReadLine(); 
    } 
} 

साथ:

public class Class64 
{ 
    public long l1; 
    public long l2; 
    public long l3; 
    public long l4; 
    public long l5; 
    public long l6; 
    public long l7; 
    public long l8; 
} 
public struct Struct64 
{ 
    public long l1; 
    public long l2; 
    public long l3; 
    public long l4; 
    public long l5; 
    public long l6; 
    public long l7; 
    public long l8; 
} 

प्रतिनिधि structs/वर्गों के साथ बात की इस तरह की कोशिश करो, और देखो क्या परिणाम आपको मिल ।(मेरी मशीन पर, परीक्षण के ऊपर, कक्षा ~ 3 गुना तेज लगती है)

Answer 2

• बड़ी संरचना उतनी कुशल नहीं है, लेकिन फिर .... यदि आपके पास अधिक डेटा है, तो आपके पास यह है। वहां दक्षता के बारे में बात करने का कोई मतलब नहीं है।

• 64 बाइट ठीक होना चाहिए।

• मुख्य कारण संभवतः कॉपी ऑपरेशन है .... यदि संरचना बड़ी है तो आईआईआरसी धीमी हो जाती है। और इसे काफी हद तक कॉपी किया जाना चाहिए।

मैं करूंगा सामान्य रूप से यहां एक वर्ग का उपयोग करते हुए सलाह;) लेकिन struct की सामग्री को जानने के बिना, यह एक छोटे मुश्किल है।

Answer 3

आप पुस्तक (कम से कम 2 संस्करण) गलत तरीके से गलत कर रहे हैं। जेफरी रिक्टर राज्यों मूल्य प्रकार 16 से अधिक बाइट्स अगर कर सकते हैं:

आप इरादा नहीं है उन्हें अन्य तरीकों के पास या करने के लिए और एक संग्रह वर्ग से उन्हें कॉपी करने के लिए।

इसके अतिरिक्त एरिक Gunnerson (16 बाइट सीमा के बारे में) कहते हैं

उपयोग एक ट्रिगर के रूप में इस निर्देश अधिक जांच करने के लिए।

यह सच नहीं है कि एक संरचना "आकार में 16 बाइट से कम होनी चाहिए"। यह सब उपयोग पर निर्भर करता है।

यदि आप संरचना बना रहे हैं और इसे भी उपभोग कर रहे हैं और प्रदर्शन के बारे में चिंतित हैं तो एक संरचना बनाम कक्षा की तुलना में एक प्रोफाइलर का उपयोग करें ताकि यह देखने के लिए कि कौन सा आपके लिए सबसे अच्छा काम करता है।

Answer 4

मुझे लगता है कि एक और महत्वपूर्ण बिंदु यह है कि यदि आपके पास लाखों structs के साथ एक सूची है, तो यह अभी भी ढेर पर केवल एक स्मृति आवंटन है, जबकि इसमें दस लाख वर्गों के साथ सूची में लगभग दस लाख अलग ढेर वस्तुओं की जा रही है। कचरा संग्रह भार दोनों मामलों में काफी अलग है। इस दृष्टिकोण से, संरचना आगे आ सकती है।

Answer 5

असेंबली भाषा प्रोग्रामिंग करते समय मैंने जो कुछ सीखा, वह यह था कि आप 8 या 16 बाइट सीमाओं पर अपने structs (और अन्य डेटा) को संरेखित करते हैं (वास्तव में एमएएसएम में इसके लिए प्रीप्रोसेसर कमांड है)। मेमोरी में चारों ओर चीजें संग्रहीत या स्थानांतरित करते समय इसका कारण काफी तेज़ स्मृति पहुंच है। आकार में 16 बाइट्स के तहत अपने structs को बनाए रखना सुनिश्चित करेगा कि यह स्मृति संरेखण सफलतापूर्वक किया जा सकता है क्योंकि कुछ भी संरेखण सीमा पार नहीं करेगा।

हालांकि मैं बात इस तरह की उम्मीद होती है मोटे तौर पर जब नेट ढांचे का उपयोग कर आप से छिपाना चाहता है। यदि आपके structs 16 बाइट से बड़े थे तो मैं फ्रेमवर्क (या जेआईटी कंपाइलर) को 32 बाइट सीमाओं पर अपने डेटा को संरेखित करने की अपेक्षा करता हूं, और इसी तरह। उन पुस्तकों में टिप्पणियों के कुछ सत्यापन को देखना दिलचस्प होगा, और देखें कि गति में अंतर क्या है।

Answer 6

JIT कम्पाइलर संरचनाओं जो एक न्यूनतम सीमा से छोटे हैं कॉपी करने के लिए विशेष-केस कोड पैदा करता है, और कुछ हद तक एक-धीमी सामान्य प्रयोजन बड़ों के लिए का निर्माण। मैं अनुमान लगाता हूं कि जब वह सलाह लिखी गई थी, तो सीमा 16 बाइट थी, लेकिन आज के 32-बिट ढांचे में यह 24 बाइट्स लगता है; यह 64-बिट कोड के लिए बड़ा हो सकता है।

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

भी ध्यान दें कि यह कई मामलों में मूल्य से संरचनाओं के आसपास गुजर या अन्यथा प्रचुरता से, उन्हें कॉपी करने अगर एक प्रयासों ऐसा करने के लिए से बचने के लिए संभव है। एक विधि के लिए ref पैरामीटर के रूप में संरचना के किसी भी आकार को पास करना, उदाहरण के लिए, केवल एक-मशीन-शब्द (4 या 8 बाइट्स) पते को पारित करने की आवश्यकता होती है। क्योंकि .net में const ref अवधारणा की किसी भी प्रकार की कमी नहीं है, केवल लिखने योग्य फ़ील्ड या वेरिएबल्स को इस तरह से पारित किया जा सकता है, और System.Array के अलावा संग्रह - नेटवाइड ref द्वारा सदस्यों तक पहुंचने का कोई मतलब नहीं है। यदि कोई सरणी या कस्टम संग्रह का उपयोग करने के इच्छुक है, हालांकि, यहां तक ​​कि विशाल (100 बाइट्स या अधिक) संरचनाओं को भी बहुत कुशलता से संसाधित किया जा सकता है। कई मामलों में, एक अपरिवर्तनीय वर्ग के बजाय संरचना का उपयोग करने का प्रदर्शन लाभ encapsulated डेटा के आकार के साथ बढ़ सकता है।

Answer 7

वास्तव में, एक 64-बिट मशीन पर 32 बाइट्स अधिकतम आकार struct डेटा के लिए उपयोग करने के लिए है। मेरे परीक्षणों से 32 बाइट स्ट्रक्चर (चार लम्बाई) के साथ-साथ ऑब्जेक्ट संदर्भ भी करता है।

आप यहाँ परीक्षण अपने आप को चलाने के परीक्षण कोड प्राप्त कर सकते हैं और: https://github.com/agileharbor/structBenchmark

परीक्षण पिछले कुछ structs की एक बड़ी संख्या को कॉपी/एक से दूसरे सरणी से वस्तुओं, और आप देखने के लिए जहां वर्ग में सक्षम हैं आठ लम्बाई के साथ संरचना का प्रदर्शन करता है, लेकिन यह चार लम्बाई के साथ संरचना के समान है।