Ускорение матрицы 5x5 с плавающей запятой * векторное умножение с помощью SSE

Библиотека шаблонов C++ Eigen для векторов, матриц и т. д.

• оптимизированный код для небольших матриц фиксированного размера (а также динамических)

• оптимизированный код, использующий оптимизацию SSE

так что вы должны дать ему попробовать.

В принципе ускорение может быть в 4 раза с SSE (в 8 раз с AVX). Позволь мне объяснить.

Назовем вашу фиксированную матрицу 5x5 M. Определение компонентов 5D-вектора как (x, y, z, w, t). Теперь сформируйте матрицу 5x4 U из первых четырех векторов.

U =
xxxx
yyyy
zzzz
wwww
tttt

Затем сделайте матричное произведение MU = V. Матрица V содержит произведение M и первых четырех векторов. Единственная проблема заключается в том, что для SSE нам нужно читать в строках U, но в памяти U хранится как xyzwtxyzwtxyzwtxyzwt, поэтому мы должны транспонировать его на xxxxyyyyzzzzwwwwtttt. Это можно сделать с помощью перемешивания/смешивания в SSE. Когда у нас есть этот формат, матричный продукт становится очень эффективным.

Вместо того, чтобы выполнять операции O (5x5x4) со скалярным кодом, требуется только операции O (5x5), то есть ускорение в 4 раза. С AVX матрица U будет 5x8, поэтому вместо операций O(5x5x8) она облагает налогом только O(5x5), то есть ускорение в 8 раз.

Однако матрица V будет иметь формат xxxxyyyyzzzzwwwwtttt, поэтому в зависимости от приложения ее может потребоваться преобразовать в формат xyzwtxyzwtxyzwtxyzwt.

Повторите это для следующих четырех векторов (8 для AVX) и так далее, пока не закончите.

Если у вас есть контроль над векторами, например, если ваше приложение генерирует векторы на лету, вы можете генерировать их в формате xxxxyyyyzzzzwwwwtttt и избегать транспонирования массива. В этом случае вы должны получить 4-кратное ускорение с SSE и 8-кратное с AVX. Если вы объедините это с потоковой передачей, например. OpenMP, ваше ускорение должно быть близко к 16x (при условии четырех физических ядер) с SSE. Я думаю, что это лучшее, что вы можете сделать с SSE.

Редактировать: из-за параллелизма на уровне инструкций (ILP) вы можете получить еще один коэффициент ускорения 2, поэтому ускорение для SSE может быть 32-кратным с четырьмя ядрами (64x AVX) и снова еще одним коэффициентом 2 с Haswell из-за FMA3.

Я бы предложил использовать Intel IPP и абстрагироваться от зависимости от методов

Если вы используете GCC, обратите внимание, что параметр -O3 включает автоматическую векторизацию, которая во многих случаях автоматически генерирует инструкции SSE или AVX. В общем, если вы просто напишете это как простой цикл for, GCC векторизует его. См. http://gcc.gnu.org/projects/tree-ssa/vectorization.html для получения дополнительной информации.

Это должно быть легко, особенно когда вы используете Core 2 или более позднюю версию: вам нужно 5* _mm_dp_ps , одно _mm_mul_ps, два _mm_add_ps, одно обычное умножение, а также несколько перетасовок, загрузок и сохранений (и если матрица фиксирована, вы можете сохранить большая часть в регистрах SSE, если они вам больше ни для чего не нужны).

Что касается пропускной способности памяти: мы говорим о 2,4 мегабайтах векторов, когда пропускная способность памяти выражается одноразрядными гигабайтами в секунду.

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

Классический метод оптимизации для обмена памяти на циклы...

Я бы рекомендовал взглянуть на оптимизированную библиотеку BLAS, такую ​​как Intel MKL или AMD ACML. Основываясь на вашем описании, я бы предположил, что вы будете после матрично-векторной процедуры SGEMV уровня 2, чтобы выполнять операции в стиле y = A*x.

Если вы действительно хотите что-то реализовать самостоятельно, использование (доступных) наборов инструкций SSE..SSE4 и AVX может в некоторых случаях значительно повысить производительность, хотя именно это и будет делать хорошая библиотека BLAS. Вам также нужно много думать о шаблонах доступа к данным, дружественных к кэшу.

Я не знаю, применимо ли это в вашем случае, но можете ли вы работать с «кусками» векторов одновременно?? Таким образом, вместо повторного выполнения операции в стиле y = A*x вы можете работать с блоками [y1 y2 ... yn] = A * [x1 x2 ... xn]. Если это так, это означает, что вы можете использовать оптимизированную матричную подпрограмму, такую ​​как SGEMM. Из-за шаблонов доступа к данным это может быть значительно эффективнее повторных вызовов SGEMV. Если бы это был я, я бы попытался пойти по этому пути...

Надеюсь это поможет.

Если вы знаете векторы заранее (например, выполняете все 240 КБ одновременно), вы получите лучшее ускорение, распараллелив цикл, чем переходя к SSE. Если вы уже сделали этот шаг или не знаете их всех сразу, SSE может быть большим преимуществом.

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

5x5 — забавный размер, но вы можете сделать по крайней мере 4 флопа в одной инструкции SSE и попытаться сократить свои арифметические накладные расходы. Вам не нужен компилятор Intel, но он может быть лучше, я слышал легенды о том, что он намного лучше с арифметическим кодом. В Visual Studio есть встроенные средства для работы с SSE2, и я думаю, что до SSE4, в зависимости от того, что вам нужно. Конечно, вам придется качать его самостоятельно. Захват библиотеки может быть разумным ходом здесь.