Про MMX, SSE и оптимизацию

Вводная

Продолжаю делать H264 декодер. Надо соответственно сделать обратное преобразование блока 8х8 коэффициентов в 8х8 кусок плоскости (можно назвать это IDCT, но это будет не совсем правда, потому что там от косинусов осталось мало, а получилось что-то вроде Адамара, но не в этом суть). В спецификации H264 вся эта хрень осуществляется за 6 шагов (ну или за 7, как считать, может даже и за 8, для нашего текущего разговора это опять же не важно). Решил, что это хороший повод освежить свои навыки работы с ММХ и SSE.

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

Дома у меня тогда стояла MSVS 2003 Standard. а Standard он очень хороший, только вот опции оптимизации компилятора в свойствах проекта он включить не дает (ну или я как обычно где-то, чего-то не нашел). Но я чего-то про это не особо задумывался. Соответственно, набросал кусок кода на С++, потом сделал код с той же функциональностью под SSE, сравнил скорость, и возрадовался. Разница была где-то раз в десять (естественно в пользу SSE). Правда радовался я до момента пока не скомпилил тот же тест на работе, где стояла MSVS 2003 Prof. Оказалось, что компилятор оптимизирует так же хорошо, как и я. Только у меня процесс оптимизации занимает два часа, а у него пару секунд. Но там задачка изначально, плохо ложилась на SSE, так что эксперимент был не слишком чистым.

Возвращаясь к H264. Здесь все очень красиво, преобразования с матрицей 8x8 (в матрице элементы типа short) плюс первые три шага используют только сложение вычитание строк этих матриц, как векторов. В общем, если не распробовать эти MMX с SSE здесь, то уж не понятно, где их и пробовать.

Формулировка задачи

Разбираться со всеми шагами сразу есть смысл только, если пишешь декодер, а для поиграться с MMX и SSE достаточно разобрать один шаг.

Итак, на входе матрица

short arBufferSrc[8][8];

Мы эту матрицу преобразуем, результат помещаем в новую память (можно собственно и на месте крутить, но оно только усложняет код, а мне этого на данном этапе не хотелось бы). На С++ это выглядит так:

показать код

short arBufferSrc[64];
short arBufferCPPDst[64];
short *pBufferSrc = arBufferSrc;
short *pBufferCPPDst = arBufferCPPDst; memset(pBufferCPPDst, 0, 64);
for (int i=0;i<8;i++)
{
    pBufferCPPDst[0 * 8 + i] =  pBufferSrc[0 * 8 + i] + pBufferSrc[4 * 8 + i];
    pBufferCPPDst[1 * 8 + i] = -pBufferSrc[3 * 8 + i] + pBufferSrc[5 * 8 + i] 
                               -pBufferSrc[7 * 8 + i] - (pBufferSrc[7 * 8 + i]>>1);
    pBufferCPPDst[2 * 8 + i] =  pBufferSrc[0 * 8 + i] - pBufferSrc[4 * 8 + i];
    pBufferCPPDst[3 * 8 + i] =  pBufferSrc[1 * 8 + i] + pBufferSrc[7 * 8 + i] 
                               -pBufferSrc[3 * 8 + i] - (pBufferSrc[3 * 8 + i]>>1);
    pBufferCPPDst[4 * 8 + i] =  (pBufferSrc[2 * 8 + i]>>1) - pBufferSrc[6 * 8 + i];     
    pBufferCPPDst[5 * 8 + i] = -pBufferSrc[1 * 8 + i] + pBufferSrc[7 * 8 + i] + 
                                pBufferSrc[5 * 8 + i] + (pBufferSrc[5 * 8 + i]>>1);
    pBufferCPPDst[6 * 8 + i] =  pBufferSrc[2 * 8 + i] + (pBufferSrc[6 * 8 + i]>>1);     
    pBufferCPPDst[7 * 8 + i] =  pBufferSrc[3 * 8 + i] + pBufferSrc[5 * 8 + i] + 
                                pBufferSrc[1 * 8 + i] + (pBufferSrc[1 * 8 + i]>>1);
}

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

Все работает, код нам потом пригодится проверять результаты работы MMX-шного и SSE-шного вариантов

Оптимизация с использованием MMX

Принцип оптимизации простой. Если в исходном коде мы работали с одним столбцом за раз, то, используя MMX регистры, мы можем обработать сразу 4 столбца. Выглядит это примерно так:

показать код

short arBufferSrc[64];
short arBufferMMXDst[64];

short *pBufferSrc = arBufferSrc;
short *pBufferMMXDst = arBufferMMXDst; memset(pBufferMMXDst, 0, 64);

__asm
{
    mov  eax, pBufferSrc
    mov  ecx, pBufferMMXDst
    mov  edx, 2
$loop:   
    movq mm0, qword ptr [eax]
    movq mm1, qword ptr [eax + 4*16]
    paddsw  mm0, mm1
    movq qword ptr [ecx], mm0
    
    movq mm0, qword ptr [eax]
    movq mm1, qword ptr [eax + 4*16]
    psubsw  mm0, mm1
    movq qword ptr [ecx + 2*16], mm0
    
    movq mm0, qword ptr [eax + 3*16]
    movq mm1, qword ptr [eax + 5*16]
    movq mm2, qword ptr [eax + 7*16]
    psubsw  mm1, mm0
    psubsw  mm1, mm2
    psraw   mm2, 1
    psubsw  mm1, mm2
    movq qword ptr [ecx + 1*16], mm1
    
    movq mm0, qword ptr [eax + 1*16]
    movq mm1, qword ptr [eax + 3*16]
    movq mm2, qword ptr [eax + 7*16]
    paddsw  mm0, mm2
    psubsw  mm0, mm1
    psraw   mm1, 1
    psubsw  mm0, mm1
    movq qword ptr [ecx + 3*16], mm0
    
    movq mm0, qword ptr [eax + 2*16]
    movq mm1, qword ptr [eax + 6*16]
    psraw   mm0, 1
    psubsw  mm0, mm1
    movq qword ptr [ecx + 4*16], mm0
    
    movq mm0, qword ptr [eax + 1*16]
    movq mm1, qword ptr [eax + 5*16]
    movq mm2, qword ptr [eax + 7*16]
    psubsw  mm2, mm0
    paddsw  mm2, mm1
    psraw   mm1, 1
    paddsw  mm2, mm1
    movq qword ptr [ecx + 5*16], mm2
    
    movq mm0, qword ptr [eax + 2*16]
    movq mm1, qword ptr [eax + 6*16]
    psraw   mm1, 1
    paddsw  mm0, mm1
    movq qword ptr [ecx + 6*16], mm0
    
    movq mm0, qword ptr [eax + 1*16]
    movq mm1, qword ptr [eax + 3*16]
    movq mm2, qword ptr [eax + 5*16]
    paddsw  mm1, mm2
    paddsw  mm1, mm0
    psraw   mm0, 1
    paddsw  mm1, mm0
    movq qword ptr [ecx + 7*16], mm1
    
    add  eax, 8
    add  ecx, 8
    dec  edx
    jne  $loop
    emms
}

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

Замеры скорости

Понятно, что отмерить время выполнения одного преобразования не представляется возможным, по причине и его крайней малости, поэтому, мы будем выполнять наши куски по 1 000 000 (одному миллиону) раз. Так же, чтобы никто нам не помешал, выставим побольше приоритет текущему процессу (SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_TIME_CRITICAL);) и не забудем вернуть его в нормальный по окончанию работы.

А как Вы будете непосредственно время измерять - вариантов, масса сами придумаете.

А я пока расскажу про свои итоги. Вариант номер раз, C++ код - время выполнения миллиона преобразований составляет 111 мс. Вариант номер два, оптимизация под MMX - 24 мс. Я считаю, что это очень достойный результат оптимизации.

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

Основное что нам надо запомнить на данном этапе, это то, что при использовании MMX скорость увеличилась в 4-5 раз. Перейдем теперь к SSE.

Оптимизация с использованием SSE

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

показать код

short arBufferSrc[64];
short arBufferSSEDst[64];

short *pBufferSrc = arBufferSrc;
short *pBufferSSEDst = arBufferMMXDst; memset(pBufferSSEDst, 0, 64);

__asm
{
    mov  eax, pBufferSrc
    mov  ecx, pBufferSSEDst

    movdqa xmm0, [eax]
    movdqa xmm2, xmm0
    movdqa xmm1, [eax + 4*16]
    paddsw xmm0, xmm1
    movdqa [ecx], xmm0
    
    psubsw xmm2, xmm
    movdqa [ecx + 2*16], xmm2
    
    movdqa xmm0, [eax + 2*16]
    movdqa xmm2, xmm0
    movdqa xmm1, [eax + 6*16]
    psraw   xmm0, 1
    psubsw  xmm0, xmm1
    movdqa [ecx + 4*16], xmm0
    
    psraw   xmm1, 1
    paddsw  xmm1, xmm2
    movdqa [ecx + 6*16], xmm1
    
    movdqa xmm0, [eax + 1*16]
    movdqa xmm1, [eax + 3*16]
    movdqa xmm2, [eax + 5*16]
    movdqa xmm3, [eax + 7*16]
    movdqa xmm4, xmm0
    movdqa xmm5, xmm1
    movdqa xmm6, xmm2
    movdqa xmm7, xmm3
    psubsw  xmm6, xmm1
    psubsw  xmm6, xmm3
    psraw   xmm7, 1
    psubsw  xmm6, xmm7
    movdqa [ecx + 16], xmm6
    
    paddsw  xmm4, xmm3
    psubsw  xmm4, xmm5
    psraw   xmm5, 1
    psubsw  xmm4, xmm5
    movdqa [ecx + 3*16], xmm4
    
    movdqa xmm6, xmm2
    psubsw  xmm3, xmm0
    paddsw  xmm3, xmm6
    psraw   xmm6, 1
    paddsw  xmm3, xmm6
    movdqa [ecx + 5*16], xmm3
    
    paddsw  xmm1, xmm2
    paddsw  xmm1, xmm0
    psraw   xmm0, 1
    paddsw  xmm1, xmm0
    movdqa [ecx + 7*16], xmm1
    
    emms
}

Меряем для этого кода время аналогично тому, как делали для MMX - получаем 19 мс. Ага. Прирост относительно MMX варианта, прооптимизированого для работы с памятью, 5%. Упс. Но, как выясняется, столь скромный результат связан с тем, что у меня AMD Athlon, на Intel-овском процессоре получилось ускорение на 50% (соответственно, для MMX получили 17 мс, для SSE - 9 мс). Выводы делать не буду, собственно, для меня понятно, что надо пользовать SSE, если возможно, потому что и 5% тоже хлеб, а 50% это уже и масло.

Надо сделать одно замечание по поводу SSE.

Для загрузки данных из памяти в регистры мы используем оператор movdqa, для него есть аналог movdqu, если использовать его, то вместо прироста скорости относительно MMX мы получим спад. Однако, чтобы использовать movdqa и не получить Run time error, исходные данные должны быть выровнены в памяти к 16 байтам. Это можно сделать либо автоматически:

__declspec(align(16) ) short arBufferSrc[64];

либо выделяя памяти побольше и подравнивая руками.

Заключение

Итак, MMX и SSE оптимизация не представляет сложностей, все работает на задаче, которая к этой оптимизации хорошо подходит. Относительно исходного C++ варианта использование SSE дает нам ускорение от 5 раз в худшем случае, до 10 раз в лучшем.