Intel Hyperflex 体系结构高性能设计手册 · 2021. 2. 18. · Intel® Hyperflex ™...

Intel® Hyperflex™ 体系结构高性能设计手册

针对 Intel® Quartus® Prime设计套件的更新：20.1

本翻译版本仅供参考，如果本翻译版本与其英文版本存在差异，则以英文版本为准。某些翻译版本尚未更新对应到最新的英文版本，请参考英文版本以获取最新信息。

订阅

反馈

S10HPHB | 2020.07.13

官网最新文档：PDF | HTML

https://www.intel.com/content/www/us/en/programmable/documentation/jbr1444752564689.html

https://www.intel.com/content/www/us/en/programmable/bin/rssdoc?name=jbr1444752564689

mailto:[email protected]?subject=%20Intel%20Hyperflex%20%E4%BD%93%E7%B3%BB%E7%BB%93%E6%9E%84%E9%AB%98%E6%80%A7%E8%83%BD%E8%AE%BE%E8%AE%A1%E6%89%8B%E5%86%8C%20(S10HPHB%202020.07.13)%20%E7%9A%84%E5%8F%8D%E9%A6%88&body=%E9%9D%9E%E5%B8%B8%E6%84%9F%E8%B0%A2%E6%82%A8%E7%9A%84%E5%8F%8D%E9%A6%88%E3%80%82%E8%AF%B7%E5%9C%A8%E8%AF%84%E8%AE%BA%E4%B8%AD%E6%8C%87%E6%98%8E%E7%9B%B8%E5%85%B3%E7%9A%84%E9%A1%B5%E7%A0%81%E5%92%8C%E6%AE%B5%E8%90%BD%EF%BC%8C%E8%B0%A2%E8%B0%A2%E3%80%82

https://www.intel.cn/content/dam/altera-www/global/zh_CN/pdfs/literature/hb/stratix-10/s10_hp_hb-ch.pdf

https://www.intel.cn/content/www/cn/zh/programmable/documentation/jbr1444752564689.html

内容

1. Intel® Hyperflex™ FPGA体系结构介绍................................................................................ 41.1. Intel Hyperflex 体系结构设计概念 ............................................................................. 5

2. Intel Hyperflex 体系结构 RTL设计指南................................................................................ 62.1. 高速设计方法.......................................................................................................... 6

2.1.1. 设置一个高速目标.........................................................................................62.1.2. 实验和迭代.................................................................................................72.1.3. 独立地编译组件........................................................................................... 82.1.4. 优化子模块.................................................................................................82.1.5. 避免广播信号.............................................................................................. 8

2.2. Hyper-Retiming (帮助寄存器移动).............................................................................102.2.1. 复位策略.................................................................................................. 112.2.2. 时钟使能策略............................................................................................ 142.2.3. 综合期间保留寄存器.................................................................................... 152.2.4. 时序约束考量............................................................................................ 162.2.5. 时钟同步策略............................................................................................ 172.2.6. 亚稳态同步器(Metastability Synchronizers).................................................... 202.2.7. 初始上电条件............................................................................................ 212.2.8. 通过 RAM和 DSP的重定时........................................................................... 26

2.3. Hyper-Pipelining (添加流水线寄存器).........................................................................272.3.1. 传统对超级流水线(Conventional versus Hyper-Pipelining)................................. 272.3.2. 流水线和延迟............................................................................................ 282.3.3. 使用寄存器代替多周期异常............................................................................ 35

2.4. Hyper-Optimization (优化 RTL)............................................................................... 362.4.1. 一般优化技术............................................................................................ 362.4.2. 优化特定的设计结构.................................................................................... 46

3. 编译 Intel Hyperflex 体系结构设计......................................................................................693.1. 独立编译子模块......................................................................................................713.2. 使用 Design Assistant进行设计规则检查..................................................................... 73

3.2.1. 编译期间运行 Design Assistant.....................................................................733.2.2. 在分析模式下运行 Design Assistant............................................................... 753.2.3. Hyper-Retimer Readiness规则....................................................................81

4. 设计实例演练(Design Example Walk-Through)..................................................................834.1. 中值滤波器设计实例................................................................................................ 83

4.1.1. 步骤 1：编译基本设计..................................................................................844.1.2. 步骤 2：添加流水线级和移除异步复位...............................................................864.1.3. 步骤 3：添加更多的流水线级和移除全部异步复位.................................................884.1.4. 步骤 4：优化短路径和长路径条件.................................................................... 89

5. 重定时限制和解决方法......................................................................................................... 925.1. 设置 dont_merge综合属性...................................................................................... 935.2. 解读关键链报告(Interpreting Critical Chain Reports)....................................................94

5.2.1. 不足的寄存器(insufficient Registers)............................................................. 94

内容

Intel® Hyperflex™ 体系结构高性能设计手册反馈

2


5.2.2. 短路径/长路径(short path/long path)............................................................ 985.2.3. 快进限制(Fast Forward Limit).................................................................... 1015.2.4. 回路(loop)............................................................................................. 1025.2.5. 每个时钟域一个关键链................................................................................1055.2.6. 相关时钟组中的关键链................................................................................1065.2.7. 复杂的关键链...........................................................................................1065.2.8. 延伸到可定位的节点.................................................................................. 1075.2.9. 域边界入口和域边界出口(Domain Boundary Entry and Domain Boundary Exit)... 1075.2.10. 包括双时钟存储器的关键链........................................................................ 1095.2.11. 关键链比特和总线................................................................................... 1095.2.12. 延迟线................................................................................................. 110

6. 优化实例........................................................................................................................ 1116.1. 循环排程器(Round Robin Scheduler).......................................................................111

7. Intel Hyperflex 体系结构移植指南....................................................................................1177.1. 设计移植和性能探索.............................................................................................. 117

7.1.1. Black-boxing Verilog HDL模块.................................................................. 1187.1.2. Black-boxing VHDL模块...........................................................................1187.1.3. 时钟管理................................................................................................ 1207.1.4. 管脚分配................................................................................................ 1207.1.5. 收发器控制逻辑........................................................................................ 1217.1.6. 升级过时的 IP内核....................................................................................122

7.2. 顶层设计考量.......................................................................................................122

8. 附录..............................................................................................................................1238.1. 附录 A：可参数化的流水线模块.................................................................................1248.2. 附录 B：时钟使能和复位......................................................................................... 126

8.2.1. 同步复位和限制........................................................................................ 1268.2.2. 通过时钟使能重定时.................................................................................. 1298.2.3. 解决短路径............................................................................................. 133

9. Intel Hyperflex 体系结构高性能设计手册存档......................................................................135

10. Intel Hyperflex 体系结构高性能设计手册修订历史.............................................................. 136

内容

反馈 Intel® Hyperflex™ 体系结构高性能设计手册

3


1. Intel® Hyperflex™ FPGA体系结构介绍

本文档对通过 Intel® Hyperflex™ FPGA体系结构实现最大性能的设计方法进行了描述。 IntelHyperflex FPGA体系结构支持新的 Hyper-Retiming，Hyper-Pipelining和 Hyper-Optimization设计方法，实现 Intel Stratix® 10和 Intel Agilex™ 器件的最大时钟频率。

表 1. Intel Hyperflex 体系结构 FPGA

Intel Hyperflex 体系结构器件 Intel Hyperflex 体系结构描述

Intel Stratix 10 FPGAs 一种“寄存器无处不在(registers everywhere)”的体系结构，将可旁路的Hyper-Register封装到器件内核中的布线段中以及所有功能模块输入上。布线信号可以首先通过寄存器传播，或者旁路寄存器直接到达多路复用器，从而改善带宽，面积和功率。

Intel Agilex FPGAs

图 1. Registers Everywhere(寄存器无处不在)

ALM ALM ALM

ALM ALM ALM

ALM ALM ALM

模块输入上的寄存器

布线中的寄存器

Lorem ipsum

图 2. 可旁路的Hyper-Register

clk CRAMConfig

S10HPHB | 2020.07.13

反馈

Intel Corporation. All rights reserved. Agilex, Altera, Arria, Cyclone, Enpirion, Intel, the Intel logo, MAX, Nios,Quartus and Stratix words and logos are trademarks of Intel Corporation or its subsidiaries in the U.S. and/orother countries. Intel warrants performance of its FPGA and semiconductor products to current specifications inaccordance with Intel's standard warranty, but reserves the right to make changes to any products and servicesat any time without notice. Intel assumes no responsibility or liability arising out of the application or use of anyinformation, product, or service described herein except as expressly agreed to in writing by Intel. Intelcustomers are advised to obtain the latest version of device specifications before relying on any publishedinformation and before placing orders for products or services.*Other names and brands may be claimed as the property of others.

ISO9001:2015Registered


https://www.intel.com/content/www/us/en/quality/intel-iso-registrations.html



本文档提供了使用 Intel Hyperflex FPGA体系结构的具体设计指南，工具流程和实际示例：

• Intel Hyperflex 体系结构 RTL设计指南 (第 6页)—描述了 Intel Hyperflex FPGA体系结构设计的基本高性能 RTL设计技术。

• 编译 Intel Hyperflex 体系结构设计 (第 69页)—描述了如何使用 Intel Quartus PrimePro Edition软件实现 Intel Hyperflex 体系结构 FPGA的最高性能。

• 优化实例 (第 111页)—使用现实世界设计示例演示性能改进技术。

• Intel Hyperflex 体系结构移植指南 (第 117页)—提供移植到 Intel Hyperflex 体系结构FPGA的设计指南。

1.1. Intel Hyperflex 体系结构设计概念

表 2. 术语

术语/短语说明

关键链(Critical Chain) 任何防止寄存器重定时(retiming)的设计条件。限制因素可以包括一个链中有多个寄存器到寄存器路径。关键链的 fMAX及其相关的时钟域受到寄存器到寄存器路径的平均延迟以及不可分离的电路元件(如布线)量化延迟的限制。使用 Fast Forward编译来断开关键链。

快进编译(Fast Forward Compilation) 生成设计特定的时序收敛建议，并在移除每个时序限制后获得前瞻性的性能结果。

Hyper-Aware设计流程通过 Hyper-Retiming，Hyper-Pipelining，Fast Forward compilation和Hyper-Optimization实现 Intel Hyperflex 体系结构 FPGA中的最高性能的设计流程。

Intel Hyperflex FPGA体系结构器件内核体系结构，在整个内核架构中包括称为 Hyper-Register的额外寄存器。Hyper-Register提供已增加的带宽和已改进的区域和功率。

Hyper-Optimization 通过实现 Fast Forward编译建议的关键 RTL更改(例如重构逻辑以使用功能等效的前馈或预计算路径，而不是长的组合反馈路径)来改进设计性能的设计过程。

Hyper-Pipelining 通过在 ALM之间的互连上增添额外的流水线级来消除较长的布线延迟的设计过程。此技术支持设计运行在更快的时钟频率上。

Hyper-Retiming 在 Fast Forward编译期间，Hyper-Retiming会推测性地删除寄存器中的信号，对重定时使能网表中的移动性能。

多角时序分析(Multiple Corner TimingAnalysis)

分析多个“timing corner cases”以验证您设计的电压，工艺和温度操作条件。fast-corner分析假定最佳情况下的时序条件。

相关链接

• Hyper-Retiming (帮助寄存器移动) (第 10页)

• Hyper-Pipelining (添加流水线寄存器) (第 27页)

• Hyper-Optimization (优化 RTL) (第 36页)

1. Intel® Hyperflex™ FPGA体系结构介绍

S10HPHB | 2020.07.13


5


2. Intel Hyperflex 体系结构 RTL设计指南

本章节介绍了 RTL设计技术，通过 RTL设计技术实现 Intel Hyperflex 体系结构 FPGA中的最高时钟速率。 Intel Hyperflex 体系结构 FPGA支持的最大时钟速率明显高于前几代 FPGA。

注意: 避免违反 RTL设计规则可以提高设计的可靠性，时序性能和逻辑利用率。 Intel Quartus Prime软件包括 Design Assistant设计规则检查工具，可帮助避免违反设计规则。这些规则包括 Hyper-Retimer Readiness Rules (HRR)，专门用于 Intel Hyperflex 体系结构 FPGA设计，如使用Design Assistant进行设计规则检查 (第 73页)所描述。

相关链接

Intel Quartus Prime Pro Edition用户指南：设计建议提供有关设置和使用 Design Assistant的完整信息

2.1. 高速设计方法

将一个设计移植到 Intel Hyperflex 体系结构需要实现高速设计最佳实践，以获得最大效益并保留功能。 Intel Hyperflex 体系结构 FPGA高速设计方法会摒弃(proscribe)对延迟不敏感的设计，这些设计支持更多的流水线级，并避免性能限制环路。下面的高速设计最佳实践对 Intel HyperflexFPGA提供了最大优势：

• 设置一个高速目标

• 实验和迭代

• 单独编译设计组件

• 优化设计子模块

• 避免广播信号

接下来的部分描述了特定 RTL设计技术，在 Intel Quartus Prime Pro Edition软件中使能Hyper-Retiming，Hyper-Pipelining和 Hyper-Optimization。

2.1.1. 设置一个高速目标

为了提高硅效率，请将速度目标设置得尽可能高。 Intel Hyperflex 体系结构 LUT本质上是一个微型 ROM，每秒可以进行十亿次查询。在 156 MHz上运行这种 LUT仅占用 15％的容量。

设置高速目标的同时，您也必须在能够收敛时序的速度与所需要的实际系统速度之间维持一个舒适的保护带。最初通过裕量解决时序收敛会更容易。

2.1.1.1. 速度和时序收敛

当实际电路性能低于您设计的 f MAX要求时，就会无法关闭时序。如果目标 FPGA器件具有用于逻辑布局的很多可用资源，则时序收敛更容易，并且需要更少的处理时间。

S10HPHB | 2020.07.13

反馈



https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#mwh1409959528162





慢速电路的时序收敛并不比快速电路的时序收敛更容易，因为慢速电路通常在寄存器之间包括更多的组合逻辑。当一条路径包含很多节点时，Fitter必须使这些节点彼此分开，从而导致显着的布线延迟。相比之下，一个大量流水线化的电路更少依赖于布局，这样可简化时序收敛。

创建设计时使用实际的时序裕量。在系统中添加逻辑时，请考虑设计的某些部分能够使接触相互扭曲。增加系统压力通常会对速度产生不利影响。在设计开始时允许更多的时序裕量有助于缓解此问题。

2.1.1.2. 速度和延迟

下表列出了随着总线宽度的增加，各种电路的增长率。电路函数与作为总线宽度函数的面积的大 O符号交错，开始于 log(N)的子线性直到 N*N的超线性。

表 3. 总线宽度对面积的影响

Circuit Function

总线宽度 (N) log N Mux ripple add N*log N barrel shift Crossbar N*N

16 4 5 16 64 64 80 256

32 5 11 32 160 160 352 1024

64 6 21 64 384 384 1344 4096

128 7 43 128 896 896 5504 16384

256 8 85 256 2048 2048 21760 65536

通常，当总线宽度加倍时，电路组件使用 2倍以上的面积。对于像多路复用器(mux)这样的简单电路，随着总线宽度的增加，面积呈亚线性增长。降低多路复用器的总线宽度会略差于线性面积益处。随着总线宽度的增加，纹波加法器呈线性增长。

随着总线宽度的增加，诸如桶型移位器(barrel shifter)和交叉开关(crossbar)的更复杂的电路呈超线性增长。如果将桶型移位器，交叉开关或其他复杂电路的总线宽度减半，那么面积效益能显著地好于半速率，接近二次速率。对于那些所有输入影响所有输出的组件，增加总线宽度会导致二次增长。那么预期的结果将会是，如果利用加速来处理半宽度总线，那么所生成设计的面积将少于原始面积的一半。

使用流数据通路(streaming datapaths)时，寄存器的数量与流水线的延迟(以比特为单位)相近似。将宽度减半可以使流水线级增加一倍，而不会对延迟产生负面影响。这种更高的性能通常需要远远少于两倍的额外寄存量，以产生延迟效益。

2.1.2. 实验和迭代

如果设计性能最初不符合性能要求，那么需要尝试进行设置和设计更改。 Intel FPGA可重编程性使实验能够实现您的目标。随着技术要求的不断增加，设计性能通常变得不足。例如，如果在更广泛的参数化中将现有设计元素应用于新的方面，那么速度性能可能会下降。

在对电路时序进行实验时，实验会暂时中断电路以收集数据点，而不会产生永久性风险。您可以在功能上非法的位置添加寄存器，以确定对整体时序的影响。如果预期电路满足时序目标，那么可以专注于设计布局规划。

如果电路太慢，即使当大量插入寄存器时，那么您也可以重新考虑设计的更基本元素。向上或向下移动速度等级或者压缩 Logic Lock区域中的电路都是调查性能的好方法。


S10HPHB | 2020.07.13


7


2.1.3. 独立地编译组件

要尽早识别和优化性能瓶颈，您可以将设计子组件编译为独立实体。通过单独的组件编译，您可以独立地测试和优化组件，而无需运行时及整个系统的复杂性。

为每个组件所需的速度建立一个裕量。例如，当目标定为 20％的时序裕量时，具有 19.5％裕量的组件是失败的。时序裕量目标要基于不同的组件。例如，对于代表芯片一半的高级组件，可以允许10％的时序裕量。但是，如果规则不明确，那么裕量可能无效。

使用 Chip Planner可视化系统级视图。以下 Chip Planner视图显示了一个使用器件上 5％的逻辑(中央橙色)和使用 25％的M20K模块块(红色带状)的组件。

图 3. Chip Planner中的M20K分布

Chip Planner系统视图表明资源比率没有异常。但是，布线拥塞很明显。橙色存储器控制逻辑在一个大物理范围内扇出，以连接到所有存储器模块。单从操作上讲，此设计是令人满意的，但是当不相关的逻辑单元占据中介区域时，此设计变得不令人满意。重构此模块以物理分布控制逻辑可以更好地解决高级问题。

2.1.4. 优化子模块

在设计优化期间，您可以在大型设计的一个或两个子模块中隔离关键路径，然后编译子模块。编译设计的一部分可缩短编译时间，并使您可以专注于关键部分的优化。

2.1.5. 避免广播信号

要尽量避免使用广播信号。广播信号是高扇出控制网，并且在路径之间产生很大的延迟差异。此路径延迟差异对 Compiler为寄存器找到合适的位置增加了难度，从而导致不平衡的延迟路径。使用流水线来解决这个问题，复制寄存器来驱动广播信号。

广播信号要传播很长的距离才能到达每个独立的寄存器。因为这些扇出寄存器可能会在平面布局图中分散开，因此要使用手动寄存器复制来改进布局。流水线级的正确布局会对性能产生显著影响。


S10HPHB | 2020.07.13


8


在图 4 (第 9页)中，黄色框突出显示了在一个模块中插入的寄存器有助于时序。此模块将输出广播到多个收发器通道。这些额外的寄存器可能无法充分改进时序，因为最终的寄存器阶段会在器件的广泛区域上扇出到目的地。

图 4. 广播信号的次优流水线

D Q

Channel 0

D Q

Channel 1

D Q

Channel n

D Q D Q D Q

图 5 (第 9页)显示了一种更好的方法：复制最后一个流水线寄存器，然后将寄存器的副本放置在目标模块中(本例中的收发器通道)。此方法会产生更好的布局和时序。由于每个通道的流水线寄存器布局有助于覆盖黄色模块中的最后一个寄存器级与收发器中的寄存器之间的距离，因此会进行改进。

图 5. 广播信号的优化流水线

D Q

Channel 0

D Q

Channel 1

D Q

Channel n

D Q

D Q D Q D Q

D Q

除了复制最后一个流水线寄存器之外，您还可以应用 dont_merge综合属性以避免在综合期间合并重复的寄存器，这将消除任何益处。


S10HPHB | 2020.07.13


9


Compiler会尽可能自动添加流水线级并将寄存器移到 Hyper-Registers中。您还可以使用手动流水线操作来获得更好的布局结果。

相关链接

设置 dont_merge综合属性 (第 93页)

2.2. Hyper-Retiming (帮助寄存器移动)

Fitter的 Retime阶段通过将 ALM寄存器重定时(移动)到布线架构的 Hyper-Registers中来平衡寄存器链。通过在组合逻辑中前移和后移寄存器，Retime阶段也执行顺序优化。通过平衡一系列寄存器钟每个阶段之间的传播延迟，重定时(retiming)会缩短关键路径，降低时钟周期，增加操作频率。

Retime阶段然后在 Fitter期间运行，将寄存器移入理想的 Hyper-Register位置。此 Hyper-Retiming过程需要最小的工作量，同时又实现了 1.1 – 1.3倍的性能提升。

在图 6 (第 10页)中，左边的寄存器显示重定时前，两个 LUT的最坏情况延迟。右边的寄存器显示重定时后，一个 LUT的最坏情况延迟。

图 6. 在 LUT之间移动寄存器

LUT

LUT

LUT

LUT

LUT

LUT

LUT

LUT

LUT

LUT

LUT

LUT

BackwardRetiming

ForwardRetiming

当 Compiler不能重定时寄存器时，这是一个重定时限制，这种限制会限制设计的 fMAX。在设计的性能关键部分中最小化重定时限制以实现最高性能。

有各种各样的限制性能的情况。限制关系到硬件特性，软件行为或者设计特性。使用下面的设计技巧来协助寄存器重定时和避免重定时限制：

• 除非必要，否则要避免异步复位。请参考复位策略部分。

• 避免同步清零。同步清零通常是不利于重定时器的广播信号。

• 在时序约束和异常中使用通配符或名称。请参考时序约束考量部分。

• 避免单周期(停止/启动)流程控制，例如时钟使能和 FIFO full/empty信号。请考虑分别使用有效信号和 almost full/empty。


S10HPHB | 2020.07.13


10


• 避免保留寄存器属性。请参考重定时限制和解决方法部分。

• 关于添加流水线寄存器的详细信息，请参考 Hyper-Pipelining (Add Pipeline Registers)部分。

• 关于解决环路和重定时的其他 RTL限制的详细信息，请参考 Hyper-Optimization (OptimizeRTL)部分。

以下部分提供了在特定设计情况下帮助寄存器移动的设计技巧。

相关链接

• 复位策略 (第 11页)

• 时序约束考量 (第 16页)


• 重定时限制和解决方法 (第 92页)

2.2.1. 复位策略

本节提供了使用复位信号时实现最佳性能的技术建议。在配置完成前要使设计保持在复位状态，必须实现 Reset Release Intel FPGA IP或者 INIT_DONE信号(通过管脚回送)。关于器件复位的详细信息，请参考 Intel Agilex Configuration User Guide或者 Intel Stratix 10Configuration User Guide。

要实现最佳性能，除非必要，否则要避免复位(异步和同步)。由于 Hyper-Registers没有异步复位，因此 Compiler不能将带有异步复位的寄存器重定时到 Hyper-Register位置。

使用同步复位(而不是异步复位)可以支持寄存器的重定时。请参考同步复位和限制部分获得关于同步清零寄存器的重定时行为的详细信息。您设计中的某些寄存器需要同步或异步复位，但必须尽可能的减少数量以获得最佳性能。

相关链接

• 同步复位和限制 (第 126页)

• Intel Agilex 配置用户指南

• Intel Stratix 10配置用户指南

2.2.1.1. 移除异步复位(Removing Asynchronous Resets)

如果当复位保持足够长的时间来达到一个相当于完整复位的稳定状态时，电路自然地复位，那么就要移除异步复位。

表 4 (第 11页)显示了异步复位是如何对流水线中的所有寄存器进行复位的(以粗体显示)，从而防止 Hyper-Registers中的布局。

表 4. Verilog HDL和 VHDL异步复位实例

Verilog HDL VHDL

always @(posedge clk, aclr) if (aclr) begin reset_synch <= 1'b0; aclr_int <= 1’b0; end else begin reset_synch <= 1'b1; aclr_int <= reset_synch; end

PROCESS(clk, aclr) BEGIN IF (aclr = '0') THEN reset_synch <= '0'; aclr_int <= '0'; ELSIF rising_edge(clk) THEN reset_synch <= '1'; aclr_int <= reset_synch; END IF;END PROCESS;


S10HPHB | 2020.07.13


11

https://www.intel.cn/content/www/cn/zh/programmable/documentation/oex1546548090650.html#dtn1534779107124

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sss1439972793861.html#dtn1534779107124


Verilog HDL VHDL

always @(posedge clk, aclr_int)// Asynchronous reset=============== if (!aclr_int) begin a <= 1'b0; b <= 1'b0; c <= 1'b0; d <= 1'b0; out <= 1'b0; end//=============== else begin a <= in; b <= a; c <= b; d <= c; out <= d; end

PROCESS(clk, aclr_int) BEGIN// Asynchronous reset=============== IF (aclr_int = '0') THEN a <= '0'; b <= '0'; c <= '0'; d <= '0'; output <= '0';//=============== ELSIF rising_edge(clk) THEN a <= input; b <= a; c <= b; d <= c; output <= d; END IF;END PROCESS;

图 7 (第 12页)以示意图的形式显示了表 4 (第 11页)的逻辑。当 aclr置位时，触发器(flop)的所有输出都是零。释放 aclr并应用两个时钟脉冲会使所有触发器都进入功能模式。

图 7. 完全异步复位的电路

X0

X0

X0

X0

X0aclr

1

aclr

reset_synch

aclr_int a b c d output

Feeds aclr_int

RegisterStates

图 8 (第 12页)显示了从电路中间移除异步复位。在部分复位之后，如果修改的电路与原始电路具有相同的稳定状态，那么此修改在功能上是等效的。

图 8. 部分异步复位(Partial Asynchronous Reset)

X0

XX

XX

XX

X0aclr

Feeds aclr_intaclr

Add Enough Stages

Feeds sclr

00

00

X0

XX

00

0 0 0 0 0

1

a b c d output

reset_synch

aclr_int

图 9 (第 13页)显示了包含反相逻辑的电路如何需要额外的同步复位以保留在流水线中。


S10HPHB | 2020.07.13


12


图 9. 寄存器链中有逆变器(Inverter)的电路

X0

X0

X0

X0

X0aclr

1

aclr

reset_synch

aclr_int a b c d output

Feeds aclr_intInverter

1 0 1 0 01 0 1 0 0

operation

在移除复位并应用时钟后，寄存器输出不会处于复位状态。如果从反相寄存器中移除异步复位，那么电路在退出复位后不能与图 9 (第 13页)保持等效。

图 10. 带异步复位的寄存器链中有逆变器(Inverter)的电路

Steady State Is Not Correct

This Register Requiredto Keep Its Reset

X0

XX

XX

XX

X0aclr

Feeds aclr_intaclr

Add Enough Stages

Feeds sclr

00

00

X1

XX

00

0 0 1 1 0

1 reset_synch

aclr_int

a b c d output

1 0 1 1 10 1 1 1 1

为避免对由非自然反转功能导致的逻辑进行复位，请验证输出与复位移除同步，如图 11 (第 13页)所示。如果当计算流水线实际有效时验证流水线能够使能输出，那么此行为与复位移除等效。即使电路的计算部分不自然复位，此方法也是适合的。

图 11. 验证输出以同步复位

Feeds aclr_intaclr

Add Enough Stages

Feeds sclr

1

valid

reset_synch

aclr_int


S10HPHB | 2020.07.13


13


表 5 (第 14页)显示了图 8 (第 12页)的 Verilog HDL和 VHDL实例。您可以修改此实例以适合您的设计来删除不必要的异步复位。

表 5. 使用最少或无异步复位的 Verilog HDL实例

Verilog HDL VHDL

always @(posedge clk, aclr) if (aclr) begin reset_synch_1 <= 1'b0; reset_synch_2 <= 1'b0; aclr_int <= 1'b0; end else begin reset_synch_1 <= 1'b1; reset_synch_2 <= reset_synch_1; aclr_int <= reset_synch_2; end

// Asynchronous reset for output register=====always @(posedge clk, posedge aclr_int) if (aclr_int) out <= 1'b0; else out <= d;// Synchronous reset for input register=====always @(posedge clk) if (reset_synch_2) a <= 1'b0; else a <= in;// Naturally resetting registers=====always @(posedge clk) begin b <= a; c <= b; d <= c;

end

PROCESS (clk, aclr) BEGIN IF (aclr = '1') THEN reset_synch_1 <= '0'; reset_synch_2 <= '0'; aclr_int <= '0'; ELSIF rising_edge(clk) THEN reset_synch_1 <= '1'; reset_synch_2 <= reset_synch_1; aclr_int <= reset_synch_2; END IF;END PROCESS;

// Asynchronous reset for output register=====PROCESS (clk, aclr_int) BEGIN IF (aclr_int = '1') THEN output <= '0'; ELSIF rising_edge(clk) THEN output <= d; END IF;END PROCESS;// Synchronous reset for input register=====PROCESS (clk) BEGIN IF rising_edge(clk) THEN IF (reset_synch_2 = '1') THEN a <= '0'; ELSE a <= input; END IF; END IF;END PROCESS;// Naturally resetting registers=====PROCESS (clk) BEGIN IF rising_edge(clk) THEN b <= a; c <= b; d <= c; END IF;END PROCESS;

2.2.1.2. 全局时钟树上的同步复位

使用全局时钟树分布同步复位可能会限制 Compiler的重定时性能提升。全局时钟树没有 Hyper-Registers。因此，同布线架构的扇出相比，重定时那些通过全局时钟树扇出的寄存器的灵活性会更低。

2.2.1.3. I/O端口上的同步复位

Compiler不重定时那些驱动输出端口或者被输入端口驱动的寄存器。如果这种 I/O寄存器有一个同步清零，那么就不能重定时寄存器。此限制不常存在于包含逻辑驱动复位的实际设计中。然而，此问题在基准更小的逻辑(复位可能来自一个 I/O端口)时可能变得更加明显。在此情况中，您不能重定时任何被复位驱动的寄存器。将一些寄存器添加到同步复位路径中可以纠正此情况。

2.2.1.4. 复制和流水线同步复位

如果一个同步清零信号导致了时序问题，那么复制源寄存器与目的寄存器之间的同步清零信号能够解决此时序问题。被推进的寄存器不需要与被推回的寄存器争用 Hyper-Register位置。对于一个设计的小型逻辑模块，此方法是改进时序的一个有效策略。

2.2.2. 时钟使能策略

高扇出时钟使能信号能够限制重定时可实现的性能。这一部分对时钟使的正确使用进行了建议。


S10HPHB | 2020.07.13


14


2.2.2.1. 本地化时钟使能

本地化时钟使能有一个小扇出。本地化时钟使能经常出现在时钟化进程(clocked process)中或者永久模块(always block)中。在这些情况下，信号的行为在有条件的 case或 if声明语句的特定分支下是未定义的。因此，信号保留其以前的值，此值是一个时钟使能。

要检查一个设计是否有时钟使能，请查看 Fitter Report > Plan Stage > Control SignalsCompilation report and check the Usage列。由于本地化时钟使能有一个小扇出，因此会很容易地对其重定时，通常不会导致任何时序问题。

2.2.2.2. 高扇出时钟使能

要尽量避免高扇出信号。高扇出时钟使能驱动大量逻辑。逻辑的数量非常大，以至于您重新定时的寄存器会根据其特定需求在时钟启用路径上下推或上拉寄存器。这种推拉可能导致沿时钟使能线的冲突。这种情况类似于同步复位汇总部分中的主动重定时(aggressive retiming)。该部分讨论的一些方法，如复制使能逻辑，也有助于解决沿时钟使能线的冲突。

您通常使用这些高扇出信号来禁止运行大量逻辑。 FIFO的满标志变高时可能会出现这些信号。您可以经常设计这些信号。例如，您可以设计 FIFO以提前几个时钟周期指定 almost full，并允许时钟使能几个时钟周期以传播回禁用的逻辑。如有必要，您可以将这些额外的寄存器重定时到逻辑中。

相关链接

同步复位汇总 (第 128页)

2.2.2.3. 带时序异常的时钟使能

Compiler不能重定时那些是多周期或者假路径时序异常的端点的寄存器。时钟使能有时用于创建以主时钟频率的一半或四分之一运行的子域。有时这些时钟能够控制一条单一路径，其逻辑每隔一个周期都会改变。因为您通常使用时序异常来缓解时序，所以这种情况不是一个问题。如果时钟使能验证长数据路径和慢数据路径，并且该路径仍然遇到时序问题，那么要在数据路径中添加一个寄存器阶段。删除路径上的多周期时序约束。 Hyper-Aware CAD流程允许 Retimer重新定时路径以改善时序。

2.2.3. 综合期间保留寄存器

您可以指定实体级别的分配和综合属性，用于在综合处理期间保留特定的寄存器。

例如，Preserve Registers in ynthesis assignment保留在综合期间分配的寄存器，而不会限制 Hyper-Retiming优化。同样，您可以指定 dont_merge或 preserve_syn_only综合属性以保留寄存器，而不限制重定时优化，如下例所示。

logic hip_data; /* synthesis preserve_syn_only */(*preserve_syn_only*) logic hip_data;

Preserve Registers assignment也保留寄存器，但不支持所分配的寄存器的 Hyper-Retimer优化。当想要保留一个寄存器用于调试可观察性时，此 assignment很有用。

通过点击 Assignments > Assignment Editor，修改.qsf文件，或者在 RTL中指定综合属性来指定以下任何的综合保留分配。


S10HPHB | 2020.07.13


15


表 6. 综合保留选项

Assignment 说明支持Hyper-Retimer优化？

Assignment Syntax

PreserveRegisters inSynthesis

防止在综合期间删除寄存器。此设置不会影响 Fitter中的重定时或其他优化。

是 • PRESERVE_REGISTER_SYN_ONLY ON|Off-to <entity> .qsf

• preserve_syn_only orsyn_preservesyn_only (synthesisattributes)

PreserveFan-Out FreeRegisterNode

防止在综合期间删除没有扇出的寄存器。

PRESERVE_FANOUT_FREE_NODEassignment不能保留一个无扇出的寄存器，此寄存器在 Verilog HDL或 VHDL模块(其中定义了此寄存器)内没有扇出。要保留这些无扇出的寄存器，请在源文件中实现 noprune编译指令(pragma)：

(*noprune*)reg r;

如果此模块有多个实例，而只有一些实例需要保留无扇出寄存器，那么在 HDL中的寄存器上设置虚拟编译指令(dummypragma)，并设置PRESERVE_FANOUT_FREE_NODEassignment。此虚拟编译指令(dummypragma)使寄存器综合能够实现分配。例如，为 Verilog HDL中的寄存器 r设置以下虚拟编译指令(dummy pragma)：

(*dummy*)reg r;

是 • PRESERVE_REGISTER_FANOUT_FREE_NODEON|Off -to <entity> .qsf

• no_prune on (synthesis attribute)

PreserveRegisters

防止在综合期间删除和顺序优化分配的寄存器。顺序网表优化可以消除冗余寄存器和具有恒定驱动器的寄存器。

否 • PRESERVE_REGISTER ON|Off -to<entity> .qsf

• preserve, syn_preserve, or keep on(synthesis attributes)

2.2.4. 时序约束考量

时序约束的使用会对编译结果有影响。时序收敛会影响 Fitter如何布局逻辑。这一部分对能够最大化设计性能的时序约束技术作了介绍。

2.2.4.1. 优化多周期路径

Compiler不重定时.sdc时序约束的端点的寄存器，包括多周期或者假路径时序约束。因此，要尽可能具体地分配约束或异常，以避免重定时限制。

使用实际的寄存器阶段(而不是多周期约束)会实现 Compiler最大灵活性，从而提高性能。例如，不指定多周期异常为 3的组合逻辑，而是移除多周期异常，然后在组合逻辑前或后插入两个额外的寄存器阶段。这样，Compiler能够通过逻辑最佳地平衡额外寄存器阶段。

2.2.4.2. 过约束(Overconstraints)

过约束引导 Fitter使用更多的时间对设计的特定部分进行优化。在某些情况下，过约束适用于提高性能。然而，由于传统的过约束方法限制了重定时优化，因此 Intel Hyperflex 体系结构 FPGA支持一个允许重定时的新的 is_post_route函数。is_post_route函数允许 Fitter调整时序裕量延迟(slack delay)来实现时序优化。


S10HPHB | 2020.07.13


16


实例-1: 过约束语法(支持Hyper-Retiming)

if { ! [is_post_route] } { # Put overconstraints here}

实例-2: 传统过约束示例(防止Hyper-Retiming)

### Over Constraint #### if {$::quartus(nameofexecutable) == "quartus_fit"} {# set_min_delay 0.050 -from [get_clocks {CPRI|PHY|TRX*|*|rx_pma_clk}] -to \ [get_clocks {CPRI|PHY|TRX*|*|rx_clkout}]# }

2.2.5. 时钟同步策略

使用一个简单的同步策略来实现 Intel Hyperflex 体系结构 FPGA中的最大速度。在简单的同步器交叉路径上添加延迟很简单直接。然而，在其他交叉路径上添加延迟会更为复杂。

图 12 (第 17页)显示了一个简单的同步方案，其中有一条路径从第一个域的一个寄存器(蓝色)直接到下一个域的寄存器(红色)。

图 12. 简单时钟域交叉

如要在红色区域中增添延迟用于重定时，则要添加寄存器，如图 13 (第 17页)所示。

图 13. 添加延迟到简单时钟域交叉

图 14 (第 18页)显示了一个域交叉结构，此结构在 Intel Hyperflex 体系结构 FPGA中不是最优的，但存在于使用其他目标器件系列的设计中。此设计在蓝色时钟域与红色时钟域之间包含一些组合逻辑。此设计没有正确地同步逻辑，您无法灵活地添加寄存器。蓝色时钟域驱动组合逻辑，此逻辑包含红色域启动的路径。


S10HPHB | 2020.07.13


17


图 14. 在多个位置上的时钟域交叉

图 15 (第 18页)显示在红色时钟域的边界上添加延迟，而不在一条红色到红色域路径上添加寄存器。否则，路径会变得不平衡(相对于时钟边沿上的周期行为)，从而可能会改变设计功能。虽然可能，但在这种情况下添加延迟是有风险的。在添加延迟之前要彻底分析各种路径。

图 15. 在多个时钟域交叉位置添加延迟

对于 Intel Hyperflex 体系结构 FPGA，在进入组合逻辑前要同步时钟交叉路径。与前面的示例进行比较时，添加延迟会更加简单。

图 16 (第 19页)显示在进入组合逻辑之前蓝色域寄存器与红色域同步。此方法允许在同步寄存器之前安全地添加流水线寄存器，而不会无意中接触红色到红色路径。实现此同步方法以实现 IntelHyperflex 体系结构 FPGA中的最高性能。


S10HPHB | 2020.07.13


18


图 16. 时钟域同步改进


S10HPHB | 2020.07.13


19


2.2.5.1. 时钟域交叉约束准则(Clock Domain Crossing Constraint Guidelines)

您必须将相应的时序约束应用于任何多比特时钟域交叉。set_false_path约束的优先级高于所有其他基于路径的约束。因此，当时钟域交叉有 set_false_path约束时，时序分析可以忽略其他较低优先级约束(例如偏斜)。

请遵循以下准则，正确地限制时钟域交叉：

• 查看 SDC时序约束以确保两个时钟域之间不存在 set_false_path约束。

• 要从建立和保持时序分析中移除两个时钟域之间的任何伪路径，请应用set_clock_groups约束，而不是 set_false_path约束。set_clock_groups的优先级低于 set_false_path 。

• 使用 set_net_delay约束两个时钟域之间的路径，以使网络(net)尽可能短。

• 使用 set_max_skew约束两个时钟域之间的网络(net)。您可以在 Timing Analyzer报告中查看与您的约束相比的结果。

以下命令显示在 clk_a时钟域中的 data_a与 clk_b时钟域中的 data_b之间的时钟域交叉的实例约束：

create_clock -name clk_a -period 4.000 [get_ports {clk_a}]create_clock -name clk_b -period 4.500 [get_ports {clk_b}]set_clock_groups -asynchronous -group [get_clocks {clk_a}] -group \ [get_clocks {clk_b}]set_net_delay -from [get_registers {data_a[*]}] -to [get_registers \ {data_b[*]}] -max -get_value_from_clock_period dst_clock_period \ -value_multiplier 0.8set_max_skew -from [get_keepers {data_a[*]}] -to [get_keepers {data_b[*]}] \ -get_skew_value_from_clock_period src_clock_period \ -skew_value_multiplier 0.8

2.2.6. 亚稳态同步器(Metastability Synchronizers)

Compiler检测作为同步器链中的一部分的寄存器。Compiler不能重定时同步器链中的寄存器。要实现同步器链中的寄存器重定时，需要在时钟域边界上添加更多的流水线寄存器。

Intel Hyperflex 体系结构 FPGA的默认亚稳态同步器链长为 3。Critical Chain报告通过 REG(Metastability required)文本对亚稳态需要的寄存器进行标记。

如果设计包括 two-register链作为同步器，那么可以指定以下设置以将默认链长度从 3修改为 2：

1. 点击 Assignments > Settings。

2. 点击 Category下的 Compiler Settings。

3. 点击 Advanced Settings (Synthesis)按钮。

4. 对于 Synchronization Register Chain Length，在 Setting列中输入 2。

或者，您可以在.qsf文件中指定此设置：

set_instance_assignment -name SYNCHRONIZATION_REGISTER_CHAIN_LENGTH 2 \ -to * -entity <top_module_name>


S10HPHB | 2020.07.13


20


2.2.7. 初始上电条件

上电时的设计初始条件代表时钟周期 0的设计状态。初始条件高度依赖于基础器件技术。一旦设计离开初始状态，就没有自动方法返回到该状态。换句话说，初始状态是一个过渡状态而不是功能状态。另外，其他设计组件可能会影响初始状态的有效性。例如，上电时尚未锁定的 PLL可能会影响初始状态。

因此，当对 Intel Hyperflex 体系结构 FPGA进行设计时不要依赖于初始条件，而是使用一个复位信号将设计置于一个已知的功能状态下，直到所有接口都上电，锁定并受训为止。

2.2.7.1. 指定初始存储器条件

您可以通过 RTL代码中的推理(inference)来指定初始上电条件。 Intel Quartus Prime综合自动将寄存信号的默认值转换成 Power-Up Level约束。或者，手动指定 Power-Up Level约束。

实例-3: 初始上电条件语法(Verilog HDL)

reg q = 1’b1; //q has a default value of ‘1’always @ (posedge clk)begin q <= d;end

实例-4: 初始上电条件语法(VHDL)

SIGNAL q : STD_LOGIC := '1'; -- q has a default value of '1'PROCESS (clk, reset)BEGIN IF (rising_edge(clk)) THEN q <= d; END IF;END PROCESS;

2.2.7.2. 初始条件和重定时

初始上电条件可能会限制 Compiler在综合期间执行逻辑优化的能力，以及在重定时期间将寄存器移到 Hyper-Registers的能力。

以下实例说明如何将初始条件设置为已知状态，以确保重定时后电路的功能等效。

图 17. 重定时前的电路

此示例电路显示寄存器 F1在上电时有状态‘0’或状态‘1’。假设逻辑云是纯组合的，在电路中有两种可能的状态 C1 (F1=‘0’或 F1=‘1’)。

D QF1


S10HPHB | 2020.07.13


21


图 18. 向前重定时后的电路

如果 Retimer向前推动寄存器 F1，那么 Retimer必须复制 F1驱动的每个分支中的寄存器。

F12

D QF11

D QF12

D QF12

在重定时和寄存器复制之后，电路在上电时现在有四种可能的状态。重定时后电路中增加的两种潜在状态可能会改变设计功能。

表 7. 重定时后可能的上电状态

F11状态 F12状态

0 0

0 1

1 0

1 1

C-Cycle等同

c-cycle是指上电后设计需要用于确保功能等同的时钟周期数。c-cycle值在构建设计的复位流程时是一个重要的考虑因素。要确保重定时后的设计功能等同，需要在上电后使用一个额外的时钟周期。此额外时钟周期确保了 F11和 F12状态始终相同。这种技术导致寄存器只能有 0/0或 1/1两种可能的状态，假设组合逻辑在两个路径上都是非反相的。

向后重定时

向后重定时寄存器总是一个安全的操作(c-cycle值为 0)。在这种情况下，Compiler将 F11和F12合并在一起。如果没有对 F11和 F12指定初始条件，那么 Compiler会始终允许合并。如果指定了初始条件，那么 Compiler会考虑 F11和 F12的初始状态。在此情况下，仅在转换保留初始状态时才会发生重定时转换。

如果 Compiler转换不能保留 F11和 F12的初始状态，那么 Compiler不允许重定时操作。要避免在重定时期间更改电路功能，需要在上电后使用一个额外的时钟周期来确保 F11和 F12的内容始终相同。

2.2.7.3. 初始条件和Hyper-Registers

Intel Hyperflex 体系结构布线架构包括 Hyper-Registers，以实现最高性能。然而，除非适当考虑，否则初始上电条件会限制 Compiler将寄存器重新定时到 Hyper-Registers的能力。使用单个复位信号(而不是依赖于初始条件)将设计置于已知的功能状态，直到所有接口都已上电，锁定和训练为止。


S10HPHB | 2020.07.13


22


如果必须依赖初始条件，并且系统要求所有寄存器同步启动，那么建议使用时钟门控。由于 Hyper-Registers缺少复位或使能信号，因此无法使用复位控制信号将它们初始化为一个特定值。 IntelStratix 10 Hyper-Registers能够上电到 0或者 1。 Intel Agilex Hyper-Registers在配置期间上电到 1。当系统启动时，在配置后立即显示初始值，而无需显式复位。

ALM和Hyper-Registers的时钟门控

独立信号驱动 Intel Hyperflex 体系结构 FPGA中 ALM寄存器和 Hyper-Registers的内部时钟控制。在配置过程中，寄存器逐行变为有效(与器件范围相反)。此外，ALM寄存器时钟可以独立于Hyper-Register时钟进行使能。如果设计时钟是自由运行的，那么这可能会导致行之间以及 ALM寄存器与 Hyper-Registers之间的潜在竞争条件。这些条件可能导致初始条件的覆盖。为了避免这些情况的发生，需要在在所有时钟控制逻辑置低和所有寄存器有效之前对时钟进行门控。

2.2.7.3.1. 实现时钟门控(Implementing Clock Gating)

要实现时钟门控，需要使用 Intel Quartus Prime软件中的以下 Intel FPGA IP对USER_CLKGATE信号进行访问：

• Reset Release Intel FPGA IP—在配置完成前将设计保持在复位状态(通过门控时钟，复位或者写使能)。此 IP输出 nINIT_DONE信号。当 nINIT_DONE为低电平时，器件不再处于配置模式。

• Clock Control Intel FPGA IP—使用反向的 nINIT_DONE信号作为时钟使能信号。

请按照以下步骤实现时钟门控：

1. 在 Intel Quartus Prime软件中打开一个设计。

2. 在 IP Catalog中，在搜索域中输入 reset release，然后双击 Reset Release IntelFPGA IP 。

3. 在参数编辑器中对配置指定相应的参数，然后点击 Generate HDL。

4. 重复步骤 2到 3将 Clock Control Intel FPGA IP添加到工程中。在 IP生成之前，在参数编辑器中对 IP指定以下选项：

• 在 Clock Gating下，开启 Clock Enable选项。

• 对 Clock Enable Type选择 Root Level。

• 对 Enable Register Mode选择Negative Latch。

5. 将 Reset Release和 Clock Control Intel FPGA IP连接在一起：

• 要门控时钟，请使用反相的 nINIT_DONE作为 Clock Control Intel FPGA IP的使能输入。

• 如果要求初始条件，那么 Intel建议 Clock Control Intel FPGA IP也使用根时钟门控(root clock gating)。

下图显示了 Reset Release与 Clock Control Intel FPGA IP之间的正确连接，确保配置后的准确初始条件：


S10HPHB | 2020.07.13


23


图 19. Reset Release (reset_release)与 Clock Control (clock_control) Intel FPGA IPCore之间的连接

Clock Control Intel FPGA IP使用 ena信号执行时钟门控功能。Clock Control Intel FPGAIP的输出上的时钟信号然后可以安全地用于已初始化的寄存器(ALM and Hyper-Registers)。

2.2.7.3.2. 用于初始条件的 Intel Quartus Prime设置

您可以使用以下对初始条件有影响的 Intel Quartus Prime设置。

Power-Up Don't Care Logic选项

通过确保 Power-Up Don't Care Logic选项(ALLOW_POWER_UP_DONT_CARE)是开启的，可以使能更多寄存器的重定时。此选项指定在 RTL中没有明确初始条件的寄存器上电到 don't care。默认情况下，此选项设置为 On。

set_global_assignment -name ALLOW_POWER_UP_DONT_CARE ON

当使用 ALLOW_POWER_UP_DONT_CARE时，您在 RTL中指定的任何初始条件或隐含的任何初始条件(由于语言规范或 FSM初始状态)仍然适用。

忽略初始条件

由于语言规范和结构(例如状态机)上的保守综合等因素，即使您期望没有初始条件出现，初始条件也可能出现在某些寄存器中。这样的初始条件可能会导致性能限制。如果您确认删除此类初始条件在功能上是正确的，那么您可以指定以下.qsf assignment来删除这些初始条件：

set_instance_assignment -name IGNORE_REGISTER_POWER_UP_INITIALIZATION ON \ -to <instance name>

Synthesis报告标识了"Registers with Power-Up Settings Ignored"报告中受IGNORE_REGISTER_POWER_UP_INITIALIZATION影响的寄存器。

2.2.7.4. 重定时复位流程(Retiming Reset Sequences)

在某些条件下，Retime阶段会执行 c-cycle值大于零的寄存器转换。此功能可以帮助提高设计的最大频率。但是，大于零的 c-cycle等效值的寄存器重定时需要额外的预防措施，以确保重定时后的功能等效。为了保持功能等效，请重新使用现有的复位流程，并添加适当的时钟周期数，如以下部分所述：

修改复位序列

请按照如下建议在重定时期间最大化复位的操作频率：


S10HPHB | 2020.07.13


24


• 从所有自然复位的寄存器中删除 sclr信号。此删除操作使寄存器能够在重定时期间在逻辑中自由移动。

• 确保 ALLOW_POWER_UP_DONT_CARE global assignment设为 ON。此设置最大化寄存器移动。

• 计算由 c-cycle等价导致的额外时钟周期的相关数量，并加入到复位同步器中。

添加时钟周期到复位

Compiler报告要加入到 Fitter > Retime Stage > Reset Sequence Requirement报告中复位序列中的时钟周期数。此报告在时钟域基础上列出了要加入的周期数。

图 20. 复位序列要求报告

到多个分支的寄存器复制的 c-cycle值为 1。无论复制寄存器的数量是多少，寄存器始终是一个远离其原始源的连接。一个时钟周期后，所有分支再次具有相同的值。

以下示例显示了如何在复位序列中添加时钟周期，以确保重定时后设计的功能等同性。

图 21 (第 25页)显示了具有前向重定时潜力的寄存器的流水线操作。c-cycle值等于 0。

图 21. 流水线和寄存器复制

D QF4

D QF3

D QF2

D QF1

图 22 (第 25页)显示了一个寄存器的向前重定时后的流水线寄存器。由于 c-cycle值等于 1，因此该电路的复位序列需要一个额外的时钟来实现复位后的功能等效。

图 22. 一个寄存器移动的影响

D QF4

D QF3

D QF2

D QF11

D QF12


S10HPHB | 2020.07.13


25


图 23 (第 26页)显示了两个寄存器的向前重定时后的流水线寄存器。由于 c-cycle值等于 2，因此该电路的复位序列需要两个额外的时钟来实现复位后的功能等效。

图 23. 两个寄存器移动的影响

D QF4

D QF3

D QF21

D QF22

D QF11

D QF12

流水线中的寄存器每次移到逻辑中时，寄存器就会复制，C-cycle值就会加 1。

2.2.8. 通过 RAM和 DSP的重定时

Compiler能够在往返 RAM或者 DSP的路径上使用 Hyper-Register，而无需考虑 RAM或者 DSP重定时的设置如何。然而，开启 Allow RAM Retiming或者 Allow DSP Retiming选项使Compiler能够通过 RAM和 DSP对寄存器进行重定时。当 RAM或者 DSP重定时设置禁止(默认)时，Compiler不会通过 RAM或者 DSP对寄存器进行重定时。

要访问这些设置，请点击 Assignments > Settings > Compiler Settings > AdvancedSettings (Fitter)。

图 24. 寄存器优化设置(Register Optimization Settings)

以下这些图显示了这些设置产生的影响：

图 25. RAM或 DSP时序路径

RAMor

DSP


S10HPHB | 2020.07.13


26


图 26. 默认的 RAM或 DSP重定时优化

RAMor

DSP

Retimer Scope Retimer Scope

图 27. 允许 RAM重定时或者允许 DSP重定时

RAMor

DSP

Retimer Scope

2.3. Hyper-Pipelining (添加流水线寄存器)

Hyper-Pipelining通过在 ALM之间的互连上增添额外的流水线级来消除较长的布线延迟。此技术支持设计运行在更快的时钟频率上。首先运行 Fast-Forward编译来决定通过添加流水线级预期达到的最佳位置和性能。与上一代高性能 FPGA相比，此过程在实现了 Intel Hyperflex 体系结构FPGA的 1.3 – 1.6x性能增量的同时只需要最少的操作量。

如果在您的设计中提前规划额外的延迟，那么添加寄存器会变得更容易。从最基本的层面上看，规划额外延迟意味着在设计中的时钟域的输入和输出上使用可参数化的流水线。请参考附录：流水线实例部分来了解 Verilog HDL，VHDL和 SystemVerilog中的已预写的可参数化模块。

更改延迟比只添加流水线阶段还复杂。更改延迟需要修订控制逻辑，设计的其他部分或者系统软件来正确地与稍后达到的数据一起操作。在现有的 RTL中进行这样的更改可能会很难，但在新的设计部分中或许会更容易。不要将模块延迟硬编码到控制逻辑中，而要尝试使它们中的一些成为参数。在某些类型的系统中，“valid data”标志出现在处理流水线中的流水线阶段中，以触发各种计算，而不是依赖于数据何时有效的高级固有概念。

额外的延迟也可能要求对测试台的变更。当您创建测试台时，使用与创建延迟敏感的设计时所使用的相同技术。不要依赖于预定义数量的时钟周期后出现的结果，但要考虑选择“valid data”或“valid result”标志。

延迟敏感的设计不适用于系统的每个部分。对数据变成有效而指定时钟周期的接口协议一定要符合这些要求，并且可能不会接受延迟上的变化。

在修改了 RTL并将相应数量的流水线阶段布置在每个时钟域的边界上之后，Retime阶段自动将时钟域中的寄存器布置在最优位置以最大化性能。与传统的流水线相比，Hyper-Retiming和 Fast-Forward的结合会有助于自动化进程。

相关链接

• 附录 A：可参数化的流水线模块 (第 124页)

• 预计算 (第 45页)

2.3.1. 传统对超级流水线(Conventional versus Hyper-Pipelining)

Hyper-Pipelining简化了传统流水线的这一进程。传统流水线包括以下设计修改：


S10HPHB | 2020.07.13


27


• 在逻辑云之间添加两个寄存器

• 修改 HDL将第三个寄存器(或者流水线阶段)插入到设计的逻辑云中，也就是 Logic Cloud 2。此寄存器插入在 HDL中有效地创建了 Logic Cloud 2a和 Logic Cloud 2b

图 28. 传统流水线用户修改

LogicCloud1

LogicCloud2

Reg1 Reg2 Reg3

LogicCloud1

LogicCloud2b

Reg2Reg1 Reg3

LogicCloud2a

Pipe1 Pipe2 Pipe3

图 29. Hyper-Pipelining用户修改Hyper-Pipelining简化了添加寄存器的这一进程。在设计 RTL中的一个位置共添加了寄存器 Pipe 1、Pipe 2和 Pipe 3。然后，在设计编译期间，Compiler重定时电路上的寄存器以找到路径上的最佳布局。此优化缩短了路径延迟，并最大化设计的操作频率。

LogicCloud1

LogicCloud2

Reg1 Reg2 Reg3 Reg1 Reg2 Reg3Pipe1 Pipe2 Pipe3

LogicCloud1

LogicCloud2

图 30. Hyper-Pipelining和Hyper-Retiming实现下图显示了重定时阶段完成优化后的额外寄存器的实现。

LogicCloud2a

Reg1 Reg2 Reg3Pipe1 Pipe2 Pipe3 Reg1 Reg2 Reg3Pipe1 Pipe2 Pipe3

LogicCloud1

LogicCloud2

LogicCloud1

LogicCloud2b

在 Hyper-Pipelining流程中完成的实现不同于传统的流水线流程，不同之处表现在 Pipe 3寄存器的位置。由于 Compiler了解当前电路实现，包括布线，因此 Compiler能够更有效地定位总寄存器，以满足设计的最大操作频率。Hyper-Pipelining需要的操作要比传统的流水线技术少很多，这是因为您可以在数据通路的方便位置上布局寄存器。Compiler自动优化寄存器布局。

2.3.2. 流水线和延迟

在路径中添加流水线寄存器会增加一个信号值在路径上传播所需要的时钟周期数。增加时钟频率能够抵消增加的延迟。

图 31. Hyper-Pipeline缩短的延迟此实例显示了上一代 Intel FPGA，具有 275 MHz fMAX要求。由于 3.5 ns延迟限制了路径，因此左侧路径达到 286 MHz。数据需要三个周期传播到寄存器流水线。275 MHz上的三个周期计算成 10.909 ns，也就是数据传播到流水线需要的时间。

1.5 ns 3.5 ns 1.5 ns 1.7 ns 1.8 ns


S10HPHB | 2020.07.13


28


如果重新定位一个 Intel Hyperflex 体系结构 FPGA将 fMAX要求加倍到 550 MHz，那么图中右侧上路径显示一个额外的流水线级如何重定时。由于 1.8 ns延迟的限制，路径现在达到 555 MHz。数据需要四个周期传播到寄存器流水线。550 MHz上的四个周期为 7.273 ns，也就是数据传播到流水线需要的时间。

与三阶段的流水线相比，如果目标是保持传播到四阶段的流水线的时间，那么需要通过提高第二个版本的 fMAX到 367 MHz 来满足第一个版本的 10.909 ns延迟。此技术可产生 275 MHz的 33%提升。

2.3.2.1. 可变延迟位置的流水线操作(Pipelining at Variable Latency Locations)

通常，FPGA设计包括一些对额外延迟不敏感的位置，例如在时钟域边界，主要功能模块之间的连接和错误路径。最佳设计实践建议在时钟域边界或主要功能模块之间添加流水线级(pipeline stages)以改善时序。但是，添加过多的流水线级也会使面积使用量增加，同时增加布线拥塞。

Intel Quartus Prime软件的当前版本包括一些新特性，有助于改善对额外延迟不敏感的设计路径的时序性能。 Hyper-Retimer现在可以在标记为对延迟不敏感的假路径上自动添加流水线级，并在您指定的寄存器中插入适当数量的流水线级。Hyper-Retimer将添加的寄存器重定时到设计的时序关键部分。 Hyper-Retimer添加的流水线级的数量可以针对每个编译而更改，或者在更改设计的任何时候而更改。

注意: • 如果不指定对延迟不敏感的伪路径或者使用自动流水线，那么 Hyper-Retimer输出网表与RTL是周期等效。

• 如果指定对延迟不敏感的伪路径或者使用自动流水线，那么 Hyper-Retimer输出网表与 RTL不是循环等效的。因此，仿真和验证环境必须适应电路延迟的变化才能使用这些技术。

2.3.2.1.1. 指定延迟不敏感的伪路径

您可以指定对延迟不敏感的伪路径，使 Hyper-Retimer能够自动将流水线级添加到一条路径中。仅在交叉时钟域路径(例如在低速配置时钟域与高速数据路径时钟域之间，如在信号处理设计中)上指定对延迟不敏感的伪路径。

对 set_false_path异常指定 latency_insensitive选项，将伪路径指定为对延迟不敏感。对 from和 to选项指定时钟名称，如下例所示：

set_false_path -latency_insensitive -from [get_clocks {clock_a}] \ -to [get_clocks {clock_b}]

尽管对 from或者 to选项指定 register，cell，net，pin或者 keeper名称不是一个语句错误，但 Compiler会将伪路径看作重定时限制，并阻止 Hyper-Retimer重定时这些端点。在一条寄存器到寄存器的伪路径上使用 latency_insensitive选项没有任何好处。

注意: set_false_path约束的优先级高于所有其他基于路径的约束。如果对延迟不敏感的伪路径位于包含 FIFO，总线同步器或其他具有 set_max_skew，set_max_delay或者set_min_delay等约束的跨域电路的时钟域传输上，那么时钟到时钟 set_false_path约束会覆盖这些约束。如果使用任何基于路径的约束对一个时钟域交叉进行约束，那么latency_insensitive选项会覆盖这些约束。仅在从时序分析中实际切断的时钟域交叉路径上使用对延迟不敏感的伪路径。

在下图中，顶部图代表设计 RTL，表示标记为对延迟不敏感的伪路径的伪路径。下图显示了 Hyper-Retimer如何在延迟不敏感的伪路径的端点处的寄存器的另一侧添加流水线级。

Hyper-Retimer可以将寄存器添加到延迟不敏感的伪路径的源输入，以及延迟不敏感的伪路径的目的地输出。然后，Hyper-Retimer通过两个时钟域向后和向前重定时寄存器。


S10HPHB | 2020.07.13


29


图 32. 对延迟不敏感的伪路径对电路的影响

Clock A

Clock B

Clock B

对延迟不敏感的伪路径

插入的流水线级的数量取决于性能需要

Clock A

对延迟不敏感的伪路径

Hyper-Retimer分别分析每个跨时钟域(cross-clock-domain)路径的性能，以确定要自动添加的级数(number of stages)。Hyper-Retimer可以在每个跨时钟域路径上插入不同数量的级。

例如，跨越通过 latency_insensitive选项切割的时钟域的总线在 Hyper-Retimer运行后可以对总线中的每个比特有不同的延迟。因此，请确保跨越时钟域的数据在多个时钟周期内保持不变，以确保它在目的地保持恒定。例如，这可能发生在每个比特上有不同延迟的总线上。

编译报告未显示 Hyper-Retimer在延迟不敏感的伪路径中插入的级数(number of stages)。但是，您可以在 Hyper-Retimer完成后检查时序网表中的连接来确定级数。

2.3.2.2. 自动流水线插入(Automatic Pipeline Insertion)

自动流水线插入使 Hyper-Retimer能够在设计中指定的位置插入多个流水线级。您可以指定要在每个特定寄存器中插入的流水线级的最大数量。

图 33. 可变延迟模块的典型使用

N

ParameterizedData Width

NVariableLatencyModule

Logic CloudNeeds More Pipeline

Stages

Intel Quartus Prime软件包括 Variable Latency Module模板(hyperpipe_vlat)，可对实现进行简化。或者，通过使用.qsf assignments的组合来实现自动流水线插入。


S10HPHB | 2020.07.13


30


当例化 hyperpipe_vlat模块，Enable Auto-Pipelining(HYPER_RETIMER_ENABLE_ADD_PIPELINING)选项保持使能时，Hyper-Retimer在重定时期间指定的寄存器上添加相应数量(不超过指定的最大值)的额外流水线级。此设置在默认下是使能的。点击 Assignments > Settings > Compiler Settings > Advanced Settings(Fitter)访问此设置。

图 34. 包含最多十个流水线级的可变延迟模块

Variable Latency ModuleWith Maximum 10 Pipe

Stages

Logic CloudNeeds 2~5 Pipeline

Stages

FF

FF

例如，如果指定最大数量 10个流水线级，那么 Hyper-Retimer可能决定仅需要三个额外的流水线级来最大化时序性能。Hyper-Retimer仅添加必要数量的流水线级。

图 35. Hyper-Retimer仅添加所需的额外级

Variable Latency ModuleWith Maximum 10 Pipe

StagesAdded 3 Pipes stages asneeded for this compile

Number of stages arematched for each bit

in the group

FF

FF

您可以对 hyperpipe_vlat模块的各个实例指定不同数量的流水线级，如下图所示：


S10HPHB | 2020.07.13


31


图 36. 每个模块不同的最大流水线级

Registers in each group arepipelined equally, up to anuser-specified maximum

User can assign multiple instanceswith different maximum stages

Instance 1

FF

FF

Instance 2

FF

FF

以下步骤详细描述了如何实现自动流水线插入：

• 第 1步：创建可变延迟模块 (第 32页)

• 第 2步：例化可变延迟模块 (第 33页)

• 第 3步：验证自动流水线插入选项 (第 34页)

• (可选)无可变延迟模块的自动流水线插入 (第 35页)

额外级的最大数量的有效值为 1到 100 (包括 1和 100)。

2.3.2.2.1. 第 1步：创建可变延迟模块

您可以使用 Intel Quartus Prime软件中的 Hyper-Pipelining Variable Latency Module模板(hyperpipe_vlat)创建可变延迟模块，用于自动流水线插入。

hyperpipe_vlat模块包含一个单一流水线级。Hyper-Retimer将相同数量的流水线级添加到hyperpipe_vlat模块的一个实例中的所有比特中。模块包含如下自定义参数：

• WIDTH—指定总线宽度，默认值为 1。

• MAX_PIPE—指定 Hyper-Retimer可以在此实例上添加的最大流水线级数。此值必须介于 1和 100之间(包括 1和 100)。默认值为 100。


S10HPHB | 2020.07.13


32


图 37. Hyper-Pipelining可变延迟模块模板

在 Intel Quartus Prime软件中按照以下步骤创建一个可变延迟模块：

1. 点击 File > New创建一个新的 Verilog HDL或者 VHDL设计文件。

2. 右击新的文件，然后点击 Insert Template。

3. 选择 Verilog HDL (or VHDL) > Full Designs > Pipelining > Hyper-PipeliningVariable Latency Module，然后点击 Enter和 Close。模块模板插入到文件中。

4. 当例化 hyperpipe_vlat模块时对 WIDTH和 MAX_PIPE参数指定相应值。

5. 保存文件。

2.3.2.2.2. 第 2步：例化可变延迟模块

您可以使用 Fast Forward Compilation功能来帮助确定自动流水线插入的合适位置。以下位置通常适用于自动流水线插入：

• 传输不断变化的数据的时钟边界

• 毗邻复杂的组合功能

• 在同一时钟域上的两个独立功能模块之间


S10HPHB | 2020.07.13


33


在时钟域边界例化可变延迟

Fast Forward Compilation建议在时钟域边界添加流水线级，这样可以很容易处理额外延迟。在这种情况下，您可以在 synchronizer或者 FIFO之前或者之后例化 hyperpipe_vlat，无需comb function与 vlat module之间的寄存器或者逻辑(相对于网表连接)。建议在 synchronizer或 FIFO之后进行例化，因为后向重定时不需要额外的复位周期即可满足初始条件。

此实例使 Hyper-Retimer能够自动插入足够的流水线寄存器以满足时序要求。在这种情况下，由于数据不断变化，因此对延迟不敏感的伪路径是不合适的。

例化与复杂组合功能相邻的可变延迟

您可以实例化与复杂组合模块相邻的 hyperpipe_vlat模块，使 Hyper-Retimer能够插入足够的寄存器以满足时序要求。在复杂组合模块之后例化 hyperpipe_vlat模块，因为向后重定时(backwards retiming)不需要额外的复位周期来适应任何初始条件。您无法控制hyperpipe_vlat模块中的寄存器是否向前重定时到其后面的逻辑或向后重定时到组合模块中。

在独立功能模块之间例化可变延迟

您可以例化同一时钟域中的两个独立功能模块之间的 hyperpipe_vlat模块。此例化允许功能模块在布局期间展开(spread apart)，同时只在这些功能模块之间添加流水线级以满足时序要求。如果使用此方法，那么还必须添加一个伪路径(set_false_path)异常，此异常在 Hyper-Retimer运行之前处于活动状态。此异常允许连接的模块在布局期间浮动(float apart)。伪路径应用于hyperpipe_vlat模块中的 vlat_r寄存器。

下行命令显示了相应.sdc语句，在 my|top|design|hyperpipe_vlat_inst上对hyperpipe_vlat实例应用 set_false_path异常。对于连接到独立功能模块的hyperpipe_vlat实例，将类似的命令行添加到您的.sdc实例中：

If { ! [is_post_route] } { set_false_path -to my|top|design|hyperpipe_vlat_inst|vlat_r[*]

在例化独立功能模块之间的可变延迟时，使用 hyperpipe_vlat而没有相应的伪路径几乎没有任何益处。如果没有此约束，Hyper-Retimer在布局布线期间只能识别 hyperpipe_vlat中的单一流水线级。Hyper-Retimer仅在布局布线完成后添加额外的流水线级。Compiler倾向于将由单一流水线级连接的两个功能模块布局在一起，除非它们之间的路径被切断。在这种情况下，对延迟不敏感的伪路径是不合适的，因为此路径必须在两个不同的时钟域之间。此外，Hyper-Retimer未必对由延迟不敏感的伪路径切割的总线中的每个比特上插入相同数量的流水线级。

2.3.2.2.3. 第 3步：验证自动流水线插入选项

Enable Auto-Pipelining选项(HYPER_RETIMER_ENABLE_ADD_PIPELINING)被要求用于自动流水线插入，在 Intel Quartus Prime软件中是默认使能的。

按照下面步骤验证或者更改 Enable Auto-Pipelining设置：

1. 点击 Assignments > Settings > Compiler Settings > Advanced Settings(Fitter)。

2. 如要使用自动流水线插入，要确保 Enable Auto-Pipelining为On。您可以关闭此设置(Off)以防止在 hyperpipe_vlat模块的实例中添加更多的流水线级。

3. 点击OK。

或者，您可以通过直接指定.qsf中的如下语句来使能或者禁用此选项：

set_global_assignment -name HYPER_RETIMER_ENABLE_ADD_PIPELINING <ON|OFF>


S10HPHB | 2020.07.13


34


4. 要编程设计，请点击 Processing > Start Compilation。

2.3.2.2.4. (可选)无可变延迟模块的自动流水线插入

按照以下针对目标寄存器的步骤来选择使能自动流水线插入，而不使用可变延迟模块(hyperpipe_vlat)：

1. 要指定要插入的最大级数，请点击 Assignments > Assignment Editor，然后对Assignment Name选择Maximum Additional Pipelining，在 Value中输入最大数量的流水线, 在 To中输入到寄存器的层次路径。或者，将以下等效赋值语句添加到.qsf中。

set_instance_assignment -name HYPER_RETIMER_ADD_PIPELINING \ <maximum stages> -to <register path>

注意: 如果使用 altera_attribute语句在 RTL中嵌入赋值，而不是添加到.qsf，那么必须在 Verilog HDL和 VHDL中将数值指定为字符串。

2. 如要防止在自动流水线插入额外级之前进行总线优化，请指定 preserve pragma，并在Assignment Editor中将目标寄存器的Netlist Optimizations设置为Never Allow，或者使用以下.qsf赋值语句进行指定。如果自动流水线操作将额外级添加到总线的某些比特中(而不是全部比特)，那么在自动流水线操作之前对总线进行的任何优化都会对信号完整性产生影响。

set_instance_assignment -name \ ADV_NETLIST_OPT_ALLOWED NEVER_ALLOW -to <register path>

3. 要确保相关寄存器接收相同数量的额外流水线级，需要创建一个 assignment group以关联并分配组中的所有寄存器。如果没有定义 assignment group，那么组名称将自动生成，前缀为add_pipelining_group ，并且对 HYPER_RETIMER_ADD_PIPELINING指定的每个寄存器都将成为一组。

以下命令行显示了.qsf group assignment的语法：

set_instance_assignment -name \ HYPER_RETIMER_ADD_PIPELINING_GROUP <group name string> \ -to <register path>

2.3.3. 使用寄存器代替多周期异常

通常情况下，设计包含复杂组合逻辑的模块(例如 CRC和其他算术功能)，这些模块需要多个时钟周期进行处理。您可以通过多周期异常来约束这些模块，这些异常可以放松整个模块的时序要求。您可以在采用 Intel Hyperflex 体系结构 FPGA的设计中使用这些模块和约束。请参考多周期路径的设计考量部分来了解详细信息。

或者，您可以在模块中的适当位置插入多个寄存器阶段，Compiler自动对它们进行平衡。例如，如果您要流水线化一个 CRC功能，那么您不需要识别要寄存的最优分解和中间项。在输入和输出上添加寄存器，Compiler能够对它们进行平衡。

相关链接

• 优化多周期路径 (第 16页)



S10HPHB | 2020.07.13


35


2.4. Hyper-Optimization (优化 RTL)

通过 Hyper-Retiming，Fast Forward编译和 Hyper-Pipeline加速数据通路之后，设计可能仍然有控制逻辑的限制，例如长反馈循环和状态机。

为了克服这些限制，请使用功能上等效的前馈路径或者预计算路径，而不要使用较长的组合反馈路径。以下部分描述了针对各种设计结构的 Hyper-Optimization。与上一代高性能 FPGA相比，此操作可使 Intel Hyperflex 体系结构 FPGA的性能提高 2倍。

2.4.1. 一般优化技术

使用以下常规 RTL技术来对 Intel Hyperflex FPGA体系结构优化您的设计。

2.4.1.1. 香农分解(Shannon’s Decomposition)

Shannon分解作用于 Hyper-Optimization中。Shannon分解或者 Shannon扩展是分解Boolean函数的一种方法。函数可表达为 F = x.Fx + x′Fx′，其中 x.Fx和 x′Fx′是函数 F关于 x的正和负辅因数。可通过四个输入来分解一个函数，例如：(a, b, c, x) = x.(a, b, c, 1) +x′.F(a, b, c, 0)，如下图所示。在 Hyper-Optimization中，Shannon分解将 x信号推至逻辑的圆锥头，使 x信号成为通过逻辑圆锥的最快路径。x信号以其他所有信号为代价成为最快的路径。使用 Shannon分解也会加倍原始功能的面积成本。

图 38. 香农分解(Shannon’s Decomposition)

abcx

F

abc1

F

abc0

F

x

10

图 39. 香农分解逻辑减少

逻辑综合可以利用常量驱动输入，并略微减少辅因数，如下图所示。

abc1

F

abc0

F

x

10

abc F X

abc F X

x

10


S10HPHB | 2020.07.13


36


图 40. 重复的香农分解(Repeated Shannon’s Decomposition)下图显示了如何重复使用香农分解来分解具有一个以上的关键输入信号的函数，从而增加了面积成本。

abc F X

abc F X

x

10

ab F X

ab F X

x

10

ab F X

ab F X

x

10

c

10

香农分解是对环路的有效优化技术。当对环路中的逻辑执行香农分解时，环路中的逻辑移出环路。Compiler现在可以对移出环路的逻辑进行流水线化。

图 41. 香农分解前的环路实例

此图显示了一个环路，其中包括一个寄存器，四级组合逻辑和一个额外输入。在环路中添加寄存器会改变功能性，但通过执行香农分解可以将组合逻辑移出环路。

Cannot Be Pipelined

环路中的寄存器的输出是 0或 1。您可以对驱动环路中的寄存器的组合逻辑进行复制，将备份的输入连接到 0，另一个备份的输入连接到 1。

图 42. 香农分解后的环路实例

环路中的寄存器然后选择两个副本中的一个，如下图所示。

Can Be Pipelined

0

1

0

1

Cannot Be Pipelined

对环路中的逻辑执行香农分解可减少环路中逻辑的数量。Compiler现在可以对被移出环路的逻辑执行寄存器重定时或 Hyper-Pipelining，从而提高了电路性能。


S10HPHB | 2020.07.13


37


2.4.1.1.1. 香农分解实例(Shannon’s Decomposition Example)

示例电路根据与目标值的关系从 internal_total值加入或减去一个输入值。电路的核心是target_loop模块，如香农分解前的源代码 (第 38页)中所示。

实例-5: 香农分解前的源代码

module target_loop (clk, sclr, data, target, running_total);parameter WIDTH = 32;

input clk;input sclr;input [WIDTH-1:0] data; input [WIDTH-1:0] target; output [WIDTH-1:0] running_total;

reg [WIDTH-1:0] internal_total;

always @(posedge clk) begin if (sclr) begin internal_total <= 0; end else begin internal_total <= internal_total + ((( internal_total > target) ? -data:data)* (target/4)); endendassign running_total = internal_total;end module

此模块使用同步清零，基于建议来使能 Hyper-Retiming。

图 43 (第 38页)显示了在一个寄存器环(register ring)中例化的 target_loop模块的 FastForward Compile报告。

图 43. 香农分解前的 Fast Forward Compile报告

Hyper-Retiming通过在 Fast Forward Compile中添加一个流水线级报告关于 302 MHz。最后的 Fast Forward Limit行表示关键链是一个环路(loop)。检查关键链报告显示链段中存在重复结构。此重复结构在优化环路部分中显示为一个实例。

图 44 (第 39页)显示了在之前示例代码中实现表达式的结构。功能模块对应于比较，加法和乘法运算。每个算术模块名称中的零是网表中综合名称的一部分。零是因为模块是由综合创建的那些运算符的第一个零索引实例。


S10HPHB | 2020.07.13


38


图 44. 一个关键链子环路的单元

internal_total

LessThan0 Add0

Mult0

此表达式是香农分解的备选表达式。您可以同时进行以下两个计算，而不是执行与数据的正或负值的一个加法运算：

• internal_total - (data * target/4)

• internal_total + (data * target/4)

您可以使用比较表达式 internal_total > target的结果来选择要使用的计算结果。此代码的修改版本(使用 Shannon分解来实现 internal_total计算)如香农分解后的源代码 (第 39页)中所示。

实例-6: 香农分解后的源代码

module target_loop_shannon (clk, sclr, data, target, running_total); parameter WIDTH = 32;

input clk;input sclr;input [WIDTH-1:0] data;input [WIDTH-1:0] target;output [WIDTH-1:0] running_total;

reg [WIDTH-1:0] internal_total;wire [WIDTH-1:0] total_minus;wire [WIDTH-1:0] total_plus;

assign total_minus = internal_total - (data * (target / 4));assign total_plus = internal_total + (data * (target / 4));

always @(posedge clk) begin if (sclr) begin internal_total <= 0; end else begin internal_total <= (internal_total > target) ? total_minus:total_plus); endend

assign running_total = internal_total;endmodule

图 45 (第 39页)显示重新编译代码更改的设计后性能几乎翻倍。

图 45. 香农分解后的 Fast Forward汇总报告


S10HPHB | 2020.07.13


39


2.4.1.1.2. 对香农分解识别电路

香农分解是在那些可以重新安排很多输入来控制最终选择阶段的电路的良好解决方案。在重构逻辑以使用一组输入来控制选择阶段的同时要留意新的逻辑深度。理想情况下，到选择信号的逻辑深度类似于到选择器输入的逻辑深度。实际上，由于很难完美地平衡驱动每个逻辑云的输入数量，因此存在逻辑深度上的差异。

香农分解也是具有逻辑圆锥中的一个或两个信号(非常关键的信号)的电路的良好解决方案，其他的都是静态的，或者优先权很低。

香农分解能够导致显著的面积成本，特别是在函数很复杂时。如本文档所述，也存在较低面积成本的其他优化技术。

2.4.1.2. 时间域多路复用(Time Domain Multiplexing)

时间域多路复用通过使用多线程计算来提高电路吞吐量。这种技术也称作 C缓慢重定时(C-slowretiming)或者多线程处理(multithreading)。

时间域多路复用使用一组串联 C寄存器取代电路中的每个寄存器。每个额外的寄存器复制创建一个新的计算线程。通过设计的一次计算要求 C与原始电路一样多的时钟周期相乘。然而，Compiler能够重定时额外的寄存器以提高 fMAX一个 C因子。例如，您可以例化一个运行在 800 MHz的模块，而不是例化两个运行在 400 MHz的模块。

下图显示了 C缓慢重定时的进程，开始于一个初始电路。

图 46. C缓慢重定时起点

编辑 RTL设计，将每个寄存器(包括回路中的寄存器)替换为一组 C寄存器，每个独立计算线程有一个寄存器。

图 47. C缓慢重定时中间点此实例显示了每个寄存器被两个寄存器替换。

此时此刻编译电路。当 Compiler优化电路时，用附加寄存器执行重定时有更大的灵活性。

图 48. C缓慢重定时终点

除了用一组寄存器替换每个寄存器之外，还必须将多个输入数据流多路复用到模块中，并将输出流多路分解出此模块。当设计包含多个并行线程时使用时间域多路复用，为此回路限制每个线程。您优化的模块不能对延迟敏感。

2.4.1.3. 环路展开(Loop Unrolling)

环路展开将逻辑从环路中移出，然后移进前馈(feed-forward)流程。您能够使用额外的流水线级进一步优化逻辑。


S10HPHB | 2020.07.13


40


2.4.1.4. 循环流水线(Loop Pipelining)

循环是无所不在的，也是设计功能的组成部分。但是，循环是 Hyper-Retiming优化的限制因素。Compiler不能自动流水线化循环内的任何逻辑。在循环中添加或删除顺序单元可能会破坏设计的功能。

但是，您可以修改循环结构以使 Compiler能够插入流水线阶段，而不会更改设计的功能，如下面部分所示。正确地流水线化一个循环包括以下步骤：

1. 重构循环和非循环逻辑

2. 手动将流水线阶段添加到循环中

3. 级联循环逻辑

2.4.1.4.1. 回路流水线理论

下图显示了一个逻辑回路的定义。结果(Zn )是输入 Xn 函数和此输入的延迟版本。

图 49. 简单回路实例

f(.)

z-1

zn

Loop Logic

g

xn

Delay Element/Register

如果函数 f(.)满足交换性，关联性和分配性(例如，加法，XOR，最大值)，下图的等价性在数学上是可证明的。

图 50. 修改后的等效回路

f(.)

z-1

zn

Loop Logic

g

xn

Delay Element/Register

f(.)

z-1

zn

g

xn

Yn f(.)

f(.)

z-1

g2

f(.)

z-1

z-1gK-1

z-1

gK

Commutative: f(x,y) = f(y,x)Associative: f(f(x,y),z) = f(x,f(y,z))Distributive: f(g . x,y) = g . f(x,y/g)

2.4.1.4.2. 环路流水线演示

以下演示了用于优化实例设计中的累加器的正确环路流水线化。在最初的实现中，累加器数据输入in乘以 x，然后与之前的 out值相加，乘以 y。此演示使用以下技术来提高性能：


S10HPHB | 2020.07.13


41


1. 实现正向逻辑的分离

2. 重定时环路寄存器

3. 通过级联逻辑创建反馈环路等同

图 51. 原始环路结构

D QIN D Q OUT

y B

f(.)x

实例-7: 原始环路结构实例 Verilog HDL代码

module orig_loop_strct (rstn, clk, in, x, y, out); input clk, rstn, in, x, y; output out; reg out; reg in_reg;

always @ ( posedge clk ) if ( !rstn ) begin in_reg <= 1'b0; end else begin in_reg <= in; end

always @ ( posedge clk ) if ( !rstn ) begin out <= 1'b0; end else begin out <= y*out + x*in_reg; endendmodule //orig_loop_strct

优化的第一阶段是重写逻辑，从环路(loop)中移除尽可能多的逻辑，并创建一个正向逻辑模块。重写的目标是从反馈环路中去除尽可能多的工作。Compiler无法自动优化反馈环路中的任何逻辑。从环路中删除逻辑时，请考虑以下建议：

• 在环路之前评估尽可能多的决策并执行尽可能多的计算(不直接依赖环路值)。

• 在将逻辑传递到环路前首先将其传递到寄存器阶段。

重写逻辑之后，Compiler现在可以自由地重定时移动到正向路径上的逻辑。


S10HPHB | 2020.07.13


42


图 52. 从环路中分离出正向逻辑

D QIN D Q OUT

y

B

A

f(.)

x

D Q OUT

在下一个优化阶段，重定时环路寄存器，以确保设计功能与原始环路电路相同。

图 53. 重定时环路寄存器

D QIN

y

B

A

f(.)

x

D Q

D Q

Further Optimize

最后，通过高显边界中的逻辑来重复第一个优化步骤，从而进一步优化环路。


S10HPHB | 2020.07.13


43


图 54. 级联环路逻辑，Hyper-Retimer和综合优化的结果(四级优化)

D QIN

y

B

A

f(.)

x

SynthesisCollapsesMultipliers

out_

add1

_reg

4

out_add1

K = 4

y

B

y

B

y

B

D Q D Q D Q D Q

y

B

y

B

y

B

y

B

y

B

y

B

f(.)

f(.)

f(.)D Q OUT

out_add4out_

add1

_reg

3

out_

add1

_reg

2

out_

add1

_reg

1

实例-8: 四级优化实例 Verilog HDL代码

module cll_hypr_rtm_synopt ( rstn, clk, x, y, in, out); input rstn, clk, x, y, in;

output out; reg out;

reg in_reg;

wire out_add1; wire out_add2; wire out_add3; wire out_add4;

reg out_add1_reg1; reg out_add1_reg2; reg out_add1_reg3; reg out_add1_reg4;

always @ ( posedge clk ) if ( !rstn ) begin in_reg <= 0; end else begin in_reg <= in; end

always @ ( posedge clk ) if ( !rstn ) begin out_add1_reg1 <= 0; out_add1_reg2 <= 0; out_add1_reg3 <= 0; out_add1_reg4 <= 0;


S10HPHB | 2020.07.13


44


end else begin out_add1_reg1 <= out_add1; out_add1_reg2 <= out_add1_reg1; out_add1_reg3 <= out_add1_reg2; out_add1_reg4 <= out_add1_reg3; end

assign out_add1 = x*in_reg + ((((y*out_add1_reg4)*y)*y)*y);assign out_add2 = out_add1 + (y*out_add1_reg1);assign out_add3 = out_add2 + ((y*out_add1_reg2)*y);assign out_add4 = out_add3 + (((y*out_add1_reg3)*y)*y);

always @ ( posedge clk ) begin if ( !rstn ) out <= 0; else out <= out_add4;endendmodule //cll_hypr_rtm_synopt

2.4.1.4.3. 回路流水线和综合优化

回路流水线技术最初创建更多的逻辑来优化此回路，导致更少的器件资源。虽然这种技术在某些情况下可能会增加逻辑使用，但设计综合可以进一步减少优化期间的逻辑。

综合优化各种逻辑云。在前面的例子中，综合确保了包含 g*g*g*g的逻辑云小于实现模块 g的四个实例。这种尺寸的减小是因为 LUT实际上有六个输入，逻辑崩溃，共享一些 LUT。此外，Hyper-Retimer重定时此更小的逻辑云中和周围的寄存器，从而使得逻辑对时序要求更低。

2.4.1.5. 预计算

预计算是优化总体设计速度的最简单和最有利的技术之一。当面对关键逻辑时，要验证计算蕴涵的信号是否可用。要尽早计算信号，使这些计算保持在关键逻辑之外。

当试图保持关键逻辑在您的循环之外时，要首先尝试预计算。Compiler不能只使用 retiming来优化循环中的逻辑。Compiler不能将循环中的寄存器移出。Compiler不能将循环外的寄存器重定时到循环中。因此，要将逻辑保持在尽可能小的循环中，使其不会对 fMAX产生负面影响。

预计算之后，循环中的逻辑被最小化，并且设计预计算编码。计算在循环外执行，通过 pipelining和 retiming可以对计算进行优化。您不能移除循环，但可以更好地在设计速度上控制循环的效果。


S10HPHB | 2020.07.13


45


图 55. 使用昂贵的回路重构一个设计(Restructuring a Design with an Expensive Loop)

FIFO

readenExpensive

Calculation

Payload

Before Precomputation

FIFO

readenSimpleLogic

Payload

After Precomputation

SimpleLogicPort Count

PrecomputeNew Encoding

以下实例代码显示了一个类似问题。原始回路包含比较运算符。

StateJam:if (RetryCnt <=MaxRetry&&JamCounter==16) Next_state=StateBackOff; else if (RetryCnt>MaxRetry) Next_state=StateJamDrop; else Next_state=Current_state;

预计算 RetryCnt<=MaxRetry和 JamCounter==16的值从 StateJam循环中移除昂贵的计算，并使用简单的布尔计算进行替换。修改后的代码：

reg RetryCntGTMaxRetry;reg JamCounterEqSixteen; StateJam:if (!RetryCntGTMaxRetry && JamCounterEqSixteen) Next_state=StateBackOff; else if (RetryCntGTMaxRetry) Next_state=StateJamDrop; else Next_state=Current_state; always @ (posedge Clk or posedge Reset) if (Reset) JamCounterEqSixteen <= 0; else if (Current_state!=StateJam) JamCounterEqSixteen <= 0; else JamCounterEqSixteen <= (JamCounter == 15) ? 1:0; always @ (posedge Clk or posedge Reset) if (Reset) RetryCntGTMaxRetry <= 0; else if (Current_state==StateSwitchNext) RetryCntGTMaxRetry <= 0; else if (Current_state==StateJam&&Next_state==StateBackOff) RetryCntGTMaxRetry <= (RetryCnt >= MaxRetry) ? 1: 0;

2.4.2. 优化特定的设计结构

本节将介绍常见的性能瓶颈接口，并对每种情况给出了提高 fMAX性能的建议。


S10HPHB | 2020.07.13


46


2.4.2.1. 高速时钟域(High-Speed Clock Domains)

Intel Hyperflex 体系结构 FPGA支持超高速时钟域。Compiler使用可编程时钟树综合来最小化时钟插入延迟，降低动态功耗并在器件内核中提供时钟灵活性。

器件最小脉冲宽度约束可以限制 Intel Hyperflex 体系结构 FPGA时钟的最高性能。随着给定时钟路径上资源数量的增加，时钟脉冲上的不确定性和偏斜也随之增加。如果时钟不确定性超过目标器件的最小脉冲宽度，那么会降低最小可行时钟周期。这种影响是路径上总时钟插入延迟的一个功能。要为高速时钟域抵消这种影响，请使用 Chip Planner和 Timing Analyzer报告来优化设计中的时钟源布局。

如果报告指示长时钟布线的限制，那么需要调整时钟管脚约束或者使用 Clock Region或 LogicLock Region约束来限制更接近时钟源的扇出逻辑。使用 Clock Region约束来指定时钟扇区并优化时钟树的大小。

进行约束变更后，重新编译设计并查看时钟布线长度和时钟树大小。查看 Compilation Report以确保时钟网络不会限制设计的性能。

2.4.2.1.1. 可视化时钟网络

运行 Fitter后，在 Chip Planner中可视化时钟网络实现。Chip Planner显示源时钟管脚位置，时钟布线，时钟树大小和时钟扇区边界(clock sector boundary)。使用这些视图进行调整并减少总时钟树大小。

在 Chip Planner中可视化设计时钟网络：

1. 打开一个工程。

2. 在 Compilation Dashboard上，点击 Fitter，Early Place，Place，Route或者Retime来运行 Fitter。

3. 在 Tasks窗格上，双击 Chip Planner。Chip Planner加载器件选项并显示彩色编码的芯片资源。

4. 在 Chip Planner Tasks窗格上，点击 Report Clock Details。Chip Planner高亮显示时钟管脚位置，布线和扇区边界。点击 Clock Details Report下的单元以显示单元的常规和扇出详细信息。

5. 要可视化时钟扇区边界，点击 Layers Settings标签，然后使能 Clock Sector Region。绿线表示每个扇区的边界。


S10HPHB | 2020.07.13


47


图 56. Chip Planner中的时钟网络

Source Clock Pin

Clock Routing Path

Clock Tree Region

图 57. Chip Planner中的时钟扇区边界


S10HPHB | 2020.07.13


48


2.4.2.1.2. 查看 Fitter报告中的时钟网络

Compilation Report提供 Fitter布局后的时钟网络实现的详细信息。查看 Global & Other FastSignals Details报告，显示从源时钟管脚到时钟树的时钟路径的长度和深度。

查看 Fitter报告中的时钟网络实现


2. 在 Compilation Dashboard上，点击 Fitter，place，Route来运行 Fitter。

3. 在 Compilation Dashboard上，点击完成阶段的 Report图标。

4. 点击 Global & Other Fast Signals Details。此表显示了从源到时钟树的时钟布线的长度和时钟域深度。

图 58. Fitter报告中的时钟网络详情

2.4.2.1.3. 在 Timing Analyzer中查看时钟

Timing Analyzer报告受长时钟路径限制的高速时钟。打开 Fmax Summary报告来查看受高最小脉冲宽度违规(high minimum pulse width violations)(tCH)或者低最小脉冲宽度违规(lowminimum pulse width violation)(tCL)限制的任何时钟 fMAX。

在 Timing Analyzer中查看时钟网络数据：


2. 在 Compilation Dashboard上点击 Timing Analysis。时序分析完成后，TimingAnalyzer文件夹出现在 Compilation Report中。

3. 在 Slow 900mV 100C Model文件夹下，点击 Fmax Summary报告。


S10HPHB | 2020.07.13


49


4. 要查看最小脉冲宽度违规的详细路径信息，在 Compilation Report中右击MinimumPulse Width Summary报告，然后点击 Generate Report in Timing Analyzer。Timing Analyzer加载时序网表。

5. 点击 Reports > Custom Reports > Report Minimum Pulse Width。

6. 在 Report Minimum Pulse Width对话框中，指定用于自定义报告输出的选项，然后单击OK。

7. 在 Slow 900mV 100C Model报告中查看长时钟布线报告的数据通路详细信息。

图 59. 最小脉冲宽度详情显示长时钟布线

Reports show long clock delay

2.4.2.2. 重构回路(Restructuring Loops)

由于回路从根本上限制了性能，因此回路是重构技术的主要目标。回路是电路中的反馈路径。一些回路是简单并且短的，在反馈路径上有很少的组合逻辑。而另一些回路要复杂得多，在回到原始寄存器的途中可能会经过其他多个寄存器。所有有用的电路都包含回路。

Compiler从不将寄存器重定时到回路中，因为在回路中添加流水线阶段会改变功能。然而，通过手动更改 RTL来重构回路可以提高性能。通过 Fast Forward compile分析性能瓶颈后执行回路优化，对您设计中的新 RTL也应用这些技术。


S10HPHB | 2020.07.13


50


2.4.2.3. 控制信号反压(Control Signal Backpressure)

本节介绍了用于控制信号反压(signal backpressure)的 RTL设计技术。 Intel Hyperflex 体系结构有效地传输数据。由于这种体系结构支持超高时钟速率，因此很难在一个时钟周期内发送反馈信号以实现大量逻辑。插入额外的流水线寄存器也会增加控制信号的反压。数据必须尽可能向前流动。

单时钟周期控制信号创建能够防止或降低流水线和寄存器重计时的有效性的环路。此实例显示了一个 ready信号，此信号通知上游寄存器准备使用数据。ready信号必须同时冻结多个数据源。

图 60. 控制信号反压(Control Signal Backpressure)

I Am Not Ready for the Next Data

修改原始的 RTL以添加一个可以缓解压力上游的小型 FIFO缓冲器是一个简单直接的方法。当此模块的逻辑下游没有准备好使用数据时，FIFO存储此数据。

图 61. 使用 FIFO缓冲器来控制反压This Is Valid Data

FIFOBuffer

Please Try to Slow Down Soon

目标是每个时钟周期数据都能到达 FIFO缓冲器。一个额外比特的信息决定了数据是否是有效的和是否应该存储在 FIFO缓冲器中。关键信号现在位于 FIFO缓冲器和消耗数据的下游寄存器之间。此环路要小得多。现在，您可以使用流水线和寄存器重计时来优化 FIFO寄存器的上游部分。

2.4.2.4. 使用 FIFO状态信号的流程控制

在处理流程控制信号时需要考虑高时钟速度。对于同时在多个位置门控一个数据通路的信号而言，此考虑因素是尤为重要的，例如，使用时钟使能信号或 FIFO full或 empty信号。使用一个延迟的信号来替代实时控制信号。您可以在 FIFO模块中构建一个缓冲器。控制信号对上游数据通路表明它几乎变满，对于上游数据还有几个时钟周期来接收其门控信号。此方法减缓了对控制信号的时序收敛困难。

当使用 FIFO满和空信号时，为防止上溢或下溢，您必须在一个时钟周期内处理这些信号。

图 62. FIFO流程控制回路从 FIFO中读取控制信号的同时形成回路。

FIFO

readempty

data

read_reqempty


S10HPHB | 2020.07.13


51


如果使用一个 almost full或者 almost empty信号，那么您可以在流程控制回路中添加流水线寄存器。如果 almost full阈值越低，并且 almost empty阈值越高，那么可添加到信号的寄存器就越多。

图 63. 通过使用 Almost Full替代 Full FIFO而改进的 FIFO流控制回路下面实例显示了完全控制流程信号中的两个额外的寄存器。FIFO生成 almost full标志后，信号要经过两个周期达到 dataproducer模块。在已发送的数据停止到达 FIFO之前需要两个额外的周期。这种情况会导致四个周期的延迟。只要 almost full标志被置位，data producer就能在 FIFO变慢之前再发送 4个字。测量 FIFO模块大小，以确保这些额外有效数据的正确存储。控制路径中的两个额外流水线寄存器有助于布线，并且实现比使用传统的单周期 FIFO控制方案更高的速度。

DataProducer

FIFO

FIFO Full

DataProducer

FIFO

FIFO Almost Full

2.4.2.5. 包含 skid缓冲器的流程控制

您可以使用 skid缓冲器来对 FIFO进行流水线化。如果必要，您可以级联 skid缓冲器。当插入skid缓冲器时，它们展开了包括 FIFO控制信号的环路。skid缓冲器不会消除流控逻辑中的环路，但是环路变换成一系列更短的环路。一般情况下，要尽可能地切换到 almost empty和 almostfull信号，而不是使用 skid缓冲器。

图 64. 读控制中有两个 skid缓冲器的 FIFO流控环路

FIFO

empty

data

empty

readread_req

Skid Buffer #1 Skid Buffer #2

如果环路包含 FIFO控制信号，并且这些 FIFO控制信号广播到很多目的地以用于流控，那么您要仔细考虑是否有消除这些广播信号的方法。对广播控制信号进行流水线化，并使用 FIFO的 almostfull和 almost empty状态比特。

实例-9: Skid Buffer示例(单时钟)

/ synopsys translate_off//`timescale 1 ps / 1 ps// synopsys translate_on

module singleclock_fifo_lowell#(

parameter DATA_WIDTH = 8, parameter FIFO_DEPTH = 16, parameter SHOWAHEAD = "ON", // "ON" = showahead mode ('pop' is an acknowledgement); / "OFF" = normal mode ('pop' is a request). parameter RAM_TYPE = "AUTO", // "AUTO" or "MLAB" or "M20K".


S10HPHB | 2020.07.13


52


// Derived parameter ADDR_WIDTH = $clog2(FIFO_DEPTH) + 1 // e.g. clog2(64) = 6, but 7 bits / needed to store 64 value) ( input wire clk, input wire rst, input wire [DATA_WIDTH-1:0] in_data, // write data input wire pop, // rd request input wire push, // wr request output wire out_valid, // not empty output wire in_ready, // not full output wire [DATA_WIDTH-1:0] out_data, // rd data output wire [ADDR_WIDTH-1:0] fill_level); wire scfifo_empty; wire scfifo_full; wire [DATA_WIDTH-1:0] scfifo_data_out; wire [ADDR_WIDTH-1:0] scfifo_usedw;

logic [DATA_WIDTH-1:0] out_data_1q; logic [DATA_WIDTH-1:0] out_data_2q; logic out_empty_1q; logic out_empty_2q; logic e_pop_1; logic e_pop_2; logic e_pop_qual; assign out_valid = ~out_empty_2q; assign in_ready = ~scfifo_full; assign out_data = out_data_2q; assign fill_level = scfifo_usedw + !out_empty_1q + !out_empty_2q;

// add output pipe assign e_pop_1 = out_empty_1q || e_pop_2; assign e_pop_2 = out_empty_2q || pop; assign e_pop_qual = !scfifo_empty && e_pop_1; always_ff@(posedge clk) begin if(rst == 1'b1) begin out_empty_1q <= 1'b1; // empty is 1 by default out_empty_2q <= 1'b1; // empty is 1 by default end else begin if(e_pop_1) begin out_empty_1q <= scfifo_empty; end if(e_pop_2) begin out_empty_2q <= out_empty_1q; end end end always_ff@(posedge clk) begin if(e_pop_1) out_data_1q <= scfifo_data_out; if(e_pop_2) out_data_2q <= out_data_1q; end

scfifo scfifo_component ( .clock (clk), .data (in_data),

.rdreq (e_pop_qual), .wrreq (push),


S10HPHB | 2020.07.13


53


.empty (scfifo_empty), .full (scfifo_full), .q (scfifo_data_out), .usedw (scfifo_usedw),// .aclr (rst), .aclr (1'b0), .almost_empty (), .almost_full (), .eccstatus (), //.sclr (1'b0) .sclr (rst) // switch to sync reset ); defparam scfifo_component.add_ram_output_register = "ON", scfifo_component.enable_ecc = "FALSE", scfifo_component.intended_device_family = "Stratix", scfifo_component.lpm_hint = (RAM_TYPE == "MLAB") ? "RAM_BLOCK_TYPE=MLAB" : / ((RAM_TYPE == "M20K") ? "RAM_BLOCK_TYPE=M20K" : ""), scfifo_component.lpm_numwords = FIFO_DEPTH, scfifo_component.lpm_showahead = SHOWAHEAD, scfifo_component.lpm_type = "scfifo", scfifo_component.lpm_width = DATA_WIDTH, scfifo_component.lpm_widthu = ADDR_WIDTH, scfifo_component.overflow_checking = "ON", scfifo_component.underflow_checking = "ON", scfifo_component.use_eab = "ON";

endmodule

实例-10: Skid Buffer示例(双时钟)

// synopsys translate_off//`timescale 1 ps / 1 ps// synopsys translate_on

module skid_dualclock_fifo#(

parameter DATA_WIDTH = 8, parameter FIFO_DEPTH = 16, parameter SHOWAHEAD = "ON", parameter RAM_TYPE = "AUTO", // "AUTO" or "MLAB" or "M20K". // Derived parameter ADDR_WIDTH = $clog2(FIFO_DEPTH) + 1 ) ( input wire rd_clk, input wire wr_clk, input wire rst, input wire [DATA_WIDTH-1:0] in_data, // write data input wire pop, // rd request input wire push, // wr request output wire out_valid, // not empty output wire in_ready, // not full output wire [DATA_WIDTH-1:0] out_data, // rd data output wire [ADDR_WIDTH-1:0] fill_level); wire scfifo_empty; wire scfifo_full; wire [DATA_WIDTH-1:0] scfifo_data_out; wire [ADDR_WIDTH-1:0] scfifo_usedw;

logic [DATA_WIDTH-1:0] out_data_1q; logic [DATA_WIDTH-1:0] out_data_2q; logic out_empty_1q; logic out_empty_2q; logic e_pop_1;


S10HPHB | 2020.07.13


54


logic e_pop_2; logic e_pop_qual; assign out_valid = ~out_empty_2q; assign in_ready = ~scfifo_full; assign out_data = out_data_2q; assign fill_level = scfifo_usedw + !out_empty_1q + !out_empty_2q;

// add output pipe assign e_pop_1 = out_empty_1q || e_pop_2; assign e_pop_2 = out_empty_2q || pop; assign e_pop_qual = !scfifo_empty && e_pop_1; always_ff@(posedge rd_clk) begin if(rst == 1'b1) begin out_empty_1q <= 1'b1; // empty is 1 by default out_empty_2q <= 1'b1; // empty is 1 by default end else begin if(e_pop_1) begin out_empty_1q <= scfifo_empty; end if(e_pop_2) begin out_empty_2q <= out_empty_1q; end end end always_ff@(posedge rd_clk) begin if(e_pop_1) out_data_1q <= scfifo_data_out; if(e_pop_2) out_data_2q <= out_data_1q; end dcfifo dcfifo_component ( .data (in_data), .rdclk (rd_clk), .rdreq (e_pop_qual), .wrclk (wr_clk), .wrreq (push), .q (scfifo_data_out), .rdempty (scfifo_empty), .rdusedw (scfifo_usedw), .wrfull (scfifo_full), .wrusedw (), .aclr (1'b0), .eccstatus (), .rdfull (), .wrempty () ); defparam dcfifo_component.add_usedw_msb_bit = "ON", dcfifo_component.enable_ecc = "FALSE", dcfifo_component.intended_device_family = "Stratix 10", dcfifo_component.lpm_hint = (RAM_TYPE == "MLAB") \ ? "RAM_BLOCK_TYPE=MLAB" : ((RAM_TYPE == "M20K") \ ? "RAM_BLOCK_TYPE=M20K" : ""), dcfifo_component.lpm_numwords = FIFO_DEPTH, dcfifo_component.lpm_showahead = SHOWAHEAD, dcfifo_component.lpm_type = "dcfifo", dcfifo_component.lpm_width = DATA_WIDTH, dcfifo_component.lpm_widthu = ADDR_WIDTH+1, dcfifo_component.overflow_checking = "ON", dcfifo_component.read_aclr_synch = "ON", dcfifo_component.rdsync_delaypipe = 5, dcfifo_component.underflow_checking = "ON", dcfifo_component.write_aclr_synch = "ON",


S10HPHB | 2020.07.13


55


dcfifo_component.use_eab = "ON", dcfifo_component.wrsync_delaypipe = 5;

endmodule

2.4.2.6. Read-Modify-Write存储器

Intel Hyperflex 体系结构 FPGA M20K存储器模块支持一致性读取(coherent read)以简化实现read-modify-write存储器。read-modify-write在诸如网络统计计数器之类的应用中很有用。对于将一个值存储在存储器中的应用，read-modify-write存储器也是很有用的，这类应用要求在单一周期内递增和重写。

M20K存储模块通过消除对手写高速缓存电路的需求而简化了实现。由于高时钟速度或者大型计数器，在多个时钟周期上对修改操作进行流水线化的高速缓存电路变得复杂。

要使用一致性读取功能，需根据是否寄存输出数据端口来连接存储器。如果寄存输出数据端口，则要在例化存储器时将两个寄存器阶段添加到写使能和写地址行。

图 65. 寄存的输出数据需要两个寄存器阶段

M20K Memorywith CoherentRead Feature

operand

readaddress

wen

writeaddress

writedata

readdata

如果没有寄存输出数据端口，那么要在例化存储器时将一个寄存器阶段添加到写使能和写地址行。


S10HPHB | 2020.07.13


56


图 66. 寄存的输出数据需要一个寄存器阶段

M20K Memorywith CoherentRead Feature

operand

readaddress

wen

writeaddress

writedata

readdata

一致性读取(coherent read)的使用有如下限制：

• 必须使用相同的时钟进行读写。

• 必须对读端口和写端口使用相同的宽度。

• 不能使用 ECC。

• 不能使用字节使能。

图 67 (第 57页)显示了 read-modify-write存储器的流水线方法，此方法可以提高性能，而无需维护用于跟踪最近活动的高速缓存。

图 67. 流水线化 Read-Modify-Write存储器


S10HPHB | 2020.07.13


57


如果您需要与一致性读取不兼容的M20K存储器功能，或者如果您不想使用一致性读取，那么请使用以下替代方法来提高存储器的 fMAX性能：

• 将修改操作分成能够在一个周期内完成的更小模块。

• 确保每个块(chunk)不能宽于一个M20K存储器模块。Compiler将数据字分成多个 n-bit块(chunk)，其中每个块(chunk)都足够小，以便在一个时钟周期内进行高效处理。

• 要增加 fMAX，则需要增加存储器模块的数量，使用更窄的存储器模块并增加延迟。要降低延迟，则需要使用更少，更宽的存储器模块，并且适当地移除流水线级。由于 read-modify-write电路的性质，read-modify-write电路中的环路是不可避免的，但此解决方案中的环路小而短。此解决方案是可伸缩的，因为无论流水线级的数量是多少，基本结构总保持不变。

2.4.2.7. 计数器和累加器

受性能限制的环路很少出现在小型简单的计数器中。具有非自然翻转条件(不是 2的幂)或者不规则递增的计数器更可能具有受性能限制的关键链。当一个受性能限制的环路出现在一个小型计数器(大概 8比特或更少)中时，要将计数器作为一个完全解码的状态机来进行写操作，这取决于控制计数器的所有输入。计数器仍然包含环路，但它们会更小，而且是不受性能限制的。当计数器很小(大概 8比特或更少)时，Fitter会实现单一 LAB中的计数器。由于所有逻辑都并拢布置在一块，所有此实现使计数器运行很快。

您也可以使用环路展开(loop unrolling)来提高计数器性能。

图 68. 计数器和累加器环路

在计数器和累加器环路中，寄存器的新值取决于其旧值。这包括诸如 LFSR (线性反馈移位寄存器)和格雷码计数器的变体。

Counter

+1

Accumulator

2.4.2.8. 状态机

与状态机关联的回路难以优化。仔细检查状态机逻辑，决定是否能够预计算下一个状态逻辑使用的任何信号。

为有效地对状态机回路进行流水线化，要考虑将跳过状态添加到状态机中。跳过状态是添加的状态，允许两个相邻状态之间更长的跳变时间。

状态机循环的优化可能需要一个新的状态机。


S10HPHB | 2020.07.13


58


图 69. 状态机回路

在状态机回路中，下一状态取决于电路的当前状态。

S0

S1

S2S3

S4

相关链接


• 预计算 (第 45页)

2.4.2.9. 储存器

本节涵盖了关于优化 Intel Hyperflex 体系结构 FPGA中硬核存储器模块的各个主题。

2.4.2.9.1. Intel Hyperflex 体系结构真双端口存储器

Intel Hyperflex 体系结构支持真双端口存储器结构。真双端口存储器支持同时进行两个写操作和两个读操作。

与以前的 Intel FPGA技术相比， Intel Hyperflex 体系结构嵌入式存储器组件(M20K)的操作模式略有不同，包括用于读/写访问的混合宽度比率。

Intel Hyperflex 体系结构支持独立时钟模式下的真双端口存储器。在此模式下使用存储器时，与此存储器相关的最大 fMAX为 600 MHz。

2.4.2.9.2. 使用简单双端口存储器

将一个设计移植到 Intel Hyperflex 体系结构中时，请考虑原始设计是否包含一个双端口存储器(在每个端口上使用不同的时钟)以及运行该存储器的最大频率。如果您的设计实际上在两个写端口上使用相同的时钟那么需要使用两个简单双时钟存储器对其进行重组。

此方法的优势在于简单双端口模块支持高达 1 GHz的频率。其劣势是实现存储器所需要的存储器模块的数量增加了一倍。


S10HPHB | 2020.07.13


59


图 70. Intel Arria 10真双端口存储器实现之前版本的 Intel Quartus Prime Pro Edition软件对 Intel Arria 10器件生成这一真双端口存储器结构。

实例-11: 双端口，双时钟存储器实现

module true_dual_port_ram_dual_clock#(parameter DATA_WIDTH=8, parameter ADDR_WIDTH=6)( input [(DATA_WIDTH-1):0] data_a, data_b, input [(ADDR_WIDTH-1):0] addr_a, addr_b, input we_a, we_b, clk_a, clk_b, output reg [(DATA_WIDTH-1):0] q_a, q_b);

// Declare the RAM variable reg [DATA_WIDTH-1:0] ram[2**ADDR_WIDTH-1:0];

always @ (posedge clk_a) begin // Port A if (we_a) begin ram[addr_a] <= data_a; q_a <= data_a; end else begin q_a <= ram[addr_a]; end end

always @ (posedge clk_b) begin // Port B if (we_b) begin ram[addr_b] <= data_b; q_b <= data_b; end else begin q_b <= ram[addr_b]; end end

endmodule


S10HPHB | 2020.07.13


60


对使用不同写时钟的双端口存储器进行同步是很困难的。要确保两个端口不要同时对一个指定地址进行写操作。在很多设计中，双端口存储器通常对其中一个端口执行写操作，然后是使用这两个端口(1W2R)的两个读操作。您可以通过使用两个简单双端口存储器模型化此行为。在简单双端口存储器中，写操作总是写入两个存储器，而读操作取决于端口。

2.4.2.9.3. Intel Hyperflex 体系结构简单双端口存储器示例

使用两个简单的双端口存储器可以将器件中的M20K模块的使用率翻倍。然而，此存储器结构可以在高达 1 GHz的频率上运行。当在 Intel Hyperflex 体系结构 FPGA中使用包括独立时钟的真双端口存储器时，此频率是不可能的。

图 71. 简单双端口存储器实现

通过推断 RTL中的简单双端口存储器可以实现类似的频率结果，而不是通过 Intel Quartus PrimeIP parameter editor中的实例来实现类似的频率结果。

实例-12: 简单双端口 RAM接口

module simple_dual_port_ram_with_SDPs#(parameter DATA_WIDTH=8, parameter ADDR_WIDTH=6)( input [(DATA_WIDTH-1):0] wrdata, input [(ADDR_WIDTH-1):0] wraddr, rdaddr, input we_a, wrclock, rdclock, output reg [(DATA_WIDTH-1):0] q_a);

// Declare the RAM variablereg [DATA_WIDTH-1:0] ram[2**ADDR_WIDTH-1:0];

always @ (posedge wrclock)begin // Port A is for writing only if (we_a) begin ram[wraddr] <= wrdata; end


S10HPHB | 2020.07.13


61


end

always @ (posedge rdclock)begin// Port B is for reading onlybeginq_a <= ram[rdaddr];endendendmodule

实例-13: 真双端口 RAM行为仿真

module test (wrdata, wraddr, rdaddr_a, rdaddr_b, clk_a, clk_b, we_a, q_a, q_b); input [7:0] wrdata; input clk_a, clk_b, we_a; input [5:0] wraddr, rdaddr_a, rdaddr_b; output [7:0] q_a, q_b; simple_dual_port_ram_with_SDPs myRam1 ( .wrdata(wrdata), .wraddr(wraddr), .rdaddr(rdaddr_a), .we_a(we_a), .wrclock(clk_a), .rdclock(clk_b), .q_a(q_a) );

simple_dual_port_ram_with_SDPs myRam2 ( .wrdata(wrdata), .wraddr(wraddr), .rdaddr(rdaddr_b), .we_a(we_a), .wrclock(clk_a), .rdclock(clk_a), .q_a(q_b) ); endmodule

2.4.2.9.4. 存储器混合端口宽度比率限制

Intel Hyperflex 体系结构 FPGA器件模块 RAM支持高达 1GHz的时钟速度。相对于混合端口数据宽度的使用，新的 RAM模块设计更具限制性。 Intel Hyperflex 体系结构 FPGA器件模块 RAM不支持 1/32，1/16和 1/8混合端口比率。有效的比率为 1，½和¼混合端口比率。Compiler会对无效的混合端口比率的实现生成错误消息。

当移植一个对 Intel Hyperflex 体系结构 FPGA使用无效端口宽度比率的设计时，需要修改 RTL来创建所需的比率。


S10HPHB | 2020.07.13


62


图 72. 无效的 1/8混合端口比率的双端口存储器

要创建一个在功能上等效的设计，请创建并合并具有有效混合端口宽度比率的较小存储器。例如，以下步骤实现了一个混合端口宽度比率：

1. 通过从 IP Catalog例化 2-Ports存储器 IP Core来创建两个具有¼混合端口宽度比率的存储器。

2. 定义写使能逻辑来对两个存储器进行交替写操作。

3. 交错存储器的输出来重构一个 1/8比率输出。

图 73. 1/8宽度比率实例

此实例显示了两个存储器的写逻辑的交错。所选择的写逻辑使用写地址的最低有效位来决定要写入的存储器。偶数地址写入到存储器 mem_A中，奇数地址写入到存储器 mem_B中。

由于用于控制写入到存储器的方案，在写操作期间谨慎地构建完整的 64-bit输出。您必须要考虑到在两个存储器中的单独 8-bit字的交错。


S10HPHB | 2020.07.13


63


图 74. 存储器输出解扰实例

此实例显示了当试图在地址 0h0上进行读操作时的已解扰输出。

下面的 RTL实例实现了额外的阶段来对读一侧的存储器进行数据解扰。

实例-14: 顶层解扰 RTL代码

module test #( parameter WR_DATA_WIDTH = 8, parameter RD_DATA_WIDTH = 64, parameter WR_DEPTH = 64, parameter RD_DEPTH = 4, parameter WR_ADDR_WIDTH = 6, parameter RD_ADDR_WIDTH = 4)( data, wraddress, rdaddress, wren, wrclock, rdclock, q);

input [WR_DATA_WIDTH-1:0] data;input [WR_ADDR_WIDTH-1:0] wraddress;input [RD_ADDR_WIDTH-1:0] rdaddress;input wren;input wrclock;input rdclock;output [RD_DATA_WIDTH-1:0] q;

wire wrena, wrenb;wire [(RD_DATA_WIDTH/2)-1:0] q_A, q_B;

memorySelect memWriteSelect ( .wraddress_lsb(wraddress[0]), .wren(wren), .wrena(wrena), .wrenb(wrenb));

myMemory mem_A ( .data(data), .wraddress(wraddress), .rdaddress(rdaddress), .wren(wrena), .wrclock(wrclock), .rdclock(rdclock), .q(q_A));

myMemory mem_B ( .data(data),


S10HPHB | 2020.07.13


64


.wraddress(wraddress), .rdaddress(rdaddress), .wren(wrenb), .wrclock(wrclock), .rdclock(rdclock), .q(q_B));

descrambler #( .WR_WIDTH(WR_DATA_WIDTH), .RD_WIDTH(RD_DATA_WIDTH)) outputDescrambler ( .qA(q_A), .qB(q_B), .qDescrambled(q));

endmodule

实例-15: 支持的 RTL代码

module memorySelect (wraddress_lsb, wren, wrena, wrenb); input wraddress_lsb; input wren; output wrena, wrenb;

assign wrena = !wraddress_lsb && wren; assign wrenb = wraddress_lsb && wren;endmodule

module descrambler #( parameter WR_WIDTH = 8, parameter RD_WIDTH = 64) ( input [(RD_WIDTH/2)-1 : 0] qA, input [(RD_WIDTH/2)-1 : 0] qB, output [RD_WIDTH:0] qDescrambled);

genvar i; generate for (i=WR_WIDTH*2; i<=RD_WIDTH; i += WR_WIDTH*2) begin: descramble assign qDescrambled[i-WR_WIDTH-1:i-(WR_WIDTH*2)] = qA[(i/2)-1:(i/2)-WR_WIDTH]; assign qDescrambled[i-1:i-WR_WIDTH] = qB[(i/2)-1:(i/2)-WR_WIDTH]; end endgenerate

endmodule

2.4.2.9.5. 未寄存的 RAM输出

要实现最高性能，需要在使用任何组合逻辑中的数据之前寄存存储器模块的输出。直接通过未寄存的存储器输出来驱动组合逻辑能够导致一条包含不足寄存器的关键链。

如果使用 read-during-write新数据模式来实现 RAM，那么您会无意识地使用未寄存的存储器输出，随后是组合逻辑。Compiler通过用于比较读写地址的存储器模块外的软核逻辑来实现此模式。此模式多路复用直接写入到输出的数据。如果想要实现最高性能，那么就不要使用 read-during-write新数据模式。

2.4.2.10. DSP模块

DSP模块支持高达 1 GHz的频率，但必须使用所有的寄存器，包括输入寄存器，两个阶段的流水线寄存器和输出寄存器。


S10HPHB | 2020.07.13


65


2.4.2.11. 一般逻辑

避免使用单行逻辑功能，单行逻辑功能结构上是合理的，但会生成多个层级的逻辑。唯一的例外是在任意一侧添加几个流水线寄存器，以便 Hyper-Retiming能够通过逻辑的云来重定时。

2.4.2.12. 求模与除法

求模和除法运算符在器件面积和速度性能方面的成本是很高的，除非使用二次幂。如果可能，使用一个可以避免求模或除法运算符的实现。循环排程器(Round Robin Scheduler)章节介绍了一个使用简单移位(simple shift)来替换求模运算符的方法，在性能上实现了显著的提高。

2.4.2.13. 复位

在监控逻辑中对有回路的电路使用复位，以检测错误条件，并对复位条件进行流水线化。

2.4.2.14. 硬件重用

要解决由硬件重用造成的回路，则需要展开回路。

2.4.2.15. 算法要求

这些回路可能会很难改进，但有时能够使用常规优化技术部分中所介绍的优化技术组合进行改进。

2.4.2.16. FIFO

FIFO中总是包含回路。有一些有效方法用于实现内部 FIFO逻辑来实现杰出性能。

FIFO的特性之一是旁路模式，在此模式下，当 FIFO为空时，数据完全旁路内部存储器。如果在任何 FIFO中实现此模式，那么要对未寄存的存储器输出所固有的性能限制做到心中有数。

2.4.2.17. 三元加法器(Ternary Adders)

实现三元加法器可以增加 Intel Hyperflex 体系结构 FPGA中的资源利用率。但是，除非您的设计严重依赖于三元加法器结构，否则在顶层设计级别可能不会注意到额外的资源使用情况。但是，对添加三元加法器结构的设计级别进行的检查可能会显示 LUT数量增加。另外，资源增加的数量与加法器的大小直接相关。较小宽度加法器(尺寸<16比特)不会造成很大的资源差异。但是，与旧的FPGA技术相比，增加加法器的尺寸会增加资源计数的差异。

三元加法器 RTL代码

module ternary_adder (CLK, A, B, C, OUT); parameter WIDTH = 16; input [WIDTH-1:0] A, B, C; input CLK; output [WIDTH-1:0] OUT;

wire [WIDTH-1:0] sum1; reg [WIDTH-1:0] sumreg1;

// 3-bit additions assign sum1 = A + B + C; assign OUT = sumreg1;

// Registers always @ (posedge CLK) begin


S10HPHB | 2020.07.13


66


sumreg1 <= sum1; endendmodule

器件资源使用量的增加是因为 Intel Hyperflex 体系结构 ALM没有以前的 FPGA技术所具有的共享算术模式。共享算术模式下的 ALM可以在 ALM中实现三输入加法。相比之下， IntelHyperflex 体系结构 ALM只能在 ALM中实现两输入加法。

图 75. 从一个 three 8-bit输入加法器加入 2个 LSB的 Intel Arria 10与 Intel Hyperflex 体系结构 FPGA的 RTL视图

D Q

D Q

CLK

A[0]B[0]C[0]

A[1]B[1]C[1]

Sumreg[0]

Sumreg[1]

Intel Arria 10 FPGAs

D Q

D Q

CLKA[0]B[0]

C[0]

A[1]B[1]

C[1]

Sumreg[0]

Sumreg[1]

Intel Stratix 10 FPGAs

在共享算术模式下， Intel Arria 10 ALM支持三输入加法器使用三个自适应 LUT (ALUT)输入：CIN，SHAREIN，COUT，SUMOUT和 SHAREOUT。缺少共享算术模式会限制 ALM仅使用两个ALUT输入：CIN，COUT和 SUMOUT。下图显示了在 Intel Arria 10和 Intel Hyperflex 体系结构 FPGA上的三元加法器的实现结果。

图 76. Intel Arria 10: ALM用于从 three 8-bit input adder加 2个 LSB

Technology Map Viewer (Intel Arria 10 Design)

Chip Planner


S10HPHB | 2020.07.13


67


图 77. Intel Hyperflex 体系结构 FPGA：ALM用于从一个 three 8-bit输入加法器加入 2个 LSB

Technology Map Viewer (Intel Stratix 10 Design)

Chip Planner


S10HPHB | 2020.07.13


68


3. 编译 Intel Hyperflex 体系结构设计

Intel Quartus Prime Pro Edition Compiler经过优化可充分利用 Intel Hyperflex 体系结构。Intel Quartus Prime Pro Edition Compiler支持 Hyper-Aware设计流程，在此流程中Compiler自动对到 Hyper-Registers的寄存器重定时(retiming)进行最大化。

Hyper-Aware设计流程

使用 Hyper-Aware设计流程可以缩短设计周期并优化性能。Hyper-Aware设计流程将自动寄存器重定时与目标时序收敛建议(Fast Forward编译)的实现相结合，以最大限度地使用用 Hyper-Register，并显示 Intel Hyperflex 体系结构 FPGA的最高性能。

图 78. Hyper-Aware设计流程

Synthesis Plan Place Route Retime

Fast Forward(Hyper-Retiming)RTL

optimizeoptimize optimize optimize optimize

Finalize (Hold Fixup)

寄存器重定时

Intel Hyperflex 体系结构的一个关键创新是在布线段和模块输入上添加了多个 Hyper-Register。最大限度地使用 Hyper-Register可以提高设计性能。Hyper-Register的普及改善了寄存器之间的时间延迟平衡，并减轻了关键路径延迟。Compiler的 Retime阶段将寄存器从 ALM中移出，然后将它们重定时到 Hyper-Register中。寄存器重定时在 Fitter期间自动运行，需要最小工作量，但能够产生显著的性能提升。重定时后，Finalize阶段对具有保持违规的连接进行更正。

快进编译(Fast Forward Compilation)

如果您需要优化而不是简单的寄存器重定时，那么需要运行 Fast Forward编译来生成时序收敛建议，这些建议可以打破关键性能瓶颈，阻止进一步移入 Hyper-Registers。例如，Fast Forward建议删除特定的重定时限制，以防止进一步重定时到 Hyper-Registers。Fast Forward编译能够准确显示 RTL更改对哪些方面产生最大影响，并报告通过消除限制并重定时到 Hyper-Registers(Hyper-Retiming)来获得预测性能优势。Fitter不会自动重新对 RAM和 DSP模块进行寄存器重定时。但是，Fast Forward分析显示了此优化的潜在性能优势。

S10HPHB | 2020.07.13

反馈







图 79. Hyper-Register体系结构

ALM ALM

ALM ALM

Hyper-Registers in core fabricPotential routing path

clk ConfigurationCRAM

Hyper-Register Detail

Fast-Forward编译识别添加流水线阶段(Hyper-Pipelining)的最佳位置，以及每种情况下预期的性能优势。修改 RTL将流水线阶段布置在每个时钟域边界后， Retime阶段会自动将时钟域内的寄存器放置在最佳位置，以最大限度地提高性能。在 RTL中实施此建议来获得类似的结果。进行任何更改后，重新运行 Retime阶段，直到结果符合性能和时序要求。Fast Forward编译不会作为完整编译的一部分自动运行。使能或运行 Compilation Dashboard中的 Fast Forwardcompilation。

表 8. 优化步骤

优化步骤技术说明

步骤 1 寄存器重定时 Retime阶段执行寄存器重定时并将现有的寄存器移入 Hyper-Registers中，从而通过消除重定时限制和去除关键路径来提高性能。

步骤 2 快进编译(Fast ForwardCompile)

Compiler生成设计特定的时序收敛建议，并预测性能改进，同时消除所有Hyper-Registers (Hyper-Retiming)的障碍。

步骤 3 Hyper-Pipelining 使用 Fast Forward编译来识别 RTL中添加新的寄存器和流水线阶段的位置。

步骤 4 Hyper-Optimization Hyper-Retiming和 Hyper-Pipelining之外的设计优化，例如：重构回路，消除控制逻辑限制以及减少长路径上的延迟。

验证设计 RTL

Intel Quartus Prime软件包含 Design Assistant设计规则检查工具，用于验证 Intel Hyperflex体系结构的设计 RTL的适合性。这些规则包括 Hyper-Retimer Readiness Rules (HRR)，专门用于 Intel Hyperflex FPGA体系结构设计。


S10HPHB | 2020.07.13


70


3.1. 独立编译子模块

您可以独立编译较大设计的子模块。独立编译较大的子模块使您可以获得子模块性能信息，并优化子模块以获得更好的性能。根据编译子模块的目标，您可以选择不同地处理 I/O，如以下技术所述：

• 如果在编译过程中对子模块要求额外的 Hyper-Optimization，那么要在 wrapper中例化此子模块，并在每个输入和输出处添加两个或更多寄存器级。此技术支持将那些额外的寄存器重定时到电路中。如果 Compiler将其他寄存器重定时到子模块中，那么可以修改完整设计来对子模块提供额外的寄存器。当在子模块上测试 Hyper-Optimization以确定重定时的影响时(子模块是较大设计的一部分时)，此方法很有用。

• 如果不需要进一步的子模块 Hyper-Optimization，而是希望隔离一个模块以节省编译时间并在整个设计中模仿模块时序预算，那么定义虚拟管脚约束以使能对直接连接到子模块的寄存器进行重定时。指定相应的 set_input_delay或 set_ouput_delay SDC约束以解决内部时钟树的时钟偏斜。根据以下准则和示例，通过指定 reference_pin或静态最大约束来解决内部时钟树的时钟偏斜问题：

表 9. 子模块编译约束指南

SDCArgument

指南示例

clock 指定内部时钟域名称(无虚拟时钟)。此参数使 Compiler将外部时钟和内部时钟视为相同，从而使 I/O寄存器的重定时不再在边界上。

reference_pin argument:

set_input_delay -clock [get_clocks <name>] \ 0 [get_ports <name>] \ -reference_pin [get_pins [<names>]

static maximum constraint:

set insert_delay <value>set_input_delay -clock [get_clocks <name>] \ $insert_delay [get_ports <name>]

delay 指定以下其中一个设置来解决内部时钟树的时钟偏斜：

• 将 max (setup)参数设置为 0 ，并将reference_pin参数设置为 I/O寄存器的时钟管脚。Compiler自动减去 I/O寄存器的时钟树插入延迟。

• 设置max参数≥时钟树插入延迟。

图 80. 子模块编译输入约束示例

Submodule A

Clock Insertion Delay (X)

~1.3nsclk_in

data

Clock Insertion Delay (Y)

set_input_delay

*Clock skew for internal reg-to-reg paths = X - Y*Clock insertion delay removes unnecessary constraint

set_input_delay -clock [get_clocks clk_in] \ 0 [get_ports data] \ -reference_pin [get_pins [int_reg|clk]


S10HPHB | 2020.07.13


71


或者：

set insert_delay 1.3set_input_delay -clock [get_clocks clk_in] \ $insert_delay [get_ports data]


S10HPHB | 2020.07.13


72


3.2. 使用 Design Assistant进行设计规则检查

避免违反设计规则，可以提高设计的可靠性，时序性能和逻辑利用率。 Intel Quartus Prime软件包括 Design Assistant设计规则检查工具，可帮助避免违反设计规则。

Design Assistant通过在每个阶段进行有针对性的健全性检查和指导来最大程度地减少每次迭代的时间，从而减少了设计的总迭代次数，从而提高了生产率。

使能后，Design Assistant根据一组标准的 Intel FPGA建议的设计指南自动报告任何违规。(1)您可以在 Compilation Flow模式下运行 Design Assistant，从而可以在阶段完成时查看与该阶段相关的违规。或者，可以在诸如 Timing Analyzer和 Chip Planner等工具的分析模式下使用Design Assistant。

• Compilation Flow Mode—在编译的一个或者多个阶段自动运行。在此模式下，DesignAssistant在编译期间使用流入(瞬态)数据。

• Analysis Mode—在编译流程中继续之前，从 Timing Analyzer和 Chip Planner运行Design Assistant来分析特定编译阶段上的设计违规。在分析模式中，Design Assistant使用静态编译快照数据。

Design Assistant使用以下其中一个严重性级别来指定每个规则违规的严重程度。您可以指定Design Assistant要检查的规则，并自定义严重性级别，从而可以消除那些对设计不重要的规则检查。

表 10. Design Assistant规则严重性级别

类别描述严重性级别颜色

Critical 解决交接问题。红色

High 可能导致功能故障。可能表示缺失或不正确的设计数据。橙色

Medium 可能会影响 fMAX结果的质量和资源利用率。棕色

Low 规则反映了 RTL编码准则的最佳实践。蓝色

您可以选择定义自己的自定义规则来进行 Design Assistant检查。

注意: Intel Quartus Prime Standard Edition Design Assistant不支持 Intel Arria 10和 IntelMAX® 10器件。

3.2.1. 编译期间运行 Design Assistant

使能时，Design Assistant在编译期间自动运行并在 Compilation Report中报告使能的设计规则违规。或者，您可以在特定的编译快照上运行 Design Assistant，针对此阶段进行分析，如在分析模式下运行 Design Assistant (第 75页)所描述。

请按照以下步骤使能并运行 Design Assistant，并查看编译后的结果：

1. 创建或者打开一个 Intel Quartus Prime工程。

2. 点击 Assignments > Settings > Design Assistant Rules Settings。

(1) 默认情况下使能的一组高值 Design Assistant规则，确保增量运行时没有显著增加的良好设计健康状态。


S10HPHB | 2020.07.13


73


图 81. Design Assistant规则设置

3. 要在编译期间使能 Design Assistant检查，请开启 Enable Design Assistantexecution during compilation。

4. 要过滤要使能或禁用的规则列表，对特定编译 Stage进行选择，在 Filter列表中选择Name，Description，Parameter，Severity或者 Category。

5. 要对检查一个特定设计规则进行使能或者禁用，请在Name列中开启或者关闭此规则的复选框。如果规则未被选中，那么 Design Assistant在规则检查期间不会考虑此规则。

6. 如果使能一个包含可配置参数的规则，那么要在 Parameters域中指定值。

7. 要在编译期间运行 Design Assistant，需要运行 Compiler的一个或多个模块。DesignAssistant在 Compilation Report中报告每个阶段的结果。

图 82. 在 Synthesis，Plan，Place，Finalize和 Timing Signoff报告中的 Design Assistant结果

8. 要查看每个规则的结果，请在 Rules列表中点击相应规则。出现规则描述和设计纠正建议。


S10HPHB | 2020.07.13


74


图 83. Design Assistant规则违规建议

Design Assistant Recommendation

3.2.2. 在分析模式下运行 Design Assistant

您可以在分析模式下使用 Design Assistant，根据应用于 Timing Analyzer和 Chip Planner中快照的设计规则来验证一个特定快照。Timing Analyzer和 Chip Planner可以报告该阶段的设计规则违规情况。然后，您可以更正违规，然后再进行下一个编译阶段。

3.2.2.1. Design Assistant的交叉探测(Cross-Probing)

Design Assistant的交叉探测功能使您能够根据一个规则违规实例找到相关工具(RTL Viewer，Technology Map Viewer，Chip Planner，Pin Planner)或设计文件中的错误源。

Design Assistant可以从一个单端的规则违规到源进行交叉探测。以下两个示例演示了如何通过从交叉探测位置进行扩展来全面分析违规。

注意: 在某些情况下，定位到规则违规的确切原因可能是不可行的。对于这些情况，交叉探测可定位到调试违规的近似起点。在某些情况下，无法进行交叉探测。

通用高扇出规则违规示例(Generic High Fan-Out Rule Violation Example)

以下示例显示了 RTL Viewer中的 HRR-10115高扇出信号规则违规的交叉探测：

1. 当 Design Assistant报告规则 HRR-10115的 FAIL状态时，您可以在 Design Assistant报告中右键单击任何违规，然后单击 Locate Node > Locate in RTL Viewer。


S10HPHB | 2020.07.13


75


图 84. Locate in RTL Viewer

交叉探测使您能够在 RTL Viewer中找到驱动寄存器。

图 85. Driver Register in RTL Viewer

2. 然后，要完全可视化高扇出违规，右键点击寄存器并点击 Expand Connections以显示所有接收器(sink)。


S10HPHB | 2020.07.13


76


图 86. 扩展连接

通用时序路径违规示例

对于更复杂的违规，例如涉及时序路径的违规，精确的交叉探测需要额外的步骤。例如，对时序规则 TMC-20001保持路径违规的交叉探测位于路径的起点。但是，要跟踪完整路径，需要手动跟踪连接性或者通过报告 Timing Analyzer中的相同路径。

在 Timing Analyzer中，对 Timing Analyzer Locate Path命令指定相同的-from，-to，-clock_from和 clock_to以在 RTL Viewer，Technology Map Viewer，Chip Planner，Pin Planner或者设计文件中定位源。

1. 当 Design Assistant报告规则 TMC-20001的 FAIL状态，您可以复制(Copy) Start Point违规文本用于路径-from值，复制 End Point违规文本用于-to值。

图 87. 复制违规文本

2. 要打开 Timing Analyzer，需点击 Tools > Timing Analyzer，或者点击编译仪表板上的Timing Analyzer图标。

3. 在 Tasks窗格上，点击 Update Timing Netlist。

4. 将路径信息粘贴到 Tcl console，创建并运行以下命令：

report_timing -from i_qm_top|i_qmll|QMLL[15].qm_ll|piped_dq_req_qid[8][0] \ -to i_qm_top|i_qmll|QMLL[15].qm_ll|piped_dq_req_qid_rtl_0|\ auto_generated|altera_syncram4|altsyncram5|ram_block6a9~reg0 \ -panel_name debug_panel


S10HPHB | 2020.07.13


77


Timing Analyzer在 debug_panel报告中报告路径的时序。

图 88. 时序路径报告

5. 然后，要找到违规的确切原因，右击调试面板中的路径，然后点击 Locate Path > Locatein Chip Planner或者 Locate in Technology Map Viewer。

图 89. Technology Map Viewer中的时序路径

3.2.2.2. 从 Chip Planner运行 Design Assistant

请按照以下步骤在分析模式下从 Chip Planner运行 Design Assistant：

1. 运行 Compiler的任何阶段。在从 Chip Planner运行 Design Assistant之前，必须至少运行Analysis ＆ Elaboration阶段。

2. 点击 Tools > Chip Planner

3. 在 Chip Planner Tasks窗口中，点击 Design Assistant下的 Report DRC。出现Report DRC(设计规则检查)对话框。


S10HPHB | 2020.07.13


78


图 90. Report DRC对话框

4. 在 Rules下，通过删除复选标记禁用对分析不重要的任何规则。点击 Select all Rules来使能所有规则，或者点击 Deselect all Rules来禁用所有规则。

5. 如果使能一个包含可配置参数的规则，那么要在 Parameters域中调整参数值。

6. 在Output下，确认 Report panel name并可选择指定一个输出 File name。

7. 点击 Run。如果 Design Assistant检测到违规，那么在 Report窗格生成并出现 Results报告。结果也显示在主 Compilation Report中。

图 91. Chip Planner Reports窗格中的违规


S10HPHB | 2020.07.13


79


图 92. 主 Compilation Report中的 Chip Planner违规

3.2.2.3. 从 Timing Analyzer运行 Design Assistant

请按照以下步骤在分析模式下从 Timing Analyzer运行 Design Assistant。

注意: 在运行时序分析前必须运行 Compiler的 Plan阶段。

1. 要运行 Compiler的 Plan阶段，需点击 Compilation Dashboard上的 Plan。

2. 在 Compilation Dashboard中点击 Plan阶段旁边的 Timing Analyzer图标。

3. 在 Timing Analyzer Tasks窗格中，点击 Update Timing Netlist。

4. 在 Tasks窗格中，在 Design Assistant文件夹下双击 Report DRC。出现 ReportDRC (设计规则检查)对话框。

5. 在 Rules下，通过删除复选标记禁用对分析不重要的任何规则。点击 Select all Rules来使能所有规则，或者点击 Deselect all Rules来禁用所有规则。

6. 如果使能一个包含可配置参数的规则，那么要在 Parameters域中调整参数值。

7. 在Output下，确认 Report panel name并可选择指定一个输出 File name。


S10HPHB | 2020.07.13


80


图 93. Report DRC (设计规则检查)对话框

Enables or Disables Rule Design Assistant RuleEnable/Disable All

8. 点击 Run。在 Report窗格以及主 Compilation Report中生成和出现 Results报告。

图 94. Timing Analyzer Report窗格中的 Design Assistant报告

9. 在 Report窗格中，在 Design Assistant (Planned)文件夹下，点击 Results报告来查看针对该阶段的设计规则检查的结果摘要。

10. 在 Results报告中，将鼠标悬停在相应违规上以了解详细信息。

3.2.3. Hyper-Retimer Readiness规则

下表列出了所有 HRR规则的汇总：

表 11. HRR Design Assistant规则

规则 ID 简短描述严重程度阶段支持的器件

HRR-10003 高扇出非时钟全球网上的寄存器中 Place • Intel Stratix 10• Intel Agilex

HRR-10004 高扇出非全局网低 Place • Intel Stratix 10• Intel Agilex

继续...


S10HPHB | 2020.07.13


81

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#cbv1548270363942

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#qtp1548270572411


规则 ID 简短描述严重程度阶段支持的器件

HRR-10101 异步清零中 Analysis and Elaboration • Intel Stratix 10• Intel Agilex

HRR-10102 同步清零中 Analysis and Elaboration • Intel Stratix 10• Intel Agilex

HRR-10105 具有 preserve约束的寄存器低 Analysis and Elaboration • Intel Stratix 10• Intel Agilex• Intel Cyclone® 10 GX• Intel Arria 10

HRR-10106 具有 keep约束的信号低 Analysis and Elaboration • Intel Stratix 10• Intel Agilex• Intel Cyclone 10 GX• Intel Arria 10

HRR-10107 保持最大扇出低 Analysis and Elaboration • Intel Stratix 10• Intel Agilex• Intel Cyclone 10 GX• Intel Arria 10

HRR-10108 Pragma dont retime 中 Analysis and Elaboration • Intel Stratix 10• Intel Agilex• Intel Cyclone 10 GX• Intel Arria 10

HRR-10109 Pragma dont replicate 中 Analysis and Elaboration • Intel Stratix 10• Intel Agilex• Intel Cyclone 10 GX• Intel Arria 10

HRR-10110 寄存器重定时约束中 Analysis and Elaboration,Planned

• Intel Stratix 10• Intel Arria 10• Intel Cyclone 10 GX

HRR-10115 高扇出信号低 Analysis and Elaboration • Intel Stratix 10• Intel Agilex• Intel Cyclone 10 GX• Intel Arria 10

HRR-10201 寄存器不能通过 don't care logic level上电

低 Analysis and Elaboration • Intel Stratix 10• Intel Agilex

HRR-10204 Reset Release Instance CountCheck

高 Analysis and Elaboration • Intel Stratix 10• Intel Agilex

相关链接

• Intel Quartus Prime Pro Edition用户指南：设计编译

• Intel Quartus Prime Pro Edition用户指南：设计建议提供有关设置和使用 Design Assistant的完整信息


S10HPHB | 2020.07.13


82

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#wia1548102148757

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#tsk1548104924799

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#gst1548105451432

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#wwb1548270751112

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#wkl1548270829268

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#wsb1548271133129

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#qpz1548271209739

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#aty1548271265021

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#wxg1552087820789

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#dxj1563553665860

https://www.intel.cn/content/www/cn/zh/programmable/documentation/sbc1513987577203.html#wfd1563553391793

https://www.intel.cn/content/www/cn/zh/programmable/documentation/zpr1513988353912.html#jbr1443197641054

https://www.intel.cn/content/www/cn/zh/programmable/documentation/zpr1513988353912.html#jbr1443197641054


4. 设计实例演练(Design Example Walk-Through)

此演练显示了现实Median Filter图像处理设计上进行 Fast-Forward编译和 Hyper-Retiming技术后的性能优化。Fast Forward编译会生成对设计 RTL变更的建议，以通过 Intel Hyperflex 体系结构实现最高性能。此演练描述了工程设置，设计编译，解释结果和优化 RTL。此演练描述了工程设置，设计编译，结果分析和 RTL优化。

图 95. 中值滤波器操作图

P1 P2 P3 FilterP4

FilterP1

FilterP2

FilterP3

I(x,y)

P1 P2 P3

FilterP4

O(x,y)

O(x,y)

Stage 1

Stage 2

4.1. 中值滤波器设计实例

中值滤波器是一个非线性滤波器，用于去除图像中的脉冲噪声。这些滤波器要求最高的性能。设计要求是在工厂车间进行实时图像处理。

您可以在 https://www.intel.com/content/dam/www/programmable/us/en/others/literature/tt/median_filter_17_1.zip上找到此演练支持的设计实例工程和设计文件。您可以下载 median.zip，解压缩已验证的工程，约束，设计，RTL来完成此演练。 (2)

(2) 在 2002年的葡萄牙里斯本的第 10届地中海控制和自动化会议上,在论文 An FPGA-BasedImplementation for Median Filtering Meeting the Real-Time Requirements of Automated VisualInspection Systems中首次提出这一设计。此设计可在 Free Software Foundation发布的 GNUGeneral Public License下公开使用。

S10HPHB | 2020.07.13

反馈



https://www.intel.com/content/dam/www/programmable/us/en/others/literature/tt/median_filter_17_1.zip

https://www.intel.com/content/dam/www/programmable/us/en/others/literature/tt/median_filter_17_1.zip





图 96. 使用中值滤波进行图像处理的前后图

中值滤波器设计实例文件

下载和解压后，中值滤波器设计实例.zip文件的Median_filter_design_example_<version>目录下包含以下目录：

表 12. 中值滤波器设计实例文件

文件名说明

Base 包含原始版本的设计和工程文件。

Final 包含最终版本的设计和工程文件，其中包括所有的 RTL优化。

fpga-median.ORIGINAL 包含原始 OpenSource版本的中值过滤器和相关的研究论文。

Step_1 增量式 RTL设计更改和工程文件，用于 Fast Forward优化第 1步。

Step_2 增量式 RTL设计更改和工程文件，用于 Fast Forward优化第 2步。

此演练包含以下步骤：

1. 步骤 1：编译基本设计 (第 84页)

2. 步骤 2：添加流水线级和移除异步复位 (第 86页)

3. 步骤 3：添加更多的流水线级和移除全部异步复位 (第 88页)

4. 步骤 4：优化短路径和长路径条件 (第 89页)

4.1.1. 步骤 1：编译基本设计

按照以下步骤编译median project的基本设计：

1. 在 Intel Quartus Prime Pro Edition软件中，点击 File > Open Project，然后选择Median_filter_<version>/Base/median.qpf工程文件。基本版本的设计实例打开。

2. 要编译基本设计，请点击 Compilation Dashboard上的 Compile Design。默认情况下，Fast Forward Timing Recommendations阶段在 Fitter期间运行，并在 Fast ForwardDetails报告中生成详细建议。


S10HPHB | 2020.07.13


84


3. 点击 Fast Forward Timing Closure Recommendations的报告图标。在 FastForward Details报告中，查看 Clk时钟域的编译结果。

图 97. Fast Forward Details报告Analysis Recommends Removal of Asynchronous Registers and Add Pipeline Stages

报告显示 188 MHz的 Base Performance，包括限制进一步优化的以下设计条件：

• 设计包含异步复位(清零)。

• 额外的流水线级(寄存器)可以提高性能。

• 短路径和长路径组合限制了进一步的优化。

以下步骤对设计 RTL中这些建议的实现进行了说明。


S10HPHB | 2020.07.13


85


4.1.2. 步骤 2：添加流水线级和移除异步复位

第一个优化步骤在 Fast Forward建议的设计位置添加了五个级别的流水线寄存器，并删除了设计模块中存在的异步复位。在 ALM之间的互连上添加额外的流水线级可以消除一些长的布线延迟。此优化步骤将 fMAX性能提高到 Fast Forward估计的水平。

添加流水线级并从设计中移除异步复位：

1. 打开 Median_filter_<version>/Step_1/rtl/hyper_pipe.sv。此文件定义了一个可参数化的 hyper_pipe流水线组件，您可以在任何设计中轻松使用此组件。以下是此组件的代码，包括可参数化的宽度(WIDTH)和深度(NUM_PIPES)：

module hyper_pipe #( parameter WIDTH = 1, parameter NUM_PIPES = 1)(input clk,input [WIDTH-1:0] din,output [WIDTH-1:0] dout);

reg [WIDTH-1:0] hp [NUM_PIPES-1:0];

genvar i;generate if (NUM_PIPES == 0) begin assign dout = din; end else begin always @ (posedge clk) hp[0] <= din; for (i=1;i < NUM_PIPES;i++) begin : hregs always @ ( posedge clk) begin hp[i] <= hp[i-1]; end end assign dout = hp[NUM_PIPES-1]; endendgenerateendmodule

2. 使用可参数化的模块在 Fast Forward建议的位置添加一些级别的流水线级。下面的实例显示了如何在 dff_3_pipe模块的 q输出之前添加延迟：

. . .

hyper_pipe #( .WIDTH (DATA_WIDTH), .NUM_PIPES(4)) hp_d0 ( .clk(clk), .din(d0), .dout(q0_int));. . .always @(posedge clk)begin : register_bank_3u if(~rst_n) begin q0 <= {DATA_WIDTH{1'b0}}; q1 <= {DATA_WIDTH{1'b0}}; q2 <= {DATA_WIDTH{1'b0}}; end else begin q0 <= q0_int; q1 <= q1_int; q2 <= q2_int; endend


S10HPHB | 2020.07.13


86


3. 通过将寄存器更改为同步寄存器就可以移除 dff_3_pipe模块中的异步复位，如下所示。请参考复位策略 (第 11页)来了解有效复位实现的一般示例。

always @(posedge clk or negedge rst_n) // Asynchronous resetbegin : register_bank_3u if(~rst_n) begin q0 <= {DATA_WIDTH{1'b0}}; q1 <= {DATA_WIDTH{1'b0}}; q2 <= {DATA_WIDTH{1'b0}}; end else begin q0_reg <= d0; q1_reg <= d1; q2_reg <= d2; q0 <= q0_reg; q1 <= q1_reg; q2 <= q2_reg; endend

always @(posedge clk)begin : register_bank_3u if(~rst_n_int) begin // Synchronous reset q0 <= {DATA_WIDTH{1'b0}}; q1 <= {DATA_WIDTH{1'b0}}; q2 <= {DATA_WIDTH{1'b0}}; end else begin q0 <= q0_int; q1 <= q1_int; q2 <= q2_int; endend

这些 RTL变更将五级流水线添加到 median_wrapper设计的输入(word0，word1和word2总线)，并将五级流水线添加到 dff_3_pipe模块。下面步骤显示了这些变更的结果。

4. 要实现这些变更，保存全部设计变更，然后点击 Compilation Dashboard上的 CompileDesign。

5. 编译之后，再次查看 Fast Forward Details报告中的 Clk时钟域的编译结果。

报告显示了 RTL变更对设计 Base Performance fMAX的影响。设计性能现在提升到 495MHz。


S10HPHB | 2020.07.13


87


该报告指出，通过移除更多的异步寄存器，添加更多的流水线寄存器以及解决短路径和长路径的优化限制可以进一步提高性能。以下步骤描述了在设计 RTL中这些建议的实现。

注意: 作为完成上述步骤的替代方法，您可以打开并编译 Median_filter_<version>/Step_1/median.qpf工程文件(此文件已包含这些变更)，然后观察结果。

相关链接

• 移除异步复位(Removing Asynchronous Resets) (第 11页)


4.1.3. 步骤 3：添加更多的流水线级和移除全部异步复位

Fast Forward Timing Closure Recommendations建议您进行进一步的变更，以便在重定时期间实现更多的优化。Optimizations Analyzed选项卡报告可供您修改的特定寄存器。此报告指出，state_machine.v仍然包含限制优化的异步复位。按照下面的步骤移除state_machine.v中剩余的异步复位，并添加更多的流水线级：

1. 使用步骤 2：添加流水线级和移除异步复位 (第 86页)中的技术方法和示例将state_machine.v中的全部异步复位更改成同步复位。如报告中指出，这些复位位于文件中的多个位置。

2. 在 Fast Forward Details报告中，选择 Fast Forward Limit行之前的最后一行优化，然后点击Optimizations Analyzed选项卡。Optimizations Analyzed指出要添加的寄存器位置和数量。

3. 使用步骤 2：添加流水线级和移除异步复位 (第 86页)中的技术方法和示例在Optimizations Analyzed选项卡的位置上添加流水线级的数量。

4. 再次编译设计和查看 Fast Forward Details报告。提升的性能与所评估的类似，但短路径和长路径组合仍然限制性能。下一步将解决这个性能限制。


S10HPHB | 2020.07.13


88


注意: 作为完成上述步骤的替代方法，您可以打开并编译 Median_filter_<version>/Step_2/median.qpf工程文件(此文件已包含这些变更)，然后观察结果。

4.1.4. 步骤 4：优化短路径和长路径条件

移除异步寄存器并添加流水线阶段后，Fast Forward Details报告指出，短路径和长路径条件限制了进一步优化。在此实例中，最长路径限制了这个特定时钟域的 fMAX。要提高性能，需要按照下面的步骤来缩短此时钟域的最长路径的长度。

1. 要查看长路径信息，点击 Fast Forward Details报告中的 Critical Chain Details选项卡。复查此路径周围的逻辑结构，并考虑相关的 RTL代码。此路径包括 node.v文件的 node模块。关键路径关系到寄存器 data_hi和 data_lo(几个比较器的一部分)的计算。


S10HPHB | 2020.07.13


89


以下是此路径的原始 RTL：

always @(*) begin : comparator if(data_a < data_b) begin sel0 = 1'b0; // data_a : lo / data_b : hi end else begin sel0 = 1'b1; // data_b : lo / data_a : hi end end

always @(*) begin : mux_lo_hi case (sel0) 1'b0 : begin if(LOW_MUX == 1) data_lo = data_a; if(HI_MUX == 1) data_hi = data_b; end 1'b1 : begin if(LOW_MUX == 1) data_lo = data_b; if(HI_MUX == 1) data_hi = data_a; end default : begin data_lo = {DATA_WIDTH{1'b0}}; data_hi = {DATA_WIDTH{1'b0}}; end endcase end

Compiler从此 RTL推断出以下逻辑：

• 一个创建 sel0信号的比较器

• 一对创建 data_hi和 data_lo信号的复用器，如下图所示：

图 98. 节点组件连接


S10HPHB | 2020.07.13


90


2. 复查例化 node模块的 pixel_network.v文件。当 node模块的输出没有使用时，它们是未连接的。这些未连接的输出导致 LOW_MUX和 HI_MUX代码未被使用。使用按位逻辑运算来计算 data_hi和 data_lo信号的值，而不是推断多路复用器，如下例所示：

reg [DATA_WIDTH-1:0] sel0;

always @(*) begin : comparator if(data_a < data_b) begin sel0 = {DATA_WIDTH{1'b0}}; // data_a : lo / data_b : hi end else begin sel0 = {DATA_WIDTH{1'b1}}; // data_b : lo / data_a : hi end data_lo = (data_b & sel0) | (data_a & sel0); data_hi = (data_a & sel0) | (data_b & sel0);end

3. 再次编译设计和查看 Fast Forward Details报告。提升的性能与所评估的类似，短路径和长路径组合不再限制进一步性能提升。此步骤完成后，只有逻辑回路(logical loop)限制进一步的性能提升。

图 99. 优化的短路径和长路径条件

注意: 作为完成上述步骤的替代方法，您可以打开并编译 Median_filter_<version>/Final/median.qpf工程文件(此文件已包含这些变更)，然后观察结果。


S10HPHB | 2020.07.13


91


5. 重定时限制和解决方法

Compiler通过 Hyper-Retiming确认设计中限制进一步优化的寄存器链。Compiler将这些相关寄存器-寄存器路径称为关键链。关键链的 fMAX及其相关时钟域受限于寄存器-寄存器路径中的平均延迟和不可分割电路元件（如布线电缆）的量化延迟。导致重定时限制（retiming restriction）的情况有多种。重定时限制的存在是由硬件特性，软件行为或设计固有的特性导致。Retiming LimitDetails报告阻止进一步重定时的限制原因，以及组成链的寄存器和组合节点。Fast Forward建议中列出了移除关键链和使能其他寄存器重定时的步骤。

在图 100 (第 92页)中，红线代表相同的关键链。时序约束可以阻止 register A向前重定时。时序约束也可以阻止 register B向后重定时。当 register A和 register B是相同寄存器时会出现环路(loop)。

图 100. 关键链样例

A B

对关键链的 Fast Forward建议包括：

• 降低链中“长路径”延迟。使用标准时序收敛技术降低延迟。组合逻辑，次优布局和布线拥塞都是导致路径延迟的原因。

• 在链中的“Long Paths”（“长路径”）中插入更多流水线级。长路径（long path）是关键链中包含寄存器间最大延迟的部分。

• 增加延迟（或在链中的“Short Paths”中添加流水线阶段）。

关键链中的特定寄存器会因为许多其他原因而限制性能。Compiler将限制通过重定时进一步优化的原因做出如下类型分类：

• 寄存器不足(insufficient Registers)

• 环路(loop)

• 短路径/长路径(short path/long path)

• 路径限制(path limit)

了解特定关键链限制设计性能的原因后，便可进行 RTL更改，以消除瓶颈并提高性能。

S10HPHB | 2020.07.13

反馈







表 13. 对各种设计条件的Hyper-Register支持

设计条件 Hyper-Register支持

无法保留的初始条件 Hyper-Registers有初始条件支持。但无法在保留所有寄存器初始条件阶段（即，合并和复制 Hyper-Registers）的同时执行某些重定时操作。如果设计中出现此情况，则Fitter不会重定时这些寄存器。此重定时限制确保了寄存器重定时不会影响设计功能。

寄存器的异步清零 Hyper-Register仅支持数据和时钟输入。Hyper-Register无诸如异步清零，预置或使能的控制信号。Fitter不能重定时任何有异步清零的寄存器。仅在必要时使用异步清零，例如状态机或控制逻辑。通常可避免或从数据路径的较大部分中删除异步清零。

寄存器驱动异步信号此设计条件是所有使用异步复位的设计所固有的。着重减少通过异步清零进行复位的寄存器数量。

寄存器具有 don’t touch或 preserve属性 Compiler不重定时具有这些属性的寄存器。如果使用 preserve属性管理高扇出信号的寄存器复制，则尝试删除 preserve属性。Compiler或许能将每条布线沿线的高扇出寄存器重定时到其目的地。或者，使用 dont_merge属性。Compiler重定时ALM，DDIO，单端口 RAM和 DSP块中的寄存器。

寄存器是时钟源此设计条件并不常见，尤其是对设计的关键性能部分。如果此重定时限制阻止您实现所需性能，则要考虑 PLL是否能够生成时钟而非寄存器。

寄存器是分区边界（partition boundary）此条件是任何使用设计分区的设计中所固有的。如果此重定时限制阻止您实现所需的性能，则要在分区边界内添加其他寄存器用于 Hyper-Retiming。

寄存器是由 ECO操作修改的模块类型此限制并不常见。通过对设计源和重编译进行功能性变更而非执行 ECO来避免此限制。

寄存器位于未知模块此限制并不常见。通常可以通过在特定模块类型旁添加其他寄存器解决此问题。

寄存器在 RTL中被描述为锁存器 Hyper-Register不能实现锁存器。有时由于 RTL编码问题导致 Compiler推断为锁存器，例如不完整的约束。如果打算实现锁存器，就请修改 RTL。

寄存器位于 I/O边界所有设计都包含 I/O，但可在 I/O边界旁添加其他流水线阶段以用于 Hyper-Retiming。

组合节点由特殊源驱动此条件并不常见，特别是对设计的性能关键部分。

寄存器由局部布线的时钟驱动只有专用时钟网络对 Hyper-Register提供时钟。使用布线架构分布时钟信号并不常见，尤其对于设计的关键性能部分。可考虑改为实现小型时钟域。

寄存器是一个时序异常端点 Compiler不重定时作为.sdc约束的源或目标的寄存器。

带有反转输入或输出的寄存器此条件不常见。

寄存器是同步器链的一部分 Fitter优化了同步器链以增加平均故障间隔时间(MTBF)，并且 Compiler不会对检测到或标记为同步器链部分的寄存器重定时。在与同步器链相邻的时钟域边界处添加更多流水线阶段，可为重定时提供灵活性。或者，可减少特定同步器链的检测数量Synchronization Register Chain Length（默认为 3）。某些情况下，同步器链不是必需，亦不应进行推断。

对开始或结束于寄存器的路径使用具有多个周期要求的寄存器（跨时钟边界）

凡是寄存器以一个频率锁存某时钟上的数据，并扇出到运行在另一个频率上的寄存器时，跨时钟边界上就会出现该情况。Compiler不重定时跨时钟边界处的寄存器。考虑在时钟域边界的一侧添加其他流水线阶段（或另一侧），以对重定时提供更大灵活性。

相关链接

时序约束考量 (第 16页)

5.1. 设置 dont_merge综合属性

您可以在 HDL代码中设置 dont_merge属性，如下例所示。


S10HPHB | 2020.07.13


93


表 14. 在HDL代码中设置属性dont_merge防止 my_reg寄存器合并。

HDL 编码

Verilog HDL reg my_reg /* synthesis dont_merge */;

Verilog-2001 andSystemVerilog

(* dont_merge *) reg my_reg;

VHDL signal my_reg : stdlogic;attribute dont_merge : boolean;attribute dont_merge of my_reg : signal is true;

相关链接

避免广播信号 (第 8页)

5.2. 解读关键链报告(Interpreting Critical Chain Reports)

Compiler识别设计中通过 Hyper-Retiming限制进一步优化的寄存器链。Compiler将这些相关的寄存器到寄存器的路径称为关键链。关键链的 fMAX和其关联的时钟域受寄存器到寄存器路径的平均延迟限制和不可分割的电路元件(如布线)的量化限制。

Retiming Limit Details报告阻止进一步重定时的限制原因，以及组成链的寄存器和组合节点。Fast Forward建议中列出了移除关键链和使能额外寄存器重定时的步骤。

在了解了特定关键链为什么限制您的设计性能之后，您可以进行 RTL更改，以消除瓶颈并提高性能。

5.2.1. 不足的寄存器(insufficient Registers)

当 Compiler无法对链任一端上的寄存器进行重定时，但增添更多的寄存器可能会提高性能时，Retiming Limit Details报告会显示 Limiting Reason(限制原因)为 Insufficient Registers(不足的寄存器)。

图 101. 报告为限制原因的不足寄存器


S10HPHB | 2020.07.13


94


5.2.1.1. 不足寄存器实例(insufficient Registers Example)

以下屏幕截图显示了 Retiming Limit Details报告的相关部分以及关键链中的逻辑。

Retiming Limit Details报告指出 clk域的性能没有满足时序要求。

图 102. 重定时限制详情(Retiming Limit Details)

电路中有一个交叉开关，通过一级输入寄存器，一级输出寄存器和纯组合逻辑来布线信号实现的。输入和输出寄存器有异步复位。因为交叉开关中的多路复用器不是流水线的，所以实现效率低下，性能有限。

在图 103 (第 95页)中，关键链从输入寄存器，通过组合逻辑云，到输出寄存器。关键链只包含一条寄存器到寄存器路径。

图 103. Post-Fit Technology Map Viewer中的关键链

在图 104 (第 96页)中，第 1行显示了 Path Info列中的时序限制。第 33行也列出了一个时序限制。两个寄存器上的异步复位导致重定时限制。


S10HPHB | 2020.07.13


95


图 104. 包含Hyper-Retimer期间报告的不足寄存器的关键链

表 15 (第 96页)显示了关键链单元与 Technology Map Viewer示例之间的相关性。

表 15. 关键链单元和技术视图实例之间的相关性

关键链报告中的行号 Technology Map Viewer中的电路单元

1-2 din_reg[0][0]源寄存器和其输出

3-9 din_reg[0][0]与 Mux_0~20之间的 FPGA布线架构，crossbar中mux的第一阶段

10-11 实现 Mux_0~20的组合逻辑

12-15 Mux_0~20与 Mux_0~24之间的布线，crossbar中mux的第二阶段

16-17 实现 Mux0~24的组合逻辑

18-20 Mux0~24与 Mux0~40之间的布线，crossbar中mux的第三阶段


23-29 Mux_0~40与 Mux_0~41之间的布线，crossbar中mux的第四阶段


32-33 dout_reg[16][0]


S10HPHB | 2020.07.13


96


在图 104 (第 96页)的关键链报告中，有 11行列出了 Register列中的旁路 Hyper-Register。旁路的 Hyper-Register表明使用 Hyper-Register的位置，如果链中有更多的寄存器或者端点没有限制。如果端点没有限制，那么 Compiler将端点寄存器或者关键链外部的其他寄存器重定时到关键链中。如果 RTL设计通过交叉开关包含更多寄存器，那么就有 Compiler能够重定时的更多寄存器。Fast Forward编译还可以插入更多寄存器以提高性能。

在关键链报告中，第 2行到第 32行的 Path Info列中列出了"Long Path (Critical)"。这表示路径太长而无法在列出的频率之上运行。"Long Path"标识还与关键链的 Short Path/Long Path类型相关。请参考 Short Path/Long Path部分来了解详细信息。此标识(Critical)存在于关键链的一个 register-to-register分段上。(Critical)标识表明 register-to-register路径是时钟域中最关键的时序路径。

Register ID列在第 1行包含一个"#1"，在第 33行包含一个"#2"。Register ID列中的信息有助于解释更复杂的关键链。关于详细信息，请参考复杂关键链部分。

图 104 (第 96页)中的 Element列显示了关键链中每个步骤的电路单元名称或布线资源。您可以右击名称进行复制，或者使用 Locate选项交叉探测到 Intel Quartus Prime软件的其他部分。

相关链接

• 短路径/长路径(short path/long path) (第 98页)

• 复杂的关键链 (第 106页)


5.2.1.2. 优化不足寄存器(Optimizing Insufficient Registers)

使用本文档介绍的 Hyper-Pipelining技术来解决由被报告的不足寄存器限制的关键链。

相关链接



5.2.1.3. 包括双时钟存储器的关键链

Hyper-Retiming不通过双时钟存储器重定时寄存器。因此，Compiler可以将两个双时钟 FIFO或存储器之间的功能块报告为关键链。报告指定了寄存器不足的限制原因，即使在 Fast Forward之后也是如此。

如果限制原因是 Insufficient Registers，并且链位于双时钟存储器之间，那么可以对功能模块添加流水线级。或者，在 RTL中添加一组寄存器(a bank of registers)，然后是 Compiler能够平衡寄存器。请参考 Hyper-Pipelining (Add Pipeline Registers)，Add Pipeline Stages andRemove Asynchronous Resets和 Appendix A: Parameterizable Pipeline Modules来了解流水线技术和实例。

两个单时钟 FIFO之间的功能模块不受此行为影响，因为 FIFO存储器是单时钟。Compiler能够重定时单时钟存储器上的寄存器。此外，双时钟 FIFO与寄存器件 I/O之间的功能模块不受此行为影响，因为 Fast Forward Compile能通过器件 I/O上的寄存器将寄存器拉进功能模块。

相关链接




S10HPHB | 2020.07.13


97


• 步骤 2：添加流水线级和移除异步复位 (第 86页)

5.2.2. 短路径/长路径(short path/long path)

当关键链包括具有冲突特性的相关路径时，其中一个路径可以通过更多寄存器提高性能，而另一个路径没有地方容纳额外寄存器，所报告的限制原因是 Short Path/Long Path。

当存在 Hyper-Retiming的冲突优化目标时，关键链被分类为短路径/长路径。短路径和长路径始终以某种方式连接在一起，包含至少有一个公共节点。重定时的寄存器必须保持功能正确性，并通过两个关键链确保相同的相对延迟。此要求可能导致冲突优化目标。因此，一个分段(长路径)可以接受重定时方法(retiming move)，但是另一个分段(短路径)不能接受重定时方法。重定时方法通常是将一个额外的寄存器重定时到短路径和长路径中。图 106 (第 99页)说明了此概念。

关键链分类为短路/长路径的原因如下：

• 当 Hyper-Register位置在短路径上不可用于重定时。

• 当重定时一个寄存器到两个路径以提高长路径的性能时不满足短路径上的保持时间要求。有时，短路径/长路径的存在是由于设计中使用的电路结构，例如广播控制信号，同步清零和时钟使能。

短路径/长途径关键链是与后拟合重定时(post-fit retiming)相关联的新优化焦点。在常规的重定时中，网表的结构可以在综合或布局布线期间进行更改。然而，在 Hyper-Retiming期间，由于网表结构和布局布线不能更改，因此会出现短路径/长路径。

5.2.2.1. Hyper-Register位置不可用

Fitter可以将单元非常紧密地布局在关键链中，或者以一种无可用的 Hyper-Register位置的方式对它们进行布线。当关键链中所有的 Hyper-Register位置都被使用时，没有更多的位置可用于进一步优化。

在图 105 (第 98页)中，短路径包含两个正在使用的 Hyper-Register位置。Element列中有一个或多个以_dff结尾的名称，表明在这些位置的 Hyper-Registers正在使用中。_dff代表 Dflop-flop。没有其他的 Hyper-Register位置可用于此链段中。可用的 Hyper-Register位置通过Register列中的旁路 Hyper-Register入口来表明状态。

图 105. 无可用的Hyper-Register位置的关键链短路径


S10HPHB | 2020.07.13


98


5.2.2.2. 保持优化的实例

对于某些设计，Register列指示不可用(保持)(unusable (hold))。此数据表明无法使用此寄存器位置，因为此位置不符合保持时间要求。Compiler无法对出现在指示不可用(保持)的寄存器之前或者之后的寄存器进行重定时(向前或向后)。

5.2.2.3. 优化短路径/长路径

评估 Fast Forward建议，对由于短路径/长路径约束导致的性能限制进行优化。

5.2.2.4. 添加寄存器

如果您能够适应关键链中的额外延迟，那么在短路径以及长路径上手动添加寄存器是有帮助的。

图 106. 交替短路径/长路径的关键链

Cannot RetimeForwards Dueto Short Path

Long Path (LP)Short Path (SP)

Legend

Cannot RetimeBackwards Dueto Short Path

如果将寄存器添加到四个链段(chain segment)中，那么 Compiler能够优化关键链。当在 RTL中有额外的寄存器时，Compiler能够优化它们的位置。


S10HPHB | 2020.07.13


99


图 107. 有额外延迟的短路径/长路径示例


LegendManually Added

5.2.2.5. 复制公共节点

当短路径/长路径关键链包含来自相同寄存器的公共段(common segment)时，您可以复制寄存器，一个副本驱动短路径，一个副本驱动长路径。

图 108. 交替短路径/长路径的关键链

Cannot RetimeForwards Dueto Short Path


Legend

Cannot RetimeBackwards Dueto Short Path


S10HPHB | 2020.07.13


100


图 109. 有两个复制节点的短路径/长路径

Long Path (LP)

Short Path (SP)

Legend

Duplicated Nodes

Fitter可以单独优化新独立段。复制的寄存器有其共同源，所有它们不是完全独立的，但在关键链的每个部分中有一个额外，独立的寄存器，优化就会更容易。

您可以将最大扇出综合指令应用到公共源寄存器。使用值 1，因为大于 1的值会导致短路径段和长路径段有相同源节点。

或者，如果您手动复制短路径/长路径关键链中的共同源寄存器，那么使用综合命令来保存备份寄存器。否则，在综合期间备份可能会被合并。使用综合命令来保存备份寄存器能够导致意外的重定时限制。请使用最大扇出命令。

5.2.2.6. 数据和控制平面

有些时候长路径可以在数据平面中，短路径可以在控制平面中。如果将寄存器添加到数据路径，那么要更改控制逻辑。这可能是一个耗时的过程。如果控制逻辑基于数据路径中的时钟周期数，那么可以在数据路径中添加寄存器(长路径)并修改控制逻辑中的计数器值(短路径)以适应用于处理数据所增加的周期数。

5.2.3. 快进限制(Fast Forward Limit)

当关键路径上没有可用的 Hyper-Register位置时，关键链有 Path Limit的限制原因，设计无法更快地运行，也不能实现进一步的重定时。Path Limit还表明达到了当前布局布线结果的性能限制。

当关键链是 Path Limit时，Path Info列显示信息。此列指示链太长。然而，通过将一个寄存器重定时到链中可以提高性能。如果报告在 Register列中没有列出旁路的 Hyper-Register的条目，那么表明没有可用的 Hyper-Register位置。

Path Limit不是指关键链已经达到固有硅性能的极限，而是表明当前的布局布线有报告的性能极限。另一个编译能够产生一个不同的布局，使 Hyper-Retiming能够实现特定关键链上的更高的性能。导致路径限制的一个常见原因是当寄存器还没有被封装进 hard DSP或 RAM模块中的专用的输入输出寄存器时。

5.2.3.1. 优化路径限制(Optimizing Path Limit)

评估 Fast Forward建议。如果您的关键链有 Path Limit的限制原因，并且此链完全在 IntelFPGA架构的内核逻辑和布线单元中，那么设计能够在内核架构的最大性能上运行。当关键链有Path Limit的限制原因时，并且此链通过 DSP模块或者硬核存储器模块时，您可以通过优化路径限制来提高性能。


S10HPHB | 2020.07.13


101


要优化路径限制，需要对 DSP模块和硬核存储器模块使能可选的输入和输出寄存器。如果对 DSP模块和存储器模块不使用可选的输入和输出寄存器，那么可选寄存器的位置不可用于 Hyper-Retiming，没有显示为关键链中的旁路 Hyper-Registers。路径限制是路径的硅限制，没有可选的输入或输出寄存器。通过使能可选的输入和输出寄存器能够提高性能。

使用 IP参数编辑器开启可选的寄存来参数化 hard DSP或者存储器模块。如果从您的 RTL推断DSP或存储器功能，那么要确保遵循 Recommended HDL Coding Styles中所建议的编码风格，以便使用硬核模块的可选输入和输出寄存器。Compiler不会重定时到 DSP和硬核存储器模块。例化可选的寄存器以实现最大性能。

如果您的关键链包含真双端口存储器，那么请参考真双端口存储器来了解优化技术。

相关链接

• Recommended HDL Coding Styles

• Intel Hyperflex 体系结构真双端口存储器 (第 59页)

5.2.4. 回路(loop)

回路是电路中的反馈路径。当一个电路被大量流水线化时，回路通常是通过寄存器重定时来提高设计 fMAX 的限制原因。回路可以非常短，只包含单个寄存器，回路也可以很长，包含几十个寄存器和组合逻辑云。divide-by-two配置中的寄存器是一个短回路。

图 110. 简单回路

ToggleFlipFlop

当关键链是一个反馈回路时，寄存器重定时不能更改回路中的寄存器数量(在不改变功能性的情况下)。在不改变功能性的情况下，寄存器可以对一个回路进行重定时，但在回路中添加寄存器会改变功能性。要探索性能上的提升，Fast Forward Compile进程在电路的特定边界(例如时钟域边界)上添加了寄存器。

图 111. FIFO流控回路在 FIFO流控回路中，当 FIFO变满时，上游处理停止，当 FIFO为空时，下游进程停止。

DataProducer

FIFO

FIFO Full


S10HPHB | 2020.07.13


102

https://www.intel.cn/content/www/cn/zh/programmable/documentation/mwh1409960181641.html#mwh1409959570946


图 112. 计数器和累加器回路

在计数器和累加器回路中，寄存器的新值取决于旧值。这包括诸如 LFSR (线性反馈移位寄存器)和格雷码计数器的变体。

Counter

+1

Accumulator

图 113. 状态机回路

在状态机回路中，下一状态取决于电路的当前状态。

S0

S1

S2S3

S4

图 114. 复位电路回路

复位电路回路包括监控逻辑，在错误情况下进行复位。

CombinationalLogic

使用回路通过硬件重用来节省面积。被重复使用几个周期的组件通常包括回路。这样的组件包括CRC计算，过滤器，浮点分频器，和字对齐器。封闭回路反馈设计(例如 IIR滤波器和用于远程radiohead设计的发送器功率的自动增益控制)也使用回路。


S10HPHB | 2020.07.13


103


5.2.4.1. 限制关键链环路的实例

以下屏幕截图显示了 Fast Forward Details报告的相关面板以及关键链中包含的逻辑。

图 115. Fast Forward Details Report显示Hyper-Optimization的限制原因是一个环路

在图 116 (第 104页)中，起点和终点的 Register ID是相同的，都是#1。这种情况表明链的起点和终点是相同的，从而产生一个环路(loop)。

图 116. 包括环路的关键链(lines 1-34)


S10HPHB | 2020.07.13


104


图 117. 包括环路的关键链(lines 35-65)

图 118 (第 105页)显示 Addr_wr[0]寄存器的输出，通过八级组合逻辑反馈到其使能输入。

图 118. Technology Map Viewer中的关键链

此图未显示 Addr_wr[0]寄存器的逻辑锥的其他输入。关键链的源代码 (第 105页)显示了源的部分和 Addr_wr寄存器的一些输入。

实例-16: 关键链的源代码

assign Add_wr_pluse =Add_wr+1;assign Add_wr_pluse_pluse =Add_wr+4;

always @ (Add_wr_pluse or Add_rd_ungray) if (Add_wr_pluse==Add_rd_ungray) Full =1; else Full =0; always @ (posedge Clk_SYS or posedge Reset) if (Reset) Add_wr <= 0; else if (Wr_en&&!Full) Add_wr <= Add_wr +1;

5.2.5. 每个时钟域一个关键链

Hyper-Retiming报告每个时钟域一个关键链，除了相关时钟组中的关键链中涵盖的特殊情况。如果执行 Fast Forward编译，那么 Hyper-Retiming报告显示每个 Fast Forward优化步骤的每个时钟域一个关键链。由于只有一个链是关键链，因此 Hyper-Retiming不会报告每个时钟域多个关键链。


S10HPHB | 2020.07.13


105


复查您设计中可优化的其他链。查看 Fast Forward compilation报告每一步中其他链。报告中的每一步测试一组变化，例如移除或者转换异步清零和添加流水线阶段。报告详细给出了这些变化的性能和假设实现。

相关链接

相关时钟组中的关键链 (第 106页)

5.2.6. 相关时钟组中的关键链

当两个或更多时钟域有完全相同的时序要求时，并且存在域之间的路径，时钟域边界上的寄存器没有 Don’t Touch属性时，Hyper-Retiming报告 Related Clock Group的一个关键链。优化技术关键链类型也适用于相关时钟组中的关键链。

5.2.7. 复杂的关键链

复杂的关键链由几个由连接点连接的的分段组成。在 Fitter报告的 Register ID列中，连接点用一个正整数表示。连接点列在关键链中的分段末尾，表示分段发散或收敛的位置。当在基于行的文本报告中列出链时，连接点表示链段之间的连接。连接点对应于电路中的单元，并显示它们如何连接到其他单元以形成一条关键链。

以下示例使用下表中的关键链样例显示连接点如何与电路连接相对应。

表 16. 关键链样例

Path Info Register Register ID Element

REG #1 a

b

REG #2 c

------------ ------------ ------------ ------------

REG #3 d

e

REG #2 c

------------ ------------ ------------ ------------

REG #3 d

f

REG #4 g

------------ ------------ ------------ ------------

g

h

a


S10HPHB | 2020.07.13


106


图 119. 关键链样例的可视化表示

图中的每个圆都包含关键链表中的单元名称和连接点编号。

d#3

g#4

a#1

c#2

对于长关键链，对关键链的较小部分进行优化。重编译设计并分析关键链中的变化。请参考优化环路来了解使用其他方法来优化关键链的一部分。

5.2.8. 延伸到可定位的节点

在关键链中可能会看到“扩展到可定位节点”的路径信息条目。这是一个方便的功能，使您能够通过关联关键链中的节点来设计 RTL中名称。

在一个关键链中，不是每一行都对应一个 RTL文件中的设计入口名称。例如，单独的布线与 RTL中的名称没有关联。通常这不是一个问题，因为在附近或相邻行上的另一个名称对应于并且可定位到RTL文件中的一个名称。有时在关键链报告中一行可能没有能够在 RTL中找到的相邻或邻近的行；此情况频繁出现连接点上。当发生这种情况时，关键链段会根据需要进行扩展，直到它达到了位于HDL文件的那一行。

5.2.9. 域边界入口和域边界出口(Domain Boundary Entry and Domain BoundaryExit)

Path Info列出了关键链的 Domain Boundary Entry或 Domain Boundary Exit。域边界入口(domain boundary entry)或域边界出口(domain boundary exit)指的是不受约束的路径，异步时钟域之间的路径或者时钟域与顶层器件输入输出之间的路径。域边界入口和出口也指示为某些假路径。

域边界入口是指设计拓扑中位于时钟域边界上的一个点，如果使能了 Hyper-Pipelining，Hyper-Retiming可以在此点上插入寄存器阶段(延迟可以进入时钟域)。域边界入口的概念与数据流方向无关。 Hyper-Retiming可以在模块的输入处插入寄存器级，并执行向前重定时推动。 Hyper-Retiming还可以在模块的输出端插入寄存器阶段，并执行向后重定时推送。这些插入出现在域边界入口点。

域边界出口是指设计拓扑中的一个点，位于时钟域边界上，如果使能了 Hyper-Pipelining，Hyper-Retiming可以移除寄存器阶段，延迟可以退出时钟域。移除一个寄存器似乎是反直观的。但是，通常使用这种方法来保持功能的正确性，具体取决于 Hyper-Retiming执行的其他优化。

当在寄存器到寄存器路径上有未寄存的 I/O驱动组合逻辑( feeding combinational logic)时，如下图所示，关键链有时表示一个域边界入口或出口。


S10HPHB | 2020.07.13


107


图 120. 包括未寄存输入/输出的域边界

CombinationalLogic

根据路径限制 Hyper-Retiming的方式，寄存器到寄存器路径可能会显示为具有域边界入口或域边界退出的关键链段。未寄存的输入可防止 Hyper-Retiming在域边界插入寄存器阶段，因为输入是未寄存的。同样，未寄存的输入也可以防止 Hyper-Retiming在域边界移除寄存器阶段。

具有域边界出口的关键链不能提供用于确定是什么阻止将寄存器重定时出时钟域的完整的信息。要确定寄存器无法重定时的原因，请查看设计以找到与域边界出口相关联的寄存器另一端连接的信号。

域边界入口和域边界出口可以独立出现在关键链中。他们也可以组合出现在关键中，例如：没有域边界入口的域边界出口，或者关键链起始或和末尾的域边界入口。

以下关键链以域边界入口(domain boundary entry)开始和结束。域边界入口是连接到顶层器件I/O的输入和输出寄存器。输入寄存器是 round_robin_requests_r ，输出寄存器是round_robin_next 。

图 121. 包括域边界的关键链原理图

基本编译的限制原因是不足寄存器(Insufficient Registers)。

图 122. 包括 Insufficient Registers的 Retiming Limit Summary

以下部分关键链报告显示了端点标记为 Domain Boundary Entry。


S10HPHB | 2020.07.13


108


图 123. 包括 Domain Boundary Entry的关键链

输入和输出寄存器都指示为 Domain Boundary Entry，因为如果使能了 Hyper-Pipelining，那么Fast Forward Compile通常会在这些边界插入寄存器级。

5.2.10. 包括双时钟存储器的关键链

Hyper-Retiming不通过双时钟存储器重定时寄存器。因此，Compiler可以将两个双时钟 FIFO或存储器之间的功能块报告为关键链。报告指定了寄存器不足的限制原因，即使在 Fast Forward之后也是如此。

如果限制原因是 Insufficient Registers，并且链位于双时钟存储器之间，那么可以对功能模块添加流水线级。或者，在 RTL中添加一组寄存器(a bank of registers)，然后是 Compiler能够平衡寄存器。请参考 Hyper-Pipelining (Add Pipeline Registers)，Add Pipeline Stages andRemove Asynchronous Resets和 Appendix A: Parameterizable Pipeline Modules来了解流水线技术和实例。

两个单时钟 FIFO之间的功能模块不受此行为影响，因为 FIFO存储器是单时钟。Compiler能够重定时单时钟存储器上的寄存器。此外，双时钟 FIFO与寄存器件 I/O之间的功能模块不受此行为影响，因为 Fast Forward Compile能通过器件 I/O上的寄存器将寄存器拉进功能模块。

相关链接



• 步骤 2：添加流水线级和移除异步复位 (第 86页)

5.2.11. 关键链比特和总线

一个设计的关键链通常包括在更宽总线或寄存器组中的单比特的寄存器。当分析一个关键链时，要将重点放在总线上，而不是与单比特相关的结构上。例如，一个指向 512比特总线中的 bit 10的关键链可能对应于此总线中所有比特的类似结构。使用此方法的一个技巧是将每个比特索引(例如[10])替换成[*]。


S10HPHB | 2020.07.13


109


如果关键链包含总线中的一个寄存器，其中不同的部分(slices)遍历不同的逻辑，那么要基于关键链中报告的寄存器来将您的分析着重放在相应的部分(slices)。

5.2.12. 延迟线

如果您的设计包含一个使总线延迟一定时钟周期的模块，那么 Compiler可以使用 altshift_tapsIntel FPGA IP实现这样的结构。当此实现发生时，关键链包括 altshift_taps:r_rtl_0的设计层次结构，表明综合使用 altshift_taps IP core替换了寄存器组(bank of registers)。

当 Fitter将寄存器链紧密布局在一起时，使用任何中间 Hyper-Register位置时 Fitter都无法满足保持时间要求。关闭寄存器组的 Auto Shift Register Replacement选项可防止综合使用altshift_taps IP core，并解决此关键链的任何短路径部分。

考虑基于 RAM的 FIFO实现是否可以替代寄存器延迟线。如果延迟线的一个功能是流水线布线(在芯片上移动信号很长的距离)，那么基于 RAM的实现通常不是可接受的替代。如果不需要长距离移动数据，那么基于 RAM的实现是一种延迟数据总线的紧凑方法。


S10HPHB | 2020.07.13


110


6. 优化实例

此部分包含一个循环排程器(round robin scheduler)优化实例。

6.1. 循环排程器(Round Robin Scheduler)

循环排程器(round robin scheduler)是一个基本的功能模块。以下实例使用模数运算符来确定下一个客户端的服务。由于模数运算符执行除法运算，因此相对较慢，并且面积效率低下。

实例-17: Round Robin Scheduler的源代码

module round_robin_modulo (last, requests, next);

parameter CLIENTS = 7;parameter LOG2_CLIENTS = 3;

// previous client to be servicedinput wire [LOG2_CLIENTS -1:0] last;// Client requests:- input wire [CLIENTS -1:0] requests;// Next client to be serviced: -output reg [LOG2_CLIENTS -1:0] next;

//Schedule the next client in a round robin fashion, based on the previousalways @*begin integer J, K;

begin : find_next next = last; // Default to staying with the previous for (J = 1; J < CLIENTS; J=J+1) begin K = (last + J) % CLIENTS; if (requests[K] == 1'b1) begin next = K[0 +: LOG2_CLIENTS]; disable find_next; end end // of the for-loop end // of 'find_next'end

endmodule

图 124. Round Robin Scheduler的快进编译报告

S10HPHB | 2020.07.13

反馈







Retiming Summary报告识别关键链上限制 Hyper-Retiming的不足寄存器。链从连接到最后一个输入的寄存器开始，通过使用分频器实现的模数运算符，并继续到连接到下一个输出的寄存器。

图 125. Round Robin Scheduler的基本性能的关键链

上面关键链中的 44个单元对应于下面具有 10级逻辑的电路图。模数运算符是导致低性能的主要因素。10级逻辑中的 7级逻辑是模数运算符实现的一部分。

图 126. 关键链的原理图

如图 124 (第 111页)所示，Fast Forward编译根据在模块输入上添加两个流水线级，通过逻辑云进行重定时，评估出一个 140%的性能提升。此时，关键链是一条短路径/长路径，此链包含模数运算符。

6. 优化实例

S10HPHB | 2020.07.13


112


图 127. Round Robin Scheduler的关键链快进编译

模数运算中的除法器是要求 RTL修改的瓶颈。通过除法器的路径存在于关键链中，用于 FastForward编译中所有步骤。考虑替代的实现来计算下一个要服务的客户端，以避免模数运算符。如果切换到一个将客户端的数量指定为 2的幂数的实现，那么决定下一个要服务的客户端就不需要模数运算符。当使用少于 2n个客户端来例化模块时，要将未使用的请求输入连接到逻辑 0。

实例-18: Round Robin Scheduler的源代码，通过 2n个客户端输入提高了性能

module round_robin_modulo (last, requests, next);

parameter LOG2_CLIENTS = 3;parameter CLIENTS = 2**LOG2_CLIENTS;

6. 优化实例

S10HPHB | 2020.07.13


113


// previous client to be servicedinput wire [LOG2_CLIENTS -1:0] last;// Client requests:- input wire [CLIENTS -1:0] requests;// Next client to be serviced: -output reg [LOG2_CLIENTS -1:0] next;

//Schedule the next client in a round robin fashion, based on the previousalways @(next or last or requests)begin integer J, K;

begin : find_next next = last; // Default to staying with the previous for (J = 1; J < CLIENTS; J=J+1) begin K = last + J; if (requests[K[0 +: LOG2_CLIENTS]] == 1'b1) begin next = K[0 +: LOG2_CLIENTS]; disable find_next; end end // of the for-loop end // of 'find_next'end

endmodule

图 128. Round Robin Scheduler(通过 2n个客户端输入提高了性能)的 Fast Forward Summary报告

即使没有任何 Fast Forward优化(Base Performance步骤)，与 Round Robin Scheduler的源代码 (第 111页)中没有性能提升的版本相比，这种循环(round robin)实现的运行频率是其两倍。虽然两个版本中的关键链都只包含两个寄存器，但 2n版本的关键链仅包含 26个单元，而模数版本中只有 44个单元。

6. 优化实例

S10HPHB | 2020.07.13


114


图 129. 性能提升的 Round Robin Scheduler的关键链

关键链中的 26个单元对应于下面具有四级逻辑的电路图。

图 130. 性能提升的关键链的原理图

通过在输入端添加三个寄存器级，通过逻辑云进行重定时，Fast Forward Compile将电路性能提升至 1 GHz。与模数版本类似，Fast Forward优化后的最终关键链具有短路径/长路径的限制原因，如图 131 (第 116页)所示，但性能是模数版本的 1.6倍。

6. 优化实例

S10HPHB | 2020.07.13


115


图 131. 最佳性能的 Round Robin Scheduler的关键链

移除模式运算符并切换到二次幂实现是一个很小的设计变化，但实现了显著的性能提升。

• 仅可能地对数学运算使用自然二次幂

• 对看似基本的功能探索替代的实现。

在此实例中，改变循环逻辑的实现提供了比添加流水线级更多的性能提升。

6. 优化实例

S10HPHB | 2020.07.13


116


7. Intel Hyperflex 体系结构移植指南

本章节提供将一个 Stratix V或者 Intel Arria 10设计移植到 Intel Hyperflex 体系结构 FPGA的指导原则。这些指导原则使您能够对 Intel Hyperflex 体系结构中的设计优化的优势进行快速评估，而同时又能保留设计的功能意图。

移植需要对设计进行少量修改，但能够实现设计中最关键模块的主要性能提升。

要对性能探索进行实验，需要使用一个不包含外设 IP(收发器，存储器等)的大型的第二层模块。在性能探索过程中查看所报告的性能提升。

7.1. 设计移植和性能探索

您可以移植到 Intel Hyperflex 体系结构 FPGA对性能提升进行评估。针对 Intel Hyperflex 体系结构 FPGA的设计移植仅要求 requires进行次要变更。然而，您可以应用其他未要求的 non-required变更进一步提高性能。这种性能提升可帮助关闭时序并为设计添加功能。

任何器件移植通常都需要进行一些常规的设计变更。这些变更包括更新 PLL，高速 I/O管脚和其他器件资源。这些组件的 Intel Hyperflex 体系结构版本具有与以前器件系列相同的常规功能。然而， Intel Hyperflex 体系结构 IP组件包括可提高运行速度的功能：

• DSP模块包括流水线寄存器并支持浮点模式。

• 存储器模块包含用于一致性和宽度限制的附加逻辑。

移植过程中的高级步骤包括：

1. 选择移植设计中的较低级别的模块，不使用任何专用 IP。

2. 排除(black-box)任何特殊 IP组件，仅保留当前级别所需要的组件。仅保留以下关键模块用于内核性能评估：

• 用于生成时钟的 PLL

• 内核模块(逻辑，寄存器，存储器，DSP)

注意:

如果从 Intel Quartus Prime软件的以前版本进行设计移植，那么某些 Intel FPGAIP可能会因为与当前的软件版本不兼容而需要替换。例如，您不能更新基于 IP的收发器，因为基于 IP的收发器在不同的器件系列之间各不相同。

3. 当排除组件时，要保留模块端口定义。您不能只是将源文件从工程中移除。

4. 指定设计中使用的每个组件的端口定义和方向。定义端口失败会导致编译错误。

5. 设计综合期间，查看错误消息并纠正缺失的端口或模块定义。

排除模块的最简单方法是清空其功能内容。以下实例显示了在 Verilog HDL或 VHDL中进行排除(black-boxing)。

S10HPHB | 2020.07.13

反馈







7.1.1. Black-boxing Verilog HDL模块

在 black-boxing Verilog HDL中，保留模块定义，但要删除功能描述。

之前：

// k-bit 2-to-1 multiplexermodule mux2tol (V, W, Sel, F); parameter k = 8; input [k-1:0] V, W; input Sel; output [k-1:0] F; reg [k-1:0] F;

always @(V or W or Sel) if (Sel == 0) F = V; else F = W;endmodule

之后：

// k-bit 2-to-1 multiplexermodule mux2tol (V, W, Sel, F); parameter k = 8; input [k-1:0] V, W; input Sel; output [k-1:0] F;endmodule

7.1.2. Black-boxing VHDL模块

在 black-boxing VHDL中，保持 entity不变，但要删除体系结构。在有多个体系结构的情况下，要确保将它们全部删除。

之前：

-- k-bit 2-to-1 multiplexerLIBRARY ieee ;USE ieee.std_logic_1164.all ;

ENTITY mux2tol ISGENERIC ( k : INTEGER := 8) ; PORT ( V, W : IN STD_LOGIC_VECTOR(k-1 DOWNTO 0) ; Sel : IN STD_LOGIC ; F : OUT STD_LOGIC_VECTOR(k-1 DOWNTO 0) ) ;END mux2tol ;

ARCHITECTURE Behavior OF mux2to1 ISBEGIN PROCESS ( V, W, Sel ) BEGIN IF Sel = '0' THEN F <= V ; ELSE F <= W ; END IF ; END PROCESS ;END Behavior ;


S10HPHB | 2020.07.13


118


之后：

-- k-bit 2-to-1 multiplexerLIBRARY ieee ;USE ieee.std_logic_1164.all ;

ENTITY mux2tol ISGENERIC ( k : INTEGER := 8) ; PORT ( V, W : IN STD_LOGIC_VECTOR(k-1 DOWNTO 0) ; Sel : IN STD_LOGIC ; F : OUT STD_LOGIC_VECTOR(k-1 DOWNTO 0) ) ;END mux2tol ;

ARCHITECTURE Behavior OF mux2to1 ISBEGINEND Behavior ;

除了 black-boxing模块，也必须分配给其他模块一个空的设计分区。分区可以防止与排除模块连接的逻辑在综合期间被优化。

创建一个新的分区：

1. 在 Project Navigator Hierarchy标签，右击 black-boxed模块，然后点击 DesignPartition > Set as Design Partition。

2. 对于 Empty，选择 Yes。

3. 将所有的 black-box模块添加到此分区中。

图 132. 创建新的空分区


S10HPHB | 2020.07.13


119


7.1.3. 时钟管理

black-boxing相应逻辑后，要确保设计中的所有寄存器都还接收时钟信号。所有的 PLL必须存在。识别出任何存在于 black-boxed模块中的时钟。如果这出现在您的设计中，那么您要重新创建此时钟，否则会将寄存器下游标记为为 unclocked。这会改变设计的逻辑功能，因为综合能够移除那些不接收时钟的寄存器。检查.sdc文件中的时钟定义以确定此文件是否在其中的一个 black-boxed模块中指定一个时钟定义。对于一个特定的模块，能够出现几种情况：

• 此模块中有一个时钟定义：

— 时钟信号达到模块的主输出和模块的寄存器下游的时钟管脚吗？

• 不：此时钟是完全内部的，不需要做任何事情。

• 是：在此模块的输出管脚上创建一个与.sdc中定义相匹配的时钟。

• 此模块上没有时钟定义：

— 在此模块中有时钟馈通路径(clock feedthrough path)吗?

• 不：不需要做任何事情。

• 是：在此模块的馈通输出管脚上创建一个新时钟。

7.1.4. 管脚分配

black-boxing逻辑能导致一些管脚分配错误。使用以下指南来解析管脚分配。重新分配高速通信输入管脚来纠正这些错误。

FPGA检查高速管脚的状态，如果不连接这些管脚，那么会生成错误信息。当 black-box收发器时，您可能会遇到这种情况。要解决这些错误，请将 HSSI管脚重新分配给一个标准 I/O管脚。必要时验证并更改 I/O bank。

在.qsf文件中，assignmnet语句如下所示：

set_instance_assignment –name IO_STANDARD “2.5 V” –to hip_serial_rx_in1set_instance_assignment –name IO_STANDARD “2.5 V” –to hip_serial_rx_in2set_instance_assignment –name IO_STANDARD “2.5 V” –to hip_serial_rx_in3set_location_assignment IOBANK_4A –to hip_serial_rx_in1set_location_assignment IOBANK_4A –to hip_serial_rx_in2set_location_assignment IOBANK_4A –to hip_serial_rx_in3

悬挂管脚(dangling pins)

如果由于 black-boxing组件而导致高速 I/O管脚悬挂，那么要将他们设置成虚拟管脚。您可以在Assignment Editor中输入此 assignment，或者直接在.qsf文件中输入，如下所示：

set_instance_assignment –name VIRTUAL_PIN ON –to hip_serial_tx_in1set_instance_assignment –name VIRTUAL_PIN ON –to hip_serial_tx_in2set_instance_assignment –name VIRTUAL_PIN ON –to hip_serial_tx_in3

GPIO管脚

如果您有 GPIO管脚，那么要使用 qsf assignment将他们变成虚拟管脚：

set_instance_assignment VIRTUAL_PIN –to *


S10HPHB | 2020.07.13


120


7.1.5. 收发器控制逻辑

您的设计可能有一些包括添加的逻辑的组件，添加的逻辑控制这些组件。例如，您可能有一个小型设计，用于控制收发器的复位功能。您可以将这些模块保留在顶层设计中，他们的逻辑可用于优化。


S10HPHB | 2020.07.13


121


7.1.6. 升级过时的 IP内核

Intel Quartus Prime软件会提醒您设计中的过时 IP组件。除非 black-boxed，否则要将每个过时 IP组件都升级到当前版本：

1. 点击 Project > Upgrade IP Components更新组件到最新版本。

2. 要升级一个或多个支持自动升级的 IP内核，需确保开启 Auto Upgrade选项，并点击Perform Automatic Upgrade。Status和 Version列在升级完成时更新。当升级一个IP内核时会自动重新生成使用任何 IP内核的实例设计。

3. 如要手动升级一个单独的 IP内核，则需要选择 IP内核并点击 Upgrade in Editor (或者双击 IP内核名称)。参数编辑器打开，使您能够调整参数并重新生成最新版本的 IP内核。

注意: 您不能升级某些 IP组件。如果这些组件很重要(例如 PLL)，那么要修改设计并替换成最新的兼容 IP组件。

7.2. 顶层设计考量

I/O约束

为了从寄存器重定时获得最大性能，将顶层包装在一个寄存器环中，并从.sdc文件中删除以下约束条件：

• set_input_delay

• set_output_delay

这些约束模拟模块外的外部延迟。为分析设计优化的效果，您可以在模块内使用所有可用的裕量(slack)。此技术有助于最大化模块级上的性能。当移到全芯片时序收敛时，替换这些约束。

复位

如果将复位生成(reset generation)从设计中删除，那么要通过与设计中的一个输入管脚的直接连接来提供一个替换信号。此配置可能会影响 Intel Hyperflex 体系结构 FPGA中的重定时能力。添加两个流水线级到您的复位信号。此技术使 Compiler能够在复位输入与寄存器的第一级之间进行优化。

特殊模块

重定时不会自动改变一些组件，例如 DSP和M20K模块。为了通过重定时实现更高的性能，您可以手动重编译这些模块。注意以下条件：

• DSP：注意流水线深度。更多的流水线阶段会导致更快的设计。如果 DSP模块中的逻辑级限制了重定时，那么需要添加更多的流水线阶段。

• M20K：重定时非常依赖于寄存器的存在来移动逻辑。通过使用M20K模块，您可以通过寄存逻辑存储器两次来帮助 Compiler：

— 一次直接在M20K模块内

— 一次在架构中，在模块的管脚上

寄存模块

寄存模块的所有输入和输出。此寄存器环模拟模块嵌入在完整设计中时被驱动的方式。此环也避免了与连接到输入/输出的寄存器相关联的重定时限制。Compiler现在能够更现实地重定时第一级和最后一级寄存器。


S10HPHB | 2020.07.13


122


8. 附录

S10HPHB | 2020.07.13

反馈







8.1. 附录 A：可参数化的流水线模块

下面的实例显示了 Verilog HDL，SystemVerilog和 VHDL中可参数化的流水线模块。在顶层 I/O和时钟域边界上使用这些代码模块来更改电路的延迟。

实例-19: 可参数化的Hyper-Pipelining Verilog HDL模块

(* altera_attribute = "-name AUTO_SHIFT_REGISTER_RECOGNITION off" *) module hyperpipe #(parameter CYCLES = 1, parameter WIDTH = 1) ( input clk, input [WIDTH-1:0] din, output [WIDTH-1:0] dout);

generate if (CYCLES==0) begin : GEN_COMB_INPUT assign dout = din; end else begin : GEN_REG_INPUT integer i; reg [WIDTH-1:0] R_data [CYCLES-1:0]; always @ (posedge clk) begin R_data[0] <= din; for(i = 1; i < CYCLES; i = i + 1) R_data[i] <= R_data[i-1]; end assign dout = R_data[CYCLES-1]; end endgenerate

endmodule

实例-20: 可参数化的Hyper-Pipelining Verilog HDL实例

hyperpipe # ( .CYCLES ( ), .WIDTH ( ) ) hp ( .clk ( ), .din ( ), .dout ( ) );

实例-21: 可参数化的Hyper-Pipelining SystemVerilog模块

(* altera_attribute = "-name AUTO_SHIFT_REGISTER_RECOGNITION off" *) module hyperpipe #(parameter int CYCLES = 1, PACKED_WIDTH = 1, UNPACKED_WIDTH = 1) ( input clk, input [PACKED_WIDTH-1:0] din [UNPACKED_WIDTH-1:0], output [PACKED_WIDTH-1:0] dout [UNPACKED_WIDTH-1:0]);

generate if (CYCLES == 0) begin : GEN_COMB_INPUT assign dout = din; end else begin : GEN_REG_INPUT integer i; reg [PACKED_WIDTH-1:0] R_data [CYCLES-1:0][UNPACKED_WIDTH-1:0];

8. 附录

S10HPHB | 2020.07.13


124


always_ff@(posedge clk) begin R_data[0] <= din; for(i = 1; i < CYCLES; i = i + 1) R_data[i] <= R_data[i-1]; end assign dout = R_data[CYCLES-1]; end endgenerate

endmodule : hyperpipe

实例-22: 可参数化的Hyper-Pipelining SystemVerilog实例

// Quartus Prime SystemVerilog Template//// Hyper-Pipelining Module Instantiation

hyperpipe # ( .CYCLES ( ), .PACKED_WIDTH ( ), .UNPACKED_WIDTH ( ) ) hp ( .clk ( ), .din ( ), .dout ( ) );

实例-23: 可参数化的Hyper-Pipelining VHDL实体

library IEEE;use IEEE.std_logic_1164.all;library altera;use altera.altera_syn_attributes.all;

entity hyperpipe is generic ( CYCLES : integer := 1; WIDTH : integer := 1 ); port ( clk : in std_logic; din : in std_logic_vector (WIDTH - 1 downto 0); dout : out std_logic_vector (WIDTH - 1 downto 0) );end entity;

architecture arch of hyperpipe is type hyperpipe_t is array(CYCLES-1 downto 0) of std_logic_vector(WIDTH-1 downto 0); signal HR : hyperpipe_t; -- Prevent large hyperpipes from going into memory-based altshift_taps, -- since that won't take advantage of Hyper-Registers attribute altera_attribute of HR : signal is "-name AUTO_SHIFT_REGISTER_RECOGNITION off"; begin wire : if CYCLES = 0 GENERATE -- The 0 bit is just a pass-thru, when CYCLES is set to 0 dout <= din; end generate wire; hp : if CYCLES > 0 GENERATE process (clk) begin if (clk'event and clk = '1')then HR <= HR(HR'high-1 downto 0) & din;

8. 附录

S10HPHB | 2020.07.13


125


end if; end process; dout <= HR(HR'high); end generate hp;

end arch;

实例-24: 可参数化的Hyper-Pipelining VHDL实例

-- Template Declarationcomponent hyperpipe generic ( CYCLES : integer; WIDTH : integer ); port ( clk : in std_logic; din : in std_logic_vector(WIDTH - 1 downto 0); dout : out std_logic_vector(WIDTH - 1 downto 0) );end component;

-- Instantiation Template: hp : hyperpipe generic map ( CYCLES => , WIDTH => ) port map ( clk => , din => , dout => );

8.2. 附录 B：时钟使能和复位

8.2.1. 同步复位和限制

将异步复位转换成同步复位会减轻重定时限制，但不会移除所有性能限制。ALM寄存器的专用LAB-wide信号通常用于同步清零。此信号的扇出决定了综合(synthesis)期间此信号的使用。Compiler通常实现包含逻辑中小扇出的同步清零。较大扇出使用此专用信号。即便综合使用同步清零，Compiler仍然将寄存器重定时到 Hyper-Registers中。ALM寄存器的旁路模式使能此功能。当 Compiler旁路寄存器时，sclr信号和其他控制信号仍然能够被访问。

在下面实例中，LAB-wide同步清零驱动多个 ALM寄存器。同步清零路径上的 Hyper-Register可用于每个寄存器。

8. 附录

S10HPHB | 2020.07.13


126


图 133. 同步复位的重定时实例

圆圈代表 Hyper-Registers，矩形代表 ALM寄存器。未填充的部分代表空闲的位置，蓝色填充的部分表示已经占用。

LAB-WideSynchronous

Clear

a)

b)

c)

LAB-WideSynchronous

Clear

重定时期间，Compiler将(a)行中的顶端寄存器推进到 Hyper-Register中，Compiler通过旁路ALM寄存器来实现此操作，但仍使用驱动此寄存器的 SCLR逻辑。当使用 LAB-wide SCLR信号时，ALM寄存器必须存在于数据通路上，当不必使用此寄存器。

寄存器重定时将(b)行左边的寄存器推进到它的数据通路中。寄存器推进数据通路和同步清零的信号分割。Compiler必须将此寄存器推到两个网络上，一个在数据通路中，一个在同步清零路径中。这能够实现是因为每个路径都有一个 Hyper-Register。

当另一个寄存器向前推进到 ALM中时，重定时会更加复杂。如下图所示，来自同步清除端口的寄存器和来自数据路径的寄存器合并在一起。

图 134. 重定时实例– 从 ALM中推出的第二个寄存器

LAB-WideClock sclr

LAB-WideClock sclr

BeforeRetiming

AfterRetiming

由于其他寄存器共享同步清零路径，因此寄存器会在通往其他同步清零端口的路径上分离。

8. 附录

S10HPHB | 2020.07.13


127


图 135. 重定时实例–寄存器在通往其他同步清零端口的路径上分离

BeforeRetiming

AfterRetiming

在下图中，同步清零上的 Hyper-Register正在被使用，不能接受另一个寄存器。Compiler不能再次通过 ALM重定时此寄存器。

图 136. 重定时实例–同步清零上的冲突

Conflict

两个主要体系结构组件通过同步向前清零或者同步向后清零来使 ALM寄存器移动：

• 旁路 ALM寄存器的能力

• 同步清零路径上的 Hyper-Register

如果推进更多的寄存器，那么重时序会变得困难。与转换到同步复位相比，通过异步复位移除能够实现更好的性能提升。由于同步清零的广播特性，因此同步清零通常很难重定时。

8.2.1.1. 同步复位汇总

同步清零能够限制重定时的数量。同步清零存在两个问题，它们可以导致重定时出错：

• 一条短路径，通常直接从源寄存器到目的寄存器，中间没有任何逻辑。短路径通常不是一个问题，因为 Compiler将正裕量(positive slack)重定时到更长的路径。该 retiming提升了性能。但是，短路径通常连接到需要重定时的长数据路径。通过将很多寄存器重定时，寄存器被推下或拉上至这个短路径。在正常逻辑中这不是一个大问题，但由于同步清零通常具有较大的扇出，因此此问题会更加显著。

• 同步清零有很大的扇出。当主动重定时(aggressive retiming)将寄存器向上或向下推入同步清除路径时，路径会混乱，直到它们不能接受更多寄存器。这种情况会导致路径长度不平衡，并且 Compiler不再从同步清零路径中拉更多寄存器。

8. 附录

S10HPHB | 2020.07.13


128


当 Compiler通过 ALM寄存器对第二个寄存器进行重定时时会出现主动重定时(aggressiveretiming)。

图 137. 主动重定时(Aggressive Retiming)

SCLR

ALM Register withSynchronous Clear

SCLR

ALM Register Bypassed toPush Register Forward

SCLR

SCLR HyperRegister Used toPush ALM Register Backward

Intel Hyperflex 体系结构 FPGA在 SCLR路径上有一个专用的 Hyper-Register，能够将 ALM寄存器置于旁路模式。此功能使您能够推拉此寄存器。如果向前推动寄存器，则必须从 SCLR路径拉下一个寄存器，然后将两个寄存器合并。如果向后推寄存器，则必须上推一个复制寄存器到沿 SCLR路径上。您可以同时使用这两个选项。但是，当多个寄存器上下推拉寄存器到同步清零布线上时，会造成瓶颈。

请实际方式使用复位。控制逻辑主要需要同步复位。不需要同步复位的逻辑有助于时序。关于同步复位，请参考以下指南：

• 避免在必须高速运行的新代码中进行同步复位。此限制通常适用于系统处于复位状态时刷新的数据路径逻辑，或者具有系统在退出复位时忽略的值的逻辑。

• 控制逻辑通常需要一个同步复位，因此在此情况下没有避免此复位。

• 对于高速运行的现有逻辑，尽可能移除复位。如果您不了解复位时的逻辑行为，那么要保持同步复位。只有出现时序问题时才移除同步清零。

• 流水线化同步清零。此方法在寄存器必须被拉回时是不起作用的，但在寄存器必须拉进到数据通路中时是有帮助的。

• 针对不同的层次结构重复同步清零逻辑。这种技术限制了同步清零的扇出，以便 Compiler可以用本地逻辑重新清零。只有在您确定现有同步清零功能和大型扇出限制重定时后才应用此技术。此技术不难在后端使用，因为此技术不会改变设计功能。

• 针对不同时钟域和反相时钟重复同步清零。此方法能够克服一些由边界或多周期要求问题导致的重定时限制。

8.2.2. 通过时钟使能重定时

与同步复位一样，时钟使能使用专用 LAB-wide资源，在 ALM寄存器中驱动特定功能。同样，Intel Hyperflex 体系结构 FPGA支持特殊逻辑，可通过时钟使能来简化重定时逻辑。但是，诸如时钟使能(和同步清零)之类的广播控制信号很难重新定时。

8. 附录

S10HPHB | 2020.07.13


129


图 138. 代表时钟使能的 ALM下图显示了同步复位和限制章节中异步清零的重定时顺序。

LAB-WideClock Enable

LAB-WideClock Enable

顶层电路的时钟使能路径上包含一个专用的 Hyper-Register。要推回寄存器，Compiler必须分开寄存器，以便另一个寄存器被上推至时钟使能路径。在此情况下，Hyper-Register位置能够接受此寄存器，而不会有任何问题。这些特性使 Compiler能够容易地通过时钟使能向后或者向前(中间电路)来重定时一个 ALM寄存器，以改进时序。时钟使能的一个有用功能是它的逻辑通常是由同步信号生成的，这样 Compiler能够在数据通路上重定时时钟使能路径。

8. 附录

S10HPHB | 2020.07.13


130


图 139. 包括 ALM寄存器和Hyper-Register的重定时步骤和结构

CLKEN

CLKEN

CLKEN

LUTHyper-Register

Used RegisterBypassed Register

Legend

此图显示了时钟使能信号 clken(一种典型的广播类型的控制信号)的重定时。在顶层电路中，在重定时之前，电路使用一个 ALM寄存器。电路也在时钟使能和数据路径上使用 Hyper-Register。在中间电路中，ALM寄存器向前重定时到 ALM以外的 Hyper-Register中和布线架构中。ALM保留寄存器的之前值。时钟使能复用器(clock enable mux)现在根据时钟使能在之前值与新值之间进行选择。此图显示了第二个寄存器从时钟使能和数据路径向前重定时到 ALM寄存器。电路现在此路径中的 ALM寄存器。此过程可重复，多个寄存器可在一个使能的 ALM寄存器内被反复地重定时。

相关链接

同步复位和限制 (第 126页)

8.2.2.1. 广播控制信号的实例

扇出到多个目的地的广播控制信号限制重新定时。由于器件支持特定的寄存器控制信号，异步清零会限制重定时。然而，即使是同步信号(如同步清零和时钟使能)在短路径或长路径关键链的一部分时也可限制重定时。同步控制信号的使用本身不是限制性原因;而是电路的结构和布局导致了此限制。

8. 附录

S10HPHB | 2020.07.13


131


在所有的节点的输入上都必须要有一个寄存器，以通过一个节点向前重定时一个寄存器。在下图中，要通过寄存器 B重定时寄存器 A，Compiler必须要将一个寄存器从所有输入中拉起，包括时钟使能输入上的寄存器 C。另外，如果 Compiler将一个寄存器重定时到一个分支点的一侧，那么Compiler必须将此寄存器的一个副本重定时到分支点的所有侧。此要求同样应用于常规重定时和Hyper-Retiming。

图 140. 通过时钟使能重定时

B

CLKEN

B

CLKEN

A

C

A

在寄存器 B的时钟使能输入上有一个分支点。除了所示的时钟使能之外，此分支点还包括到其他目的地的额外扇出。要通过寄存器 B重定时寄存器 A，则要进行与上一个图相同的操作，但分支点的存在意味着寄存器 C的复制必须沿着分支点的另一侧重定时到寄存器 C。

图 141. 通过分支点的时钟使能重定时

CLKEN CLKEN

重定时实例

下图结合了之前的两步来展示在广播时钟使能信号或一个分支点存在的情况下一个向前 Hyper-Retiming推进的过程。

图 142. 重定时实例起点

Hyper-Retiming能将重定时的寄存器移到 Hyper-Registers中。CLKEN

Hyper-Register

Combinational Logic

每个寄存器的时钟使能在其输入上有一个 Hyper-Register位置。由于布局布线，寄存器到寄存器路径包括三个 Hyper-Register位置。不同的编译能够包括更多或更少的 Hyper-Register位置。此外，在此链的数据和时钟使能输入上有能够被 Hyper-Retimer重定时的寄存器。这些寄存器存在于 RTL中，或者通过 Pipeline Stages部分中描述的选项进行指定。

输入寄存器的一个阶段重定时到两个寄存器之间的 Hyper-Register位置。图 143 (第 133页)显示了 Hyper-Retiming前推的一个部分。时钟使能输入上的一个寄存器通过分支点重定时，一个复制到达每个时钟使能输入上 Hyper-Register位置。

8. 附录

S10HPHB | 2020.07.13


132


图 143. 重定时实例中点

CLKEN

图 144 (第 133页)显示了 Hyper-Retiming完成前推后电路中寄存器的位置。左侧寄存器的输入上的两个寄存器重定时到 Hyper-Register位置。此图在功能上等同于上两个图。第二个寄存器的时钟使能输入上的一个 Hyper-Register位置仍被占用。在通往第二个寄存器的时钟使能路径上没有其他的 Hyper-Register位置，但在输入上仍有一个可被 Compiler重定时的寄存器。

图 144. 重定时实例端点

CLKEN

图 145 (第 133页)显示了 Hyper-Retiming使用的寄存器位置(如果短路径/长路径关键链不限制此路径)。然而，由于在右侧时钟使能路径上没有 Hyper-Registers，因此 Hyper-Retiming不能重定时图中所示的电路。

图 145. 重定时实例限制条件

CLKEN Short Path LimitsPerformance

由于通往第二个寄存器的时钟使能路径没有更多的 Hyper-Register位置，因此 Compiler将此时钟使能路径报告成短路径。由于寄存器到寄存器路径太长而不能在性能要求上运行(尽管有更多的Hyper-Register位置用于重定时的寄存器)，因此 Compiler将此路径报告成长路径。

此实例简单地显示了短路径/长路径关键链的结构。事实上，双扇出负载(two-fan-out load)不是电路中的关键链。然而，广播控制信号能成为具有更高扇出的限制关键链。为提高性能，请避免或重写这种结构。

相关链接

附录 A：可参数化的流水线模块 (第 124页)

8.2.3. 解决短路径

彼此临近的重定时寄存器可能会在更高速度上触发保持违规。下图显示了一条短路径是如何限制重定时的。

8. 附录

S10HPHB | 2020.07.13


133


图 146. 短路径限制重定时

在此实例中，向前重定时推动一个寄存器到两条路径上，但一条路径有用于重定时的寄存器，而另一个路径没有。

Unusable Slot Due to Hold

#2#2

Routed Longer to Pick Up Extra Slots

#1#1

Register already used and not available for retimingRegister not used and available for retiming

Legend

在左侧电路中，如果寄存器#1将被向前重定时，那么上面路径有一个可用的 slot。然而，下面路径不能接受重定时的寄存器。重定时的寄存器与一个正在使用中的相邻寄存器太近，从而导致保持时间违规。 Compiler检测到这些短路径，并将寄存器布线到更长的路径，如右侧电路所示。这种方法确保了有足够的 slot用于重定时。

下面两个实例解决了短路径问题：

案例 1：一个设计在 400 MHz上运行，Fast Forward compile报告建议添加一个流水线阶段以达到 500 MHz，并添加第二个流水线阶段以实现 600 MHz性能。

限制原因是短路径/长路径。添加 Compiler建议的两阶段流水线(two-stage pipelining)来实现600 MHz的性能。如果限制原因还是短路径/长路径，那么这意味着 Router已经达到尝试修复设计中的短路径的极限。此时您可能已经达到目标性能，或者这不再是关键路径。

案例 2：一个设计在 400 MHz上运行，Fast Forward compile报告没有建议添加流水线阶段。

如果短路径/长路径是重定时的直接限制原因，那么这意味着 Router已经达到尝试修复短路径的极限。将流水线阶段添加到报告的路径中是没有帮助的。您必须优化设计。

彼此临近的重定时寄存器可能会在更高速度上触发保持违规。Compiler在 Path Info下的重定时报告中报告此情况。如果没有足够的 Hyper-Registers，Compiler也会报告短路径。当节点包括短路径以及长路径时，将流水线寄存器添加到这两条路径将有助于时序。

8. 附录

S10HPHB | 2020.07.13


134


9. Intel Hyperflex 体系结构高性能设计手册存档

Intel Quartus Prime软件版本

用户指南

19.4 Intel Stratix 10 High-Performance Design Handbook




S10HPHB | 2020.07.13

反馈



https://www.intel.com/content/dam/altera-www/global/en_US/pdfs/literature/hb/stratix-10/archives/s10_hp_hb-19-4.pdf








10. Intel Hyperflex 体系结构高性能设计手册修订历史

文档版本 Intel QuartusPrime版本

修订内容

2020.07.13 20.1 • 将"Retiming Example – Second Register Pushes out of ALM"图中的参考从异步复位更改成同步复位。

• 更新了"Initial Power-Up Conditions"部分，以反映最新的 IP和 QSF选项的默认状态。

• 删除了过时的"Synchronous Start System Clock Gating Examples"主题。

2020.05.01 20.1 • 增添了"Clock Domain Crossing Constraint Guidelines"主题。• 在"Metastability Synchronizers"主题中添加了 Synchronization Register

Chain Length assignment。

2019.12.16 19.4.0 • 对 Intel Agilex 器件引用编程文件生成支持。• 在"Preserving Registers During Synthesis"主题中添加了详细信息，示例和表格。

• 在"Reset Strategies"主题中添加了关于复位释放要求的注释和链接。• 增添了"Compiling Submodules Independently"主题。

2019.11.15 19.3.0 • 在"Specifying a Latency-Insensitive False Path"中添加了关于分配优先级的注释。

• 在"Step 2: Instantiate the Variable Latency Module"中澄清了 vlat模块的插入。

2019.11.04 19.3.0 • 重命名 Intel Stratix 10高性能设计手册，更新并包括 Intel Agilex 器件。• 增添了"使用 Design Assistant进行设计规则检查"主题。• 增添了"Running Design Assistant During Compilation"主题。• 增添了"在分析模式下运行 Design Assistant"主题。• 增添了"Cross-Probing from Design Assistant"主题。• 增添了"从 Chip Planner运行 Design Assistant"主题。• 增添了"从 Timing Analyzer运行 Design Assistant"主题。• 增添了"Hyper-Retimer Readiness Rules"主题和特定规则描述的链接。

2019.07.01 19.2.0 • 改进了截图质量。

• 更新了"Step 1：Compile the Base Design"。• 在"Step 2: Add Pipeline Stages and Remove Asynchronous Resets"中增添了添加 5个流水线级的目的的更多详细信息。

• 少量措辞修改，更新了图表参考。

• 更新了设计实例文件的链接。

• 更新了"Synchronous Resets and Limitations"主题中的图。

2018.12.30 18.1.0 • 增添了可变延迟自动流水线特性的说明。

• 更新了"Initial Conditions and Hyper-Registers"部分。• 增添了新主题"Synchronous Start System Example"。• 增添了新主题"Implementing Clock Gating"。

2018.10.04 18.0.0 • 在"Fast Forward Limit"中作了少量文本变更。• 在"Delay Lines"中作了少量文本变更。

2018.10.01 18.0.0 • 更正了"Retiming through RAMs and DSPs"中的拼写错误。

继续...

S10HPHB | 2020.07.13

反馈







文档版本 Intel QuartusPrime版本

修订内容

2018.07.12 18.0.0 • 更新了 Appendix A: Parameterizable Pipeline Modules中的所有代码模板。• 将 Dual Clock Skid Buffer Example添加到 Flow Control with Skid Buffers主题。

• 更新了各种屏幕截图，以提高结果的可见性和准确性。

2018.06.22 18.0.0 更正了 Loop Pipelining Demonstration中 Original Loop Structure图中的错误。

2018.05.22 18.0.0 • 将 Removing Asynchronous Clears重命名为 Removing AsynchronousResets。

• 将 Removing Asynchronous Resets中的代码图像转换成代码示例，并更正了代码语法。

• 更新了 Removing Asynchronous Resets图像中的信号名称，以匹配代码示例。

• 更正了 Shannon's Decomposition Example中的语法错误。• 将包括 skid buffer的流程控制的信息移到 Flow Control with Skid Buffers部分中。

• 增强了 FIFO Flow Control Loop with Two Skid Buffers图的描述。• 澄清了 Improved FIFO Flow Control Loop with Almost Full instead of Full

FIFO图的描述。

2018.05.07 18.0.0 • 移除了对 dont_touch综合属性的引用。• 添加了 Retiming through RAMs and DSPs主题和图。• 澄清了 preserve_syn_only综合属性的使用。

• 更新了 Intel Quartus Prime Pro Edition截图。• 更正了 Round Robin Scheduler实例中的语法错误。• 更新了 Retime阶段的描述，包括了传统的寄存器重定时。

2018.02.05 17.1.1 更新了Median Filter设计实例文件的链接。

日期版本修订内容

2017.11.06 17.1.0 • 修订了设计示例演练步骤和结果。

• 对每一阶段可用的设计实例提供了链接。

• 将逐步设计编译指南移到 Intel Quartus Prime Pro Edition手册中的设计编译章节。

• 添加了 Ternary Adders主题和示例。• 添加了 Loop Pipelining主题和示例。• 添加了“复位流程要求”报告的描述。

• 对最新的 Intel 命名标准作了更新。

2017.05.08 Quartus Prime Pro v17.1Stratix 10 ES Editions

• 将软件支持版本更新到 Quartus Prime Pro v17.1 Stratix 10 ES Editions。• 添加了“初始上电条件”主题。

• 增加了“重定时复位序列”主题。

• 添加了高速时钟域的指南。

• 添加了 Fitter Overconstraints主题。• 描述了 Fitter Finalize阶段中的 Hold Fix-up。• 添加了有关 Fast Forward编译支持 RAM和 DSP模块重定时的声明。• 在 read-modify-write存储器描述中增添了关于 coherent RAM的详细信息。• 添加了 Fast Forward Viewer和 Hyper-Optimization Advisor的说明。• 添加了 Advanced HyperFlex Settings主题。• 添加了 Prevent Register Retiming主题。• 添加了 Preserve Registers During Synthesis主题。• 添加了 Fitter Commands主题。• 添加了 Finalize Stage Reports主题。

继续...


S10HPHB | 2020.07.13


137


日期版本修订内容

• 在编译流程中使用新的 GUI步骤取代了命令行指令。• 描述了 Compilation Dashboard中的并发分析控制。• 合并重复的内容，将附录部分整合在一起。

• 更新图表和截图。

2016.08.07 2016.08.07 • 增添了时钟交叉和初始条件时序限制详情。

• 通过实例描述了真双端口存储器支持和存储器宽度比率

• 在“设计实例演练(Design Example Walk-through)”中更新了代码样例和解释• 对所提供的设计实例文件添加了参考

• Intel 重新命名。• 针对软件 GUI和性能的最新变更作了更新

2016.03.16 2016.03.16 首次公开发行。


S10HPHB | 2020.07.13


138


Intel Hyperflex 体系结构高性能设计手册 · 2021. 2. 18. · Intel® Hyperflex ™...

Documents

Transcript of Intel Hyperflex 体系结构高性能设计手册 · 2021. 2. 18. · Intel® Hyperflex ™...

Intel Hyperflex 体系结构高性能设计手 册 · 2021. 2. 18. · Intel® Hyperflex ™...

Documents

Transcript of Intel Hyperflex 体系结构高性能设计手 册 · 2021. 2. 18. · Intel® Hyperflex ™...

Intel Hyperflex 体系结构高性能设计手册 · 2021. 2. 18. · Intel® Hyperflex ™...

Transcript of Intel Hyperflex 体系结构高性能设计手册 · 2021. 2. 18. · Intel® Hyperflex ™...