a multiplicación flotante se realiza más lentamente dependiendo de los operandos en C
Estoy realizando un cálculo de plantilla en una matriz que leí previamente de un archivo. Utilizo dos tipos diferentes de matrices (tipo no cero y tipo cero). Ambos tipos comparten el valor de los límites (1000 generalmente), mientras que el resto de los elementos son 0 para el tipo Cero y 1 para el tipo No Cero.
El código almacena la matriz del archivo en dos matrices asignadas del mismo tamaño. Luego realiza una operación en cada elemento de una matriz usando su propio valor y valores de vecinos (suma x 4 y mul x 1), y almacena el resultado en la segunda matriz. Una vez que finaliza el cálculo, se intercambian los punteros de las matrices y se realiza la misma operación durante un número finito de veces. Aquí tienes el código central:
#define GET(I,J) rMat[(I)*cols + (J)]
#define PUT(I,J) wMat[(I)*cols + (J)]
for (cur_time=0; cur_time<timeSteps; cur_time++) {
for (i=1; i<rows-1; i++) {
for (j=1; j<cols-1; j++) {
PUT(i,j) = 0.2f*(GET(i-1,j) + GET(i,j-1) + GET(i,j) + GET(i,j+1) + GET(i+1,j));
}
}
// Change pointers for next iteration
auxP = wMat;
wMat = rMat;
rMat = auxP;
}
El caso que expongo utiliza una cantidad fija de 500 timeSteps (iteraciones externas) y un tamaño de matriz de 8192 filas y 8192 columnas, pero el problema persiste mientras cambia el número de timeSteps o el tamaño de la matriz. Tenga en cuenta que solo mido el tiempo de esta parte concreta del algoritmo, por lo que leer la matriz del archivo ni ninguna otra cosa afecta la medida del tiempo.
Lo que sucede es que obtengo diferentes tiempos dependiendo del tipo de matriz que uso, obteniendo un rendimiento mucho peor cuando uso el tipo Cero (cualquier otra matriz funciona igual que el tipo No Cero, ya que he intentado generar una matriz llena de valores aleatorios).
Estoy seguro de que es la operación de multiplicación, ya que si la elimino y dejo solo las adiciones, realizan lo mismo. Tenga en cuenta que con el tipo de matriz Cero, la mayoría del tipo el resultado de la suma será 0, por lo que la operación será "0.2 * 0".
Este comportamiento es ciertamente extraño para mí, ya que pensé que las operaciones de coma flotante eran independientes de los valores de los operandos, lo cual no parece ser el caso aquí. También intenté capturar y mostrar excepciones SIGFPE en caso de que ese fuera el problema, pero no obtuve resultados.
En caso de que ayude, estoy usando un procesador Intel Nehalem y gcc 4.4.3.