C++ 0x | Tại sao std :: nguyên tử quá tải mỗi phương pháp với các biến dạng dễ bay hơi?

Question

Đoạn trích sau đây từ dự thảo hiện nay cho thấy những gì tôi muốn nói:

namespace std { 
    typedef struct atomic_bool { 
     bool is_lock_free() const volatile; 
     bool is_lock_free() const; 
     void store(bool, memory_order = memory_order_seq_cst) volatile; 
     void store(bool, memory_order = memory_order_seq_cst); 
     bool load(memory_order = memory_order_seq_cst) const volatile; 
     bool load(memory_order = memory_order_seq_cst) const; 
     operator bool() const volatile; 
     operator bool() const; 
     bool exchange(bool, memory_order = memory_order_seq_cst) volatile; 
     bool exchange(bool, memory_order = memory_order_seq_cst); 
     bool compare_exchange_weak(bool&, bool, memory_order, memory_order) volatile; 
     bool compare_exchange_weak(bool&, bool, memory_order, memory_order); 
     bool compare_exchange_strong(bool&, bool, memory_order, memory_order) volatile; 
     bool compare_exchange_strong(bool&, bool, memory_order, memory_order); 
     bool compare_exchange_weak(bool&, bool, memory_order = memory_order_seq_cst) volatile; 
     bool compare_exchange_weak(bool&, bool, memory_order = memory_order_seq_cst); 
     bool compare_exchange_strong(bool&, bool, memory_order = memory_order_seq_cst) volatile; 
     bool compare_exchange_strong(bool&, bool, memory_order = memory_order_seq_cst); 
     atomic_bool() = default; 
     constexpr atomic_bool(bool); 
     atomic_bool(const atomic_bool&) = delete; 
     atomic_bool& operator=(const atomic_bool&) = delete; 
     atomic_bool& operator=(const atomic_bool&) volatile = delete; 
     bool operator=(bool) volatile; 
    } atomic_bool; 
} 

dễ bay hơi là bắc cầu. Do đó, bạn không thể gọi hàm thành viên không bay hơi từ một đối tượng dễ bay hơi. Mặt khác, gọi hàm thành viên dễ bay hơi từ một đối tượng không bay hơi được cho phép.

Vì vậy, có sự khác biệt thực hiện nào giữa các hàm thành viên dễ bay hơi và không bay hơi trong các lớp nguyên tử không? Nói cách khác, có cần thiết cho quá tải không bay hơi không?

Answer 1

Tôi nghĩ rằng quá tải dễ bay hơi tồn tại vì lý do hiệu quả. Đọc và viết dễ bay hơi vốn đắt hơn các lần đọc không dễ bay hơi và viết trong C++ 0x, vì mô hình bộ nhớ đặt một số yêu cầu nghiêm ngặt ngăn chặn bộ nhớ đệm của các giá trị của các biến dễ bay hơi. Nếu tất cả các chức năng chỉ được đánh dấu dễ bay hơi, thì mã không nhất thiết phải thực hiện tối ưu hóa nhất định mà nếu không sẽ cải thiện hiệu suất. Có sự phân biệt cho phép trình biên dịch tối ưu hóa các lần đọc không dễ bay hơi và viết khi có thể trong khi giảm đi một cách duyên dáng khi đọc và ghi dễ bay hơi.

Answer 2

Đầu tiên, nó nghe có vẻ dư thừa để tạo ra một std dễ bay hơi :: nguyên tử. Trên thực tế, tôi có thể tưởng tượng một tình huống hữu ích. Giả sử chúng ta có một địa chỉ thiết bị cố định (bộ nhớ) mà chúng ta muốn vận hành. Do thực tế là các lớp std :: atomic_xxx cũng như std :: atomic <> lớp mẫu nên có cùng kích thước với các kiểu dựng sẵn tương ứng của chúng, bạn có thể muốn xử lý cả hai: Thực hiện các phép toán nguyên tử với quyền kiểm soát bộ nhớ đặt hàng và đảm bảo rằng quyền truy cập vào đối tượng nguyên tử của chúng tôi không bao giờ được tối ưu hóa. Do đó, chúng tôi có thể tuyên bố một cái gì đó như:

std::atomic<long> volatile* vmem_first4 = reinterpret_cast<std::atomic<long> volatile*>(0xxB8000);