清除 __m128i 的高字节

Posted 2023-02-16

【中文标题】清除 __m128i 的高字节

【英文标题】：Clear upper bytes of __m128i

【发布时间】：2013-09-07 14:08:50

【问题描述】：

如何清除__m128i 的16 - i 高字节？

我试过这个；它有效，但我想知道是否有更好（更短，更快）的方法：

int i = ...  //  0 < i < 16

__m128i x = ...

__m128i mask = _mm_set_epi8(
    0,
    (i > 14) ? -1 : 0,
    (i > 13) ? -1 : 0,
    (i > 12) ? -1 : 0,
    (i > 11) ? -1 : 0,
    (i > 10) ? -1 : 0,
    (i >  9) ? -1 : 0,
    (i >  8) ? -1 : 0,
    (i >  7) ? -1 : 0,
    (i >  6) ? -1 : 0,
    (i >  5) ? -1 : 0,
    (i >  4) ? -1 : 0,
    (i >  3) ? -1 : 0,
    (i >  2) ? -1 : 0,
    (i >  1) ? -1 : 0,
    -1);

x = _mm_and_si128(x, mask);

【问题讨论】：

听起来不像是值得 C++ 标记的东西。

如果 i 直到运行时才知道，那么我认为最好的选择是查找表。

@LaszloPapp：为什么不呢？ 应该用哪种语言标记？

@jalf：我会使用“C”。

但如果他正在编写恰好使用 SSE 的 C++ 代码，他为什么要不将其标记为 C++？如果通过某种疯狂的想象，他想确保他得到的解决方案可以编译为 C++ 怎么办？你是说 SSE 是 C 语言的一部分，而不是 C++ 的一部分？

【参考方案1】：

我尝试了几种不同的实现方式，并在早期的 Core i7 @ 2.67 GHz 和最近的 Haswell @ 3.6 GHz 上使用几个不同的编译器对它们进行了基准测试：

//
// mask_shift_0
//
// use PSHUFB (note: SSSE3 required)
//

inline __m128i mask_shift_0(uint32_t n)

  const __m128i vmask = _mm_set1_epi8(255);
  const __m128i vperm = _mm_set_epi8(112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127);
  __m128i vp = _mm_add_epi8(vperm, _mm_set1_epi8(n));
  return _mm_shuffle_epi8(vmask, vp);


//
// mask_shift_1
//
// use 16 element LUT
//

inline __m128i mask_shift_1(uint32_t n)

  static const int8_t mask_lut[16][16] __attribute__ ((aligned(16))) = 
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ,
     0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ,
     0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ,
     0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ,
     0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ,
     0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ,
     0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 ,
     0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1 ,
     0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1 ,
     0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1 ,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1 ,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1 ,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1 ,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1 ,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1 ,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1 
  ;
  return _mm_load_si128((__m128i *)&mask_lut[n]);


//
// mask_shift_2
//
// use misaligned load from 2 vector LUT
//

inline __m128i mask_shift_2(uint32_t n)

  static const int8_t mask_lut[32] = 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
  ;
  return _mm_loadu_si128((__m128i *)(mask_lut + 16 - n));


//
// mask_shift_3
//
// use compare and single vector LUT
//

inline __m128i mask_shift_3(uint32_t n)

  const __m128i vm = _mm_setr_epi8(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
  __m128i vn = _mm_set1_epi8(n);
  return _mm_cmpgt_epi8(vm, vn);


//
// mask_shift_4
//
// use jump table and immediate shifts
//

inline __m128i mask_shift_4(uint32_t n)

  const __m128i vmask = _mm_set1_epi8(-1);
  switch (n)
  
    case 0:
      return vmask;
    case 1:
      return _mm_slli_si128(vmask, 1);
    case 2:
      return _mm_slli_si128(vmask, 2);
    case 3:
      return _mm_slli_si128(vmask, 3);
    case 4:
      return _mm_slli_si128(vmask, 4);
    case 5:
      return _mm_slli_si128(vmask, 5);
    case 6:
      return _mm_slli_si128(vmask, 6);
    case 7:
      return _mm_slli_si128(vmask, 7);
    case 8:
      return _mm_slli_si128(vmask, 8);
    case 9:
      return _mm_slli_si128(vmask, 9);
    case 10:
      return _mm_slli_si128(vmask, 10);
    case 11:
      return _mm_slli_si128(vmask, 11);
    case 12:
      return _mm_slli_si128(vmask, 12);
    case 13:
      return _mm_slli_si128(vmask, 13);
    case 14:
      return _mm_slli_si128(vmask, 14);
    case 15:
      return _mm_slli_si128(vmask, 15);
  


//
// lsb_mask_0
//
// Contributed by by @Leeor/@dtb
//
// uses _mm_set_epi64x
//

inline __m128i lsb_mask_0(int n)

  if (n >= 8)
    return _mm_set_epi64x(~(-1LL << (n - 8) * 8), -1);
  else
    return _mm_set_epi64x(0, ~(-1LL << (n - 0) * 8));


//
// lsb_mask_1
//
// Contributed by by @Leeor/@dtb
//
// same as lsb_mask_0 but uses conditional operator instead of if/else
//

inline __m128i lsb_mask_1(int n)

  return _mm_set_epi64x(n >= 8 ? ~(-1LL << (n - 8) * 8) : 0, n >= 8 ? -1 : ~(-1LL << (n - 0) * 8));

结果很有趣：

Core i7 @ 2.67 GHz，Apple LLVM gcc 4.2.1 (gcc -O3)

mask_shift_0: 2.23377 ns
mask_shift_1: 2.14724 ns
mask_shift_2: 2.14270 ns
mask_shift_3: 2.15063 ns
mask_shift_4: 2.98304 ns
lsb_mask_0:   2.15782 ns
lsb_mask_1:   2.96628 ns

Core i7 @ 2.67 GHz，Apple clang 4.2 (clang -Os)

mask_shift_0: 1.35014 ns
mask_shift_1: 1.12789 ns
mask_shift_2: 1.04329 ns
mask_shift_3: 1.09258 ns
mask_shift_4: 2.01478 ns
lsb_mask_0:   1.70573 ns
lsb_mask_1:   1.84337 ns

Haswell E3-1285 @ 3.6 GHz，gcc 4.7.2 (gcc -O2)

mask_shift_0: 0.851416 ns
mask_shift_1: 0.575245 ns
mask_shift_2: 0.577746 ns
mask_shift_3: 0.850086 ns
mask_shift_4: 1.398270 ns
lsb_mask_0:   1.359660 ns
lsb_mask_1:   1.709720 ns

所以mask_shift_4 (switch/case) 似乎是所有情况下最慢的方法，而其他方法非常相似。基于 LUT 的方法似乎始终是最快的。

注意：我用clang -O3 和gcc -O3 得到了一些可疑的快速数字（仅限gcc 4.7.2） - 我需要查看针对这些情况生成的程序集，以了解编译器在做什么，并确保它没有做任何“聪明”的事情，例如优化掉时序测试工具的某些部分。

如果其他人对此有任何进一步的想法或想要尝试其他 mask_shift 实现，我很乐意将其添加到测试套件并更新结果。

【讨论】：

嘿，伙计们，在基准测试方面做得很好，我谦虚地承认被打败了 :) - 仍然想知道原生 128b 移位是否可以工作，以及它可以比较多快对这些

@Leeor：switch 和 case n: return _mm_srli_si128(_mm_set1_epi32(-1), 16 - n) 的每个可能值 n 在我的机器上需要 2.10 秒。

值得注意的是mask_shift_*返回了lsb_mask的按位否定。

问题中发布的原始代码需要8.29秒。因此，已发布的每个解决方案都是一个巨大的改进。再次感谢你们！

现在检查 - 通过使 lsb 掩码使用 cond 移动，我得到了 2 倍的加速（Linux 上的 gcc 4.6.3，循环中没有其他操作）： return _mm_set_epi64x(n >= 8 ? ~( -1LL = 8 ? -1 : ~(-1LL

【参考方案2】：

如果是正常的 64 位值，我会使用类似 -

    mask = (1 << (i * 8)) - 1;

但在将其推广到 128 时要小心，内部移位运算符不一定在这些范围内工作。

对于 128b，您可以只构建一个上下掩码，例如 -

    __m128i mask = _mm_set_epi64x( 
       i > 7 ? 0xffffffff : (1 << ((i) * 8)) - 1 
       i > 7 ? (1 << ((i-8) * 8)) - 1 : 0 
    );

（假设我没有交换订单，请检查我的这个，我对这些内在函数不是很熟悉） 或者，您可以在 2 宽的 uint64 数组上执行此操作，并使用它的地址直接从内存中加载 128b 掩码。

但是，这两种方法都不像原来的那样自然，它们只是将元素从 1 字节扩展到 8 字节，但仍然是部分的。最好使用单个 128b 变量进行适当的移位。

我刚刚遇到了这个关于 128b 班次的话题 -

Looking for sse 128 bit shift operation for non-immediate shift value

看起来有可能，但我从未使用过。您可以从那里尝试使用适当的 SSE 内在函数的上述单线。我会试一试 -

    mask = _mm_slli_si128(1, i); //emmintrin.h shows the second argument is in bytes already

然后使用您喜欢的方式减去一个（如果这种类型支持普通的旧运算符，我会感到惊讶-）

【讨论】：

听起来不错。您能否详细介绍如何创建上下蒙版？

将我的帖子编辑为我认为更好的方法

感谢您的更新。 _mm_slli_si128 需要一个编译时常量；这就是变量操作数需要链接的代码的原因。我正在使用基于 _mm_set_epi64x 代码的稍微修改过的代码版本，以及一些基于 32 位平台上的 _mm_set_epi32 的等效代码。将其与 Paul 现在发布的功能进行比较...