Estoy ejecutando este código en OpenMP para la multiplicación de matrices y medí sus resultados:

#pragma omp for schedule(static)
for (int j = 0; j < COLUMNS; j++)
    for (int k = 0; k < COLUMNS; k++)
        for (int i = 0; i < ROWS; i++)
            matrix_r[i][j] += matrix_a[i][k] * matrix_b[k][j];

Hay diferentes versiones del código en función de dónde coloco el#pragma omp directiva: antes del bucle j, el bucle k o el bucle i. Además, para cada una de esas variantes ejecuté diferentes versiones para la programación estática predeterminada, la programación estática con los fragmentos 1 y 10 y la programación dinámica con los mismos fragmentos. También medí el número de accesos de CC, fallos de CC, relojes de CPU, instrucciones retiradas y otros indicadores de rendimiento en CodeXL. Aquí están los resultados para la matriz de tamaño 1000x1000 en AMD Phenom I X4 945:

Resultados de mediciones de desempeño

Dóndemultiply_matrices_1_dynamic_1 es una función con#pragma omp antes del primer ciclo y la programación dinámica con el fragmento 1, etc. Aquí hay algunas cosas que no entiendo bien sobre los resultados y agradecería ayuda:

La versión estática predeterminada con paralelización antes del ciclo interno se ejecuta en 2.512 segundos, mientras que la versión secuencial se ejecuta en 31.683 segundos, a pesar del hecho de que se ejecutó en una máquina de 4 núcleos, así que imaginé que la mayor aceleración posible sería 4x. ¿Es lógicamente posible que eso ocurra, o se trata de algún error? ¿Cómo puedo explicar eso?CodeXL dice que la tercera versión con programación estática tiene un número mucho menor de accesos DC (y errores) que las otras versiones. ¿Porqué es eso? ¿No es en gran parte porque todos los hilos paralelos operan en la misma celda de la matriz b? ¿Es asi?Sé que la segunda versión es incorrecta debido al hecho de que los hilos podrían funcionar en la misma celda de la matriz R, lo que podría causar condiciones de carrera. Sin embargo, ¿por qué tiene un rendimiento más bajo? ¿La incorrección lo causa de alguna manera?Me doy cuenta de que la programación dinámica causa una sobrecarga, por lo que el código se ralentiza al usarlo. Además, con la tercera versión (con pragma antes del ciclo i), la programación se realiza muchas más veces (mil millones de veces con una matriz de 1000x1000), por lo que el algoritmo es mucho menos eficaz. Sin embargo, esta programación no parece causar desaceleración en la segunda versión (con pragma antes del segundo bucle). ¿Porqué es eso?

Además, estoy confundido acerca de la relación de los errores de TLB con los errores de caché. ¿Cuándo se usa DTLB específicamente? El documento de mi profesor dice que cada acceso de DC es una solicitud de DTLB, pero no entiendo cómo funciona: la cantidad de fallas de TLB es a menudo mayor que la cantidad de accesos de DC. ¿Cómo calculo el índice de fallas TLB? Mi profesor dice que son errores TBL / accesos DC. También dice que puedo calcular la localidad temporal por la relación de aciertos de caché y la localidad espacial por la relación de aciertos TLB. Como funciona exactamente?