C++ 使用二维还是一维，哪个最快？_C++_Optimization

C++ 使用二维还是一维，哪个最快？

c++ optimization

C++ 使用二维还是一维，哪个最快？,c++,optimization,C++,Optimization,我一直在网上（和stackoverflow）搜索一维数组（或向量）是否比二维数组快的观点。总的结论似乎是一维的速度最快。然而，我写了一个简短的测试程序，让自己看看，它表明二维是最好的。有谁能在我的测试中发现一个bug，或者至少解释一下为什么我会得到这个结果我使用它来存储矩阵，因此需要用行和列对一维数组进行索引。 #include <iostream> #include <chrono> #include <vector> uint64_t timestam

我一直在网上（和stackoverflow）搜索一维数组（或向量）是否比二维数组快的观点。总的结论似乎是一维的速度最快。然而，我写了一个简短的测试程序，让自己看看，它表明二维是最好的。有谁能在我的测试中发现一个bug，或者至少解释一下为什么我会得到这个结果

我使用它来存储矩阵，因此需要用行和列对一维数组进行索引。

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

uint64_t timestamp()
{
    namespace sc = std::chrono;
    static auto start = sc::high_resolution_clock::now();
    return sc::duration_cast<sc::duration<uint64_t, std::micro>>(sc::high_resolution_clock::now() - start).count();
}

int main(int argc, char** argv)
{
    if (argc < 3)
        return 0;
    size_t size = atoi(argv[1]);
    size_t repeat = atoi(argv[2]);

    int** d2 = (int**)malloc(size*sizeof(int*));
    for (size_t i = 0; i < size; ++i)
        d2[i] = (int*)malloc(size*sizeof(int));

    int* d1 = (int*)malloc(size*size*sizeof(int));

    std::vector<std::vector<int> > d2v(size);
    for (auto& i : d2v)
        i.resize(size);

    std::vector<int> d1v(size*size);

    uint64_t start, end;
    timestamp();

    start = timestamp();
    for (size_t n = 0; n < repeat; ++n)
    {
        for (size_t r = 0; r < size; ++r)
        {
            for (size_t c = 0; c < size; ++c)
            {
                if (r == 0)
                    d2[r][c] = 0;
                else
                    d2[r][c] = d2[r-1][c] + 1;
            }
        }
    }
    end = timestamp();
    std::cout << "2D array\t" << size << "\t" << end - start << std::endl;

    start = timestamp();
    for (size_t n = 0; n < repeat; ++n)
    {
        for (size_t c = 0; c < size; ++c)
        {
            for (size_t r = 0; r < size; ++r)
            {
                if (r == 0)
                    d2[r][c] = 0;
                else
                    d2[r][c] = d2[r-1][c] + 1;
            }
        }
    }
    end = timestamp();
    std::cout << "2D array C\t" << size << "\t" << end - start << std::endl;

    start = timestamp();
    for (size_t n = 0; n < repeat; ++n)
    {
        for (size_t r = 0; r < size; ++r)
        {
            for (size_t c = 0; c < size; ++c)
            {
                if (r == 0)
                    d1[r + c*size] = 0;
                else
                    d1[r + c*size] = d1[r-1 + c*size] + 1;
            }
        }
    }
    end = timestamp();
    std::cout << "1D array\t" << size << "\t" << end - start << std::endl;

    start = timestamp();
    for (size_t n = 0; n < repeat; ++n)
    {
        for (size_t c = 0; c < size; ++c)
        {
            for (size_t r = 0; r < size; ++r)
            {
                if (r == 0)
                    d1[r + c*size] = 0;
                else
                    d1[r + c*size] = d1[r-1 + c*size] + 1;
            }
        }
    }
    end = timestamp();
    std::cout << "1D array C\t" << size << "\t" << end - start << std::endl;

    start = timestamp();
    for (size_t n = 0; n < repeat; ++n)
    {
        for (size_t r = 0; r < size; ++r)
        {
            for (size_t c = 0; c < size; ++c)
            {
                if (r == 0)
                    d2v[r][c] = 0;
                else
                    d2v[r][c] = d2v[r-1][c] + 1;
            }
        }
    }
    end = timestamp();
    std::cout << "2D vector\t" << size << "\t" << end - start << std::endl;

    start = timestamp();
    for (size_t n = 0; n < repeat; ++n)
    {
        for (size_t c = 0; c < size; ++c)
        {
            for (size_t r = 0; r < size; ++r)
            {
                if (r == 0)
                    d2v[r][c] = 0;
                else
                    d2v[r][c] = d2v[r-1][c] + 1;
            }
        }
    }
    end = timestamp();
    std::cout << "2D vector C\t" << size << "\t" << end - start << std::endl;

    start = timestamp();
    for (size_t n = 0; n < repeat; ++n)
    {
        for (size_t r = 0; r < size; ++r)
        {
            for (size_t c = 0; c < size; ++c)
            {
                if (r == 0)
                    d1v[r + c*size] = 0;
                else
                    d1v[r + c*size] = d1v[r-1 + c*size] + 1;
            }
        }
    }
    end = timestamp();
    std::cout << "1D vector\t" << size << "\t" << end - start << std::endl;

    start = timestamp();
    for (size_t n = 0; n < repeat; ++n)
    {
        for (size_t c = 0; c < size; ++c)
        {
            for (size_t r = 0; r < size; ++r)
            {
                if (r == 0)
                    d1v[r + c*size] = 0;
                else
                    d1v[r + c*size] = d1v[r-1 + c*size] + 1;
            }
        }
    }
    end = timestamp();
    std::cout << "1D vector C\t" << size << "\t" << end - start << std::endl;

    return 0;
}

遍历1D数组的方式是错误的。在一维数组中不需要嵌套循环。这不仅是不必要的，而且会带来额外的数学工作来计算索引。而不是这部分,

for (size_t c = 0; c < size; ++c)
{
    for (size_t r = 0; r < size; ++r)
    {
        if (r == 0)
            d1[r + c*size] = 0;
        else
            d1[r + c*size] = d1[r-1 + c*size] + 1;
    }
}

（大小c=0；c


{
对于（大小r=0；r
你应该写
for (size_t r = 0; r < size*size; ++r)
{
    if (r == 0)
        d1[r] = 0;
    else
        d1[r] = d1[r-1] + 1;
}

（大小r=0；r
这很好。
问题的根源在于两种方案的存储顺序不同
二维结构存储在主行中。通过首先取消对行的引用，可以得到一个可以直接按列索引的缓冲区。相邻列位于相邻的内存位置
您的1D结构存储在主列中。相邻列是内存中分开的size
元素
尝试两种迭代顺序几乎涵盖了所有效果。但剩下的是数据依赖性。通过参考D（r-1，c）
，行主键和列主键之间的访问模式完全不同
果然，将1D索引更改为d1[r*size+c]
和d1[（r-1）*size+c]
会产生以下计时：
2D array    1000    78099
2D array C  1000    878527
1D array    1000    19661
1D array C  1000    729280
2D vector   1000    61641
2D vector C 1000    741249
1D vector   1000    18348
1D vector C 1000    726231

所以我们还是要解释一下。我将使用“循环携带依赖性”。当您以列主顺序迭代列主一维数组时（好主意），每个元素都依赖于在上一次迭代中计算的元素。这意味着循环不能完全管道化，因为必须完全计算结果并将其写回缓存，然后才能再次读取以计算下一个元素。在row major中，依赖关系现在是一个很久以前计算的元素，这意味着循环可以展开和管道化。
关键词：局部性，缓存。是的，但这似乎是人们说一维最快的原因。哦，刚刚检查了代码。在遍历1D数组时，您的做法是错误的。请看我在分钟内的答案。FWIW，以下是使用Intel、Clang和GCC编译器在英特尔Core i7上的Arch Linux 64位上的结果：@rubenvb是否使用优化标志？我的用例是矩阵存储，因此我使用行和列用0
和size-1
之间的整数填充矩阵。所以我需要能够通过行和列进行索引。这会产生不同的结果。编译时是否使用过任何优化标志？当我使用-O3时，1D和2D向量的速度几乎与1D数组的速度相同。是的，这些计时与使用-O3的GCC 4.8相同。在不同的优化设置中，至少有50%的因子持续存在，除非我使用-O3并禁用矢量化。在这种情况下，一维阵列的速度仅略高于二维阵列。因此，自动矢量化也在这些计时中发挥作用。
2D array    1000    78099
2D array C  1000    878527
1D array    1000    19661
1D array C  1000    729280
2D vector   1000    61641
2D vector C 1000    741249
1D vector   1000    18348
1D vector C 1000    726231