Vấn đề GCC với so sánh hai loại thô

Question

Tôi có bit sau đây, tuy nhiên khi biên dịch với GCC 4.4 với các cờ tối ưu hóa khác nhau, tôi nhận được một số kết quả không mong muốn khi chạy.

#include <iostream> 

int main() 
{ 
    const unsigned int cnt = 10; 
    double lst[cnt] = { 0.0 }; 
    const double v[4] = { 131.313, 737.373, 979.797, 731.137 }; 

    for(unsigned int i = 0; i < cnt; ++i) { 
     lst[i] = v[i % 4] * i; 
    } 

    for(unsigned int i = 0; i < cnt; ++i) { 
     double d = v[i % 4] * i; 
     if(lst[i] != d) { 
     std::cout << "error @ : " << i << std::endl; 
     return 1; 
     } 
    } 
    return 0; 
} 

• khi biên soạn với: "g ++ -pedantic Wall -Werror -O1 -o test test.cpp" tôi nhận được kết quả như sau: "Lỗi @: 3"

• khi biên soạn với: "g ++ -pedantic Wall -Werror -O2 -o test test.cpp" tôi nhận được kết quả như sau: "lỗi @: 3"

• khi biên soạn với: "g ++ -pedantic Wall -Werror O3 -o test test.cpp" tôi nhận được không có lỗi

• khi biên soạn với: "g ++ -pedantic Wall - Werror -o test test.cpp" tôi nhận được không có lỗi

tôi không tin rằng đây là một vấn đề liên quan đến làm tròn, hoặc chênh lệch epsilon trong so sánh. Tôi đã thử điều này với Intel v10 và MSVC 9,0 và tất cả họ dường như làm việc như mong đợi. Tôi tin rằng điều này sẽ không có gì hơn một so sánh bitwise.

Nếu tôi thay thế if-tuyên bố như sau: if (static_cast<long long int>(lst[i]) != static_cast<long long int>(d)), và thêm "-Wno dài dài" tôi nhận được không có lỗi trong bất kỳ chế độ tối ưu hóa khi chạy.

Nếu tôi thêm std::cout << d << std::endl; trước khi "return 1", tôi nhận được không có lỗi trong bất kỳ chế độ tối ưu hóa khi chạy.

Đây có phải là lỗi trong mã của tôi hay không, có điều gì sai với GCC và cách xử lý loại kép không?

Lưu ý: Tôi vừa thử với phiên bản gcc 4.3 và 3.3, lỗi không được hiển thị.

Độ phân giải: Mike Dinsdale ghi nhận trong báo cáo lỗi sau: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=323 Có vẻ như đội GCC không hoàn toàn chắc chắn về bản chất của vấn đề.

Như được đề xuất trong báo cáo lỗi, độ phân giải có thể là sử dụng tùy chọn lưu trữ ffloat. Tôi đã thử điều này và nó hoạt động, tuy nhiên kết quả từ một quan điểm thực hiện không phải là tuyệt vời, mặc dù ymmv.

Answer 1

Vấn đề là khả năng kết quả của mất một số chính xác khi lưu trữ kết quả của một biểu thức so với các trình biên dịch không làm như vậy trong một địa phương như là một tối ưu hóa:

double d = v[i % 4] * i; // the result, `d`, might be kept in a register 
          // instead of storing it in a memory location, 
          // keeping full precision 

if(lst[i] != d) {   // the value stored in lst[i] may have lost some 
          // precision since it had to be stored in memory, 
          // which might not be able to hold the full 
          // precision that the expression generated 

Tiêu chuẩn C99 nói trong 6.3.1 .8/2 "Chuyển đổi số học thông thường":

Giá trị của toán hạng nổi và kết quả của biểu thức nổi có thể là đại diện cho độ chính xác và phạm vi lớn hơn yêu cầu của loại; các loại không phải là đã thay đổi.

Answer 2

Chiều rộng của thanh ghi dấu phẩy động trong x86 khác với chiều rộng của double trong RAM. Do đó việc so sánh có thể thành công hay thất bại tùy thuộc hoàn toàn vào cách trình biên dịch quyết định tối ưu hóa tải trọng của các giá trị dấu phẩy động.

Answer 3

Thực tế là kết quả phụ thuộc vào các thiết lập tối ưu hóa cho thấy nó có thể là x87 mở rộng chính xác rối tung với những thứ (như Michael Burr nói).

Dưới đây là một số mã tôi sử dụng (với gcc trên bộ xử lý x86) để chuyển đổi chính xác mở rộng off:

static const unsigned int PRECISION_BIT_MASK = 0x300; 
///< bitmask to mask out all non-precision bits in the fpu control word \cite{INTEL}. 
static const unsigned int EXTENDED_PRECISION_BITS = 0x300; 
///< add to the fpu control word (after zeroing precision bits) to turn on extended precision \cite{INTEL}. 
static const unsigned int STANDARD_PRECISION_BITS = 0x200; 
///< add to the fpu control word (after zeroing precision bits) to turn off extended precision \cite{INTEL}. 

void set_fpu_control_word(unsigned int mode) 
{ 
    asm ("fldcw %0" : : "m" (*&mode)); 
} 

unsigned int get_fpu_control_word() 
{ 
    volatile unsigned int mode = 0; 
    asm ("fstcw %0" : "=m" (*&mode)); 
    return mode; 
} 

bool fpu_set_extended_precision_is_on(bool state) 
{ 
    unsigned int old_cw = get_fpu_control_word(); 
    unsigned int masked = old_cw & ~PRECISION_BIT_MASK; 
    unsigned int new_cw; 
    if(state) 
    new_cw = masked + EXTENDED_PRECISION_BITS; 
    else 
    new_cw = masked + STANDARD_PRECISION_BITS; 
    set_fpu_control_word(new_cw); 
    return true; 
} 

bool fpu_get_extended_precision_is_on() 
{ 
    unsigned int old_cw = get_fpu_control_word(); 
    return ((old_cw & PRECISION_BIT_MASK) == 0x300); 
} 

Hoặc bạn chỉ có thể chạy mã của bạn với valgrind, mà không mô phỏng các thanh ghi 80-bit và có lẽ dễ dàng hơn cho một chương trình ngắn như thế này!