如何使用AVX2将24位RGB转换为32位

我已经使用ssse3完成了此操作，现在我想知道是否可以使用avx2来做得更好？

我使用快速24位阵列的代码 - ＆gt;32位阵列转换？。

    static const __m128i mask = _mm_setr_epi8(0, 1, 2, -1, 3, 4, 5, -1, 6, 7, 8, -1, 9, 10, 11, -1);
    for (size_t row = 0; row < height; ++row)
    {
        for (size_t column = 0; column < width; column += 16)
        {
            const __m128i *src = reinterpret_cast<const __m128i *>(in + row * in_pitch + column + (column << 1));
            __m128i *dst = reinterpret_cast<__m128i *>(out + row * out_pitch + (column << 2));
            __m128i v[4];
            v[0] = _mm_load_si128(src);
            v[1] = _mm_load_si128(src + 1);
            v[2] = _mm_load_si128(src + 2);
            v[3] = _mm_shuffle_epi8(v[0], mask);
            _mm_store_si128(dst, v[3]);
            v[3] = _mm_shuffle_epi8(_mm_alignr_epi8(v[1], v[0], 12), mask);
            _mm_store_si128(dst + 1, v[3]);
            v[3] = _mm_shuffle_epi8(_mm_alignr_epi8(v[2], v[1], 8), mask);
            _mm_store_si128(dst + 2, v[3]);
            v[3] = _mm_shuffle_epi8(_mm_alignr_epi8(v[2], v[2], 4), mask);
            _mm_store_si128(dst + 3, v[3]);
        }
    }

问题是_mm256_shuffle_epi8分别散装128位和低128位，因此面罩不能仅仅用

替换

    _mm256_setr_epi8(0, 1, 2, -1, 3, 4, 5, -1, 6, 7, 8, -1, 9, 10, 11, -1, 12, 13, 14, -1, 15, 16, 17, -1, 18, 19, 20, -1, 21, 22, 23, -1);

还需要用_mm256_permute2x128_si256和_mm256_alignr_epi8

替换_mm_alignr_epi8

您可以使用AVX2合理地处理8个像素(24个输入字节和32个输出字节(。

您只需要对齐负载，以便您要处理的24字节像素块在32字节负载的中间是中心，而不是对齐负载的通常方法到像素块的开始²。这意味着泳道边界将属于像素4和5之间，并且您将在每个车道中具有4个像素的字节。结合适当的洗牌面罩，这应该是SSE的两倍。

例如：

给定输入指针uint8_t input[]您使用非SIMD代码¹处理前四个像素，然后在input[8]处进行第一个32字节负载以高阶字节获得12个像素4,5,6,7的有效载荷字节，然后立即在高速公路中的接下来4个像素的下一个12个有效载荷字节。然后，您使用pshufb将像素扩展到其正确的位置(每个车道都需要一个不同的掩码，因为您将低速公路中的像素移动到较低的位置，而在高速公路上的像素则将其移至较高的位置，但这不是'提出问题(。然后，下一个负载将在input[26](稍后24个字节(等等。

对于完美缓存的输入/输出 - 在1/Cycle Store吞吐量和1/Cycle Shuffle吞吐量上，您应该使用此方法获得大约8个像素。幸运的是，这种方法与始终对齐的商店兼容(因为商店的增量为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之前将计时器绑在dspConvertPCM之前，该计时器一次处理1024个样本，启用AVX2代码路径的平均处理时间将在2.6和3.0微秒之间变化。另一方面，如果我禁用AVX2代码路径，则平均时间徘徊在2.0微秒左右。

另一方面，使用/ARCH启用Vex编码：AVX2并没有给我以前声称的一致的性能提升，因此一定是Fluke。

使用Visual Studio上的默认MSVC编译器15.9.5上的默认MSVC编译器在Haswell Core i7-6700HQ @ 2.6 GHz上执行此测试，并在速度和使用/fp：fast上进行了优化。

相关内容

最新更新

热门标签：