Отправляем GC в отпуск и создаем эксзепляры классов .NET сами

Придерживаясь великой цитаты «правила созданы для того, чтобы их нарушать», давайте нарушим какие-то основополагающие правила CLR. Как на счет того, чтобы послать GC с его работой в отставку и самим заняться размещением в памяти экземпляров классов? Заодно разберемся, как все это работает где-то там под капотом CLR.

Начнем с того, что мы сразу откинем правило «все экземепляры должны создаваться через ключевое слово new в управляемой куче благодаря GC«. Сначала разберемся, что вообще такое есть экземпляр класса и ссылка.

Когда мы создаем экземпляр через ключевое слово new, мы аллоцируем где-то в куче sizeof(class) + 16 и возвращаем pointer + 8. Теперь остановимся подробнее. То, чем мы оперируем в контексте работы с классом — это всего лишь указатель на некую область памяти. То есть любую ссылку можно представить как IntPtr или void* и смысла она не поменяет. А если любая ссылка это просто указатель, значит мы может откинуть оковы безопасного кода и поработать напрямую с указателями… Насколько это позволяет C#. 

Но для этого, сначала, надо понять, как работает память у классов. Помимо размещения полей класса, CLR так же добавляет для себя еще 16 байт (или 8 для 32bit систем), это так называемый object header и указатель на virtualMethodTable. Первое содержит себе разные данные для правильной работы GC и CLR, а указатель помогает определить, с каким типом мы работаем. Для простоты понимания можно сказать, что это поле отвечает за тип класса, а соответственно, и за его переопределенные методы, и другие ООП вещи.

Размещается он в памяти как…

public unsafe struct UnmanagedClass  {    public ulong objectHeader; -8    public void* methodTable; 0 < сюда будет указывать наш указатель  // Далее уже идут наши поля    public int value0; 8    public ulong value1; 12 }

…аналогичная структура. Почему objectHeader находится по адресу -8? Зачем так сделано? Хз. Даже майкрософт говорили, что просто так исторически сложилось и никакого скрытого смысла здесь нет. 

Значит теперь мы можем представлять классы в виде структур и работать с указателями? Верно.

Попробуем…

public class TestClass {    public int value0;    public ulong value1;    public string value2; }  // Будет равно public struct UnmanagedTestClass {    public void* methodTable;    public int value0;    public ulong value1;    public void* value2; // Все managed поля должны быть unmanaged.    // Либо создаем свой вариант строки в виде структуры с таким же расположением полей.    // Либо забиваем и используем void* или IntPtr. Я выбрал этот вариант <3 }

… и теперь если мы сделаем…

public static void Test() {    var instance = new TestClass();      var pInstance = *(UnmanagedTestClass**)Unsafe.AsPointer(ref instance); }

…мы получим указатель на наш класс. Почему *(UnmanagedTestClass**) — объясняю, мы взяли указатель на переменную на стеке, которая, как я говорил, является указателем на экземпляр класса. Соответственно, это указатель на указатель, поэтому его надо разыменовать.

Поздравляю. Уже на этом этапе мы послали на 3 буквы очень много правил безопасности C# и CLR, продолжаем. Теперь нам надо избавится от ключевого слова new. Если мы загуглим, как это сделать, то получим ответ в духе «нельзя так делать, нужно только new и бла-бла-бла», но мы сделаем.

Мы уже разобрались, как в памяти располагается экземпляр, теперь мы можем его воссоздать.

Для этого нам надо где-то аллоцировать память. Для этого можно использовать 3 варианта:

1. Использовать malloc();

2. Использовать stackalloc;

3. Использовать кастомный аллокатор.

Первый и второй вариант самые простые, которое готовы прямо из коробки, поэтому будем использовать их. Первый и третий вариант схожи по своей сути и я настоятельно рекомендую использовать 3й.

Что же нам надо сделать? Аллоцировать память sizeof(class) + 16. Заполнить первые 8 байт нулями, вторые 8 байт заполнить указателем на virtualMethodTable, записать указатель на эту область память в переменную на стеке… И все.

Теперь попробуем это сделать и аллоцируем экземпляр на стеке…

public static void Test()   {      var memory = stackalloc ulong[8]; // Аллоцируем память на стеке 64 байта. Взято с запасом      Unsafe.InitBlock(memory, 0, 8 * 8); // Очищаем память, ибо она грязная      TestClass res = null; // Создаем на стеке переменную под ссылку на экземпляр    var pRes = (ulong**)Unsafe.AsPointer(ref res); // Получаем указатель на переменную на стеке      *memory = 0x0; // Заполняем первые 8 байт нулями, ибо это заголовок, а он нам не нужен    *++memory = (ulong)typeof(TestClass).TypeHandle.Value.ToPointer(); // Заполняем вторые 8 байт указателем на метод таблицу      // В вашем случае вместо TestClass должен быть указан ваш класс    *pRes = memory; // Передаем указатель на память в переменную      // Теперь переменную res можно использовать в этой функции.    // Как толкьо мы выйдем из функции, ссылка станет невалидной и ее использование недопустимо }

…и мы получим работоспособный экземпляр. Для получения точного размера класса нам нужно немного напрячься и написать структуру VirtualMethodTable, выглядит она так…

[StructLayout(LayoutKind.Explicit)] public struct VirtualMethodTable {     [FieldOffset(0)] public uint flags;     [FieldOffset(4)] public uint size; // Отсюда нам надо только это поле, остальные можно игнорировать     [FieldOffset(8)] public uint flags2;     [FieldOffset(12)] public ushort numVirtuals;      [FieldOffset(14)] public ushort numInterfaces;     [FieldOffset(16)] public void* pParentMethodTable;     [FieldOffset(24)] public void* pModule;     [FieldOffset(32)] public void* pAuxiliaryData;     // Эти два поля находятся по одному и тому же адресу     [FieldOffset(40)] public void* pPerInstInfo;     [FieldOffset(40)] public void* pElementTypeHnd;     [FieldOffset(48)] public void* pInterfaceMap; }

…в поле size будет выравненный размер класса в байтах.

В примере указан вариант со аллокацией на стеке, но его можно заменить на malloc() или Marshal.AllocHGlobal(). В таком случае надо не забыть потом вызвать Free() для указателя. Однако для глобальной аллокации намного лучше использовать кастомные аллокаторы с кэшем памяти по причинам, как я и говорил выше.

Если напрячься и сделать для всего этого API, то выйдет нечто такое:

public static void Main()   {      var size = (int)((VirtualMethodTable*)typeof(TestClass).TypeHandle.Value)->size + 16; // Вычисляем размер класса    var buffer = stackalloc byte[size]; // Аллоцируем память для класса на стеке    Unsafe.InitBlock(buffer, 0, (uint)size); // Очищаем память, ибо она грязная      TestClass res = null; // Резервуем на стеке переменную под ссылку      UnsafeInitializeInstance<TestClass>((ulong*)buffer, (void**)Unsafe.AsPointer(ref res)); // Передаем указатель на память и указатель на переменную      Console.WriteLine(res.GetType());      var res2 = UnsafeAllocateInstance<TestClass>();      Console.WriteLine(res2.GetType());   }      public static T UnsafeAllocateInstance<T>()   {    var size = (int)((VirtualMethodTable*)typeof(TestClass).TypeHandle.Value)->size + 16; // Вычисляем размер класса      var buffer = Marshal.AllocHGlobal(size  ).ToPointer(); // Аллоцируем память для класса. Взято с запасом      Unsafe.InitBlock(buffer, 0, (uint)size  ); // Очищаем память, ибо она грязная      T res = default; // Резервуем на стеке переменную под ссылку      UnsafeInitializeInstance<T>((ulong*)buffer, (void**)Unsafe.AsPointer(ref res)); // Передаем указатель на память и указатель на переменную      return res; // Возвращаем переменную   }      public static void UnsafeInitializeInstance<T>(ulong* ptr, void** stackPointer)   {      *ptr = 0x0; // Заполняем первые 8 байт нулями, ибо это заголовок      *++ptr = (ulong)typeof(T).TypeHandle.Value.ToPointer(); // Заполняем вторые 8 байт указателем на метод таблицу      *stackPointer = ptr; // Передаем указатель на память в переменную   }

Поздравляю, вы нарушили так много правил безопасности в C#, что заслужили пинок под зад от Хайльсберга. Этот код ходит по грани UB и строго не рекомендуется к использовании без веских причин, ибо малейшая ошибка или изменение могут поломать всю логику и вызвать «Segmentation fault», а так же понос и выпадение волос.

Однако теперь вы знаете, что происходит за невинным словом `new` (спойлер: это даже не половина того, что происходит, в CLR эта часть написана на ассемблере и там еще много логики для выравнивания и оптимизации) и почему структуры намного предпочтительнее классов в случаях, когда их использование возможно. Спасибо за внимание.

P.S. Если правильно организовать управление памятью, такой способ аллокации экземпляров может быть на ~20% быстрее, чем через new :D. Не говоря уж о том, что это снимает нагрузку с GC и дает на контроль над тем, сколько будет жить объект и возможность его переиспользовать под те же, или даже другие цели.