Aquisição/liberação atômica em C++ e RMW - é possível adquirir sincronização de carga com vários RMWs de liberação?

Sim, está correto.

Há três sequências de liberação sobrepostas, de modo que a aquisição-carga sincroniza com todos os três RMWs de liberação. Os RMWs incluem, releasepara que cada um possa liderar sua própria sequência de liberação, além de fazer parte de uma sequência mais longa. ( acq_relou seq_csttambém incluir releasee funcionaria aqui.)

As garantias no padrão se aplicam a todos os casos em que as condições se aplicam - liberação de armazenamento (inclusive como parte de um RMW), zero ou mais operações RMW intervenientes (de qualquer memory_order), então uma operação de aquisição sincroniza com a operação de liberação original da qual viu um valor (ou um valor dependente dela por meio de uma cadeia de RMWs).

No formalismo do padrão, cada releaseoperação lidera sua própria sequência de liberação e, portanto, você pode ter sequências de liberação sobrepostas. (Eu acho; não verifiquei duas vezes o texto do padrão.)
Também funciona pensar em uma cadeia de RMWs como uma sequência de liberação e acquireoperações sincronizadas com todas releaseas operações -ou-mais fortes na cadeia.

Uma loja pura quebra uma sequência de liberação , mas você não tem essas em D_dependencies.

Relacionado:

• O que significa "sequência de liberação"?
• Por que a sequência de liberação só pode conter leitura-modificação-gravação, mas não gravação pura (veja meus comentários lá)

Sim, e você também pode usar std::counting_semaphore , onde você pode usar release() / e try_acquire() .

#include <iostream>
#include <thread>
#include <semaphore>
#include <cassert>
#include <atomic>
#include <chrono>

// global vars
int a = 0;
int b = 0;
int c = 0;

std::atomic<int> remaining{3}; 
std::counting_semaphore<3> sem(0); // initialized to 0

void thread_A_function() {
    // Do work for thread A
    std::cout << "Thread A working..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(200)); // A takes 200 ms
    
    a = 1;
    remaining.fetch_sub(1, std::memory_order_relaxed);
    sem.release(); // Increment semaphore by 1
    std::cout << "Thread A completed. Remaining threads: " << remaining.load() << std::endl;
}

void thread_B_function() {
    // Do work for thread B
    std::cout << "Thread B working..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(300)); // B takes 300 ms
    
    b = 1;
    remaining.fetch_sub(1, std::memory_order_relaxed);
    sem.release(); // Increment semaphore by 1
    std::cout << "Thread B completed. Remaining threads: " << remaining.load() << std::endl;
}

void thread_C_function() {
    // Do work for thread C
    std::cout << "Thread C working..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // C takes 100 ms
    
    c = 1;
    remaining.fetch_sub(1, std::memory_order_relaxed);
    sem.release(); // Increment semaphore by 1
    std::cout << "Thread C completed. Remaining threads: " << remaining.load() << std::endl;
}

void thread_D_function() {
    bool done = false;
    int acquired = 0;
    
    while (!done) {
        // D tries to grab all 3 tokens 
        while (acquired < 3) {
            if (!sem.try_acquire()) { // succeeds only if semaphores's count > 0, breaks otherwise
                break; 
            }
            acquired++;
        }
        
        if (acquired == 3) {
            done = true;
            std::cout << "Thread D: All threads completed. Checking results..." << std::endl;
            assert(a + b + c == 3);
            std::cout << "Assertion passed: a + b + c = " << (a + b + c) << std::endl;
        } else {
            int current = remaining.load(std::memory_order_relaxed);
            std::cout << "Thread D: Not all threads completed yet. Acquired: " << acquired 
                      << ", Remaining: " << current << std::endl;
            
            // D Does other work while waiting (non-blocking)
            std::cout << "Thread D: Doing other work..." << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
        }
    }
}

int main() {
    
    std::thread A(thread_A_function);
    std::thread B(thread_B_function);
    std::thread C(thread_C_function);
    std::thread D(thread_D_function);
    
    A.join();
    B.join();
    C.join();
    D.join();
    
    return 0;
}

A execução do programa acima produz esta saída:

Thread A working...
Thread B working...
Thread C working...
Thread D: Not all threads completed yet. Acquired: 0, Remaining: 3
Thread D: Doing other work...
Thread D: Not all threads completed yet. Acquired: 0, Remaining: 3
Thread D: Doing other work...
Thread C completed. Remaining threads: 2
Thread D: Not all threads completed yet. Acquired: 1, Remaining: 2
Thread D: Doing other work...
Thread D: Not all threads completed yet. Acquired: 1, Remaining: 2
Thread D: Doing other work...
Thread A completed. Remaining threads: 1
Thread D: Not all threads completed yet. Acquired: 2, Remaining: 1
Thread D: Doing other work...
Thread D: Not all threads completed yet. Acquired: 2, Remaining: 1
Thread D: Doing other work...
Thread B completed. Remaining threads: 0
Thread D: All threads completed. Checking results...
Assertion passed: a + b + c = 3

Assim, o Thread D (thread consumidor) pode fazer outro trabalho de forma independente e verificar periodicamente se outros threads produtores (A, B e C) concluíram seu trabalho.