Kiểm tra phân chia nhanh hơn toán tử%?

Tôi nhận thấy một điều tò mò trên máy tính của tôi. ^* Bài kiểm tra chia nhỏ viết tay nhanh hơn đáng kể so với người %vận hành. Hãy xem xét ví dụ tối thiểu:

^{* _{Máy xâu chuỗi AMD Ryzen 2990WX, GCC 9.2.0}}

static int divisible_ui_p(unsigned int m, unsigned int a)
{
    if (m <= a) {
        if (m == a) {
            return 1;
        }

        return 0;
    }

    m += a;

    m >>= __builtin_ctz(m);

    return divisible_ui_p(m, a);
}

Ví dụ được giới hạn bởi lẻ avà m > 0. Tuy nhiên, nó có thể dễ dàng khái quát cho tất cả avà m. Mã chỉ chuyển đổi phân chia thành một loạt các bổ sung.

Bây giờ hãy xem xét chương trình thử nghiệm được biên dịch với -std=c99 -march=native -O3:

    for (unsigned int a = 1; a < 100000; a += 2) {
        for (unsigned int m = 1; m < 100000; m += 1) {
#if 1
            volatile int r = divisible_ui_p(m, a);
#else
            volatile int r = (m % a == 0);
#endif
        }
    }

... và kết quả trên máy tính của tôi:

| implementation     | time [secs] |
|--------------------|-------------|
| divisible_ui_p     |    8.52user |
| builtin % operator |   17.61user |

Do đó nhanh hơn 2 lần.

Câu hỏi: Bạn có thể cho tôi biết mã hoạt động trên máy của bạn như thế nào không? Có bỏ lỡ cơ hội tối ưu hóa trong GCC không? Bạn có thể làm bài kiểm tra này thậm chí nhanh hơn?

CẬP NHẬT: Theo yêu cầu, đây là một ví dụ tái sản xuất tối thiểu:

#include <assert.h>

static int divisible_ui_p(unsigned int m, unsigned int a)
{
    if (m <= a) {
        if (m == a) {
            return 1;
        }

        return 0;
    }

    m += a;

    m >>= __builtin_ctz(m);

    return divisible_ui_p(m, a);
}

int main()
{
    for (unsigned int a = 1; a < 100000; a += 2) {
        for (unsigned int m = 1; m < 100000; m += 1) {
            assert(divisible_ui_p(m, a) == (m % a == 0));
#if 1
            volatile int r = divisible_ui_p(m, a);
#else
            volatile int r = (m % a == 0);
#endif
        }
    }

    return 0;
}

được biên dịch với gcc -std=c99 -march=native -O3 -DNDEBUGtrên AMD Ryzen Threadripper 2990WX với

gcc --version
gcc (Gentoo 9.2.0-r2 p3) 9.2.0

CẬP NHẬT2: Theo yêu cầu, phiên bản có thể xử lý bất kỳ avà m(nếu bạn cũng muốn tránh tràn số nguyên, thử nghiệm phải được thực hiện với loại số nguyên dài gấp đôi số nguyên đầu vào):

int divisible_ui_p(unsigned int m, unsigned int a)
{
#if 1
    /* handles even a */
    int alpha = __builtin_ctz(a);

    if (alpha) {
        if (__builtin_ctz(m) < alpha) {
            return 0;
        }

        a >>= alpha;
    }
#endif

    while (m > a) {
        m += a;
        m >>= __builtin_ctz(m);
    }

    if (m == a) {
        return 1;
    }

#if 1
    /* ensures that 0 is divisible by anything */
    if (m == 0) {
        return 1;
    }
#endif

    return 0;
}

Những gì bạn đang làm được gọi là giảm sức mạnh: thay thế một hoạt động đắt tiền bằng một loạt các hoạt động giá rẻ.

Hướng dẫn mod trên nhiều CPU rất chậm, vì trước đây nó không được thử nghiệm trong một số điểm chuẩn chung và do đó các nhà thiết kế đã tối ưu hóa các hướng dẫn khác thay thế. Thuật toán này sẽ hoạt động kém hơn nếu nó phải thực hiện nhiều lần lặp và %sẽ hoạt động tốt hơn trên CPU khi nó chỉ cần hai chu kỳ xung nhịp.

Cuối cùng, hãy lưu ý rằng có nhiều phím tắt để lấy phần còn lại của phép chia theo các hằng số cụ thể. (Mặc dù trình biên dịch thường sẽ chăm sóc điều này cho bạn.)

Tôi sẽ tự trả lời câu hỏi của mình. Dường như tôi trở thành nạn nhân của dự đoán chi nhánh. Kích thước lẫn nhau của các toán hạng dường như không quan trọng, chỉ có thứ tự của chúng.

Hãy xem xét việc thực hiện sau đây

int divisible_ui_p(unsigned int m, unsigned int a)
{
    while (m > a) {
        m += a;
        m >>= __builtin_ctz(m);
    }

    if (m == a) {
        return 1;
    }

    return 0;
}

và các mảng

unsigned int A[100000/2];
unsigned int M[100000-1];

for (unsigned int a = 1; a < 100000; a += 2) {
    A[a/2] = a;
}
for (unsigned int m = 1; m < 100000; m += 1) {
    M[m-1] = m;
}

được / không được xáo trộn bằng cách sử dụng chức năng xáo trộn .

Không xáo trộn, kết quả vẫn là

| implementation     | time [secs] |
|--------------------|-------------|
| divisible_ui_p     |    8.56user |
| builtin % operator |   17.59user |

Tuy nhiên, một khi tôi xáo trộn các mảng này, kết quả sẽ khác

| implementation     | time [secs] |
|--------------------|-------------|
| divisible_ui_p     |   31.34user |
| builtin % operator |   17.53user |