Calling different implementation of function based on SSE features - c++

Question

I am designing a series of Vector classes in C++ that support SSE(SIMD). The operators have been overloaded for convenience. Example of class:
class vector2 {
public:
//...code
friend const vector2 operator+ (const vector2 & lhs, const vector2 & rhs);
//...code
protected:
float x, y;
};
So far the method checks to see if the CPU has a SSE(SIMD) feature, using a class I created called PROCESSOR, which does this check when the program is executed at run-time. Example of method:
const vector2 operator+ (const vector2 & lhs, const vector2 & rhs) {
vector2 temp;
if(PROCESSOR.SSE) {
_asm { //... The "SSE WAY"
}
} else {
// The "NORMAL WAY"
}
return temp;
}
So as you can see if SSE is available it will run the "SSE" way otherwise it will run "normal" way. However, it is very in-efficient having to check if SSE is available every time this operation is called. Is there a way to implement two versions of a method and call only the appropriate method? Since my PROCESSOR class only does the SSE check once, is there a way of setting my vector class can do the same?

Answer 1

To help you avoid code duplication you can create two vector classes, one for SSE and one for non-SSE. Then you can template your calling algorithms.
class vector_base { float x,y; } ;
class vector_sse : public vector_base { vector_sse operator+(...){...} };
class vector_nonsse : public vector_base { vector_nonsse operator+(...){...} };
template< typename VECTOR >
void do_somthing() {
for( /*lots*/) {
VECTOR v = ...;
VECTOR w = ...;
foo(v+w);
}
}
int main() {
if(PROCESSOR.SSE) { do_something<vector_sse>(); }
else { do_something<vector_nonsse>(); }
}
If you're likely to use other classes than vector (like matrix etc) in an SSE manner you might do better by tagging your types instead .. in which case the code looks like this:
class vector_base { float x,y; } ;
struct SSE_tag;
struct NONSSE_tag;
template<typename T>
class vector;
template<>
class vector<SSE_tag> : public vector_base { vector_sse operator+(...){...} };
template<>
class vector<NONSSE_tag> : public vector_base { vector_nonsse operator+(...){...} };
template< typename TAG >
void do_somthing() {
for( /*lots*/) {
vector<TAG> v = ...;
vector<TAG> w = ...;
matrix<TAG> m = ...;
foo(v+(m*w));
}
}
int main() {
if(PROCESSOR.SSE) { do_something<SSE_tag>(); }
else { do_something<NONSSE_tag>(); }
}

Answer 2

Split the function into two parts, one for SSE and one not. Create a function pointer and initialize it with the appropriate version of the function. You can make an inline function that calls the pointer if that makes your code look cleaner.
Unfortunately you'll still pay the price of an indirection for the function call. Whether this is faster than testing a boolean flag can only be determined by benchmarking.
The best way to deal with this problem is to make sure the amount of data being processed with each call is enough to make the overhead insignificant.