上证所表现特征

我想用Eigen编写一些上证所代码，有些行为没有我。上证所表现特征

鉴于代码：

#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
征对齐矢量没有UNROLL：〜120320
特征矩阵：〜120207（与Align不展开相同）
自己的SSE：160784

当我检查程序集，对齐版本和Own SSE时，使用addps movaps，但是直到我手动展开循环，我没有获得额外的性能，即使我没有在所有运行中执行（50％），没有任何提升。版本机智Eigen Matrix不使用sse，实现相同的性能，内联汇编显示在16次迭代中展开。手动展开是否有影响力？我们是否应该为SSE手动执行此操作，并且如果使用它的CPU属性取决于它？

编辑：所以总结一下。由于无法证明展开循环与未展开的展开循环相同，SSE指令执行效果不佳，因此无法隐藏存储器存储延迟。但是在汇编代码中，“单个”指令只使用1个寄存器并在展开的循环中递增。如果SSE上瘾是垂直执行的（对齐向量中的单个浮点积累了相同的添加操作量），编译器应该能够证明展开的平等性。默认情况下，SSE操作是否未经编译器优化？如果展开循环保持执行顺序，那么保留非关联数学运算，自动展开应该是可能的，为什么它不会发生，以及如何强制编译器执行它？

编辑：作为建议我跑的测试，但是从本征替补单位不下的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毫秒

特征矩阵平均值：131691毫秒

特征矩阵展开4分钟：40099毫秒

特征矩阵展开4平均数：54812毫秒

特征矩阵展开8分钟：40001毫秒

特征矩阵展开8平均数：51482毫秒

本征向量分钟：100270毫秒

特征向量平均值：117316毫秒

特征向量展开分钟：59966毫秒

特征向量展开平均值：65847毫秒

在每一个我测试机，exepted一个用是最老的。看起来像在新机器上小展开可能是非常有益的（结果在4倍展开时加速1.5到3.5倍，即使展开为8,16,32或256时也不会增加）。

来源

2017-09-25 CzakCzan

*所有*优化应该是* per-CPU *。这一切都回到了根本问题：它太慢了吗？如果答案是*是*，那么我们就避免了过早的优化。你认为这可能是一个不成熟的优化？假设是Intel SSE还是C++ SSE？ – Sebivor

它不是关于优化这些rutine，而是一般使用sse。通过每CPU的优化，你的意思是例如计数xmm寄存器和展开使用所有？ – CzakCzan

您可以展开以隐藏ADDPS或FMA延迟，以及避免循环开销的前端瓶颈。例如对于一个点积：https://stackoverflow.com/questions/45113527/why-does-mulss-take-only-3-cycles-on-haswell-different-from-agners-instruction。 –

你的计时是非常不准确的（当你多次运行你的代码时，我会得到很多变化）。为了获得更好的重现性，您应该多次运行每个变体并花费最少的时间。我把一个基准使用它们是本征的一部分BenchUtils：

#include <iostream> 
#include <unsupported/Eigen/AlignedVector3> 
#include <bench/BenchUtil.h> 

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 = 10; 
    int rep = 10; 
    BenchTimer t; 

    std::cout.precision(4); 
    { 
     std::vector<Eigen::AlignedVector3<float>> A(SIZE, Eigen::AlignedVector3<float>(0, 0, 0)); 
     BENCH(t, tries, rep, vector_no_unroll(A)); 
     std::cout << "no unroll: " << 1e3*t.best(CPU_TIMER) << "ms\n"; 
    } 
    { 
     std::vector<Eigen::AlignedVector3<float>> A(SIZE, Eigen::AlignedVector3<float>(0, 0, 0)); 
     BENCH(t, tries, rep, vector_unrolled(A)); 
     std::cout << "unrolled:  " << 1e3*t.best(CPU_TIMER) << "ms\n"; 
    } 
    { 
     Eigen::Matrix3Xf A(3, SIZE); 
     BENCH(t, tries, rep, eigen_matrix(A)); 
     std::cout << "eigen matrix: " << 1e3*t.best(CPU_TIMER) << "ms\n"; 
    } 
    { 
     Eigen::Matrix3Xf A(3, SIZE); 
     BENCH(t, tries, rep, eigen_matrix_unrolled<4>(A)); 
     std::cout << "eigen unrd<4>: " << 1e3*t.best(CPU_TIMER) << "ms\n"; 
    } 
    { 
     Eigen::Matrix3Xf A(3, SIZE); 
     BENCH(t, tries, rep, eigen_matrix_unrolled<8>(A)); 
     std::cout << "eigen unrd<8>: " << 1e3*t.best(CPU_TIMER) << "ms\n"; 
    } 
}

，我十分相似的时间几乎独立于-msse2，-msse4.2或-mavx2编译：

no unroll: 66.72ms 
unrolled:  66.83ms 
eigen matrix: 57.56ms 
eigen unrd<4>: 50.39ms 
eigen unrd<8>: 51.19ms

值得注意的是，AligenedVector3变体始终是最慢的，展开与否之间没有显着差异。矩阵变体需要大约7/8的时间，手动展开矩阵变体（每次迭代处理4或8列），将时间减少到原始时间的大约3/4。

这表明内存带宽可能是所有向量化变体的瓶颈。展开的矩阵变体可能受实际操作（或单个标量的手动拷贝）限制。

基准测试是在Intel Core i5-4210U CPU @ 1.70GHz上使用Ubuntu 16.04上的g ++ 5.4.1进行的，最近签出了Eigen开发分支。

来源

2017-09-27 21:55:48 chtz

感谢您的完整答案，但有什么办法来检查内存带宽限制？有没有什么“经验法则”来决定是否使用SSE，或者它对于机器来说是如此特定的，而不是从一开始就排除某些情况？诚实，即使我用sqrt替换简单的加法，我没有得到任何加速英特尔酷睿i7-7700HQ @ 2.8GHZ在Windows 10上。 – CzakCzan

关于内存带宽检查，例如：https://stackoverflow.com/questions/3386042/how -to-measure-memory-bandwidth-utilization-on-windows如果你在循环之间没有任何数据依赖，我认为手动展开不会带来任何显着的好处。 – chtz

但是当然，可能会有一些（旧的或者低级的）CPU在分支预测非常糟糕的情况下部分循环展开将会增加性能（当然这也会增加指令高速缓存的使用...） – chtz

上证所表现特征

回答

相关问题