un oggetto atomico è pericoloso in qualsiasi contesto in cui un oggetto normale è sicuro?

la mia domanda è semplice: esiste un algoritmo parallelo in cui l'uso di un oggetto di tipo banale T è legale e sicuro (ben definito, garantito per funzionare) e l'uso di un oggetto std::atomic<T> porta ad un comportamento non specificato o indefinito? in altre parole, è possibile che un tipo non atomico fornisca garanzie più forti di un tipo atomico?

tutte le garanzie di visibilità della memoria sono valide per oggetti atomici quando sono valide per oggetti regolari?

[ciò significherebbe che un compilatore potrebbe trattare (rilassato) operazioni atomiche e non atomiche lo stesso, semplificando la rappresentazione intermedia.]

se sì, è formalmente dimostrabile?

naturalmente i tipi T tali che std::atomic<T> non è una specializzazione valida di std::atomic non contano.


En title : Is an atomic object unsafe in any context where a plain object is safe?

3 Comments:

  1. nessun scenario in cui un valore non-atomico ha una garanzia più forte rispetto ad esso è equivalente atomic.

    l'unico cattivo modello che posso pensare, è quando uno sviluppatore fa un errore di assumere che se tutti i membri di una struttura di dati sono individualmente thread sicuro, allora l'intera struttura di dati si presume essere thread sicuro. questo non sarebbe un presupposto corretto.

    si consideri il seguente ipotetico:

    class Volume
    {
        atomic<int> _width;
        atomic<int> _height;
        atomic<int> _depth;
    public:
       int computeValue() {return (_width*_height*_depth);}
       void SetInternals(int w, int h, int d) {_height=h;_width=w;_depth=d;}
    };
    

    dove il thread 1 fa questo:

    f->SetInternals(42, 100, 200);
    

    e il thread 2 lo fa allo stesso tempo.

    int something_important = f->computeValue();
    

    si può vedere che il valore restituito da computeValue può essere danneggiato se entrambi i thread eseguire allo stesso tempo.

    è possibile ottenere il comportamento filetto sicuro desiderato con una combinazione mutex e blocco invece di atomici:

    class Volume
    {
        int _width;
        int _height;
        int _depth;
        mutex _mutex;
    public:
       int computeValue() {
            lock_guard<mutex> lck(_mutex);
            int result = _width*_height*_depth;
            return result;
       }
       void SetInternals(int w, int h, int d) {
          lock_guard<mutex> lck(_mutex);
          _height=h;_width=w;_depth=d;
       }
    };
    
    1. naturalmente, se si utilizza il mutex e gli atomici, è ancora sicuro. quindi non è la stessa cosa che gli OP hanno chiesto, dove se avete appena tirato fuori gli atomici, diventa improvvisamente più sicuro.

More similar articles:

  • definizione di "oggetto atomico"
  • è sicuro dereferencing un SOLO puntatore non-atomico ad un oggetto atomico in differenti thread?
  • è questa implementazione C ++ per un galleggiante atomico sicuro?
  • c ++ modello di memoria: i carichi seq_cst si sincronizzano con i negozi seq_cst?
  • più lettori veloci singolo lento scrittore: è l'utilizzo di ombra-dati con indice atomico sicuro?
  • è questa funzione con filo atomico sicuro
  • è un contatore atomico rilassato sicuro?
  • STD:: il metodo di carico atomico diminuisce il numero di riferimento quando usato con std:: Shared_ptr
  • assegnazione multipla in una istruzione per variabili di bool atomico
  • un modello C ++ è solo "grammatica sicura" e non digitare prima sicuro?
  • e 'sicuro di memset bool a 0?
  • efficienza di ordinazione del carico atomico C ++
  • propagazione/visibilità dell'operazione atomica (carico atomico vs carico atomico RMW)
  • perché il qualificatore volatile è usato attraverso fuori std:: atomico?
  • dati di decremento atomico membro di un'unione?
  • un mutex condiviso è più efficiente di un atomico di una struttura relativamente grande?
  • un carico non-atomico sulla stessa linea di cache di una variabile atomica causa il fallimento della variabile atomica?
  • dovrebbe std:: le variabili atomiche usano la sintassi "normale" o "load" e "store"?
  • fa C ++ garantisce che è sicuro accedere agli elementi adiacenti di un array da due thread
  • è atomica di ritorno e dovrei usare provvisorio in getter per essere filetto sicuro?
  • pre-incremento vs post-incremento su std:: atomico
  • c ++ memory_order_consumare, kill_dipendenze, dependency-ordered-prima, sincronizzi-con
  • ridimensionare un vettore di atomico?
  • c ++ 11 ha introdotto un modello di memoria standardizzato. che cosa significa? e come influenzerà la programmazione C ++?
  • è l'aumento atomico e la comparazione thread-safe
  • sarà ordine di memoria rilassata portare a loop infinito qui?
  • e 'sicuro lanciare un char non firmato * a char *, e trattare il puntatore dereferenced come se punti davvero ad un char?
  • è ancora sicuro eliminare il valore nullo in c ++ 0x?
  • lo sgabello atomico non protegge il contatore non-atomico
  • reinterpretare_cast tra char * e std:: uint8_t * - sicuro?