值得使用SSE，还是应该只依赖编译器
Is worth using SSE or should I just rely on the compiler?
我正在研究SSE指令，这些指令非常棒，并开始使用一些简单的代码来测量使用它们的函数与使用"标准"代码(即非SSE(的同一函数之间的差异。我意识到，当我编译代码(带有-O3标志(时，使用SSE版本函数的版本实际上(非常轻微(比不使用SSE指令的程序版本"慢"。我的猜测是：
- 编译器在优化代码方面做得很好
- SSE函数可以运行得更快，但将浮点加载到寄存器是有成本的，这抵消了使用SSE指令的好处
- testSSE((函数不够复杂，无法真正显示使用SSE的程序版本与不使用SSE程序版本之间的区别
有人能告诉我他/她对此有何看法吗？非常感谢-
编辑：所以我更正了代码(请参阅下面的2个代码列表(。即使使用较短的更正版本，SSE版本也会给我2''48，而非SSE版本会给我1''36，这证实了这样一个事实，即在这种情况下，编译器比我做得更好！
编辑：带BUG的旧代码(见以下更正版本(
// compiled with c++ tmp.cpp -msse4 -o testSSE -O3
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <pmmintrin.h>
inline void testSSE(float *node1, float *node2, float *node3, float *node4, float *result)
{
__m128 tmp0, tmp1, tmp2, tmp3;
__m128 l, r;
l = _mm_load_ps(node1); //_mm_store_ps(result, l); fprintf(stderr, "1 %f %f %f %fn", result[0], result[1], result[2], result[3]);
r = _mm_load_ps(node1 + 4); //_mm_store_ps(result, r); fprintf(stderr, "2 %f %f %f %fn", result[0], result[1], result[2], result[3]);
tmp0 = _mm_hadd_ps(l, r); //_mm_store_ps(result, tmp0); fprintf(stderr, "3 %f %f %f %fn", result[0], result[1], result[2], result[3]);
l = _mm_load_ps(node2); //_mm_store_ps(result, l); fprintf(stderr, "4 %f %f %f %fn", result[0], result[1], result[2], result[3]);
r = _mm_load_ps(node2 + 4); //_mm_store_ps(result, r); fprintf(stderr, "5 %f %f %f %fn", result[0], result[1], result[2], result[3]);
tmp1 = _mm_hadd_ps(l, r); //_mm_store_ps(result, tmp0); fprintf(stderr, "6 %f %f %f %fn", result[0], result[1], result[2], result[3]);
l = _mm_load_ps(node3);
r = _mm_load_ps(node3 + 4);
tmp2 = _mm_hadd_ps(l, r);
l = _mm_load_ps(node4); //_mm_store_ps(result, l); fprintf(stderr, "10 %f %f %f %fn", result[0], result[1], result[2], result[3]);
r = _mm_load_ps(node4 + 4); //_mm_store_ps(result, r); fprintf(stderr, "11 %f %f %f %fn", result[0], result[1], result[2], result[3]);
tmp3 = _mm_hadd_ps(l, r); //_mm_store_ps(result, tmp0); fprintf(stderr, "12 %f %f %f %fn", result[0], result[1], result[2], result[3]);
l = _mm_hadd_ps(tmp0, tmp1);
r = _mm_hadd_ps(tmp2, tmp3);
__m128 pDest = _mm_hadd_ps(l, r);
_mm_store_ps(result, pDest); // fprintf(stderr, "FINAL %f %f %f %fn", result[0], result[1], result[2], result[3]);
}
void test(float *node1, float *node2, float *node3, float *node4, float *result)
{
float tmp0[4], tmp1[4], tmp2[4], tmp3[4];
tmp0[0] = node1[0] + node1[1];
tmp0[1] = node1[2] + node1[3];
tmp0[2] = node1[4] + node1[5];
tmp0[3] = node1[6] + node1[7];
tmp1[0] = node2[0] + node2[1];
tmp1[1] = node2[2] + node2[3];
tmp1[2] = node2[4] + node2[5];
tmp1[3] = node2[6] + node2[7];
tmp2[0] = node3[0] + node3[1];
tmp2[1] = node3[2] + node3[3];
tmp2[2] = node3[4] + node3[5];
tmp2[3] = node3[6] + node3[7];
tmp3[0] = node4[0] + node4[1];
tmp3[1] = node4[2] + node4[3];
tmp3[2] = node4[4] + node4[5];
tmp3[3] = node4[6] + node4[7];
float l[4], r[4];
l[0] = tmp0[0] + tmp0[1];
l[1] = tmp0[2] + tmp0[3];
l[2] = tmp1[0] + tmp1[1];
l[3] = tmp1[2] + tmp1[3];
r[0] = tmp2[0] + tmp2[1];
r[1] = tmp2[2] + tmp2[3];
r[2] = tmp3[0] + tmp3[1];
r[3] = tmp3[2] + tmp3[3];
result[0] = l[0] + l[1];
result[1] = l[2] + l[3];
result[2] = r[0] + r[1];
result[3] = r[2] + r[3];
}
int main(int argc, char **argv)
{
int nnodes = 4;
double t = clock();
for (int k = 0; k < 10000000; ++k) {
float *data = new float [nnodes * 8];
for (int i = 0; i < nnodes * 8; ++i) { data[i] = (i / 8) + 1; /* fprintf(stderr, "data %02d %fn", i, data[i]); */ }
float result[4];
int off = sizeof(float) * 8;
testSSE(data, data + 8, data + 16, data + 24, result);
delete [] data;
}
fprintf(stderr, "%02f (sec)n", (clock() - t) / (float)CLOCKS_PER_SEC);
return 0;
}
编辑：新(已更正(代码
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <pmmintrin.h>
inline void testSSE(float *node1, float *node2, float *node3, float *node4, float *result)
{
__m128 tmp0, tmp1, tmp2, tmp3;
tmp0 = _mm_load_ps(node1);
tmp1 = _mm_load_ps(node2);
tmp2 = _mm_hadd_ps(tmp0, tmp1);
tmp0 = _mm_load_ps(node3);
tmp1 = _mm_load_ps(node4);
tmp3 = _mm_hadd_ps(tmp0, tmp1);
tmp0 = _mm_hadd_ps(tmp2, tmp3);
_mm_store_ps(result, tmp0);
}
void test(float *node1, float *node2, float *node3, float *node4, float *result)
{
float tmp0[4], tmp1[4], tmp2[4], tmp3[4];
tmp0[0] = node1[0] + node1[1];
tmp0[1] = node1[2] + node1[3];
tmp0[2] = node1[4] + node1[5];
tmp0[3] = node1[6] + node1[7];
tmp1[0] = node2[0] + node2[1];
tmp1[1] = node2[2] + node2[3];
tmp1[2] = node2[4] + node2[5];
tmp1[3] = node2[6] + node2[7];
tmp2[0] = node3[0] + node3[1];
tmp2[1] = node3[2] + node3[3];
tmp2[2] = node3[4] + node3[5];
tmp2[3] = node3[6] + node3[7];
tmp3[0] = node4[0] + node4[1];
tmp3[1] = node4[2] + node4[3];
tmp3[2] = node4[4] + node4[5];
tmp3[3] = node4[6] + node4[7];
float l[4], r[4];
l[0] = tmp0[0] + tmp0[1];
l[1] = tmp0[2] + tmp0[3];
l[2] = tmp1[0] + tmp1[1];
l[3] = tmp1[2] + tmp1[3];
r[0] = tmp2[0] + tmp2[1];
r[1] = tmp2[2] + tmp2[3];
r[2] = tmp3[0] + tmp3[1];
r[3] = tmp3[2] + tmp3[3];
result[0] = l[0] + l[1];
result[1] = l[2] + l[3];
result[2] = r[0] + r[1];
result[3] = r[2] + r[3];
}
int main(int argc, char **argv)
{
int nnodes = 4;
float *data = new float [nnodes * 8];
for (int i = 0; i < nnodes * 8; ++i) { data[i] = (i / 8) + 1; /* fprintf(stderr, "data %02d %fn", i, data[i]); */ }
double t = clock();
for (int k = 0; k < 1e+9; ++k) {
float result[4];
int off = sizeof(float) * 8;
test(data, data + 8, data + 16, data + 24, result);
}
fprintf(stderr, "%02f (sec)n", (clock() - t) / (float)CLOCKS_PER_SEC);
delete [] data;
return 0;
}
我修复了您的代码以有效地使用SIMD。你的旧方法在我的电脑上需要14.1秒，然后新方法需要1.2秒。我重写了测试函数中的代码，使其更易于阅读，但在其他方面都是一样的。
旧方法将节点存储在内存中，如下所示：node1[0], node1[1],...node1[7], node2[0], node2[1],...。现在的方法称为结构数组(AoS(。这是使用SSE的缓慢方式，这就是为什么它并不比标量代码好。
使用SSE的新方法存储如下节点：node1[0], node2[0], node3[0], node4[0], node1[1], node2[1], ...。这被称为阵列结构(SoA(。这是使用SIMD的有效方法。一般来说，如果你经常使用hadd(或点积指令(，那么你可能没有使用SIMD的最佳算法。
这是代码，包括你的旧方法和我的新方法。请注意，您可以尝试其他几种方法来提高效率，例如展开循环，但现在至少SIMD被正确使用了。
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <pmmintrin.h>
void test(float *node1, float *node2, float *node3, float *node4, float *result)
{
result[0] = node1[0] + node1[1] + node1[2] + node1[3] + node1[4] + node1[5] + node1[6] + node1[7];
result[1] = node2[0] + node2[1] + node2[2] + node2[3] + node2[4] + node2[5] + node2[6] + node2[7];
result[2] = node3[0] + node3[1] + node3[2] + node3[3] + node3[4] + node3[5] + node3[6] + node3[7];
result[3] = node4[0] + node4[1] + node4[2] + node4[3] + node4[4] + node4[5] + node4[6] + node4[7];
}
void testSSE(float *nodes_soa, float *result)
{
__m128 sum = _mm_set1_ps(0.0f);
for(int i=0; i<8; i++) {
__m128 tmp0 = _mm_load_ps(nodes_soa + 4*i);
sum =_mm_add_ps(tmp0, sum);
}
_mm_store_ps(result, sum);
}
int main(int argc, char **argv)
{
int nnodes = 4;
float *data = new float [nnodes * 8];
double t;
//old method using array of structs (AoS)
for (int i = 0; i < nnodes * 8; ++i) {
data[i] = (i / 8) + 1;
// printf("data %02d %fn", i, data[i]);
}
t = clock();
for (int k = 0; k < 1e+9; ++k) {
float result[4];
int off = sizeof(float) * 8;
test(data, data + 8, data + 16, data + 24, result);
//printf("%f %f %f %fn", result[0], result[1], result[2], result[3]);
}
printf("%02f (sec)n", (clock() - t) / (float)CLOCKS_PER_SEC);
//new method using struct of arrays (SoA)
for (int i = 0; i < nnodes * 8; ++i) {
data[i] = i%4 + 1;
//printf("data %02d %fn", i, data[i]);
}
t = clock();
for (int k = 0; k < 1e+9; ++k) {
float result[4];
int off = sizeof(float) * 8;
//test(data, data + 8, data + 16, data + 24, result);
testSSE(data, result);
//printf("%f %f %f %fn", result[0], result[1], result[2], result[3]);
}
printf("%02f (sec)n", (clock() - t) / (float)CLOCKS_PER_SEC);
delete [] data;
return 0;
}
编辑：通常，您希望在SSE中使用16位对齐。以下是我通常使用的功能。
inline void* aligned_malloc(size_t size, size_t align) {
void *result;
#ifdef _MSC_VER
result = _aligned_malloc(size, align);
#else
if(posix_memalign(&result, align, size)) result = 0;
#endif
return result;
}
inline void aligned_free(void *ptr) {
#ifdef _MSC_VER
_aligned_free(ptr);
#else
free(ptr);
#endif
}
使用
//float *data = new float [nnodes * 8];
float *data = (float*) aligned_malloc(nnodes*8*sizeof(float), 16);
您的测试非常糟糕。你正在做很多其他的事情，这些事情与你试图测试和测量的东西无关。
您在这里做的最慢的事情是每次调用new来分配一个新数组。这可能是这里唯一重要的事情。
如果要测试SSE，请仅测量SSE。
根据编译器和代码编写方式的不同，使用-O3时，它可能会使用SSE本身来实现代码，甚至可能使用其他适合任务并更快完成任务的命令集。
相关文章：
- 使用Bazel构建具有不同编译器/链接器选项的C/C++依赖关系
- 现代编译器是否可以在使用依赖关系注入时取消虚拟化函数调用
- 避免使用MINGW编译器和NAR-Maven-Plugin避免使用机器依赖的POM
- 是否可以在不依赖内置编译器的情况下拥有is_trivially_constructible的库实现
- 编译器是否也将所有参数依赖类型实例化，即使超载函数的参数计数不匹配
- 避免从函数返回时进行复制，而不依赖编译器优化
- 如果使用 Visual C++ 编译器 2013 年 11 月 CTP，是否还需要使用它编译所有依赖项
- 在多继承编译器的情况下访问成员变量是否依赖?如何正确地做
- 使用 auto 关键字并依赖于编译器的类型推断
- 为什么 sizeof 内置类型(char 除外)在 C 和 C++ 中依赖于编译器？
- 我必须依赖编译器 NRVO 吗?
- void指针之间的比较，它是定义的还是依赖于编译器的
- C++:避免编译器依赖与避免指针过度使用
- 值得使用SSE，还是应该只依赖编译器
- 是否临时对象的创建依赖于c++编译器
- c++ 11库特性依赖于编译器特定的代理
- 在c++中浮点表示依赖于编译器
- 初始化C/ c++结构体的const成员…依赖于编译器的
- C++枚举和编译器依赖关系
- Do编译器模板实现引入循环依赖项
