Question

我不熟悉java惯例和最佳实践。

我需要二维缓冲区来进行涉及动态编程的大型计算，并怀疑我是否应该使用一维数组并将两个坐标映射到单个，或者使用数组和索引链接访问。

在C中，我更喜欢第一种方式，但Java不是C，可能还有其他重要的细节。

Answer 1

如果您需要最高速度，请务必使用单个数组（一维）并根据需要映射索引。正如我在你的问题下面的评论中链接的线程中看到的那样，人们似乎忽略了2d数组对CPU缓存行的不良影响，并且只强调了内存查找的数量。

是要考虑的一个因素：如果你的内部数组足够大（比如1K或更多），那么速度优势就会逐渐消失。如果内部数组很小（如10-50），那么差异应该是显而易见的。

修改

正如所要求的，这是我的jmh基准：

@OutputTimeUnit(TimeUnit.SECONDS)
public class ArrayAccess
{
  static final int gapRowsize = 128, rowsize = 32, colsize = 10_000;
  static final int[][] twod = new int[colsize][],
      gap1 = new int[colsize][];
  static final int[] oned = new int[colsize*rowsize];
  static final Random r = new Random();
  static {
    for (int i = 0; i < colsize; i++) {
      twod[i] = new int[rowsize];
      gap1[i] = new int[gapRowsize];
    }
    for (int i = 0; i < rowsize*colsize; i++) oned[i] = r.nextInt();
    for (int i = 0; i < colsize; i++)
      for (int j = 0; j < rowsize; j++)
        twod[i][j] = r.nextInt();
  }

  @GenerateMicroBenchmark
  public int oned() {
    int sum = 0;
    for (int i = 0; i < rowsize*colsize; i++)
      sum += oned[i];
    return sum;
  }

  @GenerateMicroBenchmark
  public int onedIndexed() {
    int sum = 0;
    for (int i = 0; i < colsize; i++)
      for (int j = 0; j < rowsize; j++)
        sum += oned[ind(i,j)];
    return sum;
  }

  static int ind(int row, int col) { return rowsize*row+col; }

  @GenerateMicroBenchmark
  public int twod() {
    int sum = 0;
    for (int i = 0; i < colsize; i++)
      for (int j = 0; j < rowsize; j++)
        sum += twod[i][j];
    return sum;
  }

}

注意 gap 数组分配：这模拟了堆碎片的最坏情况。

我看到rowsize = 32的优势超过5倍，而1024的优势仍然非常显着（25％）。我也发现高度依赖于间隙大小的优势，显示的是128 rowsize = 32的最坏情况（较高和较低的值都会降低优势），512 rowsize = 1024的最坏情况。

rowsize = 32, gapRowsize = 128

Benchmark    Mean        Units
oned         8857.400    ops/sec
twod         1697.694    ops/sec


rowsize = 1024, gapRowsize = 512

Benchmark   Mean     Units
oned        147.192  ops/sec
twod        118.275  ops/sec

处理二维数组的首选方法是什么？

1 个答案:

修改