Variables de pila y pila falsas

Question

Tengo objetos de función pequeños pero de uso frecuente. Cada hilo obtiene su propia copia. Todo está asignado estáticamente. Las copias no comparten datos globales o estáticos. ¿Debo proteger estos objetos del intercambio falso?

Gracias. EDITAR: Aquí hay un programa de juguete que usa Boost.Threads. ¿Puede producirse el intercambio falso para el campo data?

#include <boost/thread/thread.hpp> 

struct Work { 
    void operator()() { 
     ++data; 
    } 

    int data; 
}; 

int main() { 
    boost::thread_group threads; 
    for (int i = 0; i < 10; ++i) 
     threads.create_thread(Work()); 
    threads.join_all(); 
} 

Answer 1

Falso intercambio entre hilos es cuando 2 o más hilos utilizan la misma línea de caché.

E.g. :

struct Work { 
    Work(int& d) : data(d) {} 
    void operator()() { 
     ++data; 
    } 

    int& data; 
}; 

int main() { 
    int false_sharing[10] = { 0 }; 
    boost::thread_group threads; 
    for (int i = 0; i < 10; ++i) 
     threads.create_thread(Work(false_sharing[i])); 
    threads.join_all(); 

    int no_false_sharing[10 * CACHELINE_SIZE_INTS] = { 0 }; 
    for (int i = 0; i < 10; ++i) 
     threads.create_thread(Work(no_false_sharing[i * CACHELINE_SIZE_INTS])); 
    threads.join_all(); 
} 

Los hilos en el primer bloque sufren de uso compartido falso. Los hilos en el segundo bloque no (gracias a CACHELINE_SIZE).

Los datos en la pila siempre están "lejos" de otros hilos. (Por ejemplo, en Windows, al menos un par de páginas).

Con su definición de objeto de función, puede aparecer el uso compartido falso, porque las instancias de Work se crean en el montón y este espacio de montón se utiliza dentro del subproceso.

Esto puede provocar que varias instancias Work sean adyacentes y, por lo tanto, puede incurrir en el intercambio de líneas de caché.

Pero ... su muestra no tiene sentido, porque los datos nunca se tocan fuera, por lo que el intercambio falso se produce de forma innecesaria.

La manera más fácil, para evitar problemas como este, es copiar los datos 'compartidos' localmente en la pila y luego trabajar en la copia de la pila. Cuando su trabajo finalice, cópielo de nuevo a la var. De salida.

por ejemplo:

struct Work { 
    Work(int& d) : data(d) {} 
    void operator()() 
    { 
     int tmp = data; 
     for(int i = 0; i < lengthy_op; ++i) 
      ++tmp; 
     data = tmp; 
    } 

    int& data; 
}; 

Esto evita todos los problemas con el uso compartido.

Answer 2

I' no se siente del todo seguro con los detalles, pero aquí está mi opinión:

(1) Su ejemplo simplificado se rompe desde el impulso create_thread espera una referencia, se pasa un temporal.

(2) si utiliza vector<Work> con un elemento para cada hilo, o bien, los tiene en memoria secuencialmente, se producirá el intercambio falso.

Answer 3

Hice un poco de investigación y parece que no hay una solución milagrosa para compartir falsamente. Esto es lo que se me ocurre (gracias a Christopher): 1) Rellene sus datos desde ambos lados con cosas no usadas o usadas con menos frecuencia. 2) Copie sus datos en la pila y cópielos nuevamente después de que todo el trabajo duro haya terminado. 3) Use la asignación de memoria alineada con el caché.