开源编译器工具链突破：PyTorch直通FPGA，性能超越Vitis HLS 2.21倍

关键词：PyTorch、Calyx、编译器工具链、机器学习加速器、FPGA

From PyTorch to Calyx: An Open-Source Compiler Toolchain for ML Accelerators
https://arxiv.org/pdf/2512.06177
9000 字，阅读 30 分钟，播客 6 分钟

本文提出一款端到端开源编译器工具链，可将 PyTorch 编写的机器学习（ML）模型编译为可综合的 SystemVerilog 代码，填补了现有高级综合（HLS）工具鲜有直接支持 PyTorch 等 ML 框架、且过度依赖闭源商业工具的空白。

该工具链整合加速器设计语言 Allo、硬件中间表示（IR）Calyx 及 LLVM 旗下 CIRCT 项目，构建了从软件级 ML 程序到 FPGA 可执行硬件加速器的完整编译流程。

图 1：从 PyTorch 经 Allo 到 Calyx 的编译流水线

工具链工作流程为：通过 Allo 将 PyTorch 模型转换为 MLIR，经 MLIR 方言逐步降低后，借助 CIRCT 生成 Calyx IR，最终编译为 SystemVerilog 并通过 Xilinx Vivado 部署到 FPGA。

核心优化包括：扩展结构化控制流支持、集成浮点运算库，以及针对内存并行访问的关键改进——将内存 bank 索引嵌入维度布局、重写循环嵌套避免控制逻辑冗余，有效解决了内存端口竞争和硬件资源浪费问题。

实验以 FFNN、CNN、MHA 三种代表性模型为基准，与商业工具 Xilinx Vitis HLS 对比。基线配置下 Vitis 因成熟优化略占优势，但启用内存分区后，Calyx 在高分区因子（如 4）时性能反超，最高提速达 2.21 倍，展现出强大的并行性挖掘能力。尽管 Calyx 在 LUT 等资源消耗上更高，但 该工具链以开源、可定制为核心优势，为硬件加速器的研究与原型开发提供了灵活平台。未来将进一步优化硬件流水线、资源共享及反向传播编译等功能。

本文目录

关键问题
- 问题一：LUT 资源高开销的根源、性能增益抵消风险及优化潜力
- 问题二：CNN 基线性能落后的本质原因及内存模型的优化路径
一、引言
二、背景
- 2.1 Allo
- 2.2 Calyx
- 2.3 CIRCT
三、贡献
- 3.1 概述
- 3.2 下转换至 Calyx
- 3.3 内存与并行性优化
四、结果与评估
- 4.1 基准测试模型（Benchmark Models）
- 4.2 模型间对比
- 4.3 前馈神经网络的内存分区
五、结论
参考文献

关键问题

问题一：LUT 资源高开销的根源、性能增益抵消风险及优化潜力

文中 Calyx 方案的 LUT 资源消耗最高达 Vitis HLS 的数倍（如 FFNN 分区因子 4 时 Calyx LUT 为 49121 vs Vitis 的 13799），这种显著的资源开销是否源于 Calyx IR 显式控制建模的固有设计？ 在 FPGA 资源受限的实际部署场景中，该问题是否会抵消其内存分区带来的性能增益，且后续优化（如硬件流水线、资源共享）能否有效缩小这一资源差距？

表 1：各模型的资源占用情况

表 2：前馈神经网络（FFNN）模型在不同分区因子下的资源占用情况

资源高开销的核心原因：根据作者实验结果（表 1 和 2），Calyx 的 LUT 消耗显著高于 Vitis HLS（如 FFNN 分区因子 4 时，Calyx LUT 为 49121 vs Vitis 的 13799），这确实源于 Calyx IR 的固有设计特性—— 其显式分离控制流与结构硬件描述，需通过显式有限状态机（FSM）实现控制逻辑，且内存分区时的 bank 索引管理会引入额外控制电路，导致控制开销冗余。此外，论文提及 Calyx 缺乏商业工具的激进调度优化，进一步放大了 LUT 资源消耗。

性能增益抵消风险：在 FPGA 资源受限场景中，该问题是否抵消性能增益需分场景判断。
* 对于内存密集型 ML workload（如 FFNN），当分区因子 ≥4 时，Calyx 通过内存并行访问实现的 2.21 倍提速，其性能收益超过 LUT 资源增加的成本；
* 但对于资源极度紧张或对面积敏感的场景（如边缘端小型 FPGA），过高的 LUT 开销可能限制部署可行性，部分抵消并行化带来的性能优势。

后续优化的改善空间：作者明确将硬件流水线、资源共享列为未来工作，这类优化具备缩小资源差距的潜力。资源共享可减少重复控制逻辑的实例化，硬件流水线能提升资源利用率，二者有望缓解显式 FSM 带来的 LUT 冗余；但需注意，Calyx IR 的显式控制建模本质不会改变，因此资源开销可能无法完全与 Vitis HLS 持平，仅能实现“有效缩小差距”。

问题二：CNN 基线性能落后的本质原因及内存模型的优化路径

针对 CNN 模型，Calyx 基线性能大幅落后于 Vitis HLS，核心归因于单维内存对多维张量的扁平化处理及深层循环嵌套的开销。这一缺陷是 Calyx IR 的架构性局限，还是仅为当前实现的阶段性问题？ 开源方案若要在复杂 ML 模型（如深层 CNN、多模块 Transformer）中全面比肩商业工具，是否需要重构内存模型，而非仅依赖后续优化手段？

性能落后的核心症结：CNN 基线性能大幅落后于 Vitis HLS，并非 Calyx IR 的架构性局限，而是当前实现的阶段性问题。作者指出核心原因是：
* Calyx 仅支持单维内存，需将 CNN 的多维张量扁平化处理，导致内存访问索引需通过乘法、模运算等复杂硬件操作实现，引入额外 latency；
* 同时 CNN 的卷积、池化层天然形成深层循环嵌套，进一步放大了索引计算的开销。

这些问题源于当前内存模型的设计限制，而非 Calyx IR 的架构不可扩展性。

从内存模型的优化方向来说，开源方案要在复杂 ML 模型中比肩商业工具，无需重构 Calyx IR 的核心架构，而是需改进内存模型设计 。作者已通过“将 bank 索引嵌入内存维度布局”的优化，在 FFNN 中验证了内存模型调整的有效性；针对 CNN，可进一步扩展多维内存支持，避免张量扁平化带来的索引开销，或优化深层循环嵌套的调度策略，减少控制逻辑冗余。这些改进属于对现有内存模型的增强，而非架构级重构，与 Calyx IR 的控制-结构分离核心设计兼容。

一、引言

高级综合（High-Level Synthesis, HLS）是为机器学习（ML）应用设计加速器的一种极具潜力的方法[3,7,9,11]。通过 HLS，我们能够将软件中的高层级功能描述（通常由 C 或 C++编写）编译为适用于硬件实现的可综合寄存器传输级（RTL）代码。

然而，目前很少有 HLS 方法能够直接从表达 ML 模型的语言和框架（如 PyTorch）进行编译 。此外，以往的研究工作在很大程度上依赖于闭源的商业 HLS 工具链，例如赛灵思（Xilinx）的 Vitis HLS。近年来，基于 MLIR 的 HLS 系统展现出了构建开源加速器设计编译栈的潜力[12]。

构建此类系统面临诸多挑战。ML 模型通常使用 Python 编写，并且严重依赖浮点运算、复杂的张量运算以及多模块执行模式，而这些元素均无法直接映射到低层级的硬件描述中。 要支持这些工作负载，需要一种编译流程，能够将高层级张量程序转换为面向硬件的中间表示 （IR）， 同时保留足够的结构以支持并行执行和激进的内存优化。 然而，传统 HLS 方法存在局限性，因为高层级软件编程语言并不适合直接转换为硬件语义。此外，现代 ML 加速器必须利用细粒度并行性，但并行执行会引入诸如存储端口竞争 等风险，这需要细致的程序分析来解决。

因此，我们提出了一种端到端的开源编译器工具链，该工具链通过结构化编译流程，能够从 PyTorch 模型生成可综合的 SystemVerilog 代码。

我们的系统利用 Allo[1]将 PyTorch 程序转换为 MLIR，借助领域特定的 MLIR 方言[10]保留高层级张量结构，并依赖 CIRCT[2,6]基础设施进行硬件下转换。最终生成的程序以 Calyx 语言表示，其对控制流与硬件结构的显式分离，使我们能够清晰地编码加速器架构和优化策略。

最后，我们将 Calyx 代码编译为 SystemVerilog，并使用标准的 FPGA 厂商工具（如赛灵思 Vivado）进行综合、布局布线以及加速器部署。我们的贡献如下：

一套端到端的开源编译栈，基于 Allo、CIRCT 和 Calyx，能够从 PyTorch 生成可综合的 SystemVerilog。
在 Calyx 中实现存储分块和分割分析，支持安全且高效的并行访问模式。
FPGA 评估结果显示，相较于 Vitis HLS，性能提升最高可达 2.21 倍。

二、背景

2.1 Allo

Allo[1]是一款用于构建大规模、高性能硬件加速器的编译器。

其下转换流水线能够将 PyTorch 程序转换为 MLIR ，同时保留张量语义、控制流和数据布局信息。生成的结构化 MLIR 程序能够与下游方言和编译器基础设施无缝集成，从而在高层级 ML 框架与硬件生成后端之间搭建起一座桥梁。

2.2 Calyx

Calyx[8]是一种中间表示（IR）和编译器基础设施，旨在从高层级编程语言生成硬件加速器。

它将控制流与结构化硬件描述进行显式分离 ，从而支持同时利用这两种视角进行优化。随后，Calyx 编译器通过一系列转换和优化过程，将程序下转换为可综合的寄存器传输级（RTL）代码。

2.3 CIRCT

CIRCT（Circuit IR Compilers and Tools）[6]是一个基于 LLVM 的开源基础设施，用于构建硬件编译器。

它建立在 MLIR[5]之上，提供了一套硬件特定方言和转换过程 ，以支持定制化编译流程、硬件综合流水线和中间表示的开发。

Calyx 作为 CIRCT 的一种方言被集成其中，这一集成具有重要价值：CIRCT 提供了一条从 MLIR 原生下转换到面向硬件方言的路径，而 Calyx 则是该下转换过程的自然终点—— 因为它同时保留了结构化硬件描述和类软件的控制流 ，为我们在生成 RTL 代码之前提供了一个统一的空间，用于表达针对加速器的重写优化。

三、贡献

3.1 概述

本研究的目标是在定制化硬件加速器上运行 PyTorch 程序。我们将 FPGA 作为原型平台，并开发了一套完全开源的编译流水线，能够将高层级 Python 程序转换为可综合的硬件设计。

我们的工具链由多个开源组件构成。

首先，我们使用 Allo 框架[1]将 PyTorch 模型编译为 MLIR 程序。
然后，通过原生 MLIR 过程将这些 MLIR 程序逐步下转换为 CIRCT 支持的方言。在此阶段，我们还会应用高层级优化，以提升性能和硬件兼容性。

当程序转换为与 Calyx 兼容的形式后，我们生成 Calyx IR 代码。随后，Calyx 编译器执行硬件特定的转换 ，并生成可综合的 SystemVerilog。最终，该硬件设计被部署到 FPGA 上，从而完成从软件到硬件的编译流程。

3.2 下转换至 Calyx

图 1 展示了我们开发并编排的、用于将 PyTorch 下转换至 Calyx 的编译流程。

图 1：从 PyTorch 经 Allo 到 Calyx 的编译流水线

我们利用 Allo 将 PyTorch 下转换为 MLIR 的 Linalg 方言。
随后依次下转换为 MLIR 的 Affine 方言、Memref 方言以及 SCF 方言。
之后，我们借助 CIRCT 生成 Calyx 代码 ，并通过 Vivado HLS 在 FPGA 上执行该设计。

在文献[10]的基础上，我们扩展了相关工作：

支持更多 SCF 操作（包括 if 条件判断和 parallel 并行操作）；
实现了将软件级函数转换为 Calyx 组件的功能——每个函数对应一个硬件模块（该模块包含用于标量参数的端口和用于张量参数的实例化内存），而函数调用则对应组件实例化。

我们还为 Calyx 开发了一套完整的通用浮点库，以在 CIRCT 中提供浮点支持 ，其中包括对 伯克利硬件浮点库 （Berkeley HardFloat[4]）组件的集成。

此外，我们还实现了位级别的 IEEE-754 标准常量处理和人类可读的属性表示，以提升 CIRCT 中的代码可读性和可调试性。

这些贡献共同构成了我们编译栈的基础，使高层级 MLIR 程序能够下转换为 Calyx IR，并最终综合为 RTL 代码。

3.3 内存与并行性优化

为了优化模型的前向传播，我们利用并行性来提高硬件吞吐量。Calyx 将并行执行作为一等控制结构，使我们能够显式地建模并发计算。因此，我们的核心任务是：在遵循硬件约束的前提下，挖掘并最大化并行性（尤其是在内存访问模式中）。

我们的方法基于数据并行：将内存分割为多个存储块（bank），使不同操作能够并发访问数据。由于 Calyx 假设每个内存在每个周期内仅支持一次读或写操作，因此存储分块能够通过复制存储单元并将访问请求路由到不同存储块的方式，实现并行访问。

我们的数据并行策略必须避免存储块冲突：存储分块会增加端口数量，并引入用于选择访问目标存储块的控制逻辑，这通常会产生嵌套条件判断。若不进行优化，这些额外的控制路径会增加延迟和资源占用。

我们的实现支持循环内存分割，并在整个研究中均采用该策略。为了将访问请求路由到正确的存储块，使用 switch 语句；在 switch 语句不可用的情况下，则使用嵌套 if-else 链。

直接为每个存储块生成控制分支的朴素实现会导致代码体积膨胀：对于一个具有 d 个维度、分割因子为 c 的内存，其独立控制分支的数量会以的规模增长（其中 c 为分割因子，d 为内存维度数）。

在 Calyx 中，即使这些分支在运行时仅有一个处于活跃状态，所有分支都会被实例化为硬件。这不仅会增加面积占用，还会导致控制有限状态机（FSM）的深度增加，进而损害性能。

为具体说明这一问题，我们考虑以下简单循环：向一个包含 4 个元素的内存写入数据，存储分块因子为 2：

    for (int i = 0; i < 4; ++i) {  
        if (i % 2 == 0) {  
            mem_bank_0[i / 2] = i;  
        } else {  
            mem_bank_1[i / 2] = i;  
        }  
    }

为了并行化该循环，我们将其以因子 2 进行实例化，并使用嵌套的 seq（顺序）和 par（并行）结构：

    seq for (int i = 0; i < 2; ++i) {  
        par for (int j = 0; j < 2; ++j) {  
            int new_index = 2 * i + j;  
            if (new_index % 2 == 0) {  
                mem_bank_0[new_index / 2] = new_index;  
            } else {  
                mem_bank_1[new_index / 2] = new_index;  
            }  
        }  
    }

然而，每个 par 块必须被展开为具有静态已知索引的独立分支。在我们的示例中，这会生成两个并行分支——j=0 和 j=1——每个分支计算一个不同的 new_index。尽管在运行时每个分支仅会激活存储块条件判断中的一侧，但由于无法对谓词进行符号折叠，Calyx 仍会实例化 if-else 语句的两侧。

结果就是，即使是无冲突的访问模式，也可能导致多个分支向同一个物理存储块写入数据，从而产生 Calyx 无法静态消除的写冲突。

我们实现了两种技术，以确保内存并行访问的安全性和高效性：

通过将存储块索引嵌入内存的维度布局中（而非使用条件逻辑保护访问）来实现存储分块；
重写循环嵌套——若不重写，这些循环嵌套在并行执行时会导致顺序控制器重复。

对于第一种技术，我们不再为每次访问生成分支逻辑，而是增加内存的维度，并将存储块索引嵌入到第一个维度中。例如：

    seq for (int i = 0; i < 2; ++i) {  
        par for (int k = 0; k < 2; ++k) {  
            mem[k][i] = 2 * i + k;  
        }  
    }

展开该循环后得到：

    seq for (int i = 0; i < 2; ++i) {  
        parallel execution {  
            execute par-arm-0 {  
                mem [0][i] = 2 * i + 0;  
            }  
            execute par-arm-1 {  
                mem [1][i] = 2 * i + 1;  
            }  
        }  
    }

在此示例中，每个并行分支中的存储块索引都是编译时常量，这确保了内存访问是无重叠的且无竞争的。这种方法能够在保留并行性的同时，避免产生不必要的控制开销。

第二种转换针对循环结构层面。该示例还揭示了一个更普遍的问题：在软件中语义等价的循环转换，在硬件中未必会产生等价的结果。考虑两种嵌套方式：

一种是 seq(i) 包含 par(j)
另一种是 par(j) 包含 seq(i)

尽管在软件中，这两种方式在语义上等价，但在硬件中的行为却截然不同。

在第一种方式中，存在一个单独的顺序控制器迭代 i，每次迭代都会触发一个 j 维度的并行组；
而在第二种方式中，每个并行分支都会获得一个用于迭代 i 的私有顺序控制器，这实际上会复制整个有限状态机（FSM）。这种复制会导致硬件面积膨胀，并增加控制开销。为防止此类不必要的复制，我们的编译器会检测这些模式，并将并行-顺序循环嵌套重写为共享控制逻辑的调度方式，同时保留预期的并行性。

通过这些感知内存和循环的转换，我们的编译器生成的并行 Calyx 程序既正确又高效，能够适用于硬件执行。

四、结果与评估

在本节中，我们将基于 Calyx 的流程与 Vitis HLS 在两种配置下进行评估对比。

4.2 节将对比无数据并行的基准设计：两种工具链均不采用任何分块策略。
4.3 节将为两种流程均启用内存分块，并采用匹配的分区因子、分区方案和分区维度，从而实现对并行化配置的直接对比。

在呈现结果之前，需说明：Vitis HLS 集成了许多成熟且通常为隐式的优化，这些优化目前尚未在我们基于 Calyx 的流程中实现，且无法通过编译指示禁用或查看。

因此，我们并未期望 Calyx 在基准延迟或资源占用上优于 Vitis。相反，我们的目标是评估 Calyx 的竞争力，以及我们针对性的分块转换是否能有效缩小性能差距。

如下文所示，尽管 Vitis 在基准配置下仍保持优势，但一旦启用分块，Calyx 便具备了竞争力——它为后续优化提供了一个开源且可由编译器控制的基础框架。

4.1 基准测试模型

我们通过对三个代表性机器学习模型的性能与资源占用进行基准测试，并将其与商业高级综合工具链 Xilinx Vitis HLS 对比，以此评估我们编译器的性能。这三个模型分别是前馈神经网络、卷积神经网络和多头注意力模块。

FFNN 模型：输入为 64 个特征，后续接一个尺寸为 64×48 的全连接层、一个 ReLU 激活函数，以及一个尺寸为 48×4 的全连接层。
CNN 模型：处理 3 通道、尺寸为 80×60 的彩色图像。第一层执行二维卷积（使用 5×5 卷积核、3 个输入通道、8 个输出通道，步长为 1），后续接 ReLU 激活函数和一个窗口尺寸为 2×3 的最大池化层。最终得到的特征图被展平后，输入全连接层以完成二分类任务。
MHA 模型：基于 Transformer 架构，使用 2 个注意力头。每个注意力头在 42 维嵌入向量的 21 维子空间上运行，并采用因果掩码以支持自回归解码。

4.2 模型间对比

为进行对比，我们采用了 Vitis HLS。Allo 项目提供了一个共享前端，可将 PyTorch 模型下转为 MLIR；随后，MLIR 会进一步编译为两种目标形式：一是供 Vitis 使用的 HLS C++代码，二是供我们流程使用的 Calyx 代码。为确保公平性，两种编译路径的 MLIR 输入保持一致。除 #pragma ARRAY_PARTITION 外，所有 HLS 编译指示均被禁用——该编译指示用于与我们的内存分块配置进行对比。我们确保两种流程采用一致的分块因子、分块方案和分块维度。

实际延迟的计算方式如下：首先获取每个设计的周期数，再获取其满足时序约束的布局布线后最大频率，最终结合两者计算实际延迟。

图2：不同模型的挂钟延迟对比

图 2 展示了两种工具链下各模型的实际延迟。Vitis 在所有情况下都优于我们基于 Calyx 的流程，在 CNN 模型上的优势尤为明显。

这一性能差距主要源于 Calyx 内存模型的局限性：

Calyx 仅支持一维内存，因此我们必须将多维张量展平存储。这导致 内存访问索引在硬件中需通过乘法、取模等耗时算术运算实现，进而引入额外延迟。
此外，CNN 模型的卷积层和池化层天然会形成更深层次的循环嵌套，进一步放大了这一延迟开销。

表 1：各模型的资源占用情况

表 1 报告了相同模型的资源占用情况。我们观察到：

Vitis 使用更多块 RAM 来存储权重和偏置；
而 Calyx 由于使用显式有限状态机进行控制，消耗了显著更多的查找表和触发器。

总体而言，Calyx 的资源占用更高，这源于其冗余的控制建模和缺乏激进的调度策略。

4.3 前馈神经网络的内存分区

为进一步理解内存分块的影响，我们以 FFNN 模型为研究对象。

在本研究中，每个内存均沿其各维度进行循环分区。

在 Vitis 中，这一操作通过 #pragma ARRAY_PARTITION 编译指示实现；
而在 Calyx 中，分区通过我们实现的编译器遍完成。我们对比了不同分区因子下的延迟与资源占用情况。

图3：前馈神经网络的延迟与分区因子对比

图 3 展示了不同分区因子下的延迟。

当分区因子为 1（无分区）和 2 时，Vitis 表现更优；
但当分区因子为 4 时，Calyx 的速度超过了 Vitis。

此外，Vitis 的相对加速比较为平缓：将分区因子从 2 提升至 4 时，加速比仅为 7908/6813≈1.16。考虑到所有矩阵均为二维，理想条件下的理论最大加速比为 2^2=4， 而 Vitis 有限的性能提升表明其仍存在其他瓶颈。

相比之下，基于 Calyx 的流程在更高分区因子下表现出显著提升：

分区因子从 1 提升至 2 时，加速比为 22475/9378≈2.40；
从 2 提升至 4 时，加速比为 9378/3078≈3.05。

这一结果证明了我们内存分块分析与转换遍的有效性——它使 Calyx 能够在内存层面释放更多并行性。

表 2：前馈神经网络模型在不同分区因子下的资源占用情况

表 2 报告了上述实验对应的资源占用情况。两种工具链的数字信号处理器使用率相当：

Vitis 的块 RAM 和触发器使用量略多；
而 Calyx 的查找表使用量显著更高，这源于管理多个内存块所需的额外控制逻辑。

这些结果体现了细粒度内存分区带来的性能与硬件复杂度之间的权衡——提升性能需以增加硬件资源占用为代价。

五、结论

本文提出了一个完整的开源编译工具链，该工具链利用 Allo、MLIR、CIRCT 和 Calyx，将 PyTorch 程序转换为可综合的硬件设计。

我们通过实现对结构化控制流、函数建模、浮点算术和内存布局转换的支持，填补了软件级机器学习程序与 FPGA 可执行硬件加速器之间的鸿沟。

本文重点关注通过静态内存分块（在编译时确定内存分块方式，而非运行时动态调整）以及控制逻辑重构来优化内存访问的并发性。

硬件流水线、资源共享（多个操作复用同一硬件资源）以及反向传播过程的编译优化，将作为未来的研究方向。

在代表性机器学习模型上的评估结果表明：尽管基于 Calyx 的流程在通用调度和资源利用效率上仍落后于 Vitis 等商业工具，但在采用激进的内存分区策略（例如使用较大的分区因子以最大化并行访问）时，它展现出了可观的性能提升。

这些结果凸显了 Calyx 作为硬件加速器编译研究与原型开发平台的潜力，尤其是在优先考虑开源性和高度可定制化（允许用户深度修改和扩展工具链）的应用场景中。

参考文献

关注“鲸栖”小程序，掌握最新AI资讯

本文由鲸栖原创发布，未经许可，请勿转载。转载请注明出处：http://www.itsolotime.com/archives/13888