From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <gcc-help-return-23802-listarch-gcc-help=gcc.gnu.org@gcc.gnu.org>
Received: (qmail 14069 invoked by alias); 6 Jun 2006 00:19:48 -0000
Received: (qmail 14061 invoked by uid 22791); 6 Jun 2006 00:19:48 -0000
X-Spam-Check-By: sourceware.org
Received: from www.nabble.com (HELO talk.nabble.com) (72.21.53.35)     by sourceware.org (qpsmtpd/0.31) with ESMTP; Tue, 06 Jun 2006 00:19:45 +0000
Received: from localhost ([127.0.0.1] helo=talk.nabble.com) 	by talk.nabble.com with esmtp (Exim 4.50) 	id 1FnPIM-000061-Qz 	for gcc-help@gcc.gnu.org; Mon, 05 Jun 2006 17:19:42 -0700
Message-ID: <4724748.post@talk.nabble.com>
Date: Tue, 06 Jun 2006 00:19:00 -0000
From: bobk <bobklepko@yahoo.com>
To: gcc-help@gcc.gnu.org
Subject: HELP With Slow SSE Code
MIME-Version: 1.0
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
X-Nabble-Sender: bobklepko@yahoo.com
X-Nabble-From: bobk <bobklepko@yahoo.com>
X-IsSubscribed: yes
Mailing-List: contact gcc-help-help@gcc.gnu.org; run by ezmlm
Precedence: bulk
List-Archive: <http://gcc.gnu.org/ml/gcc-help/>
List-Post: <mailto:gcc-help@gcc.gnu.org>
List-Help: <mailto:gcc-help-help@gcc.gnu.org>
Sender: gcc-help-owner@gcc.gnu.org
X-SW-Source: 2006-06/txt/msg00042.txt.bz2


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.