Как преобразовать 24-битный rgb в 32-битный с помощью avx2?

Вы можете достаточно эффективно обрабатывать 8 пикселей за раз (24 входных байта и 32 выходных байта) с помощью AVX2.

Вам просто нужно выровнять свои загрузки так, чтобы 24-байтовый блок пикселей, который вы будете обрабатывать, был центрирован в середине 32-байтовой загрузки, а не при обычном подходе выравнивания загрузки по началу. блока пикселей². Это означает, что граница дорожки будет располагаться между пикселями 4 и 5, и у вас будут байты ровно для 4 пикселов на каждой дорожке. В сочетании с соответствующей маской перемешивания это должно быть в два раза эффективнее, чем SSE.

Например:

Получив указатель ввода uint8_t input[], вы обрабатываете первые четыре пикселя с кодом, отличным от SIMD¹, а затем выполняете первую 32-байтную загрузку по адресу input[8], чтобы полоса младшего разряда (байты 0–15) получила 12 байты полезной нагрузки для пикселей 4, 5, 6, 7 в байтах старшего порядка, за которыми сразу следуют следующие 12 байтов полезной нагрузки для следующих 4 пикселей в старшей дорожке. Затем вы используете pshufb, чтобы расширить пиксели до их правильных позиций (вам нужна другая маска для каждой дорожки, так как вы перемещаете пиксели в нижней дорожке в более низкие позиции, а в верхней дорожке в более высокие позиции, но это не не представляет проблемы). Затем следующая загрузка будет в input[26] (через 24 байта) и так далее.

При таком подходе вы должны получить пропускную способность около 8 пикселей за цикл, для идеального кэшированного ввода/вывода - пропускная способность хранилища 1/цикл и пропускная способность перемешивания 1/цикл. К счастью, этот подход совместим с всегда выровненными хранилищами (поскольку приращение хранилища составляет 32 байта). У вас будут некоторые смещенные нагрузки, но они все еще могут возникать при 1/цикле, поэтому не должны быть узким местом.

Стоит отметить, что этот тип подхода «работает только один раз» с точки зрения расширения набора инструкций SIMD: он работает, когда у вас есть 2 полосы, но не более (поэтому та же идея не применима к 512-битному AVX512 с 4 128 битами). -битные дорожки).

¹Это позволяет избежать чтения за пределы перед входным массивом: если вы знаете, что это безопасно, вы можете пропустить этот шаг.

²То есть, если вы загружаете из addr, именно addr + 16 должно быть на границе пикселей ((addr + 16) % 12 == 0), а не addr.

Вот исходный код SSSE3, в который добавлены некоторые мои собственные диспетчеризации.

void DspConvertPcm(f32* pOutBuffer, const s24* pInBuffer, size_t totalSampleCount)
{
    constexpr f32 fScale = static_cast<f32>(1.0 / (1<<23));

    size_t i = 0;
    size_t vecSampleCount = 0;

#if defined(SFTL_SSE2)
    if (CpuInfo::GetSupports_SIMD_I32x8())
    {
        vecSampleCount = DspConvertPcm_AVX2(pOutBuffer, pInBuffer, totalSampleCount);
    }
    else
    if (CpuInfo::GetSupports_SSE3())
    {
        const auto vScale = _mm_set1_ps(fScale);
        const auto mask = _mm_setr_epi8(-1, 0, 1, 2, -1, 3, 4, 5, -1, 6, 7, 8, -1, 9, 10, 11);

        constexpr size_t step = 16;
        vecSampleCount = (totalSampleCount / step) * step;

        for (; i < vecSampleCount; i += step)
        {
            const auto* pSrc = reinterpret_cast<const __m128i*>(pInBuffer + i);
            auto* pDst = pOutBuffer + i;

            const auto sa = _mm_loadu_si128(pSrc + 0);
            const auto sb = _mm_loadu_si128(pSrc + 1);
            const auto sc = _mm_loadu_si128(pSrc + 2);

            const auto da = _mm_srai_epi32(_mm_shuffle_epi8(sa, mask), 8);
            const auto db = _mm_srai_epi32(_mm_shuffle_epi8(_mm_alignr_epi8(sb, sa, 12), mask), 8);
            const auto dc = _mm_srai_epi32(_mm_shuffle_epi8(_mm_alignr_epi8(sc, sb,  8), mask), 8);
            const auto dd = _mm_srai_epi32(_mm_shuffle_epi8(_mm_alignr_epi8(sc, sc,  4), mask), 8);

            //  Convert to float and store
            _mm_storeu_ps(pDst + 0,  _mm_mul_ps(_mm_cvtepi32_ps(da), vScale));
            _mm_storeu_ps(pDst + 4,  _mm_mul_ps(_mm_cvtepi32_ps(db), vScale));
            _mm_storeu_ps(pDst + 8,  _mm_mul_ps(_mm_cvtepi32_ps(dc), vScale));
            _mm_storeu_ps(pDst + 12, _mm_mul_ps(_mm_cvtepi32_ps(dd), vScale));
        }
    }
#endif

    for (; i < totalSampleCount; i += 1)
    {
        pOutBuffer[i] = (static_cast<s32>(pInBuffer[i])) * fScale;
    }
}

Если присутствует AVX2, он вызовет DspConvertPcm_AVX2, который выглядит так:

size_t DspConvertPcm_AVX2(f32* pOutBuffer, const s24* pInBuffer, size_t totalSampleCount)
{
    SFTL_ASSERT(CpuInfo::GetSupports_SIMD_I32x8());

    constexpr f32 fScale = static_cast<f32>(1.0 / (1 << 23));
    const auto vScale = _mm256_set1_ps(fScale);

    auto fnDo16Samples = [vScale](f32* pOutBuffer, const s24* pInBuffer)
    {
        const auto vScaleSSE = _mm256_castps256_ps128(vScale);
        const auto mask = _mm_setr_epi8(-1, 0, 1, 2, -1, 3, 4, 5, -1, 6, 7, 8, -1, 9, 10, 11);

        const auto* pSrc = reinterpret_cast<const __m128i*>(pInBuffer);
        auto* pDst = pOutBuffer;

        const auto sa = _mm_loadu_si128(pSrc + 0);
        const auto sb = _mm_loadu_si128(pSrc + 1);
        const auto sc = _mm_loadu_si128(pSrc + 2);

        const auto da = _mm_srai_epi32(_mm_shuffle_epi8(sa, mask), 8);
        const auto db = _mm_srai_epi32(_mm_shuffle_epi8(_mm_alignr_epi8(sb, sa, 12), mask), 8);
        const auto dc = _mm_srai_epi32(_mm_shuffle_epi8(_mm_alignr_epi8(sc, sb, 8), mask), 8);
        const auto dd = _mm_srai_epi32(_mm_shuffle_epi8(_mm_alignr_epi8(sc, sc, 4), mask), 8);

        //  Convert to float and store
        _mm_storeu_ps(pDst +  0, _mm_mul_ps(_mm_cvtepi32_ps(da), vScaleSSE));
        _mm_storeu_ps(pDst +  4, _mm_mul_ps(_mm_cvtepi32_ps(db), vScaleSSE));
        _mm_storeu_ps(pDst +  8, _mm_mul_ps(_mm_cvtepi32_ps(dc), vScaleSSE));
        _mm_storeu_ps(pDst + 12, _mm_mul_ps(_mm_cvtepi32_ps(dd), vScaleSSE));
    };

    //  First 16 samples SSE style
    fnDo16Samples(pOutBuffer, pInBuffer);

    //  Next samples do AVX, where each load will discard 4 bytes at the start and end of each load
    constexpr size_t step = 16;
    const size_t vecSampleCount = ((totalSampleCount / step) * step) - 16;
    {
        const auto mask = _mm256_setr_epi8(-1, 4, 5, 6, -1, 7, 8, 9, -1, 10, 11, 12, -1, 13, 14, 15, -1, 16, 17, 18, -1, 19, 20, 21, -1, 22, 23, 24, -1, 25, 26, 27);
        for (size_t i = 16; i < vecSampleCount; i += step)
        {
            const byte* pByteBuffer = reinterpret_cast<const byte*>(pInBuffer + i);
            auto* pDst = pOutBuffer + i;

            const auto vs24_00_07 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(pByteBuffer -  4));
            const auto vs24_07_15 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(pByteBuffer - 24));

            const auto vf32_00_07 = _mm256_srai_epi32(_mm256_shuffle_epi8(vs24_00_07, mask), 8);
            const auto vf32_07_15 = _mm256_srai_epi32(_mm256_shuffle_epi8(vs24_07_15, mask), 8);

            //  Convert to float and store
            _mm256_storeu_ps(pDst + 0, _mm256_mul_ps(_mm256_cvtepi32_ps(vf32_00_07), vScale));
            _mm256_storeu_ps(pDst + 8, _mm256_mul_ps(_mm256_cvtepi32_ps(vf32_00_07), vScale));
        }
    }

    //  Last 16 samples SSE style
    fnDo16Samples(pOutBuffer + vecSampleCount, pInBuffer + vecSampleCount);

    return vecSampleCount;
}

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

С таймером, установленным непосредственно перед вызовом DspConvertPcm, который обрабатывает 1024 выборки за раз, среднее время обработки здесь с включенным путем кода AVX2 будет варьироваться от 2,6 до 3,0 микросекунд. С другой стороны, если я отключу путь кода AVX2, среднее время колеблется около 2,0 микросекунд.

С другой стороны, включение кодирования VEX с помощью /arch:AVX2 не дало мне постоянного прироста производительности, о котором я заявлял ранее, так что это, должно быть, было случайностью.

Этот тест был выполнен на процессоре Haswell core i7-6700HQ с частотой 2,6 ГГц с использованием компилятора MSVC по умолчанию в Visual Studio 15.9.5 с включенной оптимизацией для скорости и использованием /fp:fast.