c# - संरचना संरेखण इस बात पर निर्भर करता है कि फ़ील्ड प्रकार आदिम या उपयोगकर्ता परिभाषित है या नहीं?




.net struct (3)

नोडा टाइम वी 2 में, हम नैनोसेकंद रिज़ॉल्यूशन में जा रहे हैं। इसका मतलब है कि हम उस समय की पूरी रेंज का प्रतिनिधित्व करने के लिए 8-बाइट पूर्णांक का उपयोग नहीं कर सकते हैं, जिसने हमें दिलचस्पी है। इसने मुझे नोडा टाइम के कई (कई) structs के स्मृति उपयोग की जांच करने के लिए प्रेरित किया है, जिसने मुझे बदले में नेतृत्व किया है सीएलआर के संरेखण निर्णय में मामूली विषमता को उजागर करने के लिए।

सबसे पहले, मुझे एहसास हुआ कि यह एक कार्यान्वयन निर्णय है, और डिफ़ॉल्ट व्यवहार किसी भी समय बदल सकता है। मुझे एहसास है कि मैं इसे [StructLayout] और [FieldOffset] [StructLayout] का उपयोग करके संशोधित कर सकता हूं, लेकिन मैं ऐसे समाधान के साथ [FieldOffset] जो संभव होने पर इसकी आवश्यकता नहीं है।

मेरा मुख्य परिदृश्य यह है कि मेरे पास एक struct जिसमें एक संदर्भ-प्रकार फ़ील्ड और दो अन्य मूल्य-प्रकार फ़ील्ड हैं, जहां वे फ़ील्ड int लिए सरल रैपर हैं। मैंने आशा की थी कि इसे 64-बिट सीएलआर (संदर्भ के लिए 8 और प्रत्येक के लिए 4) पर 16 बाइट्स के रूप में दर्शाया जाएगा, लेकिन किसी कारण से यह 24 बाइट्स का उपयोग कर रहा है। मैं सरणी का उपयोग करके अंतरिक्ष को माप रहा हूं, वैसे - मैं समझता हूं कि लेआउट विभिन्न स्थितियों में भिन्न हो सकता है, लेकिन यह एक उचित प्रारंभिक बिंदु की तरह महसूस किया।

इस मुद्दे का प्रदर्शन करने वाला नमूना कार्यक्रम यहां दिया गया है:

using System;
using System.Runtime.InteropServices;

#pragma warning disable 0169

struct Int32Wrapper
{
    int x;
}

struct TwoInt32s
{
    int x, y;
}

struct TwoInt32Wrappers
{
    Int32Wrapper x, y;
}

struct RefAndTwoInt32s
{
    string text;
    int x, y;
}

struct RefAndTwoInt32Wrappers
{
    string text;
    Int32Wrapper x, y;
}    

class Test
{
    static void Main()
    {
        Console.WriteLine("Environment: CLR {0} on {1} ({2})",
            Environment.Version,
            Environment.OSVersion,
            Environment.Is64BitProcess ? "64 bit" : "32 bit");
        ShowSize<Int32Wrapper>();
        ShowSize<TwoInt32s>();
        ShowSize<TwoInt32Wrappers>();
        ShowSize<RefAndTwoInt32s>();
        ShowSize<RefAndTwoInt32Wrappers>();
    }

    static void ShowSize<T>()
    {
        long before = GC.GetTotalMemory(true);
        T[] array = new T[100000];
        long after  = GC.GetTotalMemory(true);        
        Console.WriteLine("{0}: {1}", typeof(T),
                          (after - before) / array.Length);
    }
}

और मेरे लैपटॉप पर संकलन और आउटपुट:

c:\Users\Jon\Test>csc /debug- /o+ ShowMemory.cs
Microsoft (R) Visual C# Compiler version 12.0.30501.0
for C# 5
Copyright (C) Microsoft Corporation. All rights reserved.


c:\Users\Jon\Test>ShowMemory.exe
Environment: CLR 4.0.30319.34014 on Microsoft Windows NT 6.2.9200.0 (64 bit)
Int32Wrapper: 4
TwoInt32s: 8
TwoInt32Wrappers: 8
RefAndTwoInt32s: 16
RefAndTwoInt32Wrappers: 24

इसलिए:

  • यदि आपके पास कोई संदर्भ प्रकार फ़ील्ड नहीं है, तो सीएलआर Int32Wrapper फ़ील्ड को एक साथ पैक करने में प्रसन्न है (दो TwoInt32Wrappers आकार 8 है)
  • संदर्भ प्रकार फ़ील्ड के साथ भी, सीएलआर अभी भी int फ़ील्ड को पैक करने में खुश है ( RefAndTwoInt32s का आकार 16 है)
  • दोनों का मिश्रण, प्रत्येक Int32Wrapper फ़ील्ड को 8 बाइट्स तक गद्देदार / गठबंधन किया जाता है। ( RefAndTwoInt32Wrappers का आकार 24 है।)
  • डीबगर में एक ही कोड चलाना (लेकिन अभी भी एक रिलीज बिल्ड) 12 का आकार दिखाता है।

कुछ अन्य प्रयोगों ने समान परिणाम प्राप्त किए हैं:

  • मान प्रकार फ़ील्ड के बाद संदर्भ प्रकार फ़ील्ड डालने से मदद नहीं मिलती है
  • string बजाय object का उपयोग करने से मदद नहीं मिलती है (मुझे उम्मीद है कि यह "कोई संदर्भ प्रकार" है)
  • संदर्भ के चारों ओर एक "रैपर" के रूप में एक और संरचना का उपयोग करने में मदद नहीं करता है
  • संदर्भ के चारों ओर एक रैपर के रूप में एक सामान्य संरचना का उपयोग करने में मदद नहीं करता है
  • यदि मैं फ़ील्ड जोड़ना चाहता हूं (सादगी के लिए जोड़े में), int फ़ील्ड अभी भी 4 बाइट्स के लिए गिनती है, और Int32Wrapper फ़ील्ड 8 बाइट्स के लिए गिनती है
  • दृष्टि में प्रत्येक संरचना में [StructLayout(LayoutKind.Sequential, Pack = 4)] जोड़ना परिणाम नहीं बदलता है

क्या किसी के पास इस के लिए कोई स्पष्टीकरण है (आदर्श रूप से संदर्भ प्रलेखन के साथ) या सीएलआर को संकेत कैसे मिल सकता है कि मैं फ़ील्ड को निरंतर फ़ील्ड ऑफ़सेट निर्दिष्ट किए बिना पैक करना चाहता हूं?


मिश्रण में कुछ डेटा जोड़ने के लिए - मैंने आपके पास से एक और प्रकार बनाया है:

struct RefAndTwoInt32Wrappers2
{
    string text;
    TwoInt32Wrappers z;
}

कार्यक्रम लिखता है:

RefAndTwoInt32Wrappers2: 16

तो ऐसा लगता है कि नई RefAndTwoInt32Wrappers2 संरचना में दो RefAndTwoInt32Wrappers2 संरचना ठीक से संरेखित है।


मुझे लगता है कि यह एक बग है। आप स्वचालित लेआउट के दुष्प्रभाव को देख रहे हैं, यह गैर-तुच्छ फ़ील्ड को उस पते पर संरेखित करना पसंद करता है जो 64-बिट मोड में 8 बाइट्स का एक से अधिक है। यह तब भी होता है जब आप [StructLayout(LayoutKind.Sequential)] । आवश्यक [StructLayout(LayoutKind.Sequential)] विशेषता को स्पष्ट रूप से लागू करते हैं। ऐसा नहीं होना चाहिए।

आप इसे स्ट्रक्चर सदस्यों को सार्वजनिक करके और इस तरह टेस्ट कोड जोड़कर देख सकते हैं:

    var test = new RefAndTwoInt32Wrappers();
    test.text = "adsf";
    test.x.x = 0x11111111;
    test.y.x = 0x22222222;
    Console.ReadLine();      // <=== Breakpoint here

जब ब्रेकपॉइंट हिट होता है, डीबग + विंडोज + मेमोरी + मेमोरी का उपयोग करें 1. 4-बाइट पूर्णांक पर स्विच करें और पता फ़ील्ड में डाल दें &test :

 0x000000E928B5DE98  0ed750e0 000000e9 11111111 00000000 22222222 00000000 

0xe90ed750e0 मेरी मशीन पर स्ट्रिंग पॉइंटर है (आपका नहीं)। आप आसानी से Int32Wrappers देख सकते हैं, अतिरिक्त 4 बाइट पैडिंग के साथ जो आकार को 24 बाइट्स में बदल देता है। संरचना पर वापस जाएं और स्ट्रिंग को आखिरी रखें। दोहराएं और आप देखेंगे कि स्ट्रिंग पॉइंटर अभी भी पहले है। LayoutKind.Sequential उल्लंघन करना। आवश्यक, आपको LayoutKind.Auto मिला।

इसे ठीक करने के लिए माइक्रोसॉफ्ट को मनाने के लिए मुश्किल हो रही है, इसने इस तरह से बहुत लंबे समय तक काम किया है, इसलिए कोई भी बदलाव कुछ तोड़ने जा रहा है । सीएलआर केवल एक संरचना के प्रबंधित संस्करण के लिए [StructLayout] का सम्मान करने का प्रयास करता है और इसे ब्लिटेबल बनाता है, यह सामान्य रूप से जल्दी छोड़ देता है। किसी भी संरचना के लिए कुख्यात रूप से डेटटाइम होता है। एक संरचना को मार्शल करते समय आपको केवल वास्तविक लेआउटकिंड गारंटी मिलती है। मार्शल संस्करण निश्चित रूप से 16 बाइट्स है, क्योंकि मार्शल. Marshal.SizeOf() आपको बताएगा।

LayoutKind.Explicit का LayoutKind.Explicit करना इसे ठीक करता है, जो आप सुनना नहीं चाहते थे।


EDIT2

struct RefAndTwoInt32Wrappers
{
    public int x;
    public string s;
}

यह कोड 8 बाइट गठबंधन होगा ताकि संरचना में 16 बाइट होंगे। तुलना करके यह:

struct RefAndTwoInt32Wrappers
{
    public int x,y;
    public string s;
}

4 बाइट गठबंधन होगा इसलिए इस संरचना में 16 बाइट होंगे। तो यहां तर्क यह है कि सीएलआर में संरचना संरेखण सबसे गठबंधन क्षेत्रों की संख्या से निर्धारित होता है, जो स्पष्ट रूप से ऐसा नहीं कर सकते हैं, इसलिए वे 8 बाइट गठबंधन बने रहेंगे।

अब अगर हम सभी को गठबंधन करते हैं और संरचना बनाते हैं:

struct RefAndTwoInt32Wrappers
{
    public int x,y;
    public Int32Wrapper z;
    public string s;
}

इसमें 24 बाइट्स होंगे {x, y} में प्रत्येक 4 बाइट होंगे और {z, s} में 8 बाइट होंगे। एक बार जब हम संरचना सीएलआर में एक रेफ प्रकार पेश करेंगे, तो कक्षा संरेखण से मेल खाने के लिए हमेशा हमारे कस्टम स्ट्रक्चर को संरेखित करेंगे।

struct RefAndTwoInt32Wrappers
{
    public Int32Wrapper z;
    public long l;
    public int x,y;  
}

इस कोड में 24 बाइट होंगे क्योंकि Int32Wrapper को लंबे समय तक गठबंधन किया जाएगा। तो कस्टम स्ट्रक्चर रैपर हमेशा संरचना में या अपने स्वयं के आंतरिक सबसे महत्वपूर्ण क्षेत्रों में उच्चतम / सर्वोत्तम गठबंधन क्षेत्र में संरेखित होगा। तो एक रेफ स्ट्रिंग के मामले में जो 8 बाइट गठबंधन है, संरचना रैपर उस पर संरेखित होगा।

संरचना के अंदर कस्टम स्ट्रक्चर फ़ील्ड को हमेशा संरचना में उच्चतम गठबंधन उदाहरण फ़ील्ड में गठबंधन किया जाएगा। अब अगर मुझे यकीन नहीं है कि यह एक बग है लेकिन कुछ सबूत के बिना मैं अपनी राय से चिपकने वाला हूं कि यह सचेत निर्णय हो सकता है।

संपादित करें

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

मैं क्ली कोड का निरीक्षण करूंगा और कुछ उपयोगी पोस्ट करूंगा यदि कुछ उपयोगी मिलेगा।

यह एक संरेखण रणनीति है जो .NET mem आवंटक द्वारा उपयोग की जाती है।

public static RefAndTwoInt32s[] test = new RefAndTwoInt32s[1];

static void Main()
{
    test[0].text = "a";
    test[0].x = 1;
    test[0].x = 1;

    Console.ReadKey();
}

X64 के तहत .net40 के साथ संकलित यह कोड, WinDbg में निम्न कार्य करने देता है:

आइए पहले हीप पर टाइप ढूंढें:

    0:004> !dumpheap -type Ref
       Address               MT     Size
0000000003e72c78 000007fe61e8fb58       56    
0000000003e72d08 000007fe039d3b78       40    

Statistics:
              MT    Count    TotalSize Class Name
000007fe039d3b78        1           40 RefAndTwoInt32s[]
000007fe61e8fb58        1           56 System.Reflection.RuntimeAssembly
Total 2 objects

एक बार हमारे पास यह देखने के बाद कि उस पते के तहत क्या है:

    0:004> !do 0000000003e72d08
Name:        RefAndTwoInt32s[]
MethodTable: 000007fe039d3b78
EEClass:     000007fe039d3ad0
Size:        40(0x28) bytes
Array:       Rank 1, Number of elements 1, Type VALUETYPE
Fields:
None

हम देखते हैं कि यह एक वैल्यू टाइप है और जिसे हमने बनाया है। चूंकि यह एक सरणी है, इसलिए हमें सरणी में एक तत्व के ValueType def को प्राप्त करने की आवश्यकता है:

    0:004> !dumparray -details 0000000003e72d08
Name:        RefAndTwoInt32s[]
MethodTable: 000007fe039d3b78
EEClass:     000007fe039d3ad0
Size:        40(0x28) bytes
Array:       Rank 1, Number of elements 1, Type VALUETYPE
Element Methodtable: 000007fe039d3a58
[0] 0000000003e72d18
    Name:        RefAndTwoInt32s
    MethodTable: 000007fe039d3a58
    EEClass:     000007fe03ae2338
    Size:        32(0x20) bytes
    File:        C:\ConsoleApplication8\bin\Release\ConsoleApplication8.exe
    Fields:
                      MT    Field   Offset                 Type VT     Attr            Value Name
        000007fe61e8c358  4000006        0            System.String      0     instance     0000000003e72d30     text
        000007fe61e8f108  4000007        8             System.Int32      1     instance                    1     x
        000007fe61e8f108  4000008        c             System.Int32      1     instance                    0     y

संरचना वास्तव में 32 बाइट्स है क्योंकि यह 16 बाइट पैडिंग के लिए आरक्षित है, इसलिए वास्तविकता में प्रत्येक संरचना कम से कम 16 बाइट्स आकार में है।

यदि आप इनट्स से 16 बाइट जोड़ते हैं और एक स्ट्रिंग को रेफरी करते हैं: 0000000003e72d18 + 8 बाइट ईई / पैडिंग आप 0000000003e72d30 पर समाप्त हो जाएंगे और यह स्ट्रिंग संदर्भ के लिए स्टारिंग पॉइंट है, और चूंकि सभी संदर्भ 8 बाइट अपने पहले वास्तविक डेटा फ़ील्ड से पैड किए गए हैं यह इस संरचना के लिए हमारे 32 बाइट्स के लिए बनाता है।

चलो देखते हैं कि स्ट्रिंग वास्तव में उस तरह से गद्देदार है या नहीं:

0:004> !do 0000000003e72d30    
Name:        System.String
MethodTable: 000007fe61e8c358
EEClass:     000007fe617f3720
Size:        28(0x1c) bytes
File:        C:\WINDOWS\Microsoft.Net\assembly\GAC_64\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll
String:      a
Fields:
              MT    Field   Offset                 Type VT     Attr            Value Name
000007fe61e8f108  40000aa        8         System.Int32  1 instance                1 m_stringLength
000007fe61e8d640  40000ab        c          System.Char  1 instance               61 m_firstChar
000007fe61e8c358  40000ac       18        System.String  0   shared           static Empty
                                 >> Domain:Value  0000000001577e90:NotInit  <<

अब उपर्युक्त प्रोग्राम का विश्लेषण उसी तरह करते हैं:

public static RefAndTwoInt32Wrappers[] test = new RefAndTwoInt32Wrappers[1];

static void Main()
{
    test[0].text = "a";
    test[0].x.x = 1;
    test[0].y.x = 1;

    Console.ReadKey();
}

0:004> !dumpheap -type Ref
     Address               MT     Size
0000000003c22c78 000007fe61e8fb58       56    
0000000003c22d08 000007fe039d3c00       48    

Statistics:
              MT    Count    TotalSize Class Name
000007fe039d3c00        1           48 RefAndTwoInt32Wrappers[]
000007fe61e8fb58        1           56 System.Reflection.RuntimeAssembly
Total 2 objects

हमारी संरचना अब 48 बाइट्स है।

0:004> !dumparray -details 0000000003c22d08
Name:        RefAndTwoInt32Wrappers[]
MethodTable: 000007fe039d3c00
EEClass:     000007fe039d3b58
Size:        48(0x30) bytes
Array:       Rank 1, Number of elements 1, Type VALUETYPE
Element Methodtable: 000007fe039d3ae0
[0] 0000000003c22d18
    Name:        RefAndTwoInt32Wrappers
    MethodTable: 000007fe039d3ae0
    EEClass:     000007fe03ae2338
    Size:        40(0x28) bytes
    File:        C:\ConsoleApplication8\bin\Release\ConsoleApplication8.exe
    Fields:
                      MT    Field   Offset                 Type VT     Attr            Value Name
        000007fe61e8c358  4000009        0            System.String      0     instance     0000000003c22d38     text
        000007fe039d3a20  400000a        8             Int32Wrapper      1     instance     0000000003c22d20     x
        000007fe039d3a20  400000b       10             Int32Wrapper      1     instance     0000000003c22d28     y

यहां स्थिति समान है, अगर हम स्ट्रिंग रेफरी के 0000000003c22d18 + 8 बाइट्स में जोड़ते हैं तो हम पहले इंट रैपर की शुरुआत में समाप्त हो जाएंगे, जहां मूल्य वास्तव में उस पते पर इंगित करता है जिस पर हम हैं।

अब हम देख सकते हैं कि प्रत्येक मान एक ऑब्जेक्ट संदर्भ है फिर पुष्टि करता है कि 0000000003c22d20 देखकर।

0:004> !do 0000000003c22d20
<Note: this object has an invalid CLASS field>
Invalid object

असल में यह एक संरचना के बाद से सही है, पता हमें कुछ भी नहीं बताता है अगर यह एक ओबीजे या वीटी है।

0:004> !dumpvc 000007fe039d3a20   0000000003c22d20    
Name:        Int32Wrapper
MethodTable: 000007fe039d3a20
EEClass:     000007fe03ae23c8
Size:        24(0x18) bytes
File:        C:\ConsoleApplication8\bin\Release\ConsoleApplication8.exe
Fields:
              MT    Field   Offset                 Type VT     Attr            Value Name
000007fe61e8f108  4000001        0         System.Int32  1 instance                1 x

तो वास्तविकता में यह एक संघ प्रकार की तरह अधिक है जो इस समय 8 बाइट गठबंधन करेगा (सभी पैडिंग मूल संरचना के साथ गठबंधन किए जाएंगे)। यदि यह नहीं था तो हम 20 बाइट्स के साथ समाप्त हो जाएंगे और यह इष्टतम नहीं है, इसलिए स्मृति आवंटक इसे कभी भी होने की अनुमति नहीं देगा। यदि आप फिर से गणित करते हैं तो यह पता चला है कि संरचना वास्तव में आकार के 40 बाइट्स है।

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

आखिरी सवाल यह है कि अचानक हम इस तरह के लेआउट क्यों ले सकते हैं। ठीक है अगर आप काउंटर फील्ड वृद्धि के साथ jit कोड और स्ट्रक्चर [] के साथ int [] वृद्धि के प्रदर्शन की तुलना करते हैं तो दूसरा एक 8 बाइट गठबंधन पता एक यूनियन बन जाएगा, लेकिन जब यह जब्त किया जाता है तो यह अधिक अनुकूलित असेंबली कोड (गायक एलआईए बनाम एकाधिक एमओवी)। हालांकि यहां वर्णित मामले में प्रदर्शन वास्तव में और भी खराब होगा, इसलिए मेरा लेना यह है कि यह अंतर्निहित सीएलआर कार्यान्वयन के अनुरूप है क्योंकि यह एक कस्टम प्रकार है जिसमें कई फ़ील्ड हो सकते हैं ताकि प्रारंभिक पते को इसके बजाय प्रारंभिक पता लगाया जा सके मूल्य (क्योंकि यह असंभव होगा) और वहाँ संरचना पैडिंग करते हैं, जिसके परिणामस्वरूप बड़े बाइट आकार होते हैं।





memory-alignment