基于SSE特性调用不同的函数实现 我设计了一系列支持C++（SIMD）的向量类。为方便起见，操作人员已超负荷工作。课程示例： class vector2 { public: //...code friend const vector2 operator+ (const vector2 & lhs, const vector2 & rhs); //...code protected: float x, y; };

到目前为止，该方法使用我创建的名为PROCESSOR的类检查CPU是否具有SSE（SIMD）功能，该类在运行时执行程序时执行此检查。方法示例：

const vector2 operator+ (const vector2 & lhs, const vector2 & rhs) {
vector2 temp;
if(PROCESSOR.SSE) {
_asm { //... The "SSE WAY"
}
} else {
// The "NORMAL WAY"
}
return temp;
}

---

因此，您可以看到，如果SSE可用，它将以“SSE”方式运行，否则将以“正常”方式运行。然而，每次调用此操作时都必须检查SSE是否可用，这是非常有效的。有没有一种方法可以实现一个方法的两个版本，并且只调用适当的方法？由于我的PROCESSOR类只执行一次SSE检查，有没有办法设置我的vector类可以执行相同的检查？

将函数分为两部分，一部分用于SSE，另一部分不用于。创建函数指针，并使用函数的适当版本对其进行初始化。您可以创建一个内联函数来调用指针，如果这样可以使代码看起来更干净的话

不幸的是，您仍然要为函数调用付出间接寻址的代价。这是否比测试布尔标志更快，只能通过基准测试来确定

---

处理此问题的最佳方法是确保每次调用处理的数据量足以使开销变得微不足道。

为了帮助您避免代码重复，您可以创建两个向量类，一个用于SSE，另一个用于非SSE。然后你可以模板化你的调用算法

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>(); }
}

类向量_基{float x，y；}；
类向量_-sse：公共向量_基{vector_-sse算子+（…）{…}；
类向量_nonse:public vector_base{vector_nonse操作符+（…）{…}；
模板
无效做某事{
对于（/*标段*/）{
向量v=。。。；
向量w=。。。；
foo（v+w）；
}
}
int main（）{
if（PROCESSOR.SSE）{do_something（）；}
否则{dou_something（）；}
}

如果您可能以SSE的方式使用vector以外的其他类（如matrix等），您可以通过标记类型来做得更好。。在这种情况下，代码如下所示：

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>(); }
} 

类向量_基{float x，y；}；
结构SSE_标签；
结构非seu标签；
模板
类向量；
模板
类向量：公共向量_基{向量_sse算子+（…）{…}；
模板
类向量：公共向量_基{向量_非se算子+（…）{…}；
模板
无效做某事{
对于（/*标段*/）{
向量v=。。。；
向量w=。。。；
矩阵m=。。。；
foo（v+（m*w））；
}
}
int main（）{
if（PROCESSOR.SSE）{do_something（）；}
否则{dou_something（）；}
} 

如果您一直将调用函数分为两种形式，最终您几乎可以保证达到避免开销的程度，代价是代码大小可能翻倍（但不会执行额外的代码，因此不会降低速度）。测试本身可能会很慢，但此SSE实现将比“正常”慢代码。SSE设计用于处理16字节的数据，对于未对齐的较小类型来说不是最佳选择。不要在没有评测的情况下优化代码。如果你把两个向量表相加，这是有意义的。但就其中一个，它肯定会慢一些。正如有人所说，过早的优化是万恶之源。使代码正常工作，然后对其进行概要分析，最后对其进行优化+1。我以前使用过这种技术，效果很好。然而，crazyjul对原始问题的评论值得注意；现在还不清楚SSE是否适合一个2元素向量，除非你同时处理一堆向量。@JasonR我同意，我假设SSE是已知的代码的显著加速。该类只是一个例子。我正在使用向量2、4、16（或矩阵）