Tôi có thể gợi ý trình tối ưu hóa bằng cách đưa ra phạm vi của một số nguyên không?

Tôi đang sử dụng một intloại để lưu trữ một giá trị. Theo ngữ nghĩa của chương trình, giá trị luôn thay đổi trong một phạm vi rất nhỏ (0 - 36) và int(không phải a char) chỉ được sử dụng vì hiệu quả của CPU.

Có vẻ như nhiều tối ưu hóa số học đặc biệt có thể được thực hiện trên một phạm vi số nguyên nhỏ như vậy. Nhiều lệnh gọi hàm trên các số nguyên đó có thể được tối ưu hóa thành một tập hợp nhỏ các phép toán "ma thuật" và một số hàm thậm chí có thể được tối ưu hóa để tra cứu bảng.

Vì vậy, có thể nói với trình biên dịch rằng điều này intluôn nằm trong phạm vi nhỏ đó và liệu trình biên dịch có thể thực hiện những tối ưu hóa đó không?

Vâng, nó là có thể. Ví dụ: đối với gccbạn có thể sử dụng __builtin_unreachableđể báo cho trình biên dịch về các điều kiện không thể, như vậy:

if (value < 0 || value > 36) __builtin_unreachable();

Chúng ta có thể gói các điều kiện trên trong một macro:

#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)

Và sử dụng nó như vậy:

assume(x >= 0 && x <= 10);

Như bạn có thể thấy , gccthực hiện tối ưu hóa dựa trên thông tin này:

#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)

int func(int x){
    assume(x >=0 && x <= 10);

    if (x > 11){
        return 2;
    }
    else{
        return 17;
    }
}

Sản xuất:

func(int):
    mov     eax, 17
    ret

Tuy nhiên, một nhược điểm là nếu mã của bạn từng phá vỡ các giả định như vậy, bạn sẽ có hành vi không xác định .

Nó không thông báo cho bạn khi điều này xảy ra, ngay cả trong các bản dựng gỡ lỗi. Để gỡ lỗi / kiểm tra / bắt lỗi với các giả định dễ dàng hơn, bạn có thể sử dụng macro giả định / xác nhận kết hợp (tín dụng cho @David Z), như thế này:

#if defined(NDEBUG)
#define assume(cond) do { if (!(cond)) __builtin_unreachable(); } while (0)
#else
#include <cassert>
#define assume(cond) assert(cond)
#endif

Trong các bản dựng gỡ lỗi ( NDEBUG không được xác định), nó hoạt động như một chương trình thông assertbáo lỗi và in thông thường abort, và trong bản phát hành, nó sử dụng một giả định, tạo ra mã được tối ưu hóa.

Tuy nhiên, lưu ý rằng nó không thay thế cho thường xuyên assert- condvẫn còn trong các bản dựng phát hành, vì vậy bạn không nên làm điều gì đó như thế assume(VeryExpensiveComputation()).

Có hỗ trợ tiêu chuẩn cho việc này. Những gì bạn nên làm là bao gồm stdint.h( cstdint) và sau đó sử dụng loại uint_fast8_t.

Điều này cho trình biên dịch biết rằng bạn chỉ sử dụng các số trong khoảng 0 - 255, nhưng việc sử dụng loại lớn hơn là miễn phí nếu điều đó cho mã nhanh hơn. Tương tự, trình biên dịch có thể giả định rằng biến sẽ không bao giờ có giá trị trên 255 và sau đó thực hiện tối ưu hóa tương ứng.

Câu trả lời hiện tại phù hợp với trường hợp khi bạn biết chắc chắn phạm vi đó là gì, nhưng nếu bạn vẫn muốn hành vi đúng khi giá trị nằm ngoài phạm vi dự kiến, thì nó sẽ không hoạt động.

Trong trường hợp đó, tôi thấy kỹ thuật này có thể hoạt động:

if (x == c)  // assume c is a constant
{
    foo(x);
}
else
{
    foo(x);
}

Ý tưởng là một sự đánh đổi dữ liệu mã: bạn đang chuyển 1 bit dữ liệu (cho dù x == c) vào logic điều khiển .
Điều này gợi ý cho trình tối ưu hóa xtrên thực tế là một hằng số đã biết c, khuyến khích nó thực hiện nội tuyến và tối ưu hóa lệnh gọi đầu tiên footách biệt với phần còn lại, có thể khá nặng nề.

fooMặc dù vậy, hãy đảm bảo thực sự đặt mã vào một chương trình con duy nhất - không sao chép mã.

Thí dụ:

Để kỹ thuật này hoạt động, bạn cần phải có một chút may mắn - có những trường hợp trình biên dịch quyết định không đánh giá mọi thứ một cách tĩnh và chúng là loại tùy ý. Nhưng khi nó hoạt động, nó hoạt động tốt:

#include <math.h>
#include <stdio.h>

unsigned foo(unsigned x)
{
    return x * (x + 1);
}

unsigned bar(unsigned x) { return foo(x + 1) + foo(2 * x); }

int main()
{
    unsigned x;
    scanf("%u", &x);
    unsigned r;
    if (x == 1)
    {
        r = bar(bar(x));
    }
    else if (x == 0)
    {
        r = bar(bar(x));
    }
    else
    {
        r = bar(x + 1);
    }
    printf("%#x\n", r);
}

Chỉ cần sử dụng -O3và chú ý các hằng số được đánh giá trước 0x20và 0x30etrong đầu ra của trình biên dịch chương trình .

Tôi chỉ nói rằng nếu bạn có thể muốn một giải pháp C ++ chuẩn hơn, bạn có thể sử dụng [[noreturn]]thuộc tính để viết riêng của bạnunreachable .

Vì vậy, tôi sẽ tái sử dụng ví dụ tuyệt vời của deniss để chứng minh:

namespace detail {
    [[noreturn]] void unreachable(){}
}

#define assume(cond) do { if (!(cond)) detail::unreachable(); } while (0)

int func(int x){
    assume(x >=0 && x <= 10);

    if (x > 11){
        return 2;
    }
    else{
        return 17;
    }
}

Mà như bạn có thể thấy , kết quả trong mã gần giống hệt nhau:

detail::unreachable():
        rep ret
func(int):
        movl    $17, %eax
        ret

Nhược điểm là tất nhiên, rằng bạn nhận được một cảnh báo rằng một [[noreturn]]chức năng thực sự trở lại.