Является ли индексирование векторов в MATLAB неэффективным?

Я могу, конечно, только спекулировать. Однако, когда я запускаю ваш тест с включенным компилятором JIT и отключен, я получаю следующие результаты:

 % with JIT   no JIT
    0.1677    0.0011 %# init
    0.0974    0.0936 %# #1 I added an assigment before this line to avoid issues with deferring
    0.4005    0.4028 %# #2
    0.4047    0.4005 %# #3
    1.1160    1.1180 %# #4
    0.8221   48.3239 %# #5 This is where "don't use loops in Matlab" comes from 
    0.3232   48.2197 %# #6
    0.5464   %# logical indexing

Разделение показывает нам, где есть увеличение скорости:

% withoutJit./withJit
    0.0067 %# w/o JIT, the memory allocation is deferred
    0.9614 %# no JIT
    1.0057 %# no JIT
    0.9897 %# no JIT
    1.0018 %# no JIT
   58.7792 %# numel
  149.2010 %# no numel

Очевидная ускоренная инициализация происходит, поскольку при выключении JIT появляется сообщение о том, что MATLAB задерживает выделение памяти до тех пор, пока оно не будет использовано, поэтому x = нули (...) ничего не делают. (спасибо, @angainor).

Методы с 1 по 4, похоже, не полезны JIT. Я полагаю, что # 4 может быть медленным из-за дополнительного тестирования входных данных в subsref, чтобы убедиться, что вход имеет правильную форму.

Результат numel может иметь какое-то отношение к тому, что сложнее компилятор справиться с неопределенным количеством итераций или с некоторыми накладными расходами из-за проверки того, соответствует ли граница цикла (считается, что нет-тестов JIT только ~ 0,1 с для этого)

Удивительно, но на R2012b на моей машине логическое индексирование работает медленнее, чем # 4.

Я думаю, что это еще раз показывает, что MathWorks проделали большую работу по ускорению кода и что "не использовать циклы" не всегда лучше, если вы пытаетесь получить самое быстрое время выполнения (по крайней мере, на данный момент). Тем не менее, я считаю, что векторизация в целом является хорошим подходом, поскольку (а) JIT не работает на более сложных циклах, и (b) обучение векторизации позволяет вам лучше понять Matlab.

Заключение. Если вы хотите скорость, используйте профилировщик и перепрофилируйте, если вы переключите версии Matlab.

Для справки я использовал следующую слегка измененную тестовую функцию

function tt = speedTest

tt = zeros(8,1);

tic; x = zeros(1,1e8); tt(1)=toc;

x(:) = 2;

tic; x(:) = 1; tt(2)=toc;
tic; x(1:end) = 2; tt(3)=toc;
tic; x(1:1e8) = 3; tt(4)=toc;

tic;
id = 1:1e8; % colon(1,1e8);
x(id) = 4;
tt(5)=toc;

tic;
for i=1:numel(x)
    x(i) = 5;
end
tt(6)=toc;

tic;
for i=1:1e8
    x(i) = 6;
end
tt(7)=toc;

%# logical indexing
tic;
id = true(1e8,1));
x(id)=7;
tt(8)=toc;

У меня нет ответа на все проблемы, но у меня есть некоторые уточненные предположения о методах 2, 3 и 4.

Относительно методов 2 и 3. Действительно, MATLAB выделяет память для векторных индексов и заполняет ее значениями от 1 до 1e8. Чтобы понять это, давайте посмотрим, что происходит. По умолчанию MATLAB использует double в качестве своего типа данных. Выделение массива индексов принимает то же время, что и выделение x

tic; x = zeros(1e8,1); toc
Elapsed time is 0.260525 seconds.

Теперь массив индексов содержит только нули. Присвоение значения вектору x оптимальным образом, как в методе 1, занимает 0.094316 секунд. Теперь вектор индекса должен считываться из памяти, чтобы его можно было использовать при индексировании. Это дополнительные 0.094316/2 секунды. Напомним, что в x(:)=1 вектор x должен быть как прочитан, так и записан в память. Поэтому только чтение занимает половину времени. Предполагая, что это все, что сделано в x(1:end)=value, общее время методов 2 и 3 должно быть

t = 0.260525+0.094316+0.094316/2 = 0.402

Это почти правильно, но не совсем. Я могу только догадываться, но заполнение индексного вектора значениями, вероятно, выполняется как дополнительный шаг и требует дополнительных 0.094316 секунд. Следовательно, t=0.4963, который более или менее соответствует времени методов 2 и 3.

Это только предположения, но они, похоже, подтверждают, что MATLAB явно создает индексные векторы при естественной векторной индексации. Лично я считаю, что это ошибка производительности. Компилятор MATLABs JIT должен быть достаточно умным, чтобы понять эту тривиальную конструкцию и преобразовать ее в вызов правильной внутренней функции. Как и сейчас, в сегодняшней индексировании индексов ограниченной пропускной способности памяти производительность достигает около 20% теоретического пика.

Итак, если вы заботитесь о производительности, вам нужно реализовать x(1:step:end) как функцию MEX, что-то вроде

set_value(x, 1, step, 1e8, value);

Теперь это явно незаконно в MATLAB, так как вы НЕ ДОПУСКАЕТСЯ для изменения массивов в файлах MEX на месте.

Изменить В отношении метода 4 можно попытаться проанализировать производительность отдельных шагов следующим образом:

tic;
id = 1:1e8; % colon(1,1e8);
toc
tic
x(id) = 4;
toc

Elapsed time is 0.475243 seconds.
Elapsed time is 0.763450 seconds.

Первый шаг, распределение и заполнение значений индексного вектора происходит в то же время, что и методы 2 и 3. Похоже, что это слишком много - для распределения памяти и установления значений (0.260525s+0.094316s = 0.3548s) требуется не более времени, поэтому есть дополнительные накладные расходы 0.12 секунды, которые я не могу понять, Вторая часть (x(id) = 4) выглядит также очень неэффективной: для установки значений x требуется время, чтобы прочитать вектор id (0.094316s+0.094316/2s = 0.1415s) плюс некоторые проверки ошибок на id значения. Программируемый в C, два шага принимают:

create id                              0.214259
x(id) = 4                              0.219768

В коде используется проверка того, что индекс double фактически представляет целое число и что он соответствует размеру x:

tic();
id  = malloc(sizeof(double)*n);
for(i=0; i<n; i++) id[i] = i;
toc("create id");

tic();
for(i=0; i<n; i++) {
  long iid = (long)id[i];
  if(iid>=0 && iid<n && (double)iid==id[i]){
    x[iid] = 4;
  } else break;
}
toc("x(id) = 4");

Второй шаг занимает больше, чем ожидаемый 0.1415s - это связано с необходимостью проверки ошибок на значениях id. Накладные расходы кажутся слишком большими для меня - возможно, это может быть написано лучше. Тем не менее, требуемое время 0.4340s, а не 1.208419s. Что MATLAB делает под капотом - я понятия не имею. Может быть, это нужно сделать, я просто этого не вижу.

Конечно, использование doubles в качестве индексов приводит к двум дополнительным уровням служебных данных:

• размер double в два раза больше uint32. Напомним, что пропускная способность памяти здесь является ограничивающим фактором.
• Для того, чтобы индексировать

Метод 4 может быть записан в MATLAB с использованием целых индексов:

tic;
id = uint32(1):1e8;
toc
tic
x(id) = 8;
toc

Elapsed time is 0.327704 seconds.
Elapsed time is 0.561121 seconds.

Что явно улучшило производительность на 30% и доказывает, что нужно использовать целые числа в качестве векторных индексов. Однако накладные расходы все еще существуют.

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