c++ - SSE 性能 Eigen-6ren

c++ - SSE 性能 Eigen

转载作者：太空狗更新时间：2023-10-29 21:34:30

我正在尝试使用 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';

}

在我的电脑上时间似乎很奇怪

Eigen 对齐 vector 展开:20057
未展开的特征对齐 vector :~120320
特征矩阵:~120207(与 Align no unroll 相同)
拥有上交所:160784

当我检查程序集时，对齐版本和 Own SSE 使用 addps movaps，但在我手动展开循环之前，我不会获得额外的性能，即使我在所有运行中都没有这样做 (50%)，我也没有得到任何提升。具有特征矩阵的版本不使用 sse，实现相同的性能，内联汇编显示在 16 次迭代中展开。手动展开是否有影响？我们是否应该为 SSE 手动执行此操作，是否取决于 CPU 属性？

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

编辑:按照建议我运行测试，但是来自 eigen 的 bench 单元在 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 毫秒

在我测试的每台机器上，除了最旧的机器。看起来在新机器上小的展开可能是非常有益的(结果不同于 1.5 到 3.5 倍的加速 4 倍展开并且即使展开是 8、16、32 或 256 次也不会增加)。

最佳答案

您的计时非常不准确(多次运行您的代码时，我得到了很多变化)。为了获得更好的重现性，您应该多次运行每个变体并花费最少的时间。我使用作为 Eigen 一部分的 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 开发分支。

关于c++ - SSE 性能 Eigen ，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46407332/

文章推荐： python - 如何更改我的 PyPI 用户名？

文章推荐： Python 的 argh 库 : preserve docstring formatting in help message

sse - SSE-不存在的hardsub固有的吗？
在浏览可用的内在函数时，我注意到没有地方可以看到水平的addsub / subadd指令可用。在过时的3DNow中可用!扩展名，但是出于明显的原因，它的使用是不实际的。是什么原因导致SSE3扩展中无法
assembly - SSE 在哪里可以找到从 SSE 内在函数到汇编程序的翻译指南
我需要在 SSE2 汇编程序中编写一些东西。我所看到的都是内在因素。我一直在寻找从内在函数到汇编器的转换表，但一直没有找到。因为我不想玩猜谜游戏，有人可以给我一个链接，将这些可怕的内在函数转换为
sse - 随机播放 16 位向量 SSE
我正在研究 SSE 并且是这里的新手。我正在尝试使用 shuffle 指令来随机播放一个 16 位向量，如下所示: 输入: 1 2 3 4 5 6 7 8 输出: 1 5 2 6 3 7 4 8 如何
sse - 我们可以使用 SSE 内在函数写入内存映射的 PCI 设备内存吗
我有一个用例，其中 x86 CPU 必须将 64 字节的数据写入内存已 mmapp 到用户空间的 PCIe 从属设备。截至目前，我使用 memcpy 来执行此操作，但事实证明它非常慢。我们可以使用像
sse - 隐式 SSE/AVX 加载/存储和堆栈
我最近偶然发现了隐式 SSE/AVX 加载/存储。我认为这些是 GCC 的一些特殊扩展，但后来意识到它们也适用于 MSVC。 __m128 a = *(__m128*)data // same
sse - 在整数 SSE 寄存器中移动更高或更低 64 位的最快方法
仅将较高或较低 64 位从整数 SSE 寄存器移动到另一个的最快方法是什么？使用 SSE 4.1，可以使用单个 pblendw 来完成。指令(_mm_blend_epi16)。但是旧的 SSE 版本呢
sse - 实用的 BigNum AVX/SSE 可能吗？
SSE/AVX 寄存器可以被视为整数或浮点 BigNum。也就是说，人们可能会忽略车道的存在。是否存在一种简单的方法来利用这个观点并将这些寄存器单独或组合用作 BigNum？我问这个问题是因为从我对
c++ - 简单的 SSE 循环比非 SSE 版本慢
我正在尝试比较 SSE float[4] 添加与标准 float[4] 添加。作为演示，我在使用和不使用 SSE 的情况下计算求和分量的总和: #include #include struct P
c - 禁用 SSE 的 SSE 寄存器返回
我处于以下情况: 我正在为不允许 SSE 指令的内核编写代码我需要做浮点运算我正在为 x86_64 平台编译这是一个说明问题的代码示例: int main(int argc, char** ar
c - 禁用 SSE 的 SSE 寄存器返回
我处于以下情况: 我正在为不允许 SSE 指令的内核编写代码我需要做浮点运算我正在为 x86_64 平台编译这是一个说明问题的代码示例: int main(int argc, char** ar
sse - SSE 和 NEON Intrinsics-Shuffling 之间的转换
我正在尝试将用 SSE3 内在函数编写的代码转换为 NEON SIMD，但由于 shuffle 函数而卡住了。我查看了 GCC Intrinsic , ARM manuals和其他论坛，但一直无法找到
sse - 我可以将存储在 _m128 SSE 寄存器中的 float 直接移动到普通寄存器吗？
我正在尝试对一些代码进行 super 优化，我想加快速度的地方如下。我想取一个 _m128 的点积运算 (_mm_dp_ps) 的答案，并将答案直接保存到寄存器中。但是，使用 _mm_store，这
sse - SSE 和 AVX 的 SIMD 数学库
我正在寻找 SSE 和 AVX 的 SIMD 数学库(最好是开源的)。我的意思是，例如，如果我有一个带有 8 个浮点值的 AVX 寄存器 v，我希望 sin(v) 一次返回所有八个值的 sin。 AM
sse - 可能使用 SSE/SSE2/SSE3/SSE4 指令从多个数字创建位掩码的有效方法
假设我在 128 位变量/寄存器中有 16 个 ascii 字符(因此有 16 个 8 位数字)。我想创建一个位掩码，其中那些位将是高位，其位位置(索引)由这 16 个字符表示。例如，如果由这 16
sse - 如何在 c++ 的 x64 架构中使用 SSE 指令？
目前我正在使用 Visual C++ 内联汇编使用 SSE 嵌入一些核心功能；但是我意识到 x64 模式不支持内联汇编。在 x64 架构中构建软件时如何使用 SSE？最佳答案在 C/C++ 中使
sse - 使用 SSE/AVX/AVX2 检查 __m128i 的所有字节是否与单个字节匹配
我正在寻找计算以下函数的有效方法: 输入:__m128i数据，uint8_t in; 输出: bool 值，指示 data 中的任何字节是否在 in 中。我实际上是在使用它们为容量为 8 的字节实现
sse - 使用 SSE/AVX/AVX2 检查 __m128i 的所有字节是否与单个字节匹配
我正在寻找计算以下函数的有效方法: 输入:__m128i数据，uint8_t in; 输出: bool 值，指示 data 中的任何字节是否在 in 中。我实际上是在使用它们为容量为 8 的字节实现
php - HTML SSE 或 PHP SSE .innerHTML 显示顺序
我正在尝试将最新消息拉入顶部页面。目前，每次收到新消息时，最新消息都会显示在下方。 if(typeof(EventSource)!=="undefined") { var source=new Ev
sse - 使用 AVX/AVX2/SSE __m128i 将所有负字节设置为 -128 (0x80) 并保留所有其他字节
基本上我想做的是获取一个 __m128i 寄存器并将每个负字节的值设置为 -128 (0x80) 并且不更改任何正值。确切的是: signed char __m128_as_char_arr[16]
sse - 使用 SSSE3 将 2 个未对齐的 64 位值加载到 sse 寄存器中的最佳方法是什么？
有 2 个指针指向要加载到 xmm 寄存器中的 2 个未对齐的 8 字节 block 。如果可能，使用内在函数。如果可能的话，不使用辅助寄存器。没有pinsrd。 (SSSE核心2) 最佳答案来自

太空狗

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - SSE 性能 Eigen