(x | y) - y perché non può essere semplicemente x o anche `x | 0`

Stavo leggendo un codice del kernel, e in un posto ho visto un'espressione dentro una ifdichiarazione come

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

dove SPINLOCK_SHARED = 0x80000000è una costante predefinita.

Mi chiedo perché ne abbiamo bisogno (SPINLOCK_SHARED | 1) - 1- ai fini della conversione del tipo? il risultato dell'espressione sarebbe 80000000, uguale a 0x80000000, no? ma perché ORing 1 e Sottraendo 1 sono importanti?

Sento che mi manca per ottenere qualcosa ..

È stato fatto così per chiarezza, tutto qui. È perché atomic_fetchadd_int () (ad es. Sys / spinlock2.h) restituisce il valore PRIOR all'addizione / sottrazione e quel valore viene passato a _spin_lock_contested ()

Si noti che il compilatore C pre-calcola completamente tutte le espressioni costanti. In effetti, il compilatore può persino ottimizzare il codice inline basato su condizionali che usano argomenti di procedure passate quando alle procedure vengono passate costanti in tali argomenti. Questo è il motivo per cui lockmgr () inline in sys / lock.h ha un'istruzione case ... perché l'intera istruzione case sarà ottimizzata e devoluta in una chiamata diretta alla funzione appropriata.

Inoltre, in tutte queste funzioni di blocco il sovraccarico delle operazioni atomiche riduce tutti gli altri calcoli di due o tre ordini di grandezza.

-Opaco

Il codice si trova in _spin_lock_contested, che viene chiamato da _spin_lock_quickquando qualcun altro sta tentando di ottenere il blocco:

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

Se non ci sono contest, allora count(il valore precedente) dovrebbe essere 0, ma non lo è. Questo countvalore viene passato come parametro a _spin_lock_contestedcome valueparametro. Questo valueviene quindi verificato con ifdall'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;
}

Tenendo presente che valueè il valore precedente di spin->counta, e quest'ultimo è già stato incrementato di 1, ci aspettiamo spin->countache sia uguale value + 1(a meno che qualcosa non sia cambiato nel frattempo).

Quindi, verificare se spin->counta == SPINLOCK_SHARED | 1(la condizione preliminare di atomic_cmpset_int) corrisponde a verificare se value + 1 == SPINLOCK_SHARED | 1, che può essere riscritto come value == (SPINLOCK_SHARED | 1) - 1(di nuovo, se nel frattempo non è cambiato nulla).

Mentre value == (SPINLOCK_SHARED | 1) - 1potrebbe essere riscritto come value == SPINLOCK_SHARED, è lasciato così com'è, per chiarire l'intento del confronto (cioè per confrontare il valore precedente incrementato con il valore del test).

O iow. la risposta sembra essere: per chiarezza e coerenza del codice.

Penso che l'obiettivo sia probabilmente di ignorare il bit significativo più basso:

• Se SPINLOCK_SHARED espresso in binario è xxx0 -> il risultato è xxx0
• Se SPINLOCK_SHARED = xxx1 -> il risultato è anche xxx0

sarebbe stato forse più chiaro usare un'espressione con un po 'di maschera?

L'effetto di

(SPINLOCK_SHARED | 1) - 1

è assicurarsi che il bit di ordine inferiore del risultato venga cancellato prima del confronto con value. Concordo sul fatto che sembra piuttosto inutile, ma apparentemente il bit di basso ordine ha un uso o un significato particolare che non è evidente in questo codice, e penso che dobbiamo supporre che gli sviluppatori abbiano una buona ragione per farlo. Una domanda interessante sarebbe: questo stesso modello ( | 1) -1) è usato in tutta la base di codice che stai guardando?

È un modo offuscato di scrivere una maschera. Versione Leggibile: value == (SPINLOCK_SHARED & ~1u).

La maggior parte di questi viene eseguita per gestire diversi casi aggiuntivi. Ad esempio, in questo caso, diciamo che SPINLOCK_SHAREDnon può essere 1:

int SPINLOCK_SHARED = 0x01

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