同一份代码,在开发板上用五十兆时钟跑了一星期都没事,换到两百兆就时不时算错一位;或者状态机大部分时间正常,偶尔多走一步,把一个不该发的请求发了出去。把时钟降下来问题就消失,于是很多人以为「就是跑太快了」,却说不清到底快在哪里、慢在哪里。

上一页讲清楚了触发器只在时钟边沿采样。这一篇把触发器连起来,讲三件事:怎么用状态机描述「下一步做什么」,时钟周期为什么不能随便定,以及建立时间和保持时间这两个参数到底约束了谁。这三件事合起来,就是数字电路从「能跑」到「稳定能跑」的分界线。

先把结构说清楚。组合逻辑负责算,触发器负责记,时钟负责让大家同时更新。只要有一条组合路径在一个时钟周期内没算完,或者算得太快、在采样之后又变了,结果就会错。前者叫建立时间违例,后者叫保持时间违例。文中的时序余量表、状态机逐拍输出是本机跑出来的,具体工艺下的标准单元参数和上板波形未在本机实测。

先看现象:降频就好,说明问题在时间不在逻辑

这是时序问题最典型的特征:逻辑本身是对的,给它更多时间就对了。五十兆对应二十纳秒一个周期,两百兆只有五纳秒一个周期,同一段组合逻辑在二十纳秒里算得完,在五纳秒里算不完,后级触发器在时钟沿到来时拿到的还是上一拍的中间值。

另一类现象更迷惑:大多数数据都对,只有某些特定的输入组合错。这往往不是逻辑写错,而是那条路径只在特定数据下才最长。比如加法器的进位链,只有进位一路传到最高位时延迟才最大;平时进位在中间就断掉了,路径短,看起来一切正常。测试向量的覆盖不够,就很容易漏掉这种问题。

还有一种是「偶尔」出错,重启又好了。这种通常和亚稳态、时钟偏斜或者复位释放时机有关,靠改逻辑是改不掉的,必须从时序约束和同步策略入手。

时钟:给所有触发器一个共同的节拍

时钟,clock,是一路周期性翻转的方波。它的周期决定一拍有多长,频率是周期的倒数,占空比是高电平占一个周期的比例。数字电路绝大多数是同步设计,意思是所有触发器共用同一个时钟,大家在同一类边沿一起更新,这样每一拍的状态才是确定的。

同步设计的好处是分析简单:只要保证每一拍之间组合逻辑都算完,整个电路就正确。代价是所有触发器都要接时钟,时钟要驱动成百上千个负载,布线长、功耗大,而且时钟本身的偏差会直接吃掉时序余量。

实际芯片里,时钟不是一根理想导线。时钟偏斜,clock skew,指同一个时钟到达不同触发器的时刻有先有后;时钟抖动,jitter,指时钟周期本身在随机变化。两者都会让「同一时刻」这个假设打折扣,计算余量时必须留出位置。

状态机:把「下一步做什么」写成表

状态机,finite state machine,简称 FSM,是一种用有限个状态描述流程的电路。它由三部分组成:当前状态存在触发器里,下一状态由组合逻辑根据当前状态和输入算出来,输出也由组合逻辑算出来。时钟每来一拍,当前状态就更新成下一状态。

按输出怎么算,分两类。摩尔型,Moore,输出只取决于当前状态;米利型,Mealy,输出同时取决于当前状态和输入。米利型响应快一拍,但输出可能随输入变化产生毛刺;摩尔型输出更干净,但要多一个状态。选哪种取决于输出要不要直接驱动异步信号。

写法上,常见的是三段式:第一段用always块描述状态寄存器,只在时钟边沿更新;第二段用组合逻辑算下一状态;第三段算输出。分成三段的好处是每段职责清楚,综合工具容易推断出触发器,也不容易写出锁存器。把三件事塞进一个always块也能跑,但一旦漏了某个分支,综合工具就会推断出锁存器,这正是上一篇说的那种坑。

写法优点风险
一段式代码短状态、转移、输出混在一起,漏分支就推断出锁存器
两段式状态和输出分开组合输出仍有毛刺,驱动异步信号要小心
三段式职责清楚,时序好分析代码略长,寄存器化输出会多一拍延迟

建立时间:数据要比时钟早到

建立时间,setup time,记作 tsu,指数据在时钟采样边沿到来之前,必须提前稳定的一段时间。触发器内部要把输入电平放大、锁住,需要一点时间;如果数据在边沿附近才变,内部电路来不及分辨,就会进入亚稳态。

所以一条路径能不能在一拍内走完,不是看「平均延迟」,而是看最坏情况:前级触发器从时钟沿到输出稳定的时间 tco,加上中间组合逻辑的最长延迟 tcomb,必须早于后级触发器的建立时间窗口开始之前到达。写成一拍的时间预算,就是周期要大于等于 tco 加 tcomb 加 tsu,再留出时钟偏斜的位置。

这条式子里,tco 和 tsu 由器件工艺决定,设计者改不了;能改的只有 tcomb。想提高频率,本质上就是想办法缩短最长的组合路径,比如把一个大加法拆成两级、把深组合逻辑中间打一拍。流水线那一篇讲的切分,用的就是这个道理。

保持时间:数据不能变得太快

保持时间,hold time,记作 th,指数据在采样边沿之后还必须保持稳定的一段时间。很多人只记得建立时间,忽略了保持时间,因为它在低频下几乎不会出问题。

原因在于保持时间检查与频率无关。时钟周期变长,只影响建立时间余量,不会让保持时间变好。如果一条路径的组合延迟太短,前级触发器的新数据在同一个时钟沿之后很快就冲到了后级,而后级触发器还在要求旧数据保持,就会发生保持时间违例。这种错误在高频低频都会出现,而且更隐蔽,因为缩短周期并不能修好它。

修保持时间违例的办法和修建立时间相反:不是缩短路径,而是增加延迟。常见的做法是在路径上插入缓冲器,或者调整布线。这也解释了为什么综合工具报出保持违例时,不能顺着「优化速度」的思路去改,方向会完全相反。

余量:把公式代进去算一遍

把上面两条合起来,就有两个余量。建立余量等于时钟周期减去 tco、最长组合延迟、tsu 和时钟偏斜之和;保持余量等于 tco 加最短组合延迟减去偏斜,再减去 th。余量为正表示满足,为负表示违例,负得越多越危险。

下面这张表用一组假设参数算出来:tco 取 1.5 纳秒,tsu 取 0.8 纳秒,时钟偏斜取 0.2 纳秒,保持时间取 0.6 纳秒,五条组合路径的最长延迟从 2.0 到 9.1 纳秒不等。这些数字是模型假设,不是某个具体工艺的实测值,只用来看趋势。

路径组合延迟50MHz 余量100MHz150MHz200MHz
操作数旁路2.0 ns15.505.502.170.50
4 位加法3.6 ns13.903.900.57负 1.10
8 位比较5.4 ns12.102.10负 1.23负 2.90
乘法器一级7.8 ns9.70负 0.30负 3.63负 5.30
组合译码加深9.1 ns8.40负 1.60负 4.93负 6.60

读这张表的方法:同一个路径,频率翻倍,余量不是简单减半,而是被周期直接压掉。五十兆时所有路径都有大把余量,一百兆时乘法器一级已经开始违例,两百兆时连四位数加法都撑不住。这解释了为什么降频能救活一个设计,也解释了为什么「在板上跑通了」不等于「设计是对的」。

偏斜、抖动与跨时钟域

时钟偏斜可以是正的也可以是负的。如果时钟先到后级触发器,后级会更早采样,留给前级组合逻辑的时间变少,建立余量被吃掉;如果时钟后到后级,建立余量变好,但保持余量变差。做时钟树的目的之一就是把偏斜控制在一个范围内,而不是简单地把线接过去。

抖动则是时钟周期在时间轴上的随机漂移,来自锁相环、电源噪声和温度变化。它同样直接扣减建立余量,所以在高速设计里,时序报告通常会区分最好和最坏两种情况。

当两个模块用不同时钟,或者外部信号异步进来,就不能再套用同一套公式了。正确做法是先做跨时钟域处理,用两级触发器同步,或者用异步先进先出缓冲。直接把异步信号接到组合逻辑上,等于把亚稳态概率放大到整个电路,早晚会出错。这一点和流水线那一篇里跨级传递要打拍是同一件事。

跑一遍:余量计算与 1011 序列检测

下面这段 Python 先按上面的假设参数算五条路径在四个频率下的建立余量,再算前三条路径的保持余量,最后用一个米利型状态机检测输入序列里的 1011,允许重叠匹配。输入是十一个比特,状态从 S0 开始,分别表示已经匹配到空、1、10、101 的前缀。

path            tcomb(ns) | 50MHz slack | 100MHz slack | 150MHz slack | 200MHz slack
操作数旁路               2.0 |    15.50 |     5.50 |     2.17 |     0.50
4 位加法               3.6 |    13.90 |     3.90 |     0.57 |    -1.10
8 位比较               5.4 |    12.10 |     2.10 |    -1.23 |    -2.90
乘法器一级               7.8 |     9.70 |    -0.30 |    -3.63 |    -5.30
组合译码加深              9.1 |     8.40 |    -1.60 |    -4.93 |    -6.60
positive slack = timing met; negative = setup violation
hold check 操作数旁路: margin = 2.70 ns
hold check 4 位加法: margin = 4.30 ns
hold check 8 位比较: margin = 6.10 ns

1011 detector, input 10110111011:
  cycle  1: in=1 next_state=S1 out=0
  cycle  2: in=0 next_state=S2 out=0
  cycle  3: in=1 next_state=S3 out=0
  cycle  4: in=1 next_state=S1 out=1
  cycle  5: in=0 next_state=S2 out=0
  cycle  6: in=1 next_state=S3 out=0
  cycle  7: in=1 next_state=S1 out=1
  cycle  8: in=1 next_state=S1 out=0
  cycle  9: in=0 next_state=S2 out=0
  cycle 10: in=1 next_state=S3 out=0
  cycle 11: in=1 next_state=S1 out=1
matches at cycles: [4, 7, 11]

状态机的输出很值得看。第四拍输入 1 时,状态从 S3 回到 S1,同时输出 1,这就是米利型:输出和最后一个输入在同一拍产生,不用多等一个时钟。第七拍和第十一拍又各命中一次,说明匹配是允许重叠的,前一次命中的最后一个 1 还能作为下一次的开头。如果改成摩尔型,输出会晚一拍,状态表也要多一个「已匹配」状态。

保持余量那三行则说明另一件事:三条路径的保持余量都是正的,而且和频率无关。这正是前面强调的点,降频只能救建立违例,救不了保持违例。文中数值是模型计算结果,具体工艺参数未在本机实测。

现象对照:这些症状先查哪儿

时序问题的难点是现象和原因隔得远。下表把常见症状、真实原因和第一步该查什么放在一起,方便按现象倒推。

现象真实原因第一步查什么
降频就正常,升频就错最长组合路径超过一个时钟周期看时序报告里最长的几条路径和负余量
只有特定输入才错那组输入激活了最长路径,平时路径较短用边界值和进位传播最长的向量做测试
低频也出错,且换批次变化保持时间违例,或依赖了锁存器竞态查最短路径延迟和最小余量,别只看最长路径
状态机偶尔多走一步下一状态组合逻辑有毛刺,或用了未初始化状态查状态编码是否覆盖全部分支,输出是否寄存
综合工具报推断出锁存器组合always块漏了分支或敏感列表不全检查每个 if 和 case 是否都有默认赋值
跨模块数据偶尔错异步信号直接进逻辑,采样时亚稳态查是否做了两级同步或异步缓冲
同一设计换板子就不行时钟偏斜和布线延迟不同,余量被吃掉对比两块板的时钟树和时序报告
复位释放后第一拍异常异步复位释放太靠近时钟沿查是否做了异步复位、同步释放

边界与代价

第一,时序余量是一个统计意义上的保证,不是绝对正确。工艺、电压、温度都会让延迟漂移,时序分析要按最坏角算。余量为正只说明在建模覆盖的范围内成立,建模没覆盖的毛刺和亚稳态仍然可能出错,所以要配合同步策略和仿真验证。

第二,提高频率不是免费的。缩短组合路径要么加流水级、要么加面积,要么两者都加。流水级多了,延迟和功耗上升,控制复杂度也上升。频率、面积、功耗这三个量在大多数设计里此消彼长,选哪个取决于产品更在意什么。

第三,状态机的状态编码会影响速度和面积。二进制编码用的触发器少,但下一状态逻辑深;独热编码每个状态一个触发器,下一状态逻辑浅、速度快,但触发器多。状态数少的时候独热更常见,状态数多的时候要重新算账。

第四,异步逻辑不是不能用,而是很难验证。它的正确性依赖延迟和竞态,换工艺、换温度就可能失效。除非有明确理由,比如低功耗握手或跨时钟域接口,否则优先用同步设计。

第五,时序约束要写全。只约束了主时钟,漏了生成时钟、输入输出延迟和跨时钟域路径,工具就会按默认值分析,报告好看但和实际不符。约束文件本身也是设计的一部分,需要和代码一起维护。

今天就能验证的五个练习

  1. 用本文的公式,把时钟周期设成十纳秒,算一条组合延迟为六纳秒的路径的建立余量,再判断它在什么频率下开始违例。
  2. 写一个检测 1011 的状态机,先用米利型,再改成摩尔型,对比两者输出相差几拍、状态数差几个。
  3. 把三段式状态机改成一段式,故意漏掉一个 case 分支,跑综合或仿真,看工具是否报出推断锁存器。
  4. 给一条很短的组合路径人为插入几级缓冲,观察保持余量怎么变化,理解为什么修保持违例要加延迟。
  5. 找一份 FPGA 的时序报告,找出最长的三条路径,记录它们的起点、终点和余量,说明哪一条决定了最高频率。

收束:时钟把组合逻辑切成拍

状态机把流程拆成有限个状态,时钟每来一拍推进一次;建立时间要求数据早到,保持时间要求数据晚走,两条约束一前一后夹住组合逻辑;余量把这两条写成可以算的数字,正数放心,负数就要改路径或降频率。降频能救建立违例,救不了保持违例,这个区别能省掉很多无效调试。

到这里,触发器、状态机和时序都齐了。下一篇把这些零件拼成运算器:加法器负责算术,逻辑门负责位运算,选择器负责挑结果,控制信号负责选操作,最后输出结果和几个标志位。时序约束在 ALU 里同样成立,因为 ALU 本身就是一条最典型的组合路径。