为什么引用调用比内联代码慢得多？

Question

我正在编写一个包含少量粒子（通常为 3 个，不超过 5 个）的物理模拟。

在精简版中，我的代码结构如下：

#include<iostream>

class Particle{
  double x; // coordinate
  double m; // mass
};


void performStep(Particle &p, double &F_external){
   p.x += -0.2*p.x + F_external/p.m; // boiled down, in reality complex calculation, not important here
}
 
int main(){

 dt = 0.001; // time step, not important

 Particle p1;
 p1.x = 5; // some random number for initialization, in reality more complex but not important here
 p.m = 1;

 Particle p2;
 p2.x = -1; // some random numbersfor initialization, in reality more complex but not important here
 p.m = 2;

 Particle p3;
 p3.x = 0; // some random number for initialization, in reality more complex but not important here
 p.m = 3;

 double F_external = 0; // external forces

 for(unsigned long long int i=0; i < 10000000000; ++i){ // many steps, typically 10e9
    F_external = sin(i*dt);
    performStep(p1, F_external);
    performStep(p2, F_external);
    performStep(p3, F_external);
 }

 std::cout << "p1.x: " << p1.x << std::endl;
 std::cout << "p2.x: " << p2.x << std::endl;
 std::cout << "p3.x: " << p3.x << std::endl;

}

我已通过clock() 确定performStep(p, F_external) 调用是我代码中的瓶颈）。 当我尝试进行内联计算时，即用 p1.x += -0.2*p1.x + F_external/p1.m; 替换 performStep(p1, F_external) 时，计算突然快了大约 2 倍。请注意，performStep() 实际上是大约 20 行的大约 60 次基本算术计算，所以如果我只为每个粒子内联它，代码就会变得非常臃肿。

为什么会这样？我正在使用 MinGW64/g++ 和 -O2 标志进行编译。我以为编译器会优化这些东西？

编辑：

这是被调用的函数。请注意，实际上，我使用几个不同的外力计算所有三个坐标 x、y、z。未通过函数传递的变量是SimulationRun 的成员。该算法是四阶leapfrog算法。

void SimulationRun::performLeapfrog_z(const unsigned long long int& i, const double& x, const double& y, double& z, const double& vx, const double& vy, double& vz, const double& qC2U0, 
    const double& U0, const double& m, const double& C4, const double& B2, const double& f_minus, const double& f_z, const double& f_plus, const bool& bool_calculate_xy,
    const double& Find, const double& Fheating) {

    // probing for C4 == 0 and B2 == 0 saves some computation time
    if (C4 == 0) {
        Fz_C4_Be = 0;
    }
    if (B2 == 0 || !bool_calculate_xy) {
        Fz_B2_Be = 0;
    }


    z1 = z + c1 * vz * dt;


    if (C4 != 0 && !bool_calculate_xy) {
        Fz_C4_Be = (-4) * q * C4 * U0 * z1 * z1 * z1;
    }
    else if (C4 != 0 && bool_calculate_xy) {
        Fz_C4_Be = q * C4 * U0 * (-4 * z1 * z1 * z1 + 6 * z1 * (x * x + y * y));
    }
    if (B2 != 0 && bool_calculate_xy) {
        Fz_B2_Be = q * B2 * (-vx * z1 * y + vy * z1 * x);
    }
    acc_z1 = (qC2U0 * (-2) * z1 + Find + Fz_C4_Be + Fz_B2_Be + Fheating) / m;
    vz1 = vz + d1 * acc_z1 * dt;
    z2 = z1 + c2 * vz1 * dt;


    if (C4 != 0 && !bool_calculate_xy) {
        Fz_C4_Be = (-4) * q * C4 * U0 * z2 * z2 * z2;
    }
    else if (C4 != 0 && bool_calculate_xy) {
        Fz_C4_Be = q * C4 * U0 * (-4 * z2 * z2 * z2 + 6 * z2 * (x * x + y * y));
    }
    if (B2 != 0 && bool_calculate_xy) {
        Fz_B2_Be = q * B2 * (-vx * z2 * y + vy * z2 * x);
    }
    acc_z2 = (qC2U0 * (-2) * z2 + +Find + Fz_C4_Be + Fz_B2_Be + Fheating) / m;
    vz2 = vz1 + d2 * acc_z2 * dt;
    z3 = z2 + c3 * vz2 * dt;

    if (C4 != 0 && !bool_calculate_xy) {
        Fz_C4_Be = (-4) * q * C4 * U0 * z3 * z3 * z3;
    }
    else if (C4 != 0 && bool_calculate_xy) {
        Fz_C4_Be = q * C4 * U0 * (-4 * z3 * z3 * z3 + 6 * z3 * (x * x + y * y));
    }
    if (B2 != 0 && bool_calculate_xy) {
        Fz_B2_Be = q * B2 * (-vx * z3 * y + vy * z3 * x);
    }
    acc_z3 = (qC2U0 * (-2) * z3 + Find + Fz_C4_Be + Fz_B2_Be + Fheating) / m;
    vz3 = vz2 + d3 * acc_z3 * dt;

    z = z3 + c4 * vz3 * dt;
    vz = vz3;
}

Answer 1

优化很难，即使对于编译器也是如此。以下是一些优化提示：

1. 因为你的performStep是热点，所以把它放到一个头文件中（如果你把声明和定义分成头/源），然后添加inline关键字，比如：

// at file xxx.h
inline void performStep(Particle &p, double F_external){
   p.x += -0.2*p.x + F_external/p.m; // boiled down, in reality complex calculation, not important here
}
 

1. 将您的编译器升级到最新版本。
2. 使用https://godbolt.org/检查汇编代码。在这种情况下，不必要的取消引用是性能问题。