Hey guys, I've done a "quick" first implementation of a vector normalize and dot product using sse intrinsics and was wondering if there's still something that could be optimized further.

Here's my code:

_declspec(align(16))
struct Vec4
{
	float x, y, z, w;

	inline const Vec4 Normalize()
	{
		__m128 tmp;

		// copy data into the 128bit register
		tmp = _mm_set_ps(w, z, y, x);

		// 0x7F = 0111 1111 ~ means we don't want the w-component multiplied
		// and the result written to all 4 components
		__m128 dp = _mm_dp_ps(tmp, tmp, 0x7F); 
		
		// compute rsqrt of the dot product
		dp = _mm_rsqrt_ps(dp);

		// vec * rsqrt(dot(vec, vec))
		tmp = _mm_mul_ps(tmp, dp);
		
		Vec4 vec;
		union {__m128 v; float f[4]; } uf; // to access the 4 floats
		uf.v = tmp;

		vec.x = uf.f[0];
		vec.y = uf.f[1];
		vec.z = uf.f[2];
		vec.w = 1.0f;

		return vec;
	}

	inline const float Dot(const Vec4 &v2)
	{
		__m128 a;
		
		// copy data into the 128bit register
		a = _mm_set_ps(w, z, y, x);
		__m128 b = _mm_set_ps(v2.w, v2.z, v2.y, v2.x);

		// 0x7F = 0111 1111 ~ means we don't want w-component multiplied
		// and the result written to all 4 components
		__m128 dp = _mm_dp_ps(a, b, 0x7F); 
		
		Vec4 vec;
		union {__m128 v; float f[4]; } uf; // to access the 4 floats
		uf.v = dp;

		return uf.f[0];
	}
};

Thanks in advance

I don't know if this is the case, but I've seen often that if you've got lots of functions like this that move data back and forth between float registers and SSE registers, then that ends up wasting so much time, that SSE becomes the same speed (or slower) than regular float stuff!

I'd try to make your Vec4 class store it's members as an __m128.

In some engines I've even seen a floatInVec class (or Vec1), which internally is an __m128, but to the user it appears like a float. This lets you keep more of your math code working with SSE data, rather than having it juggle between float and SSE.

Regarding the Normalize and Dot functions - considering that you're only really operating on a Vec3, then if you're running these over large data-sets, it might be worthwhile making an SoAVec3 class (as well as the normal Vec4 class), which stores 4 x values, then 4 y values, then 4 z values in 3 __m128 variables. This reduces the total working size of the data-set, and often lets you write more optimized (shorter) functions.

@achild As you can see above I'm already using that intrinsic for the dot product

@hodgman I was thinking about that...I'll give it a try and see if it gives me some boost

I just tried your updated code AllEightUp and it actually got slower

Yea release build and compiler is msvc (visual studio 2008)

edit: Doing it something like this makes it a little bit faster than before now:

// 4-component vector class using SIMD instructions
_declspec(align(16))
struct Vec4
{
    __m128 v;

    Vec4()
    {

    }

    Vec4(float x, float y, float z, float w)
    {
        v = _mm_set_ps(w, z, y, x);
    }

    inline const float X()
    {
        union {__m128 v; float f[4]; } uf; // to access the 4 floats
        uf.v = v;
        return uf.f[0];
    }

    inline const float Y()
    {
        union {__m128 v; float f[4]; } uf; // to access the 4 floats
        uf.v = v;
        return uf.f[1];
    }

    inline const float Z()
    {
        union {__m128 v; float f[4]; } uf; // to access the 4 floats
        uf.v = v;
        return uf.f[2];
    }

    inline const void Normalize()
    {
        // 0x7F = 0111 1111 ~ means we don't want the w-component multiplied
        // and the result written to all 4 components
        __m128 dp = _mm_dp_ps(v, v, 0x7F); 

        // compute rsqrt of the dot product
        dp = _mm_rsqrt_ps(dp);

        // vec * rsqrt(dot(vec, vec))
        v = _mm_mul_ps(v, dp);
	  }

    inline const float Dot(const Vec4 &v2) const
    {
        // 0x7F = 0111 1111 ~ means we don't want w-component multiplied
        // and the result written to all 4 components
        __m128 dp = _mm_dp_ps(v, v2.v, 0x7F); 

        float result;
        _mm_store_ss(&result, dp);

        return result;
	  }
};