I changed to __attribute__ ((aligned(16))) because my gcc couldn't use the __declspec( align( 16 ) ).

__attribute__ ((aligned(16))) double U0[n1][n2];
__attribute__ ((aligned(16))) double U1[n1][n2];
__attribute__ ((aligned(16))) double U2[n1][n2];
__attribute__ ((aligned(16))) __m128d vU0[n1][n2];
__attribute__ ((aligned(16))) __m128d vU1[n1][n2];
__attribute__ ((aligned(16))) __m128d vU2[n1][n2];

It has no effects, times are the sames. I tried on a Core 2 and on an Xeon i7, same effects.

I would really appreciate if you could test it. This very simple code simulate the same kind of loop we face in CFD computations, and our codes can stay weeks running on 1024 Westmer CPUs. Reducing the cost of this loop would be very effective in terms of time and energy consumption. On top of that, with the new AVX, I expect results to be two times better.

Yes, it's for Computational Fluid Dynamics. My apologies.
We decompose spatial domain in millions of points, and use Navier Stokes equations to resolve fluid advancement in time. Considering that at each iteration, time step is around 1e-8 seconds of real simulated time, and that an iteration takes something like 15s to be done, you can imagine how important it is to optimize calculations. (after 1 week you have 6ms of simulated fluid in average)

The example program below is resolving heat diffusion in fluids, and is a good and simple representation of what is done at larger scales in our codes.

Thank you.

>> What computers do you use? Could you provide some details about a generation of CPU and model? Is it Intel, AMD, or something else?

In fact, a lot of different systems. I ran the code on the following type of architecture: AMD Opteron (don't remember the type), Intel Xeon with 775 socket (JADE 1 at CINES - France), Intel Xeon Westmere with 1366 socket (ANTARES at CRIHAN - France) and I used PowerPC processors with 4.7 Ghz, 32mo L3 cache (ANTARES at IDRISS - France). I used from 16 to 4096 CPUs with MPI library [http://fr.wikipedia.org/wiki/Message_Passing_Interface].
However, most of systems tend to be intel only now, most of the time Westmere and maybe 2011 socket PCUs now because of the tri and quad memory channels (more important than CPU frequency in our cases).
I also plan to use Nvidia CUDA Fermi to solve Chemistry because when used in simulations, it calls a lot of mathematical functions and simple matrix operations.

>> What numerical approximation is used to solve Navier-Stokes equation?
I use Low Mach approach: I suppose that sound propagates at infinite speed. So I cut spatial domain on a small grid with respects to Kolmogorov Scale [http://en.wikipedia.org/wiki/Kolmogorov_microscales] which is an important part of Direct Numerical Simulations. The order of spatial step is around 10 µm.
Then, Navier Stokes equations are solved using discretization [http://en.wikipedia.org/wiki/Finite_difference] and finites difference (6 order) for space and Runge Kutta time advancement. (3 iterations for one time step).
To conclude, I need to solve a Poisson equations for pressure resolution which is implicit and difficult to solve on memory distributed CPU. I use a BICGSTAB approach combined with a multigrid preconditioning system to solve respectively high and low frequencies. Our code to solve Poisson converges in 15 Iterations in average, independently of the number of CPU used, which is a good achievement.

A good example of results can be found here: https://www.youtube.com/results?search_query=direct+numerical+simulation

A bit late, my apologies. I was on travel and I couldn't get a secured internet connection. I am downloading your code and I will take a look at it tomorrow.

>>> CUDA will be very helpful in your case.Do chemistry calculation could be easily vectorized like a video processing?
Unfortunately no, and that is the challenge. Another team is working on it, and they face difficulties with the Fortran 77 code that is using a lot of “go to” instructructions.

>>> Very interesting info,but it is too advanced for me.I have only written 1D numerical integrators.By reading your code it could be implemented relatively easily with the help of intrinsics.
Yes. The equations are relatively complex, but the main core is always the same : Derivative calculations, which is the same than image processing.

>>> Is it an Open Source project?
Not know, but it is on the way to be, yes. We are currently rewriting some parts of the code to make it more “usable”. Then, we will release the sources, which could be used in OpenFoam For example (an open source fluid mechanic solver).

>>> - Review all equations because in some cases they could be normalized in order to reduce number of multiplications ( it is related to variables InvDxDx, InvDyDy, DtAlpha )
I gave you a simple loop. In normal time, Dx and Dy are not constant, so the loop can be more complicated. You need to calculate each terms at a time, but yes, I think we could comment the main loop and rewrite it in a more optimized way.

>>> - I was very impressed with performance results when MinGW C/C++ compiler was used
Yes, they made impressive improvements lately.

>>> - Review a Test-Case #3 ( your SSE codes ) because you've declared a couple of 128-bit variables on the stack and it affects performance ( some memory for these variables will be allocated and de-allocated more than ~208,080,000 times )
I will try this and report results tomorrow.

>>> >>... I also attached a zip-file with outputs for all versions of codes...
I used Microsoft's WinDiff utility to compare results.
>>> I've done a quick test with a 20-bit precision Fixed Floating Point ( FFP ) type instead of a 53-bit precision Double-Precision floating point 'double' type. I could say that was a right decision to use 'double' data type because there was a significant loss in precision of results if FFP types are used.
Thank you. I don’t know this program, so I will take a look.
In fact, because the solver can perform this loop more than 300 times per iterations, and considering that a run can be more than 100,000 iterations, precision is extremely important. For example, we tried to calculate using simple reals, and the results diverged after only 12 iterations. And if you add chemistry calculations, due to exponential operations, it explodes immediately. On top of that, the BICGSTAB solver converged at 10^-15 of precision, which cannot be achieved with simple precision.

I will report tomorrow the results on my Core i7 Xeon.

Just before testing more, as I thought your loops are not the sames as the original one. U1 needs U0 to be fully calculated before being processed. And vice versa. Look at the U0[i][j+1] for example. I made the same mistake when I first tried to optimise the loop. But because it is a convergence calcul, results will be the same at the end. However, the non correct loops will take a larger time to converge.

I made the code running on Gcc 4.7 on an i7 860. I will now test your loops and try to correct my SSE instructions. Results in a few hours.

After some tests, the first loop is all the time the fastest when using GCC O3 level optimisations. I think it automaticaly unroll the loops because they are simple in this case.

I need to take a look at icc compiler because some time it makes excellents optimisations.

I also tried to make the Simd code, but it doesn't work, the executable stop running.

double *cU0[n1][n2];

double *cU1[n1][n2];

/* simd */

__attribute__ ((aligned(16))) __m128d va;

__attribute__ ((aligned(16))) __m128d vb;

__attribute__ ((aligned(16))) __m128d vc;

__attribute__ ((aligned(16))) __m128d vd;

__attribute__ ((aligned(16))) __m128d vmmx00;

__attribute__ ((aligned(16))) __m128d vmmx01;

__attribute__ ((aligned(16))) __m128d vmmx02;

__attribute__ ((aligned(16))) __m128d vmmx03;

__attribute__ ((aligned(16))) __m128d vmmx04;

__attribute__ ((aligned(16))) __m128d vmmx10;

__attribute__ ((aligned(16))) __m128d vmmx20;
[...]
va = _mm_set1_pd(-2.0);

vb = _mm_set1_pd(InvDxDx);

vc = _mm_set1_pd(InvDyDy);

vd = _mm_set1_pd(DtAlpha);                       
 for( t = 0; t < niter; t++)

 {

    /* even */

    for( i = 1; i < n1-1; i++)

    {

       for( j = 1; j < n2-1; j+=2)

       {
          // Need five variables : [i][j],[i][j+1],[i][j-1],[i+1][j],[i-1][j]

          // respectively : vxmm0,vxmm1,vxmm2,vxmm3,vxmm4

          // can be optimized after (re-used of already loaded values)

          vmmx00 = _mm_load_pd(cU0[i][j]);

          vmmx01 = _mm_load_pd(cU0[i][j+1]);

          vmmx02 = _mm_load_pd(cU0[i][j-1]);

          vmmx03 = _mm_load_pd(cU0[i+1][j]);

          vmmx04 = _mm_load_pd(cU0[i-1][j]);
          vmmx10 = _mm_mul_pd(va,vmmx00);	// U1[i][j] = -2.0*U0[i][j];

          vmmx10 = _mm_add_pd(vmmx10,vmmx03);	// U1[i][j] = U1[i][j] + U0[i+1][j];

          vmmx10 = _mm_add_pd(vmmx10,vmmx04);	// U1[i][j] = U1[i][j] + U0[i-1][j];

          vmmx10 = _mm_mul_pd(vb,vmmx10);	// U1[i][j] = U1[i][j] * InvDxDx;
          vmmx20 = _mm_mul_pd(va,vmmx00);	// U2[i][j] = -2.0*U0[i][j];

          vmmx20 = _mm_add_pd(vmmx20,vmmx01);	// U2[i][j] = U2[i][j] + U0[i][j+1];

          vmmx20 = _mm_add_pd(vmmx20,vmmx02);	// U2[i][j] = U2[i][j] + U0[i][j-1];

          vmmx20 = _mm_mul_pd(vc,vmmx20);	// U2[i][j] = U2[i][j] * InvDyDy;
          vmmx10 = _mm_add_pd(vmmx10,vmmx20);	// U1[i][j] = U1[i][j] + U2[i][j];

          vmmx10 = _mm_mul_pd(vd,vmmx10);	// U1[i][j] = U1[i][j] * DtAlpha;
          vmmx10 = _mm_add_pd(vmmx10,vmmx00);	// U1[i][j] = U1[i][j] + U0[i][j];
          _mm_store_pd(cU1[i][j],vmmx10);
[...]

Do you locate the error ? Because it seems correct to me and I don't have a good debugger here with me ...

I made a simplier program (one dimension). All data are aligned, and I need to use unaligned load (no problems with >= i7).

But ! The non SSE loop is 2 times faster. I don't understand...

#include 

#include 

#include 

//#include 

#define n1 1004

#define niter 200000
int i,j,t;
double U0[n1] __attribute__ ((aligned(16)));

double U1[n1] __attribute__ ((aligned(16)));

double Dx,Dy,Lx,Ly,InvDxDx,Dt,alpha,totaltime,Stab,DtAlpha,DxDx;
__m128d vmmx00;

__m128d vmmx01;

__m128d vmmx02;

__m128d vmmx10;
__m128d va;

__m128d vb;

__m128d vc;

__m128d vd;
clock_t time0,time1;

FILE *f1;

int main()

{

/* ---- GENERAL ---- */

   alpha = 0.4;

   totaltime = 1.0/100.0;

   Dt = totaltime/((niter-1)*1.0);

   Lx = 1.0;

   Dx = Lx/((n1-1)*1.0);

   InvDxDx = 1.0/(Dx*Dx);

   DxDx = Dx*Dx;

   Stab = alpha*Dt*(InvDxDx);

   DtAlpha = Dt*alpha;

/* Stability if result <= 0.5 */

   printf("Stability factor : %f n",Stab);
   for( i = 0; i < n1; i++){U0[i] = 0.0;}

   U0[1] = 1.0;

   U0[2] = 1.0;

   U0[3] = 1.0;

   U0[n1-2] = 2.0;
//    for ( i = 0; i < n1; i++) {

 //       for ( j = i + 1; j < n2; j++) {

  //          std::swap(U0[i][j], U0[j][i]);

   //     }

    //}
    va = _mm_set1_pd(-2.0);

    vb = _mm_set1_pd(InvDxDx);

    vd = _mm_set1_pd(DtAlpha);
 time0=clock();
 for( t = 0; t < niter; t++)

 {
    for( i = 2; i < n1-2; i+=2)

    {

          //printf("%d  %d  n",i,j);

          //fflush(stdout);

          vmmx00 = _mm_load_pd(&U0[i]);

          vmmx01 = _mm_loadu_pd(&U0[i+1]);

          vmmx02 = _mm_loadu_pd(&U0[i-1]);
          vmmx10 = _mm_mul_pd(va,vmmx00);	// U1[i][j] = -2.0*U0[i][j];

          vmmx10 = _mm_add_pd(vmmx10,vmmx01);	// U1[i][j] = U1[i][j] + U0[i+1][j];

          vmmx10 = _mm_add_pd(vmmx10,vmmx02);	// U1[i][j] = U1[i][j] + U0[i-1][j];

          vmmx10 = _mm_mul_pd(vb,vmmx10);	// U1[i][j] = U1[i][j] * InvDxDx;
          vmmx10 = _mm_mul_pd(vd,vmmx10);	// U1[i][j] = U1[i][j] * DtAlpha;

          vmmx10 = _mm_add_pd(vmmx10,vmmx00);	// U1[i][j] = U1[i][j] + U0[i][j];
          _mm_store_pd(&U1[i],vmmx10);
          // U1[i][j] = U0[i][j] + DtAlpha*( (U0[i+1][j]-2.0*U0[i][j]+U0[i-1][j])*InvDxDx

    }
    for( i = 2; i < n1-2; i+=2)

    {

          //printf("%d  %d  n",i,j);

          //fflush(stdout);

          vmmx00 = _mm_load_pd(&U1[i]);

          vmmx01 = _mm_loadu_pd(&U1[i+1]);

          vmmx02 = _mm_loadu_pd(&U1[i-1]);
          vmmx10 = _mm_mul_pd(va,vmmx00);	// U0[i][j] = -2.0*U1[i][j];

          vmmx10 = _mm_add_pd(vmmx10,vmmx01);	// U0[i][j] = U0[i][j] + U1[i+1][j];

          vmmx10 = _mm_add_pd(vmmx10,vmmx02);	// U0[i][j] = U0[i][j] + U1[i-1][j];

          vmmx10 = _mm_mul_pd(vb,vmmx10);	// U0[i][j] = U0[i][j] * InvDxDx;
          vmmx10 = _mm_mul_pd(vd,vmmx10);	// U0[i][j] = U0[i][j] * DtAlpha;

          vmmx10 = _mm_add_pd(vmmx10,vmmx00);	// U0[i][j] = U0[i][j] + U1[i][j];
          _mm_store_pd(&U0[i],vmmx10);
          // U1[i][j] = U0[i][j] + DtAlpha*( (U0[i+1][j]-2.0*U0[i][j]+U0[i-1][j])*InvDxDx

    }
 }
 time1=clock();

 printf("Loop 0, total time : %f n", (double) time1-time0);

 f1 = fopen ("out0.dat", "wt");

 for( i = 1; i < n1-1; i++)

 {

       fprintf (f1, "%dt%fn", i, U0[i]);

 }
// REF
   for( i = 0; i < n1; i++){U0[i] = 0.0;}

   U0[1] = 1.0;

   U0[2] = 1.0;

   U0[3] = 1.0;

   U0[n1-2] = 2.0;
 time0=clock();
 for( t = 0; t < niter; t++)

 {
    for( i = 2; i < n1-2; i++)

    {

       U1[i] = U0[i] + DtAlpha* (U0[i+1]-2.0*U0[i]+U0[i-1])*InvDxDx;

    }
    for( i = 2; i < n1-2; i++)

    {

       U0[i] = U1[i] + DtAlpha* (U1[i+1]-2.0*U1[i]+U1[i-1])*InvDxDx;

    }
 }
 time1=clock();

 printf("Loop 0, total time : %f n", (double) time1-time0);

 f1 = fopen ("outref.dat", "wt");

 for( i = 1; i < n1-1; i++)

 {

       fprintf (f1, "%dt%fn", i, U0[i]);

 }
}

I really don't understand where I made a mistake...Does someone has any Idea ?