HELP With Slow SSE Code

[bobk <bobklepko at yahoo dot com>]

I am new to the world of SSE, but in trying to speed up some C code I have
run into a wall which is both perplexing and frustrating (since I can't find
a solution).  I am hoping someone here can provide the help I seek.  I thank
you for all your assistance!

My (watered down version) code is as follows (running on a pentium4 based
machine and compiling with gcc 4.02 using the compile options:

-O3 -Wall -march=pentium4 -msse2 -mfpmath=sse):


// standard C #include files are put here
#include <emmintrin.h> // I will actually eventually be using sse2 and 
                                 // sse instructions
#include <mm_malloc.h>

void main()
{
float *ptr1,*ptr2,*ptr3,*tptr1,*tptr2;
__m128 m1,m2,m3,*sptr1,*sptr2,*sptr3;
int i,j,arraysize=1000,loopcount=10;

// allocate space for dynamic arrays that are aligned to 16-byte boundary
(note that arraysize will actually be read into this program in the final
version).
ptr1=(float *) __mm_malloc(arraysize*sizeof(float),16);
ptr2=(float *) __mm_malloc(arraysize*sizeof(float),16);
ptr3=(float *) __mm_malloc(arraysize*sizeof(float),16);

tptr1=ptr1;
tptr2=ptr2;

// fill in two of the arrays with some numbers
for(i=0;i<arraysize;i++,tptr1++,tptr2++)
{
  *tptr1=(float)rand();
  *tptr2=(float)rand();
}

// TIMING LOOP STARTS
for(i=0;i<loopcount;i++)
{
  sptr1=(__m128) ptr1; // cast to size 128 bits
  sptr2=(__m128) ptr2;
  sptr3=(__m128_ ptr3;

  for(j=0;j<arraysize;j++,stptr1++,stptr2++,sptr3++)
  {
    m1=*sptr1;
    m2=*sptr2;
    m3=_mm_mul_ps(m1,m2); // use SSE intrinsic instruction to
                // multiply two numbers (note that even if I use *sptrx
                // instead of mx I will get the same speed problem).
    *sptr3=m3;
  }
} 
// TIMING LOOP ENDS HERE

}



So my speed problem is as follows.  Without the line "*sptr3=m3;" the TIMING
LOOP works as expected.  That is, four times faster than if I used normal
float values instead of quad sized float values (i.e. __m128). With the line
"*sptr3=m3;" inside this TIMING LOOP the code runs about 3 times slower than
when using normal float values.  For some reason writing to the pointer
location of type __m128 seems to slow things down, but reading from it is
fine (e.g. line "m1=*sptr1;").  If I write the computed/multiplied data to a
static array (but I truly need a dynamic array) such as

x.m[j*i]=m3;  // that is, replace line *sptr3=m3 with this line

where , say

union {
__m128m m[1000*10];
float f[1000*10][4];
} x


then the program runs as fast as expected.  So what may I be doing wrong
with my code such that I do not effectively take advantage of SSE
capabilities in the pentium 4?

--
View this message in context: http://www.nabble.com/HELP-With-Slow-SSE-Code-t1738578.html#a4724748
Sent from the gcc - Help forum at Nabble.com.