Ограничен ли размер массива верхним пределом int (2147483647)?

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

Как упоминалось в этой статье, есть 2 Предел ГБ для любого объекта в .Net. Для всех x86, x64 и IA64.

Как и в 32-битных операционных системах Windows, существует ограничение в 2 ГБ на размер объекта, который вы можете создать при запуске 64-битного управляемого приложения в 64-битной операционной системе Windows.

Кроме того, если вы определите в стеке слишком большой массив, произойдет переполнение стека. Если вы определите массив в куче, он попытается разместить все в одном большом непрерывном блоке. Было бы лучше использовать ArrayList с неявным динамическим распределением в куче. Это не позволит вам преодолеть 2 ГБ, но, вероятно, позволит вам приблизиться к ним.

Я думаю, что ограничение на размер стека будет больше, только если вы используете архитектуру и операционную систему x64 или IA64. При использовании x64 или IA64 у вас будет 64-разрядная выделяемая память вместо 32-разрядной.

Если вы не можете выделить список массивов сразу, вы, вероятно, можете выделить его по частям.

Используя список массивов и добавляя по одному объекту за раз на машине x64 Windows 2008 с 6 ГБ ОЗУ, максимум, что я могу получить для ArrayList, - это размер: 134217728. Поэтому я действительно думаю, что вам нужно найти лучшее решение своей проблемы, которое не использует столько памяти. Возможно, запись в файл вместо использования ОЗУ.

Ограничение массива, afaik, фиксировано как int32 даже в 64-битной версии. Существует ограничение на максимальный размер одного объекта. Тем не менее, у вас довольно легко может быть хороший большой массив с зазубринами.

Худший; поскольку ссылки больше в x64, для массивов типа ref вы фактически получаете меньше элементов в одном массиве.

См. здесь:

Я получил ряд запросов о том, почему 64-разрядная версия среды выполнения 2.0 .Net по-прежнему имеет максимальный размер массива, ограниченный 2 ГБ. Учитывая, что в последнее время это кажется актуальной темой, я придумал небольшую предысторию и обсуждение возможностей обойти это ограничение было целесообразным.

Сначала немного предыстории; в версии 2.0 среды выполнения .Net (CLR) мы приняли сознательное дизайнерское решение сохранить максимальный размер объекта, разрешенный в куче сборщика мусора, равным 2 ГБ, даже в 64-разрядной версии среды выполнения. Это то же самое, что и текущая реализация 32-разрядной среды CLR 1.1, однако вам будет сложно фактически выделить объект размером 2 ГБ в 32-разрядной среде CLR, потому что виртуальное адресное пространство просто слишком фрагментировано, чтобы реально найти 2 ГБ отверстие. Обычно люди не особо озабочены созданием типов, размер которых при создании экземпляров будет> 2 ГБ (или где-то рядом), однако, поскольку массивы - это просто особый вид управляемого типа, который создается в управляемой куче, они также страдают от этого ограничения.

Следует отметить, что в .NET 4.5 ограничение размера памяти необязательно снимается с помощью gcAllowVeryLargeObjects, однако это не меняет максимальный размер измерения. Ключевым моментом является то, что если у вас есть массивы нестандартного типа или многомерные массивы, то теперь вы можете выйти за пределы 2 ГБ памяти.

Вам вообще не нужен такой большой массив.

Когда ваш метод сталкивается с проблемами ресурсов, не просто смотрите на то, как расширить ресурсы, посмотрите также на метод. :)

Вот класс, который использует буфер размером 3 МБ для вычисления простых чисел с помощью сита Эратосфена. Класс отслеживает, насколько вы вычислили простые числа, и когда диапазон необходимо расширить, он создает буфер для проверки еще 3 миллионов чисел.

Он сохраняет найденные простые числа в списке, и когда диапазон расширяется, предыдущие простые числа используются для исключения чисел в буфере.

Я провел небольшое тестирование, и буфер около 3 МБ наиболее эффективен.

public class Primes {

   private const int _blockSize = 3000000;

   private List<long> _primes;
   private long _next;

   public Primes() {
      _primes = new List<long>() { 2, 3, 5, 7, 11, 13, 17, 19 };
      _next = 23;
   }

   private void Expand() {
      bool[] sieve = new bool[_blockSize];
      foreach (long prime in _primes) {
         for (long i = ((_next + prime - 1L) / prime) * prime - _next;
            i < _blockSize; i += prime) {
            sieve[i] = true;
         }
      }
      for (int i = 0; i < _blockSize; i++) {
         if (!sieve[i]) {
            _primes.Add(_next);
            for (long j = i + _next; j < _blockSize; j += _next) {
               sieve[j] = true;
            }
         }
         _next++;
      }
   }

   public long this[int index] {
      get {
         if (index < 0) throw new IndexOutOfRangeException();
         while (index >= _primes.Count) {
            Expand();
         }
         return _primes[index];
      }
   }

   public bool IsPrime(long number) {
      while (_primes[_primes.Count - 1] < number) {
         Expand();
      }
      return _primes.BinarySearch(number) >= 0;
   }

}

Я считаю, что даже в 64-битной среде CLR существует ограничение в 2 ГБ (или, возможно, 1 ГБ - я точно не могу вспомнить) на объект. Это помешает вам создать массив большего размера. Тот факт, что Array.CreateInstance принимает только аргументы Int32 для размеров, тоже наводит на размышления.

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

Я новичок в C # (т.е. изучаю его на этой неделе), поэтому я не уверен в точных деталях того, как реализован ArrayList. Однако я предполагаю, что, поскольку вы не определили тип для примера ArrayList, тогда массив будет выделен как массив ссылок на объекты. Это вполне может означать, что вы фактически выделяете 4-8 ГБ памяти в зависимости от архитектуры.

Согласно MSDN индекс для массива байтов не может быть больше чем 2147483591. Для .NET до 4.5 это также был предел памяти для массива. В .NET 4.5 этот максимум такой же, но для других типов он может достигать 2146435071.

Это код для иллюстрации:

    static void Main(string[] args)
    {
        // -----------------------------------------------
        // Pre .NET 4.5 or gcAllowVeryLargeObjects unset
        const int twoGig = 2147483591; // magic number from .NET

        var type = typeof(int);          // type to use
        var size = Marshal.SizeOf(type); // type size
        var num = twoGig / size;         // max element count

        var arr20 = Array.CreateInstance(type, num);
        var arr21 = new byte[num];

        // -----------------------------------------------
        // .NET 4.5 with x64 and gcAllowVeryLargeObjects set
        var arr451 = new byte[2147483591];
        var arr452 = Array.CreateInstance(typeof(int), 2146435071);
        var arr453 = new byte[2146435071]; // another magic number

        return;
    }