(x | y) - y tại sao nó không thể đơn giản là x hoặc thậm chí `x | 0`

Tôi đang đọc mã hạt nhân và ở một nơi tôi đã thấy một biểu thức bên trong ifcâu lệnh như

if (value == (SPINLOCK_SHARED | 1) - 1) {
         ............
}

trong đó SPINLOCK_SHARED = 0x80000000một hằng số được xác định trước.

Tôi tự hỏi tại sao chúng ta cần (SPINLOCK_SHARED | 1) - 1- cho mục đích chuyển đổi loại? kết quả của biểu thức sẽ là 80000000-- giống như 0x80000000, phải không? chưa, tại sao ORing 1 và trừ 1 vấn đề?

Có cảm giác như tôi đang thiếu để có được thứ gì đó ..

Nó chỉ được thực hiện theo cách đó cho rõ ràng, đó là tất cả. Đó là bởi vì nguyên tử_fetchadd_int () (ví dụ: sys / spinlock2.h) trả về giá trị PRIOR cho phép cộng / trừ và giá trị đó được truyền cho _spin_lock_contested ()

Lưu ý rằng trình biên dịch C hoàn toàn tính toán trước tất cả các biểu thức hằng. Trong thực tế, trình biên dịch thậm chí có thể tối ưu hóa mã nội tuyến dựa trên các điều kiện sử dụng các đối số thủ tục được truyền vào khi các thủ tục được truyền hằng trong các đối số đó. Đây là lý do tại sao lockmgr () nội tuyến trong sys / lock.h có một câu lệnh tình huống .... bởi vì toàn bộ câu lệnh trường hợp đó sẽ được tối ưu hóa và chuyển thành một cuộc gọi trực tiếp đến hàm thích hợp.

Ngoài ra, trong tất cả các chức năng khóa này, phần trên của các op nguyên tử lùn tất cả các phép tính khác theo hai hoặc ba bậc độ lớn.

-Matt

Mã được tìm thấy _spin_lock_contested, được gọi từ _spin_lock_quickkhi người khác đang cố lấy khóa:

count = atomic_fetchadd_int(&spin->counta, 1);
if (__predict_false(count != 0)) {
    _spin_lock_contested(spin, ident, count);
}

Nếu không có cuộc thi, thì count(giá trị trước đó) sẽ là 0, nhưng không phải vậy. Đây countgiá trị được thông qua như là tham số để _spin_lock_contestedlà valuetham số. Điều này valuesau đó được kiểm tra với iftừ OP:

/*
 * WARNING! Caller has already incremented the lock.  We must
 *      increment the count value (from the inline's fetch-add)
 *      to match.
 *
 * Handle the degenerate case where the spinlock is flagged SHARED
 * with only our reference.  We can convert it to EXCLUSIVE.
 */
if (value == (SPINLOCK_SHARED | 1) - 1) {
    if (atomic_cmpset_int(&spin->counta, SPINLOCK_SHARED | 1, 1))
        return;
}

Hãy nhớ rằng đó valuelà giá trị trước đó và giá trị spin->countasau đã được tăng thêm 1, chúng tôi hy vọng spin->countasẽ bằng nhau value + 1(trừ khi có gì đó đã thay đổi trong thời gian này).

Vì vậy, kiểm tra xem spin->counta == SPINLOCK_SHARED | 1(điều kiện tiên quyết của atomic_cmpset_int) tương ứng với việc kiểm tra xem value + 1 == SPINLOCK_SHARED | 1, có thể được viết lại thành value == (SPINLOCK_SHARED | 1) - 1(một lần nữa, nếu không có gì thay đổi trong thời gian đó).

Mặc dù value == (SPINLOCK_SHARED | 1) - 1có thể được viết lại value == SPINLOCK_SHARED, nhưng nó vẫn để làm rõ ý định so sánh (nghĩa là so sánh giá trị gia tăng trước đó với giá trị thử nghiệm).

Hoặc iow. câu trả lời dường như là: cho sự rõ ràng và thống nhất mã.

Tôi nghĩ rằng mục tiêu có lẽ là bỏ qua bit đáng kể thấp nhất:

• Nếu SPINLOCK_SHARED thể hiện ở dạng nhị phân là xxx0 -> kết quả là xxx0
• Nếu SPINLOCK_SHARED = xxx1 -> kết quả cũng là xxx0

có lẽ đã rõ ràng hơn để sử dụng một biểu thức mặt nạ bit?

Ảnh hưởng của

(SPINLOCK_SHARED | 1) - 1

là để đảm bảo rằng bit thứ tự thấp của kết quả được xóa trước khi so sánh với value. Tôi đồng ý rằng nó có vẻ khá vô nghĩa nhưng rõ ràng bit thứ tự thấp có cách sử dụng hoặc ý nghĩa cụ thể không rõ ràng trong mã này và tôi nghĩ rằng chúng ta phải cho rằng các nhà phát triển có lý do chính đáng để làm điều này. Một câu hỏi thú vị sẽ là - có phải mẫu này ( | 1) -1) được sử dụng trong toàn bộ cơ sở mã mà bạn đang xem không?

Đó là một cách khó hiểu để viết một mặt nạ bit. Phiên bản dễ đọc : value == (SPINLOCK_SHARED & ~1u).

Hầu hết như thế này được thực hiện để xử lý một số trường hợp bổ sung. Ví dụ: trong trường hợp này, chúng tôi nói rằng SPINLOCK_SHAREDkhông thể là 1:

int SPINLOCK_SHARED = 0x01

int res = (SPINLOCK_SHARED | 1) - 1 // 0