c++ - pthread mutex example
¿Son C++ lecturas y escrituras de un int Atomic? (15)
A partir del problema de caché mencionado anteriormente ...
Si transfiere el código a un procesador con un tamaño de registro más pequeño, ya no será atómico.
OMI, problemas de enhebrado son demasiado espinosos para arriesgarlo.
Tengo dos hilos, uno que actualiza un int y otro que lo lee. Este es un valor estadístico donde el orden de las lecturas y escrituras es irrelevante.
Mi pregunta es, ¿necesito sincronizar el acceso a este valor de varios bytes de todos modos? O, dicho de otra manera, puede que parte de la escritura se complete y se interrumpa, y luego la lectura ocurre.
Por ejemplo, piense en un valor = 0x0000FFFF que obtiene un valor incrementado de 0x00010000.
¿Hay algún momento en que el valor se vea como 0x0001FFFF del que debería estar preocupado? Sin duda, cuanto más grande sea el tipo, más posible es que algo así suceda.
Siempre sincronicé este tipo de accesos, pero sentía curiosidad por lo que piensa la comunidad.
Al principio uno podría pensar que las lecturas y escrituras del tamaño de la máquina nativa son atómicas, pero hay una serie de problemas con los que lidiar, incluida la coherencia del caché entre los procesadores / núcleos. Utilice operaciones atómicas como Interbloqueado * en Windows y su equivalente en Linux. C ++ 0x tendrá una plantilla "atómica" para envolverlos en una interfaz agradable y multiplataforma. Por ahora, si está utilizando una capa de abstracción de plataforma, puede proporcionar estas funciones. ACE sí, vea la plantilla de clase ACE_Atomic_Op .
Algunas personas piensan que ++ c es atómico, pero tienen un ojo en el conjunto generado. Por ejemplo, con ''gcc -S'':
movl cpt.1586(%rip), %eax
addl $1, %eax
movl %eax, cpt.1586(%rip)
Para incrementar un int, el compilador primero lo carga en un registro, y lo almacena de nuevo en la memoria. Esto no es atómico.
Chico, qué pregunta. La respuesta es:
Sí, no, hmmm, bueno, depende
Todo se reduce a la arquitectura del sistema. En un IA32, una dirección correctamente alineada será una operación atómica. Las escrituras desalineadas pueden ser atómicas, depende del sistema de almacenamiento en caché en uso. Si la memoria se encuentra dentro de una sola línea de caché L1, entonces es atómica; de lo contrario, no lo es. El ancho del bus entre la CPU y la RAM puede afectar la naturaleza atómica: una escritura de 16 bits alineada correctamente en un 8086 era atómica, mientras que la misma escritura en un 8088 no era porque el 8088 solo tenía un bus de 8 bits mientras que el 8086 tenía un Bus de 16 bits
Además, si está utilizando C / C ++, no olvide marcar el valor compartido como volátil; de lo contrario, el optimizador pensará que la variable nunca se actualizará en uno de sus subprocesos.
Debe sincronizar, pero en ciertas arquitecturas hay formas eficientes de hacerlo.
Lo mejor es usar subrutinas (tal vez enmascaradas detrás de macros) para que pueda reemplazar de manera condicional las implementaciones con las específicas de la plataforma.
El kernel de Linux ya tiene algo de este código.
Definitivamente ¡NO! Esa respuesta de nuestra máxima autoridad en C ++, M. Boost:
No se garantiza que las operaciones en variables "ordinarias" sean atómicas.
En Windows, Interlocked *** Exchange *** Add se garantiza que es atómico.
Estoy de acuerdo con muchos y especialmente con Jason . En Windows, uno probablemente usaría InterlockedAdd y sus amigos.
La única forma portátil es usar el tipo sig_atomic_t definido en el encabezado signal.h para su compilador. En la mayoría de las implementaciones C y C ++, eso es un int. Luego declare su variable como "volátil sig_atomic_t".
No, no lo son (o al menos no pueden suponer que lo son). Habiendo dicho eso, hay algunos trucos para hacer esto atómicamente, pero generalmente no son portátiles (ver Compare-and-swap ).
Para hacer eco de lo que todos dijeron en el piso de arriba, el lenguaje pre-C ++ 0x no puede garantizar nada sobre el acceso a la memoria compartida desde varios subprocesos. Cualquier garantía dependería del compilador.
Sí, necesita sincronizar accesos. En C ++ 0x será una carrera de datos y un comportamiento indefinido. Con los hilos POSIX ya es un comportamiento indefinido.
En la práctica, es posible que obtenga valores incorrectos si el tipo de datos es más grande que el tamaño de la palabra nativa. Además, es posible que otro subproceso no vea el valor escrito debido a las optimizaciones que mueven la lectura o la escritura.
SI está leyendo / escribiendo el valor de 4 bytes Y está alineado DWORD en la memoria Y se está ejecutando en la arquitectura I32, ENTONCES las lecturas y escrituras son atómicas.
Tomemos este ejemplo
int x;
x++;
x=x+5;
Se asume que la primera declaración es atómica porque se traduce en una única directiva de ensamblado INC que toma un solo ciclo de CPU. Sin embargo, la segunda asignación requiere varias operaciones, por lo que claramente no es una operación atómica.
Otro por ejemplo,
x=5;
De nuevo, debes desmontar el código para ver qué sucede exactamente aquí.
tc, creo que en el momento en que use una constante (como 6), la instrucción no se completará en un ciclo de máquina. Intenta ver el conjunto de instrucciones de x + = 6 en comparación con x ++