(x | y) - y ทำไมมันไม่เป็นแค่ x หรือแม้แต่ `x | 0`

ฉันกำลังอ่านรหัสเคอร์เนลและที่เดียวที่ฉันเห็นนิพจน์ภายในifคำสั่งเช่น

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

โดยที่SPINLOCK_SHARED = 0x80000000เป็นค่าคงที่ที่กำหนดไว้ล่วงหน้า

ฉันสงสัยว่าทำไมเราต้องใช้(SPINLOCK_SHARED | 1) - 1เพื่อการแปลงประเภท ผลลัพธ์ของนิพจน์จะเป็น 80000000 - เหมือนกับ 0x80000000 ใช่ไหม แต่ทำไม ORing 1 และ Subtracting 1 ถึงสำคัญ?

มีความรู้สึกเหมือนว่าฉันพลาดที่จะรับบางสิ่งบางอย่าง ..

มันเพิ่งทำแบบนั้นเพื่อความชัดเจนนั่นคือทั้งหมด เป็นเพราะ atomic_fetchadd_int () (ในเช่น sys / spinlock2.h) ส่งคืนค่า PRIOR ไปที่การเพิ่ม / การลบและค่านั้นจะถูกส่งไปยัง _spin_lock_contested ()

โปรดทราบว่าคอมไพเลอร์ C จะคำนวณนิพจน์คงที่ทั้งหมดล่วงหน้าอย่างสมบูรณ์ ในความเป็นจริงคอมไพเลอร์สามารถเพิ่มประสิทธิภาพโค้ดอินไลน์ตามเงื่อนไขที่ใช้อาร์กิวเมนต์โพรซีเดอร์แบบพาส - อินเมื่อโพรซีเดอร์ถูกส่งค่าคงที่ในอาร์กิวเมนต์เหล่านั้น นี่คือเหตุผลที่ lockmgr () แบบอินไลน์ใน sys / lock.h มีคำสั่ง case ... เนื่องจากว่าคำสั่ง case ทั้งหมดจะได้รับการปรับให้เหมาะสมและพัฒนาไปสู่การโทรโดยตรงไปยังฟังก์ชันที่เหมาะสม

นอกจากนี้ในฟังก์ชั่นการล็อคทั้งหมดค่าใช้จ่ายของปรมาณู ops แคระการคำนวณอื่น ๆ ทั้งหมดโดยสองหรือสามลำดับความสำคัญ

-Matt

พบรหัสใน_spin_lock_contestedซึ่งถูกเรียกจาก_spin_lock_quickเมื่อมีคนอื่นพยายามรับการล็อก:

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

หากไม่มีการแข่งขันควรcount(ค่าก่อนหน้า) 0แต่ไม่ใช่ countค่านี้ถูกส่งเป็นพารามิเตอร์เพื่อ_spin_lock_contestedเป็นvalueพารามิเตอร์ นี่valueคือการตรวจสอบกับifจาก 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;
}

โปรดทราบว่าvalueเป็นค่าก่อนหน้าของspin->countaและหลังได้เพิ่มขึ้น 1 เราคาดว่าspin->countaจะเท่ากันvalue + 1(ยกเว้นบางสิ่งที่มีการเปลี่ยนแปลงในระหว่างนี้)

ดังนั้นการตรวจสอบว่าspin->counta == SPINLOCK_SHARED | 1(เงื่อนไขเบื้องต้นatomic_cmpset_int) ตรงกับการตรวจสอบหรือvalue + 1 == SPINLOCK_SHARED | 1ไม่ซึ่งสามารถเขียนใหม่เป็นvalue == (SPINLOCK_SHARED | 1) - 1(อีกครั้งหากไม่มีการเปลี่ยนแปลงใด ๆ ในระหว่างนี้)

ในขณะที่value == (SPINLOCK_SHARED | 1) - 1สามารถเขียนใหม่เป็นvalue == SPINLOCK_SHAREDมันเป็นซ้ายเพื่อชี้แจงความตั้งใจของการเปรียบเทียบ (เช่น. เพื่อเปรียบเทียบค่าที่เพิ่มขึ้นก่อนหน้านี้กับค่าทดสอบ)

หรือ iow คำตอบดูเหมือนจะเป็น: เพื่อความชัดเจนและความสอดคล้องของรหัส

ฉันคิดว่าเป้าหมายน่าจะเพิกเฉยต่อนัยสำคัญต่ำสุด:

• ถ้า SPINLOCK_SHARED แสดงเป็นไบนารี่คือ xxx0 -> ผลลัพธ์คือ xxx0
• ถ้า SPINLOCK_SHARED = xxx1 -> ผลลัพธ์ก็คือ xxx0

อาจจะชัดเจนกว่านี้หากใช้การแสดงออกของหน้ากากเล็กน้อย

ผลของการ

(SPINLOCK_SHARED | 1) - 1

valueเพื่อให้แน่ใจว่าบิตต่ำลำดับของผลที่ได้จะถูกล้างออกก่อนที่จะเปรียบเทียบกับ ฉันเห็นด้วยว่ามันค่อนข้างไร้สาระ แต่เห็นได้ชัดว่าบิตลำดับต่ำมีการใช้งานเฉพาะหรือความหมายที่ไม่ชัดเจนในรหัสนี้และฉันคิดว่าเราต้องสมมติว่า devs มีเหตุผลที่ดีสำหรับการทำเช่นนี้ คำถามที่น่าสนใจก็คือ - ใช้รูปแบบเดียวกันนี้ ( | 1) -1) ตลอดทั้งฐานข้อมูลที่คุณกำลังดูหรือไม่?

มันเป็นวิธีการเขียนหน้ากากที่สับสน รุ่นที่อ่านได้: value == (SPINLOCK_SHARED & ~1u).

ส่วนใหญ่เช่นนี้จะทำเพื่อจัดการกรณีเพิ่มเติมหลายประการ ตัวอย่างเช่นในกรณีนี้เราบอกว่าSPINLOCK_SHAREDไม่สามารถเป็น 1:

int SPINLOCK_SHARED = 0x01

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