如何让 GCC 编译器将变量划分转换为 mul(如果更快）

How to let GCC compiler turn variable-division into mul(if faster)

int a, b;
scanf("%d %d", &a, &b);
printf("%dn", (unsigned int)a/(unsigned char)b);

    ::00401C1E::  C70424 24304000          MOV DWORD PTR [ESP],403024  %d %d
    ::00401C25::  E8 36FFFFFF              CALL 00401B60               scanf
    ::00401C2A::  0FB64C24 1C              MOVZX ECX,BYTE PTR [ESP+1C]
    ::00401C2F::  8B4424 18                MOV EAX,[ESP+18]                        
    ::00401C33::  31D2                     XOR EDX,EDX                             
    ::00401C35::  F7F1                     DIV ECX                                 
    ::00401C37::  894424 04                MOV [ESP+4],EAX                         
    ::00401C3B::  C70424 2A304000          MOV DWORD PTR [ESP],40302A  %dx0A
    ::00401C42::  E8 21FFFFFF              CALL 00401B68               printf

int main() {
    uint a, s=0, i, t;
    scanf("%d", &a);
    diviuint aa = a;
    t = clock();
    for (i=0; i<1000000000; i++)
        s += i/a;
    printf("Result:%10un", s);
    printf("Time:%12un", clock()-t);
    return 0;
}

您是对的，如果在循环中不可避免地进行整数除法，那么找到乘法逆可能是值得的。 不过，GCC 和 Clang 不会使用运行时常量为您执行此操作;仅编译时常量。 对于编译器来说，在不确定是否需要的情况下，它的成本太高（代码大小），并且非编译时常量的性能增益没有那么大。 （我不相信加速总是可能的，这取决于目标微架构上的整数除法有多好。

使用乘法逆

如果您无法转换事物以将分界线从循环中拉出，并且它运行多次迭代，并且代码大小的显着增加是性能的提高（例如，您不会因隐藏div 延迟的缓存未命中而受到瓶颈），那么您可能会从对运行时常量执行编译器对编译时常量所做的操作中获得加速。

全乘法高半部分的不同移位，并且某些常量需要比其他常量更多不同的移位。 （另一种说法是某些常量的某些移位计数为零）。 因此，非编译时间常数除以乘法代码需要所有移位，并且移位计数必须是变量计数。 （在 x86 上，这比即时计数班次更昂贵）。

libdivide实现了必要的数学运算。 我认为，您可以使用它来进行 SIMD 矢量化除法，或者用于标量。 这肯定会比解包到标量并在那里进行整数除法提供很大的加速。 我自己没有用过。

（英特尔 SSE/AVX 在硬件中不执行整数除法，但提供了多种乘法和相当高效的可变计数移位指令。 对于 16 位元素，有一条指令只产生乘法的高半部分。 对于 32 位元素，有一个加宽的乘法，所以你需要一个随机的。

无论如何，您可以使用 libdivide 对该添加循环进行矢量化，最后有一个水平总和。

让div 退出循环的其他方法

for (i=0; i<1000000000; i++)
    s += i/a;

在您的示例中，通过使用uint128_t s累加器并除以循环外的a，您可能会获得更好的结果。 64位添加/ADC对非常便宜。 （但是，它不会给出相同的结果，因为整数除法会截断而不是舍入到最接近。

我认为你可以通过循环使用 i += a; tmp++ 来解释这一点，并执行s += tmp*a，以组合来自i/a相同迭代的所有添加。 因此，s += 1 * a考虑了i = [a .. a*2-1]的所有迭代。 显然，这只是一个微不足道的例子，通常不可能更有效地循环。 这个问题是题外话，但无论如何都值得一提：在尝试更快地完成完全相同的事情之前，通过重新构建代码或利用一些数学来寻找大的优化。 说到数学，你可以在这里使用sum(0..n) = n * (n+1) / 2公式，因为我们可以从a*1 + a*2 + a*3 ... a*max中a因素。 我在这里可能有一个 off-by-one，但我相信封闭形式的简单常量时间计算将给出与任何a循环相同的答案：

uint32_t n = 1000000000 / a;
uint32_t s = a * n*(n+1)/2 + 1000000000 % a;

如果您只需要循环中的i/a，那么

// another optimization for an unlikely case
for (uint32_t i=0, remainder=0, i_over_a=0 ; i < n ; i++) {
    // use i_over_a
    ++remainder;
    if (remainder == a) {        // if you don't need the remainder in the loop, it could save an insn or two to count down from a to 0 instead of up from 0 to a, e.g. on x86.  But then you need a clever variable name other than remainder.
        remainder = 0;
        ++i_over_a;
    }
}

同样，这不太可能：它仅在将循环计数器除以常量时才有效。 但是，它应该运行良好。 要么a很大，所以分支错误预测将不常见，要么a（希望）足够小，以便一个好的分支预测器以一种方式识别a-1分支的重复模式，然后以另一种方式识别 1 个分支。 最坏情况下的a值可能是 33 或 65 或更高，具体取决于微体系结构。 无分支asm可能是可能的，但不值得。 例如，使用附加进位和有条件的归零移动来处理++i_over_a。（例如 x86 伪代码cmp a-1, remainder/cmovc remainder, 0/adc i_over_a, 0 。 b（下面）条件刚好CF==1，与c（携带）条件相同。 无分支 asm 将通过从 a 递减到 0 来简化。 （CMOV不需要归零的注册，并且可以在注册表中a而不是a-1））

printf("%x %xn", 0x10/0x9, 0x30/0x9);
// prints: 1 5