¿Por qué mi programa es lento cuando recorro exactamente 8192 elementos?

Aquí está el extracto del programa en cuestión. La matriz img[][]tiene el tamaño SIZE × SIZE, y se inicializa en:

img[j][i] = 2 * j + i

Luego, haces una matriz res[][], y cada campo aquí está hecho para ser el promedio de los 9 campos a su alrededor en la matriz img. El borde se deja en 0 por simplicidad.

for(i=1;i<SIZE-1;i++) 
    for(j=1;j<SIZE-1;j++) {
        res[j][i]=0;
        for(k=-1;k<2;k++) 
            for(l=-1;l<2;l++) 
                res[j][i] += img[j+l][i+k];
        res[j][i] /= 9;
}

Eso es todo lo que hay en el programa. Para completar, esto es lo que viene antes. Ningún código viene después. Como puede ver, es solo inicialización.

#define SIZE 8192
float img[SIZE][SIZE]; // input image
float res[SIZE][SIZE]; //result of mean filter
int i,j,k,l;
for(i=0;i<SIZE;i++) 
    for(j=0;j<SIZE;j++) 
        img[j][i] = (2*j+i)%8196;

Básicamente, este programa es lento cuando SIZE es un múltiplo de 2048, por ejemplo, los tiempos de ejecución:

SIZE = 8191: 3.44 secs
SIZE = 8192: 7.20 secs
SIZE = 8193: 3.18 secs

El compilador es GCC. Por lo que sé, esto se debe a la gestión de la memoria, pero realmente no sé demasiado sobre ese tema, por lo que pregunto aquí.

Además, cómo solucionar esto sería bueno, pero si alguien pudiera explicar estos tiempos de ejecución, ya estaría lo suficientemente feliz.

Ya conozco malloc / free, pero el problema no es la cantidad de memoria utilizada, es simplemente el tiempo de ejecución, por lo que no sé cómo ayudaría eso.

La diferencia es causada por el mismo problema de superalineación de las siguientes preguntas relacionadas:

• ¿Por qué la transposición de una matriz de 512x512 es mucho más lenta que la transposición de una matriz de 513x513?
• Multiplicación matricial: pequeña diferencia en el tamaño de la matriz, gran diferencia en los tiempos

Pero eso es solo porque hay otro problema con el código.

A partir del bucle original:

for(i=1;i<SIZE-1;i++) 
    for(j=1;j<SIZE-1;j++) {
        res[j][i]=0;
        for(k=-1;k<2;k++) 
            for(l=-1;l<2;l++) 
                res[j][i] += img[j+l][i+k];
        res[j][i] /= 9;
}

Primero note que los dos bucles internos son triviales. Se pueden desenrollar de la siguiente manera:

for(i=1;i<SIZE-1;i++) {
    for(j=1;j<SIZE-1;j++) {
        res[j][i]=0;
        res[j][i] += img[j-1][i-1];
        res[j][i] += img[j  ][i-1];
        res[j][i] += img[j+1][i-1];
        res[j][i] += img[j-1][i  ];
        res[j][i] += img[j  ][i  ];
        res[j][i] += img[j+1][i  ];
        res[j][i] += img[j-1][i+1];
        res[j][i] += img[j  ][i+1];
        res[j][i] += img[j+1][i+1];
        res[j][i] /= 9;
    }
}

Eso deja los dos bucles externos que nos interesan.

Ahora podemos ver que el problema es el mismo en esta pregunta: ¿Por qué el orden de los bucles afecta el rendimiento al iterar sobre una matriz 2D?

Está iterando la matriz a nivel de columna en lugar de a nivel de fila.

Para resolver este problema, debe intercambiar los dos bucles.

for(j=1;j<SIZE-1;j++) {
    for(i=1;i<SIZE-1;i++) {
        res[j][i]=0;
        res[j][i] += img[j-1][i-1];
        res[j][i] += img[j  ][i-1];
        res[j][i] += img[j+1][i-1];
        res[j][i] += img[j-1][i  ];
        res[j][i] += img[j  ][i  ];
        res[j][i] += img[j+1][i  ];
        res[j][i] += img[j-1][i+1];
        res[j][i] += img[j  ][i+1];
        res[j][i] += img[j+1][i+1];
        res[j][i] /= 9;
    }
}

Esto elimina por completo todo el acceso no secuencial, por lo que ya no obtienes ralentizaciones aleatorias en grandes potencias de dos.

Core i7 920 @ 3.5 GHz

Código original:

8191: 1.499 seconds
8192: 2.122 seconds
8193: 1.582 seconds

Bucles exteriores intercambiados:

8191: 0.376 seconds
8192: 0.357 seconds
8193: 0.351 seconds

Las siguientes pruebas se han realizado con el compilador de Visual C ++, ya que es utilizado por la instalación predeterminada de Qt Creator (supongo que sin bandera de optimización). Cuando uso GCC, no hay una gran diferencia entre la versión de Mystical y mi código "optimizado". Entonces, la conclusión es que las optimizaciones del compilador se encargan de la micro optimización mejor que los humanos (yo por fin). Dejo el resto de mi respuesta como referencia.

No es eficiente procesar imágenes de esta manera. Es mejor usar matrices de dimensión única. El procesamiento de todos los píxeles se realiza en un bucle. El acceso aleatorio a los puntos se puede hacer usando:

pointer + (x + y*width)*(sizeOfOnePixel)

En este caso particular, es mejor calcular y almacenar en caché la suma de tres grupos de píxeles horizontalmente porque se usan tres veces cada uno.

He hecho algunas pruebas y creo que vale la pena compartirlas. Cada resultado es un promedio de cinco pruebas.

Código original por usuario1615209:

8193: 4392 ms
8192: 9570 ms

Versión mística:

8193: 2393 ms
8192: 2190 ms

Dos pases utilizando una matriz 1D: primer pase para sumas horizontales, segundo para suma vertical y promedio. Direccionamiento de dos pasos con tres punteros y solo incrementos como este:

imgPointer1 = &avg1[0][0];
imgPointer2 = &avg1[0][SIZE];
imgPointer3 = &avg1[0][SIZE+SIZE];

for(i=SIZE;i<totalSize-SIZE;i++){
    resPointer[i]=(*(imgPointer1++)+*(imgPointer2++)+*(imgPointer3++))/9;
}

8193: 938 ms
8192: 974 ms

Dos pasadas usando una matriz 1D y direccionando así:

for(i=SIZE;i<totalSize-SIZE;i++){
    resPointer[i]=(hsumPointer[i-SIZE]+hsumPointer[i]+hsumPointer[i+SIZE])/9;
}

8193: 932 ms
8192: 925 ms

Una pasada almacenando sumas horizontales solo una fila por delante para que permanezcan en la caché:

// Horizontal sums for the first two lines
for(i=1;i<SIZE*2;i++){
    hsumPointer[i]=imgPointer[i-1]+imgPointer[i]+imgPointer[i+1];
}
// Rest of the computation
for(;i<totalSize;i++){
    // Compute horizontal sum for next line
    hsumPointer[i]=imgPointer[i-1]+imgPointer[i]+imgPointer[i+1];
    // Final result
    resPointer[i-SIZE]=(hsumPointer[i-SIZE-SIZE]+hsumPointer[i-SIZE]+hsumPointer[i])/9;
}

8193: 599 ms
8192: 652 ms

Conclusión:

• No hay beneficios de usar varios punteros y solo incrementos (pensé que habría sido más rápido)
• El almacenamiento en caché de sumas horizontales es mejor que calcularlas varias veces.
• Dos pases no son tres veces más rápidos, solo dos veces.
• Es posible lograr 3,6 veces más rápido utilizando una sola pasada y almacenando en caché un resultado intermedio

Estoy seguro de que es posible hacerlo mucho mejor.

NOTA Tenga en cuenta que escribí esta respuesta para abordar problemas generales de rendimiento en lugar del problema de caché explicado en la excelente respuesta de Mystical. Al principio era solo un pseudocódigo. Me pidieron que hiciera pruebas en los comentarios ... Aquí hay una versión completamente refactorizada con pruebas.