咨询：GCC无法优化自定义ND数组重复纯坐标转换调用的解决办法

问题背景 #

我们在基于有限差分法的麦克斯韦方程数值求解器中，基于Kokkos::View实现了自定义ND数组包装器ArrayIJKN：通过Grid::global_coords_to_tile完成全局坐标到tile坐标的转换，并重载()运算符提供隐式坐标转换的数组访问语法。

测试数据显示：

• 显式转换坐标的计算核：GCC 12.3.1下可达80GB/s，LLVM/clang 18.0下超100GB/s；
• 隐式访问的计算核：GCC下性能仅为40GB/s，原因是GCC无法消除重复的global_coords_to_tile调用——即使该函数及重载运算符标记了__attribute__((always_inline, pure))；
• clang可通过ASSUME宏提示数组共享同一Grid对象，将隐式核性能优化至与显式核相当，但GCC 12不支持该宏，GCC 13支持但难以在多数系统部署。

以下是针对三个需求的具体解决方案：

1. 更高效的隐式数组访问实现方式 #

预计算tile坐标上下文 #

在计算核入口或循环内部，一次性计算当前全局坐标对应的tile偏移量并缓存，后续数组访问直接复用该偏移：

// 核函数内循环块
for (int i = ...; i < ...; ++i) {
  for (int j = ...; j < ...; ++j) {
    for (int k = ...; k < ...; ++k) {
      // 一次性计算tile坐标，缓存到局部变量
      const auto [ti, tj, tk] = grid.global_coords_to_tile(i, j, k);
      // 直接用缓存的tile坐标访问数组，避免重复转换
      auto val = array.view(ti, tj, tk, n);
      array.view(ti, tj, tk, n) = val + update;
    }
  }
}

可进一步封装为代理类，保留隐式访问的语法简洁性：

class TileContext {
private:
  int ti_, tj_, tk_;
public:
  TileContext(int ti, int tj, int tk) : ti_(ti), tj_(tj), tk_(tk) {}
  
  template<typename ArrayType>
  auto operator()(ArrayType& arr, int n) const {
    return arr.view(ti_, tj_, tk_, n);
  }
};

// 使用方式
TileContext ctx(grid.global_coords_to_tile(i,j,k));
auto val = ctx(array, 0);
ctx(array, 0) = val + update;

将Grid绑定为Array的模板参数 #

若所有数组共享同一Grid实例，可将Grid的引用或编译期常量参数作为ArrayIJKN的模板参数，让编译器明确知晓转换函数的输入固定，便于优化：

template<typename GridRef>
class ArrayIJKN {
private:
  GridRef grid_;
  Kokkos::View<...> view_;
public:
  ArrayIJKN(GridRef grid, Kokkos::View<...> view) : grid_(grid), view_(view) {}
  
  auto operator()(int i, int j, int k, int n) __attribute__((always_inline, const)) {
    const auto [ti, tj, tk] = grid_.global_coords_to_tile(i,j,k);
    return view_(ti, tj, tk, n);
  }
};

模板参数绑定的Grid会让编译器更容易推断转换结果的一致性，消除重复调用。

2. GCC下消除重复调用的兼容方案 #

手动内联转换逻辑+const属性强化 #

将global_coords_to_tile的实现直接内联到operator()中，并用__attribute__((const))替代pure（const属性更严格，明确函数返回值仅依赖输入参数，无任何副作用），帮助GCC识别可缓存结果：

class ArrayIJKN {
private:
  const Grid& grid_;
  Kokkos::View<...> view_;
public:
  // 重载()运算符，手动内联转换逻辑
  auto operator()(int i, int j, int k, int n) __attribute__((always_inline, const)) {
    // 直接写global_coords_to_tile的实现，避免函数调用开销
    const int ti = i / grid_.tile_size_x;
    const int tj = j / grid_.tile_size_y;
    const int tk = k / grid_.tile_size_z;
    return view_(ti, tj, tk, n);
  }
};

使用GCC扩展__builtin_assume提示Grid一致性 #

GCC 12支持__builtin_assume扩展，可在核函数开头提示编译器多个数组共享同一Grid实例，帮助编译器消除重复转换：

// 核函数入口
__builtin_assume(&array1.grid_ == &array2.grid_);
__builtin_assume(&array1.grid_ == &array3.grid_);

// 后续隐式访问数组时，GCC会推断转换结果一致，消除重复调用

局部变量缓存转换结果 #

在循环内对同一(i,j,k)的转换结果进行缓存，所有数组访问复用该值——本质是显式转换，但可通过宏包装简化写法：

#define TILE_COORDS(i,j,k) \
  const auto [ti, tj, tk] = grid.global_coords_to_tile(i,j,k);

// 循环内使用
TILE_COORDS(i,j,k);
auto val1 = array1.view(ti, tj, tk, 0);
auto val2 = array2.view(ti, tj, tk, 1);
array3.view(ti, tj, tk, 0) = val1 + val2;

3. 无性能损失的等效语法糖实现方式 #

宏封装显式转换 #

用宏包装显式转换逻辑，写法接近隐式访问，同时确保编译器完全优化：

#define AT(arr, i,j,k,n) \
  ([&](){ \
    const auto [ti,tj,tk] = grid.global_coords_to_tile(i,j,k); \
    return arr.view(ti,tj,tk,n); \
  }())

// 使用方式
auto val = AT(array1, i,j,k,0);
AT(array1, i,j,k,0) = val + update;

lambda表达式会被编译器完全内联，无额外开销，且确保每个(i,j,k)仅计算一次转换。

编译期固定tile大小的模板数组 #

若Grid的tile大小是编译期常量，可将其作为模板参数传入ArrayIJKN，让转换计算在编译期完成，彻底消除运行时转换开销：

template<int TileSizeX, int TileSizeY, int TileSizeZ>
class ArrayIJKN {
private:
  Kokkos::View<...> view_;
public:
  explicit ArrayIJKN(Kokkos::View<...> view) : view_(view) {}
  
  auto operator()(int i, int j, int k, int n) const {
    // 编译期确定的转换逻辑，无运行时开销
    const int ti = i / TileSizeX;
    const int tj = j / TileSizeY;
    const int tk = k / TileSizeZ;
    return view_(ti, tj, tk, n);
  }
};

此时隐式访问的性能与显式转换完全一致，且语法简洁。

内容的提问来源于stack exchange，提问作者比尔盖子