如何用Halide实现三级缓存架构？现有代码报错求解决方案

错误原因 #

编译错误 Reduction domain referenced in pure function definition 的核心问题是：在Halide的纯函数定义中使用了RDom（归约域）变量。

Halide的Func有两种定义方式：

• 纯定义（Pure Definition）：为每个坐标计算无副作用的值，不能引用RDom变量（RDom是用于归约更新的）。
• 更新定义（Update Definition）：通过RDom修改已有值，用于求和、最大值等归约操作。

你的代码中 l1(x1) = l2(j * l1_size + r_l1); 属于纯定义，却使用了RDom变量 r_l1，这违反了Halide的规则。另外，用C++循环反复赋值Func会添加多个更新步骤，不符合缓存分层模拟的预期逻辑。

修正方案 #

方案1：显式模拟缓存传输（修正原代码逻辑） #

以下代码修复了RDom的错误使用，并用Halide原生结构替代C++循环，明确模拟缓存层级间的数据传输：

#include "Halide.h"
using namespace Halide;

int main() {
    // 定义缓存尺寸与分块数量
    const int global_size = 256 * 256;
    const int l2_chunk_size = 16 * 256;
    const int l1_chunk_size = 4 * 256;
    const int num_l2_chunks = global_size / l2_chunk_size; // 16个L2块
    const int num_l1_chunks_per_l2 = l2_chunk_size / l1_chunk_size; // 每个L2块含4个L1块

    // 声明Halide变量
    Var x("x");               // 全局内存索引
    Var l2_idx("l2_idx");     // L2块内索引
    Var l1_idx("l1_idx");     // L1块内索引

    // L3（全局内存）源数据
    Func l3("l3");
    l3(x) = x; // 示例初始化
    l3.store_in(MemoryType::L3);

    // 各缓存层级的中间Func
    Func l2("l2"), l2_out("l2_out");
    Func l1("l1"), l1_out("l1_out");
    Func l3_out("l3_out");

    // 指定各Func的存储位置
    l2.store_in(MemoryType::L2);
    l2_out.store_in(MemoryType::L2);
    l1.store_in(MemoryType::L1);
    l1_out.store_in(MemoryType::L1);
    l3_out.store_in(MemoryType::L3);

    // 遍历所有L2块
    RDom l2_chunk_iter(0, num_l2_chunks);
    // 从L3加载L2块
    l2(l2_idx) = l3(l2_chunk_iter * l2_chunk_size + l2_idx);

    // 遍历当前L2块内的所有L1块
    RDom l1_chunk_iter(0, num_l1_chunks_per_l2);
    // 从L2加载L1块
    l1(l1_idx) = l2(l1_chunk_iter * l1_chunk_size + l1_idx);

    // 可选：添加L1层处理逻辑（示例为直接复制）
    l1_out(l1_idx) = l1(l1_idx);

    // 将L1块写回L2
    l2_out(l1_chunk_iter * l1_chunk_size + l1_idx) = l1_out(l1_idx);

    // 将更新后的L2块写回L3
    l3_out(l2_chunk_iter * l2_chunk_size + l2_idx) = l2_out(l2_idx);

    // 编译并运行
    Buffer<int> result = l3_out.realize({global_size});

    return 0;
}

方案2：Halide idiomatic方式（用调度控制缓存） #

Halide的设计初衷是通过调度指令控制内存层级映射，而非显式模拟传输。这种方式更简洁且符合Halide的最佳实践：

#include "Halide.h"
using namespace Halide;

int main() {
    const int global_size = 256 * 256;
    const int l2_chunk_size = 16 * 256;
    const int l1_chunk_size = 4 * 256;

    Var x("x");
    Func source("source");
    source(x) = x; // L3全局内存中的源数据
    source.store_in(MemoryType::L3);

    // L2层级处理逻辑
    Func l2_process("l2_process");
    l2_process(x) = source(x); // 可在此添加L2层运算

    // L1层级处理逻辑
    Func l1_process("l1_process");
    l1_process(x) = l2_process(x); // 可在此添加L1层运算

    // 调度：将计算拆分为L2块，并在L2缓存中计算
    Var l2_chunk, l2_idx;
    l2_process.split(x, l2_chunk, l2_idx, l2_chunk_size);
    l2_process.compute_at(l1_process, l2_chunk);
    l2_process.store_in(MemoryType::L2);

    // 调度：将计算拆分为L1块，并在L1缓存中计算
    Var l1_chunk, l1_idx;
    l1_process.split(x, l1_chunk, l1_idx, l1_chunk_size);
    l1_process.store_in(MemoryType::L1);

    // 运行流水线
    Buffer<int> output = l1_process.realize({global_size});

    return 0;
}

关键修复点 #

1. 移除纯函数中的RDom：用普通Var替代RDom进行块内索引，RDom仅用于归约操作或块遍历的更新步骤。
2. 替换C++循环：用Halide的RDom或调度指令实现块遍历，避免反复修改Func导致的逻辑混乱。
3. 显式声明Var：确保所有Func中使用的变量都是Halide的Var类型。

内容的提问来源于stack exchange，提问作者Cery