Will read post ... but meanwhile can tell that the printf is conditionally removed from code. I used only for debugging the correctness of vectorized version, of course for the real timing, i removed.

thanks.

LOL

The post u mentioned is just the one I made first, before coming here to Intel forumns !!!

With "extensively covered" you mean the topic was left unanswered? ;-1 Cause thats what happened. I made all suggestions I got, and still no signigicant improvement. The modified version is the one I posted here, at Intel.

There you have the assembler generated by GCC ... there we can see the SSE2 instructions. So, that is wrong with this picture?!

I would expect that, if there is one place on earth with people being experts in Intel assembler, that place must be here ... hehe. So, please check the assembler and tell me what is wrong.

Thanks.

Certaingly I appreciate all the advices gcc-help community provide me. Indeed, I followed all their advices.

I was not asking for a way to achieve the vectorization ... I already did it. Neither was I looking to automatic vectorization ... I manually code it. We can see the assembler there, generated directly from intrinsics functions ... it includes SSE2 of course (thus, this is not a problem of whether the compiler automatically vectorized or not).

What I am asking for, kindly of course hehe, is for advice about why my manually coded vector version is not improving significantly the performance (it offers a gain of 10% in runtime, which is very poor considering I am vectorizing the whole thing ... I would expect a gain of 75%)

Thanks.

Jalo,

You may be watching at an old version of program. Initial posts I put on gcc-help list, shown an AOS (Array Of StructureS). Due suggestions, I changed that to a SOA (Structure Of Arrays). I have now a few aligned arrays with all the data.

I am going to post new version, which included latests suggestions I received here. You may wanna take a look at it.

Thanks.

Jallo,

It seems that rint function entered a lot of noise ;-1 It was not an escencial part of my problem, so I removed for the sake of this proof of concept. I can see now a gain of 30% less in execution time. But still, I would expect more, given SSE2 is performing 4 operations at a time, right?

Unless maybe, I am loosing something ... as usual ;-|

Thanks for your attention (below c and assembler)

PS: Dunno why, but when used an if to repeat code for calling one function or the other, instead of a func pointer, the performance is worse than 30%. I know that using function pointer may prevent inlining the functions, so I tried to avoid its usage ... with the surprise that the SSE2 gain was less !. That's the reason I kept that part. Althought this may b an interesting point on its own, think thats another topic, not related with this serial vs vectorized debate.



#include
#include
#include

int D;
float *X,*Y,*Z;

inline static void dist(int i)
{
float xd,yd;
int j;
for(j=0; j {
xd = X[i] - X[j];
yd = Y[i] - Y[j];
Z[j] = xd*xd + yd*yd;
}
}

inline static void dist_sse(int i)
{
int j;
__m128 xmm0 = _mm_set1_ps(X[i]);
__m128 xmm1 = xmm0;
__m128 xmm2 = _mm_set1_ps(Y[i]);
__m128 xmm3 = xmm2;
__m128 xmm4,xmm5,xmm6,xmm7;
for(j=0; j {
xmm4 =_mm_load_ps(X+j);
xmm5 =_mm_load_ps(X+j+4);
xmm6 =_mm_load_ps(Y+j);
xmm7 =_mm_load_ps(Y+j+4);
xmm4 = _mm_sub_ps(xmm0,xmm4);
xmm5 = _mm_sub_ps(xmm1,xmm5);
xmm6 = _mm_sub_ps(xmm2,xmm6);
xmm7 = _mm_sub_ps(xmm3,xmm7);
xmm4 = _mm_mul_ps(xmm4,xmm4);
xmm5 = _mm_mul_ps(xmm5,xmm5);
xmm6 = _mm_mul_ps(xmm6,xmm6);
xmm7 = _mm_mul_ps(xmm7,xmm7);
xmm4 = _mm_add_ps(xmm4,xmm6);
xmm5 = _mm_add_ps(xmm5,xmm7);
_mm_store_ps(Z+j,xmm4);
_mm_store_ps(Z+j+4,xmm5);
}
}

int main(int argc, char * argv[])
{
int i,j,opc,debug;
void (*opc_func)(int);

if ( argc != 4 )
{
fprintf(stderr,"
Usage: %s

",argv[0]);
return 1;
}

opc = atoi(argv[1]);
D = atoi(argv[2]);
debug = atoi(argv[3]);

if ( D %8 != 0 )
{
fprintf(stderr,"
Dimension %d must be multiple of 8:

",D);
return 2;
}

if ( opc == 0 )
{
X = (float *) malloc(D * sizeof(float));
Y = (float *) malloc(D * sizeof(float));
Z = (float *) malloc(D * sizeof(float));
}
else
{
X = (float *) _mm_malloc(D * sizeof(float), 16);
Y = (float *) _mm_malloc(D * sizeof(float), 16);
Z = (float *) _mm_malloc(D * sizeof(float), 16);
}


for(i=0;i {
X[i] = i;
Y[i] = D - i;
}

opc_func = opc == 0? dist : dist_sse;
for(i=0;i {
opc_func(i);
if ( debug )
{
for(j=0; j printf("%f
",Z[j]);
}
}

return 0;
}


.file "kk.c"
.text
.p2align 4,,15
.def _dist; .scl 3; .type 32; .endef
_dist:
pushl %ebp
xorl %eax, %eax
movl %esp, %ebp
pushl %edi
movl 8(%ebp), %edi
pushl %esi
movl _D, %esi
pushl %ebx
cmpl %esi, %eax
jge L7
movl _X, %ecx
movl _Y, %edx
movl _Z, %ebx
.p2align 4,,15
L5:
flds (%ecx,%eax,4)
flds (%edx,%eax,4)
fxch %st(1)
fsubrs (%ecx,%edi,4)
fxch %st(1)
fsubrs (%edx,%edi,4)
fxch %st(1)
fmul %st(0), %st
fxch %st(1)
fmul %st(0), %st
faddp %st, %st(1)
fstps (%ebx,%eax,4)
incl %eax
cmpl %esi, %eax
jl L5
L7:
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.p2align 4,,15
.def _dist_sse; .scl 3; .type 32; .endef
_dist_sse:
pushl %ebp
movl %esp, %ebp
pushl %esi
pushl %ebx
subl $8, %esp
movl 8(%ebp), %esi
movl _X, %ebx
movl _Y, %ecx
movl (%ebx,%esi,4), %edx
movl %edx, -12(%ebp)
movl (%ecx,%esi,4), %eax
xorl %es
i, %esi
movss -12(%ebp), %xmm5
movl %eax, -16(%ebp)
movss -16(%ebp), %xmm4
cmpl _D, %esi
shufps $0, %xmm5, %xmm5
shufps $0, %xmm4, %xmm4
jl L36
jmp L34
.p2align 4,,7
L35:
movl _X, %ebx
movl _Y, %ecx
L36:
leal 0(,%esi,4), %edx
movaps %xmm5, %xmm1
leal (%edx,%ebx), %eax
movaps (%eax), %xmm2
leal (%edx,%ecx), %ebx
movaps %xmm5, %xmm6
movaps (%ebx), %xmm0
addl $8, %esi
movaps 16(%eax), %xmm3
subps %xmm2, %xmm1
movl _Z, %eax
movaps 16(%ebx), %xmm7
movaps %xmm1, %xmm2
movaps %xmm4, %xmm1
subps %xmm0, %xmm1
movl %edx, %ebx
movaps %xmm1, %xmm0
mulps %xmm2, %xmm2
mulps %xmm0, %xmm0
subps %xmm3, %xmm6
addl %eax, %ebx
addps %xmm0, %xmm2
movaps %xmm6, %xmm3
movaps %xmm2, (%ebx)
movaps %xmm4, %xmm6
subps %xmm7, %xmm6
movl _Z, %ecx
movaps %xmm6, %xmm1
mulps %xmm3, %xmm3
mulps %xmm6, %xmm1
addps %xmm1, %xmm3
addl %ecx, %edx
movaps %xmm3, 16(%edx)
cmpl _D, %esi
jl L35
L34:
addl $8, %esp
popl %ebx
popl %esi
popl %ebp
ret
.def ___main; .scl 2; .type 32; .endef
.section .rdata,"dr"
.align 4
LC1:
.ascii "12Usage: %s 1212"
LC3:
.ascii "%f12"
.align 4
LC2:
.ascii "12Dimension %d must be multiple of 8: 1212"
.text
.p2alig
n 4,,15
.globl _main
.def _main; .scl 2; .type 32; .endef
_main:
pushl %ebp
movl $16, %eax
movl %esp, %ebp
pushl %edi
pushl %esi
pushl %ebx
subl $28, %esp
movl 12(%ebp), %ebx
andl $-16, %esp
call __alloca
call ___main
cmpl $4, 8(%ebp)
je L38
call ___getreent
movl (%ebx), %esi
movl $LC1, %ecx
movl %ecx, 4(%esp)
movl %esi, 8(%esp)
movl 12(%eax), %edx
movl %edx, (%esp)
call _fprintf
movl $1, %eax
leal -12(%ebp), %esp
L99:
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
.p2align 4,,7
L38:
movl 4(%ebx), %edx
movl %edx, (%esp)
call _atoi
movl %eax, -16(%ebp)
movl 8(%ebx), %eax
movl %eax, (%esp)
call _atoi
movl %eax, _D
movl 12(%ebx), %edi
movl %edi, (%esp)
call _atoi
movl %eax, -20(%ebp)
movl _D, %ecx
testb $7, %cl
jne L89
movl -16(%ebp), %edi
testl %edi, %edi
je L90
movl %ecx, %eax
xorl %edx, %edx
sall $2, %eax
jne L91
L43:
movl %edx, _X
movl %ecx, %eax
xorl %edx, %edx
sall $2, %eax
jne L92
L48:
movl %edx, _Y
movl %ecx, %eax
xorl %edx, %edx
sall $2, %eax
jne&nb
sp; L93
L53:
movl %edx, _Z
L41:
xorl %edx, %edx
cmpl %ecx, %edx
jge L73
movl _X, %esi
movl _Y, %ebx
.p2align 4,,15
L60:
movl %ecx, %eax
cvtsi2ss %edx, %xmm1
subl %edx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm1, (%esi,%edx,4)
movss %xmm0, (%ebx,%edx,4)
incl %edx
cmpl %ecx, %edx
jl L60
L73:
movl -16(%ebp), %ebx
movl $_dist, %edi
movl $_dist_sse, %edx
testl %ebx, %ebx
cmovne %edx, %edi
xorl %esi, %esi
cmpl %ecx, %esi
jge L75
.p2align 4,,15
L101:
movl %esi, (%esp)
call *%edi
movl -20(%ebp), %ecx
testl %ecx, %ecx
je L77
movl _D, %eax
xorl %ebx, %ebx
cmpl %eax, %ebx
jge L65
.p2align 4,,15
L100:
movl _Z, %eax
flds (%eax,%ebx,4)
incl %ebx
movl $LC3, (%esp)
fstpl 4(%esp)
call _printf
movl _D, %eax
cmpl %eax, %ebx
jl L100
L65:
incl %esi
cmpl %eax, %esi
L102:
jl L101
L75:
leal -12(%ebp), %esp
xorl %eax, %eax
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
L90:
leal 0(,%ecx,4), %ebx
movl %ebx, (%esp)
call _malloc
movl %eax, _X
movl _D, %edx
sall $2, %edx
movl %edx, (%esp)
call _malloc
movl %eax, _Y
&
nbsp; movl _D, %eax
sall $2, %eax
movl %eax, (%esp)
call _malloc
movl %eax, _Z
movl _D, %ecx
jmp L41
.p2align 4,,7
L77:
movl _D, %eax
incl %esi
cmpl %eax, %esi
jmp L102
L93:
addl $16, %eax
movl %eax, (%esp)
call _malloc
testl %eax, %eax
movl %eax, %edx
je L86
leal 16(%eax), %edi
andl $-16, %edi
movl %edi, %edx
movl %eax, -4(%edi)
L86:
movl _D, %ecx
jmp L53
L92:
addl $16, %eax
movl %eax, (%esp)
call _malloc
testl %eax, %eax
movl %eax, %edx
je L85
leal 16(%eax), %esi
andl $-16, %esi
movl %esi, %edx
movl %eax, -4(%esi)
L85:
movl _D, %ecx
jmp L48
L91:
addl $16, %eax
movl %eax, (%esp)
call _malloc
testl %eax, %eax
movl %eax, %edx
je L84
leal 16(%eax), %ecx
andl $-16, %ecx
movl %ecx, %edx
movl %eax, -4(%ecx)
L84:
movl _D, %ecx
jmp L43
L89:
call ___getreent
movl _D, %esi
movl $LC2, %ecx
movl %ecx, 4(%esp)
movl %esi, 8(%esp)
movl 12(%eax), %ebx
movl %ebx, (%esp)
call _fprintf
movl $2, %eax
leal -12(%ebp), %esp
jmp L99
.comm _D, 16 # 4
.comm _X, 16 # 4
.comm _Y, 16
# 4
.comm _Z, 16 # 4
.def _printf; .scl 3; .type 32; .endef
.def _atoi; .scl 3; .type 32; .endef
.def ___getreent; .scl 3; .type 32; .endef
.def _fprintf; .scl 3; .type 32; .endef
.def _malloc; .scl 3; .type 32; .endef