Synthesis translates your RTL into a gate-level netlist using a cell library (AND/OR/flop cells for a technology node). It is not “compiling software” — it explores hardware implementations under constraints.
Synthesis is a constrained hardware translation — not a software compile.
In learning mode you may use open tools (e.g. Yosys concepts). In industry: Design Compiler, Genus, etc. The ideas match.
# Tell synthesis the clock exists and its period create_clock -name clk_sys -period 10.0 [get_ports clk] # Input delay: data arrives 2ns after clock edge (example) set_input_delay 2.0 -clock clk_sys [get_ports csr_wdata*] set_output_delay 2.0 -clock clk_sys [get_ports csr_rdata*] # False paths / multicycle exceptions added later with care
Without create_clock, the tool does not know how fast to optimize — timing reports are meaningless.
Synthesis maps RTL to standard cells from a foundry library (e.g. 7nm, 28nm). Each cell has area, delay, and power characteristics. You do not pick individual AND gates in RTL — the tool chooses from the library under constraints.
Meet setup (and later hold via other steps) for target clocks.
Prefer smaller implementations when timing allows.
Clock gating and cell choices (depth grows later).
| Lever | RTL / constraint action |
|---|---|
| Pipeline | Break long combo paths with registers |
| Retiming | Tool moves logic across flops (advanced) |
| Resource sharing | One multiplier time-multiplexed vs many |
| Clock gating | Stop toggling idle flops |
| Constraint tightness | 10 ns period vs 8 ns — harder but faster chip |
When timing fails, ask: “Is it RTL structure, missing pipeline, wrong constraint, or placement?” — blame category before blame person.
Synthesis is a translator. If your sentences are ambiguous, the translation will be weird — and you will blame the translator incorrectly.
Same function, two coding styles. The left is clear RTL; synthesis may map both to similar gates — but messy priority clouds hurt QoR:
// Clean, obvious mux — synthesizer-friendly module mux2_clean ( input wire [7:0] a, input wire [7:0] b, input wire sel, output wire [7:0] y ); assign y = sel ? b : a; endmodule
// Still legal — but a long priority chain can hurt timing
module priority_cloud (
input wire [7:0] req,
output reg [2:0] grant_id,
output reg grant_valid
);
always @(*) begin
grant_valid = 1'b0;
grant_id = 3'd0;
if (req[0]) begin grant_valid = 1'b1; grant_id = 3'd0; end
else if (req[1]) begin grant_valid = 1'b1; grant_id = 3'd1; end
else if (req[2]) begin grant_valid = 1'b1; grant_id = 3'd2; end
else if (req[3]) begin grant_valid = 1'b1; grant_id = 3'd3; end
// ... imagine this continuing for dozens of sources
end
endmodule
always @(*) begin if (en) q = d; // else branch missing → latch end
always @(*) begin if (en) q = d; else q = 1'b0; // full case → mux, not latch end
Pipelining adds flops (area ↑) but shortens combo paths (timing ↑). A 32-bit adder in one cycle may fail at 500 MHz; two pipelined stages often pass. Synthesis alone cannot always fix a bad micro-architecture.
“What is QoR?” — Quality of Results: how well synthesis met timing, area, and power goals for the constraints given.
| Report line | What it tells you |
|---|---|
| Total cell area | Silicon cost proxy |
| Worst negative slack (WNS) | How far from timing goal |
| Inferred latches | RTL bug — fix before PD |
| Unmapped logic | Constructs synthesis cannot handle |