Modalità di blocco per la copia atomica nel Copy Manufacturer

Question

Sto scrivendo un costruttore di copia per una struttura dati che deve copiare due membri std::atomic<T> in un nuovo oggetto. Sebbene il processo non debba necessariamente essere atomico nel mio caso d'uso, preferirei avere la soluzione più corretta possibile.

Sono consapevole del fatto che il costruttore di copie viene eliminato esplicitamente con std::atomic<T> in modo da imporre agli utenti di utilizzare l'interfaccia atomica.

atomico (const atomico &) = elimina;

Quello che sto attualmente sto facendo qualcosa di simile:

SomeObject(const SomeObject& other): 
    _atomic1(other._atomic1.load()),    
    _atomic2(other._atomic2.load()) { 
... 
} 

Non credo che questa operazione è atomica, né so un modo per fare è così (senza serrature).

C'è un modo per copiare questi valori atomicamente (senza blocchi)?

Answer 1

L'unico modo è di creare una struttura banalmente copiabile S contenente due T s e utilizzare std::atomic<S>.

Si noti che questo funziona solo se si sta usando questo S dall'inizio - non c'è modo di caricare atomicamente due atomici separati senza blocchi.

Così, invece di:

struct SomeObject { 
    SomeObject(const SomeObject& other) : i(other.i.load()), j(other.j.load()) { } 
    std::atomic<int> i, j; 
}; 

fare questo:

struct SomeObject { 
    SomeObject(const SomeObject& other) : data(other.data.load()) { } 
    struct Data { int i, j; }; 
    std::atomic<Data> data; 
}; 

Si noti che questo potrebbe (probabilmente) usa ancora serrature internamente. Utilizzare is_lock_free per verificare se lo fa.