如何在c++中加速返回指向对象的指针的函数

How to speed up a function that returns a pointer to object in c++?

本文关键字：对象 指针 函数 返回 c++ 加速      更新时间：2023-10-16

我是一名机械工程师，所以请理解我没有受过正确编码的培训。我有一个有限元代码，它使用网格来制作构成模型的元素。这个元素对这个问题不重要，所以我把它省略了。图元和轴网是从文件中读入的，该零件可以工作。

class Grid
{
private:
    int id;
    double x;
    double y;
    double z;
public:
    Grid();
    Grid(int, double, double, double);
    int get_id() { return id;};
};
Grid::Grid() {};
Grid::Grid(int t_id, double t_x, double t_y double t_z)
{
    id = t_id; x = t_x; y = t_y; z = t_z;
}
class SurfaceModel
{
private:
    Grid** grids;
    Element** elements;
    int grid_count;
    int elem_count;
public:
    SurfaceModel();
    SurfaceModel(int, int);
    ~SurfaceModel();
    void read_grid(std::string);
    int get_grid_count() { return grid_count; };
    Grid* get_grid(int);
};
SurfaceModel::SurfaceModel()
{
    grids = NULL;
    elements = NULL;
}
SurfaceModel::SurfaceModel(int g, int e)
{
    grids = new Grid*[g];
    for (int i = 0; i < g; i++)
        grids[i] = NULL;
    elements = new Element*[e];
    for (int i = 0; i < e; i++)
        elements[i] = NULL;
}
void SurfaceModel::read_grid(std::string line)
{
    ... blah blah ...
    grids[index] = new Grid(n_id, n_x, n_y, n_z);
    ... blah blah ....
}
Grid* SurfaceModel::get_grid(int i)
{
    if (i < grid_count)
        return grids[i];
    else
        return NULL;
}

当我需要实际使用网格时，我会使用get_grid，可能是这样的：

SurfaceModel model(...);
.... blah blah ..... 
for (int i = 0; i < model.get_grid_count(); i++)
{
    Grid *cur_grid = model.get_grid(i);
    int cur_id = cur_grid->get_id();
}

我的问题是，对get_grid的调用似乎比我认为的简单返回对象所花费的时间更多。我在代码上运行了gprof，发现在进行一个非常大的模拟时，get_grid被调用了大约40亿次，而使用x、y、z的另一个操作也发生了同样的情况。这个运算做一些乘法运算。我发现get_grid和math花费的时间大致相同（约40秒）。这似乎是我做错了什么。有没有更快的方法把那个物体弄出来？

我想您忘记设置grid_count和elem_count了。

这意味着，它们将具有未初始化（不确定）的值。如果为这些值进行循环，则很容易循环大量迭代。

SurfaceModel::SurfaceModel() 
   : grid_count(0), 
     grids(NULL),
     elem_count(0),
     elements(NULL)
{
}
SurfaceModel::SurfaceModel(int g, int e)
   : grid_count(g), 
     elem_count(e)
{
    grids = new Grid*[g];
    for (int i = 0; i < g; i++)
        grids[i] = NULL;
    elements = new Element*[e];
    for (int i = 0; i < e; i++)
        elements[i] = NULL;
}

但是，我建议您在这个程序中去掉new的每个实例（并为网格使用向量）

在现代CPU上，访问内存通常比做乘法花费更长的时间。在现代系统上获得良好的性能通常意味着更多地关注优化内存访问，而不是优化计算。因为您将网格对象存储为动态分配的指针数组，所以网格对象本身将不连续地存储在内存中，并且在尝试访问它们时可能会遇到许多缓存未命中。在这个例子中，您可能会看到通过将网格对象直接存储在数组或向量中来显著加速，因为您将访问循环中的连续内存，从而获得良好的缓存利用率和有效的硬件预取。

40亿次一微秒（在许多情况下这是一个非常可接受的时间）会产生4000秒。由于你只有大约40秒（如果我说得对的话），我怀疑这里有什么严重的问题。如果任务仍然很慢，我会考虑使用并行计算。

相关文章：