在 C/C++ 中获得正模的最快方法

Question

通常在我的内部循环中，我需要以“环绕”方式对数组进行索引，因此（例如）如果数组大小为 100 并且我的代码要求元素 -2，则应为其指定元素 98 . 在 Python 等许多高级语言中，可以简单地使用my_array[index % array_size] 来完成此操作，但由于某种原因，C 的整数算术（通常）向零舍入而不是始终向下舍入，因此它的模运算符在给定时返回负结果否定的第一个参数。

我通常知道index 不会小于-array_size，在这些情况下我只做my_array[(index + array_size) % array_size]。但是，有时这无法保证，对于这些情况，我想知道实现始终为正的模函数的最快方法。有几种“聪明”的方法可以在没有分支的情况下做到这一点，例如

inline int positive_modulo(int i, int n) {
    return (n + (i % n)) % n;
}

或

inline int positive_modulo(int i, int n) {
    return (i % n) + (n * (i < 0));
}

当然，我可以分析这些以找出我的系统上最快的，但我不禁担心我可能错过了更好的一个，或者我的机器上的快速可能在不同的机器上很慢.

那么有没有一种标准的方法可以做到这一点，或者我错过了一些可能是最快的方法？

另外，我知道这可能是一厢情愿，但如果有一种方法可以自动矢量化，那就太棒了。

Answer 1

我学习的标准方法是

inline int positive_modulo(int i, int n) {
    return (i % n + n) % n;
}

这个函数本质上是你的第一个没有abs 的变体（事实上，它会返回错误的结果）。如果优化编译器能够识别这种模式并将其编译为计算“无符号模”的机器代码，我不会感到惊讶。

编辑：

继续您的第二个变体：首先，它也包含一个错误——n < 0 应该是i < 0。

这个变体可能看起来不像分支，但在很多架构上，i < 0 会编译成条件跳转。在任何情况下，将(n * (i < 0)) 替换为i < 0? n: 0 至少会一样快，从而避免了乘法；此外，它“更干净”，因为它避免将 bool 重新解释为 int。

至于这两个变体中哪一个更快，这可能取决于编译器和处理器架构——对这两个变体计时，然后看看。不过，我认为没有比这两种变体更快的方法了。

Answer 2

以二的幂为模，以下工作（假设二进制补码表示）：

return i & (n-1);

Answer 3

大多数时候，编译器非常擅长优化您的代码，因此通常最好让您的代码保持可读性（让编译器和其他开发人员都知道您在做什么）。

由于您的数组大小始终为正，我建议您将商定义为unsigned。编译器会将小的 if/else 块优化为没有分支的条件指令：

unsigned modulo( int value, unsigned m) {
    int mod = value % (int)m;
    if (mod < 0) {
        mod += m;
    }
    return mod;
}

这会创建一个非常小的没有分支的函数：

modulo(int, unsigned int):
        mov     eax, edi
        cdq
        idiv    esi
        add     esi, edx
        mov     eax, edx
        test    edx, edx
        cmovs   eax, esi
        ret

例如modulo(-5, 7) 返回2。

不幸的是，由于商是未知的，它们必须执行整数除法，这与其他整数运算相比有点慢。如果您知道数组的大小是 2 的幂，我建议将这些函数定义保留在头文件中，以便编译器可以将它们优化为更有效的函数。这里是函数unsigned modulo256(int v) { return modulo(v,256); }：

modulo256(int):                          # @modulo256(int)
        mov     edx, edi
        sar     edx, 31
        shr     edx, 24
        lea     eax, [rdi+rdx]
        movzx   eax, al
        sub     eax, edx
        lea     edx, [rax+256]
        test    eax, eax
        cmovs   eax, edx
        ret

查看程序集：https://gcc.godbolt.org/z/DG7jMw

查看与投票最多的答案的比较：http://quick-bench.com/oJbVwLr9G5HJb0oRaYpQOCec4E4

编辑：事实证明，Clang 能够在没有任何条件移动指令的情况下生成一个函数（这比常规算术运算成本更高）。这种差异在一般情况下完全可以忽略不计，因为积分除法大约需要总时间的 70%。

基本上，Clang 向右移动value 以将其符号位扩展到m 的整个宽度（即为负时为0xffffffff，否则为0），用于屏蔽mod + m 中的第二个操作数.

unsigned modulo (int value, unsigned m) {
    int mod = value % (int)m;
    m &= mod >> std::numeric_limits<int>::digits;
    return mod + m;
}

Answer 4

使用二进制补码符号位传播获取可选加数的老式方法：

int positive_mod(int i, int m)
{
    /* constexpr */ int shift = CHAR_BIT*sizeof i - 1;
    int r = i%m;
    return r+ (r>>shift & m);
}

Answer 5

在 C/C++ 中获得正模的最快方法

下面快吗？ - 可能不如其他人快，但对所有人来说都简单且功能正确¹a,b -- 与其他人不同。

int modulo_Euclidean(int a, int b) {
  int m = a % b;
  if (m < 0) {
    // m += (b < 0) ? -b : b; // avoid this form: -b is UB when b == INT_MIN
    m = (b < 0) ? m - b : m + b;
  }
  return m;
}

---

其他各种答案都有mod(a,b) 的弱点，尤其是在b < 0 时。

请参阅 Euclidean division 了解有关 b < 0 的想法

---

inline int positive_modulo(int i, int n) {
    return (i % n + n) % n;
}

当i % n + n 溢出时失败（想想大i, n） - 未定义的行为。

---

return i & (n-1);

依赖 n 作为 2 的幂。 （公平地说，答案确实提到了这一点。）

---

int positive_mod(int i, int n)
{
    /* constexpr */ int shift = CHAR_BIT*sizeof i - 1;
    int m = i%n;
    return m+ (m>>shift & n);
}

n < 0 时经常失败。 e、g、positive_mod(-2,-3) --> -5

---

int32_t positive_modulo(int32_t number, int32_t modulo) {
    return (number + ((int64_t)modulo << 32)) % modulo;
}

强制使用 2 个整数宽度。 （公平地说，答案确实提到了这一点。）
modulo < 0 失败。 positive_modulo(2, -3) --> -1.

---

inline int positive_modulo(int i, int n) {
    int tmp = i % n;
    return tmp ? i >= 0 ? tmp : tmp + n : 0;
}

n < 0 时经常失败。 e、g、positive_modulo(-2,-3) --> -5

---

¹ 例外：在 C 中，a/b 溢出时未定义 a%b，如 a/0 或 INT_MIN/-1。

Answer 6

如果您有能力升级到更大的类型（并对更大的类型进行模运算），则此代码只进行一次模运算，如果：

int32_t positive_modulo(int32_t number, int32_t modulo) {
    return (number + ((int64_t)modulo << 32)) % modulo;
}

Answer 7

如果你想避免所有条件路径（包括上面生成的条件移动，（例如如果你需要这段代码进行向量化，或者在恒定时间内运行），你可以使用符号位作为掩码：

unsigned modulo(int value, unsigned m) {
  int shift_width = sizeof(int) * 8 - 1;
  int tweak = (value >> shift_width);
  int mod = ((value - tweak) % (int) m) + tweak;
  mod += (tweak & m);
  return mod;
}

这里是quickbench results 你可以看到在 gcc 上它在通用情况下更好。对于 clang，它在通用情况下的速度相同，因为在通用情况下 clang 生成 分支免费代码。无论如何，该技术很有用，因为不能总是依赖编译器来产生特定的优化，您可能不得不手动滚动它以获得矢量代码。

Answer 8

您也可以使用array[(i+array_size*N) % array_size]，其中 N 是足够大的整数以保证正论点，但又足够小以不会溢出。

当array_size 是常数时，有一些技术可以计算模数而不用除法。除了两种方法的幂之外，可以计算位组的加权和乘以 2^i % n，其中 i 是每个组中的最低有效位：

例如32位整数0xaabbccdd % 100 = dd + cc*[2]56 + bb*[655]36 + aa*[167772]16，最大范围为(1+56+36+16)*255 = 27795。通过重复应用和不同的细分，可以将操作减少到几个条件减法。

常见的做法还包括用 2^32 / n 的倒数近似除法，这通常可以处理相当大范围的参数。

 i - ((i * 655)>>16)*100; // (gives 100*n % 100 == 100 requiring adjusting...)

Answer 9

你的第二个例子比第一个好。乘法比 if/else 操作更复杂，所以使用这个：

inline int positive_modulo(int i, int n) {
    int tmp = i % n;
    return tmp ? i >= 0 ? tmp : tmp + n : 0;
}