为什么一维数组比C#中的Jagged数组更快？

Question

我很好奇,如果一维数组比锯齿状数组更快,我测量了以下代码块的性能:

测试1:锯齿状阵列

double[][][][] jagged = ArrayExtensions.Get4DMatrix<double>(100, 100, 50, 50, 0);
for (int iter = 0; iter < 5; iter++)
{
    sw.Restart();
    for (i = 0; i < 100; i++)
    {
        for (j = 0; j < 100; j++)
        {
            for (k = 0; k < 50; k++)
            {
                for (l = 0; l < 50; l++)
                {
                    test = jagged[i][j][k][l];
                    jagged[i][j][k][l] = test;
                }
            }
        }
    }
    Console.WriteLine("Jagged Arrays, Test {0}: {1} ms", iter, sw.ElapsedMilliseconds);
}

测试2:单维数组

double[] single = ArrayExtensions.Get1DArray<double>(25000000);
for (int iter = 0; iter < 5; iter++)
{
    sw.Restart();
    for (i = 0; i < 100; i++)
    {
        for (j = 0; j < 100; j++)
        {
            for (k = 0; k < 50; k++)
            {
                for (l = 0; l < 50; l++)
                {
                    test = single[i * 100 + j * 100 + k * 50 + l];
                    single[i * 100 + j * 100 + k * 50 + l] = test;
                }
            }
        }
    }
    Console.WriteLine("Single Arrays, Test {0}: {1} ms", iter, sw.ElapsedMilliseconds);
}

运行测试产生:

Jagged Arrays, Test 0: 1447 m
Jagged Arrays, Test 1: 1429 m
Jagged Arrays, Test 2: 1431 m
Jagged Arrays, Test 3: 1430 m
Jagged Arrays, Test 4: 1429 m

Single Arrays, Test 0: 386 ms
Single Arrays, Test 1: 387 ms
Single Arrays, Test 2: 386 ms
Single Arrays, Test 3: 387 ms
Single Arrays, Test 4: 387 ms

另外,我只在分配数组时运行测试,然后只从数组中读取,结果具有相同的比率.

我期待一维数组比锯齿状数组更快,但当我看到最后一个块仅在第一个块的执行时间的27%执行时,我感到非常惊讶.

有人能解释为什么会出现这种巨大差异吗 使用一维数组也有任何缺点(除了代码可读性之外,它显然变得更难,并且可能增加了出错的风险)？

代码是在非优化版本中执行的.在优化构建中,两次测试在每次迭代时都会在100毫秒内执行,但我认为这需要在循环内执行的代码中执行更多操作.尽管如此,1维阵列比锯齿状阵列快50%.

Answer 1

   test = single[i * 100 + j * 100 + k * 50 + l];

一位聪明的程序员曾经说过:"永远不要相信你没有自己伪造的基准".可能是无心的,这是你的代码中一个非常讨厌的错误,让你比较苹果和橘子.乘数完全错误.该i指数必须乘以100*50*50,j指数乘以50*50.

副作用是,你多少更容易,因为你的地址要少得多的内存来有效地使用CPU缓存.造成巨大差异,RAM非常慢.