Skip to content
TheChatArchiveThe Chat Archive
o3-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

我现在再使用HLS开发CNN加速器,我想对两个Conv层之间做优化。现在的做法是,当一个Conv层计算结束,再开始另一个Conv层,但事实上,第二个Conv层再第一个层输出一部分…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with grok-4-0709’s answer.
  1. User

    我现在再使用HLS开发CNN加速器,我想对两个Conv层之间做优化。现在的做法是,当一个Conv层计算结束,再开始另一个Conv层,但事实上,第二个Conv层再第一个层输出一部分的时候就可以开始工作了。我该如何优化我的HLS代码呢?

  2. Assistant

    下面给你一个“思路 → 指令 → 代码骨架 → 常见坑”的四步法,帮助你把 Conv1 和 Conv2 从“串行”变成真正的“流水并行”。示例基于 Xilinx (Vivado/Vitis-HLS),但在 Intel HLS 或 Catapult 也大同小异。


    一、总体思路:把层融合成一个 Dataflow

    1. 把 Conv1 和 Conv2 写成两个独立函数,各自内部再做 pipeline。
    2. 用 hls::stream 或 ap_fifo 把两层连起来,构成生产-消费模型。
    3. 在顶层函数用 #pragma HLS DATAFLOW 让综合器把两个函数排成流水。

    这样综合器就会一边让 Conv1 写 FIFO,一边让 Conv2 读 FIFO,只要 FIFO 里有足够数据就能启动计算。


    二、关键指令/pragma

    #pragma HLS DATAFLOW                      // 顶层启用 Dataflow
    #pragma HLS STREAM   variable=stream12 depth=512  // FIFO 深度
    #pragma HLS PIPELINE II=1                // Conv 内部主循环
    #pragma HLS ARRAY_PARTITION variable=weight complete dim=2 // 权重并行
    

    • DATAFLOW:让函数级并行。
    • STREAM:把局部数组/变量综合成 FIFO。
    • PIPELINE:让单个 Conv 达到 II=1。
    • ARRAY_PARTITION:把权重/系数拆开,保证并行 MAC。


    三、代码骨架(3×3 卷积+ReLU 举例)

    #include <hls_stream.h>
    #include <ap_int.h>
    #include <ap_fixed.h>
    
    typedef ap_fixed<16,8> data_t;
    static const int H = 32, W = 32;
    static const int IC1 = 16, OC1 = 32;  // Conv1 通道数
    static const int IC2 = 32, OC2 = 64;  // Conv2 通道数
    static const int K = 3;
    
    /* ---------- Conv1 ---------- */
    void conv1(data_t in[IC1][H][W],
               hls::stream<data_t> &out_stream,
               const data_t weight[OC1][IC1][K][K])
    {
    #pragma HLS INLINE off
        /* 行缓冲实现 3×3 滑窗,可自行封装 */
        for(int oh=0; oh<H-2; ++oh){
            for(int ow=0; ow<W-2; ++ow){
        #pragma HLS PIPELINE II=1
                for(int oc=0; oc<OC1; ++oc){
                    data_t sum = 0;
                    for(int ic=0; ic<IC1; ++ic){
        #pragma HLS UNROLL
                        for(int kh=0; kh<K; ++kh)
                            for(int kw=0; kw<K; ++kw)
                                sum += in[ic][oh+kh][ow+kw] * weight[oc][ic][kh][kw];
                    }
                    /* ReLU */
                    if(sum < 0) sum = 0;
                    out_stream.write(sum);      // 写入 FIFO
                }
            }
        }
    }
    
    /* ---------- Conv2 ---------- */
    void conv2(hls::stream<data_t> &in_stream,
               data_t out[OC2][H-2][W-2],
               const data_t weight[OC2][IC2][K][K])
    {
    #pragma HLS INLINE off
    
        /* 由于 Conv1 输出已是 (H-2)*(W-2)*OC1 顺序,
           这里用简单计数器重组输入即可 */
        data_t linebuf[IC2][K-1][W-2];
    #pragma HLS ARRAY_PARTITION variable=linebuf complete dim=1
    
        for(int oh=0; oh<(H-4); ++oh){
            for(int ow=0; ow<(W-4); ++ow){
                for(int oc=0; oc<OC2; ++oc){
        #pragma HLS PIPELINE II=1
                    data_t sum = 0;
                    for(int ic=0; ic<IC2; ++ic){
        #pragma HLS UNROLL
                        /* 取窗口数据:自行实现行缓冲 + 局部 shift */
                        data_t pix[K][K];   // 伪代码
                        for(int kh=0; kh<K; ++kh)
                            for(int kw=0; kw<K; ++kw)
                                sum += pix[kh][kw] * weight[oc][ic][kh][kw];
                    }
                    out[oc][oh][ow] = sum;
                }
            }
        }
    }
    
    /* ---------- 顶层 ----------- */
    void top(data_t in[IC1][H][W],
             data_t out[OC2][H-4][W-4],
             const data_t w1[OC1][IC1][K][K],
             const data_t w2[OC2][IC2][K][K])
    {
    #pragma HLS DATAFLOW
    
        hls::stream<data_t> fifo12("fifo12");
    #pragma HLS STREAM variable=fifo12 depth=512
    
        conv1(in, fifo12, w1);
        conv2(fifo12, out, w2);
    }
    

    要点:

    1. conv1 在行、列、通道三个层次 output 顺序与 conv2 的 input 顺序一致(OC 最内层),方便直接 stream。
    2. FIFO 深度要能撑住 “Conv2 需要的首个 3 行 ready”——常见估算公式:depth >= OC1 * (K-1) * (W-2)。
    3. 如果同一层内部又做 IC/OC 分块,也依然用 stream 将子块连起来,保持单生产单消费避免死锁。

    四、常见坑 & 调参小贴士

    • 死锁/挂起:
    – 检查 FIFO depth,过小会卡住 DATAFLOW 调度。
    – 确认 conv1 写顺序 = conv2 读顺序,尤其是分块循环的层级一致。

    • II 未到 1:
    – 缺少 ARRAY_PARTITION,导致多通道 MAC 竞争单端口 BRAM。
    – 权重放 external DDR,没做 #pragma HLS RESOURCE core=ROM_1P 或双端口/BRAM 分割。

    • BRAM 爆量:
    – 行缓冲只存 K-1 行,不要把整 feature map 存下来。
    – Weight reuse:把 OC loop 放里层,把 weight partition 掉后从数组常量读取。

    • 访存带宽:
    – 如需多 batch,可用 ping-pong 双缓冲 (double buffering) + AXI burst。
    – 对 qdma/vivado_ip,记得 #pragma HLS INTERFACE m_axi depth=... port=... offset=slave.

    • 进一步加速:
    – 可以把 Conv1+ReLU+Pool 一次性 fusion;只要维度能对齐都可以继续往后并。
    – 在更大芯片上,OC 和 IC 可以 hierarchically unroll,不同级别并行映射到 DSP vs LUT.


    五、一句话总结 把层拆成函数,用 stream/FIFO 串起来,再打开 #pragma HLS DATAFLOW,最后确保每层本身 II=1 且 FIFO 足够深。这样 Conv1 一边输出、Conv2 一边就能吃数据,流水隐藏了大部分前后层等待时间,算力利用率通常能从 ~50% 升到 90%+ 🚀。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.