Что самый быстрый путь состоит в том, чтобы Инициализировать многомерный массив к значениям не по умолчанию в.NET?

Как я инициализирую многомерный массив типа примитива максимально быстро?

Я застреваю с использованием многомерных массивов. Моей проблемой является производительность. Следующая стандартная программа инициализирует 100x100 массив приблизительно в 500 галочках. Удаление интервала. Инициализация MaxValue приводит приблизительно к 180 галочкам только для цикличного выполнения. Приблизительно 100 галочек для создания массива без цикличного выполнения и не инициализируя к интервалу. MaxValue.

• Стандартные программы, подобные этому, называют несколькими сотнями тысяч к нескольким миллионам раз во время "выполнения".
• Размер массива не изменится во время выполнения, и массивы создаются по одному, используются, затем отбрасываются, и новый созданный массив.
• "Выполнение", которое может продлиться с одной минуты (использующий 10x10 массивы) к сорока пяти минутам (100x100).
• Приложение создает массивы интервала, bool, и структуру.
• Может быть несколько "выполнений", выполняющихся в то же время, но - не потому что производительность ухудшается ужасно.
• Я использую 100x100 в качестве базовой линии.

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

    public int[,] CreateArray(Size size) {
        int[,] array = new int[size.Width, size.Height];
        for (int x = 0; x < size.Width; x++) {
            for (int y = 0; y < size.Height; y++) {
                array[x, y] = int.MaxValue;
            }
        }
        return array;
    }

Вниз к 450 галочкам со следующим:

    public int[,] CreateArray1(Size size) {
        int iX = size.Width;
        int iY = size.Height;
        int[,] array = new int[iX, iY];
        for (int x = 0; x < iX; x++) {
            for (int y = 0; y < iY; y++) {
                array[x, y] = int.MaxValue;
            }
        }
        return array;
    }

CreateArray5; Принятая Реализация: Ограничение: Не мог Изменить размер, может быть изменен

Вниз приблизительно к 165 галочкам после одноразовой инициализации 2 800 галочек. (См. мой ответ ниже.), Если я могу добраться stackalloc для работы с многомерными массивами я должен смочь получить ту же производительность, не имея необходимость инициализировать private static массив.

    private static bool _arrayInitialized5;
    private static int[,] _array5;

    public static int[,] CreateArray5(Size size) {
        if (!_arrayInitialized5) {
            int iX = size.Width;
            int iY = size.Height;
            _array5 = new int[iX, iY];
            for (int x = 0; x < iX; x++) {
                for (int y = 0; y < iY; y++) {
                    _array5[x, y] = int.MaxValue;
                }
            }
            _arrayInitialized5 = true;
        }
        return (int[,])_array5.Clone();
    }

CreateArray8; принятый Implemention; ограничение: требует полного доверия

Вниз приблизительно к 165 галочкам, не используя "метод клона" выше. (См. мой ответ ниже.) Я уверен, что могу получить галочки ниже, если я могу просто выяснить возврат CreateArray9.

    public unsafe static int[,] CreateArray8(Size size) {
        int iX = size.Width;
        int iY = size.Height;
        int[,] array = new int[iX, iY];
        fixed (int* pfixed = array) {
            int count = array.Length;
            for (int* p = pfixed; count-- > 0; p++)
                *p = int.MaxValue;
        }
        return array;
    }

Примечания

Я предоставляю весь код и примечания относительно этого вопроса как ответы. Хотелось бы надеяться, это сэкономит чье-то время в будущем.

Массивы, выделенные на "Куче" для больших объектов (LOH), не являются частью этого обсуждения. Отмеченные повышения производительности слышат, только для массивов, выделенных на "куче".

Stackalloc

Моя идея использовать stackalloc устранить массив инициализации к значениям по умолчанию не удалось, потому что выделенная стековая память должна быть скопирована из метода. Значение, я должен был бы создать другой массив для содержания результатов. Этот массив был бы инициализирован, победив целую цель использовать stackalloc.

CreateArray8; небезопасный/фиксированный метод

CLR только выполнится unsafe кодируйте, если это находится в полностью доверяемом блоке.

CreateArray5; метод клона

Требует, чтобы переменные определили, инициализируется ли массив и сохранить инициализированный массив. Производительность совпадает с небезопасным/фиксированным методом после инициализации. См. ответ Dan Tao для возможного решения.

300%-е увеличение производительности?

Я сосу на уровне процентов, но 300% - то, что я изобразил (от 500 до 165 галочек).

Заключительная реализация для приложения

Для этого приложения я обосновался на использовании метода "клона". Следующее является "минимизированной" Универсальной реализацией, используемой в приложении с образцами производительности.

Инициализация:

• Grid<int>; универсальный класс клона initalize: 4348, 4336, 4339, 4654
• Grid<bool>; универсальный класс клона initalize: 2692, 2684, 3916, 2680
• Grid<Color>; универсальный класс клона initalize: 3747, 4630, 2702, 2708

Использование:

• Grid<int>; универсальный класс клона: 185, 159, 152, 290
• Grid<bool>; универсальный класс клона: 39, 36, 44, 46

• Grid<Color>; универсальный класс клона: 2229, 2431, 2460, 2496

  public class Grid<T> {
      private T[,] _array;
      private T _value;
      private bool _initialized;
      private int _x;
      private int _y;
      public Grid(Size size, T value, bool initialize) {
          _x = size.Width;
          _y = size.Height;
          _value = value;
          if (initialize) {
              InitializeArray();
          }
      }
      private void InitializeArray() {
          int iX = _x;
          int iY = _y;
          _array = new T[iX, iY];
          for (int y = 0; y < iY; y++) {
              for (int x = 0; x < iX; x++) {
                  _array[x, y] = _value;
              }
          }
          _initialized = true;
      }
      public T[,] CreateArray() {
          if (!_initialized) {
              InitializeArray();
          }
          return (T[,])_array.Clone();
      }
  }