在 Windows (Mingw64) 上的执行速度比 Linux 慢 3 倍

Question

我正在开发一个在 Windows 上比在 Linux 上慢 3-4 倍的游戏引擎。 我试图分析应用程序，除了 Windows 上的一切似乎更慢之外，我没有看到特别的问题。 我提取了应用程序的一小部分。我用g++ -O3 perf.cpp 编译它并执行如下：a.exe 500000000。结果如下：

• Linux：10 秒（平均 5 次执行）：g++ 8.2 [也使用 g++ 7.3 测试]
• Windows：27 秒（5 次执行的平均值）：g++（x86_64-posix-seh-rev0，由 MinGW-W64 项目构建）8.1.0 [也使用 g++ 7.1 测试]

源代码：

#include <iostream>
#include <cmath>
#include <vector>
#include <chrono>

struct Vector{
    float X, Y, Z;

    Vector(float X, float Y, float Z) : X(X), Y(Y), Z(Z){}

    Vector vector(const Vector &target) const{
        return Vector(target.X - X, target.Y - Y, target.Z - Z);
    }

    float dotProduct(const Vector &v) const{
        return (X*v.X + Y*v.Y + Z*v.Z);
    }
};

float compute(const std::vector<Vector> &v){
    Vector vec1 = v[0].vector(v[2]);
    Vector vec2 = v[1].vector(v[0]);
    return vec1.dotProduct(vec2);
}

int main(int argc, char *argv[]){
    unsigned int loopMax = atoi(argv[1]);

    Vector va(1.5f, 3.0f, 8.0f*loopMax);
    Vector vb(1.2f, 2.3f, 11.0f*loopMax);
    Vector vc(8.2f, 5.0f, 12.0f*loopMax);

    auto frameStartTime = std::chrono::high_resolution_clock::now();

    float res = 0.0f;
    for(unsigned int i=0; i<loopMax; ++i)
    {       
        res += compute({va, vb, vc});
    }

    auto frameEndTime = std::chrono::high_resolution_clock::now();
    auto diffTimeMicroSeconds = std::chrono::duration_cast<std::chrono::microseconds>(frameEndTime - frameStartTime).count();

    std::cout<<"Time: "<<diffTimeMicroSeconds / 1000000.0 <<" sec, res: "<<res<<std::endl;
    return 0;
}

我知道一次迭代的差异是荒谬的（

什么可以解释这种差异？如何发现问题？

Answer 1

尝试在循环之外构造compute 的参数。如果编译器没有省略 std::vector<Vector> 参数的构造，这很可能会导致堆分配：

std::vector<Vector> arg{va, vb, vc};
for(unsigned int i=0; i<loopMax; ++i)
{       
    res += compute(arg);
}

如果有一个堆分配，它很可能会比循环内容的其余部分花费更多的时间。堆分配需要多长时间可能会因系统和实现而有很大差异。删除它可能会显着提高这两种情况下的性能。

如果在实际代码中每次都需要构造向量，那么您应该考虑使用固定大小的数组（原始数组或 std::array），它不会在堆上分配，而是在堆栈上分配，这要快得多。这似乎适用，因为您在 compute 实现中使用了这三个元素。

如果你在编译时不知道向量的长度并且需要每次在热循环中重建它，那么你也许可以重用堆- 分配的空间，如果您可以指定最大长度的正确猜测，则更是如此：

std::vector<Vector> arg;
arg.reserve(1000); // Allocate for up to 1000 element
for(unsigned int i=0; i<loopMax; ++i)
{   
    arg.clear();
    arg.push_back(va);
    [...]
    arg.push_back(vn);
    res += compute(arg);
}