int w_size_grid = 1000;
int h_size_grid = 1000;
int* matrix = new int[w_size_grid * h_size_grid];

你可以注意到我使用了一个向量，但原理是一样的。

为了访问网格中的一个元素，我们需要一个函数，给定网格中的一个单元格，由(x,y)标识，它返回存储在该单元格中的值。

数学:f(x,y) -> Z很明显:f: Z^2 -> Z，其中Z为整数集。

int get_value(int x, int y) {
  return matrix[y*w_size_grid + x];
}

附加实现说明

实际上设计概念需要一种"圆形连续网格": 单元的访问索引可以超出网格本身的限制。

这意味着，例如，特殊情况:get_value(-1, -1);仍然有效。该函数将返回与get_value(w_size_grid - 1, h_size_grid -1);相同的值。

实际上这在实现中没有问题:

int get_value(int x, int y) {
  adjust_xy(&x, &y);  // modify x and y in accordance with that rule.
  return matrix[y*w_size_grid + x];
}

无论如何，这只是为了使场景更清楚而附加的注释。

问题是什么?

上面的问题很简单，很容易设计和实现。

我的问题来自于矩阵以高频率更新的事实。读取矩阵中的每个单元格，并可能使用新值更新。

显然，矩阵的解析是通过两个循环完成的，根据缓存友设计:

for (int y = 0; y < h_size_grid; ++y) {
  for (int x = 0; x < w_size_grid; ++x) {
    int value = get_value(x, y);
  }
}

内循环是x，因为[x-1] [x] [x+1]是连续存储的。事实上，这个循环利用了局部性原则。

现在问题来了，因为实际上为了更新单元格中的值，它依赖于相邻单元格中的值。

每个单元格恰好有八个相邻单元格，它们是水平、垂直或对角线相邻的单元格。

(-1,-1) | (0,-1) | (1,-1)
-------------------------
(-1,0)  | (0,0)  | (0, 1)
-------------------------
(-1,1)  | (0,1)  | (1,1)

所以代码是直观的:

for (int y = 0; y < h_size_grid; ++y) {
  for (int x = 0; x < w_size_grid; ++x) {
    int value = get_value(x, y);
    auto values = get_value_all_neighbours(x, y);  // values are 8 integer
  }
}

函数get_value_all_neighbours(x,y)将相对于y访问矩阵上一行和下一行。由于矩阵中的一行相当大，它涉及缓存丢失，并且它会弄脏缓存本身。

我终于向你展示了这个场景和问题，我的问题是如何"解决"这个问题。

使用一些额外的数据结构，或者重新组织数据是否有办法利用缓存并避免所有这些遗漏?

一些个人考虑

我的感觉引导我走向战略数据结构。

我考虑过重新实现将值存储在向量中的顺序，试图将相邻的那些单元存储在连续的索引中。

这意味着get_value有一个no-more-linear函数。经过思考，我认为不可能找到这个非线性函数。

我还考虑了一些额外的数据结构，如哈希表来存储每个单元的相邻值，但我认为这在空间和CPU周期中也是一个过度杀伤。