Typical ASIC design flow .................................................................................................................

2
时钟抖动 (Clock Jitter) ....................................................................................................................5
信号同步的窍门...............................................................................................................................8
数字后端流程...................................................................................................................................9
DC 概论之一 setup time 与 hold time .......................................................................................11
DC 概论二之 fanout 与 skew.........................................................................................................14
DC 概论三之 setup time 与 hold time 之二................................................................................21
DC 概论四之 setup time 与 hold time 之三.................................................................................26
DC 概论五之 high fanout...............................................................................................................42
DC 概论六之 multicycle_path ......................................................................................................58
DC 概论七之 gated clock...............................................................................................................75
DC 概论之 IO 约束........................................................................................................................84
DC 优化约束 ..................................................................................................................................90
Synopsys Synthesis Constraints Template ......................................................................................92
功耗和门控时钟的的基本概念.....................................................................................................95
对 FALSE PATH 的理解 ................................................................................................................97
TimeQuest 时钟分析 ....................................................................................................................101
静态时序分析...............................................................................................................................105
寄生参数提取和静态时序分析...................................................................................................124
IC 设计中的时钟类型约束..........................................................................................................130
IC 设计流程及工具......................................................................................................................132
Typical ASIC design flow
Step 1: Prepare an Requirement Specification
Step 2: Create an Micro-Architecture Document.
Step 3: RTL Design & Development of IP's
Step 4: Functional verification all the IP's/Check whether the RTL is free from
Linting Errors/Analyze whether the RTL is Synthesis friendly.

Step 4a: Perform Cycle-based verification(Functional) to verify the protocol

behaviour of the RTL

Step 4b: Perform Property Checking , to verify the RTL implementation and the
specification understanding is matching.

Step 5: Prepare the Design Constraints file (clock

definitions(frequency/uncertainity/jitter),I/O delay definitions, Output pad load
definition, Design False/Multicycle-paths) to perform Synthesis, usually called as an
SDC synopsys_constraints, specific to synopsys synthesis Tool (design-compiler)

Step 6: To Perform Synthesis for the IP, the inputs to the tool are (library file(for
which synthesis needs to be targeted for, which has the functional/timing information
available for the standard-cell library and the wire-load models for the wires based on
the fanout length of the connectivity), RTL files and the Design Constraint files, So
that the Synthesis tool can perform the synthesis of the RTL files and map and
optimize to meet the design-constraints requirements. After performing synthesis, as a
part of the synthesis flow, need to build scan-chain connectivity based on the
DFT(Design for Test) requirement, the synthesis tool (Test-compiler), builds the
scan-chain.

7: Check whether the Design is meeting the requirements

(Functional/Timing/Area/Power/DFT) after synthesis.

Step 7a: Perform the Netlist-level Power Analysis, to know whether the design is
meeting the power targets.

Step 7b: Perform Gate-level Simulation with the Synthesized Netlist to check whether
the design is meeting the functional requirements.

Step 7c: Perform Formal-verification between RTL vs Synthesized Netlist to confirm

that the synthesis Tool has not altered the functionality.

Step 7d: Perform STA(Static Timing Analysis) with the SDF(Standard Delay Format)
file and synthesized netlist file, to check whether the Design is meeting the
timing-requirements.

Step 7e: Perform Scan-Tracing , in the DFT tool, to check whether the scan-chain is
built based on the DFT requirement.

Step 8: Once the synthesis is performed the synthesized netlist file(VHDL/Verilog

format) and the SDC (constraints file) is passed as input files to the Placement and
Routing Tool to perform the back-end Actitivities.

Step 9: The next step is the Floor-planning, which means placing the IP's based on the
connectivity,placing the memories, Create the Pad-ring, placing the
Pads(Signal/power/transfer-cells(to switch voltage domains/Corner pads(proper
accessibility for Package routing), meeting the SSN requirements(Simultaneous
Switching Noise) that when the high-speed bus is switching that it doesn't create any
noise related acitivities, creating an optimised floorplan, where the design meets the
utilization targets of the chip.

Step 9a : Release the floor-planned information to the package team, to perform the
package feasibility analysis for the pad-ring .

Step 9b: To the placement tool, rows are cut, blockages are created where the tool is
prevented from placing the cells, then the physical placement of the cells is performed
based on the timing/area requirements.The power-grid is built to meet the
power-target's of the Chip .

Step 10: The next step is to perform the Routing., at first the Global routing and
Detailed routing, meeting the DRC(Design Rule Check) requirement as per the
fabrication requirement.

Step 11: After performing Routing then the routed Verilog netlist, standard-cells
LEF/DEF file is taken to the Extraction tool (to extract the parasitics(RLC) values of
the chip in the SPEF format(Standard parasitics Exchange Format), and the SPEF file
is generated.

Step 12: Check whether the Design is meeting the requirements

(Functional/Timing/Area/Power/DFT/DRC/LVS/ERC/ESD/SI/IR-Drop) after
Placement and Routing step.

Step 12a: Perform the Routed Netlist-level Power Analysis, to know whether the
design has met the power targets.

Step 12b: Perform Gate-level Simulation with the routed Netlist to check whether the
design is meeting the functional requirement .
Step 12c: Perform Formal-verification between RTL vs routed Netlist to confirm that
the place & route Tool has not altered the functionality.

Step 12d: Perform STA(Static Timing Analysis) with the SPEF file and routed netlist
file, to check whether the Design is meeting the timing-requirements.

Step 12e: Perform Scan-Tracing , in the DFT tool, to check whether the scan-chain is
built based on the DFT requirement, Peform the Fault-coverage with the DFT tool and
Generate the ATPG test-vectors.

Step 12f: Convert the ATPG test-vector to a tester understandable format(WGL)

Step 12g: Perform DRC(Design Rule Check) verfication called as

Physical-verification, to confirm that the design is meeting the Fabrication
requirements.

Step 12h: Perform LVS(layout vs Spice) check, a part of the verification which takes
a routed netlist converts to spice (call it SPICE-R) and convert the Synthesized
netlist(call it SPICE-S) and compare that the two are matching.

Step 12i : Perform the ERC(Electrical Rule Checking) check, to know that the design
is meeting the ERC requirement.

Step 12j: Perform the ESD Check, so that the proper back-to-back diodes are placed
and proper guarding is there in case if we have both analog and digital portions in our
Chip. We have seperate Power and Grounds for both Digital and Analog Portions, to
reduce the Substrate-noise.

Step 12k: Perform seperate STA(Static Timing Analysis) , to verify that the
Signal-integrity of our Chip. To perform this to the STA tool, the routed netlist and
SPEF file(parasitics including coupling capacitances values), are fed to the tool. This
check is important as the signal-integrity effect can cause cross-talk delay and
cross-talk noise effects, and hinder in the functionality/timing aspects of the design.

Step 12l: Perform IR Drop analysis, that the Power-grid is so robust enough to
with-stand the static and dynamic power-drops with in the design and the IR-drop is
with-in the target limits.

Step 13: Once the routed design is verified for the design constraints, then now the
next step is chip-finishing activities (like metal-slotting, placing de-coupling caps).

Step 14: Now the Chip Design is ready to go to the Fabrication unit, release files
which the fab can understand, GDS file.
Step 15: After the GDS file is released , perform the LAPO check so that the database
released to the fab is correct.

Step 16: Perform the Package wire-bonding, which connects the chip to the Package.

Step 5: Prepare the Design Constraints file (clock definitions(frequency/uncertainity/jitter),I/O

delay definitions, Output pad load definition, Design False/Multicycle-paths) to perform Synthesis,
usually called as an SDC synopsys_constraints, specific to synopsys synthesis Tool
(design-compiler)

时钟抖动 (Clock Jitter)

通常希望一个周期性波形(特别是时钟)跨过特定门限的时间非常精确，与该理想值的偏差称
为抖动。
1.1 clock tree：从一个 clock 源出发，clock 网络经过多级 buffer，到达每个时序器件的 clk 脚。
为了保证从 clock 源到每个器件 clk 脚的延时相差不多，clock 在布局布线时做成树形网络结
构，叫做 clock tree。
1.2 clock latency：clock 源到时序器件的 clk 脚的延迟叫做 clock latency。
1.3 clock jitter：clock 源是芯片外部管脚引入或是内部 PLL 产生的。clock 的每个周期时间都
会有微小的偏差，这种偏差叫做 clock jitter。
1.4 clock skew：clock 在不同时序器件 clk 脚上的时间差异叫做 clock skew。
1.5 clock uncertainty：clock 在时序器件 clk 脚上的不确定性，包括 clock jitter 和 clock skew
两部分的总和。
1.6 clock transition：clock 信号的 slew 时间。分为上升沿时间和下降沿时间。
1.7 clock gating：指门控时钟。由于低功耗的要求，有些模块会停止工作。通过停掉 clock
减少这些模块的耗电。
Clock skew 和 Clock jitter 是影响时钟信号稳定性的主要因素。很多书里
都从不同角度里对它们进行了解释。
其中“透视”一书给出的解释最为本质：
Clock Skew: The spatial variation in arrival time of a clock transition
on an integrated circuit;
Clock jitter: The temporal variation of the clock period at a given point
on the chip;
简言之，skew 通常是时钟相位上的不确定，而 jitter 是指时钟频率上的不确
定（uncertainty)。造成 skew 和 jitter
的原因很多。由于时钟源到达不同寄存器所经历路径的驱动和负载的不同，时钟
边沿的位置有所差异，因此就带来了
skew。而由于晶振本身稳定性，电源以及温度变化等原因造成了时钟频率的变化，
就是 jitter。
skew 和 jitter 对电路的影响可以用一个简单的时间模型来解释。假设下图中
t(c-q)代表寄存器的最大输出延迟，
t(c-q, cd)表示最大输出延时；t(su)和 t(hold)分别代表寄存器的 setup, hold
time（暂不考虑 p.v.t）差异；t(logic)
和 t(logic, cd)分别表示最大的组合逻辑传输延迟和最小组合逻辑传输延迟；

在不考虑 skew 和 jitter 的情况下，及 t(clk1)和 t(clk2)同频同相时，时钟周

期 T 和 t(hold)需要满足
T > t(c-q) + t(logic) + t(su)
t(hold) < t(c-q, cd) + t(logic, cd)
这样才能保证电路的功能正常，且避免竞争的发生。如果考虑 CLK2 比 CLK1 晚
t1 的相位，及 skew=t1。
则 t(hold) < t(c-q, cd) + t(logic, cd) - t1
这意味着电路由更大的倾向发生 hold time violation；如果考虑 CLK1 比 CLK2
晚 t2 的相位，及 skew=-t2，
则 T > t(c-q) + t(logic) + t(su) + t2
这意味着电路的性能下降了，但由于 R2 的 hold time 始终满足，所以不会有竞
争的麻烦存在。clock jitter
始终是对性能造成负面的影响，一般设计中都需要专门留取 10%左右的 margin
来保证。
如何减小 skew 是后端布设 clock tree 的主要考量。

信号同步的窍门
RMM 中曾经介绍过一个概念叫"locality"，希望能够在 RTL 编程的时候，通
过模块的正确划分(partition)和接口的恰当设计来实现模块封装。它的一大优
点在于，当验证出现问题的时候，可以更方便进行定位。概念很明确，但真的在
设计中去实现就不那么容易了。我自己就是通过一个教训才真正理解了这个概
念。当时项目中涉及到多时钟域信号同步的问题。我用的方法很简单，直接用两
级寄存器打一下。唯一值得注意的时，由于同步后采样是在时钟上升沿，两级寄
存器打的时候就采用了下降沿来做。

开始都很顺利，直到后仿的时候，跨时钟域的信号出现了 timing violation，

并导致'x'状态出现和传递。为了解决这个问题，我需要找出所有这样的信号。
但跨时钟域的信号实在太多，我为此花费了大量的时间。如果我在一开始就将所
有跨时钟域信号的同步放到一个专门的模块中去进行，问题就会变得非常简单。
至此，我才体会出一点 locality 的意义。

这个教训给我一个经验：设计 IP 的时候，在顶层分离一个专门的 SYNC 模块

进行异步信号的同步。

PS. 下图给出了简单的同步电路，仅供个人参考。

//-------------------------------------------------------------------
// input ______ sync_ff1 ______ sync_ff2
// ------| |____________ | |__________
output
// clk | | | |
// ----o|> | -----o|> |
// | |______| | |______ |
// |_______________|
//-------------------------------------------------------------------
数字后端流程
闲逛论坛，发现一篇关于后端流程的短文。不长，却非常清晰的解释了后端的
整个流程。转载以记之。

1. 数据准备。对于 CDN 的 Silicon Ensemble 而言后端设计所需的数

据主要有是 Foundry 厂提供的标准单元、宏单元和 I/O Pad 的库文件，它包括物
理库、时序库及网表库，分别以.lef、.tlf 和.v 的形式给出。前端的芯片设计
经过综合后生成的门级网表，具有时序约束和时钟定义的脚本文件和由此产生
的.gcf 约束文件以及定义电源 Pad 的 DEF（Design Exchange Format）文件。(对
synopsys 的 Astro 而言， 经过综合后生成的门级网表，时序约束文件 SDC 是
一样的,Pad 的定义文件--tdf ， .tf 文件 --technology file， Foundry 厂提
供的标准单元、宏单元和 I/O Pad 的库文件 就与 FRAM, CELL view, LM view 形
式给出(Milkway 参考库 and DB, LIB file)

2. 布局规划。主要是标准单元、I/O Pad 和宏单元的布局。I/O Pad 预

先给出了位置，而宏单元则根据时序要求进行摆放，标准单元则是给出了一定的
区域由工具自动摆放。布局规划后，芯片的大小，Core 的面积，Row 的形式、电
源及地线的 Ring 和 Strip 都确定下来了。如果必要 在自动放置标准单元和宏单
元之后， 你可以先做一次 PNA(power network analysis）--IR drop and EM .

3. Placement -自动放置标准单元。布局规划后，宏单元、I/O Pad 的

位置和放置标准单元的区域都已确定，这些信息 SE（Silicon Ensemble）会通
过 DEF 文件传递给 PC(Physical Compiler),PC 根据由综合给出的.DB 文件获得
网表和时序约束信息进行自动放置标准单元，同时进行时序检查和单元放置优
化。如果你用的是 PC +Astro
那你可用 write_milkway, read_milkway 传递数据。

4. 时钟树生成(CTS Clock tree synthesis) 。芯片中的时钟网络要驱

动电路中所有的时序单元，所以时钟源端门单元带载很多，其负载延时很大并且
不平衡，需要插入缓冲器减小负载和平衡延时。时钟网络及其上的缓冲器构成了
时钟树。一般要反复几次才可以做出一个比较理想的时钟树。---Clock skew.

5. STA 静态时序分析和后仿真。时钟树插入后，每个单元的位置都确定
下来了，工具可以提出 Global Route 形式的连线寄生参数，此时对延时参数的
提取就比较准确了。SE 把.V 和.SDF 文件传递给 PrimeTime 做静态时序分析。确
认没有时序违规后，将这来两个文件传递给前端人员做后仿真。对 Astro 而言，
在 detail routing 之后， 用 starRC XT 参数提取，生成的 E.V 和.SDF 文件传
递给 PrimeTime 做静态时序分析，那将会更准确。

6. ECO(Engineering Change Order)。针对静态时序分析和后仿真中出

现的问题，对电路和单元布局进行小范围的改动.
7. Filler 的插入(pad fliier, cell filler)。Filler 指的是标准单元
库和 I/O Pad 库中定义的与逻辑无关的填充物，用来填充标准单元和标准单元之
间，I/O Pad 和 I/O Pad 之间的间隙，它主要是把扩散层连接起来，满足 DRC 规
则和设计需要。

8. 布线(Routing)。Global route-- Track assign --Detail

routing--Routing optimization 布线是指在满足工艺规则和布线层数限制、线
宽、线间距限制和各线网可靠绝缘的电性能约束的条件下，根据电路的连接关系
将各单元和 I/O Pad 用互连线连接起来，这些是在时序驱动(Timing driven ) 的
条件下进行的，保证关键时序路径上的连线长度能够最小。--Timing report
clear

9. Dummy Metal 的增加。Foundry 厂都有对金属密度的规定，使其金属

密度不要低于一定的值，以防在芯片制造过程中的刻蚀阶段对连线的金属层过度
刻蚀从而降低电路的性能。加入 Dummy Metal 是为了增加金属的密度。

10. DRC 和 LVS。DRC 是对芯片版图中的各层物理图形进行设计规则检查

(spacing ,width)，它也包括天线效应的检查，以确保芯片正常流片。LVS 主要
是将版图和电路网表进行比较，来保证流片出来的版图电路和实际需要的电路一
致。DRC 和 LVS 的检查--EDA 工具 Synopsy hercules/ mentor calibre/ CDN
Dracula 进行的.Astro also include LVS/DRC check commands.

11. Tape out。在所有检查和验证都正确无误的情况下把最后的版图

GDSⅡ文件传递给 Foundry 厂进行掩膜制造。

加入飞索半导体中国设计中心快一年了，现在倒回去看看，收获良多。在这快一
年的时间里，我跑完了从系统设计到
综合的整个前端流程；熟悉了包括 VCS, debussy, modelsim, DC, leda 在内的
常用工具链；最近半年参与设计的
BCH 纠错码模块，从 matlab 系统仿真，C model 建立，RTL coding，验证到综合
都完整的做过；项目中系统的 verfi-
cation spec.和 IP 的 development spec 都有参与完成；也参与了芯片测试的
pattern 的生成；为纠错码的 IP，还申

请了 patent，算是对前期工作一个不小的认同吧。

刚出校门那时候，虽然也做过一些 FPGA 的工作，但实验室毕竟不是以流片为

最终目标，自己又不是地道的半导体
科班出身，对前端的流程只能是一个模糊地认识。除了 QuatrusII 以外，也就是
可以在 modelsim 的环境中勉强做一下
前仿，对 SOC 的验证完全没有概念。

工作最初的一段时间里，做的是一个 training project。虽然没有流片，但

却是我第一次接触一个完整的 SOC 系统，
8051 与 ABMA 总线结构都有涉及。当时的 assignment 是对一个 BCH 纠错译码 IP
进行模块验证，然后再放到系统中做系
统级的验证。开始的时候很菜，什么是 bus function model(BFM)，怎么写
testbench，怎么写 testcase 都把握不好。
于是只好一点点学。从 CVS 的使用，到环境的建立；从写 BFM，写 testbench，
再到开发具体的 testcase。虽然以现
在的眼光看起来，那个时候的代码很粗糙，完全没考虑到 reuse 的问题，代码风
格也够乱。

第二个项目就非常正式了，我也初次体会到了在 schedule 下工作的压力。

虽然设计中心万事都是刚起步，但毕竟是
大公司。老板 Yarbim 是微软地道的 project maneger 出身，项目管理非常科学。
我们也因此接触到 Golden-Silver-Bronze
的项目进度管理方式。在项目里，我的 assignment 是完成其中纠错模块的设计
和评估工作，并协助 Austin 的 Greg 完成
standalone 的验证。因为在实验室就接触过 BCH 码，所以算法和结构上难度不
大。不到两个月就完成了算法推导，
matlab 仿真和 C model 的编写。 为了提高 RTL 代码的质量，只好认认真真拜读
了 RMM。还好公司有不少优秀的代码资源
可以借鉴，总算是写出了自己满意的代码。不过 bug 还是不少，害得每次 Greg
每天发信给我总让我心惊一下子。

之后我转去做系统级的验证，因为数字逻辑部分不大，除了按照 Flow 跑了
前仿和 LEC 以外，我们还跑了门级的后仿，
将 Layout 以后 Astro 得到的 wire laod model 通过 PT 送出 SDF，反标到 netlist
里。这之间遇到了许多问题，比如跨时钟
域信号出现 Timing violation；Behavior Model 中或者 RTL 中因为没有标明路
径而无法顺利标上 SDF 的 Timing；Pad
模块中 inout 接口无法标时间。。。总之是问题一大堆，真正让我体会到 Yarbim
第一天告诉我们的"Shit happens all
the time"是种什么感觉。虽然后来有人觉得我们后仿做的比较没意义，但却实
实在在让我们发现了许多教训，也发现
不少 Timing 的问题。因为前仿我们没意识到系统时钟频率对验证的影响，下意
识的觉得 cycle by cycle 的验证不需要
时钟跑太高。也因为这个，我们没有发现时钟跑慢了之后，FW 也会执行的更慢，
控制信号有可能出错。

DC 概论之一 setup time 与 hold time

2009-03-13 10:49:56 来源：网络转载作者：佚名共有评论(0)条浏览次数:521
 ic 代码的综合过程可以说就是时序分析过程，dc 会将设计打散成一个个路经，这些路经上有 cell 延
迟和 net 延迟，然后 dc 会根据你加的约束，来映射库中符合这种延迟以及驱动的器件。从而达到综合的目
的。dc 的所有时序约束基础差不多就是 setup time 和 hold time。 可以用下面的图片说明：

所谓 setup time 即建立时间，也就说数据在时钟到来之前保持稳定所需要的时间，

hold time 即保持时间，也就是说在时钟到来之后数据需要保持稳定的时间。
在深入建立时间和保持时间之前。先了解下 dc 中的路经以及 start point ，end point。
所谓 start point 就是：
1. input port（顶层设计的输入端口）
2.clock pin of sequential cell（触发器的 clock pin）
所谓的 end point 就是：
1 output port（顶层设计的输出端口）
3.data pin of sequential cell（触发器的 data pin）
了解 start point 和 end point，就可以方便的了解 dc 是如何将设计打散成路经，一个设计中基本
的路经分为 4 种，如下图：

path1： input port to data pin of sequential cell

path2： input port to output port
path3： clock pin to data pin of next sequential cell
path4：clock pin to output port
所有的设计也就这四种类型的路径。
另外一种就是带反馈的，也就是本身的 clock pin to data pin 。
有了路径的概念之后，我们可以分析更复杂的 setup time 和 hold time 。
dc 中对于建立时间的分析是基于路径的最大延迟;而对于保持时间的分析是基于路径的最小延迟。
看下面一个例子：
 这个是给定 setup time 和 hold time 的案例，要求算出最小时钟周期。同理也可以给你一个周期和
setup time 和 hold time，计算时间裕度。 我们假设时钟周期是 20,每个触发器的 cell 延迟是 1,触发器
的建立时间是 1,保持时间是 0.5,分析下列图中的建立时间和保持时间的 slack。

看到设计，首先要分析路径，找出最长和最短路径，因为 dc 的综合都是根据约束而得到最短和最长路
径来进行器件选择的。所以接下来将图中的所有路径标出。因为没有前级（input_delay)和后级电路
(output_delay)，我们只分析图中给出的 路径，如下图：

对于红色路径：Td=Tcell+Td4+Td5+Td6=1+4+3+1=9
对于黄色路径：Td=Tcell+Td4+Td5+Td6+Td8=1+4+3+1+2=11
对于粉色路径：Td=Tcell+Td1+Td2+Td3=1+2+3+2=8
对于路色路径：Td=Tcell+Td7+Td2+Td3=1+2+3+2=8
所以 Tlongest=11,Tshortest=8
对于 setup time 的 slack：Tclk-Tlongest-Tsetup=30-11-1=18
对于 hold time 的 slack ： Tshortest-Thold=8-0.5=7.5
对于 setup time 和 hold time 的 slack 的计算，可以体会下面的示意：
 对照第一副示意图与此比较，建立时间看 D2 ,保持时间看 D1,因为同时把 Tl 和 Ts 放在一个图例中，
看起来可能有些误解：）
有空会继续讨论 setup time 和 hold time，下次讨论将包括 clock skew 和 input delay，output delay
在其中。

DC 概论二之 fanout 与 skew

SOC debug 中 Dc 综合是基于路径，每个路径上都有 Cell 和 net，所以基于路径的综合就是计算路径上

的 delay 和 rc（dc 是使用互连线模型进行估算）。
在了解 delay 和 rc 的计算时，我们要先了解一下一个 cell 对于 drive（前级）和 driven（后级）所
用到的模型是什么。如下图，一个 buffer，从前级看过来是一个 load（capacitance，想获得这个 load，
可以通过 load_of buffer/a 获得）,从后级看来是一个 drive（resistance）。电路的的驱动能力是上一
级的 1/R,即电阻的倒数，驱动能力大，说明看过去的电阻小，也说明这个器件比较大（大器件有较大的驱
动能力）。电路的负载能力是下一级的 load（即电容）总和，负载能力大，说明能驱动下级的期间就很多。
大器件是大电容，小电阻，而小器件是小电容，大电阻。理解这些，对于 dc 综合以及后端 apr 版图都
有很好的操作。
 对于 cell 的延迟，dc 是根据 input_transition 和 out_load 对应的查找表来计算的。
对于 net 的延迟，dc 是根据 wire_load_model 中的 fanout_length 和 resistance，capacitance,area
的查找表计算的。
例如：
Wire_load(small){
Resistance : 0.2;
Capacitance : 1.0;
Area :0;
Slop :1.0;
Fanout_length(1,0.022);
Fanout_length(2,0.046);
Fanout_length(3,0.070);
Fanout_length(4,0.095);
}
比如现在扇出是 2，
 根据 fanout_length（2，0.046）可以知道这个互连线的长度是 0.046，然后再根据 capacitance，
resistence 可以得出这个互连线的电容为：0.046x1.0,互连线电阻为：0.046x0.02。
如果扇出是 5，在查找表中没有找到 fanout_length 为 5 的項，互连线长度将会是
=fanout_length(4,0.095)+(5-4)*slop=0.095+1*1.0=1.095
得出了 rc 就可以计算出信号的 transition 时间=2.2RC。
实际的互联线如下：

扇出线上的转换时间根据在版图之后提取的 rc 参数信息求得：

2.2RC=（Rnet+Rout）×（Cnet+Cin）
无论如何，要记住的就是 dc 是基于路径分析的，每个路径上有 cell 延迟和 net 延迟，而 cell 延迟是
根据 input_transition 和 out_lod 得出的，net 延迟是根据 fanout_length，resistance，capacitanc 得
出的。驱动和电阻成反比，负载和电容成正比。
由上面可以知道 fanout 影响到 load（capacitance），transition，delay。了解了上面，我们来理
解下 dc 中对 design 建模，所用到的一些跟 fanout 有关的参数。
Dc 中的约束，其实就是给 chip 设计一个环境，比如驱动这个 chip 输入端口的 cell，或者这个 chip
输出端口驱动了那些单元或者端口接入了哪些负载，以及这个芯片的工艺，电压，温度，等等。
对于一个 cell 来说，输出端口具有 max_fanout 属性，输入端口有 fanout_load 属性。
 例如将一个 AND2 作为 design 的驱动 cell(set_driving_cell)，这样就把 AND2 的 max_fanout 属性加
在了输入端口上。如果一个 AND2 的输出端口 max_fanout 是 5，输入端口 fanout_load 是 2。一个 buffer
输入端口的 fanout_load 是 3。那么这个 AND2 的输出端可以接 2 个 AND2，或者可以接一个 buffer，或者
可以接一个 buffer 和一个 AND2。如上图所示，则会引起 DC 产生 DRC 错误。因为输入端口的
fanout_load=2XAND2+buffer=7，超过了 AND2 的 max_fanout2.如果使用了系统提供的 set_max_fanout 5
[all_inputs],将会忽略 set_driving_cell 中 cell 的 max_fanout 属性，而使用 set_max_fanout 属性。
如果将一个 AND2 作为 design 的负载，那么这个输出端口上的 fanout_load 属性将会为 2.dc 中一般的
做法是 set_fanout_load [expr [get_attribute slow/and2/a fanout_load] *xxx] [all_outputs]，来
设置输出端口的 fanout_load 属性。
这样 dc 就可以根据这些设置，选择优化端口处的器件，以及时序。
说道 fanout，所以顺带说明一下容易混淆的 max_fanout,max_capacitance。如上图所示，
输入端口的 fanout_load=2 个与门的 fanout_load 和一个 buffer 的 fanout_load。
输入端口的 load（capacitance）=2 个与门的 load_of 和一个 buffer 的 load_of。
（如果通过 set_load
设置了输入端口，另外还要加上 set_load 的值）。
Max_fanout 检查的是输入端口的 fanout_load 最大值，Max_capacitance 检查的是输入端口 load 值。
两者概念不同。
下面讲下 fanout 与 delay，看如下一个例子：
 到 buffer 的 net 延迟是 2，buffer 延迟是 1，fanout 为 1 时 net 延迟为 3，每增加一个扇出，net 延
迟增加 2.如果一个信号经过这个扇出网络后，那么延迟为：2+1+（3+（8-1）×2）=20；
如果把扇出结构优化成如下形式：

那么信号经过这个网络后，延迟为：2+1+2+1+（3+（4-1）×2）=15.
那么延迟减少了 5。

接下来讲一下 skew，既然知道了 fanout 对于 delay 的影响，下面看一个例子：

 由于时钟到每个触发器的互连线长短不一样，造成信号到达 clock pin 的时间也不一样，触发器也不
会同时翻转。Skew 的定义就是最长路径减去最短路径的值。
根据时钟域以及路径关系，skew 可以分为 global skew，local skew，interclock skew。
Global skew 是指，同一时钟域，任意路径的最大 skew。
Local skew 是指，同一时钟域，任意 2 个有逻辑关联关系的路径最大 skew。
interClock skew 是指，不同时钟域之间路径的最大 skew
 另外还有一个 useful skew。本来打算在 setup time 和 hold time 中讲解。这里先大概说下
如下图：时钟周期为 10ns，各时钟路径延迟如下：可以看到有一条路径的 slack 为-1，说明这条路径
违规。可以看到与这条路径相关的 skew 是 T3-T2=-1ns。

下面我们利用 useful skew 向前面一个 slack 比较充裕的路径（slack=2ns）借点 time，来修正现在

这条路径。如下图：

经过 useful skew，修正了原来的 violator。

这就是 useful skew 的作用，可以向前，或者向后接 time 来修正 violator
DC 概论三之 setup time 与 hold time 之二
前面一篇讲了基本的建立时间和保持时间以及时序路径划分。在这篇开始之前，先介绍一下很经典而且会
时常用到的用来讲解的一个电路图，如下。这篇文章的讲解也会给予这个电路图，讲解的时候我把电路图
分割成需要的部分：）

既然我们知道了建立时间和保持时间的含义，这篇主要是根据工厂提供的标准单元库中时序器件的建
立时间和保持时间来预估我们的约束对设计的影响，是否满足时序要求，简单点就是说，时序有没有
violator。
set_input_delay :
input_delay 是设置外部信号到达输入端口的时间，dc 会用它来计算留内内部逻辑的空余时间是多少。
 之所以让 ClkA 和 Clk 的时钟周期不一致，主要是用来说明上图中黄色部分的。黄色部分的确认是很重
要的。这是 DC 用来确定时间余量（slack）的关键。如上图所示，黄色部分已经确实是最小相位差。那么
根据 input_delay 时间以及库中触发器的 setup 建立时间，可以知道留给内部逻辑的延迟时间是红色部分
Tmin-Tinput_delay-Tsetup。综合过程中，dc 会优化 Logic2 的时序，以使他达到时序要求。
同样 set_output_delay 是设置输出端口到数据采集处的延迟。如下图：
DC 会根他来计算留给内部逻辑的时间。
这里还是要强调一下不同频率的问题：）
介绍完了 input_delay 和 output_delay，以及 skew 在分析时间余量之前再介绍下时钟的 latency。
Latency 分为 source lantency 和一般的 latency。

Source latency 指的是时钟源到时钟端口的延迟。

Latency 指的是时钟端口到内部时序器件的时钟管脚的延迟。
一般只考虑 latency 即可。
再看下 latency 对于内部逻辑的影响.下图是不考虑 latency 的情况：

内部逻辑延迟的限度为 T1-T2-Tinput_delay-Tsetup。
当考虑了 latency 的时候。D1 上的 clock 会变成时序图中的红色部分
那么留给内部逻辑的最大延迟为：T2’（T2+Tlatency）-T1-Tinput_delay-Tsetup。会发现留给内部逻辑
的延迟会变大，那么会给 DC 更大的空间来综合。
同样如果 ClakA 上面如果也设置了 Latency 在分析 slack 的时候也要算进去。
顺便介绍一下时钟的 jitter，如下图
 正常的时钟到来时蓝色的时序图。但是由于无法预知的因素，时钟可能提前（粉色）或者延迟（红
色）到来，这就是 jitter。提前到来充为 setup jitter，延迟到来充为 hold jitter。
DC 中把 skew 和 jitter 合成一个 uncertainty。用 set_clock_uncertainty 来设置。
下文中提到的 skew 指的是合体，即 uncertainty。
Uncertainty 分为 setup 和 hold，顾名思义，如上图理解即可。

DC 概论四之 setup time 与 hold time 之三

下面开始正式分析时间余量 slack。其实有了上面的知识，只要稍微说明下大家
都会很明白。

在介绍 slack 之前，我们要先了解一下要求时间（required time）和达到时间

（arrive time）的概念以及计算方法。

如果没有特殊说明，黑色 clock 代表没有影响因素的理想时钟，红色（粉色）clock

代表收到 latency 影响的时钟。蓝色 clock 代表同时受到 latency 和 skew
（uncertainty）影响的时钟。
对于建立时间（setup time）的到达时间和要求时间。

在分析前，记住，建立时间是分析路径中的考虑到各种最不利因素的最大延迟，
打个比方：

前面一级用尽最大程度向后推（最大的延迟），本级就近打力气向前顶（最大不
确定因素）。

然后看中间有没有漏气（slack 为负，时序违规）。

<!--[if !supportLists]-->1， <!--[endif]-->输入端口到

时序器件的数据端口。
上图中

要求时间=T2+Tlatency-Tuncertainty_setup-Tsetup

到达时间=T1+Tlantency+Tinput_delay+Tlogic2

<!--[if !supportLists]-->2， <!--[endif]-->时序器件的

输出管脚到输出端口

上图中：

要求时间=T2+Tlatency-Toutput_delay-Tuncertainty_setup

到达时间=T1+Tlatency+Tcell+Tlogic5

3.时序器件到时序器件
上图：

要求时间=T2+Tlatency-Tuncertainty_setup-Tsetup

到达时间=T1+Tlatency+Tcell+Tlogic

4,输入端口到输出端口
如上图：

要求时间=T2+Tlatency-Tuncertainty_setup-Toutput_delay

到达时间=T1+Tlatency+Tinput_delay+Tlogic

我们再来看下保持时间，保持时间的到达时间和建立时间的到达时间是一样的。
只是保持时间的要求时间不一样而已.

保持时间类似于龟兔赛跑：

系统要求时间就是尽可能的向后，而线上信号就是追那个要确定的时间，追上了，
就没问题，追不上问题就有了。

说明：红色和粉色表示受 latency 影响，蓝色表示受 uncertainty 影响。

1. 输入端口到时序器件的数据端口。

到达时间：Tarrive=T1+Tlatency+Tinput_delay+Tlogic

要求时间：Trequire=T2+Tlatency+Tuncertainty_hold+Thold

2. 时序器件的输出管脚到输出端口
到达时间：Ta=T1+Tlatency+Tcell+Tlogic

要求时间：Tr=T2+Tlatency+Tuncertainty_hold+Thold-Toutput_delay

3 时序器件到时序器件
到达时间：Ta=T1+Tlatency+Tcell+Tlogic

要求时间：Tr=T2+Tlatency+Tuncertainty_hold+Thold

4,输入端口到输出端口
到达时间：Ta=T1+Tlatency+Tinput_delay+Tlogic

要求时间：Tr=T2+Tlatency+Tuncertainty_hold+Thold-Toutput_delay

Slack 计算：

对于建立时间：

Slack=要求时间-到达时间

对于保持时间

Slack=到达时间-要求时间
a
9
8
7

6
5
4
3
2

DC 概论五之 high fanout

dc 在综合高扇出的网络的时候，约束优先级是：
1.功能正确
2.DRC（max_transition ,max_fanout,max_capacitance )
3.Setup time （max_delay)
4.Hold time (min_delay)
5. Other...
为了符合 drc 要求，dc 通常花费很多时间来编译和修正这些 DRC violators。
路径上的 cell 延迟由 input_transition 和 output_load(包括扇出 pin 上的 load）决定，这个由
查抄表可以得到。

而 net 延迟是由 net 上的 R，C 决定的。在没有布局布线之前，我们不知道实际的 R，C 是

多少，dc 根据互联线模型（set_wire_load_model)来计算出 R，C。然后根据得到的 R，C 计
算出 net 上的延迟：

Net_delay=R*C*OC
其中系数 OC 是根据操作环境（set_opearting_conditions)中设置的 rc 树模型得到。
一般的工艺库的操作环境有三种，WORST，TYPICAL，BEST,分别是最差，典型，最坏。

在 ic 中出现 high fanout 的情况基本有三种：

1.时钟 clock
2.复位 reset
3.一般信号
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
dc 中对于高扇出 net 的处理，基本就是加 buffer（前提，如果没有对这条 net 设置一些约束，
比如 set_ideal_network,set_dont_touch，后面会讲到），以此来减少 cell 输出端的负载，从而
减少 transition time 和 delay time，以及 max_capacitance。而事实上我们是不希望 dc 这么处
理的，我们希望的是可以在后端版图的时候让后端工具自己加 buffer，因为我们不知道真实
的 high fanout net 上的 RC，所以不知道应该加怎么样的 buffer，dc 只是根据互联线模型来计
算 RC，接着加入 buffer，不是真实的，只有布线以后我们才可以得到几乎真实的 rc。

所以在 dc 综合过程中我们要阻止 dc 最 high fanout net 进行 insert buffer 处理。因此这些没被

处理的高扇出 net 就会引起一些 drc 或者 timing 错误，在 dc 中，dc 用价值函数（cost function）
来判断这些约束对设计的影响。价值函数=DRC violator 和+ timing violator 和。一般的，dc
会根据所有 drc 和 timing 错误，通过使价值函数趋近等于 0 来修正这些违规。为了达到效果，
dc 会每次修正一个路径，然后重新计算价值函数，如果价值函数变小，说明设计被改进了。

在介绍如何处理 high fanout net 之前，先介绍 3 个命令。

Set_ideal_net （已经被 set_ideal_network -no_propagate 代替） 忽略 port，pin，net 上的时序
优化(timing optimization)，以及 drc 修正(drc fixxing)。network 具有传输型。
Set_dont_touch （已经被 set_dont_touch_network -no_propagate 代替）忽略，port，cell，design，
pin 上的优化(timing optimization)，但是不会忽略 DRC。network 具有传输型

这样我们在综合的时候就要对 high fanout net 做一定的约束，让 dc 不对这些 net 做优化以

及加入 buffer。下面分三种情况来说明。
1.Clock，对于 clock，当我们用 create_clock,or creat_generated_clock 创建 clock 的时候，这
些 clock 已经有了 ideal_network 的属性。Dc 已经不会在 clock tree 上加入 buffer，同时也不
会计算 drc violation，但是 delay timing 仍然会被计算。不计算 drc 不是说没有负载。
2.Reset，对于复位高扇出信号，因为没有那些属性，所以要手动设置,set_ideal_network
3.一般信号。同样需要手动 set_ideal_network

下面看例子：

下面看一个高扇出实例，有时钟，有复位还有一般信号
module test(clk,clk_G, d_in ,s_r1, s_r2, rst_N1, rst_N2,dout);
parameter size =1100;
input d_in, rst_N1,rst_N2, s_r1, s_r2,clk_G,clk;

output dout;
reg dout;

reg [size-1:1] tmp;

wire G_clk, rst_N, s_r;
integer i;

assign G_clk = clk & clk_G;

assign rst_N = rst_N1 & rst_N2;
assign s_r = s_r1 & s_r2;

always@(posedge G_clk or negedge rst_N) begin

if(!rst_N) begin
dout <= 0;
tmp <= 0;
end
else begin
dout <= tmp[size-1] | s_r;
for(i=size-1 ; i>1; i=i-1)
tmp[i] <= tmp[i-1] | s_r;
tmp[1] <= d_in | s_r;
end
end

endmodule
综合脚本：
set lib $env(DC_LIB)
set target_library "slow.db fast.db"
set link_library "* $target_library"
set search_path ". ../src ../scripts $lib"
set hdlin_while_loop_iterations 5000
analyze -format verilog test.v
elaborate test
uniquify
link
check_design
create_clock -period 100 [get_ports clk]
set_operating_conditions -max slow -min fast
set_wire_load_mode top
set_min_library slow.db -min_version fast.db
set input_exp_clk [remove_from_collection [all_inputs] [get_ports clk]]
set_input_delay 60 -clock [get_clocks clk] $input_exp_clk
set_output_delay 30 -clock [get_clocks clk] [all_outputs ]
compile

电路图：

下面是生成的网表的关键几个地方。
AND2X4 U1106 ( .A(clk_G), .B(clk), .Y(G_clk) );
AND2X2 U1340 ( .A(s_r2), .B(s_r1), .Y(n2) );
AND2X2 U2441 ( .A(rst_N2), .B(rst_N1), .Y(n3) );

在没有分析时序前，根据我们已经有的知识，基本上可以知道这几个 net 上可能存在的问题。

1.较大的延迟，因为每个 net 上都有 1100 个负载。
2.drc 错误，max_transition,max_capacitance,max_fanout
3.较大的输出转换时间 output_transition，尤其是 U1340 的 output_transition 作为下一级的
input_transition，经过下一级的 cell 时候会造成更大的延迟。

时序分析
<!--[if !supportLists]-->1. <!--[endif]-->clock
可以看到 clock tree 上没有插入 buffer，但是 cell 的延迟却很大
2.reset
Dc 自动插入了 buffer。
3 一般信号
Dc 同样自动插入了 buffer。

下面我们修改一下脚本，如下；
set lib $env(DC_LIB)
set target_library "slow.db fast.db"
set link_library "* $target_library"
set search_path ". ../src ../scripts $lib"
set hdlin_while_loop_iterations 5000
analyze -format verilog test.v
elaborate test
uniquify
link
check_design
create_clock -period 100 [get_ports clk]
set input_exp_clk [remove_from_collection [all_inputs] [get_ports clk]]
set_input_delay 60 -clock [get_clocks clk] $input_exp_clk
set_output_delay 30 -clock [get_clocks clk] [all_outputs ]
set_ideal_network -no_propagate [get_nets s_r]
set_ideal_network -no_propagate [get_nets rst_N]
compile
重新分析 timing
<!--[if !supportLists]-->1. <!--[endif]-->clock

基本和原来一样，cell 上仍然有很大延迟。
<!--[if !supportLists]-->1. <!--[endif]-->reset

原来插入的 buffer 现在没有了。不过令我不明白的是 cell 上竟然没有大延迟。等知道的朋友

解答。
<!--[if !supportLists]-->1. <!--[endif]-->一般信号
同样 dc 也没有插入延迟，和希望的一样。不过也没有出现大延迟，不是很明白

问题：
虽然设置了 set_ideal_net（network），set_dont_touch(network)但是 clock 上仍然有大延迟。
为了解决这个问题，我们还要继续设置高扇出的选项。
<!--[if !supportLists]-->1. <!--[endif]-->high_fanout_net_threshold，这个变量是用来指出，
如果 net 的扇出个数超过指定值，那么他就是高扇出，同时 drc 检查，还有延迟计算都是这
个数值计算，但是时间上 net 上的扇出是没有变的。
<!--[if !supportLists]-->2. <!--[endif]-->high_fanout_net_pin_capacitance ， 结 合
high_fanout_net_threshold 使用的，当 net 的扇出超过 threshold，那么 net 上的负载等于这 2
个数值的乘积。
进一步：修改脚本：
set lib $env(DC_LIB)
set target_library "slow.db fast.db"
set link_library "* $target_library"
set search_path ". ../src ../scripts $lib"
set hdlin_while_loop_iterations 5000
analyze -format verilog test.v
elaborate test
uniquify
link
check_design
create_clock -period 100 [get_ports clk]
set input_exp_clk [remove_from_collection [all_inputs] [get_ports clk]]
set_input_delay 60 -clock [get_clocks clk] $input_exp_clk
set_output_delay 30 -clock [get_clocks clk] [all_outputs ]
set_ideal_network -no_propagate [get_nets s_r]
set_ideal_network -no_propagate [get_nets rst_N]
set high_fanout_net_threshold 60
set high_fanout_net_pin_capacitance 0.01
compile
时序分析：
<!--[if !supportLists]-->1. <!--[endif]-->clock

可以发现 cell 的延迟已经很合理。

<!--[if !supportLists]-->1. <!--[endif]-->reset
Cell 上的延迟和原来一样
<!--[if !supportLists]-->1. <!--[endif]-->一般信号
发现和原来一样。

Apr 之后
导出网标，修改约束文件成初始状态，继续分析时序：
可以看出 apr 工具自动加入了 buffer，同时优化了 net 上的 fanout
总结：
为 了 让 dc 在 综 合 高 扇 出 的 net 时 候 不 插 入 buffer tree 和 buffer chain ， 需 要 使 用
set_idea_network 使这些搞扇出 net 避免时序优化（timing optimization），时序更新（timing
update），drc 修正（drc fixxing）。但是这样设置之后，net 上的高负载并没有消除，我们需
要额外的参数进行设置. high_fanout_net_threshold high_fanout_net_pin_capacitance .以减少
dc 综合时间，以及减少 timing violators report

常用的技巧

五一节了，手头也没有什么急事，正好总结一下这段时间 debug SOC 所采用的一些技

巧。SOC 大都带有一个 MCU，SOC 中其它的模块都在 MCU 的控制之下工作。在前期开
发的过程中，因为考虑到 FW 开发的周期和开发速度的要求，验证都习惯使用一个 debug
FW 来进行。只有当项目进展到一定程度的时候，才会使用比较完整的 FW 版本。在系统开
发的过程中，遇到 bug，首先要定位问题到底来自于软件还是硬件。一般的做法是，在
waveform 中 trace MCU 的 PC 指针，追踪当前 bug 发生之前 FW 做的主要控制：是否
正常的进入了系统中断，程序跳转是否正常，FW 是否给出了正确地控制信号？若上述都没
有问题，则 bug 很有可能是由硬件造成的，再 trace 到 RTL 中去定位问题就可以了。
 有时候，软硬件都没有问题，而问题发生在软硬件的配合之中，我就曾经遇到过一次。
当系统频率较低的时候，没有问题；提高频率跑 debug FW 也没有发现问题；只有当告诉
跑 real FW 的时候问题才会出现。后来才发现，因为中断服务程序的执行需要时间，在高
速的情况下，debug FW 比较短，控制信号能够及时送出，但用 real FW 的时候控制信号
却送晚了，这才造成了操作失败。解决的办法只有将原来的信号改由硬件控制。

SOC 的 debug 由于 FW 的参与而变得比较麻烦，即使 FW 不是自己写的，一般来说也

要看一下主要的操作步骤。这样才能更快的定位并解决问题。

这段日子在看《Digital Intergrated Circuits》的 Timing 一章，正好把数字

电路设计中关于时钟和 Timing 的问题总结一下。下面是我所知的一些待解决的
问题：
1) Clock skew and jitter;
2) Clock generation and clock tree;
3) Asnyc & Sync circuit; Synchronization;
4) Clock MUX;
5) 分频问题;
6) 门控时钟问题;
7) 关键路径的优化;

VCS 对 verilog 模型进行仿真包括两个步骤:

1. 编译 verilog 文件成为一个可执行的二进制文件命令为:
$> vcs source_files
2. 运行该可执行文件
$> ./simv

类似于 NC, 也有单命令行的方式:

$> vcs source_files -R
-R 命令表示, 编译后立即执行.
下面讲述常用的命令选项:
-cm line|cond|fsm|tgl|obc|path 设定 coverage 的方式

+define+macro=value+ 预编译宏定义
-f filename RTL 文件列表
+incdir+directory+ 添加 include 文件夹
-I 进入交互界面
-l logfile 文件名
-P pli.tab 定义 PLI 的列表(Tab)文件
+v2k 使用推荐的标准
-y 定义 verilog 的库
-notice 显示详尽的诊断信息
-o 指定输出的可执行文件的名字,缺省是 sim.v
DC 概论六之 multicycle_path

这几天看书看到这个概念，多周期路径。书上有点解释：指的是两个寄存器之间数据要经过多个时钟才能稳定的路径，一般出现于组合逻辑较大的那些路径。

而且有指出，在实际工程中，除了乘除法器等少数比较特殊的电路，一般应该尽量避免采用多周期路径电路。即使有所使用，也应该通过约束在综合工具中指出该路径，使得

综合工具在计算 Fmax 的时候忽略这条路径，避免用大量的时间对该路径进行优化。

对多周期路径可加一下约束：set_multicycle_path -from D_reg -to S_reg

sta 工具会分析所有的 path,除了定义为 false path 的路径.所有的 path 都在最近的沿分析 setup,在最近的沿的前一个沿分析 hold

设置为 multicycle 的 path 会改变分析分析方法， 比如 muticycle 2 就是说会在最近的沿的下一个沿分析 setup,分析 setup 的沿的前一个沿分析 hold.

在做 pre layout sta 分析时,delay 的最大值还是最小值要看你调用的 WLMS 是 fast 还是 slow 的

在做 post layout sta 分析时,delay 的最大值还是最小值要看你调用的真实 RC 参数(如 spef)是 worst 还是 best 的

data path 的计算方法都一样,不存在最大最小,只存在调用的 timing 分析参数/模型不一样

multicycle 不是以延时多少 ns 来计算的，是按照多少个周期计算。因为你路径是两个寄存器之间的路径，

所以，即使你得 multicycle 的结果稳定下来，也需要下一个时钟周期，寄存器才到，才算结束。

当你的 code 模块是 multicyle 时，你需要在约素时进行设置

在讲多周期路径之前，先看下单频率路径的建立关系和保持关系

『Design Compiler calculates the default setup and hold relations and derives single-cycle timing, based on active edges.』

1.对于 startpoint，active edge 是寄存器的 open edge。

2.对于 endpoint，active edge 是寄存器的 close edge。

3.对于上升沿触发的寄存器，上升沿既是 open edge 也是 close edge。

4.对于高电平出发的锁存器，上升沿是 open edge，下降沿是 close edge。

看一个例子：
下面进入多频率路径建立和保持

建立关系检查：

对于多频率设计，在两个时钟之间可能存在多个建立关系，对于目的时钟的的每一个锁存边沿，找到捕获边沿最近的发送边沿。发送边沿和捕获边沿的最小关

系决定了这个路径上的最大延迟。

保持关系检查：

简单说就是，数据从 startpoint 发出之后，在被 endpoint 的 active edge 锁存之前，不能被捕获。这个时序的最大值决定了，这个路径的最小延迟。

如下图所示：

Setup 要求：5-0=5

Hold 要求：30-30=0

Exp2：
Setup 要求=10-0=10

Hold 要求=0-0=0

Exp3

Setup 要求：4-3=1

Hold 要求：7-7=0

下面进入单频率的多周期：

先介绍命令 set_multicycle_path

常用格式：

set_multicycle_path

path_multiplier

[-rise | -fall]

[-setup | -hold]

[-start | -end]

[-from from_list]

[-to to_list]

[-through through_list]

Rise 和 fall 用来说明多周期路径是用在上升沿还是下降沿

Setup 和 hold 说明多周期路径是用在建立时间检查还是用在保持时间检查。

Stard 和 end 说明多周期路径依赖于 start clock 还是依赖于 end clock

例子：

Set_multicycle_path –setup 60 –to [get_pins “C_reg[*]/D”]

用来说明多周期路径的建立时间检查。

换句话说就是数据从 launch 到 capture 的时间是 6 个周期的时间。

那么缺省的保持时间检查时什么呢？看下面
根据 dc 综合原理：

对 hold 的检查之一就是：在 capture active edge 之前不能被捕获。所以缺省的 hold 检查实在第 6 个周期。而我们希望的是在 0 时刻进行 hold check。

所以要如下设置

但是这种写法很晦涩。我们可以通过 set_min_dealy 来设置 hold check：

set_min_dealy –to C_reg[0]/D

下面进入多频率的多周期：
这个例子和上面例子差不多，只是频率不同。

例子：以下仅为例子，实际设计中不会存在

module m(clka, clkb, ain, bin ,cout, dout);

input clka,clkb;

input [3:0] ain,bin;

output [7:0] cout,dout;

reg [7:0] cout, dout;

reg [3:0] ain_reg ,bin_reg;

wire [7:0] mul;

assign mul = ain_reg * bin_reg;

always@(posedge clka)

begin

ain_reg <= ain;

cout <= mul;

end

always@(posedge clkb)
begin

bin_reg <= bin;

dout <= mul;

end

endmodule

dc 脚本

set lib $env(DC_LIB)

set target_library "slow.db fast.db"

set link_library "* $target_library"

set search_path ". ../src ../scripts $lib"

analyze -format verilog m.v

elaborate m

compile

create_clock -period 10 [get_ports clka]

create_clock -period 30 [get_ports clkb]

set_multicycle_path 2 -to cout_reg[*]/D

set_multicycle_path 3 -to dout_reg[*]/D

set_min_delay 0 -to dout_reg[3]/D

set_min_delay 0 -to cout_reg[3]/D

compile

结构图
原来以为路径 path4 和 path1，path2，path3 上的建
立时间和保持时间检查的分析方法一项。所以上篇的
timing report 仅仅分析了一下 path1 和 path2。后来
觉得有些疑问，然后分析了下 path4（慢时钟采集快
数据），发现 dc 一个很微妙的分析方法，后来在 dc
的文档中发现的。后来想了下，这种建立关系和保持
关系的检查其实在 dc 的文档中还是说明了的。先看分
析，再总结：

综合脚本：

set lib $env(DC_LIB)

set target_library "slow.db fast.db"

set link_library "* $target_library"

set search_path ". ../src ../scripts $lib"

analyze -format verilog m.v

elaborate m

compile

create_clock -period 5 [get_ports clka]

create_clock -period 30 [get_ports clkb]

set_multicycle_path 3 -to cout_reg[*]/D

set_multicycle_path 4 -to dout_reg[*]/D

set_min_delay 0 -to dout_reg[3]/D

set_min_delay 0 -to cout_reg[3]/D

compile

path4 分析：

Setup：

report_timing -from ain_reg_reg[*]/CK -to

dout_reg[4]/D
可以看出来慢时钟采集快数据的多周期路径分析，不
是像快时钟采集慢数据的多周期分析一样（下图）：
希望的慢周期采集快数据的多周期分析

根据 timing report 可以知道实际的分析是：

再看下保持时间的分析

report_timing -from ain_reg_reg[*]/CK -to

dout_reg[4]/D -delay min
快时钟采慢数据的缺省 hold chek 如下，也是我们希
望的：

而实际上，dc 的分析师如下的：

所以对于慢时钟采集快数据的 setup，hold check 的

分析，可以由上面的分析总结为：

对于 setup 分析：

对于每一个 capture active edge 找到最靠近它的

launch active edge，然后这个 launch active edge
到多周期的 capture active edge 的路径就是 setup
check 的路径。

对于 hold 分析：

对于每一个 capture active edge 找到它的 launch

active edge 的下一个 launch active edge，然后这
个 launch active edge 到多周期的 capture active
edge 的路径就是 hold check 路径。

更简单的说，慢时钟采集快数据，是先分析慢时钟的
单周期 setup relation 和 hold relation，然后再扩
展到多周期路径上。

其实就是将单周期的 capture active edge，换成多

周期后的 capture active edge（多周期的相当于周
期很大）

对于 hold 分析的理解，可以将综合脚本改成下面的，
然后再分析下，就会很明白了。

set lib $env(DC_LIB)

set target_library "slow.db fast.db"

set link_library "* $target_library"

set search_path ". ../src ../scripts $lib"

analyze -format verilog m.v

elaborate m

compile

create_clock -period 5 [get_ports clka]

create_clock -period 31 [get_ports clkb]

set_multicycle_path 3 -to cout_reg[*]/D

set_multicycle_path 4 -to dout_reg[*]/D

set_min_delay 0 -to dout_reg[3]/D

set_min_delay 0 -to cout_reg[3]/D

compile

path4：

setup 分析：

report_timing -from ain_reg_reg[*]/CK -to

dout_reg[4]/D
示意图如下：

Hold 分析：

report_timing -from ain_reg_reg[*]/CK -to

dout_reg[4]/D -delay min
示意图：
DC 概论七之 gated clock

上图是一个典型的门控时钟电路。但是这种门控时钟无法避免的要受到 gate 的影响，容易

产生毛刺，除非你严格限制 gate 的输入。

一般常用的门控时钟是下面这种形式

为了得到稳定的 gclk 高电平，我们使用 clk 的高电平来锁存 gate 的值，如果 gate 是低电平，

那么 gclk 保持低电平，如果 gate 为高电平，锁存后，gate_out 为高电平，与 clk 运算后，可
以得到稳定的 gclk 高电平。

考虑上图中的各种延迟，分析门控时钟的建立时间检查和保持时间检查。

对于门控单元建立时间的检查路径：

门控的建立时间检查的路径中，因为 clk_latch 为低电平，所以理想化的可以认为，gate 直

接传输到 gate_out，但是实际要考虑点点延迟。可以简化成图一
考虑到延迟的时序图：
由时序图可以知道 gate 的上升沿或者下降沿到 clk_and 的时间应该长些比较好。

对于门控单元保持时间的检查路径：

考虑到延迟的保持时间检查：
由上图可以知道 clk_latch 的延迟如果比 clk_and 延迟大点，那么电路会更稳定些。

门控时钟综合：
综合工具内置时钟故障分析，但是有时候会产生不正确的分析。虽然如此，由于优化算法比
较强大，仍然可以得到理想的结果。

<!--[if !supportLists]-->1. <!--[endif]-->首先要开启时钟故障分析

set_clock_gating_check –setup $setup_time -hold $hold_time

$setup_time 和$hold_time 如上图的时序图所示

<!--[if !supportLists]-->2. <!--[endif]-->建立时间分析

如上图所示，综合工具会认出门控时钟里的锁存器，同时标识这条路径为锁存路径，分析的
时候会将这条路径分为 2 部分。
<!--[if !supportLists]-->第一条， <!--[endif]-->上级输出到锁存器的输入端 d
<!--[if !supportLists]-->第二条， <!--[endif]-->锁存器输出端 q 到门控逻辑的输入单

综合工具会实现分析第一条路径，因为这个锁存器的缘故。所以会发生前级向锁存器 borrow
time 的情况，出现这种情况的时候，即使第一条路径满足时序，可能的 violations 还是会产
生在第二条 path 上。

这里介绍下 latch-base 设计中的 borrow time

上图是基于 latch 的设计，黑色时钟线代表没有 borrow time 的时序图，

粉红和红色部分代表 borrow time。

对于 latch2 进行建立关系检查。由于 logic 的 8.9ns 的延迟，latch1 输出至少要经过 8.9ns 的

时间才能到达 latch2。但是根据时序图可以知道 clk1，和 clk2 的关系，当 latch2 capture 数
据的时候，latch1 的数据还没有到。这样就会产生逻辑故障。

为了修正这个逻辑故障，综合工具会 borrow time，以满足建立时间关系，如上图中的红色

和粉红色部分。综合工具会使 clk1 的低电平持续的时间够长，那么就要使 clk2 的低电平够
端，只要满足 setup relation 就可以。

如果 latch2 还有下级，那么我们可以知道，由于上级的 borrow time，下级有可能会产生一

些 time violations。
这个时候我们就要用 set_max_time_borrow 限制综合工具借入更多的时序，为了满足 setup
relation，综合工具会最大优化 logic 部分。
如果将上图放入到门控电路中，如下：

结合 borrow time 的时序图，我们分析下门控时钟里面可以设置的最大 borrow time：

上图是 borrow time 之后时序图，由时序图我们可以知道：

必须满足的时序关系:
T2-T1>Tcq_latch+Tcell_delay+clock_uncertainty
如下图红色路径所示

所以 borrowTime<Tphase – Tcq_latch –Tcell_delay –Tuncertainty

其中 Tphase 为 clk 的低电平时间

如果综合过程中 gclk 上 insert buffer 或者 insert delay，这些延迟也要考虑进去，以及后端过

程中可能引入的 buffer delay。

看一例：

module gate(clk, gate, din, qout);

 input clk,gate;

input [7:0] din;

output [7:0] qout;

reg [7:0] qout;

wire gclk;

//assign gclk = clk & gate;

always@(posedge gclk)

qout <= din;

reg gate_out;

always@(clk)

if(!clk)

gate_out <= gate;

assign gclk = clk & gate_out;

endmodule

DC 综合脚本：

set lib $env(DC_LIB)

set target_library "slow.db"

set link_library "* $target_library"

set search_path ". ../src ../scripts $lib"

analyze -format verilog gate.v

elaborate gate

uniquify

link

check_design

create_clock -period 100 [get_ports clk]

set input_exp_clk [remove_from_collection [all_inputs] [get_ports clk]]

set_input_delay 60 -clock [get_clocks clk] $input_exp_clk

set_output_delay 30 -clock [get_clocks clk] [all_outputs ]

set_clock_gating_check -setup 3 -hold 0

compile
综合结束后，setup 时序分析：

<!--[if !supportLists]-->1. <!--[endif]-->门控逻辑

AND2 的 setup 分析：

report_timing -delay max -nets -from gate_out

上图中可以看到到达时间是从 clk 的下降沿计算的，

以及要求时间是从上升沿开始，同事考虑到 clock_gating_check 中的 setup 设

置

<!--[if !supportLists]-->1. <!--[endif]-->setup 的

borrow time 分析

report_timing -delay max -nets -to gate_out_reg/D

有 dc 综合脚本的设置，以及上图 report：

到达时间是 60，由于 clk 脉冲宽度是 50，为了保证输入端建立时间满足，需要

向 ednpoint borrow time，上图中可以看出，time borrowed from endpoint
为 10，使要求时间变成 60，从而 slack 为 0，满足时序要求。

现在综合脚本中加入

set_max_time_borrow 7 [get_clock clk]

从新查看 setup 的 borrow time 分析：

report_timing -delay max -nets -to gate_out_reg/D

DC 概论之 IO 约束
用 dc 综合过程中需要对输入输出端口进行约束。
一般的约束出发点有两种，一种是 dc，一种是 ac。
所谓的 dc 是指已知输入延迟，或者输出延迟。这个要从板机考虑。
所谓的 ac 是指输入输出延迟未知，但是知道器件输入需要的保持，建立时间的关系。

下面我们看下对于输入，根据 dc，ac 如何约束。

1.DC
如果我们知道 Tdelay 的 max，min 那么很容易的写出约束
set_input_delay -max Tmax -clock Clk DIN
set_input_delay -min Tmin -clock Clk DIN
但是如果我们不知道输入延迟的最大最小值。那么如何约束呢。
先看下最大最小延迟对于器件的建立，保持检查起到的影响

如上图所示：Tdelay_min 对信号的影响可用从 T3 出看出。

Tdelay_max 对信号的影响可用从 T1 处看出。
所以信号的变化只能在斜线的阴影区。
2.AC
基于上图的认识，如果我们对于设计的芯片的输入信号的建立，保持有所了解。
可用使用 AC 来约束,如上图，我们知道对输入信号的要求是建立要在 Setup 之前，
保持要在 Hold 之后。那么约束可用写成:
set_input_delay -max Tperiod-Setup -clock Clk DIN
set_input_delay -min Hold -clock Clk DIN
再看下对于输出，根据 dc，ac 如何约束。
1.DC
如果我们知道 pcb 板上信号延迟的最大，最小，也很容易写出约束。
（这里的最大最小延迟仅指路径上的信号延迟，不包含器件如上图中 D2 本身的建立时间，
保持时间要求，
所以设置约束的时候要主意下）
set_output_delay -max Tdelay_max + Tsetup -clock Clk DOUT
set_output_delay -min Tdelay_min - Thold -clock Clk DOUT
下面再看下输出最大最小延迟对于建立，保持检查起到的影响

如上图所示，最大延迟影响如 T1 所示，最小延迟影响如 T3 所示，这里假设器件的 setup，

hold 均为 0,可用容易理解。
这里要主意，最小延迟的影响，因为任何延迟都会满足要求。最小延迟影响，要求信号在细
条阴影区变化，但是考虑到 launch 边沿在 T2,
所以信号的允许变化范围如阴影区显示(大条)。
2.AC
但是通常设计的 chip 外接可能还是 chip 或者其他器件，这些器件都有建立,保持要求。
所以如果上图的时序改成下面这种基于外围器件的建立，保持要求的。则更为理解。
约束也就相应的改成：

set_output_delay -max Setup -clock Clk DOUT

set_output_delay -min -Hold -clock Clk DOUT

如果注意观察就会发现上如对于信号的要求都是要求信号在相关时钟沿附件保持稳定。
有的时候我们要求信号在相关时钟沿附近是需要变化的。
这里要用到零多周期路径。
下面看下对于一般的单周期路径，如何写成多周期路径

那么如果对于零多周期路径，建立，保持如何检查：
当设置 set_multicycle_path -setup 0 的检查如下：
当再次设置 set_multicycle_cycle -hold -1 ..时序检查如下：

再如下图，我们要求信号在 S1,H1 区域内变化。

如何约束呢。

首先是设置 0 多周期路径。
set_multicycle_path -setup 0 .....
set_multicycle_path -hold -1 .....
然后根据要求设置最大最小延迟。
有了上面的认识，我们大约可用了解：
如果设置了最大延迟，那么信号只能在最大延迟前变化，
如果设置了最小延迟，那么信号只能在最小延迟后变化。
所以我们设置成:
set_output_delay -max -S1 .....
set_output_delay -min H1 .....
注意符号：）
接着我们来考虑下源同步接口，所谓源同步接口就是输入输出带有时钟线。
同时数据的变化和时钟沿对齐（或上升沿，或下降沿，或双沿）。
如下图，单边沿对齐的源同步接口。数据 DQ 和时钟 SCK 对齐,CAC 地址控制信号

当然我们不知道 pcb 走线延迟，但是我们知道链接的器件的建立，保持要求分别为 Th_ext，

Ts_ext
我们自己 chip 的建立保持要求为 Th,Ts
我们可用约束如下：
create_generated_clock -name clkx1 -multiply_by 1 -source clk PLL/clkx1
create_generated_clock -name SCK -divide_by 1 -source PLL/clkx1 SCK

set_input_delay -max T-Ts -clock clkx1 DQ

set_input_delay -min Th -clock clkx1 DQ

set_output_delay -max Ts_ext -clock SCK {DQ CAC}

set_output_delay -min -Th_ext -clock SCK {DQ CAC}

如果数据和时钟是双边沿对齐的,建立，保持条件如上，同时下降沿和上升沿要求一样。
 create_generated_clock -name clkx1 -multiply_by 1 -source clk PLL/clkx1
create_generated_clock -name SCK -divide_by 1 -source PLL/clkx1 SCK

set_output_delay -max Ts_ext -clock SCK CAC

set_output_delay -min -Th_ext -clock SCK CAC

set_input_delay -max T-Ts -clock clkx1 {DQ DQS}

set_input_delay -max T-Ts -add_delay -clock clkx1 -clock_fall clkx1 {DQ DQS}
set_input_delay -min Th -clock clkx1 {DQ DQS}
set_input_delay -min Th -add_delay -clock clkx1 -clock_fall clkx1 {DQ DQS}

set_output_delay -max Ts_ext -clock SCK {DQ DQS}

set_output_delay -max Ts_ext -add_delay -clock SCK -clock_fall {DQ DQS}

set_output_delay -min -Th_ext -clock SCK {DQ DQS}

set_output_delay -min -Th_ext -add_delay -clock SCK -clock_fall {DQ DQS}

DC 优化约束

时间约束和面积约束、功耗约束

set_max_area

set_input_delay

set_output_delay

create_clock

set_clock_latency

set_propagated_clock

set_clock_uncertainty

1.定义时钟, 周期和波形

create_clock [ - period period_value] [ - name clock_name] [- waveform. edge_list] [source_list]

例如，周期为 20，占空比为 40%(上升沿在 0 时刻，下降沿在 8 时刻)，的时钟，输入的管教名称为 CLK

dc_shell>create_clock - period 20 - waveform. {0 8} CLK

默认为 50%占空比

关于公共基准周期的问题，查询书。10，20，30，公共基准就是 60.尽量设置使得公共基准周期小。否则，运算复杂。

设置时钟不确定性绕开这个问题，如下：10,10.1,公共基准周期为 1010.0

>create_clock -period 10 clk1

>create_clock -period 10 clk2

>set_clock_uncertainty -setup 0.1 clk2

两个时钟都没有小数部分，计算时间也不需要扩展其周期，由于对 clk2 设置了建立时间的不确定性，最终结果仍然考虑 0.1 的时间。

用 set_clock_latency 和 set_clock_uncertainty 定义时钟网络的时延信息。

2.确定 I/O 端口相当于以时钟的时间约束

相当于给输入输出信号信号相对于时钟的时间要求。

对输入：定义了信号到达模块时已经经过的延时。

对输出：限定了信号必须在哪个时间前有效。

据此，DC 可以计算出这个模块内部各个路径的时延要求，根据这些信息进行优化。

默认，都为 0，与实际相悖。

例如： 定义的是时间约束相对于时钟上升沿的关系

>set_input_delay 20 -clock CLK DATA_IN //DATA_IN 为输入端口

>set_output_delay 15 -clock CLK DATA_OUT

3.组合时延

无法与时钟对应的情况

对复位信号 rst 设置了最大的时延 5

>set_max_delay 5 -from rst

>set_min_delay

4.确定例外情况

伪路径:

无时间要求或无实际操作的路径

dc_shell>set_false_path -from U1/G -to U1/D

最小时延要求和最大时延要求：

set_min_delay set_max_delay

多周期路径:

set_multicycle_path

结合-setup 和-hold 命令可以将建立时间和保持时间检查从缺省的位置向后移动到实际的位置。

例如：定义一个从 A 到 B 的路径伪一个两周期的路径

>set_multicycle_path 2 -from A -to B

面积约束：

>set_max_area 100 //单位与工艺库中的一致

Synopsys Synthesis Constraints Template

###Customize according to your Design needs
########################################################
#### Portion to Edit
#### Variables clock1_name is the Clock name, clock1_period is the Cloc
k period,
#### clock1_period_half is the half of the clock period
#### set clock1_name <clock1_name>
#### set clock1_period <clock1_period>
#### set clock1_period_half [expr $clock1_period / 2]
#### set clock1_period_onetenth [expr $clock1_period / 10]
#### set clock1_period_onetwenth [expr $clock1_period / 20]
#### set clock1_latency <clock1_latency_number>
#### set CTS_clock1_skew <CTS_clock1_skew_number>
########################################################
#### Source the .synopsys_dc_setup file, File which has all the library s
ettings
source .synopsys_dc_setup
#### Read the rtl files
read_verilog <RTL file name>
### Similar way read all the RTL files
### Specify the Top-level file name
current_design <top-level module name>
#### Link the design
link
#### Uniquify the design, for designs with multiple instantiation
uniquify
####Specify the Clocks in the Design ######
#### Example for one Clock in the Design named clock1
create_clock -period $clock1_period -waveform [list 0 $clock1_period_half ]
-name $clock1_name <specify the location of the node where clock? ne
ed to be generated>
set_clock_skew -ideal -uncertainty $CTS_clock1_skew $clock1_name
set_clock_transition 0.3 $clock1_name
set_clock_latency $clock1_latency_number $clock1_name
set_dont_touch_network $clock1_name
#### Generate the same list of constraints for all the clocks in the desig
n
#### Generate the False and Multi-cycle paths in the design as Timing
Exceptions for the tool.
#### False And Multi-cycle paths are purely Design Specific.
#set_false_path -from <Source > -to <Destination> -setup
#set_false_path -from <Source > -to <Destination> -hold
#set_multicycle_path <no of cycles> -from <source> -to <destination>

##### Steps to constrain the inputs/outputs and the design

set_input_transition $clock1_period_onetenth [all_inputs]
set_max_transition $clock1_period_onetwenth $current_design
#### Specify the wire-load model
set auto_wire_load_selection true ### Tool automatically selects the wire-
load model
#### Create virtual clocks to constrain the ports.To understand concept
behind the virtual clocks
#### Check out the ASIC FAQ's column.
#### To constrain inputs
set_input_delay <input delay value> -clock <with respect to virtual clock>
<input_port1>
### Similar way define for all the inputs and w.r.t virtual clocks
#### To constrain out-puts
set_output_delay <output delay value> -clock <with respect to virtual cloc
k> <output_port1>
### Similar way define for all the outputs and w.r.t virtual clocks
### To constrain purely combinational paths
set_max_delay <specify delay values> -from <source path> -to <destinati
on path>
### For the high fanout nets for which tree will be built and to get awa
y from false loading violation
set_ideal_net <reset_name>
set_ideal_net <scan_enable_name>
### In-order to constrain specific paths passing through the muxes, for e
xample for the tool to
### concentrate on the functional-paths , specify case_analysis for functi
onal paths.
set_case_analysis <case value 0/1> <Mux/Bi-furcating paths>
#### If the design requirement is for area critical designs
set_max_area 0
#### To prevent the tool from optimizing
#set_dont_touch <area to be dont-touched>
####Mapping the RTL specific to the Targetted Technology Library
#### The command means to map it , with scannable flop's, with high o
ptimization possible,
#### Area optimized for non-critical-paths as-well-as boundary paths opti
mized.
compile -scan -map_effort high -area_effort high -boundary_optimization
#### Save the database
write -f db -h -o <design_name.db>
#### Set some variables for proper saving of verilog netlist file
set verilogout_no_tri true
set bus_naming_style [format "%s%s" "%s\[" "%d\"]
write -f verilog -h -o <design_name.v>
### Save the Used SDC(Synopsys Design Constraints file>
write_sdc <design_name.sdc>
###Report Generation
report_constraints -all_violators -verbose ### Command to report all the
violations
report_area ### command to report the design area
report_reference ### command to report the design details as per the su
b-blocks
### A very powerful command to know the quality of the design constrai
nts
check_design ###Command to know the design <for example flops which
are not getting clocks, ports which are not constrained>
#### Now, let us know the Test Part of the Design
set test_default_period 100
set test_default_delay 5
set test_default_bidir_delay 30
set test_default_strobe 35
set test_default_strobe_width 0
#### Specify that there is no scan-chain present in the design
set_scan_configuration -existing_scan false
#### specify whether clock mixing is allowed or not while scanstitching
set_scan_configuration -clock_mixing no_mix
#### specify the style of flip-flop
set_scan_configuration -style multiplexed_flip_flop
#### Specify the scanchain methodology whether full-scan or partial sca
n
set_scan_configuration -methodology full_scan
#### Specify the longest chain length according to the tester memory
set_scan_configuration -longest_chain_length 200
#### Specify the scan-enable signal
set_scan_signal test_scan_enable -port <design_scan enable port name>
#### Specify a case analysis value for to the tool to be in the scan-mo
de while scan-stitching
set_test_hold <value either 0/1> <design scan-mode port name>
#### Specify the designs for which scan-stitching is not required
set_scan_element false [get_designs <sub design_name>
#### Specify the scan-in and scan-out port of the design to the tool
set_scan_signal test_scan_in -port [get_ports <design scan_port input>
set_scan_signal test_scan_out -port [get_ports <design scan_port out-put>
#### specify the test-clock in the design
create_test_clock < clock_name> -period < specify period numeric> -wav
eform {rise-edge fall-edge}
#### run the check-test to know the design violations w.r.t. test
check_test -verbose
##### command to insert scan
insert_scan -map_effort high
#### Report generation
report_test -scan_path ### command to list all the scan-chains
#### Save the database
write -f db -h -o <design_name_scan.db>
#### Set some variables for proper saving of verilog netlist file
set verilogout_no_tri true
set bus_naming_style [format "%s%s" "%s\[" "%d\"]
write -f verilog -h -o <design_name_scan.v>
###Report Generation after scan-insertion
report_constraints -all_violators -verbose ### Command to report all the
violations
report_area ### command to report the design area
report_reference ### command to report the design details as per the su
b-blocks

功耗和门控时钟的的基本概念

1. 1 功耗的基本概念
电路中耗散的能量可以分为静态功耗( static power)和动态功耗( dynamic power) 。静态功耗的主要原
因是:晶体管中从源到漏的亚阈值泄漏( subthreshold leakage) ,就是指阈值电压的降低阻止了栅的关闭。
动态功耗分为开关功耗( switching power)和内部功耗( internal power) 。开关功耗是由于器件的输出
端的负载电容的充放电引起的。负载电容包括了门和线的电容。内部功耗指在器件内部耗散的能量,主要由
瞬时短路所引起的。
1. 2 门控时钟的的基本概念
通常,门控时钟的实现方式有 4 种:基于“与”门、基于“或”门、基于触发器和基于 latch。以图 1
中基于 latch 的门控时钟为例,基于 latch 的门控时钟的实现原理是:在 clock 为高电平时 latch 不会锁存
数据,在 clock 的上升沿捕获 enable 信号。特别需要注意的是,门控时钟的使用可能会带来时序上的问题。
特别当集成电路的设计已经进入深亚微米级时代, 线延时占据了总延时的 70%。以基于 latch 的门控时钟
为例, 布局布线之后,对应的 latch 和寄存器可能会距离很远,造成它们之间的连线延时过大,时序就可能
不满足要求。因此,采取的方法是将对应的 latch 和寄存器整合在一起,作为一个标准单元来使用。这样,
可以保证的时序满足要求(此时的 set_clock_gating_style 的设置将会不同) 。

2 在设计中使用门控时钟
本文首先给出了综合时使用的脚本,以实际中的一个设计生成的报告文件为例,对比了使用门控时钟前
后的面积、时序、功耗方面的差别。
2. 1 运行的脚本
一般可以采用全定制( full - custom)的设计方法,手工绘制电路图,确定设计中是否采用门控时钟。
但随着设计规模的日益增大,必须要借助 EDA 工具的帮助。在脚本中可以很灵活地对设计进行如下方面的控
制:
(1) 时钟的实现方式:基于“与”门、基于“或”门、基于触发器、基于 latch;
(2) “使能”端( enable)进行 SETUP、HOLD 检查;
(3) 对特定的 signal 是否使用门控时钟;
(4) 门控时钟的最大扇出;
(5) 是否插入 scan 信号。
使用 Synop sys 公司的综合工具 Design Comppiler,该综合工具支持在设计中使用门控时钟,并可以进
行相应的时序分析和功耗分析[ 2～4 ] 。
下面给出使用 Design Compiler 进行综合时部分脚本:
set_clock_gating_style - sequential_cell latch - positive_edge_logic { and} -
negative_edge_logic {or}
/基于 latch 的门控时钟, 如果从工艺库中调用已经做好的具有门控时钟功能的标准单元, 对应选项
变为- positive_edge_logic integrated /
analyze - format verilog - lib library_name - define SYNOPSIS
/读入 verilog 格式的 HDL 文件,并且用指定的 library 中的中间格式存储 /
Set_clock_gating_signals - design design_name
/控制 signal 是否采用门控时钟 /
elaborate design_name - gate_clock - update - lib library_name
/从存储的中间格式中建立对应的设计/
p ropagate_constraints - gate_clock
/ 将底层设计中的约束加到当前设计中/
comp ile - incremental_mapp ing - map_effort high
/映射过程中花费更多的 cpu 运行时间 /
2. 2 报告文件
Synopys 公司的 Design Comp iler 作为业界最流行的综合工具软件,功能相当强大,可以生成详细的报
告文件,将会在时序、功耗、面积三个方面加以比较。首先必须保证时序满足条件,否则功耗的降低和面积
的减小就没有意义。而门控时钟的引入,常常会造成相应的时序问题。作者使用 Synopys 公司的 PrimeTime
进行静态时序分析( Static Timing A2nalysis) 。
表 1 给出的是 PrimeTime 对当前设计的关键路径的时序报告。data required time 表示理论上最大允许的
延迟时间, data arrival time 表示实际数据到达的时间。表 1 说明,使用门控时钟后,时序仍然满足要求。

表 2 给出的是 Design Comp iler 对当前设计的功耗报告。可以看到,使用门控时钟后,功耗总体下降了

45. 4%。其中内部功耗下降了 53. 9% ,开关功率下降了 35. 3%,但是泄漏功耗只下降了 1. 8% ,由于泄漏
功耗在总体功耗中比例可以忽略不计,使用门控时钟后功耗总体有了显著的下降。同时说明门控时钟的使用,
对内部功耗和开关功率的影响较为显著,对泄漏功耗的影响不显著。值得注意的是,虽然不排除通过牺牲面
积来降低功耗。但在本设计中,降低功耗的同时,面积也有了一定的下降。总面积下降了 7. 3% ,其中组合
逻辑的面积减少了 21. 5% ,非组合逻辑的面积增加了 5. 5%。说明门控时钟的使用,减少了组合逻辑的使用,
增加了非组合逻辑的使用。

对 FALSE PATH 的理解

最近做了一点 FPGA 方面的工作，在用 QuartusII 对代码进行综合时四处查找资料，
总算是对 FALSE PATH 有了一点点的理解，总得来说，FALSE PATH 就是我们在进
行综合分析时，不希望综合工具进行分析的那些路径。写出来和大家一起讨论。
在 QuartusII 的一个培训文档里面解释了什么时候要用到 FALSE PATH：
1.              从逻辑上考虑，与电路正常工作不相关的那些路径，比如测试逻辑，静
态或准静态逻辑。
2.              从时序上考虑，我们在综合时不需要分析的那些路径，比如跨越异步
时钟域的路径。
下面举例说明：
先看图 1，MUX_1 和 MUX_2 是两个多路选择器，MUX_1 的使能端 C 接到时钟 clk，
MUX_2 的使能端 C 接到 clk 的反。于是可以发现 MUX_1 的 S1 端口是不可能经过
MUX_2 的 S1 端口到达 MUX_2 的 D 端口的，同理 MUX_1 的 S2 端口是不可能经
过 MUX_2 的 S2 端口到达 MUX_2 的 D 端口。于是我们就不希望综合工具对这两
条路径进行分析，就是说这两条路径就是我们所说的 FALSE PATH：
set_false_paths –through Mux_1/S1 –through Mux_2/S1 
set_false_paths –through Mux_2/S2 –through Mux_2/S2

图1
再看图 2，模块 test_logic 表示一个测试逻辑，它并不真正实现我们电路的功能，
只是为了测试电路功能。所以我们就不希望综合工具对这这些路径进行分析，就
是说这些路径就是我们所说的 FALSE PATH：

图2

set_false_path –fall_from clk1–to [get_pins test_logic|*|datain]
set_false_path –from [get_pins test_logic|*|clk] \
‐to [get_pins test_logic|*|datain]
set_false_path –from [get_pins test_logic|*|clk] ‐to [get_ports test_out]
然后看图 3，reg1 的输出和 reg2 的输入跨越了不同的时钟域 clk1 和 clk2，我们
不希望综合工具对这这些路径进行分析，就是说这些路径就是我们所说的 FALSE 
PATH：
set_false_path –from [get_pins reg1|clk]–to [get_pins reg2|datain]
 图3

最后我们看图 4，clk_100 和 clk_66 仍然是两个不同的时钟域，这也是 FALSE PATH：

set_false_paths –from [get_clocks clk_100] –to [get_clocks clk_66]
set_false_paths –from [get_clocks clk_66] –to [get_clocks clk_100]
实际上，这两条 FALSE PATH 可以用一条命令来代替：
set_clock_groups –exclusive –group {clk_100} \
–group {clk_66} –group {clk_200}
这就涉及到 set_clock_groups  命令了，我们以后再说。

How many False Path?

Answer 3

What about SDC?

1 set_false_path -from x_reg -through xa1_s -through xa2_s -to y_reg
2 set_false_path -from x_reg -through xy1_s -through xy2_s -to y_reg
3 set_false_path -from y_reg -through xy1_s -through xy2_s -to y_reg

图4

TimeQuest 时钟分析
完整的静态时序分析包括寄存器至寄存器分析、I/O 和异步复位通路分析等。 TimeQuest 分
析器使用数据请求时间、数据到达时间和时钟达到时间来验证电路性能，检测潜在的时序违
规。 TimeQuest 分析器确定设计正常工作必须符合的时序关系，针对请求时间检查达到时
间，以验证时序。
时钟建立检查
时钟保持检查
恢复和消除
多周期通路
时钟建立检查
进行时钟建立检查时，TimeQuest 分析器分析每个寄存器至寄存器通路的启动和锁存边沿，
确定建立关系。对于目的寄存器的每个锁存边沿，TimeQuest 分析器使用最靠近源寄存器的
前一时钟边沿作为锁存边沿。
在图 1 中，定义了两个建立关系，标记为 Setup A 和 Setup B。对于 10ns 的锁存沿，作为启
动沿的最近时钟是在 3ns，标记为 Setup A。对于 20ns 的锁存沿，作为启动沿的最近时钟是
在 19ns，标记为 Setup B 。
图 1. 建立检查

TimeQuest 分析器时钟建立检查作为松弛结果。松弛是时序要求达到或者没有达到的余量。
正松弛表明达到要求，负松弛表明没有达到要求。 TimeQuest 分析器利用方程 1 来确定内
部寄存器至寄存器通路的时钟建立松弛。
方程 1
Clock Setup Slack = Data Required Time – Data Arrival Time
Data Required = Clock Arrival Time – μt SU – Setup Uncertainty
Clock Arrival Time = Latch Edge + Clock Network Delay to Destination Register
Data Arrival Time = Launch Edge + Clock Network Delay Source Register + μt CO +
Register-to-Register Delay
如果数据通路是从输入端口至内部寄存器， TimeQuest 分析器使用方程 2 来计算保持松弛
时间。
方程 2
Clock Setup Slack Time = Data Required Time – Data Arrival Time
Data Arrival Time = Launch Edge + Clock Network Delay to Source Register + Input Maximum
Delay of Pin + Pin to Register Delay
Data Required Time = Latch Edge + Clock Network Delay to Destination Register – μt SU
如果数据通路是从内部寄存器至输出端口， TimeQuest 分析器使用方程 3 来计算建立松弛
时间。
方程 3
Clock Setup Slack Time = Data Required Time – Data Arrival Time Data Arrival Time = Launch
Edge + Clock Network Delay to Source Register + μt CO + Register to Pin Delay
Data Required Time = Latch Edge + Clock Network Delay to Destination Register – Output
Maximum Delay of Pin
时钟保持检查
进行时钟保持检查时， TimeQuest 分析器确定所有源和目的寄存器对的建立关系的保持关
系。 TimeQuest 分析器检查所有建立关系的邻近时钟边沿，确定保持关系。 TimeQuest 分
析器对每一种建立关系进行两种保持检查。第一种保持检查确定当前启动沿启动的数据没有
被前一锁存沿捕获到。第二种保持检查确定下一启动沿启动的数据没有被当前锁存沿捕获
到。
图 2 显示了两种建立关系，以 Setup A 和 Setup B 标出。 Setup A 和 Setup B 的第一种
保持检查分别标记为 Hold Check A1 和 Hold Check B1 。 Setup A 和 Setup B 的第二种保
持检查分别标记为 Hold Check A2 和 Hold Check B2 。
图 2.保持检查

从可能的保持关系中， TimeQuest 分析器选择限制最严的保持关系。选择锁存和启动沿

( 即，锁存 – 启动不是锁存 – 启动的绝对值 ) 差异最大的保持关系，因为这决定了寄存
器至寄存器通路之间的最小延时。对于图 2 ，选择的保持关系是 Hold Check A2 。
TimeQuest 分析器按照方程 4 来确定时钟保持松弛。
方程 4
Clock Hold Slack = Data Arrival Time – Data Required Time
Data Required Time = Clock Arrival Time +μt H + Hold Uncertainty
Clock Arrival Time = Latch Edge + Clock Network Delay to Destination Register
Data Arrival Time = Launch Edge + Clock Network Delay to Source Register +μt CO + Register
to Register Delay
如果数据通路是从输入端口至内部寄存器， TimeQuest 分析器使用方程 5 来计算建立松弛
时间。
方程 5
Clock Setup Slack Time = Data Arrival Time – Data Required Time
Data Arrival Time = Launch Edge + Clock Network Delay to Source Register + Input Minimum
Delay of Pin + Pin to Register Delay
Data Required Time = Latch Edge + Clock Network Delay to Destination Register + μt H
如果数据通路是从内部寄存器至输出端口， TimeQuest 分析器使用方程 6 来计算建立松弛
时间。
方程 6
Clock Setup Slack Time = Data Arrival Time – Data Required Time
Data Arrival Time = Launch Edge + Clock Network Delay to Source Register + μt CO + Register
to Pin Delay
Data Required Time = Latch Edge + Clock Network Delay to Destination Register – Output
Minimum Delay of Pin
恢复和消除
恢复时间是异步控制信号，例如复位信号，在下一有效时钟沿达到前必须稳定下来的最短时
间。恢复松弛时间的计算与时钟建立松弛时间相似，但采用了异步控制信号。如果异步控制
信号已寄存， TimeQuest 分析器使用方程 7 来计算恢复松弛时间。
方程 7
Recovery Slack Time = Data Required Time – Data Arrival Time
Data Arrival Time = Launch Edge + Clock Network Delay to Source Register + μt CO + Register
to Register Delay
Data Required Time = Latch Edge + Clock Network Delay to Destination Register – μt SU
如果异步控制信号没有寄存， TimeQuest 分析器使用方程 8 来计算恢复松弛时间。
方程 8
Recovery Slack Time = Data Required Time – Data Arrival Time
Data Arrival Time = Launch Edge + Maximum Input Delay + Port to Register Delay
Data Required Time = Latch Edge + Clock Network Delay to Destination Register Delay – μt SU
注释 : 如果异步复位信号来自一个端口 ( 器件 I/O) ，您必须为 TimeQuest 时序分析器的
异步复位引脚分配输入最大延时，以便对通路进行恢复分析。
消除时间是异步控制信号在有效时钟沿之后必须稳定下来的最短时间。 TimeQuest 分析器
消除时间松弛计算与时钟保持松弛的计算相似，但采用异步控制信号。如果异步控制信号已
经寄存， TimeQuest 分析器使用方程 9 来计算消除松弛时间。
方程 9
Removal Slack Time = Data Arrival Time – Data Required Time
Data Arrival Time = Launch Edge + Clock Network Delay to Source Register + μt CO of Source
Register + Register to Register Delay
Data Required Time = Latch Edge + Clock Network Delay to Destination Register + μt H
如果异步控制信号没有寄存， TimeQuest 分析器使用方程 10 来计算消除松弛时间。
方程 10
Removal Slack Time = Data Arrival Time – Data Required Time
Data Arrival Time = Launch Edge + Input Minimum Delay of Pin + Minimum Pin to Register
Delay
Data Required Time = Latch Edge + Clock Network Delay to Destination Register +μt H
注释 : 如果异步复位信号来自一个器件引脚，您必须为 TimeQuest 时序分析器的异步复位
引脚分配输入最小延时，以便对通路进行消除分析。
多周期通路
多周期通路是目的寄存器需要多个时钟周期来锁存数据的数据通路。例如，寄存器可能需要
在第二或者第三个时钟上升沿来采集数据。
图 3 所示的例子是其他时钟沿目的寄存器锁存数据时，触发器输入寄存器和输出寄存器之
间的多周期通路。请参考 TimeQuest set_multicycle_path 命令 ，了解 set_multicycle_path 命
令。
图 3. 多周期通路
静态时序分析
在制程进入深次微米世代之后，晶片（IC）设计的高复杂度及系统单晶片
（SOC）设计方式兴起。此一趋势使得如何确保 IC 品质成为今日所有设计从业人
员不 得不面临之重大课题。静态时序分析（Static Timing Analysis 简称 STA）
经由完整的分析方式判断 IC 是否能够在使用者的时序环境下正常工作，对确保
IC 品质之课题，提供一个不错的解决方案。然而， 对于许多 IC 设计者而言，
STA 是个既熟悉却又陌生的名词。本文将力求以简单叙述及图例说明的方式，对
STA 的基础概念及其在 IC 设计流程中的应用做详尽 的介绍。

什么是 STA？（STA,Static Timing Analysis）

STA 的简单定义如下：套用特定的时序模型（Timing Model），针对特定电
路分析其是否违反设计者给定的时序限制（Timing Constraint）。以分析的方
式区分，可分为 Path-Based 及 Block-Based 两种。

先来看看 Path-Based 这种分析方式。如图一所示，讯号从 A 点及 B 点输入，

经由 4 个逻辑闸组成的电路到达输出 Y 点。套用的 Timing Model 标示在各逻辑
闸上，对于所有输入端到输出端都可以找到相对应的延迟时间。而使用者给定的
Timing Constraint 为：
 1. 讯号 A 到达电路输入端的时间点为 2（AT=2，AT 为 Arrival Time）。
2. 讯号 B 到达电路输入端的时间点为 5（AT=5）。
3. 讯号必须在时间点 10 之前到达输出端 Y（RT=10，RT 为 Required Time）。

现在我们针对 P1 及 P2 两条路径（Path）来做分析。P1 的起始点为 A，讯

号到达时间点为 2。经过第 1 个逻辑闸之后，由于此闸有 2 单位的延迟时间，所
以 讯号到达此闸输出的时间点为 4（2+2）。依此类推，讯号经由 P1 到达输出 Y
的时间点为 7（2+2+3）。在和上述第三项 Timing Constraint 比对之后，我们
可以得知对 P1 这个路径而言，时序（Timing）是满足使用者要求的。

按照同样的方式可以得到讯号经由路径 B 到达输出 Y 的时间点为 11

（5+1+3+2），照样和上述第三项 Timing Constraint 比对，我们可以得知对 P2
这个路径而言，Timing 是不满足使用者要求的。

对图一的设计而言，总共有 6 个讯号路径。对于采用 Path-Based 分析方式

的 STA 软体来说，它会对这 6 个讯号路径作逐一的分析，然后记录下结果。 IC
设计者藉由检视其分析报告的方式来判断所设计的电路是否符合给定的 Timing
Constraint。由于最常用来做静态时序分析验证核可（STA Signoff）的 EDA 软
体 PrimeTime?采用 Path-Based 的分析方式，所以本文将以 Path-Based 的分析
方式介绍为主。

再来看看 Block-Based 的分析方式。此时时序资讯（Timing Information）

的储存不再是以路径为单位，而是以电路节点（Node）为单位。由 Timing
Constraint 我们仅能得知 A 节点的 AT 为 2，B 节点的 AT 为 5 以及 Y 节点的 RT
为 10。Block-Based 的分析方式会找出每个节点的 AT 和 RT，然后比对这两个数
值。当 RT 的值大于 AT 时表示讯号比 Timing Constrain 中要求的时间还早到达，
如此则 Timing 是满足的，反之则不满足。

STA 资料准备

在做 STA 之前，我们必须对其准备工作有充分的了解。STA 所需的资料如图三所

示，以下我们分项说明。其中 Design Data 部分，由于 Block Model 和 STA 软体
相关性太高，我们不在此加以说明，请直接参阅您 STA 软体的使用手册。
 图 三

Library Data：

STA 所需要的 Timing Model 就存放在标准元件库（Cell Library）中。这些必

要的时序资讯是以 Timing Arc 的方式呈现在标准元件库中。Timing Arc 定义逻
辑闸任两个端点之间的时序关系，其种类有 Combinational Timing Arc、Setup
Timing Arc、Hold Timing Arc、Edge Timing Arc、Preset and Clear Timing Arc、
Recovery Timing Arc、Removal Timing Arc、Three State Enable & Disable
Timing Arc、Width Timing Arc。其中第 1、4、5、8 项定义时序延迟，其他各
项则是定义时序检查。

图 四

Combinational Timing Arc 是最基本的 Timing Arc。Timing Arc 如果不特别宣

告的话，就是属于此类。如图四所示，他定义了从特定输入到特定输出（A 到 Z）
的延迟时间。Combinational Timing Arc 的 Sense 有三种，分别是 inverting
（或 negative unate），non-inverting（或 positive unate）以及 non-unate。
当 Timing Arc 相关之特定输出（图四 Z）讯号变化方向和特定输入（图四 A）讯
号变化方向相反（如输入由 0 变 1，输出由 1 变 0），则此 Timing Arc 为 inverting
sense。反之，输出输入讯号变化方向一致的话，则此 Timing Arc 为
non-inverting sense。当特定输出无法由特定输入单独决定时，此 Timing Arc
为 non-unate。

图 五

图 六

图 七

图 八

图 九
 图 十

图 十一

图 十二

其他的 Timing Arc 说明如下。

• Setup Timing Arc：定义序向元件（Sequential Cell，如 Flip-Flop、

Latch 等）所需的 Setup Time，依据 Clock 上升或下降分为 2 类（图五）。
• Hold Timing Arc：定义序向元件所需的 Hold Time，依据 Clock
上升或下降分为 2 类（图六）。
• Edge Timing Arc：定义序向元件 Clock Active Edge 到资料输出
的延迟时间，依据 Clock 上升或下降分为 2 类（图七）。
• Preset and Clear Timing Arc：定义序向元件清除讯号（Preset
或 Clear）发生后，资料被清除的速度，依据清除讯号上升或下降及是
Preset 或 Clear 分为 4 类（图 八）。这个 Timing Arc 通常会被取消掉，
因为它会造成讯号路径产生回路，这对 STA 而言是不允许的。
• Recovery Timing Arc：定义序向元件 Clock Active Edge 之前，
清除讯号不准启动的时间，依据 Clock 上升或下降分为 2 类（图九）。
• Removal Timing Arc：定义序向元件 Clock Active Edge 之后，清
除讯号不准启动的时间，依据 Clock 上升或下降分为 2 类（图十）。
• Three State Enable & Disable Timing Arc：定义 Tri-State 元
件致能讯号（Enable）到输出的延迟时间，依据 Enable 或 Disable 分为
2 类。（图十一）
• Width Timing Arc：定义讯号需维持稳定的最短时间，依据讯号维
持在 0 或 1 的位准分为 2 类。（图十二）
上文列出了标准元件库内时序模型的项目，但对其量化的数据却没有加以说明。
接下来，我们就来看看到底这些时序资讯的确实数值是如何定义在标准元件库中
的。

以 Combinational Timing Arc 为例，讯号从输入到输出的延迟时间可

以描述成以输入的转换时间（Transition Time）和输出的负载为变数的函数。
描述的方式可以是线性的方式，如图十三所示。也可以将这 2 个变数当成指标，
建立时序表格（Timing Table），让 STA 软体可以查询出正确的延迟时间。这种
以表格描述的方式会比上述线性描述的方式准确许多，因此现今市面上大部分的
标准元件库皆采用产 生时序表格的方式来建立 Timing Model。

图 十三

我们举个简单的例子来说明 STA 软体如何从时序表格计算出元件延迟时间。（图

十四）

图十四

• 元件延迟时间（Ddelay）：输入达逻辑 1 位准 50%到输出达
逻辑 1 位准 50%的时间。
 • 元件转换时间（Dtransition）：输出达逻辑 1 位准 20%（80%）
到 80%（20%）的时间。

当输入的转换时间为 0.5，输出负载为 0.2 时，可由图十四的时序表格查

得元件 I2 的延迟时间为 0.432。而由于表格的大小有限，对于无法直接由表格
查 询到的延迟时间（如输入转换时间 0.25，输出负载 0.15），STA 软体会利用
线性内插或外插的方式计算延迟时间。

对于其他的 Timing Arc，不管是时序延迟或时序检查，其相对应的时

序数值计算和上例的计算方式是一样的。

接下来我们说明操作环境（Operating Condition）对时序的影响。操
作环境指的是制程（Process）、电压（Voltage）、温度（Temperature）三项
因子。这三项因 子通常会被简称为 PVT，其对时序的影响可用下方线性方程式
来描述。其中 nom_process、nom_voltage 及 nom_temperature 会定义在标准元
件库中，代表建立时序表格时的操作环境。

Interconnect Data：

在「什么是 STA」段落的例子中，为了方便说明，我们并没有把逻辑闸和逻
辑闸间的连线延迟（Interconnect Delay）考虑在内。事实上，许多 DSM IC 设
计之时序表现是由连线延迟主导的，其重要性不容我们忽视。

连线延迟依照布局与绕线（P&R）前后有不同的考量。在布局与绕线前，元
件在晶片中摆放的位置尚未确定，所以连线延迟是一个预估值。而在布局与绕 线
之后，连线延迟则是根据实际绕线计算出来的。对布局与绕线之前的连线延迟，
通常是用 Wireload Model 来预估。Wireload Model 根据晶片面积的预估大小及
连线驱动元件数目（Fan-out）的多寡来决定连线的电阻和电容值，STA 软体则
利用这些电阻电容值计算出连线延 迟。在布局与绕线之后，可以利用电阻电容
萃取（RC Extraction）软体将绕线图形转换成实际的电阻电容电路，然后贴回
（Back-annotate）STA 软体计算连线延迟。

Timing Constraints：

Timing Constraint 为使用者所给定，用来检验设计电路时序的准则。其中

最重要的一项就是时脉（Clock）的描述。对于一个同步电路而言，暂存器和暂
存 器之间的路径延迟时间必须小于一个 Clock 周期（Period），也就是说，当
我们确认了 Clock 规格，所有暂存器间的路径的 Timing Constraint 就会自动给
定了。

图十五

Clock 规格包含波形、Latency 及 Uncertainty 的定义。波形定义一个 Clock 的

周期及讯号上升缘及下降缘的时间点。 Latency 定义从 Clock 来源到序向元件
Clock 输入端的延迟时间。Uncertainty 则定义 Clock 讯号到序向元件 Clock 输
入端可能 早到或晚到的时间。

如果上面的文字让你有不知所云的感觉，那底下看图说故事的解说也许会让你有
比较清晰的概念。在图十五的电路中，左边的正反器（Flip-Flop） 在第一个
Clock 上升缘时会丢出资料，此资料会在第二个 Clock 上升缘让右边的 Flip-Flop
撷取。要分析右边的 Flip-Flop 能否正确撷取 资料就必须知道第一个 Clock 上
升缘到达节点 C1 的时间点和第二个上升缘到达节点 C2 的时间点。假设在时间点
为 0 的时候，Clock 讯号由 S 点出发，经 过一段时间（source latency，1 个时
间单位，模拟晶片外的 Clock 延迟时间，例如板子上的绕线产生的讯号延迟时间）
到达电路的 Clock 输入端点 P，接下来再经过一 段时间（晶片内 Clock 绕线造
成的讯号延迟时间），Clock 讯号分别到达 C1 和 C2 节点。如果电路已经进行布
局与绕线，输入端点 P 到 C1 和 C2 的讯号 延迟时间可由连线上的寄生电阻电容
计算得来。比方说，经过计算发现讯号由 P 传递到 C1 需要 1 个时间单位，由 P
传递到 C2 需 2 个时间单位，则 Clock 讯号 第一个上升缘到达 C1 和第二个上升
缘到达 C2 的时间点就会如图十六下方两列所示，分别为时间点 2 和 13（因为加
上了 1 个时间单位的 source latency）。
 图十六

在布局与绕线之前，我们无法准确得知 P 到 C1 和 C2 的讯号延迟时间，仅能先做
个预估。图十五的 network latency 及上文提到的 Uncertainty 就是用来做此种
预估的。先假设我们拥有某种完美的布局与绕线软体可以让 Clock 输入端点 P
到所有 Flip-Flop 的 Clock 输入端的讯号延迟时间一模一样，那么我们只要知
道这个讯号延迟时间就可以得到 Clock 讯号到达 C1 和 C2 的时间点了。这 个讯
号延迟时间可以藉由电路特性（如预估面积大小，Flip-Flop 数目等）来做预估，
而这个预估值就是所谓的 network latency。如果这种完美的软体存在的话，那
Clock 的上升缘到达 C1 和 C2 的时间点就可以由 Latency（source latency +
network latency）计算出来。

很不幸的，世界上没有这么完美的软体，在布局与绕线后 Clock 输入端点 P 到所

有 Flip-Flop 的 Clock 输入端的讯号延迟时间不会完全一 样。也就是说 Clock
的某个上升缘不会同时到达 C1 和 C2。因此我们要对上述的预估值做些修正，加
入 Uncertainty 的描述来定义 Clock 上升 缘左右移动的可能范围。在图十六中，
Uncertainty 为 1 个时间单位，所以 Clock 第一个上升缘会在时间点 3（因为
Latency 为 3）左右 1 时间单位范围内（也就是时间点 2 到时间点 4）到达 C1，。
第二个上升缘则会在时间点 12 到 14 的范围内到达 C2。

除了 Clock 之外，对于电路其他输出输入端点及其周边的环境（Boundary
Condition）也要加以描述。在说明 Boundary Condition 之前，我们得对路径
（Path）有更进一步的了解。上文曾提及 STA 会将电路中所有的 Path 找出来加
以分析，但 Path 的定义是什么 呢？

Path 根据起点及终点可以分为 4 种：

1. 由 Flip-Flop Clock 输入到 Flip-Flop 资料输入（图十七左上）。

 2. 由主要输入（Primary Input，简称 PI）到 Flip-Flop 资料输入（图十七
右上）。
3. 由 Flip-Flop Clock 输入到主要输出（Primary Output，简称 PO）（图
十七左下）。
4. 由主要输入到主要输出（图十七右下）。

当 Clock 规格确定了之后，第 1 种 Path 的时序限制（Timing Constraint）就自

动的给定了。为了给定其他 3 种 Path 的时序限制，我们必须定义 Boundary
Condition。

一般来说，我们会定义下列的 Boundary Condition：

1. Driving Cell：定义输入端点的推动能力（图十八）。
2. Input Transition Time：定义输入端点的转换时间（图十八）。
3. Output Capacitance Load：定义输出负载（图十八）。
4. Input Delay：输入端点相对于某个 Clock 领域的延迟时间。（图十九，
Delayclk-Q + a）
5. Output Delay：自输出端点往外看相对于某个 Clock 领域的延迟时间。
（图
十九，c）

在这些 Boundary Condition 定义之后，上述 4 种 Path 事实上都可看成是第 1

种 Path（Flip-Flop 到 Flip-Flop）。也就是说，加上 Boundary Condition 后，
只要 Clock 给定，所有 Path 的 Timing Constraint 就会自动给定。。

图十八
 图十九

由于每个 Path 都有 Timing Constraint，所以时序分析都能够进行。但在某些

情况下，有些 Path 的分析可能没有意义，因此你会想忽略这些 Path 的分析。或
是有些 Path 分析的方式不一样，你会想指定这些 Path 的分析方式。此时就要
设定一些 Timing Exception，如 False Path 和 Multi-cycle Path 等等来处理
非一般性的时序分析。

STA 流程及分析方式

STA 的流程如图二十所示，而其分析验证的项目就是我们前文提及之时序检查相
关的 Timing Arc，如 Setup Time、Hold Time 等等。以下我们针对 Setup Time
举 1 实际范例来说明 STA 的分析方式。

图二十

Setup Time
设计电路如图二十一所示，时序模型（Timing Model）及时序限制（Timing
Constraint）如下：

图二十一

• 所有逻辑闸在输出讯号上升时最长的延迟时间为 3ns，最短为 2ns。

• 所有逻辑闸在输出讯号上升时最长的延迟时间为 2ns，最短为 1ns。
• 所有连线（Net）最长的延迟时间为 2ns，最短为 1ns。
• 所有 Flip-Flop Clock 到 Q 的延迟时间为 3ns。
• 所有 Flip-Flop 的 Setup Time 为 1ns（Ts）。
• 所有 Flip-Flop 的 Hold Time 为 1ns（Th）。
• Clock 周期为 14ns（Dclkp）。
• Clock source latency 为 2ns（Dclks）。
• Clock network latency 为 3ns（Dclkn）。
• Clock uncertainty 为 1ns（Dclku）。
• B 及 C 的 input delay 皆为 1ns（Da、Db、Dc）。
• Y 的 output delay 为 3ns（DY）。

接下来，我们以 Step-By-Step 的方式说明时序分析的方式。

1. 首先找出所有 Timing Path，我们只列出具代表性的 3 条 Timing

Path 来加以说明。
 图二十二

2. 假设输入 A 讯号由 0 变 1，计算第 1 条 Path 终点讯号到达的时间

（Arrival Time 简称 AT）。

3. 假设输入 A 讯号由 1 变 0，计算第 1 条 Path 终点 AT。

 图二十四

4. 计算第 1 条 Path 终点的需求时间（Required Time，简称 RT）。

图二十五

5. 假设输入 A 讯号由 0 变 1，计算第 1 条 Path 终点的 Slack。Slack

等于 RT 和 AT 的差值，对于 Setup Time 验证来说等于 RT - AT，对于 Hold Time
验证来说等于 AT - RT。在此 Setup Time 范例中，Slack 为正，表示讯号实际到
达 Path 终点时间比必须到达的时间还早，因此 Timing 是满足的。
 图二十六

6. 假设输入 A 讯号由 1 变 0，计算第 1 条 Path 终点的 Slack。Slack

为正，因此 Timing 是满足的。

综合 5 和 6，第 1 条 Path 的 Timing 是符合规格的，其 Slack 为 4ns（取较差状

况）。

图二十七

7. 假设前级 Flip-Flop 的讯号由 0 变 1，计算第 2 条 Path 终点的 AT。

 图二十八

8. 假设前级 Flip-Flop 的讯号由 1 变 0，计算第 2 条 Path 终点的 AT。

图二十九

9. 计算第 2 条 Path 终点的 RT

 图三十

10. 假设前级 Flip-Flop 的讯号由 0 变 1，计算第 2 条 Path 终点的 Slack。

Slack 为负，因此 Timing 不满足。

图三十一

11. 假设前级 Flip-Flop 的讯号由 1 变 0，计算第 2 条 Path 终点的 Slack。

Slack 为负，因此 Timing 不满足。

综合 10 和 11，第 2 条 Path 的 Timing 不满足，其 Slack 为-3。

 图三十二

12. 假设前级 Flip-Flop 的讯号由 0 变 1，计算第 3 条 Path 终点的 AT。

图三十三

13. 假设前级 Flip-Flop 的讯号由 1 变 0，计算第 3 条 Path 终点的 AT。

图三十四

14. 计算第 3 条 Path 终点的 RT。

 图三十五

15. 假设前级 Flip-Flop 的讯号由 0 变 1，计算第 3 条 Path 终点的 Slack。

Slack 为负，因此 Timing 不满足。

图三十六

16. 假设前级 Flip-Flop 的讯号由 1 变 0，计算第 3 条 Path 终点的 Slack。

Slack 为负，因此 Timing 不满足。

综合 15 和 16，第 3 条 Path Timing 不符合规格，其 Slack 为-4。

 图三十七

综合上述分析结果，此电路的时序不符合规格，其 Critical Path 是 Path3，Slack

为-4。

寄生参数提取和静态时序分析
引言

对于应用 0.18mm 及以下工艺的设计而言，二维提取进行 Sign-off 静态时序分析

就显得有些粗略，而且精度不够。这是因为对于 0.18mm 及以下工艺，毗邻金属
连线所产生的耦合电容在设计中已经成为不得不考虑的寄生参数，于是先进的寄
生参数提取工具就可以检测到相同层次之间产生耦合电容的影响。因此对
0.18mm 及以下工艺的设计，通过物理验证，在进行流片之前，需要用专门的寄
生参数抽取工具将每一个节点的 RC 网络信息写成文件传递给设计，即所谓的反
标，再用静态时序分析工具做精确的版图时序分析。

Star-RCXT 工具介绍

Star-RCXT 以其高精度、友好的用户界面以及和其它工具良好的结合成为目前业
界比较流行的一款寄生参数提取工具，是专门针对 0.18mm 及以下工艺的寄生参
数提取所设计的。它采用了二点五维的几何提取技术，达到了三维的提取精度，
但比三维的抽取工具速度快很多，能够快速准确地对上百万门的设计进行全局的
寄生参数提取。

用 Star-RCXT 进行寄生参数提取的条件

应用 Star-RCXT 进行精细寄生参数提取，还需要两个与工艺参数有关的文件：
mapping 文件和 ITF(Interconnect Technology Format)文件。ITF 文件是由晶
圆代工厂直接提供的，它包含的信息主要有：工艺采用的各个层次(包括电介质、
过孔和金属导线等)，各个层次在工艺流程中的厚度、宽度等物理尺寸，各个层
次的电气参数(如介电常数、方块阻值等)。Star-RCXT 不能直接使用 ITF 格式的
文件，它提供 grdgenxo 命令将晶圆代工厂提供的 ITF 格式文件转换成 Star-RCXT
所需要的.nxtgrd 格式文件，Mapping 文件用于实现这种转换过程，将目
标.nxtgrd 文件中各个层次名称与设计数据库中的层名称相对应起来。

Star-RCXT 支持的格式

寄生参数提取工具 Star-RCXT 支持多种格式输入，主要有 Milkyway、Lef/Def、

Hercules 和 Calibre 格式。也支持多种格式输出，如输出格式为 IEEE 1481 标
准的 SPEF(Standard Parastic Exchange Format)格式;输出与 PrimeTime 静态
时序分析工具最有效对接的 SBPF(Synopsys Binary Parasitic Format)格式;输
出格式包含了每一个节点 RC 网络信息的 DSPF (Detailed Standard Parasitic
Format)格式;还有 STAR、NETNAME、MW、CONLY 等格式。因为寄生电容值与其毗
邻的金属连线有密切关系，版图上一个图形有可能会影响到其相邻模块中某一条
连线的寄生参数提取，因此寄生参数提取是针对 flat 版图，提取出来的寄生参
数信息是不带有层次的。也正是由于这个原因，寄生参数提取一般需要花费较长
的时间，并占用较大的硬件资源。

Primetime 工具介绍

PrimeTime 是 Synopsys 公司提供的一个针对复杂全芯片进行静态时序分析的工

具。PrimeTime 可以集成于逻辑综合和物理综合的流程，让设计者分析并解决复
杂的时序问题，提高时序收敛的速度。它是一种穷尽分析方法，不依赖于激励，
分析检查电路或设计对象中的所有时序路径，包括无效路径，能够保证 100%的
覆盖率。它运行速度快，占用内存少，完全克服了动态时序验证的缺陷，适用于
超大规模芯片系统的电路验证。

PrimeTime 分析原理

PrimeTime 进行静态时序分析时把整个芯片按照时钟分成许多时序路径。路径的
起点是时序单元的输出引脚或是设计的输入端口，路径的终点是时序单元的输入
引脚或是设计的输出端口。根据起点和终点的不同，可将逻辑电路分解为图 1
中用虚线表示的四种路径，分别代表了以下四种类型: 路径 1 起始于输入端口，
终止于时序单元的数据输入端;路径 2 起始于时序单元的时钟引脚，终止于时序
单元的数据输入端;路径 3 起始于时序单元的时钟引脚，终止于输出端口;路径 4
起始于输入端口，终止于输出端口。
图 1 逻辑电路中的四种时序路径

PrimeTime 工具把设计打散成一系列时序路径之后，沿每条路径计算延时。路径
的总延时是该路径中所有单元延时和连线延时的和。单元延时为路径中从逻辑门
的输入到输出的延时量，若没有提供反标延时信息，PrimeTime 会根据工艺库中
提供的此单元延迟表来计算单元延时。典型的单元延迟表是输入传输时间和输出
负载电容的函数，基于二维表格来计算每个单元的延时。对于在表格中找不到对
应点的情况，可通过内插或外推表格中的值来获得当前条件下的延时值。连线延
时是时序路径中从一个单元的输出到下一个单元输入的延时总和。PrimeTime 可
读取由专门提取工具得到的详细内部互联网络的寄生电容和电阻值，并基于此精
确地计算连线延时，以完成精确的版图时序分析。

PrimeTime 分析要求

静态时序分析的目的是保证设计中的以上四种类型路径可以满足建立时间和保
持时间的要求。即无论其起点是什么，信号都可以被及时地传递到该路径的终点，
并且在电路正常工作所必需的时间段内保持恒定。如果建立时间和保持时间不能
得到满足，触发器就无法采样到正确的数据。

对 FFT 处理器进行寄生参数提取和静态时序分析

当 FFT 处理器完成版图设计，通过 Calibre DRC 和 LVS 进行 Sign-off 的静态时

序分析时，可用专门的寄生参数提取工具 Star-RCXT 将每一个节点的 RC 网络信
息写成文件传递给设计，再用静态时序分析工具 PrimeTime 读取由 Star-RCXT
工具得到的详细内部互联网络的寄生电容和电阻值，并基于此精确地计算连线延
迟，做精确的版图时序分析。

对 FFT 处理器进行寄生参数提取

由于 FFT 项目采用 Mentor 公司的 Calibre 工具进行 DRC 和 LVS，因此寄生参数

提取工具 Star-RCXT 采用的输入格式为 Calibre，基于 CCI(Calibre Connectiity
Interface)的 Star-RCXT 寄生参数提取流程如图 2 所示。
图 2 基于 CCI 的寄生参数提取流程

在 Calibre 中采用 flat 方式对 FFT 处理器进行 LVS，通过 LVS 后自动产生 SVDB
目录，并将配置 LVS 运行时设置的内容保存为 lvsset 文件。然后编写 query.cmd
文件，该文件指定基于 CCI 的 Star-RCXT 寄生参数提取所需文件的位置，如标注
的 GDSII 版图、层映射信息、顶层端口信息、理想版图网表、网络名信息、交互
表等。编写好 query.cmd 文件后，在 calibredrv 工具的命令行中执行命令：
Calibre-query svdb < query.cmd，会生成 Star-RCXT 寄生参数提取所需的文件，
如包含多边形和连通性信息的文件 xtalkdetailDRCLVS.agf、元件交互参考信息
的文件 xtalkdetailDRC LVS.ixf、网络交互参考信息的文件
xtalkdetailDRCLVS.nxf、理想版图网表文件 xtalkdetailDRCLVS.nl 和器件表文
件 xtalkdetailDRCLVS. devtab 等。

本设计用运行 Star-RCXT 命令文件(star.cmd)来进行寄生参数提取，在编写

star.cmd 命令文件时要输入：模块名称 xtalkdetailDRCLVS、层映射文件
SmicVTMP_LO_SRAM _MR_MM_HV_LC_018.map、电源/地网络名称 VDD 和 GND、加工
工艺文件 smic018.nxtgrd、提取参数的输出格式 SPEF、提取网络的范围、是否
要将耦合电容折算成对地电容、配置 LVS 运行的设置文件 lvsset 和指定进行基
于 CCI 寄生参数提取所需文件位置的文件 query.cmd 等。然后在 Star-RCXT 中运
行 StartXtract -clean star.cmd 命令即可完成寄生参数提取，输出文件名为
xtalkdetailDRCLVS.spef。

对 FFT 处理器进行静态时序分析

首先在 PrimeTime 的启动文件(.synopsys_pt.setup)中设置与库文件相关的信

息，如用 set_link_library { * smic18_ss.db smic18IO_line_ss.db}命令来
设置链接库，用 set target_library {* smic18_ss.db smic18_IO_line_ss.db}
命令来设置目标库、用 set_min_library 命令来指定工艺库用于最大延迟和最小
延迟分析等。然后用 primetime 命令启动 PrimeTime 的图形用户界面，对 FFT
处理器进行 Sign-off 的静态时序分析。具体流程包括：读入设计数据、约束时
序、设定环境和分析条件、检查设计数据和分析设置参数，以及执行分析和检查
结果 5 步。

读入设计数据

读入网表文件用 read_verilog 命令，读入由 Star-RCXT 提取输出的 SPEF 格式寄

生网表用 read_parasitics 命令。若要分析建立时间则要读入最坏情况的寄生电
容和电阻信息，若要分析保持时间则要读入最好情况的寄生电容和电阻信息。

约束时序

进行 Sign-off 静态时序分析时，由于现在的网表中已经包括了实际的时钟信息，
用 create_clock 命令来定义一个时钟的基本信息，如周期、波形等，将该时钟
信号在实际的时钟树中传播，进而得到实际的时钟延时和偏移。用
set_propagated_ clock 命令可以根据时钟树，自动计算出时钟信号到达终点的
延时和偏移。Sign-off 静态时序分析可不设置时钟的确定性，但有时为了提高
设计可靠性，用 set_clock_uncertainty 命令对建立时间和保持时间都设置一个
很小时间值。根据设计规范要求用 set_input_delay 命令直接设置输入延时值，
用 set_output_delay 命令直接设置输出延时值等。

设定环境和分析条件

PrimeTime 中 set_operating_conditions 命令用来根据工艺库指定工艺、温度

和电压的工作条件。分析建立时间时工作条件应当在最坏情况进行，即
set_operating_conditions worst;分析保持时间时工作条件应当在最好情况进
行，即 set_operating_conditions best。用 set_load 命令设置输出端口的负
载，用 set_driving_cell 命令指定输入端口的驱动单元等。另外可用
set_case_analysis 命令在某个端口设置为固定逻辑常数或逻辑转换限制该信
号在设计中传播，如果在时序分析时不考虑扫描链的影响，可执行
set_case_analysis 0 [get_ports scan_en_pad]命令。

检查设计数据和分析设置参数

在进行时序分析前要先检查设计数据，如层次、库、端口、单元等，以及分析设
置参数，如时钟、输入延迟约束、输出延迟约束等是否已经设置或设置是否正确。
如，用 check_timing 命令来检查是否存在未定义的时钟、未定义的输入到达时
间和未定义的输出约束等;用 report_design 命令输出当前设计的一系列属性，
如分析类型、所选的工作条件、线负载模型和设计规则等;用 report_port 命令
显示端口名、引脚电容、线电容和输入输出延迟等端口信息。

执行分析和检查结果
在设计数据和参数设置均正确的情况下进行时序分析，然后查看分析结果，获得
设计具体的时间信息。如用 report_timing 命令产生一条最大时延路径的详细报
告，包括路径信息(工作条件、线负载模型的模式、路径起点、路径终止点和路
径类型等)、路径延时、路径延时要求和总结部分。用
report_constraint-all_violator 命令报告所有的建立时间时序违规。为了准
确了解 FFT 处理器所有路径的建立时间情况，可执行菜单命令
Timing→Histogram→Endpoint Slack…弹出 Endpoint Slack 对话框，在 Delay
type 中选择 max 后按 OK 可得如图 3 所示的所有路径建立时间情况，从中可知建
立时间最小值为 0.13792，满足建立时间要求。再运行命令
report_analysis_coverage 得 PrimeTime 分析的路径条数为 45957，分析的覆盖
率为 100%，建立时间的违规率为 0%。

图 3 建立时间的分析结果

为了准确了解 FFT 处理器所有路径的保持时间情况，可进行与分析建立时间过程

相同的步骤。

结语
静态时序分析已经成为数字集成电路设计必不可少的环节。本文应用寄生提取工
具 Star-RCXT 基于 CCI 流程对 FFT 处理器进行寄生参数提取，再用静态时序分析
工具 PrimeTime 读取由 Star-RCXT 抽取工具得到的内部互连网络的详细寄生电容
和电阻值，进行精确的版图时序分析。它不需要输入测试向量就能覆盖所有的路
径，且运行速度很快，占用内存较少，可以对芯片设计进行全面的时序验证。

IC 设计中的时钟类型约束
一个比较全的例子，不过还有比较多的特殊情况。

create_clock -period 100 [get_ports Pclk]

create_clock -period 100/8 -name pclkx8 [get_pins BUF2X2/Y]

create_clock -period 10 [get_ports Sclk]

create_generated_clock -name clk_div2 -divide_by 2 -source [get_attribute [get_ports Sclk]
sources] [get_pins DIV/clk_div2]
create_generated_clock -name clk_div4 -divide_by 4 -source [get_attribute [get_ports Sclk]
sources] [get_pins DIV/clk_div4]
create_generated_clock -name clk_div8 -divide_by 8 -source [get_attribute [get_ports Sclk]
sources] [get_pins DIV/clk_div8]
create_generated_clock -name Sclk1_l -comb -add -source [get_attribute [get_clocks pclkx8]
sources] -master_clock pclkx8 [get_pins MUX1/Sclk1]
create_generated_clock -name Sclk1_h -comb -add -source [get_attribute [get_clocks clk_div2]
sources] -master_clock clk_div2 [get_pins MUX1/Sclk1]
set_clock_group -logical -group clk_div2 -group pclkx8

create_generated_clock -name Sclk2_l -comb -add -source [get_attribute [get_clocks clk_div8]

sources] -master_clock clk_div8 [get_pins MUX1/Sclk2]
create_generated_clock -name Sclk2_h -comb -add -source [get_attribute [get_ports Sclk]
sources] -master_clock Sclk [get_pins MUX1/Sclk2]
set_clock_group -logic al -group sclk -group clk_div8

对于 Sclk1，Sclk2 驱动的时钟树的输出 port，应该如下设置

set_output_delay -max 3 -clock [get_clocks Sclk1_l] [get_ports xx_out1]
set_output_delay -max 3 -add_delay -clock [get_clocks Sclk1_h] [get_ports xx_out1]

set_output_delay -max 3 -clock [get_clocks Sclk2_l] [get_ports xx_out2]

set_output_delay -max 3 -add_delay -clock [get_clocks Sclk2_h] [get_ports xx_out2]

对于 Pclkx8 需要的约束如下：

set_input_delay -max 2 -clock [get_clocks Pclk] [get_pins BUF2X2/Y]

红色圈圈出的设计要注意的，因为低速 Pclkx8 作为数据输入，对于 Pclkx8 又做时钟，又做

数据，所以在时钟树前加 buffer，然后用 buffer 的输出 pin 做 create_clock。
同时对时钟作为数据输入的设置 false_path
记住：时钟会向后穿过任何组合逻辑，直到 endpoint！
pll 是 macro，会被 astro，或者 dc 作为 black box。对于工具来说信号传输到黑盒子就算终止
了，但是内部还要用到黑盒子产生的时钟，所以要 create_clock .对于 pll 输出的 clock 的
input_delay,output_delay 约束却要用到外部的 Pclk 来约束。

以上是用 dc 的新命令来处理。不过用常规来处理也比较不错，不过要在综合以后分析其他
没有 case 的路径。
如下：
create_clock -name SCLK -p 20 [get_ports Sclk]
create_clock -name PCLK -p 8 [get_ports Pclk]
create_generated_clock -name PCLKX8 -multipy_by 8 -source [get_attribute [get_clock]
sources] [get_pins BUF2X2/Z]
create_generated_clock -name SCLK_DIV2 -devide_by 2 -source [get_attribute [get_clock]
sources] [get_pins DIV/clk_div2]
create_generated_clock -name SCLK_DIV8 -devide_by 8 -source [get_attribute [get_clock]
sources] [get_pins DIV/clk_div8]
set_case_analysis 0 [get_pins MUX2/S0]
set_case_analysis 1 [get_pins MUX1/S0]
set_ideal_network [get_pins MUX2/Y]
set_dont_touch_network [get_pins MUX2/Y]
set_ideal_network [get_pins MUX1/Y]
set_dont_touch_network [get_pins MUX1/Y]
上面的约束也不是最好的，如果想进一步精简约束和准确的话，需要仔细分析下时钟域。
如上图所示，pclkx8 和 sclk 以及分频时钟不是同时钟域的。
对于选择时钟，如果输入是同一个时钟域的话，可以在输出端 generated 出一个最高频率。
如果是异步时钟则不需要 set_case_analysis ，2 个时钟需要同时分析。
如果选择器不是用 MUX 来实现，而是用 AO 或者 AOI 实现，可能需要在 AO，AOI 的输出
端分别 generated 这 2 个时钟。
约束可以写成如下：
create_clock -name SCLK -p 20 [get_ports Sclk]
create_clock -name PCLK -p 8 [get_ports Pclk]
create_generated_clock -name PCLKX8 -multipy_by 8 -source [get_attribute [get_clock]
sources] [get_pins BUF2X2/Z]
create_generated_clock -name SCLK_DIV2 -devide_by 2 -source [get_attribute [get_clock]
sources] [get_pins DIV/clk_div2]
create_generated_clock -name MX2_CLK -devide_by 1 -source [get_attribute [get_clock]
sources] [get_pins MX2/Y]
set_ideal_network [get_clocks MX2_CLK]
set_dont_touch_network [get_attribute [get_clocks MX2_CLK] sources]
当然异步时钟之间要设置 false path
set_false_path -from [get_clocks PCLKX8] -to [get_clocks SCLK_DIV2]
set_false_path -from [get_clocks SCLK_DIV2] -to [get_clocks PCLKX8]
这种约束经济实惠，而且准确，所以推荐。当然例外情况也有可能比如加入 dft 测试时钟，
bist 时钟等等，以及 mux 是用 AO，AOI 搭建的。

IC 设计流程及工具
前端设计（也称逻辑设计）和后端设计（也称物理设计）并没有统一严格的界限，涉及到与工艺有关的设计就是后端设计。

1. 规格制定

芯片规格，也就像功能列表一样，是客户向芯片设计公司（称为 Fabless，无晶圆设计公司）提出的设计要求，包括芯片需要达到的具体功能和性能方面的要求。

2. 详细设计

Fabless 根据客户提出的规格要求，拿出设计解决方案和具体实现架构，划分模块功能。

3. HDL 编码

使用硬件描述语言（VHDL，Verilog

HDL，业界公司一般都是使用后者）将模块功能以代码来描述实现，也就是将实际的硬件电路功能通过 HDL 语言描述出来，形成 RTL（寄存器传输级）代码。

4. 仿真验证

仿真验证就是检验编码设计的正确性，检验的标准就是第一步制定的规格。看设计是否精确地满足了规格中的所有要求。规格是设计正确与否的黄金标准，一切违反，不

符合规格要求的，就需要重新修改设计和编码。

设计和仿真验证是反复迭代的过程，直到验证结果显示完全符合规格标准。
 仿真验证工具 Synopsys 的 VCS，还有 Cadence 的 NC-Verilog。

5. 逻辑综合――Design Compiler

仿真验证通过，进行逻辑综合。逻辑综合的结果就是把设计实现的 HDL 代码翻译成门级网表 netlist。综合需要设定约束条件，就是你希望综合出来的电路在面积，时序等

目标参数上达到的标准。逻辑综合需要基于特定的综合库，不同的库中，门电路基本标准单元（standard

cell）的面积，时序参数是不一样的。所以，选用的综合库不一样，综合出来的电路在时序，面积上是有差异的。

一般来说，综合完成后需要再次做仿真验证（这个也称为后仿真，之前的称为前仿真）

逻辑综合工具 Synopsys 的 Design Compiler。

6. STA

Static Timing

Analysis（STA）
，静态时序分析，这也属于验证范畴，它主要是在时序上对电路进行验证，检查电路是否存在建立时间（setup

time）和保持时间（hold

time）的违例（violation）。这个是数字电路基础知识，一个寄存器出现这两个时序违例时，是没有办法正确采样数据和输出数据的，所以以寄存器为基础的数字芯片功能

肯定会出现问题。

STA 工具有 Synopsys 的 Prime Time。

7. 形式验证

这也是验证范畴，它是从功能上（STA 是时序上）对综合后的网表进行验证。常用的就是等价性检查方法，以功能验证后的 HDL 设计为参考，对比综合后的网表功能，

他们是否在功能上存在等价性。这样做是为了保证在逻辑综合过程中没有改变原先 HDL 描述的电路功能。

形式验证工具有 Synopsys 的 Formality。

前端设计的流程暂时写到这里。从设计程度上来讲，前端设计的结果就是得到了芯片的门级网表电路。

Backend design flow ：

1. DFT

Design For

Test，可测性设计。芯片内部往往都自带测试电路，DFT 的目的就是在设计的时候就考虑将来的测试。DFT 的常见方法就是，在设计中插入扫描链，将非扫描单元（如寄

存器）变为扫描单元。关于 DFT，有些书上有详细介绍，对照图片就好理解一点。

DFT 工具 Synopsys 的 DFT Compiler

2. 布局规划(FloorPlan)

布局规划就是放置芯片的宏单元模块，在总体上确定各种功能电路的摆放位置，如 IP 模块，RAM，I/O 引脚等等。布局规划能直接影响芯片最终的面积。

工具为 Synopsys 的 Astro

3. CTS

Clock Tree

Synthesis，时钟树综合，简单点说就是时钟的布线。由于时钟信号在数字芯片的全局指挥作用，它的分布应该是对称式的连到各个寄存器单元，从而使时钟从同一个时钟

源到达各个寄存器时，时钟延迟差异最小。这也是为什么时钟信号需要单独布线的原因。

CTS 工具，Synopsys 的 Physical Compiler

4. 布线(Place & Route)

这里的布线就是普通信号布线了，包括各种标准单元（基本逻辑门电路）之间的走线。比如我们平常听到的 0.13um 工艺，或者说 90nm 工艺，实际上就是这里金属布线

可以达到的最小宽度，从微观上看就是 MOS 管的沟道长度。

工具 Synopsys 的 Astro

5. 寄生参数提取

由于导线本身存在的电阻，相邻导线之间的互感,耦合电容在芯片内部会产生信号噪声，串扰和反射。这些效应会产生信号完整性问题，导致信号电压波动和变化，如果严

重就会导致信号失真错误。提取寄生参数进行再次的分析验证，分析信号完整性问题是非常重要的。
 工具 Synopsys 的 Star-RCXT

6. 版图物理验证

对完成布线的物理版图进行功能和时序上的验证，验证项目很多，如 LVS（Layout Vs

Schematic）验证，简单说，就是版图与逻辑综合后的门级电路图的对比验证；

DRC（Design Rule Checking）：设计规则检查，检查连线间距，连线宽度等是否满足工艺要求， ERC（Electrical

Rule Checking）：电气规则检查，检查短路和开路等电气 规则违例；等等。

工具为 Synopsys 的 Hercules

实际的后端流程还包括电路功耗分析，以及随着制造工艺不断进步产生的 DFM（可制造性设计）问题，在此不说了。

物理版图验证完成也就是整个芯片设计阶段完成，下面的就是芯片制造了。物理版图以 GDS

II 的文件格式交给芯片代工厂（称为 Foundry）在晶圆硅片上做出实际的电路，再进行封装和测试，就得到了我们实际看见的芯片。