(x | y) - y neden sadece x, hatta x olamaz? 0`

Bir çekirdek kodlarını okuyordu ve tek bir yerde içimde bir ifade gördüm ifaçıklamada gibi

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

nerede SPINLOCK_SHARED = 0x80000000önceden tanımlanmış bir sabittir.

Acaba neden (SPINLOCK_SHARED | 1) - 1dönüştürme ihtiyacımız var ? ifadenin sonucu 80000000 olur - 0x80000000 ile aynıdır, değil mi? yine de neden ORing 1 ve 1 Çıkarma önemlidir?

Bir şey almak için özlediğim gibi hissediyorum.

Sadece netlik için bu şekilde yapıldı, hepsi bu. Çünkü atomic_fetchadd_int () (örneğin sys / spinlock2.h) toplama / çıkarma için PRIOR değerini döndürür ve bu değerin _spin_lock_contested () 'e iletilir

C derleyicisinin tüm sabit ifadeleri tamamen önceden hesapladığını unutmayın. Aslında, derleyici, yordamlar bu bağımsız değişkenlerde sabitler iletildiğinde geçirilen yordam bağımsız değişkenlerini kullanan koşullara dayalı olarak satır içi kodu en iyi duruma getirebilir. Bu nedenle sys / lock.h dosyasında lockmgr () satır içi bir vaka deyimi vardır .... çünkü tüm vaka deyimi optimize edilecek ve uygun işleve doğrudan çağrıya dönüşecektir.

Ayrıca, tüm bu kilitleme fonksiyonlarında, atomik oplerin ek yükü diğer tüm hesaplamaları iki veya üç büyüklükte cüce eder.

-Mat

Kod, başka bir kişi kilidi almaya çalışırken _spin_lock_contestedçağrılır _spin_lock_quick:

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

Yarışma yoksa, count(önceki değer) olmalı 0, ama değil. Bu countdeğer parametre olarak parametresi _spin_lock_contestedolarak geçirilir value. Bu valuedaha sonra OP'den kontrol edilir if:

/*
 * 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Önceki değerin olduğunu spin->countave ikincisinin zaten 1 arttırıldığını akılda tutarak, spin->countaeşit olmayı bekliyoruz value + 1(bu arada bir şey değişmedikçe).

Bu nedenle, spin->counta == SPINLOCK_SHARED | 1(ön koşulunun atomic_cmpset_int) value + 1 == SPINLOCK_SHARED | 1yeniden yazılabilir olup olmadığını kontrol etmeye karşılık gelip gelmediğini kontrol etmek value == (SPINLOCK_SHARED | 1) - 1(bu arada hiçbir şey değişmediyse).

İken value == (SPINLOCK_SHARED | 1) - 1şekilde tekrar yazılabilir value == SPINLOCK_SHARED, bu karşılaştırmanın niyet netleştirmek için, olduğu gibi kalan (yani. Test değeri ile artırılır önceki değerini karşılaştırmak için).

Veya iow. cevabın açıklık ve kod tutarlılığı için olduğu görülmektedir.

Amaç muhtemelen en düşük anlamlı bit göz ardı etmektir:

• İkili olarak ifade edilen SPINLOCK_SHARED xxx0 ise -> sonuç xxx0
• SPINLOCK_SHARED = xxx1 -> sonuç da xxx0 ise

belki biraz maske ifadesi kullanmak daha net olurdu?

Etkisi

(SPINLOCK_SHARED | 1) - 1

ile karşılaştırmadan önce sonucun düşük dereceli bitinin temizlenmesini sağlamaktır value. Oldukça anlamsız göründüğünü kabul ediyorum, ancak görünüşe göre düşük dereceli bit, bu kodda belirgin olmayan belirli bir kullanım veya anlama sahip ve sanırım geliştiricilerin bunu yapmak için iyi bir nedeni olduğunu varsaymalıyız. İlginç bir soru olurdu - bu aynı desen ( | 1) -1) baktığınız kod tabanı boyunca kullanılıyor mu?

Biraz maske yazmanın karışık bir yolu. Okunabilir versiyon: value == (SPINLOCK_SHARED & ~1u).

Bunun gibi çoğu, birkaç ek vakayı ele almak için yapılır. Örneğin, bu durumda, SPINLOCK_SHARED1 olamaz diyoruz :

int SPINLOCK_SHARED = 0x01

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