Comparing scalar, SSE and AVX basics....poor performances ??

[Joaquin_Tarraga]

Hi,

Please, look at these pieces of code, consisting of three versions to

calculate the length of a set of 3-D vectors.

Let's assume, vector v, with components x, y, z.

The length (l) of vector v, is l = sqrt((x*x) + (y*y) + (z*z))

I implemented three versions based on scalar, SSE and AVX instruction, to compute the

length of 90 000 000 vectors. I hope to get much better performance using SSE,

and AVX, but no...., here the results:

=======================================

TEST 0: l = sqrt((x*x) + (y*y) + (z*z))

=======================================

Scalar time: 0.46051

SSE time : 0.18613

AVX time : 0.19043

Speed-up Scalar vs SSE : 2.47

Speed-up Scalar vs AVX : 2.42

I hope a speed-up of 4 when using SSE, a much more with AVX,

but there is no difference between SSE and AVX.

Target architecture:

• Intel Xeon CPU E31245 @ 3.30GHz
• 4 CPU dual-core (but I only use one core)

Command line to compile:

gcc -O3 -std=c99 -mavx main.c -o main -lm

And the code:

Allocating memory for the SSE version:

x = (float*)_mm_malloc(len * sizeof(float), 16);

y =(float*)_mm_malloc(len * sizeof(float), 16);

....

Allocating memory for the AVX version:

x = (float*)_mm_malloc(len * sizeof(float), 32);

y =(float*)_mm_malloc(len * sizeof(float), 32);

....

//----------------------------------------------------------------------------------------------------------------------

void length_scalar(float *x, float *y, float *z, float *l, unsigned int length) {

for (int i = 0; i

l = sqrt((x*x) + (y*y) + (z*z));

}

}

//----------------------------------------------------------------------------------------------------------------------

void length_sse(float *x, float *y, float *z, float *l, unsigned int length) {

__m128 xmm0, xmm1, xmm2, xmm3;

for (int i = 0; i

xmm0 = _mm_load_ps(&x);

xmm1 = _mm_load_ps(&y);

xmm2 = _mm_load_ps(&z);

xmm3 = _mm_add_ps(_mm_mul_ps(xmm0, xmm0), _mm_mul_ps(xmm1, xmm1));

xmm3 = _mm_add_ps(_mm_mul_ps(xmm2, xmm2), xmm3);

xmm3 = _mm_sqrt_ps(xmm3);

_mm_store_ps(&l, xmm3);

}

}

//----------------------------------------------------------------------------------------------------------------------

void length_avx(float *x, float *y, float *z, float *l, unsigned int length) {

__m256 ymm0, ymm1, ymm2, ymm3;

for (int i = 0; i

ymm0 = _mm256_load_ps(&x);

ymm1 = _mm256_load_ps(&y);

ymm2 = _mm256_load_ps(&z);

ymm3 = _mm256_add_ps(_mm256_mul_ps(ymm0, ymm0), _mm256_mul_ps(ymm1, ymm1));

ymm3 = _mm256_add_ps(_mm256_mul_ps(ymm2, ymm2), ymm3);

ymm3 = _mm256_sqrt_ps(ymm3);

_mm256_store_ps(&l, ymm3);

}

//----------------------------------------------------------------------------------------------------------------------

Could you, please, give me some hints, suggestions....to explain that?

I think it is due to the 4 instructions to move data (memory /register, i.e., the load and store instructions),

what do you think?

If I ran a example more simple (addition of the 3 components of a vector, for 90 000 000 vectors)

and I got worse results:

=======================================

TEST 1: l = x + y + z

=======================================

Scalar time: 0.61573

SSE time : 0.34304

AVX time : 0.34770

Speed-up Scalar vs SSE : 1.79

Speed-up Scalar vs AVX : 1.77

Any idea?

Thanks a lot

--

Joaqun

[Max_L]

Note: on Sandy Bridge one can recover and improve 256-bit loads performance that are missing L1 vs 128-bit ones (256-bit loads are indeed slower than 2x128-bit loads on Sandy Bridge when missing L1, especially if the data is actually misalgned) by issuing prefetch'es to the cache lines before loads

-Max