SSE有双打，不值得吗？
我读了一些关于使用SSE内在函数的内容，并试着用双精度实现四元数旋转。以下是我写的正常和SSE函数，
void quat_rot(quat_t a, REAL* restrict b){
///////////////////////////////////////////
// Multiply vector b by quaternion a //
///////////////////////////////////////////
REAL cross_temp[3],result[3];
cross_temp[0]=a.el[2]*b[2]-a.el[3]*b[1]+a.el[0]*b[0];
cross_temp[1]=a.el[3]*b[0]-a.el[1]*b[2]+a.el[0]*b[1];
cross_temp[2]=a.el[1]*b[1]-a.el[2]*b[0]+a.el[0]*b[2];
result[0]=b[0]+2.0*(a.el[2]*cross_temp[2]-a.el[3]*cross_temp[1]);
result[1]=b[1]+2.0*(a.el[3]*cross_temp[0]-a.el[1]*cross_temp[2]);
result[2]=b[2]+2.0*(a.el[1]*cross_temp[1]-a.el[2]*cross_temp[0]);
b[0]=result[0];
b[1]=result[1];
b[2]=result[2];
}
使用SSE
inline void cross_p(__m128d *a, __m128d *b, __m128d *c){
const __m128d SIGN_NP = _mm_set_pd(0.0, -0.0);
__m128d l1 = _mm_mul_pd( _mm_unpacklo_pd(a[1], a[1]), b[0] );
__m128d l2 = _mm_mul_pd( _mm_unpacklo_pd(b[1], b[1]), a[0] );
__m128d m1 = _mm_sub_pd(l1, l2);
m1 = _mm_shuffle_pd(m1, m1, 1);
m1 = _mm_xor_pd(m1, SIGN_NP);
l1 = _mm_mul_pd( a[0], _mm_shuffle_pd(b[0], b[0], 1) );
__m128d m2 = _mm_sub_sd(l1, _mm_unpackhi_pd(l1, l1));
c[0] = m1;
c[1] = m2;
}
void quat_rotSSE(quat_t a, REAL* restrict b){
///////////////////////////////////////////
// Multiply vector b by quaternion a //
///////////////////////////////////////////
__m128d axb[2];
__m128d aa[2];
aa[0] = _mm_load_pd(a.el+1);
aa[1] = _mm_load_sd(a.el+3);
__m128d bb[2];
bb[0] = _mm_load_pd(b);
bb[1] = _mm_load_sd(b+2);
cross_p(aa, bb, axb);
__m128d w = _mm_set1_pd(a.el[0]);
axb[0] = _mm_add_pd(axb[0], _mm_mul_pd(w, bb[0]));
axb[1] = _mm_add_sd(axb[1], _mm_mul_sd(w, bb[1]));
cross_p(aa, axb, axb);
_mm_store_pd(b, _mm_add_pd(bb[0], _mm_add_pd(axb[0], axb[0])));
_mm_store_sd(b+2, _mm_add_pd(bb[1], _mm_add_sd(axb[1], axb[1])));
}
旋转基本上是使用函数
完成的 
然后我运行以下测试以检查每个函数执行一组旋转所花费的时间，
int main(int argc, char *argv[]){
REAL a[] __attribute__ ((aligned(16))) = {0.2, 1.3, 2.6};
quat_t q = {{0.1, 0.7, -0.3, -3.2}};
REAL sum = 0.0;
for(int i = 0; i < 4; i++) sum += q.el[i] * q.el[i];
sum = sqrt(sum);
for(int i = 0; i < 4; i++) q.el[i] /= sum;
int N = 1000000000;
for(int i = 0; i < N; i++){
quat_rotSSE(q, a);
}
printf("rot = ");
for(int i = 0; i < 3; i++) printf("%f, ", a[i]);
printf("\n");
return 0;
}
我使用gcc 4.6.3编译了-O3 -std = c99 -msse3。
使用unix time的正常功能的时间是SSE的18.841s和21.689s。
我错过了什么，为什么SSE实施比正常实施慢15％？在哪种情况下，SSE实现对双精度更快？
编辑：从评论中获取建议，我尝试了几件事，
- -O1选项提供非常相似的结果。
- 在
restrict函数上使用cross_p进行了尝试，并添加了__m128d来保存第二个交叉产品。这与所产生的组件没有区别。 - 根据我的理解，为正常功能生成的程序集只包含除
movapd之外的标量指令。
为SSE功能生成的汇编代码仅比正常函数少4行。
编辑：添加了生成的程序集的链接，
2 个答案:
答案 0 :(得分：10)
当你在大量元素上执行相同的操作时，SSE（以及一般的SIMD）工作得非常好，因为操作之间没有依赖关系。例如，如果您有一个double数组并且需要为每个元素执行
array[i] = (array[i] * K + L)/M + N;，则SSE / SIMD会有所帮助。
如果您没有对大量元素执行相同的操作，那么SSE没有帮助。例如，如果您有一个双倍且需要执行foo = (foo * K + L)/M + N;，则SSE / SIMD无法提供帮助。
基本上，SSE是错误的工具。您需要将工作更改为SSE是正确工具的工作。例如，而不是 将一个向量乘以一个四元数;尝试将一个1000个向量的数组乘以四元数，或者将1000个向量的数组乘以1000个四元数的数组。
编辑：在此处添加了所有内容！
请注意，这通常意味着修改数据结构以适应。例如，不是拥有一个结构数组，而是拥有一个数组结构通常会更好。
更好的例子，假设您的代码使用了一个四元数数组，如下所示：
for(i = 0; i < quaternionCount; i++) {
cross_temp[i][0] = a[i][2] * b[i][2] - a[i][3] * b[i][1] + a[i][0] * b[i][0];
cross_temp[i][1] = a[i][3] * b[i][0] - a[i][1] * b[i][2] + a[i][0] * b[i][1];
cross_temp[i][2] = a[i][1] * b[i][1] - a[i][2] * b[i][0] + a[i][0] * b[i][2];
b[i][0] = b[i][0] + 2.0 * (a[i][2] * cross_temp[i][2] - a[i][3] * cross_temp[i][1]);
b[i][1] = b[i][1] + 2.0 * (a[i][3] * cross_temp[i][0] - a[i][1] * cross_temp[i][2]);
b[i][2] = b[i][2] + 2.0 * (a[i][1] * cross_temp[i][1] - a[i][2] * cross_temp[i][0]);
}
第一步是将其转换为数组的四元数，并执行此操作：
for(i = 0; i < quaternionCount; i++) {
cross_temp[0][i] = a[2][i] * b[2][i] - a[3][i] * b[1][i] + a[0][i] * b[0][i];
cross_temp[1][i] = a[3][i] * b[0][i] - a[1][i] * b[2][i] + a[0][i] * b[1][i];
cross_temp[2][i] = a[1][i] * b[1][i] - a[2][i] * b[0][i] + a[0][i] * b[2][i];
b[0][i] = b[0][i] + 2.0 * (a[2][i] * cross_temp[2][i] - a[3][i] * cross_temp[1][i]);
b[1][i] = b[1][i] + 2.0 * (a[3][i] * cross_temp[0][i] - a[1][i] * cross_temp[2][i]);
b[2][i] = b[2][i] + 2.0 * (a[1][i] * cross_temp[1][i] - a[2][i] * cross_temp[0][i]);
}
然后，因为2 相邻加倍适合单个SSE寄存器，您想要将循环展开2：
for(i = 0; i < quaternionCount; i += 2) {
cross_temp[0][i] = a[2][i] * b[2][i] - a[3][i] * b[1][i] + a[0][i] * b[0][i];
cross_temp[0][i+1] = a[2][i+1] * b[2][i+1] - a[3][i+1] * b[1][i+1] + a[0][i+1] * b[0][i+1];
cross_temp[1][i] = a[3][i] * b[0][i] - a[1][i] * b[2][i] + a[0][i] * b[1][i];
cross_temp[1][i+1] = a[3][i+1] * b[0][i+1] - a[1][i+1] * b[2][i+1] + a[0][i+1] * b[1][i+1];
cross_temp[2][i] = a[1][i] * b[1][i] - a[2][i] * b[0][i] + a[0][i] * b[2][i];
cross_temp[2][i+1] = a[1][i+1] * b[1][i+1] - a[2][i+1] * b[0][i+1] + a[0][i+1] * b[2][i+1];
b[0][i] = b[0][i] + 2.0 * (a[2][i] * cross_temp[2][i] - a[3][i] * cross_temp[1][i]);
b[0][i+1] = b[0][i+1] + 2.0 * (a[2][i+1] * cross_temp[2][i+1] - a[3][i+1] * cross_temp[1][i+1]);
b[1][i] = b[1][i] + 2.0 * (a[3][i] * cross_temp[0][i] - a[1][i] * cross_temp[2][i]);
b[1][i+1] = b[1][i+1] + 2.0 * (a[3][i+1] * cross_temp[0][i+1] - a[1][i+1] * cross_temp[2][i+1]);
b[2][i] = b[2][i] + 2.0 * (a[1][i] * cross_temp[1][i] - a[2][i] * cross_temp[0][i]);
b[2][i+1] = b[2][i+1] + 2.0 * (a[1][i+1] * cross_temp[1][i+1] - a[2][i+1] * cross_temp[0][i+1]);
}
现在，您想将其分解为单独的操作。例如，内部循环的前两行将变为：
cross_temp[0][i] = a[2][i] * b[2][i];
cross_temp[0][i] -= a[3][i] * b[1][i];
cross_temp[0][i] += a[0][i] * b[0][i];
cross_temp[0][i+1] = a[2][i+1] * b[2][i+1];
cross_temp[0][i+1] -= a[3][i+1] * b[1][i+1];
cross_temp[0][i+1] += a[0][i+1] * b[0][i+1];
现在重新订购：
cross_temp[0][i] = a[2][i] * b[2][i];
cross_temp[0][i+1] = a[2][i+1] * b[2][i+1];
cross_temp[0][i] -= a[3][i] * b[1][i];
cross_temp[0][i+1] -= a[3][i+1] * b[1][i+1];
cross_temp[0][i] += a[0][i] * b[0][i];
cross_temp[0][i+1] += a[0][i+1] * b[0][i+1];
完成所有这些后，请考虑转换为SSE。前两行代码是一个负载（将a[2][i]和a[2][i+1]加载到SSE寄存器中），然后是一次乘法（而不是2次单独的加载和2次单独的乘法）。这6行可能会成为（伪代码）：
load SSE_register1 with both a[2][i] and a[2][i+1]
multiply SSE_register1 with both b[2][i] and b[2][i+1]
load SSE_register2 with both a[3][i] and a[3][i+1]
multiply SSE_register2 with both b[1][i] and b[1][i+1]
load SSE_register2 with both a[0][i] and a[0][i+1]
multiply SSE_register2 with both b[0][i] and b[0][i+1]
SE_register1 = SE_register1 - SE_register2
SE_register1 = SE_register1 + SE_register3
这里的每一行伪代码都是单个SSE指令/内在函数;并且每个SSE指令/内部函数并行进行2次操作。
如果每条指令并行执行2次操作，那么（理论上）它的速度可能是原始“每条指令一次操作”代码的两倍。
答案 1 :(得分：1)
可能会使代码完全优化的一些想法。
- 您的功能应该内联
- 您应该将
restrict规范添加到cross_p以避免此问题 编译器多次重新加载 - 如果您这样做，则必须引入第四个
__m128d变量，该变量将收到第二次调用cross_p的结果
然后查看汇编程序（gcc选项-S）以查看所有这些内容的生成。
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？