(x | y) - y por qué no puede ser simplemente x o incluso `x | 0`

Estaba leyendo un código del núcleo, y en un lugar he visto una expresión dentro de una ifdeclaración como

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

donde SPINLOCK_SHARED = 0x80000000es una constante predefinida

Me pregunto por qué necesitamos (SPINLOCK_SHARED | 1) - 1, para fines de conversión de tipos. el resultado de la expresión sería 80000000-- igual que 0x80000000, ¿no es así? sin embargo, ¿por qué importa ORing 1 y Resta 1?

Tengo la sensación de que me falta conseguir algo ...

Simplemente se hizo así para mayor claridad, eso es todo. Es porque atomic_fetchadd_int () (por ejemplo, en sys / spinlock2.h) devuelve el valor ANTES de la suma / resta, y ese valor se pasa a _spin_lock_contested ()

Tenga en cuenta que el compilador de C calcula previamente todas las expresiones constantes. De hecho, el compilador puede incluso optimizar el código en línea basado en condicionales que usan argumentos de procedimiento pasados ​​cuando los procedimientos son constantes pasados ​​en esos argumentos. Es por eso que lockmgr () en línea en sys / lock.h tiene una declaración de caso ... porque toda la declaración de caso se optimizará y se convertirá en una llamada directa a la función apropiada.

Además, en todas estas funciones de bloqueo, la sobrecarga de las operaciones atómicas eclipsa todos los demás cálculos en dos o tres órdenes de magnitud.

-Mate

El código se encuentra en _spin_lock_contested, que se llama _spin_lock_quickcuando alguien más intenta obtener el bloqueo:

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

Si no hay concurso, entonces count(el valor anterior) debería serlo 0, pero no lo es. Este countvalor se pasa como parámetro a _spin_lock_contestedcomo valueparámetro. Esto valueluego se verifica con ifel 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;
}

Teniendo en cuenta que ese valuees el valor anterior de spin->counta, y este último ya se ha incrementado en 1, esperamos spin->countaque sea igual value + 1(a menos que algo haya cambiado mientras tanto).

Por lo tanto, verificar si spin->counta == SPINLOCK_SHARED | 1(la condición previa de atomic_cmpset_int) corresponde a verificar si value + 1 == SPINLOCK_SHARED | 1, que puede reescribirse como value == (SPINLOCK_SHARED | 1) - 1(nuevamente, si nada ha cambiado mientras tanto).

Si bien value == (SPINLOCK_SHARED | 1) - 1podría reescribirse como value == SPINLOCK_SHARED, se deja como está, para aclarar la intención de la comparación (es decir, comparar el valor anterior incrementado con el valor de la prueba).

O iow. la respuesta parece ser: por claridad y consistencia del código.

Creo que el objetivo es probablemente ignorar el bit significativo más bajo:

• Si SPINLOCK_SHARED expresado en binario es xxx0 -> el resultado es xxx0
• Si SPINLOCK_SHARED = xxx1 -> el resultado también es xxx0

habría sido quizás más claro usar una expresión de máscara de bits?

El efecto de

(SPINLOCK_SHARED | 1) - 1

es garantizar que el bit de orden inferior del resultado se borre antes de la comparación con value. Estoy de acuerdo en que parece bastante inútil, pero aparentemente el bit de bajo orden tiene un uso o significado particular que no es aparente en este código, y creo que debemos suponer que los desarrolladores tenían una buena razón para hacerlo. Una pregunta interesante sería: ¿se | 1) -1usa este mismo patrón ( ) en toda la base de código que está viendo?

Es una forma ofuscada de escribir una máscara de bits. Versión legible: value == (SPINLOCK_SHARED & ~1u).

La mayoría de esto se hace para manejar varios casos adicionales. Por ejemplo, en este caso, decimos que SPINLOCK_SHAREDno puede ser 1:

int SPINLOCK_SHARED = 0x01

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