Cómo hacer el bloqueo de memoria para este fragmento de código

Tengo este fragmento de código y estoy tratando de optimizarlo utilizando el método de coherencia de caché como la localidad temporal y espacial con bloqueo de caché. (https://www.intel.com/content/www/us/en/developer/articles/technical/cache-blocking-techniques.html)

void randFunction1(int *arrayb, int dimension) { int i, j; for (i = 0; i < dimension; ++i) for (j = 0; j < dimension; ++j) { arrayb[j * dimension+ i] = arrayb[j * dimension+ i] || arrayb[i * dimension+ j]; } }

Esto es lo que he optimizado, pero me dijeron que no parece usar las técnicas de bloques de memoria.

for (int i = 0; i < dimension; ++i){ int j = i; for (; j < dimension; ++j) { //acceso dos veces arrayb[j * dimension+ i] = arrayb[j * dimension+ i] || arrayb[i * dimension+ j]; arrayb[i * dimension+ j] = arrayb[i * dimension+ j] || arrayb[j * dimension + i]; } }

¿Alguien podría decirme cómo puedo aprovechar el bloqueo de caché (usando la localidad para tiles más pequeños) para este fragmento de código de muestra? ¡Cualquier ayuda es apreciada, gracias!

davy.ai

June 18, 2023 at 9:56 am

Para optimizar aún más el código utilizando bloqueo de caché, se puede dividir la matriz en teselas más pequeñas y procesarlas una por una, asegurándose de que las teselas encajen en la caché. Aquí se muestra una implementación de ejemplo:

void randFunction2(int *arrayb, int dimension, int tile_size)
{
    int i, j, k, l;

    for (i = 0; i < dimension; i += tile_size) {
        for (j = 0; j < dimension; j += tile_size) {
            for (k = i; k < i + tile_size; ++k) {
                for (l = j; l < j + tile_size; ++l) {
                    arrayb[l * dimension + k] = arrayb[l * dimension + k] || arrayb[k * dimension + l];
                }
            }
        }
    }
}

El parámetro tile_size determina el tamaño de cada tesela. Los bucles externos iteran sobre cada tesela, y los bucles internos iteran sobre cada elemento dentro de una tesela. Al procesar cada tesela por separado, podemos aprovechar la localidad temporal y espacial para mejorar el rendimiento de la caché.

Si las teselas son lo suficientemente grandes como para no caber en la caché, se pueden dividir en subteselas y procesarlas en un bucle anidado. Sin embargo, hay un equilibrio entre la eficiencia de la caché y la sobrecarga del bucle, por lo que es necesario experimentar con diferentes tamaños de teselas para encontrar el equilibrio óptimo.

Answer

davy.ai

June 18, 2023 at 9:56 am
Para optimizar aún más el código utilizando bloqueo de caché, se puede dividir la matriz en teselas más pequeñas y procesarlas una por una, asegurándose de que las teselas encajen en la caché. Aquí se muestra una implementación de ejemplo:
```
void randFunction2(int *arrayb, int dimension, int tile_size)
{
    int i, j, k, l;

    for (i = 0; i < dimension; i += tile_size) {
        for (j = 0; j < dimension; j += tile_size) {
            for (k = i; k < i + tile_size; ++k) {
                for (l = j; l < j + tile_size; ++l) {
                    arrayb[l * dimension + k] = arrayb[l * dimension + k] || arrayb[k * dimension + l];
                }
            }
        }
    }
}
```
El parámetro tile_size determina el tamaño de cada tesela. Los bucles externos iteran sobre cada tesela, y los bucles internos iteran sobre cada elemento dentro de una tesela. Al procesar cada tesela por separado, podemos aprovechar la localidad temporal y espacial para mejorar el rendimiento de la caché.

Si las teselas son lo suficientemente grandes como para no caber en la caché, se pueden dividir en subteselas y procesarlas en un bucle anidado. Sin embargo, hay un equilibrio entre la eficiencia de la caché y la sobrecarga del bucle, por lo que es necesario experimentar con diferentes tamaños de teselas para encontrar el equilibrio óptimo.

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

Cómo hacer el bloqueo de memoria para este fragmento de código

Answer

davy.ai