Nâng tải trọng không nguyên tử lên thông qua việc mua các tải nguyên tử

Question

Tôi đã cảm thấy rằng tải bộ nhớ không thể được nâng lên trên một tải thu được trong mô hình bộ nhớ C++ 11. Tuy nhiên, nhìn vào mã mà gcc 4.8 tạo ra chỉ có vẻ đúng với các tải nguyên tử khác, không phải tất cả bộ nhớ. Nếu đó là sự thật và mua tải không đồng bộ hóa tất cả bộ nhớ (chỉ std::atomics) sau đó tôi không chắc chắn làm thế nào nó sẽ có thể thực hiện mutexes mục đích chung về std :: nguyên tử.

Các mã sau đây:

extern std::atomic<unsigned> seq; 
extern std::atomic<int> data; 

int reader() { 
    int data_copy; 
    unsigned seq0; 
    unsigned seq1; 
    do { 
     seq0 = seq.load(std::memory_order_acquire); 
     data_copy = data.load(std::memory_order_relaxed); 
     std::atomic_thread_fence(std::memory_order_acquire); 
     seq1 = seq.load(std::memory_order_relaxed); 
    } while (seq0 != seq1); 
    return data_copy; 
} 

Tạo:

_Z6readerv: 
.L3: 
    mov ecx, DWORD PTR seq[rip] 
    mov eax, DWORD PTR data[rip] 
    mov edx, DWORD PTR seq[rip] 
    cmp ecx, edx 
    jne .L3 
    rep ret 

nào có vẻ đúng với tôi.

Tuy nhiên thay đổi dữ liệu là một int hơn std::atomic:

extern std::atomic<unsigned> seq; 
extern int data; 

int reader() { 
    int data_copy; 
    unsigned seq0; 
    unsigned seq1; 
    do { 
     seq0 = seq.load(std::memory_order_acquire); 
     data_copy = data; 
     std::atomic_thread_fence(std::memory_order_acquire); 
     seq1 = seq.load(std::memory_order_relaxed); 
    } while (seq0 != seq1); 
    return data_copy; 
} 

Tạo này:

_Z6readerv: 
    mov eax, DWORD PTR data[rip] 
.L3: 
    mov ecx, DWORD PTR seq[rip] 
    mov edx, DWORD PTR seq[rip] 
    cmp ecx, edx 
    jne .L3 
    rep ret 

Vì vậy, những gì đang xảy ra?

Answer 1

Tại sao một tải được kéo lên trên một Acquire

tôi đã đăng này trên gcc bugzilla và họ đã xác nhận nó như là một lỗi.

bí danh thiết lập là -1 (ALIAS_SET_MEMORY_BARRIER) MEM có nghĩa vụ phải ngăn chặn điều này, nhưng PRE không biết về bất động sản đặc biệt này (nó sẽ "giết" tất cả các refs qua nó).

Dường như gcc wiki có một trang đẹp về việc này.

Nói chung, phát hành là một rào cản đối với chìm mã, có được là một rào cản đối với cẩu mã.

Tại sao mã này vẫn còn bị hỏng

Theo this paper mã của tôi là vẫn không chính xác, bởi vì nó giới thiệu một cuộc chạy đua dữ liệu. Mặc dù gcc được vá tạo mã đúng nhưng vẫn không thích hợp để truy cập data mà không cần gói nó trong std::atomic.Lý do là các cuộc đua dữ liệu là hành vi không xác định, ngay cả khi tính toán kết quả từ chúng được loại bỏ.

Một ví dụ biếu không của AdamH.Peterson:

int foo(unsigned x) { 
    if (x < 10) { 
     /* some calculations that spill all the 
      registers so x has to be reloaded below */ 
     switch (x) { 
     case 0: 
      return 5; 
     case 1: 
      return 10; 
     // ... 
     case 9: 
      return 43; 
     } 
    } 
    return 0; 
} 

Dưới đây là một trình biên dịch có thể tối ưu hóa việc chuyển đổi vào một bảng nhảy, và nhờ vào câu lệnh if ở trên sẽ có thể tránh một tấm séc phạm vi. Tuy nhiên, nếu cuộc đua dữ liệu không phải là hành vi không xác định thì cần phải kiểm tra phạm vi thứ hai.

Answer 2

Tôi vẫn còn mới về lý do về các hoạt động và các rào cản bộ nhớ không tuần tự nhất quán, nhưng có thể là việc tạo mã này là chính xác (hoặc không được phép). Trên khuôn mặt của nó, nó chắc chắn trông cá, nhưng tôi sẽ không ngạc nhiên nếu không có cách nào cho một chương trình phù hợp tiêu chuẩn để nói rằng tải từ dữ liệu đã được treo (có nghĩa là mã này là chính xác theo "như thể " qui định).

Chương trình đang đọc hai giá trị tiếp theo từ một nguyên tử, một trước khi tải và một sau khi tải và phát hành lại tải bất cứ khi nào chúng không khớp. Về nguyên tắc, không có lý do nào mà hai lần đọc nguyên tử là phải thấy các giá trị khác nhau từ nhau. Ngay cả khi một ghi nguyên tử vừa mới xảy ra, không có cách nào cho chuỗi này có thể phát hiện ra rằng nó không đọc lại giá trị cũ. Sau đó, chuỗi sẽ quay trở lại vòng lặp và cuối cùng đọc hai giá trị nhất quán từ nguyên tử, sau đó quay lại, nhưng sau đó, seq0 và seq1 sẽ bị hủy, chương trình không thể cho biết giá trị trong seq0 không tương ứng với giá trị đã đọc từ data. Về nguyên tắc, điều này cũng gợi ý với tôi rằng toàn bộ vòng lặp có thể đã được elided và chỉ tải từ data thực sự là cần thiết cho tính chính xác, nhưng không bỏ qua vòng lặp không nhất thiết phải là vấn đề chính xác.

Nếu reader() là để trả về một pair<int,unsigned> bao gồm seq0 (hoặc seq1) và vòng lặp kéo lên cùng được tạo ra, tôi nghĩ rằng nó có thể là mã không chính xác (nhưng một lần nữa tôi mới để không tuần tự-phù này lập luận hoạt động).

Answer 3

Tôi không nghĩ rằng atomic_thread_fence của bạn là chính xác. Mô hình bộ nhớ C++ 11 duy nhất hoạt động với mã của bạn sẽ là seq_cst. Nhưng điều này là rất tốn kém (bạn sẽ nhận được một hàng rào bộ nhớ đầy đủ) cho những gì bạn cần.

Mã gốc hoạt động và tôi nghĩ đây là sự cân bằng hiệu suất tốt nhất.

EDIT dựa trên thông tin cập nhật của bạn:

Nếu bạn đang tìm kiếm lý do chính thức tại sao đoạn code với một int thường xuyên không hoạt động theo cách bạn muốn, tôi tin rằng các giấy rất bạn trích dẫn (http://www.hpl.hp.com/techreports/2012/HPL-2012-68.pdf) đưa ra câu trả lời. Nhìn vào cuối phần 2. Mã của bạn có cùng một vấn đề như mã trong Hình 1. Nó có các cuộc đua dữ liệu. Nhiều luồng có thể thực hiện các thao tác trên cùng một bộ nhớ trên int thông thường cùng một lúc. Nó bị cấm bởi mô hình bộ nhớ C++ 11, mã này là chính thức không hợp lệ mã C++.

gcc hy vọng mã không có chủng tộc dữ liệu, tức là mã C++ hợp lệ. Vì không có chủng tộc và mã tải int vô điều kiện, một tải có thể được phát ra bất cứ nơi nào trong cơ thể của hàm. Vì vậy, gcc là thông minh và nó chỉ phát ra nó một lần vì nó không phải là dễ bay hơi. Câu lệnh có điều kiện thường đi đôi với rào cản có được đóng một vai trò quan trọng trong trình biên dịch sẽ làm gì.

Trong tiếng lóng chính thức của tiêu chuẩn, tải nguyên tử và tải trọng int thông thường không được kết nối. Việc giới thiệu ví dụ về một điều kiện sẽ tạo ra một điểm chuỗi và sẽ buộc trình biên dịch đánh giá int thông thường sau điểm chuỗi (http://msdn.microsoft.com/en-us/library/d45c7a5d.aspx). Sau đó, mô hình bộ nhớ C++ sẽ thực hiện phần còn lại (nghĩa là đảm bảo khả năng hiển thị của CPU thực hiện các hướng dẫn)

Vì vậy, các câu lệnh của bạn đều không đúng. Bạn chắc chắn có thể xây dựng một khóa với C++ 11, không chỉ với một cuộc đua dữ liệu :-) Thông thường một khóa sẽ liên quan đến việc chờ đợi trước khi đọc (đó rõ ràng là những gì bạn đang cố gắng tránh ở đây), do đó bạn không có loại các vấn đề.

Lưu ý rằng khung ban đầu của bạn bị lỗi vì bạn không muốn chỉ kiểm tra seq0! = Seq1 (bạn có thể đang ở giữa bản cập nhật). Giấy seqlock có điều kiện chính xác.