Verilog组合与时序电路建模

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

组合逻辑建模

备菜台上贴着一张“即时响应操作单”：只要台面上出现任何新的食材（输入），切配师傅就立刻根据操作单切出对应的菜（输出），台上不保存任何“昨天”的信息。在 Verilog 中，这张操作单就是 always @* 组合块。@* 相当于告诉综合工具：“把操作单里出现过的所有输入都装进敏感列表，任一输入一变，就重新算一次输出。”块内使用阻塞赋值 =，就像操作单上的步骤从上到下依次执行，中间结果能被后面的步骤直接看到，适合描述这种“看到什么算什么”的纯组合关系。

组合逻辑的衡量标准只有一个：输出是不是只由当前输入决定。如果某条输入路径下，输出没有被赋值，综合器就会认为“这里需要保存旧值”，于是偷偷生成一个锁存器（latch）——这就像上一桌客人的剩菜没被清走，被误当成了新菜端给下一桌。典型的安全写法是 if/else 配对完整，或在块首给所有输出赋默认值，确保每个输入组合都有唯一输出。

$$\displaystyle Y = (A \land B) \lor C$$

1. 输入与门：A 和 B 先经过一个与门，只有二者都为 1 时中间结果才为 1。

$$\displaystyle A \land B$$

2. 输出或门：中间结果再与 C 进入或门，只要其中任意一个为 1，最终输出就为 1。

$$\displaystyle (A \land B) \lor C$$

3. 信号更新：V 组合块中，A、B、C 都被隐含在 @* 敏感列表里，任意一个翻转都会触发重新计算。

$$\displaystyle \text{敏感列表} = \{A, B, C\}$$

所以，写组合 always 时，脑子里要有一张“备菜台即时响应单”：输入到输出的路径上没有任何记忆元件，所有赋值都用 =，并且务必让每种输入组合都有明确的去向，否则就会把上一桌的剩菜留给下一桌。

连续赋值与时延

备菜台旁边还有一台自动切菜机，只要食材从左边滑槽进去，切好的菜立刻就从右边滑槽出来，中间没有人工记忆。Verilog 的 assign 连续赋值就是这台切菜机：它把表达式的输出“钉”在一根线网（wire）上，只要右边任何输入变化，左边线网的电平立刻跟随更新。它和 always 组合块最大的不同在于，assign 写在过程块之外，更像一条永远生效的电气连线，而不是需要触发的工序单。

不过，真实的切菜机传送带也有物理延迟：食材滑进去后，要过 5 个单位时间才从出口出来。Verilog 允许你写 assign #5 Y = A & B; 来表示这种“传输时延”。但你一定要记住，这只是给仿真器看的慢动作提示，综合工具不会为 #5 生成任何实际的延迟电路——真实电路的延迟由门级物理决定，而不是这段代码。因此，可综合的 RTL 代码中几乎不该出现 #delay，否则仿真和实际硬件会对不上账。

$$\displaystyle Y(t + \Delta) = A(t) \land B(t)$$

1. 输入采样：在时刻 t 读取 A 和 B 的当前电平。

$$\displaystyle A(t),\ B(t)$$

2. 逻辑运算：在线网内部完成与运算，得到中间结果。

$$\displaystyle A(t) \land B(t)$$

3. 时延传递：中间结果经过 Δ 个时间单位后才反映到输出 Y 上。

$$\displaystyle Y(t + \Delta) = 中间结果$$

assign 是描述组合逻辑最简洁的方式，它天生没有记忆，天然可综合；而 #5 这种时延写法只属于仿真世界的“传送带慢动作”，不要指望综合工具把它变成物理延迟。

时钟驱动时序

现在来到灶台区。这里的规则完全不同：食材（输入 D）放在灶台边，锅里有没有东西（输出 Q）不会立刻变化，只有听到定时器铃声（时钟上升沿）响一次，厨师才把灶台边的新食材放进锅里，同时倒掉锅里原本的旧菜。这个“铃声一响，整体换一下状态”的动作，就是时序逻辑的核心。在 Verilog 中，它写作 always @(posedge clk)，posedge 表示只关心时钟信号从 0 跳变到 1 的那一瞬间。

时序块内部必须使用非阻塞赋值 <=。它和组合逻辑的 = 有本质区别：<= 的意思是“所有厨师的右手同时取旧锅里的记录，左手同时放新食材，然后统一落勺”。也就是说，右边表达式的值全部用进入时钟沿之前的状态计算，计算完后在同一时刻统一更新左边的寄存器。这正是为了防止多个寄存器互相串味：如果像组合逻辑那样一步步执行，后一个寄存器就会看到前一个刚更新的新值，导致电路行为完全错误。

$$\displaystyle Q_{n+1} = D_n$$

1. 时钟边沿触发：posedge clk 表示只在时钟从低变高的瞬间才执行块内语句。

$$\displaystyle \uparrow \text{clk}$$

2. 采样旧值：进入边沿那一刻，先读取当前 D 的值，记为 D_n。

$$\displaystyle D_n = D(t_{\text{edge}})$$

3. 统一更新：边沿结束后，Q 被更新为刚才采样的 D_n，其余时间 Q 保持不变。

$$\displaystyle Q_{n+1} \gets D_n$$

时序逻辑的寄存器就像一口有记忆的锅，铃声不响不动勺。记住：时序 always 块中用 <=，组合 always 块中用 =，这两条规则就像后厨里“备菜台用手抓、灶台用长勺”的卫生分工，一旦混用，菜品的味道就全乱了。

寄存器与复位策略

每天开业前，后厨总管都要检查所有锅具：锅里绝不能残留昨天没卖完的菜。这个“开业清零”的动作对应数字电路中的复位（reset）策略。一个寄存器在刚上电时状态是未知的，如果不先复位，它输出的 X 值就会像馊掉的剩菜一样污染后续所有计算。复位通常有两种写法：同步复位和异步复位。

同步复位像“厨师只在闹钟响时顺便看一眼复位按钮”——复位信号只有在时钟上升沿到来时才能生效；它生成的电路更省资源，但对复位信号的持续时间要求较高。异步复位像“火灾警报一响，不管闹钟是否在响都立刻关火”——复位信号电平一变，输出立刻清零，不需要等时钟；它响应快，但复位撤销时若不靠近时钟沿，容易产生亚稳态。两者都要求 if 分支里写复位、else 分支里写正常工作逻辑，优先级由 if/else 嵌套顺序决定。

$$\displaystyle Q_{n+1} = \begin{cases} 0, & \text{if } \overline{rst_n}=1 \\ D_n, & \text{otherwise} \end{cases}$$

1. 复位判定：先看 rst_n 是否有效，低电平有效意味着 rst_n = 0 时触发复位。

$$\displaystyle \overline{rst_n} = 1$$

2. 清零分支：复位有效时，Q 无条件变为 0，这就是“清空旧锅”。

$$\displaystyle Q_{n+1} = 0$$

3. 数据分支：复位无效时，Q 才在下一个时钟沿采样 D。

$$\displaystyle Q_{n+1} = D_n$$

复位策略决定了一个电路能否在混乱的上电初期迅速走上正轨。异步复位负责“紧急清锅”，同步复位负责“按点清锅”，实际工程中常采用“异步复位、同步释放”的组合拳，但无论哪种，都要保证每个寄存器都能被可靠地拉回初始状态。

算术运算单元

后厨里有一台“分量换算台”：客人点了一桌菜，换算台要把所有食材用量加总。加法器就是数字电路里的分量换算台，它是纯组合逻辑——输入 A 和 B 一到，和 S 立刻算好。但这里有个后厨新手常踩的坑：进位（carry）。一位加法除了本位和，还要把低位的进位传上来，就像算总账时不能漏掉上一桌的零头。

多位加法器可以用一个表达式直接写出，综合工具会帮你生成进位链。乘法器则更像“多次称量”：一个 N 位乘 N 位的乘法，需要把 N 个部分积相加，组合路径很长，延迟很大。如果每个时钟周期都强求一次算完，时钟频率就会被拖慢。这时就需要把大运算拆成多拍，用寄存器暂存中间结果——这就从“备菜台”转移到了“灶台区”。另一个关键点是位宽：两个 N 位数相加，结果最多有 N+1 位；相乘则最多有 2N 位。位宽不够就像秤的量程不够，会直接把多的部分丢掉。

$$\displaystyle \text{Sum} = (A + B + C_{\text{in}}) \bmod 2^N$$

1. 加数输入：A 和 B 是 N 位二进制数，C_in 是来自低位的进位。

$$\displaystyle A + B + C_{\text{in}}$$

2. 模运算：结果可能达到 N+1 位，超出 N 位的部分会被舍去，等价于对 2^N 取模。

$$\displaystyle \bmod 2^N$$

3. 输出拆分：取模结果作为本位和 Sum，而被舍去的最高位就是输出进位 C_out。

$$\displaystyle C_{\text{out}} = (A + B + C_{\text{in}}) \ge 2^N$$

算术单元是 AI 加速器等计算芯片的心脏。加法器这类“即时称量”适合用组合逻辑描述；乘法器这类“多次称量”则要权衡位宽、级数和时钟频率，必要时用多拍寄存器把长路径切短。

流水线寄存器

想象后厨出菜要经过“切配 → 烹饪 → 装盘”三个工位，如果所有工序都由一个厨师从头做到尾，那么第一道菜做完之前，第二道菜只能在门口等着，整体翻台率很低。流水线的思路是：在每两个工位之间放一个传菜托盘（寄存器），切配师傅把半成品放上托盘就走，立刻开始切下一道菜；烹饪师傅从托盘取半成品加工，再放上下一个托盘。这样三个工位可以同时处理三道菜，虽然单道菜上桌的总时间没变短，但单位时间端出的菜多了——吞吐率提高了。

在 RTL 中，流水线就是在一段长组合逻辑中间插入寄存器，把单拍延迟从“一大段”切成“几小段”。因为时钟周期只需要满足最慢的一小段，而不是整个长路径，所以最高时钟频率能大幅提升。划分流水线时要注意时序平衡：如果一段切得很粗、另一段切得很细，快慢不均，整体还是要等最慢的那段，就像三个工位中最慢的厨师决定了整条线的节奏。

$$\displaystyle F_{\max} = \frac{1}{t_{\text{clk-q}} + t_{\text{logic}} + t_{\text{setup}}}$$

1. 时钟到输出：时钟沿到后，寄存器需要 t_clk-q 时间才能把 Q 端稳定输出。

$$\displaystyle t_{\text{clk-q}}$$

2. 组合逻辑延迟：信号经过组合逻辑需要 t_logic，这是流水线要重点切割的对象。

$$\displaystyle t_{\text{logic}}$$

3. 建立时间：下一个寄存器要求数据在时钟沿前提前 t_setup 到达。

$$\displaystyle t_{\text{setup}}$$

4. 周期约束：这三者之和必须小于等于时钟周期，于是得到最大频率公式。

$$\displaystyle T_{\text{clk}} \ge t_{\text{clk-q}} + t_{\text{logic}} + t_{\text{setup}}$$

流水线寄存器就像传菜托盘，把原本漫长的一条路切成多个可以同时工作的隔间。它能显著提升吞吐率，代价是增加了寄存器数量和单条数据的延迟，这正是面积、延迟与吞吐率之间的经典权衡。

RTL建模规范

后厨如果卫生条例混乱，备菜台和灶台区混用，迟早会吃出问题。RTL 建模规范就是后厨的卫生条例，它不是可综合性的硬性红线，更是团队协作和仿真一致性的保障。第一条铁律是：组合逻辑和时序逻辑必须分开写在不同的 always 块里。组合块用 =，时序块用 <=，如果混在一起，仿真器逐条执行的行为和真实硬件并行更新的行为会产生差异，就像按“手抓菜”的规则去操作灶台，锅气全被搅乱了。

第二条铁律是敏感列表必须完整。always @* 是组合逻辑最安全的选择，它能自动收集所有被读到的信号；手动写敏感列表时一旦漏掉某个输入，仿真时该输入变化不会触发块内更新，而综合时工具会按“完整”电路生成，导致仿真和综合结果不一致——这就是著名的“仿真与综合不匹配”陷阱。第三条铁律是 if/else 必须配对完整，否则会生成锁存器；case 语句同样要写出 default 分支，确保穷尽所有情况。

$$\displaystyle Y = \text{sel} \cdot A + \overline{\text{sel}} \cdot B$$

1. 选择信号：sel 作为控制位，决定输出走 A 还是 B 这条路。

$$\displaystyle \text{sel}, \ \overline{\text{sel}}$$

2. 各自通路：sel 与 A 相与，sel 取反后与 B 相与。

$$\displaystyle \text{sel} \cdot A + \overline{\text{sel}} \cdot B$$

3. 完整输出：两个通路一加，任意 sel 取值都对应一个确定的 Y，不会出现“没赋值”的空档。

$$\displaystyle Y = \text{sel} \cdot A + \overline{\text{sel}} \cdot B$$

RTL 规范的本质，就是让代码的每一条分支都像后厨的每一道工序一样明确可追踪。组合与时序分离、敏感列表完整、条件分支穷尽，这三条纪律能避免绝大多数仿真与综合行为不一致的“后厨事故”。

综合优化技巧

后厨运营一段时间后，总管开始琢磨怎么用同样的人手服务更多客人：能不能让两台用不到的设备共用一个切菜机？能不能把两个闲着的传菜托盘合并？这就对应综合优化中经典的资源共享与寄存器合并。当两个模块不会同时使用某个乘法器时，可以用一个乘法器加多路选择器来替换，面积立刻缩小；当多个寄存器的使能条件相同时，也可以合并成一个更宽的寄存器，减少触发器数量。

另一类优化针对关键路径——整条电路中最慢的那一段路。它对时钟频率有决定性作用，就像最慢的厨师决定了整条流水线的节奏。常见的做法包括路径重组、逻辑等价变换、在路径中间插一级流水寄存器，以及调整运算符优先级减少级联层次。但优化永远是权衡：追求极端频率会消耗更多寄存器和面积，追求最小面积可能拖慢速度。综合工具通常先让开发者用约束指定目标，再由工具在面积、时序、功耗之间寻找平衡。

$$\displaystyle \text{Area}_{\text{shared}} = A_{\text{mul}} + A_{\text{mux}} < 2 \cdot A_{\text{mul}}$$

1. 独立实现面积：如果两个运算各用一个乘法器，总面积为两个乘法器面积之和。

$$\displaystyle 2 \cdot A_{\text{mul}}$$

2. 共享实现面积：共用一个乘法器，但需要多路选择器在两条数据通路间切换。

$$\displaystyle A_{\text{mul}} + A_{\text{mux}}$$

3. 大小比较：当选择器面积远小于一个乘法器时，共享方案明显更省面积。

$$\displaystyle A_{\text{mul}} + A_{\text{mux}} < 2 \cdot A_{\text{mul}}$$

综合优化就像后厨的精细化运营：共享设备、合并托盘、调整工序顺序，目标都是让同样的资源端出更多菜。但天下没有免费的午餐，每次优化都在面积、时序和功耗之间做取舍，而聪明的 RTL 工程师知道把功夫花在最关键的瓶颈路径上。

AI 应用场景

Python 演示

# 用 Python 模拟 Verilog 组合逻辑与时序逻辑的两种建模方式class FlipFlop:    def __init__(self):        self.reg_q = 0        self._prev_clk = 0     def update(self, clk, d):        # 等价于 always @(posedge clk) Q <= D;        if self._prev_clk == 0 and clk == 1:            self.reg_q = d        self._prev_clk = clk  def square_wave(t, period, high_len):    cycle = t % period    return 1 if cycle < high_len else 0  def xor_gate(a, b):    # 组合逻辑: 输出只由当前输入决定    return a ^ b  def main():    ff = FlipFlop()    for t in range(1, 41):        clk = square_wave(t, 8, 4)        d = 1 if (t // 5) % 2 == 0 else 0        comb_out = xor_gate(d, 1)        ff.update(clk, d)        if t % 8 == 0:            print(f"t={t:2d} D={d} C={comb_out} Q={ff.reg_q}")  if __name__ == "__main__":    main()

1. class FlipFlop:对应 Verilog 中的 reg 寄存器，用 reg_q 保存当前状态。
2. if self._prev_clk == 0 and clk == 1:等价于 always @(posedge clk)，只有检测到上升沿才触发。
3. self.reg_q = d等价于非阻塞赋值 Q <= D，在时钟沿统一更新。
4. def xor_gate(a, b): return a ^ b对应 assign C = A ^ B;，输入变化输出立即变化。
5. ff.update(clk, d)每个时钟周期驱动寄存器采样一次，模拟综合后硬件的并行行为。

常见误区

面试题