(x | y) - y pourquoi ne peut-il pas simplement être x ou même `x | 0`

Je lisais un code du noyau, et à un endroit, j'ai vu une expression à l'intérieur d'une ifdéclaration comme

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

où SPINLOCK_SHARED = 0x80000000est une constante prédéfinie.

Je me demande pourquoi avons-nous besoin (SPINLOCK_SHARED | 1) - 1- à des fins de conversion de type? le résultat de l'expression serait 80000000-- identique à 0x80000000, n'est-ce pas? pourtant, pourquoi ORing 1 et Soustraire 1 sont importants?

J'ai le sentiment que je manque pour obtenir quelque chose ..

Cela a été fait de cette façon pour plus de clarté, c'est tout. C'est parce que atomic_fetchadd_int () (par exemple sys / spinlock2.h) renvoie la valeur PRIOR à l'addition / soustraction, et cette valeur est passée à _spin_lock_contested ()

Notez que le compilateur C pré-calcule complètement toutes les expressions constantes. En fait, le compilateur peut même optimiser le code en ligne basé sur des conditions qui utilisent des arguments de procédure transmis lorsque les procédures reçoivent des constantes dans ces arguments. C'est pourquoi l'inline lockmgr () dans sys / lock.h a une instruction case .... car cette instruction case entière sera optimisée et transformée en un appel direct à la fonction appropriée.

De plus, dans toutes ces fonctions de verrouillage, les frais généraux des opérations atomiques éclipsent tous les autres calculs de deux ou trois ordres de grandeur.

-Mat

Le code se trouve dans _spin_lock_contested, qui est appelé à partir du _spin_lock_quickmoment où quelqu'un d'autre tente d'obtenir le verrou:

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

S'il n'y a pas de concours, alors count(la valeur précédente) devrait l'être 0, mais ce n'est pas le cas. Cette countvaleur est transmise en tant que paramètre à en _spin_lock_contestedtant que valueparamètre. Ceci valueest ensuite vérifié avec ifl'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;
}

En gardant à l'esprit que valuec'est la valeur précédente de spin->counta, et que celle-ci a déjà été incrémentée de 1, nous nous attendons spin->countaà égaler value + 1(sauf si quelque chose a changé entre-temps).

Donc, vérifier si spin->counta == SPINLOCK_SHARED | 1(la condition préalable de atomic_cmpset_int) correspond à vérifier si value + 1 == SPINLOCK_SHARED | 1, qui peut être réécrit comme value == (SPINLOCK_SHARED | 1) - 1(encore une fois, si rien n'a changé entre-temps).

Bien qu'il value == (SPINLOCK_SHARED | 1) - 1puisse être réécrit tel value == SPINLOCK_SHAREDquel, il reste tel quel, pour clarifier l'intention de la comparaison (c'est-à-dire comparer la valeur précédente incrémentée avec la valeur de test).

Ou iow. la réponse semble être: pour la clarté et la cohérence du code.

Je pense que l'objectif est probablement d'ignorer le bit significatif le plus bas:

• Si SPINLOCK_SHARED exprimé en binaire est xxx0 -> le résultat est xxx0
• Si SPINLOCK_SHARED = xxx1 -> le résultat est également xxx0

aurait peut-être été plus clair d'utiliser une expression de masque de bits?

L'effet de

(SPINLOCK_SHARED | 1) - 1

est de s'assurer que le bit de poids faible du résultat est effacé avant la comparaison avec value. Je suis d'accord qu'il semble plutôt inutile, mais apparemment le bit de poids faible a une utilisation ou une signification particulière qui n'est pas apparente dans ce code, et je pense que nous devons supposer que les développeurs avaient une bonne raison de le faire. Une question intéressante serait - ce même modèle ( | 1) -1) est-il utilisé dans toute la base de code que vous regardez?

C'est une façon obscure d'écrire un petit masque. Version Lisible: value == (SPINLOCK_SHARED & ~1u).

La plupart comme cela est fait pour gérer plusieurs cas supplémentaires. Par exemple, dans ce cas, nous disons que SPINLOCK_SHAREDne peut pas être 1:

int SPINLOCK_SHARED = 0x01

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