How to use simd instructions in c++?

I've got a simple lead structure.
struct v2f { float x; float y; };
There are two functions to work with them.
v2f addNormal(const v2f& v1, const v2f& v2) { v2f vec; vec.x = v1.x + v2.x; vec.y = v1.y + v2.y; return vec; }
v2f addVectorized(const v2f& v1, const v2f& v2) {
v2f vec;
__m128 res = _mm_add_ps(
_mm_loadu_ps((float*)(&v1)),
_mm_loadu_ps((float*)(&v2))
);
memcpy(&vec, res.m128_f32, sizeof(float) * 2);
return vec;
}
Now, the vegetation function is twice as slow as usual.
 Is it legal to copy memory directly from _m128 or necessarily use _mm_storeu_ps() ?
 Is it legal to plant in _m128 debris (structure weighs 8 byte, reads 8 extra by it)
 How do we download only two float numbers at...m128? Can we download to ...m128 directly through memcpy?
 How do you pull the maximum speed? Is there any point in using the vector for just two numbers?
Here's the new code.
v2f addVectorized(const v2f& v1, const v2f& v2) {
v2f vec;
const __m128 zero = _mm_setzero_ps();
const __m128 res = _mm_add_ps(
_mm_loadh_pi(zero, (__m64*)(&v1)),
_mm_loadh_pi(zero, (__m64*)(&v2))
);
_mm_storeh_pi((__m64*)(&vec), res);
return vec;
}
Now he's working 1.5 times slow.
How else can he be optimized?Which is remarkable when adding to the field structure z,w and working with four values instead of two, sse code wins the normal (about twice)

Questions 13 are all vague behaviour. Your initial realization is also the result of an undivided area of memory. That is, it can work, it may not work, and it makes no sense that either you trust the compiler ' s optimization or do it according to the documentation and standard, and you hope that implementation also works according to the documentation. For example, you can't remember two float values, but you can record four, two of which are not used. Two extra values in any case should be taken from somewhere, and you should indicate where.
It should be clarified that the above refers specifically to C+++. On OpenCL, for example, the rules are different. Pure C is also free, but there should be no reference to undetected memory.
Reply to 4: For your optimization attempts to work somehow, the structure must be uniform. Look at the documentation, most of the functions require the equating of 16 bytes, if there is no equating, the programme may eject or the compiler will add equalisation of the price of productivity.
More or less, the right approach is:
#include<xmmintrin.h> #include<cstring> struct alignas(16) v2f // по хорошему. нужно вообще использовать __attribute__((packed, aligned(16))) { float x; float y; }; v2f addNormal(const v2f& v1, const v2f& v2) { return {v1.x + v2.x, v1.y + v2.y}; }
v2f addVectorized(const v2f& v1, const v2f& v2) {
v2f v1_vec[2] = {v1, v1};
v2f v2_vec[2] = {v2, v2};
const _m128 v1 = _mm_load_ps(&v1_vec[0].x);
const _m128 v2 = _mm_load_ps(&v2_vec[0].x);const __m128 res = _mm_add_ps( v1_, v2_ ); v2f res_v[2]; _mm_store_ps (&res_v[0].x, res); return res_v[0];
}
Assembler for gcc https://godbolt.org/z/7b86Kv5js
addNormal(v2f const&, v2f const&):
movq xmm0, QWORD PTR [rdi]
movq xmm1, QWORD PTR [rsi]
addps xmm0, xmm1
ret
addVectorized(v2f const&, v2f const&):
movaps xmm0, XMMWORD PTR [rsi]
addps xmm0, XMMWORD PTR [rdi]
ret
The result is not equivalent, but at least there are no extra movements between registers, just a different method of initializing the register. It's too much more optimized by the compiler again, and it's clear that the compiler uses the vector for two numbers, that's normal.
But even in the correct implementation, there's a problem:
v2f test1(){
v2f v1{1.1, 3.1};
v2f v2{42.1 ,1};
return addNormal(v1, v2);
}v2f test2(){
v2f v1{1, 3};
v2f v2{3 ,1};
return addVectorized(v1, v2);
}
test1():
movq xmm0, QWORD PTR .LC0[rip]
ret
test2():
mov QWORD PTR [rsp32], 0
mov rax, QWORD PTR .LC1[rip]
mov QWORD PTR [rsp16], 0
mov QWORD PTR [rsp40], rax
mov rax, QWORD PTR .LC2[rip]
movaps xmm0, XMMWORD PTR [rsp40]
mov QWORD PTR [rsp24], rax
addps xmm0, XMMWORD PTR [rsp24]
ret
.LC0:
.long 1110232268
.long 1082340147
.LC1:
.long 1066192077
.long 1078355558
.LC2:
.long 1109943910
.long 1065353216
The compiler fully optimized the function of standard c++ but was unable to optimize the manual optimization function.