¿Por qué el calificador volátil se usa a través de std :: atomic?

Question

Por lo que he leído de Herb Sutter y others, pensaría que volatile y la programación concurrente eran conceptos completamente ortogonales, al menos en lo que respecta a C/C++. Sin embargo, en GCC implementation todas las funciones miembro de std::atomic tienen el calificador volatile. Lo mismo es cierto en Anthony Williams's implementation de std::atomic.

¿De qué se trata, mis variables atomic<> necesitan ser volatile o no?

Answer 1

¿Por qué el calificador volatile se usa en todo std::atomic?

Para que los objetos volátiles también puedan ser atómicos. Ver here:

La cita relevante es

Las funciones y las operaciones se definen para trabajar con objetos volátiles, por lo que las variables que deben ser volátiles también pueden ser atómicas. El calificador volátil, sin embargo, no es necesario para la atomicidad.

hacer mi atomic<> las variables tienen que ser volatile o no?

No, los objetos atómicos no tienen que ser volátiles.

Answer 2

Como const, volátil es transitivo. Si declara un método como volatile, no puede llamar a ningún método no volátil ni a ninguno de sus atributos de miembro. Al tener std::atomic métodos volatile, permite llamar a los métodos miembros volatile en las clases que contienen las variables std::atomic.

No estoy teniendo un buen día ... tan confuso ... tal vez un poco de ayuda ejemplo:

struct element { 
    void op1() volatile; 
    void op2(); 
}; 
struct container { 
    void foo() volatile { 
     e.op1(); // correct 
     //e.op2(); // compile time error 
    } 
    element e; 
}; 

Answer 3

Para resumir lo que otros han escrito correctamente:

C/C++ es para volatile acceso a hardware e interrupciones. C++ 11 atomic<> es para comunicación entre hilos (por ejemplo, en código sin bloqueo). Esos dos conceptos/usos son ortogonales, pero tienen requisitos superpuestos y es por eso que las personas a menudo los han confundido.

La razón de que atomic<> tiene funciones volátiles calificados es la misma razón por la que tiene funciones const cualificado, ya que es posible, en principio, para un objeto sea tanto atomic<> y también const y/o volatile.

Por supuesto, como mi artículo señaló, otra fuente de confusión es que C/C++ volatile no es lo mismo que C#/Java volatile (este último es básicamente equivalente a C++ 11 atomic<>).