Tag: provide

I've written two versions of the vector class for my Ray Tracer. Non-SIMD version and SIMD version. The code can be found below. I would like to ask what things I should consider to maximize performance with SIMD. I get so no performance gain. I've disabled compiler optimizations and still no results.

#ifndef INC_VEC4_H
#define INC_VEC4_H

#define USE_SSE

#ifndef USE_SSE

#include
#include


Class Vec4
{
Public:

Union
struct {float x, y, z, w; };
struct {float r, g, b, a; };
};

// normalized directions
static vec4 UP;
static vec4 DOWN;
static vec4 NULL;
static vec4 LEFT;
static vec4 RIGHT;
static vec4 FORWARD;
static vec4 BACKWARD;

//Construction
vec4 ();
explicit vec4 (float x, float y, float z, float w = 1.0f);
explicit vec4 (float n);
vec4 (const vec4 and others);
vec4 & operator = (const vec4 and others);
//Destruction
~ vec4 ();


// vec4-vec4 arithmetic operations
inline vec4 operator + (const vec4 and others) const {
Return vec4 (x + other.x,
y + other.y,
z + other.z);
}
inline vec4 operator - (const vec4 and others) const {
Return vec4 (x - other.x,
y - other.y,
z - other.z);
}

// vec4-vec4 arithmetic operations
Inline void operator + = (const vec4 and others) {
x + = other.x;
y + = other.y;
z + = other.z;
}


inline vec4 operator * (const vec4 and others) const {
Return vec4 (x * other.x,
y * other.y,
z * other.z);
}
inline vec4 operator / (const vec4 and others) const {
assert ((int) other.x! = 0 && (int) other.y! = 0 && (int) other.z! = 0);
Return vec4 (x / other.x,
y / other.y,
z / other.z);
}
Inline void operator * = (const vec4 and others) {
x * = other.x;
y * = other.y;
z * = other.z;
}
inline void operator / = (const vec4 and others) {
x / = other.x;
y / = other.y;
z / = other.z;
}
// vec4-scalar * & /

Inline Vec4 operator / (float scalar) const {
assert (scalar> 0.00000f);
return vec4 (x / scalar, y / scalar, z / scalar);
}
Inline void operator * = (float scalar) {
x * = scalar;
y * = scalar;
z * = scalar;
}
Inline void operator / = (float scalar) {
Assert (scalar> 0.00000000f);
x / = scalar;
y / = scalar;
z / = scalar;
}

inline vec4 normalize () const
vec4 v;
v.x = x / length ();
v.y = y / length ();
v.z = z / length ();
Return v;
}


Inline float length () const {
return (sqrt ((x * x) + (y * y) + (z * z)));
}


inline float squared_length () const {
Return x * x + y * y + z * z;
}

inline void make_it_unit () {

x / = length ();
y / = length ();
z / = length ();

}

inline vec4 & make_itzero () {
x = y = z = 0;
Return * this;
}

Inline float point (const vec4 and others) const {
return ((x * other.x) + (y * other.y) + (z * other.z));
}

inline vec4 cross (const vec4 and others) const {
return vec4 (
y * other.z + z * other.y,
z * other.x + x * other.z,
x * other.y + y * other.x
);
}

// checks
bool check_ifzero () const {
// convert the floats to int, as it is difficult to compare two floats
bool result = (((int) x) == 0 && ((int) y) == 0 && ((int) z) == 0);
Return result;
}
// IO
friend std :: ostream & operator << (std :: ostream & cout, const vec4 and others);
};

// inline operators that are not members
Inline vec4 operator * (const vec4 & v, floating-point scalar) {
return vec4 (v.x * scalar, v.y * scalar, v.z * scalar);
}

Inline Vec4 operator * (float scalar, const Vec4 & V) {
return vec4 (v.x * scalar, v.y * scalar, v.z * scalar);
}

Inline float point (const vec4 & v1, const vec4 & v2) {
return (v1.x * v2.x + v1.y * v2.y + v1.z * v2.z);
}

#otherwise

#include

_declspec (align (16))
struct vec4
{
Union
__m128 vec;
struct {float x, y, z, w; };
struct {float r, g, b, a; };
};

// normalized directions
static vec4 UP;
static vec4 DOWN;
static vec4 NULL;
static vec4 LEFT;
static vec4 RIGHT;
static vec4 FORWARD;
static vec4 BACKWARD;

//Construction
vec4 ();
vec4 (float x, float y, float z, float w = 1.0f);
explicit vec4 (float n);
vec4 (const vec4 and others);
vec4 & operator = (const vec4 and others);
//Destruction
~ vec4 ();

Inline float point (const vec4 and others)
{
__m128 dotResult = _mm_dp_ps (vec, other.vec, 0x7F);
Float result;
_mm_store_ss (& result, dotResult);
Return result;
}

inline void make_it_unit ()
{
__m128 selfDot = _mm_dp_ps (vec, vec, 0x7F);
__m128 sqrtResult = _mm_rsqrt_ps (selfDot);
vec = _mm_mul_ps (vec, sqrtResult);
}

inline vec4 normalize ()
{
vec4 result;
__m128 selfDot = _mm_dp_ps (vec, vec, 0x7F);
__m128 sqrtResult = _mm_rsqrt_ps (selfDot);
result.vec = _mm_mul_ps (vec, sqrtResult);
Return result;
}

Inline float length ()
{
__m128 selfDot = _mm_dp_ps (vec, vec, 0x7F);
__m128 sqrtResult = _mm_sqrt_ps (selfDot);
Float result;
_mm_store_ss (& result, sqrtResult);
Return result;
}

// vec4-vec4 arithmetic operations
inline vec4 operator + (const vec4 and others) const {
vec4 result;
result.vec = _mm_add_ps (vec, other.vec);
Return result;
}
inline vec4 operator - (const vec4 and others) const {
vec4 result;
result.vec = _mm_sub_ps (vec, other.vec);
Return result;
}

// vec4-vec4 arithmetic operations
Inline void operator + = (const vec4 and others) {
vec = _mm_add_ps (vec, other.vec);
}


inline vec4 operator * (const vec4 and others) const {
vec4 result;
result.vec = _mm_mul_ps (vec, other.vec);
Return result;
}
inline vec4 operator / (const vec4 and others) const {
vec4 result;
result.vec = _mm_div_ps (vec, other.vec);
Return result;
}
Inline void operator * = (const vec4 and others) {
vec = _mm_mul_ps (vec, other.vec);
}
inline void operator / = (const vec4 and others) {
vec = _mm_div_ps (vec, other.vec);
}
// vec4-scalar * & /

Inline Vec4 operator / (float scalar) const {
vec4 result;
__m128 _scalar = _mm_set_ps (scalar, scalar, scalar, scalar);
result.vec = _mm_div_ps (vec, _scalar);
Return result;
}
Inline void operator * = (float scalar) {
__m128 _scalar = _mm_set_ps (scalar, scalar, scalar, scalar);
vec = _mm_mul_ps (vec, _scalar);
}
Inline void operator / = (float scalar) {
__m128 _scalar = _mm_set_ps (scalar, scalar, scalar, scalar);
vec = _mm_div_ps (vec, _scalar);
}



inline float squared_length () const {
Float result;
__m128 dotResult = _mm_dp_ps (vec, vec, 0x7F);
_mm_store_ss (& result, dotResult);
Return result;
}

inline vec4 & make_itzero () {
vec = _mm_set_ps (0,0f, 0,0f, 0,0f, 0,0f);
}


inline vec4 cross (const vec4 and others) const {
vec4 result;
result.vec = _mm_sub_ps (
_mm_mul_ps (_mm_shuffle_ps (vec, vec, _MM_SHUFFLE (3, 0, 2, 1)), _mm_shuffle_ps (other.vec, other.vec, _MM_SHUFFLE (3, 1, 0, 2))),
_mm_mul_ps (_mm_shuffle_ps (vec, vec, _MM_SHUFFLE (3, 1, 0, 2)), _mm_shuffle_ps (other.vec, other.vec, _MM_SHUFFLE (3, 0, 2, 1)))
);
Return result;
}

// checks
bool check_ifzero () const {

}
};

// inline operators that are not members
Inline vec4 operator * (const vec4 & v, floating-point scalar) {
vec4 result;
__m128 _scalar = _mm_set_ps (scalar, scalar, scalar, scalar);
result.vec = _mm_mul_ps (v.vec, _scalar);
Return result;
}

Inline Vec4 operator * (float scalar, const Vec4 & V) {
vec4 result;
__m128 _scalar = _mm_set_ps (scalar, scalar, scalar, scalar);
result.vec = _mm_mul_ps (v.vec, _scalar);
Return result;
}

Inline float point (const vec4 & v1, const vec4 & v2) {
__m128 dotResult = _mm_dp_ps (v1.vec, v2.vec, 0x7F);
Float result;
_mm_store_ss (& result, dotResult);
Return result;
}


#endif

#endif