[DotNetBook]タイプのインスタンス構造とVMT

この記事では、引き続き一連の記事を公開します。その結果、.NET CLRおよび.NET全般の作業に関する本になります。



本全体がGitHub： CLR Bookで利用可能になります。 だから問題とプルリクエストは大歓迎です:)



これは、 型の構造とそのVMTに関する章からの抜粋です。

メモリ内のオブジェクトの構造

これまでのところ、 重要なタイプと参照タイプの違いについて言えば 、最終開発者の観点からこのトピックに取り組んできました。 すなわち CLRレベルで実際にどのように配置されているのか、それぞれの内部で特定のメカニズムがどのように作られているのかについては見ていません。 実際に最終結果を見ました。 ただし、物事の本質をより深く理解し、CLR内で発生する魔法に関する最後に残った考えを捨てるには、その内臓を調べる価値があります。

ご注意

Habréで公開されている章は更新されておらず、おそらくすでに古いものです。 そのため、最新のテキストについては元に戻してください。

• CLR Book： GitHub、目次
• CLR Book： GitHub、章
• リリース0.5.2の書籍、PDF： GitHubリリース

型インスタンスの内部構造

クラスをデータ型として話す場合、そのデータ型についての会話で、基本的なデバイスを思い出すだけで十分です。 object



型から始めましょう。これは基本型であり、すべての参照型の構造を形成します。

System.object

  ---------------------------------------------- | SyncBlkIndx | VMTPtr | Data | ---------------------------------------------- | 4 / 8  | 4 / 8  | 4 / 8  | ---------------------------------------------- | 0xFFF..FFF | 0xXXX..XXX | 0 | ---------------------------------------------- ^ |     . ..   ,   VMT Sum size = 12 (x86) .. 24 (x64)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

すなわち 実際、サイズはアプリケーションが実行される最終的なプラットフォームに依存します。



今、私たちが何を扱っているかをさらに理解するために、 VMTPtr



ポインターを追ってみましょう。 型システム全体にとって、このポインターは最も重要です。継承、インターフェースの実装、型変換が機能するのは、それを介することです。 このポインターは、.NET CLR型システムへの参照です。

仮想メソッド表

テーブル自体の説明はGitHub CoreCLRのアドレスで入手できます。余分なものをすべて破棄すると（そして4381行あります！CoreCLRチームのメンバーは恥ずかしがり屋ではありません）、 次のようになります 。

これはCoreCLRのバージョンです。 .NET Frameworkのフィールド構造を見ると、フィールドの配置が異なります。

  // Low WORD is component size for array and string types (HasComponentSize() returns true). // Used for flags otherwise. DWORD m_dwFlags; // Base size of instance of this class when allocated on the heap DWORD m_BaseSize; WORD m_wFlags2; // Class token if it fits into 16-bits. If this is (WORD)-1, the class token is stored in the TokenOverflow optional member. WORD m_wToken; // <NICE> In the normal cases we shouldn't need a full word for each of these </NICE> WORD m_wNumVirtuals; WORD m_wNumInterfaces;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

同意して、恐ろしく見えます。 恐ろしいことは、フィールドが6つしかないということではありません（他のフィールドはどこにありますか？）。しかし、それらに到達するために、4,100行のロジックをスキップする必要がありました。 しかし、心を失い、すぐに利益を得ようとしないでください：今のところ、他のフィールドが何を意味するのかわかりませんが、 `m_BaseSize`フィールドは魅力的に見えます。 コメントからわかるように、これは型インスタンスの実際のサイズです。 戦いに行こうか？



VMTアドレスを取得するには、次の2つの方法があります。困難なところからオブジェクトアドレスを取得するか、VMTです（このコードの一部は既にこの本のページにありましたが、scらないでください：探したくないです）。

 class Program { public static unsafe void Main() { Union x = new Union(); x.Reference.Value = "Hello!"; //      ,   //   VMT // - (IntPtr*)x.Value.Value -     (   ) // - *(IntPtr*)x.Value.Value -      VMT // - (void *)*(IntPtr*)x.Value.Value -    void *vmt = (void *)*(IntPtr*)x.Value.Value; //     VMT; Console.WriteLine((ulong)vmt); } [StructLayout(LayoutKind.Explicit)] public class Union { public Union() { Value = new Holder<IntPtr>(); Reference = new Holder<object>(); } [FieldOffset(0)] public Holder<IntPtr> Value; [FieldOffset(0)] public Holder<object> Reference; } public class Holder<T> { public T Value; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

または、.NET FCL APIによってそれとまったく同じアドレスが返されます。

  var vmt = typeof(string).TypeHandle.Value;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

2番目の方法は、もちろん簡単です（ただし、より長く機能します）。 ただし、前者の知識は、型のインスタンスの構造を理解する上で非常に重要です。 ただし、2番目の方法を使用すると、自信が増します。APIメソッドを呼び出すと、VMTを使用する文書化された方法を使用するようなものになります。 そして、ポインターを通過する場合、いいえ。 しかし、 `VMT *`を保存することは、ほとんどすべてのOOP言語と.NETプラットフォーム全体にとって標準であることを忘れないでください。常に同じ場所にあります。



インスタンスのサイズの観点から型構造の問題を調べてみましょう。 私たちはそれらを抽象的に研究する必要があるだけでなく（これは単に退屈です）、さらに、通常の方法では抽出できないこのような利点を引き出すことを試みます。

参照型ではなく、値型のsizeofがなぜですか？ 実際に質問は開いています 誰も参照型のサイズを計算することを気にしません。 つまずく唯一のことは、2つの参照型の固定されていないサイズ： `Array`と` String`です。 特定のオプションに完全に依存する「Generic」グループと同様に。 すなわち `sizeof（..）`演算子ではできませんでした：特定のインスタンスを操作する必要があります。 しかし、 `static int System.Object.SizeOf（object obj）`のようなメソッドを作成することを誰も気にしません。 では、なぜマイクロソフトはこの方法を実装しなかったのですか？ 彼らが理解している.NETプラットフォームは、開発者が特定のバイトを非常に心配するプラットフォームではないという考えがあります。 その場合、ストリップをマザーボードに簡単に配送できます。 さらに、私たちが実装するほとんどのタイプのデータは、そのような大量を占有しません。 ただし、必要なものがすべて必要な場合は、必要に応じてすべてのサイズを計算します。 もちろん後者は議論の余地があります。

しかし、気を散らさないようにしましょう。 したがって、インスタンスのサイズが固定されているクラスのインスタンスのサイズを取得するには、次のコードを記述するだけで十分です。

 unsafe int SizeOf(Type type) { MethodTable *pvmt = (MethodTable *)type.TypeHandle.Value.ToPointer(); return pvmt->Size; } [StructLayout(LayoutKind.Explicit)] public struct MethodTable { [FieldOffset(4)] public int Size; } class Sample { int x; } class GenericSample<T> { T fld; } // ... Console.WriteLine(SizeOf(typeof(Sample)));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

それで、私たちは今何をしましたか？ 最初のステップは、仮想メソッドのテーブルへのポインターを取得することです。 次に、タイプを仮想メソッドのテーブル（非常に単純化されたバージョン）へのポインターに導きました。 その後、サイズを読み取って `12`を取得します。これは、32ビットプラットフォームの` SyncBlockIndex + VMT_Ptr + field x`フィールドのサイズの合計です。 さまざまなタイプを試してみると、次の表が得られます。





ご覧のとおり、システムが型のインスタンスのサイズでデータを保存するとき、実際には参照型のデータ（参照バリアントの重要なものを含む）が保存されます。 いくつかの結論を導きましょう。

1. 重要な型が値としてどれだけ取るかを知りたい場合は、 `sizeof（TType）`を使用します
2. ボクシングにかかる​​コストを計算する場合は、「sizeof（TType）」をプロセッサのワードサイズ（4または8バイト）に切り上げ、さらに2ワード追加できます。 または、この値を「VMT」タイプから取得します。
3. 必要に応じて、ヒープにメモリを割り当てるのにかかるコストを理解するために、3つのオプションがあります。

System.string

実用的な問題の行については別に説明します。この比較的小さなクラスに章全体を割り当てることができます。 また、VMTの構築に関する章では、低レベルでのラインの構築について説明します。 UTF16標準は、文字列を格納するために使用されます。 つまり、各文字には2バイトが必要です。 さらに、各行の最後にヌルターミネータが格納されます（つまり、行が終了したことを識別する値）。 文字列の長さは、Int32番号としても保存されます-必要になるたびに長さをカウントしないようにするためです。 エンコーディングについては別に説明しますが、今のところはこの情報で十分です。

  //  .NET Framework 4   ------------------------------------------------------------------------- | SyncBlkIndx | VMTPtr | Length | char | char | Term | ------------------------------------------------------------------------- | 4 / 8  | 4 / 8  | 4  | 2 . | 2 . | 2 . | ------------------------------------------------------------------------- | -1 | 0xXXXXXXXX | 2 | a | b | nil | ------------------------------------------------------------------------- Term - null terminator Sum size = (12 (24) + 2 + (Len*2)) ->      . (20   ) //  .NET Framework 3.5   ------------------------------------------------------------------------------ | SyncBlkIndx| VMTPtr | ArrayLength | Length | char | char | Term | ------------------------------------------------------------------------------ | 4 / 8  | 4 / 8  | 4  | 4  | 2 . | 2 . | 2 . | ------------------------------------------------------------------------------ | -1 | 0xXXXXXXXX | 3 | 2 | a | b | nil | ------------------------------------------------------------------------------ Term - null terminator Sum size = (16 (32) + 2 + (Len*2)) ->      . (24   )
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

文字列のサイズを数える方法を教えるためにメソッドを書き直します：

 unsafe int SizeOf(object obj) { var majorNetVersion = Environment.Version.Major; var type = obj.GetType(); var href = Union.GetRef(obj).ToInt64(); var DWORD = sizeof(IntPtr); var baseSize = 3 * DWORD; if (type == typeof(string)) { if (majorNetVersion >= 4) { var length = (int)*(int*)(href + DWORD /* skip vmt */); return DWORD * ((baseSize + 2 + 2 * length + (DWORD-1)) / DWORD); } else { // on 1.0 -> 3.5 string have additional RealLength field var arrlength = *(int*)(href + DWORD /* skip vmt */); var length = *(int*)(href + DWORD /* skip vmt */ + 4 /* skip length */); return DWORD * ((baseSize + 2 + 2 * length + (DWORD -1)) / DWORD); } } else if (type.BaseType == typeof(Array) || type == typeof(Array)) { return ((ArrayInfo*)href)->SizeOf(); } return SizeOf(type); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

`SizeOf（type）`は古い実装を呼び出します-固定長の参照型の場合。



実際にコードを確認しましょう：

  Action<string> stringWriter = (arg) => { Console.WriteLine($"Length of `{arg}` string: {SizeOf(arg)}"); }; stringWriter("a"); stringWriter("ab"); stringWriter("abc"); stringWriter("abcd"); stringWriter("abcde"); stringWriter("abcdef"); } ----- Length of `a` string: 16 Length of `ab` string: 20 Length of `abc` string: 20 Length of `abcd` string: 24 Length of `abcde` string: 24 Length of `abcdef` string: 28
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

計算では、行サイズは線形ではなく段階的に、つまり2文字ごとに増加します。 これは、各文字のサイズが2バイトであり、互いに続くためです。 ただし、最終サイズは、トレースなしでプロセッサの容量で割る必要があります。 すなわち 一部の行は、さらに2バイト「アップ」します。 私たちの仕事の結果は素晴らしいです。この行がどれくらいの費用がかかるかを計算できます。 最後のステップは、メモリ内の配列のサイズを計算し、タスクをさらに実用的にする方法を見つけることです。次の質問に答えるメソッドを作成しましょう。SOHに適合するためには、どのサイズの配列を取る必要があるか。 Lengthプロパティを使用すると、より合理的で高速になるように思えるかもしれませんが、実際には、動作が遅くなります：追加コスト。

配列

配列の構造はやや複雑です：配列は構造のバリアントを持つことができます：

1. 意味のある型を保存することも、参照を保存することもできます
2. 配列には1つまたは複数の次元を含めることができます
3. 各測定は、「0」または他の数字で開始できます（これは、私の意見では非常に議論の余地のある機会です。

したがって、配列の実装には多少の混乱があり、最終的な配列のサイズを正確に予測することができません。要素の数にサイズを掛けるだけでは不十分です。 もちろん、ほとんどの場合、これでほぼ十分です。 LOHに入るのが怖いとき、サイズは重要になります。 ただし、ここにはオプションがあります。85000で境界を越えたかどうかを理解するために、「膝の上」で計算されたサイズに上記の定数（100など）を単純にスローできます。 ただし、このセクションのフレームワーク内では、タスクは多少異なります。型の構造を理解することです。 そしてそれを見てください：

 //  -------------------------------------------------------------------------------- | SBI | VMTPtr |Total | Len_1 | Len_2 | .. | Len_N | Term | VMT_Child | --------------------------opt-------opt------------opt-------opt--------opt----- | 4 / 8 | 4 / 8 | 4 | 4 | 4 | | 4 | 4 | 4/8 | -------------------------------------------------------------------------------- |0xFF.FF|0xXX.XX | ? | ? | ? | | ? |0x00.00| 0xXX..XX | -------------------------------------------------------------------------------- - opt:  - SBI: Sync Block Index - VMT_Child:         - Total:   .         - Len_2..Len_N + Term:       1 (   VMT->Flags)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ご覧のとおり、タイプヘッダーには配列の次元に関するデータが格納されます。その数は1または非常に大きい可能性があります。実際、サイズはnullターミネーターによってのみ制限されます。つまり、列挙が完了します。 この例は[GettingInstanceSize]ファイル（./ samples / GettingInstanceSize.linq）で完全に利用できます。以下では、最も重要な部分のみを示します。

 public int SizeOf() { var total = 0; int elementsize; fixed (void* entity = &MethodTable) { var arr = Union.GetObj<Array>((IntPtr)entity); var elementType = arr.GetType().GetElementType(); if (elementType.IsValueType) { var typecode = Type.GetTypeCode(elementType); switch (typecode) { case TypeCode.Byte: case TypeCode.SByte: case TypeCode.Boolean: elementsize = 1; break; case TypeCode.Int16: case TypeCode.UInt16: case TypeCode.Char: elementsize = 2; break; case TypeCode.Int32: case TypeCode.UInt32: case TypeCode.Single: elementsize = 4; break; case TypeCode.Int64: case TypeCode.UInt64: case TypeCode.Double: elementsize = 8; break; case TypeCode.Decimal: elementsize = 12; break; default: var info = (MethodTable*)elementType.TypeHandle.Value; elementsize = info->Size - 2 * sizeof(IntPtr); // sync blk + vmt ptr break; } } else { elementsize = IntPtr.Size; } // Header total += 3 * sizeof(IntPtr); // sync blk + vmt ptr + total length total += elementType.IsValueType ? 0 : sizeof(IntPtr); // MethodsTable for refTypes total += IsMultidimentional ? Dimensions * sizeof(int) : 0; } // Contents total += (int)TotalLength * elementsize; // align size to IntPtr if ((total % sizeof(IntPtr)) != 0) { total += sizeof(IntPtr) - total % (sizeof(IntPtr)); } return total; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このコードは、配列タイプのすべてのバリエーションを考慮し、そのサイズを計算するために使用できます。

 Console.WriteLine($"size of int[]{{1,2}}: {SizeOf(new int[2])}"); Console.WriteLine($"size of int[2,1]{{1,2}}: {SizeOf(new int[1,2])}"); Console.WriteLine($"size of int[2,3,4,5]{{...}}: {SizeOf(new int[2, 3, 4, 5])}"); --- size of int[]{1,2}: 20 size of int[2,1]{1,2}: 32 size of int[2,3,4,5]{...}: 512
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

セクションの結論

この段階で、かなり重要なことをいくつか学びました。 最初に、参照型を固定型の参照型、ジェネリック型、および可変サイズの参照型の3つのグループに分けました。 また、あらゆるタイプの最終インスタンスの構造を理解することも学びました（当面、VMTの構造については言及しません。これまでのところ、1つのフィールドのみを完全に理解しました。これも素晴らしい成果です）。 固定サイズの参照型（すべてが非常に単純）または不定サイズの参照型：配列または文字列。 サイズが作成時に決定されるため、不確かです。 実際、ジェネリック型を使用すると、すべてが単純になります。特定のジェネリック型ごとに、独自のVMTが作成され、そこに特定のサイズが付加されます。

メソッド表

VMTクラス

メソッドテーブルの説明はほとんど学術的なものです。結局のところ、そのようなジャングルに登るということは、自分で墓を掘るようなものです。 一方では、そのようなビンはエキサイティングで興味深いものを隠し、何が起こっているのかをさらに明らかにするデータを保存します。 ただし、一方で、Microsoftはランタイムを変更せず、たとえば、突然メソッドテーブルが1つのフィールドに移動しないという保証をMicrosoftが提供しないことを理解しています。



まあ、すべてが警告した。 今、彼らが見ているガラスを通して言うように、世界に飛び込みましょう。 実際、これまでは、見ているガラス全体がオブジェクトの構造の知識に還元されてきました。そして、理論的には、少なくともおおよそ知っているはずです。 そして本質的に、この知識は見ているガラスの背後にあるのではなく、見ているガラスへの入り口です。 CoreCLRで説明されている `MethodTable`構造に戻りましょう。

  // Low WORD is component size for array and string types (HasComponentSize() returns true). // Used for flags otherwise. DWORD m_dwFlags; // Base size of instance of this class when allocated on the heap DWORD m_BaseSize; WORD m_wFlags2; // Class token if it fits into 16-bits. If this is (WORD)-1, the class token is stored in the TokenOverflow optional member. WORD m_wToken; // <NICE> In the normal cases we shouldn't need a full word for each of these </NICE> WORD m_wNumVirtuals; WORD m_wNumInterfaces;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

つまり、「m_wNumVirtuals」および「m_wNumInterfaces」フィールドに。 これらの2つのフィールドは、「タイプに含まれる仮想メソッドとインターフェースの数」という質問に対する答えを決定します。 この構造には、通常のメソッド、フィールド、プロパティ（メソッドを結合する）に関する情報はなく、**はリフレクション**に関連付けられていません。 その本質と目的により、この構造は、CLRでのメソッド呼び出しの操作のために作成されました（実際、すべてのOOPで、Java、C ++、Rubyなどです。フィールドの場所だけが少し異なります）。 コードを見てみましょう：

  public class Sample { public int _x; public void ChangeTo(int newValue) { _x = newValue; } public virtual GetValue() { return _x; } } public class OverridedSample : Sample { public override GetValue() { return 666; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これらのクラスが無意味に見えても、VMTを記述するのに非常に適しています。 このために、基本型と、質問で継承された `ChangeTo`メソッドと` GetValue`メソッドの違いを理解する必要があります。



`ChangeTo`メソッドは両方のタイプに存在します：再定義できません。 つまり、次のように書き換えることができます。

 public class Sample { public int _x; public static void ChangeTo(Sample self, int newValue) { self._x = newValue; } // ... } //        struct public struct Sample { public int _x; public static void ChangeTo(ref Sample self, int newValue) { self._x = newValue; } // ... }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

同時に、アーキテクチャ上の意味を除けば、何も変わりません。両方のオプションをコンパイルしても同じように機能することを信じてください。 インスタンスメソッドの場合、 `this`は暗黙的に渡されるメソッドの最初のパラメーターにすぎません。

継承に関するすべての説明が静的メソッドの例に基づいて構築されている理由を事前に説明します。実際、すべてのメソッドは静的です。 インスタンスではなく。 メモリ内のクラスの各インスタンスにコンパイルされたメソッドのインスタンスはありません。 これは大量のメモリを消費します。同じメソッドが、それが機能する構造体またはクラスのインスタンスへのリンクを渡す方が簡単です。

GetValueメソッドの場合、状況はまったく異なります。 継承された型の* static * `GetValue`をオーバーライドしてメソッドを取得および再定義することはできません。変数で動作するコードの部分である` OverridedSample`のみが新しいメソッドを受け取ります。オブジェクトが実際にどの型であるかわからないため、ベース型の「GetValue」のみを呼び出すことができます。 変数がどの型であり、その結果、どの特定のメソッドが呼び出されるかを理解するために、次のことができます。

 void Main() { var sample = new Sample(); var overrided = new OverridedSample(); Console.WriteLine(sample.Virtuals[Sample.GetValuePosition].DynamicInvoke(sample)); Console.WriteLine(overrided.Virtuals[Sample.GetValuePosition].DynamicInvoke(sample)); } public class Sample { public const int GetValuePosition = 0; public Delegate[] Virtuals; public int _x; public Sample() { Virtuals = new Delegate[1] { new Func<Sample, int>(GetValue) }; } public static void ChangeTo(Sample self, int newValue) { self._x = newValue; } public static int GetValue(Sample self) { return self._x; } } public class OverridedSample : Sample { public OverridedSample() : base() { Virtuals[0] = new Func<Sample, int>(GetValue); } public static new int GetValue(Sample self) { return 666; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この例では、実際に仮想メソッドのテーブルを手動で作成し、このテーブル内のメソッドの位置で呼び出しを行います。 例の本質を理解すれば、コンパイルされたコードレベルで継承がどのように構築されるかを実際に理解できます。メソッドは、仮想メソッドテーブルのインデックスで呼び出されます。 , . VMT , , : , . , .

• CLR Book: GitHub
• 0.5.0 , PDF: GitHub Release