Kevin Meier's questions

我有这个代码：

__attribute__((target("avx2")))
size_t lower_than_16(const uint64_t values[16], uint64_t x)
{
    __m256i vx = _mm256_set1_epi64x(x);
    __m256i vvals1 = _mm256_loadu_si256((__m256i*)&values[0]);
    __m256i vvals2 = _mm256_loadu_si256((__m256i*)&values[4]);
    __m256i vvals3 = _mm256_loadu_si256((__m256i*)&values[8]);
    __m256i vvals4 = _mm256_loadu_si256((__m256i*)&values[12]);
    __m256i vcmp1  = _mm256_cmpgt_epi64(vvals1, vx);
    __m256i vcmp2  = _mm256_cmpgt_epi64(vvals2, vx);
    __m256i vcmp3  = _mm256_cmpgt_epi64(vvals3, vx);
    __m256i vcmp4  = _mm256_cmpgt_epi64(vvals4, vx);
    const int mask = (_mm256_movemask_pd((__m256d)vcmp1)) |
                    (_mm256_movemask_pd((__m256d)vcmp2) << 4) |
                    (_mm256_movemask_pd((__m256d)vcmp3) << 8) |
                    (_mm256_movemask_pd((__m256d)vcmp4) << 12);
    if (mask != 0xFFFF) {
        // found
        return __builtin_ctz(~mask);
    }

    return 16;
}

基本上，给定一个包含 16 个元素的数组，我想找到第一个为真的元素的索引values[i] <= x。如果找不到元素，则返回 16。

这是使用 AVX2 实现的，我使用 gcc 作为编译器。汇编代码如下：

lower_than_16:
        vmovq   xmm2, rsi
        vmovdqu ymm1, YMMWORD PTR [rdi]
        vpbroadcastq    ymm0, xmm2
        vpcmpgtq        ymm1, ymm1, ymm0
        vmovmskpd       esi, ymm1
        vmovdqu ymm1, YMMWORD PTR [rdi+32]
        vpcmpgtq        ymm1, ymm1, ymm0
        vmovmskpd       eax, ymm1
        vmovdqu ymm1, YMMWORD PTR [rdi+64]
        sal     eax, 4
        vpcmpgtq        ymm1, ymm1, ymm0
        vmovmskpd       ecx, ymm1
        vmovdqu ymm1, YMMWORD PTR [rdi+96]
        sal     ecx, 8
        vpcmpgtq        ymm0, ymm1, ymm0
        or      eax, ecx
        or      eax, esi
        vmovmskpd       edx, ymm0
        sal     edx, 12
        or      eax, edx
        mov     edx, 16
        cmp     eax, 65535
        je      .L1
        not     eax
        xor     edx, edx
        rep bsf edx, eax
.L1:
        mov     rax, rdx
        vzeroupper
        ret

（可在此处查看： https: //godbolt.org/z/7eea39Gqv）

我看到gcc每次展开迭代都使用相同的寄存器。但是，如果每次展开迭代都使用不同的寄存器，效率会不会更高ymm，因为这样 CPU 就可以更轻松地并行执行这 4 个独立的比较？我知道 CPU 会进行一些寄存器重命名，但它是否足够智能，不会强制这些指令不并行执行？或者，如果使用不同的寄存器，会不会更容易/更高效？

多谢

假设我在 C 中有一个这样的数组：

static volatile bool my_array[128] = {0};

最重要的是，我有 128 个线程，每个线程在完成时都会写入不同的索引。true

这会产生一些问题吗？在 x64 上写入单个字节不会影响周围的字节，对吗？

我只是问，因为我不确定CPU/内存控制器/等是否总是读取8（或4）字节，然后写入它们。这会产生一些奇怪的竞争条件。

多谢

如何std::sort用于对固定大小的数组进行排序（例如typedef XXX char[16]）？我尝试了一些方法，但似乎不起作用。例如我当前的代码如下所示：

#include <iostream>
#include <algorithm>
#include <cstring>

typedef char t_name[16];

bool compareNames(const t_name& name1, const t_name& name2) {
    return strcmp(name1, name2) < 0;
}

int main() {
    t_name names[] = {
        "bruno",
        "karl",
        "adrian",
        "yanick"
    };

    int numNames = sizeof(names) / sizeof(names[0]);

    std::sort(names, names + numNames, compareNames);

    for (int i = 0; i < numNames; i++) {
        std::cout << names[i] << std::endl;
    }

    return 0;
}

不幸的是，这段代码无法编译。可能是因为普通赋值不适用于数组类型。错误（不太可读）可以在这里看到： https ://godbolt.org/z/Ms54P7ozj

也许有人知道如何实现这一点？不幸的是，我无法控制要排序的数组类型，因此无法更改。