Warum optimieren C ++ - Compiler diese bedingte boolesche Zuweisung nicht als bedingungslose Zuweisung?

Betrachten Sie die folgende Funktion:

void func(bool& flag)
{
    if(!flag) flag=true;
}

Es scheint mir, dass wenn ein Flag einen gültigen booleschen Wert hat, dies einer bedingungslosen Einstellung truewie folgt entspricht:

void func(bool& flag)
{
    flag=true;
}

Weder gcc noch clang optimieren es auf diese Weise - beide generieren auf -O3Optimierungsebene Folgendes :

_Z4funcRb:
.LFB0:
    .cfi_startproc
    cmp BYTE PTR [rdi], 0
    jne .L1
    mov BYTE PTR [rdi], 1
.L1:
    rep ret

Meine Frage ist: Ist der Code nur zu speziell, um ihn zu optimieren, oder gibt es gute Gründe, warum eine solche Optimierung unerwünscht wäre, da dies flagkein Verweis auf ist volatile? Es scheint der einzige Grund zu sein, der sein könnte, dass er zum Zeitpunkt des Lesens flageinen Nicht- trueoder- falseWert ohne undefiniertes Verhalten haben könnte, aber ich bin mir nicht sicher, ob dies möglich ist.

Dies kann sich aufgrund von Überlegungen zur Cache-Kohärenz negativ auf die Leistung des Programms auswirken . Das Schreiben in flagjedes Mal func(), wenn aufgerufen wird, würde die enthaltene Cache-Zeile verschmutzen. Dies geschieht unabhängig davon, dass der zu schreibende Wert genau mit den Bits übereinstimmt, die vor dem Schreiben an der Zieladresse gefunden wurden.

BEARBEITEN

hvd hat einen weiteren guten Grund geliefert , der eine solche Optimierung verhindert. Es ist ein überzeugenderes Argument gegen die vorgeschlagene Optimierung, da es zu undefiniertem Verhalten führen kann, während meine (ursprüngliche) Antwort nur Leistungsaspekte betraf.

Nach etwas mehr Überlegung kann ich ein weiteres Beispiel vorschlagen, warum Compiler - sofern sie nicht nachweisen können, dass die Transformation für einen bestimmten Kontext sicher ist - von der Einführung des bedingungslosen Schreibens stark ausgeschlossen werden sollten. Betrachten Sie diesen Code:

const bool foo = true;

int main()
{
    func(const_cast<bool&>(foo));
}

Bei einem bedingungslosen Schreibvorgang func()wird definitiv ein undefiniertes Verhalten ausgelöst (das Schreiben in den Nur-Lese-Speicher beendet das Programm, selbst wenn der Effekt des Schreibvorgangs ansonsten ein No-Op wäre).

Abgesehen von Leons Antwort auf die Leistung:

Angenommen, flagist true. Angenommen, zwei Threads rufen ständig auf func(flag). Die geschriebene Funktion speichert in diesem Fall nichts in flag, daher sollte dies threadsicher sein. Zwei Threads greifen auf denselben Speicher zu, jedoch nur zum Lesen. Die bedingungslose Einstellung flagauf truebedeutet, dass zwei verschiedene Threads in denselben Speicher schreiben. Dies ist nicht sicher, dies ist unsicher, selbst wenn die zu schreibenden Daten mit den bereits vorhandenen Daten identisch sind.

Ich bin mir über das Verhalten von C ++ hier nicht sicher, aber in C kann sich der Speicher ändern, denn wenn der Speicher einen anderen Wert ungleich Null als 1 enthält, bleibt er bei der Prüfung unverändert, wird jedoch bei der Prüfung auf 1 geändert.

Da ich C ++ nicht sehr fließend beherrsche, weiß ich nicht, ob diese Situation überhaupt möglich ist.