标签: compiler-optimization

我有以下 C 函数：

void proc(long  a1, long  *a1p,
          int   a2, int   *a2p,
          short a3, short *a3p,
          char  a4, char  *a4p)
{
    *a1p += a1;
    *a2p += a2;
    *a3p += a3;
    *a4p += a4;
}

使用Godbolt，我已将其转换为 x86_64 程序集（为简单起见，我使用该-Og标志来最小化优化）。它产生以下组件：

proc:
        movq    16(%rsp), %rax
        addq    %rdi, (%rsi)
        addl    %edx, (%rcx)
        addw    %r8w, (%r9)
        movl    8(%rsp), %edx
        addb    %dl, (%rax)
        ret

我对汇编的第一行感到困惑：movq 16(%rsp), %rax. 我知道%rax寄存器用于存储返回值。但是该proc过程没有返回值。所以我很好奇为什么在此处使用该寄存器，而不是 %r9其他一些不用于返回值的寄存器。

相对于其他指令，我也对这条指令的位置感到困惑。它首先出现，远在%rax任何需要其目标寄存器之前（实际上，直到最后一步才需要该寄存器）。它也出现在 之前addq %rdi, (%rsi) …

测试代码：

#include <array>

int test(const std::array<int, 10> &arr) {
    return arr[9];
}

我要实现arr[0]像C风格数组一样高效，这意味着内联STL数组[]运算符函数。

我检查了生成汇编代码：

$ g++ --std=c++17  -c test.cpp && objdump -d -C test.o

test.o:     file format elf64-x86-64

Disassembly of section .text:

0000000000000000 <test(std::array<int, 10ul> const&)>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   48 83 ec 10             sub    $0x10,%rsp
   8:   48 89 7d f8             mov    %rdi,0xfffffffffffffff8(%rbp)
   c:   48 8b 45 f8             mov    0xfffffffffffffff8(%rbp),%rax
  10:   be 09 00 00 00          mov    $0x9,%esi
  15:   48 89 …

我遇到了一些速度很快的优化代码，但它使我的代码变得丑陋。

一个最小的例子如下：

enum class Foo : char {
    A = 'A',
    B = 'B'
};

struct A_t {
    constexpr operator Foo() const { return Foo::A; }
};

void function_v1(Foo s){
   if(s == Foo::A){
      //Run special version of the code
   } else {
      //Run other version of the code
   }
}

template<class foo_t>
void function_v2(foo_t s){
   if(s == Foo::A){
      //Run special version of the code
   } else {
      //Run other version of the code
   }
}

int main(){

   // Version 1 …

如果运行Python代码然后调用exit()，它将退出程序并且以下代码将不会运行。但是我添加exit()到我的程序中，然后出现一些语法错误并且程序崩溃了。我想知道为什么 Python 编译器在运行之前没有优化我的代码。我用逻辑错误尝试了这个问题，但它忽略了它们，比如index out of range等等。那么为什么下面的代码不起作用并SyntaxError发生呢？

print("Hi")
exit()
if 

我们可以转发声明一个函数：

void func1();

void func2() {
    // use func1
}

void func1() {
    // do stuff
}

func1如果调用以下命令，这可能是必要的func2：

void func1();

void func2() {
    func1();
}

void func1() {
    if (condition) {
        func2();
    }
}

虽然func1第二个示例中的内联并不困难，但我不知道在任意复杂的程序中是否存在此类编译器优化的理论障碍。在第二种情况下，前向声明是必要的，并且可能会丢失与程序的递归性质相关的编译器优化。

问题：当不需要但仍然使用前向声明时（例如第一个示例），任何主要编译器（gcc、clang、msvc）上是否会丢失任何编译器优化？

我正在寻找一些示例std::visit，并且我想探索一下以下常见示例代码：

#include <iostream>
#include <variant>

struct Fluid { };
struct LightItem { };
struct HeavyItem { };
struct FragileItem { };

template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
template<class... Ts> overload(Ts...) -> overload<Ts...>; // line not needed in C++20...

int main() {
    std::variant<Fluid, LightItem, HeavyItem, FragileItem> package(HeavyItem{});

    std::visit(overload{
        [](Fluid& )       { std::cout << "fluid\n"; },
        [](LightItem& )   { std::cout << "light item\n"; },
        [](HeavyItem& )   { std::cout << "heavy item\n"; },
        [](FragileItem& ) { std::cout …

最近，我和一位同事就 python 和 C++ 的性能比较进行了争论。我们俩主要使用这些语言来进行线性代数。所以我写了两个脚本，一个在 python3 中使用 numpy，另一个在 C++ 中使用 Eigen。

Python3 numpy版本matmul_numpy.py：

import numpy as np
import time
a=np.random.rand(2000,2000)
b=np.random.rand(2000,2000)
start=time.time()
c=a*b
end=time.time()
print(end-start) 

如果我运行这个脚本

python3 matmul_numpy.py

这将返回：

0.07 seconds

C++ 特征版本 matmul_eigen.cpp：

#include <iostream>
#include <Eigen/Dense>
#include "time.h"
int main(){
        clock_t start,end;
        size_t n=2000;
        Eigen::MatrixXd a=Eigen::MatrixXd::Random(n,n);
        Eigen::MatrixXd b=Eigen::MatrixXd::Random(n,n);
        start=clock();
        Eigen::MatrixXd c=a*b;
        end=clock();
        std::cout<<(double)(end-start)/CLOCKS_PER_SEC<<std::endl;
        return 0;}

我编译的方式是

g++ matmul_eigen.cpp -I/usr/include/eigen3 -O3 -march=native -std=c++17 -o matmul_eigen

这将返回（c++11 和 c++17）：

0.35 seconds

这对我来说很奇怪，1-为什么 numpy 这里比 C++ 更快？我是否缺少任何其他优化标志？

我想也许是因为 python 解释器在这里执行程序更快。因此，我使用stacks …