如何使用 avx 将 int 64 转换为 int 32 （但不使用 avx-512）

Question

我想将 4 个长整型（64 位）寄存器转换/打包为 4 个整数（32 位）。换句话说，将 int64 的 __m256i 转换为 int32 的 __m128i。

我没有 avx-512 供我使用，所以本质上是：

__m256i n;
__m128i r128i = _mm256_cvtepi64_epi32( n );

不适合我。还有比下面的更好的替代方案吗？

失去矢量化：

__m256i n;
alignas(32) int64_t temp[4];
_mm256_store_si256((__m256i*)temp, n);
int32_t a = (int32_t)temp[0];
int32_t b = (int32_t)temp[1];
int32_t c = (int32_t)temp[2];
int32_t d = (int32_t)temp[3];
__m128i r128i = _mm_set_epi32(a, b, c, d);

这打包成 16 位整数而不是 32 位

__m128i lo_lane = _mm256_castsi256_si128(n);
__m128i hi_lane = _mm256_extracti128_si256(n, 1);
__m128i r128i = _mm_packus_epi32(lo_lane, hi_lane);

Answer 1

那么只是截断，而不是有符号（或无符号）饱和？（我问是因为 AVX-512 提供有符号和无符号的饱和版本，以及截断。您使用的非 AVX512 包（如_mm_packus_epi32( packusdw)）总是会饱和，如果您想在 AVX 之前进行截断打包，则必须使用纯洗牌指令 - 512.但如果其中一个都可以，因为上半部分已知为零，那么是的，包指令可能有用。）

单个向量__m256i->__m128i

对于单个向量，产生较窄的输出，您可以使用vextracti128withvshufps将单个向量打包__m256i到__m128i. 在 AVX-512 之前，vshufps它是仅有的具有任何控制输入（而不仅仅是固定交错）的 2 输入随机播放器之一。

在具有内在函数的 C 中，您需要_mm_castsi128_ps来回让编译器满意地使用_mm_shuffle_ps整数向量，但现代 CPU 没有在整数 SIMD 指令之间使用 FP 混洗的旁路延迟。或者，如果您只是要存储它，则可以将结果保留为__m128并使用_mm_store_ps((float*)p, vec); （是的，将整数指针转换为严格别名仍然是安全的，float*因为 deref 发生在内部函数内部，而不是在纯 C 中）。

#include <immintrin.h>

__m128 cvtepi64_epi32_avx(__m256i v)
{
   __m256 vf = _mm256_castsi256_ps( v );      // free
   __m128 hi = _mm256_extractf128_ps(vf, 1);  // vextractf128
   __m128 lo = _mm256_castps256_ps128( vf );  // also free
   // take the bottom 32 bits of each 64-bit chunk in lo and hi
   __m128 packed = _mm_shuffle_ps(lo, hi, _MM_SHUFFLE(2, 0, 2, 0));  // shufps
   //return _mm_castps_si128(packed);  // if you want
   return packed;
}   

这是每 128 位输出数据 2 次混洗。我们可以做得更好：每 256 位输出数据进行 2 次洗牌。（如果我们可以很好地安排输入，甚至只是 1）。

2x__m256i输入产生__m256i输出

幸运的是 clang 发现了比我更好的优化。我认为 2x vpermd+vpblendd可以做到这一点，将一个向量中每个元素的 low32 洗牌到底部车道，或另一个向量的顶部车道。（带有set_epi32(6,4,2,0, 6,4,2,0)随机播放控件）。

但是 clang 对其进行了优化，vshufps以将我们想要的所有元素放入一个向量中，然后vpermpd（相当于vpermq）将它们按正确的顺序排列。（这通常是一个很好的策略，我自己应该想到这一点。:P 再次，它利用了vshufps2 输入随机播放的优势。）

将其转换回内在函数，我们得到的代码将编译为 GCC 或其他编译器的高效 asm（Godbolt 编译器资源管理器用于此和原始）：

// 2x 256 -> 1x 256-bit result
__m256i pack64to32(__m256i a, __m256i b)
{
    // grab the 32-bit low halves of 64-bit elements into one vector
   __m256 combined = _mm256_shuffle_ps(_mm256_castsi256_ps(a),
                                       _mm256_castsi256_ps(b), _MM_SHUFFLE(2,0,2,0));
    // {b3,b2, a3,a2 | b1,b0, a1,a0}  from high to low

    // re-arrange pairs of 32-bit elements with vpermpd (or vpermq if you want)
    __m256d ordered = _mm256_permute4x64_pd(_mm256_castps_pd(combined), _MM_SHUFFLE(3,1,2,0));
    return _mm256_castpd_si256(ordered);
}

它仅编译为 2 条指令，具有立即随机播放控制，无向量常量。源代码看起来很冗长，但它主要只是为了让编译器对类型感到满意而进行的强制转换。

# clang -O3 -march=haswell
pack64to32:                             # @pack64to32
        vshufps ymm0, ymm0, ymm1, 136           # ymm0 = ymm0[0,2],ymm1[0,2],ymm0[4,6],ymm1[4,6]
        vpermpd ymm0, ymm0, 216                 # ymm0 = ymm0[0,2,1,3]
        ret

通过输入重新排序以避免交叉车道：一vshufps

{a0, a1 | a4, a5}如果您可以排列输入向量对，使它们具有按顺序排列的 64 位元素{a2, a3 | a6, a7}，则只需要进行通道内混洗：低 4x 32 位元素来自每个 256 位输入的低半部分，等等。一个人就能完成工作_mm256_shuffle_ps。（完全如上所述，不需要_mm256_permute4x64_pd）。感谢 @chtz 在该问题下的评论中提出了此建议。

Mandelbrot 不需要元素之间的交互，因此您可以使用__m256i具有 64 位元素排列的向量对。

如果您从展开的循环开始，使用{0,1,2,3}and之类的东西{4,5,6,7}并使用_mm256_add_epi64with来递增，那么您可以从andset1_epi64(8)开始，并且所有内容都应该以相同的方式工作。（除非你正在做其他事情，而元素的顺序很重要？）{0,1,4,5}{2,3,6,7}

Asm 与内在名称

查阅Intel的内在函数指南，通过asm助记符进行搜索；它们的输入时间较短，并且更容易思考机器实际可以做什么，并且需要使用 asm 助记符来在https://uops.info/table.html / https://agner.org中查找性能/优化/