Question

我对“扩展位”的快速方法很感兴趣，可以定义如下：

让 B 为 n 位的二进制数，即 B \ {0,1} ^ n
让 P 成为 B 中所有1 / true位的位置，即1 << p[i] & B == 1和| P | = ķ
对于另一个给定的数字， A \ {0,1} ^ k ，让 Ap 成为<扩展形式的< em> A 给定 B ，例如Ap[j] == A[j] << p[j]。
“位扩展”的结果是 Ap 。

几个例子：

鉴于 B ：00 1 0 111 0， A ：0110，然后 Ap < / em>应为00 0 0 110 0

鉴于 B ： 1 00 1 1 00 1 ， A ：1101，然后 Ap 应 1 00 1 0 00 1

以下是一个简单的算法，但我不禁感到有一种更快/更容易的方法。

unsigned int expand_bits(unsigned int A, unsigned int B, int n) { int k = popcount(B); // cuda function, but there are good methods for this unsigned int Ap = 0; int j = k-1; // Starting at the most significant bit, for (int i = n - 1; i >= 0; --i) { Ap <<= 1; // if B is 1, add the value at A[j] to Ap, decrement j. if (B & (1 << i)) { Ap += (A >> j--) & 1; } } return Ap; }

Answer 1

问题似乎是要求对BMI2指令PDEP进行CUDA仿真，该指令采用源操作数a，并根据掩码的1位位置存放其位b。对于当前发运的GPU上的相同或类似操作，没有硬件支持;也就是说，包括Maxwell架构。

我假设，基于给出的两个示例，掩码b通常是稀疏的，并且我们可以通过仅迭代b的1位来最小化工作。这可能会导致GPU上出现分歧，但在不知道特定用例的情况下，性能的确切权衡是未知的。就目前而言，我假设掩盖b中稀疏性的利用与分歧的负面影响相比，对性能有更强的积极影响。

在下面的仿真代码中，我减少了使用可能“昂贵”的移位操作，而主要依赖于简单的ALU指令。在各种GPU上，执行移位指令的吞吐量低于简单整数运算。我通过代码保留了单个移位关闭关键路径，以避免被算术单元限制执行。如果需要，可以通过添加替换表达式1U << i：引入在循环之前初始化为m的变量1，并在每次循环时加倍。

基本思想是依次隔离每个1位掩码b（从最低端开始），并将其与 i -th位的值相隔离a，并将结果合并到展开的目标中。在使用b的1位后，我们将其从掩码中删除，并迭代直到掩码变为零。

为了避免将a的 i 位移位，我们只需将其隔离，然后通过简单的否定将其值复制到所有更重要的位，利用整数的二进制补码表示。

/* Emulate PDEP: deposit the bits of 'a' (starting with the least significant 
   bit) at the positions indicated by the set bits of the mask stored in 'b'.
*/
__device__ unsigned int my_pdep (unsigned int a, unsigned int b)
{
    unsigned int l, s, r = 0;
    int i;
    for (i = 0; b; i++) { // iterate over 1-bits in mask, until mask becomes 0
        l = b & (0 - b); // extract mask's least significant 1-bit
        b = b ^ l; // clear mask's least significant 1-bit
        s = 0 - (a & (1U << i)); // spread i-th bit of 'a' to more signif. bits
        r = r | (l & s); // deposit i-th bit of 'a' at position of mask's 1-bit
    }
    return r;
}

上面提到的没有任何移位操作的变体如下所示：

/* Emulate PDEP: deposit the bits of 'a' (starting with the least significant 
   bit) at the positions indicated by the set bits of the mask stored in 'b'.
*/
__device__ unsigned int my_pdep (unsigned int a, unsigned int b)
{
    unsigned int l, s, r = 0, m = 1;
    while (b) { // iterate over 1-bits in mask, until mask becomes 0
        l = b & (0 - b); // extract mask's least significant 1-bit
        b = b ^ l; // clear mask's least significant 1-bit
        s = 0 - (a & m); // spread i-th bit of 'a' to more significant bits
        r = r | (l & s); // deposit i-th bit of 'a' at position of mask's 1-bit
        m = m + m; // mask for next bit of 'a'
    }
    return r;
}

在下面的评论中，@ Evgeny Kluev指出chessprogramming网站上的无转移PDEP仿真，看起来可能更快比我上面的两个实现中的任何一个;这似乎值得一试。

bit twiddle help：扩展位以跟随给定的位掩码

1 个答案: