【发布时间】：2018-03-06 13:10:01
【问题描述】：
我正在尝试使用 Eigen 编写一些 SSE 代码，但我无法理解一些行为。
给定代码：
#ifndef EIGEN_DONT_VECTORIZE // Not needed with Intel C++ Compiler XE 15.0
#define EIGEN_VECTORIZE_SSE4_2
#define EIGEN_VECTORIZE_SSE4_1
#define EIGEN_VECTORIZE_SSSE3
#define EIGEN_VECTORIZE_SSE3
#endif
#include "stdafx.h"
#include <iostream>
#include <unsupported/Eigen/AlignedVector3>
#include <Eigen/StdVector>
#include <chrono>
int _tmain(int argc, _TCHAR* argv[]) {
static const int SIZE = 4000000;
EIGEN_ALIGNED_VECTOR3 Eigen::AlignedVector3<float> A_SSE(1, 1, 1);
//EIGEN_ALIGNED_VECTOR3 Eigen::AlignedVector3<float> B_SSE(2, 2, 2);
//std::vector<Eigen::AlignedVector3<float>> C_SSE(SIZE, Eigen::AlignedVector3<float>(0,0,0));
EIGEN_ALIGNED_VECTOR3 Eigen::AlignedVector3<float> A_SSE1(1, 1, 1);
EIGEN_ALIGNED_VECTOR3 Eigen::AlignedVector3<float> A_SSE2(1, 1, 1);
EIGEN_ALIGNED_VECTOR3 Eigen::AlignedVector3<float> A_SSE3(1, 1, 1);
EIGEN_ALIGNED_VECTOR3 Eigen::AlignedVector3<float> A_SSE4(1, 1, 1);
EIGEN_ALIGNED_VECTOR3 Eigen::AlignedVector3<float> B_SSE(2, 2, 2);
EIGEN_ALIGNED_VECTOR3 Eigen::AlignedVector3<float> B_SSE_increment_unroll(16, 16, 16);
A_SSE2 += B_SSE;
A_SSE3 = A_SSE2 + B_SSE;
A_SSE4 = A_SSE3 + B_SSE;
std::vector<Eigen::AlignedVector3<float>> C_SSE(SIZE, Eigen::AlignedVector3<float>(0, 0, 0));
auto start2 = std::chrono::system_clock::now();
// no unroll
for (int iteration = 0; iteration < SIZE; ++iteration) {
A_SSE += B_SSE;
C_SSE[iteration] = A_SSE;
}
//// own unroll
//for (int iteration = 0; iteration < SIZE / 8; ++iteration){
// A_SSE1 += B_SSE_increment_unroll;
// A_SSE2 += B_SSE_increment_unroll;
// A_SSE3 += B_SSE_increment_unroll;
// A_SSE4 += B_SSE_increment_unroll;
// C_SSE[iteration * 2] = A_SSE1;
// C_SSE[iteration * 2 + 1] = A_SSE2;
// C_SSE[iteration * 2 + 2] = A_SSE3;
// C_SSE[iteration * 2 + 3] = A_SSE4;
//}
auto end2 = std::chrono::system_clock::now();
auto elapsed2 = end2 - start2;
std::cout << "Eigen aligned vector " << elapsed2.count() << '\n';
Eigen::Matrix3Xf A = Eigen::Matrix3Xf::Zero(3, SIZE);
Eigen::Vector3f B(3, 3, 3);
Eigen::Vector3f C(2, 2, 2);
auto start1 = std::chrono::system_clock::now();
for (int iteration = 0; iteration < SIZE; ++iteration) {
B += C;
A.col(iteration) = B;
}
auto end1 = std::chrono::system_clock::now();
auto elapsed1 = end1 - start1;
std::cout << "Eigen matrix " << elapsed1.count() << '\n';
float *pResult = (float*)_aligned_malloc(SIZE * sizeof(float) * 4, 16); // align to 16-byte for SSE
auto start3 = std::chrono::system_clock::now();
__m128 x;
__m128 xDelta = _mm_set1_ps(2.0f); // Set the xDelta to (4,4,4,4)
__m128 *pResultSSE = (__m128*) pResult;
x = _mm_set_ps(1.0f, 1.0f, 1.0f, 1.0f); // Set the initial values of x to (4,3,2,1)
for (int iteration = 0; iteration < SIZE; ++iteration)
{
x = _mm_add_ps(x, xDelta);
pResultSSE[iteration] = x;
}
auto end3 = std::chrono::system_clock::now();
auto elapsed3 = end3 - start3;
std::cout << "Own sse " << elapsed3.count() << '\n';
}
时间似乎很奇怪，在我的电脑上
- 特征对齐向量展开：20057
- 特征对齐向量没有展开：~120320
- 特征矩阵：~120207（与 Align no unroll 相同）
- 自有SSE：160784
当我检查程序集、对齐版本和自己的 SSE 时使用 addps movaps，但在我手动展开循环之前我没有获得额外的性能，即使我不是在所有运行中都这样做 (50%) 我没有得到任何提升。具有 Eigen Matrix 的版本不使用 sse，实现相同的性能，内联汇编显示在 16 次迭代中展开。手动展开有那么有影响吗？我们是否应该为 SSE 手动执行此操作，如果使用 CPU 属性取决于它？
编辑： 所以总结一下。 SSE 指令表现不佳，因为无法证明展开循环将保持与未展开循环相同的结果，因此它无法隐藏内存存储延迟。但在汇编代码中，“单个”指令仅使用 1 个寄存器并在展开循环中递增。如果垂直执行 SSE 依赖（对齐向量中的单个浮点数累积相同数量的加法运算）编译器应该能够证明展开的相等性。默认情况下，SSE 操作是否未经编译器优化？如果展开循环保留执行顺序，所以保留非关联数学，自动展开应该是可能的，为什么它不会发生，以及如何强制编译器这样做？
编辑： 正如我建议的那样，我运行了测试，但是来自 eigen 的工作台单元在 Visual Studio 2017 下不起作用，所以它被替换为
#include <iostream>
#include <vector>
#include <unsupported/Eigen/AlignedVector3>
#include <chrono>
#include <numeric>
EIGEN_DONT_INLINE
void vector_no_unroll(std::vector<Eigen::AlignedVector3<float>>& out)
{
Eigen::AlignedVector3<float> A_SSE(1, 1, 1);
Eigen::AlignedVector3<float> B_SSE(2, 2, 2);
for (auto &x : out)
{
A_SSE += B_SSE;
x = A_SSE;
}
}
EIGEN_DONT_INLINE
void vector_unrolled(std::vector<Eigen::AlignedVector3<float>>& out)
{
Eigen::AlignedVector3<float> A_SSE1(1, 1, 1);
Eigen::AlignedVector3<float> A_SSE2(1, 1, 1);
Eigen::AlignedVector3<float> A_SSE3(1, 1, 1);
Eigen::AlignedVector3<float> A_SSE4(1, 1, 1);
Eigen::AlignedVector3<float> B_SSE(2, 2, 2);
Eigen::AlignedVector3<float> B_SSE_increment_unroll(16, 16, 16);
A_SSE2 += B_SSE;
A_SSE3 = A_SSE2 + B_SSE;
A_SSE4 = A_SSE3 + B_SSE;
for (size_t i = 0; i<out.size(); i += 4)
{
A_SSE1 += B_SSE_increment_unroll;
A_SSE2 += B_SSE_increment_unroll;
A_SSE3 += B_SSE_increment_unroll;
A_SSE4 += B_SSE_increment_unroll;
out[i + 0] = A_SSE1;
out[i + 1] = A_SSE2;
out[i + 2] = A_SSE3;
out[i + 3] = A_SSE4;
}
}
EIGEN_DONT_INLINE
void eigen_matrix(Eigen::Matrix3Xf& out)
{
Eigen::Vector3f B(1, 1, 1);
Eigen::Vector3f C(2, 2, 2);
for (int i = 0; i < out.cols(); ++i) {
B += C;
out.col(i) = B;
}
}
template<int unrolling> EIGEN_DONT_INLINE
void eigen_matrix_unrolled(Eigen::Matrix3Xf& out)
{
Eigen::Matrix<float, 3, unrolling> B = Eigen::Matrix<float, 1, unrolling>::LinSpaced(3.f, 1 + 2 * unrolling).template replicate<3, 1>();
for (int i = 0; i < out.cols(); i += unrolling) {
out.middleCols<unrolling>(i) = B;
B.array() += float(2 * unrolling);
}
}
int main() {
static const int SIZE = 4000000;
int tries = 30;
int rep = 10;
std::vector<int> Timings(tries, 0);
{
Eigen::Matrix3Xf A(3, SIZE);
#pragma loop( 1 )
for (int iter = 0; iter < tries; ++iter)
{
auto start1 = std::chrono::system_clock::now();
eigen_matrix(A);
Timings[iter] = (std::chrono::system_clock::now() - start1).count();
}
}
std::cout << "eigen matrix Min: " << *std::min_element(Timings.begin(), Timings.end()) << " ms\n";
std::cout << "eigen matrix Mean: " << std::accumulate(Timings.begin(), Timings.end(), 0) / tries << " ms\n";
{
Eigen::Matrix3Xf A(3, SIZE);
#pragma loop( 1 )
for (int iter = 0; iter < tries; ++iter)
{
auto start1 = std::chrono::system_clock::now();
eigen_matrix_unrolled<4>(A);
Timings[iter] = (std::chrono::system_clock::now() - start1).count();
}
}
std::cout << "eigen matrix unrolled 4 min: " << *std::min_element(Timings.begin(), Timings.end()) << " ms\n";
std::cout << "eigen matrix unrolled 4 Mean: " << std::accumulate(Timings.begin(), Timings.end(), 0) / tries << " ms\n";
{
Eigen::Matrix3Xf A(3, SIZE);
#pragma loop( 1 )
for (int iter = 0; iter < tries; ++iter)
{
auto start1 = std::chrono::system_clock::now();
eigen_matrix_unrolled<8>(A);
Timings[iter] = (std::chrono::system_clock::now() - start1).count();
}
}
std::cout << "eigen matrix unrolled 8 min: " << *std::min_element(Timings.begin(), Timings.end()) << " ms\n";
std::cout << "eigen matrix unrolled 8 Mean: " << std::accumulate(Timings.begin(), Timings.end(), 0) / tries << " ms\n";
{
std::vector<Eigen::AlignedVector3<float>> A(SIZE, Eigen::AlignedVector3<float>(0, 0, 0));
#pragma loop( 1 )
for (int iter = 0; iter < tries; ++iter)
{
auto start1 = std::chrono::system_clock::now();
vector_no_unroll(A);
Timings[iter] = (std::chrono::system_clock::now() - start1).count();
}
}
std::cout << "eigen vector min: " << *std::min_element(Timings.begin(), Timings.end()) << " ms\n";
std::cout << "eigen vector Mean: " << std::accumulate(Timings.begin(), Timings.end(), 0) / tries << " ms\n";
{
std::vector<Eigen::AlignedVector3<float>> A(SIZE, Eigen::AlignedVector3<float>(0, 0, 0));
#pragma loop( 1 )
for (int iter = 0; iter < tries; ++iter)
{
auto start1 = std::chrono::system_clock::now();
vector_unrolled(A);
Timings[iter] = (std::chrono::system_clock::now() - start1).count();
}
}
std::cout << "eigen vector unrolled min: " << *std::min_element(Timings.begin(), Timings.end()) << " ms\n";
std::cout << "eigen vector unrolled Mean: " << std::accumulate(Timings.begin(), Timings.end(), 0) / tries << " ms\n";
}
并在 8 台不同的机器（所有窗口）上检查结果并得到以下结果
特征矩阵最小值：110477 ms
特征矩阵均值：131691 ms
特征矩阵展开 4 分钟：40099 毫秒
特征矩阵展开 4 均值：54812 毫秒
特征矩阵展开 8 分钟：40001 毫秒
特征矩阵展开 8 均值：51482 毫秒
特征向量最小值：100270 ms
特征向量均值：117316 ms
特征向量展开最小值：59966 毫秒
特征向量展开平均值：65847 ms
在我测试的每台机器上，除此之外的机器都是最旧的。看起来在新机器上小展开可能是非常有益的（结果从 1.5 到 3.5 倍不同，加速 4 倍展开，即使展开 8、16、32 或 256 次也不会增加）。
【问题讨论】：
-
All 优化应该是per-CPU。这一切都回到了根本问题：是不是太慢了？如果答案是是，那么我们就避免了过早的优化。您认为这可能是过早的优化吗？假设是英特尔 SSE 还是 C++ SSE？
-
这不是优化这些规则，而是一般使用 sse。通过每个 cpu 的优化，您的意思是例如计算 xmm 寄存器并展开以使用所有？
-
您手动展开的代码不等同于原始代码，因为浮点数学（通常）是非关联的。在您的特定情况下，展开实际上会提高准确性。
-
@Sebivor 您的评论实际上可以应用于 SSE/AVX/AVX512 标签中的几乎每个问题。所以我会说，不言而喻，任何知道包含这些标签的人都可能已经超越了“是否过早优化？”阶段。
-
@PeterCordes 展开使用所有寄存器具有破坏所有被调用者保存寄存器的副作用（在 Windows 中）。除非绝对必要，否则仅此一项就足以让我不推荐它。