(x | y) - y por que não pode ser simplesmente x ou mesmo `x | 0`

Eu estava lendo um código do kernel e, em um lugar, vi uma expressão dentro de uma ifinstrução como

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

onde SPINLOCK_SHARED = 0x80000000é uma constante predefinida.

Gostaria de saber por que precisamos (SPINLOCK_SHARED | 1) - 1- para fins de conversão de tipo? o resultado da expressão seria 80000000-- o mesmo que 0x80000000, não é? ainda, por que ORing 1 e Subtração 1 são importantes?

Tenho a sensação de que estou sentindo falta de algo ..

Foi assim feito para maior clareza, só isso. Isso ocorre porque atomic_fetchadd_int () (por exemplo, sys / spinlock2.h) retorna o valor ANTES da adição / subtração, e esse valor é passado para _spin_lock_contested ()

Observe que o compilador C pré-calcula completamente todas as expressões constantes. De fato, o compilador pode até otimizar o código embutido com base em condicionais que usam argumentos de procedimentos passados ​​quando os procedimentos são passados ​​constantes nesses argumentos. É por isso que o lockmgr () inline em sys / lock.h possui uma instrução de caso .... porque toda a instrução de caso será otimizada e evoluirá para uma chamada direta para a função apropriada.

Além disso, em todas essas funções de bloqueio, a sobrecarga das operações atômicas diminui todos os outros cálculos em duas ou três ordens de magnitude.

-Matt

O código é encontrado em _spin_lock_contested, que é chamado _spin_lock_quickquando outra pessoa está tentando obter o bloqueio:

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

Se não houver concurso, counto valor anterior deve ser 0, mas não é. Este countvalor é passado como parâmetro para _spin_lock_contestedcomo o valueparâmetro. Isso valueé verificado com o ifdo 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;
}

Tendo em mente que valueé o valor anterior de spin->counta, e o último já foi incrementado em 1, esperamos spin->countaser iguais value + 1(a menos que algo tenha mudado nesse meio tempo).

Portanto, verificar se spin->counta == SPINLOCK_SHARED | 1(a pré-condição de atomic_cmpset_int) corresponde a verificar se value + 1 == SPINLOCK_SHARED | 1, que pode ser reescrito como value == (SPINLOCK_SHARED | 1) - 1(novamente, se nada mudou nesse meio tempo).

Embora value == (SPINLOCK_SHARED | 1) - 1possa ser reescrito como value == SPINLOCK_SHARED, é deixado como está para esclarecer a intenção da comparação (ou seja, comparar o valor anterior incrementado com o valor do teste).

Ou uau. a resposta parece ser: para maior clareza e consistência do código.

Eu acho que o objetivo é provavelmente ignorar o bit mais baixo e significativo:

• Se SPINLOCK_SHARED expresso em binário for xxx0 -> result is xxx0
• Se SPINLOCK_SHARED = xxx1 -> o resultado também for xxx0

teria sido talvez mais claro usar uma expressão de máscara de bits?

O efeito de

(SPINLOCK_SHARED | 1) - 1

é garantir que o bit de baixa ordem do resultado seja limpo antes da comparação com value. Concordo que parece inútil, mas aparentemente o bit de ordem inferior tem um uso ou significado específico que não é aparente neste código, e acho que devemos assumir que os desenvolvedores tiveram uma boa razão para fazer isso. Uma pergunta interessante seria - esse mesmo padrão ( | 1) -1) é usado em toda a base de código que você está vendo?

É uma maneira ofuscada de escrever um pouco de máscara. Versão legível: value == (SPINLOCK_SHARED & ~1u).

A maioria é feita para lidar com vários casos adicionais. Por exemplo, neste caso, dizemos que SPINLOCK_SHAREDnão pode ser 1:

int SPINLOCK_SHARED = 0x01

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