(x | y) - y warum kann es nicht einfach x oder sogar `x | sein? 0`

Ich habe einen Kernel-Code gelesen und an einer Stelle habe ich einen Ausdruck in einer ifAnweisung wie gesehen

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

wo SPINLOCK_SHARED = 0x80000000ist eine vordefinierte Konstante.

Ich frage mich, warum wir brauchen (SPINLOCK_SHARED | 1) - 1- für die Typkonvertierung? Das Ergebnis des Ausdrucks wäre 80000000 - genau wie 0x80000000, nicht wahr? Warum ist ORing 1 und Subtrahieren von 1 wichtig?

Ich habe das Gefühl, dass mir etwas fehlt.

Es wurde nur aus Gründen der Klarheit so gemacht, das ist alles. Dies liegt daran, dass atomic_fetchadd_int () (z. B. sys / spinlock2.h) den Wert PRIOR für die Addition / Subtraktion zurückgibt und dieser Wert an _spin_lock_contested () übergeben wird.

Beachten Sie, dass der C-Compiler alle konstanten Ausdrücke vollständig vorberechnet. Tatsächlich kann der Compiler sogar Inline-Code basierend auf Bedingungen optimieren, die übergebene Prozedurargumente verwenden, wenn die Prozeduren Konstanten in diesen Argumenten übergeben werden. Aus diesem Grund hat die Inline lockmgr () in sys / lock.h eine case-Anweisung .... da diese gesamte case-Anweisung optimiert und in einen direkten Aufruf der entsprechenden Funktion umgewandelt wird.

Bei all diesen Verriegelungsfunktionen stellt der Overhead der Atomoperationen alle anderen Berechnungen um zwei oder drei Größenordnungen in den Schatten.

-Matt

Der Code befindet sich in _spin_lock_contested, der aufgerufen wird, _spin_lock_quickwenn jemand anderes versucht, die Sperre zu erhalten:

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

Wenn es keinen Wettbewerb gibt, sollte count(der vorherige Wert) sein 0, ist es aber nicht. Dieser countWert wird als Parameter an _spin_lock_contestedals valueParameter übergeben. Dies valuewird dann mit dem ifvom OP überprüft :

/*
 * 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;
}

Wenn wir bedenken, dass dies valueder vorherige Wert von spin->countaist und dieser bereits um 1 erhöht wurde, erwarten wir, dass spin->countaer gleich ist value + 1(es sei denn, etwas hat sich in der Zwischenzeit geändert).

Die Überprüfung, ob spin->counta == SPINLOCK_SHARED | 1(die Voraussetzung der atomic_cmpset_int) entspricht der Überprüfung, ob value + 1 == SPINLOCK_SHARED | 1, was umgeschrieben werden kann value == (SPINLOCK_SHARED | 1) - 1(erneut, wenn sich in der Zwischenzeit nichts geändert hat).

Während value == (SPINLOCK_SHARED | 1) - 1es umgeschrieben werden könnte value == SPINLOCK_SHARED, bleibt es unverändert , um die Absicht des Vergleichs zu verdeutlichen (dh den inkrementierten vorherigen Wert mit dem Testwert zu vergleichen).

Oder jetzt. Die Antwort scheint zu sein: aus Gründen der Klarheit und Codekonsistenz.

Ich denke, das Ziel ist wahrscheinlich, das niedrigstwertige Bit zu ignorieren:

• Wenn SPINLOCK_SHARED in binär ausgedrückt xxx0 ist -> Ergebnis ist xxx0
• Wenn SPINLOCK_SHARED = xxx1 -> Ergebnis ist auch xxx0

wäre es vielleicht klarer gewesen, einen Bitmaskenausdruck zu verwenden?

Der Effekt von

(SPINLOCK_SHARED | 1) - 1

soll sicherstellen, dass das niederwertige Bit des Ergebnisses vor dem Vergleich mit gelöscht wird value. Ich stimme zu, dass es ziemlich sinnlos erscheint, aber anscheinend hat das Bit niedriger Ordnung eine bestimmte Verwendung oder Bedeutung, die in diesem Code nicht ersichtlich ist, und ich denke, wir müssen davon ausgehen, dass die Entwickler einen guten Grund dafür hatten. Eine interessante Frage wäre: Wird dasselbe Muster ( | 1) -1) in der gesamten Codebasis verwendet, die Sie betrachten?

Es ist eine verschleierte Art, eine Bitmaske zu schreiben. Lesbare Version : value == (SPINLOCK_SHARED & ~1u).

Die meisten davon werden durchgeführt, um mehrere zusätzliche Fälle zu behandeln. In diesem Fall sagen wir zum Beispiel, dass SPINLOCK_SHAREDdies nicht 1 sein kann:

int SPINLOCK_SHARED = 0x01

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