RTL Design

Design digital circuits with Verilog, SystemVerilog: synthesis-ready code, FSM, pipelining, and CDC.

Roadmap

SEARCHABLE ROADMAP INDEX

Topics in this roadmap

Open any concept as a complete, shareable learning page with its own URL and related-topic navigation.

Assertions Assertions are statements embedded in (or alongside) RTL that specify expected design behavior, automatically checked during simulation and formal verification. SystemVerilog Assertions (SVA), written using assert property , assume property , and cover property constructs, let designers and verification engineers express temporal relationships — "if signal A is asserted, signal B must be asserted within N cycles" — using a concise, declarative syntax built on sequences and properties.
Boolean Logic Boolean logic is the mathematical foundation of all digital circuits: every signal is modeled as a 0 or 1, and gates implement Boolean operators such as AND, OR, NOT, NAND, NOR, and XOR. In RTL design, before writing a single line of Verilog or VHDL, you must be comfortable manipulating Boolean expressions — applying De Morgan's theorems, simplifying with Karnaugh maps or the Quine-McCluskey method, and recognizing when an expression can be reduced to fewer literals or a shallower logic depth. These manipulations directly impact synthesis quality and timing closure.
CDC Clock domain crossing (CDC) refers to any signal that originates in a flip-flop clocked by one clock and is captured by a flip-flop clocked by a different, asynchronous (or asynchronously related) clock. Modern SoCs routinely have dozens of clock domains — CPU, peripherals, I/O interfaces, PLLs with different ratios — and any signal crossing between them is at risk of metastability: if the signal transitions too close to the capturing clock edge, the receiving flip-flop's output can settle to an invalid intermediate voltage level or take longer than expected to resolve, potentially propagating an unpredictable value.
Combinational Logic Combinational logic describes circuits whose outputs depend only on current input values, with no memory of past states. In RTL, combinational behavior is described using assign statements or always @(*) (Verilog) / always_comb (SystemVerilog) blocks. Examples include multiplexers, decoders, adders, comparators, and ALUs—building blocks that appear repeatedly in datapath design. Each combinational path's propagation delay directly limits clock frequency; the longest path is the critical path.
Formal Formal verification uses mathematical proof techniques — rather than simulation with test vectors — to verify properties of a design exhaustively across all possible input sequences and states. Where simulation can only show that a design behaves correctly for the specific stimulus exercised, formal tools (e.g., Synopsys VC Formal, Cadence JasperGold) can prove that a property holds for every possible input, or find a concrete counterexample (a "waveform") demonstrating a violation.
FSM Finite state machines are the primary mechanism for describing control logic in RTL designs — bus protocol controllers, arbiters, sequencers, and handshake logic are all naturally expressed as FSMs. An FSM consists of a finite set of states, a state register, a next-state function (combinational), and an output function that can be either Moore-style (outputs depend only on current state) or Mealy-style (outputs also depend on current inputs).
Lint RTL linting is a static analysis step — run before simulation or synthesis — that checks source code against a set of structural and stylistic rules without requiring any test vectors. Tools like Synopsys SpyGlass Lint, Cadence HAL, or Verilator's lint mode parse the RTL and flag constructs that are likely to cause functional bugs, simulation/synthesis mismatches, or downstream tool problems.
Low Power Low-power RTL design addresses dynamic and static (leakage) power consumption through architectural and coding techniques that the RTL designer controls, complementing physical-design and library-level power optimizations applied later in the flow. Dynamic power is dominated by switching activity ( P = C * V^2 * f * alpha , where alpha is the switching factor), so reducing unnecessary toggling of registers and combinational logic directly reduces power.
Pipelining Pipelining inserts registers into long combinational datapaths to break them into shorter stages, allowing different data to operate on different stages simultaneously—like an assembly line. The goal is to increase throughput and clock frequency by reducing critical path delay per stage, at the cost of increased latency (time for data to traverse all stages) and additional register area. This is a fundamental trade-off in high-performance RTL design.
Reset Reset strategy determines how a design's flip-flops and state initialize to a known value, and it is one of the most consequential — and most often underestimated — architectural decisions in RTL design. The two fundamental choices are synchronous reset (the reset signal is sampled like any other input, only taking effect on a clock edge, e.g., if (rst) q <= 0; else ... inside always_ff @(posedge clk) ) and asynchronous reset (the reset directly forces the flip-flop to its reset value regardless of the clock, e.g., always_ff @(posedge clk or posedge rst) ).
Sequential Logic Sequential logic introduces memory: outputs depend on both current inputs and stored state, updated relative to a clock signal. The fundamental storage elements are flip-flops (edge-triggered, typically D flip-flops in RTL) and latches (level-sensitive). In synthesizable RTL, sequential behavior is described with always @(posedge clk) (Verilog) or always_ff @(posedge clk) (SystemVerilog) blocks, where signals assigned inside become registers synchronized to the clock edge.
Synthesis Beyond the area/timing/power optimization view of synthesis, there is a verification- and lint-centric perspective: how RTL coding choices that affect synthesizability also affect whether a design can be efficiently and meaningfully verified. Writing "synthesizable" RTL is necessary but not sufficient — the same code should also produce a design whose gate-level netlist behaves equivalently to RTL simulation, whose structure supports formal tools, and whose corner cases are visible to coverage and assertion-based checking.
Synthesis Logic synthesis translates RTL (Verilog/SystemVerilog/VHDL) into a gate-level netlist mapped to a target technology library, optimized for area, timing, and power under designer-specified constraints. Tools like Synopsys Design Compiler, Fusion Compiler, or Cadence Genus elaborate RTL into a generic, technology-independent representation, apply Boolean optimizations, and map the result onto standard cells from the target library. Synthesis bridges design intent and physical implementation.
SystemVerilog SystemVerilog (IEEE 1800) extends Verilog with design and verification features, but for RTL, the most impactful are stricter typing and intent-expressing constructs. The logic type replaces reg / wire ambiguity for most signals—it can be driven by either assignments or procedural blocks (but not multiple drivers), eliminating a common class of declaration errors. logic is the modern, preferred type for RTL design.
Verilog Verilog is the most widely used hardware description language for RTL design and remains the syntactic foundation that SystemVerilog extends. As an RTL designer, Verilog provides core constructs for describing hardware structurally and behaviorally: modules with ports, wire and reg data types, continuous assignments ( assign ), and procedural blocks ( always , initial ) that model combinational and sequential logic. Mastering Verilog is essential for reading legacy designs and understanding synthesis foundations.
VHDL VHDL (VHSIC Hardware Description Language, IEEE 1076) is the other major HDL for RTL design, dominant in European companies, defense/aerospace, and FPGA flows. VHDL is strongly typed (derived from Ada), enforcing strict type matching (e.g., std_logic vs. std_logic_vector vs. integer ). Type mismatches that Verilog silently coerces are compile errors in VHDL, catching bugs earlier at the cost of more verbose code. For engineers in VHDL-centric environments, this strictness is a feature, not a burden.

STAMaster timing closure for digital IC design: from setup/hold fundamentals to advanced OCV, crosstalk, and signoff.DVVerify chip functionality: UVM testbenches, coverage-driven verification, formal methods, and debugging.