Новичок SIMD/SSE: простая фильтрация изображения

Я очень плохо знаком с SIMD/SSE, и я пытаюсь сделать некоторую простую фильтрацию изображения (размывание). Код ниже фильтрует каждый пиксель 8-разрядного серого битового массива с простым [1 2 1] взвешивающий в горизонтальном направлении. Я создаю суммы 16 пикселей за один раз.

То, что кажется очень плохим об этом коде, по крайней мере, мне, то, что существует много из, вставляют/извлекают в него, который не очень изящен и вероятно замедляет все также. Существует ли лучший способ перенести данные из одного reg в другого при смещении?

buf является данными изображения, выровненных 16 байтов. w/h являются шириной и высотой, кратными числами 16.

__m128i *p = (__m128i *) buf;
__m128i cur1, cur2, sum1, sum2, zeros, tmp1, tmp2, saved;
zeros = _mm_setzero_si128();
short shifted, last = 0, next;

// preload first row
cur1 = _mm_load_si128(p);
for (x = 1; x < (w * h) / 16; x++) {
    // unpack
    sum1 = sum2 = saved = cur1;
    sum1 = _mm_unpacklo_epi8(sum1, zeros);
    sum2 = _mm_unpackhi_epi8(sum2, zeros);
    cur1 = tmp1 = sum1;
    cur2 = tmp2 = sum2;
    // "middle" pixel
    sum1 = _mm_add_epi16(sum1, sum1);
    sum2 = _mm_add_epi16(sum2, sum2);
    // left pixel
    cur2 = _mm_slli_si128(cur2, 2);
    shifted = _mm_extract_epi16(cur1, 7);
    cur2 = _mm_insert_epi16(cur2, shifted, 0);
    cur1 = _mm_slli_si128(cur1, 2);
    cur1 = _mm_insert_epi16(cur1, last, 0);
    sum1 = _mm_add_epi16(sum1, cur1);
    sum2 = _mm_add_epi16(sum2, cur2);
    // right pixel
    tmp1 = _mm_srli_si128(tmp1, 2);
    shifted = _mm_extract_epi16(tmp2, 0);
    tmp1 = _mm_insert_epi16(tmp1, shifted, 7);
    tmp2 = _mm_srli_si128(tmp2, 2);
    // preload next row
    cur1 = _mm_load_si128(p + x);
    // we need the first pixel of the next row for the "right" pixel
    next = _mm_extract_epi16(cur1, 0) & 0xff;
    tmp2 = _mm_insert_epi16(tmp2, next, 7);
    // and the last pixel of last row for the next "left" pixel
    last = ((uint16_t) _mm_extract_epi16(saved, 7)) >> 8;
    sum1 = _mm_add_epi16(sum1, tmp1);
    sum2 = _mm_add_epi16(sum2, tmp2);
    // divide
    sum1 = _mm_srli_epi16(sum1, 2);
    sum2 = _mm_srli_epi16(sum2, 2);
    sum1 = _mm_packus_epi16(sum1, sum2);
    mm_store_si128(p + x - 1, sum1);
}
7
задан Paul R 29 November 2013 в 07:47
поделиться

2 ответа

Я предлагаю сохранить соседние пиксели в регистре SSE. То есть сохранить результат _mm_slli_si128 / _mm_srli_si128 в переменной SSE и исключить все вставки и извлечения. Мое рассуждение состоит в том, что в старых процессорах инструкции вставки / извлечения требуют связи между модулями SSE и модулями общего назначения, что намного медленнее, чем сохранение вычислений в SSE, даже если оно перетекает в кеш L1.

Когда это будет сделано, должно быть только четыре 16-битных сдвига (_mm_slli_si128, _mm_srli_si128, без учета сдвига деления ). Я предлагаю провести тест с вашим кодом, потому что к тому времени ваш код, возможно, уже достиг предела пропускной способности памяти ... что означает, что вы больше не можете оптимизировать.

Если изображение большое (больше размера L2) и вывод не будет считываться в ближайшее время, попробуйте использовать MOVNTDQ (_mm_stream_si128) для обратной записи. Согласно некоторым веб-сайтам, он находится в SSE2, хотя вы, возможно, захотите перепроверить.

Руководство по SIMD:

Некоторые веб-сайты гуру SIMD:

2
ответ дан 7 December 2019 в 14:28
поделиться

Такая операция соседства всегда была проблемой для SSE, пока не появился SSE3.5 (также известный как SSSE3) и не был введен PALIGNR (_mm_alignr_epi8).

Если вам нужна обратная совместимость с SSE2 / SSE3, вы можете написать эквивалентный макрос или встроенную функцию, которая имитирует _mm_alignr_epi8 для SSE2 / SSE3 и которая переходит на _mm_alignr_epi8 при нацеливании на SSE3.5 / SSE4.

Другой подход заключается в использовании смещенных нагрузок для получения смещенных данных - это относительно дорого для старых ЦП (примерно вдвое больше задержки и вдвое меньше пропускной способности выровненных нагрузок), но это может быть приемлемо в зависимости от большого объема вычислений, которые вы выполняете. за загрузку. Он также имеет то преимущество, что на текущих процессорах Intel (Core i7) смещенные нагрузки не имеют штрафа по сравнению с выровненными нагрузками, поэтому ваш код будет достаточно эффективным на Core i7 и др. .

2
ответ дан 7 December 2019 в 14:28
поделиться
Другие вопросы по тегам:

Похожие вопросы: