title: Floating multiplication performing slower depending of operands in C
body: <p>I am performing a stencil computation on a matrix I previously read from a file. I use two different kinds of matrices (NonZero type and Zero type). Both types share the value of the boundaries (1000 usually), whilst the rest of the elements are 0 for Zero type and 1 for NonZero type.</p>
  
  <p>The code stores the matrix of the file in two allocated matrices of the same size. Then it performs an operation in every element of one matrix using its own value and values of neighbours (add x 4 and mul x 1), and stores the result in the second matrix. Once the computation is finished, the pointers for matrices are swapped and the same operation is perform for a finite amount of times. Here you have the core code:</p>
  
  <pre><code>#define GET(I,J) rMat[(I)*cols + (J)]
  #define PUT(I,J) wMat[(I)*cols + (J)]
  
  for (cur_time=0; cur_time&lt;timeSteps; cur_time++) {
      for (i=1; i&lt;rows-1; i++) {
          for (j=1; j&lt;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;
  }
  </code></pre>
  
  <p>The case I am exposing uses a fixed amount of 500 timeSteps (outer iterations) and a matrix size of 8192 rows and 8192 columns, but the problem persists while changing number of timeSteps or matrix size. Note that I only measure time of this concrete part of algorithm, so reading matrix from file nor anything else affects the time measure.</p>
  
  <p>What it happens, is that I get different times depending on which type of matrix I use, obtaining a much worse performance when using Zero type (every other matrix performs same as NonZero type, as I have already tried to generate a matrix full of random values).</p>
  
  <p>I am certain it is the multiplication operation, as if I remove it and leave only the adds, they perform the same. Note that with Zero matrix type, most of the type the result of the sum will be 0, so the operation will be "0.2*0".</p>
  
  <p>This behaviour is certainly weird for me, as I thought that floating point operations were independent of values of operands, which does not look like the case here. I have also tried to capture and show SIGFPE exceptions in case that was the problem, but I obtained no results.</p>
  
  <p>In case it helps, I am using an Intel Nehalem processor and gcc 4.4.3.</p>