Помощь с умножением ассемблера/SSE

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

Кроме того, невозможно перемещать данные между SSE и FPU/ALU без использования записи в RAM с последующим чтением. Современные чипы IA32 хорошо справляются с этим конкретным шаблоном (запись, затем чтение), но все же будут делать недействительным некоторый кэш, что будет иметь эффект удара.

Чтобы получить максимальную отдачу от SSE, вам нужно взглянуть на весь алгоритм и данные, которые он использует. Значения a, b, c и d, а также e, f, g и h должны постоянно находиться в этих массивах, чтобы данные не перемещались в памяти до загрузки регистров SSE. Это не просто и может потребовать значительной переработки вашего кода и данных (возможно, вам придется по-другому хранить данные на диске).

Также стоит отметить, что SSE только 32-битный (или 64-битный, если вы используете удвоения), тогда как FPU — 80-битный (независимо от float или double), поэтому вы получите немного разные результаты при использовании SSE по сравнению с использованием FPU. Только вы знаете, будет ли это проблемой.

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

Вы можете включить использование SSE и SSE2 в параметрах программы в более новых версиях VS и, возможно, в 2005 году. Компилировать с использованием экспресс-версии?

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

Кроме того, вам пришлось бы выполнять ОГРОМНЫЙ объем работы для SSE/2, чтобы получить заметную выгоду.

Это старая тема, но я заметил ошибку в вашем примере. Если вы хотите выполнить это:

float x = a*b;
float y = c*d;
float z = e*f;
float w = g*h;

Тогда код должен быть таким:

Vector4 aceg, bdfh, result;  // xyzw
abcd = [float a, float c, float e, float g];
efgh = [float b, float d, float f, float h];
_asm {
movups xmm1, abcd
movups xmm2, efgh
mulps xmm1, xmm2
movups result, xmm1
}

И чтобы получить еще больше скорости, я бы посоветовал вам не использовать отдельный регистр для «результата».

Во-первых, не все алгоритмы выиграют от перезаписи на SSE. Алгоритмы, управляемые данными (например, алгоритмы, управляемые таблицами поиска) плохо переводятся в SSE, потому что много времени тратится на упаковку и распаковку данных в векторы для работы SSE.

Надеюсь, это все еще помогает.

Во-первых, когда у вас есть что-то 128-битное (16-байтовое) выровненное, вы должны использовать MOVAPS, так как это может быть намного быстрее. Компилятор обычно должен давать выравнивание по 16 байт даже в 32-битных системах.

Ваши строки C/C++ не делают то же самое, что и ваш код sse.

Четыре числа с плавающей запятой в одном регистре xmm умножаются на четыре числа с плавающей запятой в другом регистре. Предоставление вам:

float x = a*e;
float y = b*f;
float z = c*g;
float w = d*h;

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

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