将 16 位掩码转换为 16 字节掩码
Convert 16 bits mask to 16 bytes mask
有没有办法转换下面的代码：
int mask16 = 0b1010101010101010; // int or short, signed or unsigned, it does not matter
到
__uint128_t mask128 = ((__uint128_t)0x0100010001000100 << 64) | 0x0100010001000100;
所以要更清楚一些，例如：
int mask16 = 0b1010101010101010;
__uint128_t mask128 = intrinsic_bits_to_bytes(mask16);
或直接敷面膜：
int mask16 = 0b1010101010101010;
__uint128_t v = ((__uint128_t)0x2828282828282828 << 64) | 0x2828282828282828;
__uint128_t w = intrinsic_bits_to_bytes_mask(v, mask16); // w = ((__uint128_t)0x2928292829282928 << 64) | 0x2928292829282928;
对于掩码中的每一位，您想将位置 n 的一位移动到位置 n[= 的字节的低位16=]，即位位置8 * n。您可以使用循环执行此操作：
__uint128_t intrinsic_bits_to_bytes(uint16_t mask)
{
int i;
__uint128_t result = 0;
for (i=0; i<16; i++) {
result |= (__uint128_t )((mask >> i) & 1) << (8 * i);
}
return result;
}
如果能用AVX512，一条指令就搞定，没有循环：
#include <immintrin.h>
__m128i intrinsic_bits_to_bytes(uint16_t mask16) {
const __m128i zeroes = _mm_setzero_si128();
const __m128i ones = _mm_set1_epi8(1);;
return _mm_mask_blend_epi8(mask16, ones, zeroes);
}
为了使用 gcc 构建，我使用：
g++ -std=c++11 -march=native -O3 src.cpp -pthread
这将构建正常，但如果您的处理器不支持 AVX512，它将在 运行 处抛出一个 illegal instruction
时间.
Bit/byte order：除非另有说明，这些都跟在问题后面，将 uint16_t 的 LSB 放在 [=21 的最低有效字节中=]（little-endian x86 上的最低内存地址）。例如，这就是位图的 ASCII 转储所需的内容，但它与单个 16 位数字的 base-2 表示的位值打印顺序相反。
关于有效地将值（返回）到 RDX:RAX 整数寄存器的讨论与大多数正常用例无关，因为您只是从向量寄存器存储到内存，无论是 0 /1 字节整数或 ASCII '0'/'1' 数字（你可以最有效地获得 0/1 整数 __m128i, 更不用说 unsigned __int128).
Table 的内容：
- SSE2 / SSSE3 版本：如果你想要向量中的结果很好，例如用于存储字符数组。
（，改组为 MSB 优先打印顺序并转换为 ASCII。）
- BMI2
pdep：如果您要在标量寄存器中使用结果，则适用于具有 BMI2 的 Intel CPU 上的标量 unsigned __int128。在 AMD 上运行缓慢。
- 带有乘法位的纯 C++：对于标量来说相当合理
- AVX-512：AVX-512 使用标量位图将掩码作为第一个 class 操作。如果您将结果用作标量的一半，可能不如 BMI2
pdep，否则甚至比 SSSE3 更好。
- AVX2 打印顺序（最低地址的 MSB） 32 位整数的转储。
- 另请参阅 is there an inverse instruction to the movemask instruction in intel avx2? 以了解元素大小和掩码宽度的其他变化。 （SSE2 和 multiply bithack 改编自该集合链接的答案。）
使用 SSE2（最好是 SSSE3）
查看@aqrit 的 How to efficiently convert an 8-bit bitmap to array of 0/1 integers with x86 SIMD 回答
调整它以使用 16 位 -> 16 字节，我们需要一个洗牌，将掩码的第一个字节复制到向量的前 8 个字节，并将第二个掩码字节复制到向量的高 8 个字节。这可以用一个 SSSE3 pshufb，或者用 punpcklbw same,same + punpcklwd same,same + punpckldq same,same 来最终复制最多两个 64 位 qwords。
typedef unsigned __int128 u128;
u128 mask_to_u128_SSSE3(unsigned bitmap)
{
const __m128i shuffle = _mm_setr_epi32(0,0, 0x01010101, 0x01010101);
__m128i v = _mm_shuffle_epi8(_mm_cvtsi32_si128(bitmap), shuffle); // SSSE3 pshufb
const __m128i bitselect = _mm_setr_epi8(
1, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1U<<7,
1, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1U<<7 );
v = _mm_and_si128(v, bitselect);
v = _mm_min_epu8(v, _mm_set1_epi8(1)); // non-zero -> 1 : 0 -> 0
// return v; // if you want a SIMD vector result
alignas(16) u128 tmp;
_mm_store_si128((__m128i*)&tmp, v);
return tmp; // optimizes to movq / pextrq (with SSE4)
}
（要得到 0 / 0xFF 而不是 0 / 1，将 _mm_min_epu8 替换为 v= _mm_cmpeq_epi8(v, bitselect)。 如果你想要一个 ASCII 字符串 '0' / '1' 个字符，执行 cmpeq 和 _mm_sub_epi8(_mm_set1_epi8('0'), v)。这避免了 set1(1) 向量常量。)
Godbolt 包括测试用例。 （对于此版本和其他非 AVX-512 版本。）
# clang -O3 for Skylake
mask_to_u128_SSSE3(unsigned int):
vmovd xmm0, edi # _mm_cvtsi32_si128
vpshufb xmm0, xmm0, xmmword ptr [rip + .LCPI2_0] # xmm0 = xmm0[0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1]
vpand xmm0, xmm0, xmmword ptr [rip + .LCPI2_1] # 1<<0, 1<<1, etc.
vpminub xmm0, xmm0, xmmword ptr [rip + .LCPI2_2] # set1_epi8(1)
# done here if you return __m128i v or store the u128 to memory
vmovq rax, xmm0
vpextrq rdx, xmm0, 1
ret
BMI2 pdep：Intel 好，AMD 不好
BMI2 pdep 在拥有它的 Intel CPU 上速度很快（自 Haswell 以来），但在 AMD 上非常慢（超过十几个 uops，高延迟。）
typedef unsigned __int128 u128;
inline u128 assemble_halves(uint64_t lo, uint64_t hi) {
return ((u128)hi << 64) | lo; }
// could replace this with __m128i using _mm_set_epi64x(hi, lo) to see how that compiles
#ifdef __BMI2__
#include <immintrin.h>
auto mask_to_u128_bmi2(unsigned bitmap) {
// fast on Intel, slow on AMD
uint64_t tobytes = 0x0101010101010101ULL;
uint64_t lo = _pdep_u64(bitmap, tobytes);
uint64_t hi = _pdep_u64(bitmap>>8, tobytes);
return assemble_halves(lo, hi);
}
如果你想在标量寄存器（而不是一个向量）中得到结果，那很好，否则可能更喜欢 SSSE3 方式。
# clang -O3
mask_to_u128_bmi2(unsigned int):
movabs rcx, 72340172838076673 # 0x0101010101010101
pdep rax, rdi, rcx
shr edi, 8
pdep rdx, rdi, rcx
ret
# returns in RDX:RAX
带有魔法乘法位黑客的可移植 C++
在 x86-64 上还不错；自 Zen 以来，AMD 具有快速的 64 位乘法，而自 Nehalem 以来，Intel 拥有该功能。一些低功耗的 CPU 仍然有缓慢 imul r64, r64
这个版本 可能 对于 __uint128_t 结果是最优的，至少对于没有 BMI2 的 Intel 和 AMD 的延迟是这样，因为它避免了到 XMM 的往返寄存器。但是对于吞吐量来说，这是相当多的指令
请参阅@phuclv 在 How to create a byte out of 8 bool values (and vice versa)? 上的回答，了解乘法和反向的解释。对 mask.
的每个 8 位一半使用一次来自 unpack8bools 的算法
//#include <endian.h> // glibc / BSD
auto mask_to_u128_magic_mul(uint32_t bitmap) {
//uint64_t MAGIC = htobe64(0x0102040810204080ULL); // For MSB-first printing order in a char array after memcpy. 0x8040201008040201ULL on little-endian.
uint64_t MAGIC = 0x0102040810204080ULL; // LSB -> LSB of the u128, regardless of memory order
uint64_t MASK = 0x0101010101010101ULL;
uint64_t lo = ((MAGIC*(uint8_t)bitmap) ) >> 7;
uint64_t hi = ((MAGIC*(bitmap>>8)) ) >> 7;
return assemble_halves(lo & MASK, hi & MASK);
}
如果您要使用 memcpy 将 __uint128_t 存储到内存中，您可能需要使用 htole64(0x0102040810204080ULL);（来自 GNU / BSD <endian.h>）来控制主机字节顺序或者等价于总是将输入的低位映射到输出的最低字节，即 char 或 bool 数组的第一个元素。或者 htobe64 表示其他订单，例如用于打印。在常量而不是变量数据上使用该函数允许在编译时进行常量传播。
否则，如果你真的想要一个 128 位整数，其低位与 u16 输入的低位匹配，则乘数常数与主机字节序无关；无法访问更广泛的类型。
clang 12.0 -O3 for x86-64:
mask_to_u128_magic_mul(unsigned int):
movzx eax, dil
movabs rdx, 72624976668147840 # 0x0102040810204080
imul rax, rdx
shr rax, 7
shr edi, 8
imul rdx, rdi
shr rdx, 7
movabs rcx, 72340172838076673 # 0x0101010101010101
and rax, rcx
and rdx, rcx
ret
AVX-512
使用 AVX-512BW很容易；您可以使用掩码从重复的 0x01 常量中进行零掩码加载。
__m128i bits_to_bytes_avx512bw(unsigned mask16) {
return _mm_maskz_mov_epi8(mask16, _mm_set1_epi8(1));
// alignas(16) unsigned __int128 tmp;
// _mm_store_si128((__m128i*)&u128, v); // should optimize into vmovq / vpextrq
// return tmp;
}
或者避免内存常量（因为编译器可以做 set1(-1) ）：做一个 -1 的零掩码绝对值。可以挂起常量设置，与set1(1)相同。
__m128i bits_to_bytes_avx512bw_noconst(unsigned mask16) {
__m128i ones = _mm_set1_epi8(-1); // extra instruction *off* the critical path
return _mm_maskz_abs_epi8(mask16, ones);
}
但请注意，如果做进一步的向量操作，maskz_mov 的结果可能可以优化为其他操作。例如 vec += maskz_mov 可以优化为合并掩码添加。但如果没有，vmovdqu8 xmm{k}{z}, xmm 需要像 vpabsb xmm{k}{z}, xmm 这样的 ALU 端口，但 vpabsb 不能 运行 在 Skylake/Ice Lake 的端口 5 上。 （来自归零寄存器的零掩码 vpsubb 可以避免可能的吞吐量问题，但是您将设置 2 个寄存器只是为了避免加载常量。在手写的 asm 中，您只需具体化 set1(1) 使用 vpcmpeqd / vpabsb 自己，如果你想避免常量的 4 字节广播负载。）
(Godbolt compiler explorer with gcc and clang -O3 -march=skylake-avx512. Clang 看穿屏蔽的vpabsb 和第一个版本一样编译，有内存常量。)
如果可以使用向量 0 / -1 而不是 0 / 1 则更好：使用 return _mm_movm_epi8(mask16)。编译为 kmovd k0, edi / vpmovm2b xmm0, k0
如果你想要像'0'或'1'这样的ASCII字符向量，你可以使用_mm_mask_blend_epi8(mask, ones, zeroes)。 （这应该比合并屏蔽添加到 set1(1) 的向量中更有效，后者需要额外的寄存器副本，也比 set1('0') 和 _mm_movm_epi8(mask16) 之间的 sub 更好，后者需要 2说明：一个将掩码变成一个向量，一个单独的 vpsubb。）
AVX2，位按 打印 顺序（MSB 在最低地址），字节按内存顺序，ASCII '0' / '1'
使用 [] 分隔符和 \t 制表符，类似这种输出格式，来自 this codereview Q&A:
[01000000] [01000010] [00001111] [00000000]
显然，如果您希望所有 16 位或 32 位 ASCII 数字都是连续的，那会更容易，并且不需要打乱输出以单独存储每个 8 字节块。在此处发布的大部分原因是它具有正确的打印顺序的洗牌和掩码常量，并且在事实证明这是问题真正想要的之后显示针对 ASCII 输出优化的版本。
使用How to perform the inverse of _mm256_movemask_epi8 (VPMOVMSKB)?，基本上是SSSE3代码的256位版本。
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <immintrin.h>
#include <string.h>
//
void binary_dump_4B_avx2(const void *input)
{
char buf[CHAR_BIT*4 + 2*4 + 3 + 1 + 1]; // bits, 4x [], 3x \t, \n, 0
buf[0] = '[';
for (int i=9 ; i<sizeof(buf) - 8; i+=11){ // GCC strangely doesn't unroll this loop
memcpy(&buf[i], "]\t[", 4); // 4-byte store as a single; we overlap the 0 later
}
__m256i v = _mm256_castps_si256(_mm256_broadcast_ss(input)); // aliasing-safe load; use _mm256_set1_epi32 if you know you have an int
const __m256i shuffle = _mm256_setr_epi64x(0x0000000000000000, // low byte first, bytes in little-endian memory order
0x0101010101010101, 0x0202020202020202, 0x0303030303030303);
v = _mm256_shuffle_epi8(v, shuffle);
// __m256i bit_mask = _mm256_set1_epi64x(0x8040201008040201); // low bits to low bytes
__m256i bit_mask = _mm256_set1_epi64x(0x0102040810204080); // MSB to lowest byte; printing order
v = _mm256_and_si256(v, bit_mask); // x & mask == mask
// v = _mm256_cmpeq_epi8(v, _mm256_setzero_si256()); // -1 / 0 bytes
// v = _mm256_add_epi8(v, _mm256_set1_epi8('1')); // '0' / '1' bytes
v = _mm256_cmpeq_epi8(v, bit_mask); // 0 / -1 bytes
v = _mm256_sub_epi8(_mm256_set1_epi8('0'), v); // '0' / '1' bytes
__m128i lo = _mm256_castsi256_si128(v);
_mm_storeu_si64(buf+1, lo);
_mm_storeh_pi((__m64*)&buf[1+8+3], _mm_castsi128_ps(lo));
// TODO?: shuffle first and last bytes into the high lane initially to allow 16-byte vextracti128 stores, with later stores overlapping to replace garbage.
__m128i hi = _mm256_extracti128_si256(v, 1);
_mm_storeu_si64(buf+1+11*2, hi);
_mm_storeh_pi((__m64*)&buf[1+11*3], _mm_castsi128_ps(hi));
// buf[32 + 2*4 + 3] = '\n';
// buf[32 + 2*4 + 3 + 1] = '[=19=]';
// fputs
memcpy(&buf[32 + 2*4 + 2], "]", 2); // including '[=19=]'
puts(buf); // appends a newline
// appending our own newline and using fputs or fwrite is probably more efficient.
}
void binary_dump(const void *input, size_t bytecount) {
}
// not shown: portable version, see Godbolt, or my or @chux's answer on the codereview question
int main(void)
{
int t = 1000000;
binary_dump_4B_avx2(&t);
binary_dump(&t, sizeof(t));
t++;
binary_dump_4B_avx2(&t);
binary_dump(&t, sizeof(t));
}
Runnable Godbolt demo 与 gcc -O3 -march=haswell.
请注意，GCC10.3 及更早版本是哑的，并复制 AND/CMPEQ 向量常量，一次作为字节，一次作为 qword。 （在这种情况下，与零进行比较会更好，或者将 OR 与倒掩码一起使用并与全一进行比较）。 GCC11.1 用 .set .LC1,.LC2 修复了这个问题，但仍然加载它两次，作为内存操作数而不是一次加载到寄存器中。 Clang 没有这些问题。
有趣的事实：clang -march=icelake-client 设法将第二部分变成 '0' 和 '1' 向量之间的 AVX-512 掩码混合，而不仅仅是 kmov 它使用广播加载，vpermb 字节洗牌，然后使用位掩码测试进入掩码。
有没有办法转换下面的代码：
int mask16 = 0b1010101010101010; // int or short, signed or unsigned, it does not matter
到
__uint128_t mask128 = ((__uint128_t)0x0100010001000100 << 64) | 0x0100010001000100;
所以要更清楚一些，例如：
int mask16 = 0b1010101010101010;
__uint128_t mask128 = intrinsic_bits_to_bytes(mask16);
或直接敷面膜：
int mask16 = 0b1010101010101010;
__uint128_t v = ((__uint128_t)0x2828282828282828 << 64) | 0x2828282828282828;
__uint128_t w = intrinsic_bits_to_bytes_mask(v, mask16); // w = ((__uint128_t)0x2928292829282928 << 64) | 0x2928292829282928;
对于掩码中的每一位，您想将位置 n 的一位移动到位置 n[= 的字节的低位16=]，即位位置8 * n。您可以使用循环执行此操作：
__uint128_t intrinsic_bits_to_bytes(uint16_t mask)
{
int i;
__uint128_t result = 0;
for (i=0; i<16; i++) {
result |= (__uint128_t )((mask >> i) & 1) << (8 * i);
}
return result;
}
如果能用AVX512，一条指令就搞定，没有循环：
#include <immintrin.h>
__m128i intrinsic_bits_to_bytes(uint16_t mask16) {
const __m128i zeroes = _mm_setzero_si128();
const __m128i ones = _mm_set1_epi8(1);;
return _mm_mask_blend_epi8(mask16, ones, zeroes);
}
为了使用 gcc 构建，我使用：
g++ -std=c++11 -march=native -O3 src.cpp -pthread
这将构建正常，但如果您的处理器不支持 AVX512，它将在 运行 处抛出一个 illegal instruction
时间.
Bit/byte order：除非另有说明，这些都跟在问题后面，将 uint16_t 的 LSB 放在 [=21 的最低有效字节中=]（little-endian x86 上的最低内存地址）。例如，这就是位图的 ASCII 转储所需的内容，但它与单个 16 位数字的 base-2 表示的位值打印顺序相反。
关于有效地将值（返回）到 RDX:RAX 整数寄存器的讨论与大多数正常用例无关，因为您只是从向量寄存器存储到内存，无论是 0 /1 字节整数或 ASCII '0'/'1' 数字（你可以最有效地获得 0/1 整数 __m128i, 更不用说 unsigned __int128).
Table 的内容：
- SSE2 / SSSE3 版本：如果你想要向量中的结果很好，例如用于存储字符数组。
（ - BMI2
pdep：如果您要在标量寄存器中使用结果，则适用于具有 BMI2 的 Intel CPU 上的标量unsigned __int128。在 AMD 上运行缓慢。 - 带有乘法位的纯 C++：对于标量来说相当合理
- AVX-512：AVX-512 使用标量位图将掩码作为第一个 class 操作。如果您将结果用作标量的一半，可能不如 BMI2
pdep，否则甚至比 SSSE3 更好。 - AVX2 打印顺序（最低地址的 MSB） 32 位整数的转储。
- 另请参阅 is there an inverse instruction to the movemask instruction in intel avx2? 以了解元素大小和掩码宽度的其他变化。 （SSE2 和 multiply bithack 改编自该集合链接的答案。）
使用 SSE2（最好是 SSSE3）
查看@aqrit 的 How to efficiently convert an 8-bit bitmap to array of 0/1 integers with x86 SIMD 回答
调整它以使用 16 位 -> 16 字节，我们需要一个洗牌，将掩码的第一个字节复制到向量的前 8 个字节，并将第二个掩码字节复制到向量的高 8 个字节。这可以用一个 SSSE3 pshufb，或者用 punpcklbw same,same + punpcklwd same,same + punpckldq same,same 来最终复制最多两个 64 位 qwords。
typedef unsigned __int128 u128;
u128 mask_to_u128_SSSE3(unsigned bitmap)
{
const __m128i shuffle = _mm_setr_epi32(0,0, 0x01010101, 0x01010101);
__m128i v = _mm_shuffle_epi8(_mm_cvtsi32_si128(bitmap), shuffle); // SSSE3 pshufb
const __m128i bitselect = _mm_setr_epi8(
1, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1U<<7,
1, 1<<1, 1<<2, 1<<3, 1<<4, 1<<5, 1<<6, 1U<<7 );
v = _mm_and_si128(v, bitselect);
v = _mm_min_epu8(v, _mm_set1_epi8(1)); // non-zero -> 1 : 0 -> 0
// return v; // if you want a SIMD vector result
alignas(16) u128 tmp;
_mm_store_si128((__m128i*)&tmp, v);
return tmp; // optimizes to movq / pextrq (with SSE4)
}
（要得到 0 / 0xFF 而不是 0 / 1，将 _mm_min_epu8 替换为 v= _mm_cmpeq_epi8(v, bitselect)。 如果你想要一个 ASCII 字符串 '0' / '1' 个字符，执行 cmpeq 和 _mm_sub_epi8(_mm_set1_epi8('0'), v)。这避免了 set1(1) 向量常量。)
Godbolt 包括测试用例。 （对于此版本和其他非 AVX-512 版本。）
# clang -O3 for Skylake
mask_to_u128_SSSE3(unsigned int):
vmovd xmm0, edi # _mm_cvtsi32_si128
vpshufb xmm0, xmm0, xmmword ptr [rip + .LCPI2_0] # xmm0 = xmm0[0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1]
vpand xmm0, xmm0, xmmword ptr [rip + .LCPI2_1] # 1<<0, 1<<1, etc.
vpminub xmm0, xmm0, xmmword ptr [rip + .LCPI2_2] # set1_epi8(1)
# done here if you return __m128i v or store the u128 to memory
vmovq rax, xmm0
vpextrq rdx, xmm0, 1
ret
BMI2 pdep：Intel 好，AMD 不好
BMI2 pdep 在拥有它的 Intel CPU 上速度很快（自 Haswell 以来），但在 AMD 上非常慢（超过十几个 uops，高延迟。）
typedef unsigned __int128 u128;
inline u128 assemble_halves(uint64_t lo, uint64_t hi) {
return ((u128)hi << 64) | lo; }
// could replace this with __m128i using _mm_set_epi64x(hi, lo) to see how that compiles
#ifdef __BMI2__
#include <immintrin.h>
auto mask_to_u128_bmi2(unsigned bitmap) {
// fast on Intel, slow on AMD
uint64_t tobytes = 0x0101010101010101ULL;
uint64_t lo = _pdep_u64(bitmap, tobytes);
uint64_t hi = _pdep_u64(bitmap>>8, tobytes);
return assemble_halves(lo, hi);
}
如果你想在标量寄存器（而不是一个向量）中得到结果，那很好，否则可能更喜欢 SSSE3 方式。
# clang -O3
mask_to_u128_bmi2(unsigned int):
movabs rcx, 72340172838076673 # 0x0101010101010101
pdep rax, rdi, rcx
shr edi, 8
pdep rdx, rdi, rcx
ret
# returns in RDX:RAX
带有魔法乘法位黑客的可移植 C++
在 x86-64 上还不错；自 Zen 以来，AMD 具有快速的 64 位乘法，而自 Nehalem 以来，Intel 拥有该功能。一些低功耗的 CPU 仍然有缓慢 imul r64, r64
这个版本 可能 对于 __uint128_t 结果是最优的，至少对于没有 BMI2 的 Intel 和 AMD 的延迟是这样，因为它避免了到 XMM 的往返寄存器。但是对于吞吐量来说，这是相当多的指令
请参阅@phuclv 在 How to create a byte out of 8 bool values (and vice versa)? 上的回答，了解乘法和反向的解释。对 mask.
unpack8bools 的算法
//#include <endian.h> // glibc / BSD
auto mask_to_u128_magic_mul(uint32_t bitmap) {
//uint64_t MAGIC = htobe64(0x0102040810204080ULL); // For MSB-first printing order in a char array after memcpy. 0x8040201008040201ULL on little-endian.
uint64_t MAGIC = 0x0102040810204080ULL; // LSB -> LSB of the u128, regardless of memory order
uint64_t MASK = 0x0101010101010101ULL;
uint64_t lo = ((MAGIC*(uint8_t)bitmap) ) >> 7;
uint64_t hi = ((MAGIC*(bitmap>>8)) ) >> 7;
return assemble_halves(lo & MASK, hi & MASK);
}
如果您要使用 memcpy 将 __uint128_t 存储到内存中，您可能需要使用 htole64(0x0102040810204080ULL);（来自 GNU / BSD <endian.h>）来控制主机字节顺序或者等价于总是将输入的低位映射到输出的最低字节，即 char 或 bool 数组的第一个元素。或者 htobe64 表示其他订单，例如用于打印。在常量而不是变量数据上使用该函数允许在编译时进行常量传播。
否则，如果你真的想要一个 128 位整数，其低位与 u16 输入的低位匹配，则乘数常数与主机字节序无关；无法访问更广泛的类型。
clang 12.0 -O3 for x86-64:
mask_to_u128_magic_mul(unsigned int):
movzx eax, dil
movabs rdx, 72624976668147840 # 0x0102040810204080
imul rax, rdx
shr rax, 7
shr edi, 8
imul rdx, rdi
shr rdx, 7
movabs rcx, 72340172838076673 # 0x0101010101010101
and rax, rcx
and rdx, rcx
ret
AVX-512
使用 AVX-512BW很容易；您可以使用掩码从重复的 0x01 常量中进行零掩码加载。
__m128i bits_to_bytes_avx512bw(unsigned mask16) {
return _mm_maskz_mov_epi8(mask16, _mm_set1_epi8(1));
// alignas(16) unsigned __int128 tmp;
// _mm_store_si128((__m128i*)&u128, v); // should optimize into vmovq / vpextrq
// return tmp;
}
或者避免内存常量（因为编译器可以做 set1(-1) -1 的零掩码绝对值。可以挂起常量设置，与set1(1)相同。
__m128i bits_to_bytes_avx512bw_noconst(unsigned mask16) {
__m128i ones = _mm_set1_epi8(-1); // extra instruction *off* the critical path
return _mm_maskz_abs_epi8(mask16, ones);
}
但请注意，如果做进一步的向量操作，maskz_mov 的结果可能可以优化为其他操作。例如 vec += maskz_mov 可以优化为合并掩码添加。但如果没有，vmovdqu8 xmm{k}{z}, xmm 需要像 vpabsb xmm{k}{z}, xmm 这样的 ALU 端口，但 vpabsb 不能 运行 在 Skylake/Ice Lake 的端口 5 上。 （来自归零寄存器的零掩码 vpsubb 可以避免可能的吞吐量问题，但是您将设置 2 个寄存器只是为了避免加载常量。在手写的 asm 中，您只需具体化 set1(1) 使用 vpcmpeqd / vpabsb 自己，如果你想避免常量的 4 字节广播负载。）
(Godbolt compiler explorer with gcc and clang -O3 -march=skylake-avx512. Clang 看穿屏蔽的vpabsb 和第一个版本一样编译，有内存常量。)
如果可以使用向量 0 / -1 而不是 0 / 1 则更好：使用 return _mm_movm_epi8(mask16)。编译为 kmovd k0, edi / vpmovm2b xmm0, k0
如果你想要像'0'或'1'这样的ASCII字符向量，你可以使用_mm_mask_blend_epi8(mask, ones, zeroes)。 （这应该比合并屏蔽添加到 set1(1) 的向量中更有效，后者需要额外的寄存器副本，也比 set1('0') 和 _mm_movm_epi8(mask16) 之间的 sub 更好，后者需要 2说明：一个将掩码变成一个向量，一个单独的 vpsubb。）
AVX2，位按 打印 顺序（MSB 在最低地址），字节按内存顺序，ASCII '0' / '1'
使用 [] 分隔符和 \t 制表符，类似这种输出格式，来自 this codereview Q&A:
[01000000] [01000010] [00001111] [00000000]
显然，如果您希望所有 16 位或 32 位 ASCII 数字都是连续的，那会更容易，并且不需要打乱输出以单独存储每个 8 字节块。在此处发布的大部分原因是它具有正确的打印顺序的洗牌和掩码常量，并且在事实证明这是问题真正想要的之后显示针对 ASCII 输出优化的版本。
使用How to perform the inverse of _mm256_movemask_epi8 (VPMOVMSKB)?，基本上是SSSE3代码的256位版本。
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <immintrin.h>
#include <string.h>
//
void binary_dump_4B_avx2(const void *input)
{
char buf[CHAR_BIT*4 + 2*4 + 3 + 1 + 1]; // bits, 4x [], 3x \t, \n, 0
buf[0] = '[';
for (int i=9 ; i<sizeof(buf) - 8; i+=11){ // GCC strangely doesn't unroll this loop
memcpy(&buf[i], "]\t[", 4); // 4-byte store as a single; we overlap the 0 later
}
__m256i v = _mm256_castps_si256(_mm256_broadcast_ss(input)); // aliasing-safe load; use _mm256_set1_epi32 if you know you have an int
const __m256i shuffle = _mm256_setr_epi64x(0x0000000000000000, // low byte first, bytes in little-endian memory order
0x0101010101010101, 0x0202020202020202, 0x0303030303030303);
v = _mm256_shuffle_epi8(v, shuffle);
// __m256i bit_mask = _mm256_set1_epi64x(0x8040201008040201); // low bits to low bytes
__m256i bit_mask = _mm256_set1_epi64x(0x0102040810204080); // MSB to lowest byte; printing order
v = _mm256_and_si256(v, bit_mask); // x & mask == mask
// v = _mm256_cmpeq_epi8(v, _mm256_setzero_si256()); // -1 / 0 bytes
// v = _mm256_add_epi8(v, _mm256_set1_epi8('1')); // '0' / '1' bytes
v = _mm256_cmpeq_epi8(v, bit_mask); // 0 / -1 bytes
v = _mm256_sub_epi8(_mm256_set1_epi8('0'), v); // '0' / '1' bytes
__m128i lo = _mm256_castsi256_si128(v);
_mm_storeu_si64(buf+1, lo);
_mm_storeh_pi((__m64*)&buf[1+8+3], _mm_castsi128_ps(lo));
// TODO?: shuffle first and last bytes into the high lane initially to allow 16-byte vextracti128 stores, with later stores overlapping to replace garbage.
__m128i hi = _mm256_extracti128_si256(v, 1);
_mm_storeu_si64(buf+1+11*2, hi);
_mm_storeh_pi((__m64*)&buf[1+11*3], _mm_castsi128_ps(hi));
// buf[32 + 2*4 + 3] = '\n';
// buf[32 + 2*4 + 3 + 1] = '[=19=]';
// fputs
memcpy(&buf[32 + 2*4 + 2], "]", 2); // including '[=19=]'
puts(buf); // appends a newline
// appending our own newline and using fputs or fwrite is probably more efficient.
}
void binary_dump(const void *input, size_t bytecount) {
}
// not shown: portable version, see Godbolt, or my or @chux's answer on the codereview question
int main(void)
{
int t = 1000000;
binary_dump_4B_avx2(&t);
binary_dump(&t, sizeof(t));
t++;
binary_dump_4B_avx2(&t);
binary_dump(&t, sizeof(t));
}
Runnable Godbolt demo 与 gcc -O3 -march=haswell.
请注意，GCC10.3 及更早版本是哑的，并复制 AND/CMPEQ 向量常量，一次作为字节，一次作为 qword。 （在这种情况下，与零进行比较会更好，或者将 OR 与倒掩码一起使用并与全一进行比较）。 GCC11.1 用 .set .LC1,.LC2 修复了这个问题，但仍然加载它两次，作为内存操作数而不是一次加载到寄存器中。 Clang 没有这些问题。
有趣的事实：clang -march=icelake-client 设法将第二部分变成 '0' 和 '1' 向量之间的 AVX-512 掩码混合，而不仅仅是 kmov 它使用广播加载，vpermb 字节洗牌，然后使用位掩码测试进入掩码。