ARM中16位大端到小端的快速转换

Question

我需要将 16 位整数值的大数组从 big-endian 格式转换为 little-endian 格式。

现在我使用以下函数进行转换：

inline void Reorder16bit(const uint8_t * src, uint8_t * dst)
{
    uint16_t value = *(uint16_t*)src;
    *(uint16_t*)dst = value >> 8 | value << 8;
}

void Reorder16bit(const uint8_t * src, size_t size, uint8_t * dst)
{
    assert(size%2 == 0);
    for(size_t i = 0; i < size; i += 2)
        Reorder16bit(src + i, dst + i);
}

我使用 GCC。目标平台是 ARMv7 (Raspberry Phi 2B)。

有什么办法可以优化吗？

加载音频样本时需要这种转换，这些样本可以是小端格式也可以是大端格式。当然它现在不是瓶颈，但它需要大约 10% 的总处理时间。而且我认为对于这么简单的操作来说太过分了。

Answer 1

https://goo.gl/4bRGNh

int swap(int b) {
  return __builtin_bswap16(b);
}

变成

swap(int):
        rev16   r0, r0
        uxth    r0, r0
        bx      lr

所以你的可以写成 (gcc-explorer: https://goo.gl/HFLdMb)

void fast_Reorder16bit(const uint16_t * src, size_t size, uint16_t * dst)
{
    assert(size%2 == 0);
    for(size_t i = 0; i < size; i++)
        dst[i] = __builtin_bswap16(src[i]);
} 

应该是for循环

.L13:
        ldrh    r4, [r0, r3]
        rev16   r4, r4
        strh    r4, [r2, r3]    @ movhi
        adds    r3, r3, #2
        cmp     r3, r1
        bne     .L13

在GCC builtin docs 上阅读有关__builtin_bswap16 的更多信息。

Neon 建议（经过测试，gcc-explorer：https://goo.gl/fLNYuc）：

void neon_Reorder16bit(const uint8_t * src, size_t size, uint8_t * dst)
{
  assert(size%16 == 0);
  //uint16x8_t vld1q_u16 (const uint16_t *) 
  //vrev64q_u16(uint16x8_t vec);
  //void vst1q_u16 (uint16_t *, uint16x8_t) 
  for (size_t i = 0; i < size; i += 16)
    vst1q_u8(dst + i, vrev16q_u8(vld1q_u8(src + i)));
}

变成了

.L23:
        adds    r5, r0, r3
        adds    r4, r2, r3
        adds    r3, r3, #16
        vld1.8  {d16-d17}, [r5]
        cmp     r1, r3
        vrev16.8        q8, q8
        vst1.8  {d16-d17}, [r4]
        bhi     .L23

在此处查看有关霓虹内在函数的更多信息：https://gcc.gnu.org/onlinedocs/gcc-4.4.1/gcc/ARM-NEON-Intrinsics.html

来自 ARM ARM A8.8.386 的奖励：

VREV16（半字向量反转）反转向量的每个半字中 8 位元素的顺序，并将结果放入相应的目标向量中。

VREV32（Vector Reverse in words）反转向量每个字中 8 位或 16 位元素的顺序，并将结果放入相应的目标向量中。

VREV64（双字中的向量反转）将向量的每个双字中的 8 位、16 位或 32 位元素的顺序反转，并将结果放在相应的目标向量中.

数据类型之间没有区别，除了大小。

Answer 2

我对ARM指令集了解不多，但我想有一些特殊的指令可以进行字节序转换。显然，ARMv7 有 rev 之类的东西。

您是否尝试过编译器内在__builtin_bswap16？它应该编译为特定于 CPU 的代码，例如在 ARM 上转。此外，它可以帮助编译器识别您实际上是在进行字节交换，并使用该知识执行其他优化，例如在y=swap(x); y &= some_value; x = swap(y); 等情况下完全消除冗余字节交换。

我用谷歌搜索了一下，this thread discusses an issue with the optimization potential。 According to this discussion，如果CPU支持vrevNEON指令，编译器也可以向量化转换。

Answer 3

如果它专门用于 ARM，则有一条 REV 指令，特别是 REV16，它将一次执行两个 16 位整数。

Answer 4

如果您想提高代码的性能，您可以进行以下操作：

1) 一步处理4字节：

inline void Reorder16bit(const uint8_t * src, uint8_t * dst)
{
    uint16_t value = *(uint16_t*)src;
    *(uint16_t*)dst = value >> 8 | value << 8;
}

inline void Reorder16bit2(const uint8_t * src, uint8_t * dst)
{
    uint32_t value = *(uint32_t*)src;
    *(size_t*)dst = (value & 0xFF00FF00) >> 8 | (value & 0x00FF00FF) << 8;
}

void Reorder16bit(const uint8_t * src, size_t size, uint8_t * dst)
{
    assert(size%2 == 0);

    size_t alignedSize = size/4*4;
    for(size_t i = 0; i < alignedSize; i += 4)
        Reorder16bit2(src + i, dst + i);
    for(size_t i = alignedSize; i < size; i += 2)
        Reorder16bit(src + i, dst + i);
}

如果你使用 64 位平台，同样的方法可以处理 8 个字节为一个步骤。

2) ARMv7 平台支持称为 NEON 的 SIMD 指令。 通过使用它们，您可以使您的编码速度比 1) 更快：

inline void Reorder16bit(const uint8_t * src, uint8_t * dst)
{
    uint16_t value = *(uint16_t*)src;
    *(uint16_t*)dst = value >> 8 | value << 8;
}

inline void Reorder16bit8(const uint8_t * src, uint8_t * dst)
{
    uint8x16_t _src = vld1q_u8(src);
    vst1q_u8(dst, vrev16q_u8(_src));
}

void Reorder16bit(const uint8_t * src, size_t size, uint8_t * dst)
{
    assert(size%2 == 0);

    size_t alignedSize = size/16*16;
    for(size_t i = 0; i < alignedSize; i += 16)
        Reorder16bit8(src + i, dst + i);
    for(size_t i = alignedSize; i < size; i += 2)
        Reorder16bit(src + i, dst + i);
}

Answer 5

您想要测量哪个更快，但Reorder16bit 的替代机构是

*(uint16_t*)dst = 256 * src[0] + src[1];

假设你的原生整数是小端的。另一种可能性：

dst[0] = src[1];
dst[1] = src[0];