封装二维数组与普通版本 - 访问速度

Question

这个问题是这个问题的继续：2-dimensional array on heap, which version is faster?

我已经定义了类似的东西：

class Array
{
    double *data;
    int X;
    int Y;

public:
    Array(int X, int Y, double init = 0) : X(X), Y(Y)
    {
        data = new double [X*Y];
        for (int i=0; i<X*Y; i++)
            data[i] = init;
    }
    ~Array() { delete[] data; }
    double *operator[] (int x) { return (data+x*Y); }
};

我希望获得具有二维可读性的连续数组的速度优势。我以为class Array 会这样做，与

Array arr(1000,1000);
arr[x][y] = n;

与普通版本（几乎）一样快

double *arr = new double [1000*1000];
arr[x*1000+y] = n;

因为operator[] 被定义为inline。

但纯版本要快得多，而封装版本仅比真正的二维版本快一点double **arr; ...; arr[x][y] = n; 不是真的，请参阅 Edit2

这正常吗？我正在 VC++ 2010 上编译，并进行了优化。

请不要使用 vector 回答，我知道这种可能性，但我对这种行为的更深层原因感兴趣......

编辑：

我已经阅读了 cmets，我的 class Array 进行了 2 次查找，我应该使用直接 1 次查找并返回对 double 的引用。我试过了，没有速度提升，完全一样。

而且我真的不明白为什么我的班级会进行 2 次查找：

Array arr(1000,1000);
arr[x][y] = n;

应该内联到：

(arr.data+x*arr.Y)[y] = n;

还有：

*((arr.data+x*arr.Y)+y) = n;

什么是完全一样的：

arr.data[x*arr.Y+y] = n; // the proposed 1 lookup access

我错了吗？

编辑2：

我再次计时并注意到，double **arr; arr[x][y] = n; 解决方案有不同的时间，从 1:47 分钟到 2:10 分钟 - 随机样式。

所有其他解决方案：

1. 像上面那样封装class Array
2. double &operator() (int x, int y) 喜欢建议
3. 与普通double *arr; arr[x*Y+y] = n;

实际上相同在 1:44 分钟左右快速并且始终保持不变。

Answer 1

您没有获得性能优势，因为您仍然需要在包装版本中进行两次内存查找。仅访问元素 x*1000+y 的一维情况下的算术运算只需要一次内存查找。您的包装版本返回一个指针，然后必须再次取消引用，这是缓慢的部分。

尝试将您的包装版本访问权限重铸为

inline double  operator()(int x, int y) const {return data[x*Y + y];}
inline double& operator()(int x, int y) {return data[x*Y + y];}

并调用为

arr(x,y) = n;

我很惊讶封装的数组比普通的二维数组快，因为它只会有更多的开销。

编辑：现在更多地研究这个问题，我发现您的解决方案实际上并没有进行两次查找，因为您的重载 [] 运算符的行为不同。请参阅我对原始帖子的评论。

Answer 2

plain 的另一个好处是维度是 const，如果您不需要运行时维度，请尝试使用模板：

也不必担心内存管理 - 这将更适合使用 std::unique_ptr 而不是 double[] 使用 std::array

template <class T, size_t X, size_t Y>
class Array
{
    using custom_array=std::array<T,X*Y>;
    std::unique_ptr<custom_array> data;

public:
    Array() : data{new custom_array} {}
    Array(const Array& rhs) : data{new custom_array(*(rhs.data))} {}
    Array& operator=(const Array& rhs) {
         if (&rhs != this)
         {
            *data=*(rhs.data);
         }
         return *this;
    }
    ~Array() {}
    T& operator() (int x, int y) { return data->at(x*Y+y); }
    T operator() (int x, int y) const { return data->at(x*Y+y); }
};

用法：Array<double,1000,1000> A; double b=A(3,4);

对于苹果到苹果 - 将数据分配为 std::array<double,X*Y>，但由于您需要堆分配，请使用上面的 unique_ptr。

Answer 3

如果我理解正确，您问为什么使用 2D 与 1D 的速度似乎可以忽略不计。

在我看来，进行 2D 矩阵访问的最佳方法是使用类似以下的方法。

double& operator()(const int row, const int col) inline{
    return data[X*row + col];
}

double operator()(const int row, const int col) inline const{
    return data[X*row + col];
}

这为您提供了参考和复制方法。

速度的问题在于它高度依赖于您机器的底层架构。

第一个问题是缓存大小。显然，缓存越大越好，1D 版本应该比 2D 更好，因为连续内存通常可以更好地使用缓存。

此外，在您的示例中，第一次访问单个元素会很慢，无论内存是如何排序的，因为该元素不在缓存中。但是，如果您多次访问该元素，或者同一区域（缓存行）中的元素，则加速应该更加明显。

第二个问题是矢量化。根据您正在执行的操作，特别是如果它们是像加法等数学运算，它们将决定速度。如果您有带有 SSE 或 AVX 扩展的较新处理器，请确保编译器正在编译以使用这些功能，这通常在您设置优化时自动完成。您可能希望通过添加 -march=native 和 -msse3 或 Windows 等效项来确保。

另一个小的优化是使 X,Y 为常量。这将使内联更加有效，但显然伴随着分配变得痛苦的缺点。

最后一句话：简介，看看你在哪里花费的时间最多并加以改进。