C++ std:: atomic vs. Boost atomic

multithreading

Question

En mi aplicación, tengo un int y una variable bool, a los que se accede (escritura / lectura múltiple) por varios subprocesos. Actualmente, estoy usando dos mutexes, uno para int y otro para bool para proteger esas variables.

Escuché sobre el uso de variables atómicas y operadores para escribir un programa multihilo sin bloqueo. Mis preguntas son

1. ¿Cuál es la definición de variables atómicas y operadores?
2. ¿Cuál es la principal diferencia entre std :: atomic y boost / atomic.hpp ? ¿Cuál es más estándar o popular?
3. ¿Son estas bibliotecas dependientes de la plataforma? Estoy usando gnu gcc 4.6 en Linux en este momento, pero lo ideal es que sea multiplataforma. Escuché que la definición de "atómico" en realidad también depende del hardware. ¿Alguien puede explicar eso también?
4. ¿Cuál es la mejor manera de compartir una variable bool entre múltiples hilos? Preferiría no usar la palabra clave " volátil ".

¿Son seguros estos hilos?

double double_m; // double_m is only accessed by current thread.
std::atomic<bool> atomic_bool_x;
atomic_bool_x = true && (double_m > 12.5);

int int_n; // int_n is only accessed by current thread.
std::atomic<int> atomic_int_x;
std::atomic<int> atomic_int_y;
atomic_int_y = atomic_int_x * int_n;

Answer 1

1. Ver std :: plantilla de clase atómica
2. std::atomic es estándar desde C ++ 11, y Boost es más antiguo. Pero como es estándar ahora, preferiría std::atomic .
3. ?? Puede usar std::atomic con cada compilador de C ++ 11 en cada plataforma que desee.

4. Sin más información ...

   std :: atomic;

Answer 2

Creo que std::atomic (C ++ 11) y boost.atomic son equivalentes. Si su compilador todavía no admite std::atomic , use boost::atomic .

Answer 3

Lo volátil es ortogonal a lo que usas para implementar atómica. En C ++ le dice al compilador que no es seguro realizar optimizaciones con esa variable. Herb Sutters lo expone:

Para escribir de forma segura un código sin bloqueo que se comunique entre subprocesos sin usar bloqueos, prefiera usar variables atómicas ordenadas: Java / .NET volatil, C ++ 0x atómico y C compatible con atomic_T.

Para comunicarse de manera segura con un hardware especial u otra memoria que tenga una semántica inusual, use variables no optimizables: ISO C / C ++ volátil. Recuerde que las lecturas y escrituras de estas variables no son necesariamente atómicas, sin embargo.

Finalmente, para expresar una variable que tiene una semántica inusual y tiene alguna o todas las garantías de atomicidad y / o ordenación necesarias para la codificación sin bloqueo, solo el estándar ISO C ++ 0x draft proporciona una forma directa de deletrearlo: atómico volátil .

(de http://drdobbs.com/article/print?articleId=212701484&siteSectionName=parallel )

Answer 4

No soy un experto ni nada, pero esto es lo que sé:

1. std::atomic simplemente dice que la load y el store llamadas (y algunas otras operaciones) al mismo tiempo están bien definidos. Una operación atómica es indivisible: nada puede suceder "en el medio".
2. Asumo que std::atomic se basa en boost::atomic . Si puedes, usa std , de lo contrario usa boost .
3. Ambos son portátiles, y el std es completamente correcto, sin embargo, su compilador deberá ser compatible con C ++ 11
4. Probable std::atomic_bool . No deberías necesitar usar volatile.

Además, creo que la load / store difiere del operator= / operator T solo load / store son atómicos .

No importa. Revisé el estándar y parece que los operadores están definidos en términos de load / store / etc, sin embargo, pueden devolver cosas diferentes.

Otras lecturas:

• http://en.cppreference.com/w/cpp/atomic/atomic
• Estándar C ++ 11
• C ++ Concurrencia en Acción