Немного безопасности.
Как упоминалось в комментариях к первому решению, вложенные массивы можно перемещать, поэтому их также следует закреплять.
unsafe
{
double[][] array = new double[3][];
array[0] = new double[] { 1.25, 2.28, 3, 4 };
array[1] = new double[] { 5, 6.24, 7.42, 8 };
array[2] = new double[] { 9, 10.15, 11, 12.14 };
GCHandle[] pinnedArray = new GCHandle[array.Length];
double*[] ptrArray = new double*[array.Length];
for (int i = 0; i < array.Length; i++)
{
pinnedArray[i] = GCHandle.Alloc(array[i], GCHandleType.Pinned);
}
for (int i = 0; i < array.Length; ++i)
{
// as you can see, this pointer will point to the first element of each array
ptrArray[i] = (double*)pinnedArray[i].AddrOfPinnedObject();
}
// here is your double**
fixed(double** doublePtr = &ptrArray[0])
{
Console.WriteLine(**doublePtr);
}
// unpin all the pinned objects,
// otherwise they will live in memory till assembly unloading
// even if they will went out of scope
for (int i = 0; i < pinnedArray.Length; ++i)
pinnedArray[i].Free();
}
Краткое объяснение проблемы:
Когда мы размещаем некоторые объекты в куче, они могут быть перемещены в другое место при сборе мусора. Итак, представьте себе следующую ситуацию: вы выделили некоторый объект и ваши внутренние массивы, все они помещены в кучу с нулевым поколением.
Теперь какой-то объект вышел из области видимости и стал мусором, некоторые объекты просто были выделены. Сборщик мусора будет перемещать старые объекты из кучи и перемещать другие объекты ближе к началу или даже к следующему поколению, сжимая кучу. Результат будет выглядеть так:
Итак, наша цель - «закрепить» некоторые объекты в куче, чтобы они не двигались.
Что нам нужно для достижения этой цели? У нас есть фиксированный оператор и GCHandle.Allocate метод.
Во-первых, что делает GCHandle.Allocate? Он создает новую запись во внутренней системной таблице, имеющую ссылку на объект, который передается методу в качестве параметра. Поэтому, когда сборщик мусора проверит кучу, он проверит записи во внутренней таблице и, если найдет их, пометит объект как живой и не удалит его из кучи. Затем он рассмотрит, как этот объект закреплен, и не будет перемещать объект в памяти на этапе сжатия. Оператор fixed делает почти то же самое, за исключением того, что он автоматически «открепляет» объект при выходе из области видимости.
Подводя итог: каждый объект, который был прикреплен с помощью fixed, будет автоматически «откреплен», как только он покинет область. В нашем случае это будет следующая итерация цикла.
Как проверить, что ваши объекты не будут перемещаться или собирать мусор: просто используйте весь бюджет кучи для генерации нуля и заставьте GC сжать кучу. Другими словами: создайте много объектов в куче. И делайте это после того, как вы закрепили свои объекты или «починили» их.
for(int i = 0; i < 1000000; ++i)
{
MemoryStream stream = new MemoryStream(10);
//make sure that JIT will not optimize anything, make some work
stream.Write(new Byte[]{1,2,3}, 1, 2);
}
GC.Collect();
Небольшое уведомление: есть два типа кучи - для больших объектов и для маленьких. Если ваш объект большой, вы должны создать большие объекты для проверки вашего кода, иначе маленькие объекты не заставят GC начать сборку мусора и сжатие.
И наконец, вот пример кода, демонстрирующий опасность доступа к базовым массивам с помощью закрепленных / нефиксированных указателей - для всех, кому это интересно.
namespace DangerousNamespace
{
// WARNING!
// This code includes possible memory access errors with unfixed/unpinned pointers!
public class DangerousClass
{
public static void Main()
{
unsafe
{
double[][] array = new double[3][];
array[0] = new double[] { 1.25, 2.28, 3, 4 };
array[1] = new double[] { 5, 6.24, 7.42, 8 };
array[2] = new double[] { 9, 10.15, 11, 12.14 };
fixed (double* junk = &array[0][0])
{
double*[] arrayofptr = new double*[array.Length];
for (int i = 0; i < array.Length; i++)
fixed (double* ptr = &array[i][0])
{
arrayofptr[i] = ptr;
}
for (int i = 0; i < 10000000; ++i)
{
Object z = new Object();
}
GC.Collect();
fixed (double** ptrptr = &arrayofptr[0])
{
for (int i = 0; i < 1000000; ++i)
{
using (MemoryStream z = new MemoryStream(200))
{
z.Write(new byte[] { 1, 2, 3 }, 1, 2);
}
}
GC.Collect();
// should print 1.25
Console.WriteLine(*(double*)(*(double**)ptrptr));
}
}
}
}
}
}