【问题标题】:Expression Template implementation not being optimized表达式模板实现未优化
【发布时间】:2013-12-05 08:49:19
【问题描述】:

我试图理解 C++ 中表达式模板的概念,因此我拼凑了一些示例代码等,以生成一个简单的向量和相关的表达式模板基础结构,以仅支持二元运算符(+、-、* )。

一切都可以编译,但是我注意到标准手写循环与表达式模板变体之间的性能差异非常大。 ET 的速度几乎是手写速度的两倍。我预计会有不同,但没有那么大。

完整的代码清单可以在这里找到:

https://gist.github.com/BernieWt/769a4a3ceb90bb0cae9e

(为混乱的代码道歉。)

.

简而言之,我基本上是在比较以下两个循环:

东部时间:

for (std::size_t i = 0 ; i < rounds; ++i)
{
   v4 = ((v0 - v1) + (v2 * v3)) + v4;
   total += v4[0];
}

硬件:

for (std::size_t i = 0 ; i < rounds; ++i)
{
   for (std::size_t x = 0; x < N; ++x)
   {
      v4[x] = (v0[x] - v1[x]) + (v2[x] * v3[x]) + v4[x];
   }
   total += v4[0];
}

当我反汇编输出时,会产生以下内容,区别显然是在 ET 变体返回期间发生的额外 memcpy 和几个 64 位加载:

Standard Loop                           | Expression Template
----------------------------------------+--------------------------------
L26:                                    | L12:
xor   edx, edx                          | xor   edx, edx
jmp   .L27                              | jmp   .L13
L28:                                    | L14:
movsd xmm3, QWORD PTR [rsp+2064+rdx*8]  | movsd xmm3, QWORD PTR [rsp+2064+rdx*8]
L27:                                    | L13:
movsd xmm2, QWORD PTR [rsp+1040+rdx*8]  | movsd xmm1, QWORD PTR [rsp+1552+rdx*8]
movsd xmm1, QWORD PTR [rsp+16+rdx*8]    | movsd xmm2, QWORD PTR [rsp+16+rdx*8]
mulsd xmm2, QWORD PTR [rsp+1552+rdx*8]  | mulsd xmm1, QWORD PTR [rsp+1040+rdx*8]
subsd xmm1, QWORD PTR [rsp+528+rdx*8]   | subsd xmm2, QWORD PTR [rsp+528+rdx*8]
addsd xmm1, xmm2                        | addsd xmm1, xmm2
addsd xmm1, xmm3                        | addsd xmm1, xmm3
movsd QWORD PTR [rsp+2064+rdx*8], xmm1  | movsd QWORD PTR [rsp+2576+rdx*8], xmm1
add   rdx, 1                            | add   rdx, 1
cmp   rdx, 64                           | cmp   rdx, 64
jne   .L28                              | jne   .L14
                                        | mov   dx, 512
                                        | movsd QWORD PTR [rsp+8], xmm0
                                        | lea   rsi, [rsp+2576]
                                        | lea   rdi, [rsp+2064]
                                        | call  memcpy
movsd xmm3, QWORD PTR [rsp+2064]        | movsd xmm0, QWORD PTR [rsp+8]
sub   rcx, 1                            | sub   rbx, 1
                                        | movsd xmm3, QWORD PTR [rsp+2064]
addsd xmm0, xmm3                        | addsd xmm0, xmm3
jne   .L26                              | jne   .L12

我的问题是:此时我卡住关于如何删除副本,我基本上想在没有 的情况下更新 v4 复制。关于如何进行此操作的任何想法?

注意 1:我已经尝试过 GCC 4.7/9、Clang 3.3、VS2010/2013 - 我在提到的所有编译器上都获得了大致相同的性能配置文件。

注意 2:我也尝试过为 vec 前向声明 bin_exp,然后添加以下赋值运算符并从 bin_exp 中删除转换运算符,但无济于事

template<typename LHS, typename RHS, typename Op>
inline vec<N>& operator=(const bin_exp<LHS,RHS,Op,N>& o)
{
   for (std::size_t i = 0; i < N; ++i)  { d[i] = o[i]; }
   return *this;
}

更新 注 2 中提出的解决方案实际上是正确的。并且确实会导致编译器生成与手写循环几乎相同的代码。

.

另一方面,如果我将 ET 变体的用例重写​​如下:

auto expr = ((v0 - v1) + (v2 * v3)) + v4;

//auto& expr = ((v0 - v1) + (v2 * v3)) + v4;   same problem
//auto&& expr = ((v0 - v1) + (v2 * v3)) + v4;   same problem

for (std::size_t i = 0 ; i < rounds; ++i)
{
   v4 = expr
   total += v4[0];
}

发生崩溃是因为在 ET 实例化期间生成的临时变量(右值)在分配之前被销毁。我想知道是否有任何方法使用 C++11 导致编译器错误。

【问题讨论】:

  • 你能显示v0...v4的声明吗?
  • @Adam:你的意思是向量初始化的反汇编?
  • 不,这些向量是什么。为了省去翻阅那个相当长的文件的麻烦。
  • @Adam: gist.github.com/BernieWt/…gist.github.com/BernieWt/… 请注意,两个变体的初始化反汇编是相同的。
  • 这两个是等价的吗?表达式模板一个正在生成一个全新的std::vector,然后将其分配给v4,而手环正在修改v4,我猜。更改手循环以执行相同的操作(即,通过push_back 为每个外部循环创建一个新的v5)以将苹果与苹果进行比较。为了改进表达式模板,它必须知道它被分配给一个预先退出的vector,这意味着vector = expression 已经支持进行就地编辑,而不仅仅是expression::operator vector

标签: c++ optimization compiler-construction vectorization expression-templates


【解决方案1】:

表达式模板的要点是子表达式的评估可能会导致临时变量,这会产生成本并且不会带来任何好处。在您的代码中,您并没有真正将苹果与苹果进行比较。比较的两种选择是:

// Traditional
vector operator+(vector const& lhs, vector const& rhs);
vector operator-(vector const& lhs, vector const& rhs);
vector operator*(vector const& lhs, vector const& rhs);

有了这些操作的定义,你想要解决的表达式:

v4 = ((v0 - v1) + (v2 * v3)) + v4;

成为(为所有临时人员提供名字):

auto __tmp1 = v0 - v1;
auto __tmp2 = v2 * v3;
auto __tmp3 = __tmp1 + __tmp2;
auto __tmp4 = __tmp3 + v4;
// assignment is not really part of the expression
v4 = __tmp4;

如您所见,有 4 个临时对象,如果您使用表达式模板,它们会减少到最低限度:一个临时对象,因为这些操作中的任何一个都会生成一个不合适的值。

在您手卷的代码版本中,您没有执行相同的操作,而是展开整个循环并利用完整操作的知识,而不是真正相同的操作,因为知道您将分配在表达式的末尾到元素之一,您将表达式转换为:

v4 += ((v0 - v1) + (v2 * v3));

现在考虑如果您创建一个新的向量v5 而不是分配给构成表达式的向量之一,会发生什么情况。试试这个表达式:

auto v5 = ((v0 - v1) + (v2 * v3)) + v4;

表达式模板的神奇之处在于,您可以为在模板上工作的运算符提供一个实现与手动实现一样高效,并且用户代码更简单且不易出错(无需遍历可能出现错误或维护成本的向量的所有元素,因为在执行算术运算的每个地方都需要知道向量的内部表示)

我基本上想在没有副本的情况下更新 v4

使用表达式模板和您当前的向量界面,您将支付临时和副本的费用。原因是在表达式的(概念)评估过程中创建了一个新向量,虽然对您来说v4 = ... + v4; 等同于v4 += ... 似乎很明显,但编译器或表达式模板无法完成该转换。另一方面,您可以提供 vector::operator+=(甚至可能是 operator=)的重载,它采用表达式模板,并在适当的位置执行操作。


提供从表达式模板进行赋值的赋值运算符并使用 g++4.7 -O2 构建,这是为两个循环生成的程序集:

    call    __ZNSt6chrono12system_clock3nowEv   |    call    __ZNSt6chrono12system_clock3nowEv  
    movl    $5000000, %ecx                      |    movl    $5000000, %ecx                     
    xorpd   %xmm0, %xmm0                        |    xorpd   %xmm0, %xmm0                       
    movsd   2064(%rsp), %xmm3                   |    movsd   2064(%rsp), %xmm3                  
    movq    %rax, %rbx                          |    movq    %rax, %rbx                         
    .align 4                                    |    .align 4                                   
L9:                                             |L15:                                           
    xorl    %edx, %edx                          |    xorl    %edx, %edx                         
    jmp L8                                      |    jmp L18                                    
    .align 4                                    |    .align 4                                   
L32:                                            |L16:                                           
    movsd   2064(%rsp,%rdx,8), %xmm3            |    movsd   2064(%rsp,%rdx,8), %xmm3           
L8:                                             |L18:                                           
    movsd   1552(%rsp,%rdx,8), %xmm1            |    movsd   1040(%rsp,%rdx,8), %xmm2           
    movsd   16(%rsp,%rdx,8), %xmm2              |    movsd   16(%rsp,%rdx,8), %xmm1             
    mulsd   1040(%rsp,%rdx,8), %xmm1            |    mulsd   1552(%rsp,%rdx,8), %xmm2           
    subsd   528(%rsp,%rdx,8), %xmm2             |    subsd   528(%rsp,%rdx,8), %xmm1            
    addsd   %xmm2, %xmm1                        |    addsd   %xmm2, %xmm1                       
    addsd   %xmm3, %xmm1                        |    addsd   %xmm3, %xmm1                       
    movsd   %xmm1, 2064(%rsp,%rdx,8)            |    movsd   %xmm1, 2064(%rsp,%rdx,8)           
    addq    $1, %rdx                            |    addq    $1, %rdx                           
    cmpq    $64, %rdx                           |    cmpq    $64, %rdx                          
    jne L32                                     |    jne L16                                    
    movsd   2064(%rsp), %xmm3                   |    movsd   2064(%rsp), %xmm3                  
    subq    $1, %rcx                            |    subq    $1, %rcx                           
    addsd   %xmm3, %xmm0                        |    addsd   %xmm3, %xmm0                       
    jne L9                                      |    jne L15                                    
    movsd   %xmm0, (%rsp)                       |    movsd   %xmm0, (%rsp)                      
    call    __ZNSt6chrono12system_clock3nowEv   |    call    __ZNSt6chrono12system_clock3nowEv  

【讨论】:

  • 有趣的评论,虽然我认为比较这两个版本有点有效。也就是说,wrt:“提供 vector::operator+= 的重载(甚至可能是 operator=)”请查看 Note2。
  • @BernieWhitfold:您还可以将执行的操作与汇编中的矢量化指令进行比较。这也是一个有效的比较。如果操作得当,它会比表达式模板更快。这是否意味着表达式模板没有用?不,这仅意味着当您将其与手动组装进行比较时,效率可能会降低,或者当您与手动展开循环进行比较时,它可能大致相同,但是当您将其与用户代码没有的天真方法进行比较时想要迭代容器,但只调用操作会更好。
  • @BernieWhitfold:你在第二个注释中说无济于事是什么意思?
  • 我希望我有一些关于最终分配人员超载或类似情况的遗漏。我想人们可以“延迟”手写循环以匹配 ET 变体 - 但真的想走另一条路并优化 ET
  • 我试过了,程序集是一样的,似乎正在调用复制构造函数 - 也许我应该将其设为私有。
【解决方案2】:

C++11 引入了move semantics 以减少不必要的副本数量。

您的代码相当模糊,但我认为这应该可以解决问题

在你的struct vec 替换

value_type d[N];

std::vector<value_type> d;

并将d(N) 添加到构造函数初始化列表中。 std::array 是显而易见的选择,但这意味着移动每个元素(即您试图避免的副本)。

然后添加一个移动构造函数:

vec(vec&& from): d(std::move(from.d))
{
}

移动构造函数让新对象“窃取”旧对象的内容。换句话说,不是复制整个向量(数组),而是复制指向数组的指针。

【讨论】:

  • 已经尝试添加移动构造函数,没有效果,请注意向量的大小是静态类型的。此外,我相信 ET 在 c++11 更改通过之前很久就已经安静地工作了...... ;)
猜你喜欢
  • 2012-12-10
  • 2015-09-02
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2023-04-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多