Question

我正在寻找一种快速方法来有效地计算（a⋅b）模n（在数学意义上）{类型为a的{1}}，b，n。我可以使用uint64_t甚至n!=0等前提条件。

请注意，C表达式a<n && b<n不会删除它，因为产品被截断为64位。我正在寻找(a*b)%n，除了我没有(uint64_t)(((uint128_t)a*b)%n)（我知道，在Visual C ++中）。

我正在使用Visual C ++（最好）或GCC / clang内部，充分利用x86-64平台上可用的底层硬件;或者如果对于便携式uint128_t功能无法做到这一点。

Answer 1

好的，这个（未经测试）

modmul:
; rcx = a
; rdx = b
; r8 = n
mov rax, rdx
mul rcx
div r8
mov rax, rdx
ret

前提条件是a * b / n <= ~0ULL，否则会出现除法错误。这是一个比a < n && m < n稍微不那么严格的条件，只要另一个足够小，其中一个可以大于n。

不幸的是，它必须单独组装和链接，因为MSVC不支持64位目标的内联asm。

它仍然很慢，真正的问题是64位div，这可能需要近百个周期（严重的是，例如Nehalem上最多90个周期）。

Answer 2

你可以用传统/加/减的老式方式做到这一点。以下代码假定为a＆lt; n和
n＆lt; uint64_t mulmod(uint64_t a, uint64_t b, uint64_t n) { uint64_t rv = 0; while (b) { if (b&1) if ((rv += a) >= n) rv -= n; if ((a += a) >= n) a -= n; b >>= 1; } return rv; } 2 ⁶³（所以事情不会溢出）：

while (a && b)

如果a可能是n的因素，您可以使用a代替短路。如果n不是n的因素，则会稍微缓慢（更多比较和可能正确预测的分支）。

如果你真的，绝对需要最后一位（允许uint64_t mulmod(uint64_t a, uint64_t b, uint64_t n) { uint64_t rv = 0; while (b) { if (b&1) { rv += a; if (rv < a || rv >= n) rv -= n; } uint64_t t = a; a += a; if (a < t || a >= n) a -= n; b >>= 1; } return rv; }最多2 ⁶⁴ -1），你可以使用：

inline uint64_t mulmod(uint64_t a, uint64_t b, uint64_t n) {
    uint64_t rv;
    asm ("mul %3" : "=d"(rv), "=a"(a) : "1"(a), "r"(b));
    asm ("div %4" : "=d"(rv), "=a"(a) : "0"(rv), "1"(a), "r"(n));
    return rv;
}

或者，只需使用GCC内部函数来访问基础x64指令：

{{1}}

64位div指令确实慢，但是循环可能实际上更快。你需要描述一下以确定。

Answer 3

7 年后，我在 Visual Studio 2019 中找到了一个解决方案

#include <stdint.h>
#include <intrin.h>
#pragma intrinsic(_umul128)
#pragma intrinsic(_udiv128)

// compute (a*b)%n with 128-bit intermediary result
// assumes n>0  and  a*b < n * 2**64 (always the case when a<=n || b<=n )
inline uint64_t mulmod(uint64_t a, uint64_t b, uint64_t n) {
  uint64_t r, s = _umul128(a, b, &r);
  (void)_udiv128(r, s, n, &r);
  return r;
}

// compute (a*b)%n with 128-bit intermediary result
// assumes n>0, works including if a*b >= n * 2**64
inline uint64_t mulmod1(uint64_t a, uint64_t b, uint64_t n) {
  uint64_t r, s = _umul128(a % n, b, &r);
  (void)_udiv128(r, s, n, &r);
  return r;
}

Answer 4

此内在函数名为__mul128。

typedef unsigned long long BIG;

// handles only the "hard" case when high bit of n is set
BIG shl_mod( BIG v, BIG n, int by )
{
    if (v > n) v -= n;
    while (by--) {
        if (v > (n-v))
            v -= n-v;
        else
            v <<= 1;
    }
    return v;
}

现在您可以使用shl_mod(B, n, 64)

Answer 5

没有内联组件很糟糕。无论如何，函数调用开销实际上非常小。参数在易失性寄存器中传递，不需要清理。

我没有汇编程序，x64目标不支持__asm，所以我别无选择，只能自己从操作码中“汇编”我的函数。

显然这取决于。我正在使用mpir（gmp）作为参考，以显示该函数产生正确的结果。


#include "stdafx.h"

// mulmod64(a, b, m) == (a * b) % m
typedef uint64_t(__cdecl *mulmod64_fnptr_t)(uint64_t a, uint64_t b, uint64_t m);

uint8_t mulmod64_opcodes[] = {
    0x48, 0x89, 0xC8, // mov rax, rcx
    0x48, 0xF7, 0xE2, // mul rdx
    0x4C, 0x89, 0xC1, // mov rcx, r8
    0x48, 0xF7, 0xF1, // div rcx
    0x48, 0x89, 0xD0, // mov rax,rdx
    0xC3              // ret
};

mulmod64_fnptr_t mulmod64_fnptr;

void init() {
    DWORD dwOldProtect;
    VirtualProtect(
        &mulmod64_opcodes,
        sizeof(mulmod64_opcodes),
        PAGE_EXECUTE_READWRITE,
        &dwOldProtect);
    // NOTE: reinterpret byte array as a function pointer
    mulmod64_fnptr = (mulmod64_fnptr_t)(void*)mulmod64_opcodes;
}

int main() {
    init();

    uint64_t a64 = 2139018971924123ull;
    uint64_t b64 = 1239485798578921ull;
    uint64_t m64 = 8975489368910167ull;

    // reference code
    mpz_t a, b, c, m, r;
    mpz_inits(a, b, c, m, r, NULL);
    mpz_set_ui(a, a64);
    mpz_set_ui(b, b64);
    mpz_set_ui(m, m64);
    mpz_mul(c, a, b);
    mpz_mod(r, c, m);

    gmp_printf("(%Zd * %Zd) mod %Zd = %Zd\n", a, b, m, r);

    // using mulmod64
    uint64_t r64 = mulmod64_fnptr(a64, b64, m64);
    printf("(%llu * %llu) mod %llu = %llu\n", a64, b64, m64, r64);
    return 0;
}

在x86-64平台上计算C（++）中64位无符号参数的（a * b）％m FAST？

5 个答案: