Compartir información falsa

En informática , el falso compartimiento es un patrón de uso que degrada el rendimiento y que puede surgir en sistemas con cachés distribuidas y coherentes del tamaño del bloque de recursos más pequeño gestionado por el mecanismo de caché. Cuando un participante del sistema intenta acceder periódicamente a datos que no están siendo modificados por otra parte, pero esos datos comparten un bloque de caché con datos que sí están siendo modificados, el protocolo de caché puede obligar al primer participante a recargar todo el bloque de caché a pesar de la falta de necesidad lógica. ^{[ 1 ]} El sistema de caché desconoce la actividad dentro de este bloque y obliga al primer participante a soportar la sobrecarga del sistema de caché requerida por el acceso compartido real a un recurso.

El uso más común de este término se encuentra en las cachés de CPU multiprocesador modernas , donde la memoria se almacena en caché en líneas de un tamaño de palabra que es una pequeña potencia de dos (por ejemplo, 64 bytes contiguos alineados ). Si dos procesadores operan sobre datos independientes en la misma región de direcciones de memoria almacenable en una sola línea, los mecanismos de coherencia de caché del sistema pueden forzar que toda la línea atraviese el bus o la interconexión con cada escritura de datos, lo que provoca bloqueos de memoria además de desperdiciar ancho de banda del sistema . En algunos casos, la eliminación del falso compartimiento puede resultar en mejoras de rendimiento de un orden de magnitud. ^{[ 2 ]} El falso compartimiento es un artefacto inherente de los protocolos de caché sincronizados automáticamente y también puede existir en entornos como sistemas de archivos distribuidos o bases de datos, pero su prevalencia actual se limita a las cachés de RAM.

#include <atomic> #include <chrono> #include <iostream> #include <latch> #include <thread> #include <vector>int main () { std :: vector < std :: jthread > threads ; const int hc = std :: jthread :: hardware_concurrency (); constexpr int testLimit = 256 ; // para simplificar, como máximo esa cantidad de elementosfor ( int nThreads = 1 ; nThreads <= hc && nThreads <= testLimit ; ​​++ nThreads ) { // medición precisa iniciando todos los hilos simultáneamente std :: latch sync ( nThreads );// algunos datos de piezas individuales para cada hilo individual struct { std :: atomic_char mightBeShared ; } globaldata [ testLimit ];// mitigación: ocupando una línea de caché completa // struct alignas(64) { std::atomic_char mightBeShared; } globaldata[testLimit];// suma de los tiempos de ejecución de todos los hilos std :: atomic_int64_t nsSum ( 0 );for ( int t = 0 ; t != nThreads ; ++ t ) { threads . emplace_back ([ & ]( int i ) { sync . arrive_and_wait (); // sincronizar el inicio de la ejecución del hilo a nivel del kernelauto start = std :: chrono :: high_resolution_clock :: now ();para ( std :: size_t r = 10'000'000 ; r -- ;) globaldata [ i ]. mightBeShared . fetch_add ( 1 );nsSum += std :: chrono :: duration_cast < std :: chrono :: nanoseconds > ( std :: chrono :: high_resolution_clock :: now () - start ) .count ();}, t ); }hilos.clear ( ); // unir todos los hilosstd :: cout << nThreads << " : " << static_cast <double> ( nsSum / ( 1.0e7 * nThreads ) ) << std :: endl ; } }

Este código muestra el efecto del falso compartimiento de datos. Crea un número creciente de hilos, desde uno hasta el número de hilos físicos del sistema. Cada hilo incrementa secuencialmente un byte específico para ese hilo (es decir, no compartido entre ellos). Cuanto mayor sea el nivel de contención entre hilos, más tiempo tardará cada incremento, a pesar de que cada hilo solo incrementa su propia parte de los datos globales. Estos son los resultados en un sistema Intel Core i7 de 12.ª generación con 6 núcleos de alto rendimiento y 8 de bajo consumo, lo que da como resultado 20 hilos:

Como se puede observar, el acceso concurrente por parte de esos hilos requiere aproximadamente 50 veces más tiempo de computación que con la mitigación, donde se duplica aproximadamente.

Existen maneras de mitigar los efectos del falso compartimiento de datos. Por ejemplo, el falso compartimiento de datos en las cachés de la CPU se puede prevenir reordenando variables o agregando relleno (bytes no utilizados) entre ellas. Sin embargo, algunos de estos cambios en el programa pueden aumentar el tamaño de los objetos, lo que conlleva un mayor uso de memoria. ^{[ 2 ]} Las transformaciones de datos en tiempo de compilación también pueden mitigar el falso compartimiento de datos. ^{[ 3 ]} No obstante, algunas de estas transformaciones no siempre están permitidas. Por ejemplo, el borrador del estándar del lenguaje de programación C++23 exige que los miembros de datos se organicen de manera que los miembros posteriores tengan direcciones más altas. ^{[ 4 ]}

Existen herramientas para detectar el falso compartimiento de datos. ^{[ 5 ] [ 6 ]} También existen sistemas que detectan y corrigen el falso compartimiento de datos en la ejecución de programas. Sin embargo, estos sistemas conllevan cierta sobrecarga de ejecución. ^{[ 7 ] [ 8 ]}

• Comprensión sencilla del falso reparto
• Blog de C++ de hoy: ¡El falso compartimiento vuelve a hacer acto de presencia!
• Artículo del Dr. Dobbs: Eliminar el falso intercambio de información
• Tenga cuidado al intentar eliminar el falso compartimiento en Java.