(x | y) - y mengapa tidak bisa hanya x atau bahkan `x | 0`

Saya membaca kode kernel, dan di satu tempat saya melihat ekspresi di dalam ifpernyataan seperti

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

di mana SPINLOCK_SHARED = 0x80000000konstanta yang ditentukan sebelumnya.

Saya heran mengapa kita perlu (SPINLOCK_SHARED | 1) - 1- untuk tujuan konversi tipe? hasil dari ekspresi akan menjadi 80000000 - sama dengan 0x80000000, bukan? namun, mengapa ORing 1 dan Mengurangkan 1 penting?

Memiliki perasaan seperti saya kehilangan untuk mendapatkan sesuatu ..

Itu hanya dilakukan dengan cara itu untuk kejelasan, itu saja. Itu karena atomic_fetchadd_int () (dalam contoh sys / spinlock2.h) mengembalikan nilai PRIOR ke penjumlahan / pengurangan, dan nilai tersebut diteruskan ke _spin_lock_contested ()

Perhatikan bahwa kompiler C sepenuhnya menghitung semua ekspresi konstan. Bahkan, kompiler bahkan dapat mengoptimalkan kode inline berdasarkan kondisional yang menggunakan argumen prosedur masuk ketika prosedur dilewatkan konstanta dalam argumen tersebut. Inilah sebabnya mengapa lockmgr () sebaris di sys / lock.h memiliki pernyataan kasus .... karena seluruh pernyataan kasus akan dioptimalkan dan dipindahkan ke panggilan langsung ke fungsi yang sesuai.

Juga, dalam semua fungsi penguncian ini, overhead ops atom mengerdilkan semua perhitungan lainnya dengan dua atau tiga orde besarnya.

-Matt

Kode ditemukan di _spin_lock_contested, yang dipanggil dari _spin_lock_quickketika orang lain berusaha mendapatkan kunci:

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

Jika tidak ada kontes, maka count(nilai sebelumnya) seharusnya 0, tetapi tidak. Ini countnilai dilewatkan sebagai parameter untuk _spin_lock_contestedsebagai valueparameter. Ini valuekemudian diperiksa dengan ifdari 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;
}

Dengan mengingat bahwa itu valueadalah nilai sebelumnya spin->counta, dan yang terakhir telah bertambah 1, kami berharap spin->countasama value + 1(kecuali ada sesuatu yang berubah pada saat itu).

Jadi, memeriksa apakah spin->counta == SPINLOCK_SHARED | 1(prasyarat atomic_cmpset_int) sesuai dengan memeriksa jika value + 1 == SPINLOCK_SHARED | 1, yang dapat ditulis ulang sebagai value == (SPINLOCK_SHARED | 1) - 1(sekali lagi, jika tidak ada yang berubah pada saat itu).

Sementara value == (SPINLOCK_SHARED | 1) - 1dapat ditulis ulang sebagaimana value == SPINLOCK_SHARED, dibiarkan apa adanya, untuk memperjelas maksud perbandingan (mis. Untuk membandingkan nilai sebelumnya yang ditambahkan dengan nilai tes).

Atau iow. jawabannya adalah: untuk kejelasan dan konsistensi kode.

Saya pikir tujuannya mungkin untuk mengabaikan bit signifikan terendah:

• Jika SPINLOCK_SHARED diekspresikan dalam biner adalah xxx0 -> hasilnya adalah xxx0
• Jika SPINLOCK_SHARED = xxx1 -> hasilnya juga xxx0

mungkin akan lebih jelas untuk menggunakan ekspresi topeng sedikit?

Efek dari

(SPINLOCK_SHARED | 1) - 1

adalah untuk memastikan bahwa bit pesanan rendah dari hasil dibersihkan sebelum perbandingan dengan value. Saya setuju bahwa itu tampaknya tidak ada gunanya tetapi tampaknya bit orde rendah memiliki penggunaan atau makna tertentu yang tidak terlihat dalam kode ini, dan saya pikir kita harus berasumsi bahwa para devs memiliki alasan yang baik untuk melakukan ini. Pertanyaan yang menarik adalah - apakah pola yang sama ini ( | 1) -1) digunakan di seluruh basis kode yang Anda lihat?

Ini adalah cara penulisan topeng agak dikaburkan. Versi Readable: value == (SPINLOCK_SHARED & ~1u).

Kebanyakan seperti ini dilakukan untuk menangani beberapa kasus tambahan. Misalnya, dalam hal ini, kita mengatakan bahwa SPINLOCK_SHAREDtidak boleh 1:

int SPINLOCK_SHARED = 0x01

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