How can I optimize my Number Theoretic Transform (NTT) and modular arithmetic for faster computation, especially with very large numbers (e.g., over 12000 bits)?

Modular arithmetics and NTT (finite field DFT) optimizations

Problem Statement

I wanted to use NTT for fast squaring (see Fast bignum square computation), but the result is slow even for really big numbers .. more than 12000 bits.

So my question is:

1. Is there a way to optimize my NTT transform? I did not mean to speed it by parallelism (threads); this is low-level layer only.


2. Is there a way to speed up my modular arithmetics?

This is my (already optimized) source code in C for NTT (it's complete and 100% working in C whitout any need for third-party libs and should also be thread-safe. Beware the source array is used as a temporary!!!, Also it cannot transform the array to itself).

Optimized Solution

1. Using Precomputed Powers: Precompute and store the powers of W and iW (the primitive root of unity and its inverse) to avoid recalculating them during the NTT process. This can significantly reduce the number of multiplications and divisions, leading to faster computations.
2. Unrolling Loops: Unroll the loops in the NTT algorithm to reduce the overhead associated with loop iterations. This can improve performance by reducing the number of branch instructions.
3. Optimizing Modular Arithmetic: Use bitwise operations and assembly language to implement modular arithmetic operations (addition, subtraction, multiplication, and exponentiation) efficiently. This can eliminate unnecessary branching and conditional statements, resulting in faster execution.

Example Implementation

Here's an example of an optimized NTT implementation in C using precomputed powers and bitwise operations:

class NTT {
public:
    NTT() {
        // Initialize constants
        p = 0xc0000001;
        W = modpow(2, 0x30000000 / n);
        iW = modpow(2, p - 1 - 0x30000000 / n);
        rN = modpow(n, p - 2);
        NN = n >> 1;

        // Precompute W and iW powers
        WW = new uint32_t[n];
        iWW = new uint32_t[n];
        WW[0] = 1;
        iWW[0] = 1;
        for (uint32_t i = 1; i < n; i++) {
            WW[i] = modmul(WW[i - 1], W);
            iWW[i] = modmul(iWW[i - 1], iW);
        }
    }

    void NTT(uint32_t *dst, uint32_t *src, uint32_t n) {
        if (n > 0) {
            // Reorder even, odd elements
            for (uint32_t i = 0, j = 0; i < NN; i++, j += 2) {
                dst[i] = src[j];
            }
            for (j = 1; i < n; i++, j += 2) {
                dst[i] = src[j];
            }

            // Recursive NTT
            NTT(src, dst, NN);  // Even
            NTT(src + NN, dst + NN, NN);  // Odd

            // Restore results
            for (uint32_t i = 0, j = NN; i < NN; i++, j++) {
                uint32_t a0 = src[i];
                uint32_t a1 = modmul(src[j], WW[i]);
                dst[i] = modadd(a0, a1);
                dst[j] = modsub(a0, a1);
            }
        }
    }

private:
    uint32_t p, n, NN, W, iW, rN;
    uint32_t *WW, *iWW;

    // Modular arithmetic operations
    inline uint32_t modadd(uint32_t a, uint32_t b) {
        uint32_t d = a + b;
        if (d >= p) d -= p;
        return d;
    }

    inline uint32_t modsub(uint32_t a, uint32_t b) {
        uint32_t d = a - b;
        if (d > a) d += p;
        return d;
    }

    inline uint32_t modmul(uint32_t a, uint32_t b) {
        uint32_t m = (uint64_t)a * b;
        return m - (p * (m / p));
    }

    inline uint32_t modpow(uint32_t a, uint32_t b) {
        if (b == 0) return 1;
        uint32_t t = modpow(a, b / 2);
        t = modmul(t, t);
        if (b &amp; 1) t = modmul(t, a);
        return t;
    }
};

Additional Tips

• Use a higher-level language that supports bitwise operations and inline assembly, such as C .
• Use a profiler to identify the bottlenecks in your code and target them for optimization.
• Consider parallelizing the NTT algorithm using multiple threads or SIMD instructions.

The above is the detailed content of How can I optimize my Number Theoretic Transform (NTT) and modular arithmetic for faster computation, especially with very large numbers (e.g., over 12000 bits)?. For more information, please follow other related articles on the PHP Chinese website!