Ist es möglich, nicht gepaarte Erwerbs-/Release-Speicherbestellungen zu verwenden? ⇐ C++

[Anonymous]

Ich habe mehrere Stunden damit verbracht, Speicherauftrag zu studieren, aber ich habe immer noch einige Widersprüche in meinem Kopf. Einer von ihnen betrifft die Erwerbs-/Release -Speicherbestellungen. /> Ich habe auch gesehen, dass die Leute sagen, dass Erwerb /Veröffentlichung nur paarweise funktioniert. Hier bricht mein mentales Modell ein bisschen zusammen. Ich habe zwei Methoden: vielleicht_push und Consumer_pop_Many. < /P>
bool consumer_pop_many(T* dst, size_t& count) {
Index head_val = head.unsync_load(); // only consumer can change head (unsync_load is a custom function)
Index tail_val = tail.load(std::memory_order_acquire); // (1)

size_t available = len(head_val, tail_val);
size_t n = std::min(count, available);

if (n == 0) {
count = 0;
return false;
}

size_t head_idx = static_cast(head_val % CAPACITY);
size_t right = CAPACITY - head_idx;

// copy data code

head.store(head_val + n, std::memory_order_release); // (2)

count = n;
return true;
}

bool producer_maybe_push(T&& value) {
Index tail_val = tail.unsync_load(); // only the producer can change tail (unsync_load is a custom function)
Index head_val = head.load(std::memory_order_relaxed); // (3)

if (len(head_val, tail_val) == CAPACITY) {
return false;
}

size_t idx = static_cast(tail_val % CAPACITY);
new (&buffer[idx]) T(std::move(value));

tail.store(tail_val + 1, std::memory_order_release); // (4)
return true;
}
< /code>
Mein Argument: < /p>

Bei (1) verwende ich Erwerb, damit ich das Schreiben von (4) (den Nebeneffekt) sehen kann. Alle anderen Operationen in der Funktion hängen ohnehin bereits von dieser Last ab, erwerben jedoch die Sichtbarkeit dieses Schreibens. (1) beobachtet es korrekt. Aber was ist mit Nebenwirkungen? Könnte es passieren, dass: < /p>

Thread 1 (Verbraucher) den Kopf liest und fördert, < /p>
< /li>
Thread 2 (Produzent) dann liest der Kopf, aber es wird der Verbraucher (in den Sichtbarkeiten) (BR />
< /P> < /p> < /p> < /p> < /p> < /p> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < /> < />; /> Das sieht unmöglich aus, aber Beispiele mit SEQCST zeigen seltsame Situationen, und ich kann diese Frage nicht aus meinem Kopf schütteln. < /P.>