From an idea to a mask set
A flagship processor of 2026 has tens of billions of transistors. Nobody draws them. A team of hundreds of engineers describes the chip as code, proves to itself as well as it can that the code is right, and then hands it to software that turns it into a geometric description of every transistor and wire: dozens of layers of polygons, hundreds of gigabytes of data, sent to the foundry as the tape-out. A mask set at the leading edge costs a great deal and a fabrication run takes months, so a mistake found after tape-out costs a new set of masks and a quarter of a year, and a mistake found after shipping can cost far more: Intel's 1994 Pentium floating-point division bug led to a USD 475 million charge.
You have already done every step of this in miniature. In Verilog and FPGAs you described hardware in a hardware description language, in Timing and clocking you worked out how fast a circuit can be clocked, and in Designing a processor you built one. This lesson is about doing it for real: the industrial flow, the tools and the people, and what has changed since chips became too big for one die and too complex for one team.
The flow, from specification to tape-out
Definition— RTL, netlist, standard cell, PDK, GDSII
Register-transfer level (RTL) code describes a synchronous circuit as registers and the combinational logic between them, in a hardware description language: SystemVerilog or VHDL, or a generator language such as Chisel that emits Verilog. A netlist is a circuit as a graph of instances of library cells and the nets (wires) that connect them. A standard cell is a pre-designed, pre-characterised layout of a small function — an inverter, a NAND2, a flip-flop — with fixed height, so cells can be placed in rows. The foundry's process design kit (PDK) contains everything a designer needs about a process: device models for simulation, the design rules, the layer definitions and, usually with it, standard-cell and memory libraries. GDSII (and its successor OASIS) is the file format for the final layout, the polygons on every mask layer.
The stages, briefly:
- Specification and architecture. What must the chip do, at what performance, power and cost? Architects build performance models — often in C++ or Python, sometimes cycle-accurate — to choose cache sizes, pipeline depths and the number of cores before a line of RTL exists. Most of a modern system-on-chip is intellectual property (IP) bought or reused: processor cores (Arm, or RISC-V from many vendors and open projects), memory controllers, high-speed serial links.
- RTL design of the parts that make the chip different.
- Verification, which runs alongside design for the whole project (next section).
- Logic synthesis maps RTL to a gate-level netlist of standard cells, optimising for the timing constraints the designer writes (in the SDC format: clock periods, input and output delays). Design for test (DFT) inserts scan chains that link every flip-flop into long shift registers, so a tester can load and read the chip's state after manufacture.
- Physical design: floorplanning (where the big blocks and memories go, and the power grid), placement of millions of cells, clock tree synthesis (a buffered tree delivering the clock to every flip-flop at nearly the same instant), and routing of every net on the metal layers.
- Signoff: static timing analysis across every process, voltage and temperature corner; power and IR-drop analysis; electromigration; and physical verification — DRC (does the layout obey every design rule?), LVS (does the layout's extracted circuit match the netlist?), antenna and density checks.
- Tape-out, then mask making (with computational lithography that pre-distorts the patterns so they print correctly), fabrication, packaging, test and bring-up of the first silicon in the lab.
Verification: why it dominates
A design team writes RTL; a verification team, usually larger, tries to break it. Industry surveys — for instance the long-running Wilson Research Group functional verification study, published by Siemens EDA — have found for years that verification takes more than half of a project's time and that only a minority of chip projects get fully working silicon at the first tape-out. Three reasons:
- The state space is astronomical. You cannot test every input. A 64-bit multiplier alone has input pairs.
- The RTL is the specification. There is no more precise description of the chip to compare against, so verification engineers write independent reference models and assertions from the English specification, and bugs often live in the gap between the two readings.
- Bugs are cheap early and ruinous late. A bug found in simulation costs an hour; after tape-out, a new mask set and months; after shipping, a recall.
The toolbox:
- Simulation with constrained-random stimulus: random inputs, constrained to be legal, checked against a reference model, run for billions of cycles on server farms. The Universal Verification Methodology (UVM, a SystemVerilog class library standardised as IEEE 1800.2) organises this in industry; cocotb lets you write the same kind of testbench in Python.
- Coverage: since you cannot test everything, measure what you have tested — every line, every branch, every state of every state machine, and functional cover points the team defines ("a FIFO became full while a flush was in progress").
- Formal verification: equivalence checking proves that the synthesised netlist computes exactly what the RTL does; model checking proves properties (assertions) for all inputs within some number of cycles, or for all time. It is exhaustive but struggles with large designs, so it is aimed at control logic, protocols and arithmetic.
- Emulation and FPGA prototyping: the RTL is compiled onto racks of FPGAs or special processors that run it a million times faster than a simulator — fast enough to boot an operating system before the chip exists.
Here is the pattern in miniature: a saturating accumulator (it clamps at 255 instead of wrapping round) and a self-checking testbench with random stimulus, an independent reference model and a simple coverage counter. Notice that the testbench is longer than the design; in industry the ratio is larger still.
// A design under test: a saturating 8-bit accumulator with synchronous reset.
module sat_acc (
input logic clk, rst, en,
input logic [7:0] x,
output logic [7:0] acc
);
logic [8:0] sum;
assign sum = {1'b0, acc} + {1'b0, x};
always_ff @(posedge clk) begin
if (rst) acc <= 8'd0;
else if (en) acc <= sum[8] ? 8'hFF : sum[7:0]; // clamp at 255 instead of wrapping
end
endmodule
// A self-checking testbench: random stimulus, a reference model, and coverage counters.
module tb;
logic clk = 0, rst, en;
logic [7:0] x, acc;
int model, errors = 0, saturations = 0, cycles = 0;
integer seed = 42; // fixed seed: the same test every run
function automatic int unsigned rnd();
return $unsigned($random(seed));
endfunction
sat_acc dut (.clk, .rst, .en, .x, .acc);
always #5 clk = ~clk;
initial begin
rst = 1; en = 0; x = 0; model = 0;
@(posedge clk); #1 rst = 0;
repeat (2000) begin
en = (rnd() % 4) != 0; // enabled 3 cycles in 4
x = (rnd() % 32 == 0) ? 8'hFF : rnd() % 30;
rst = (rnd() % 25 == 0);
@(posedge clk); #1;
// reference model, written independently of the RTL
if (rst) model = 0;
else if (en) begin
model = model + x;
if (model > 255) begin model = 255; saturations++; end
end
if (acc !== model[7:0]) begin
errors++;
if (errors <= 3) $display("MISMATCH at cycle %0d: acc=%0d model=%0d", cycles, acc, model);
end
cycles++;
end
$display("%0d cycles checked, %0d cycles where the clamp acted, %0d errors", cycles, saturations, errors);
if (errors != 0) $fatal(1, "test failed");
$finish;
end
endmoduleThe run prints 2000 cycles checked, 705 cycles where the clamp acted, 0 errors. Replace the clamped assignment with a plain sum[7:0] — the bug a designer makes by forgetting that addition overflows — and the same testbench reports 934 mismatches and stops with $fatal. The coverage line matters as much as the error count: had the stimulus been too gentle to ever reach 255, the test would have passed against the buggy design too.
Physical design: placing a netlist
After synthesis the design is a netlist: for a large chip, tens of millions of cell instances. Placement chooses a legal location for each, in rows, without overlaps. A good placement keeps connected cells close, because wire length costs delay, power and routing space, while leaving room for the router and keeping each region's wiring demand below what the metal layers can supply.
The standard proxy for wire length is the half-perimeter wirelength (HPWL): for each net, half the perimeter of the smallest rectangle containing all its pins, summed over nets. Finding the placement with minimum total HPWL is NP-hard, so placers use heuristics. One of the oldest is simulated annealing, used in the TimberWolf placer of the 1980s: propose random moves, always accept those that shorten the wiring, and accept those that lengthen it with probability , lowering the "temperature" slowly so the search settles into a good minimum instead of the nearest one. Modern placers for millions of cells use analytic methods instead: they model wirelength with smooth functions and spread cells apart with forces (the open-source RePlAce, in OpenROAD, treats cell density like electric charge and solves Poisson's equation). But annealing shows the problem clearly, so here it places the 40 cells of an 8-bit ripple-carry adder.
import math
import random
# Place the 40 cells of an 8-bit ripple-carry adder on a 10 x 6 grid of sites,
# minimising total half-perimeter wirelength (HPWL) by simulated annealing.
N, W, H = 8, 10, 6
cells, nets = [], []
for i in range(N):
cells += [f"x{i}", f"g{i}", f"s{i}", f"t{i}", f"c{i+1}"]
# Fixed I/O pins on the boundary: inputs on the left edge, sums on the right, carries top and bottom.
pins = {"cin": (-1, -1), f"c{N}": (W, H)}
for i in range(N):
pins[f"a{i}"] = (-1, i * H / N)
pins[f"b{i}"] = (-1, i * H / N + 0.4)
pins[f"out{i}"] = (W, i * H / N)
# Each net: a driver and the cells or pins it feeds.
carry = "cin"
for i in range(N):
nets += [[f"a{i}", f"x{i}", f"g{i}"], [f"b{i}", f"x{i}", f"g{i}"],
[f"x{i}", f"s{i}", f"t{i}"], [carry, f"s{i}", f"t{i}"],
[f"g{i}", f"c{i+1}"], [f"t{i}", f"c{i+1}"], [f"s{i}", f"out{i}"]]
carry = f"c{i+1}"
nets.append([carry, f"c{N}_pin"])
pins[f"c{N}_pin"] = pins.pop(f"c{N}")
rng = random.Random(1)
sites = [(x, y) for x in range(W) for y in range(H)]
rng.shuffle(sites)
pos = {c: sites[k] for k, c in enumerate(cells)} # a random initial placement
free = sites[len(cells):] # empty sites
nets_of = {c: [k for k, n in enumerate(nets) if c in n] for c in cells}
def where(p):
return pos[p] if p in pos else pins[p]
def hpwl(k):
xs, ys = zip(*(where(p) for p in nets[k]))
return (max(xs) - min(xs)) + (max(ys) - min(ys))
def total():
return sum(hpwl(k) for k in range(len(nets)))
start = total()
cost, T = start, 8.0
moves = accepted = 0
while T > 0.01:
for _ in range(400):
c = rng.choice(cells)
if rng.random() < 0.5: # swap with another cell
d = rng.choice(cells)
if d == c:
continue
touched = set(nets_of[c]) | set(nets_of[d])
before = sum(hpwl(k) for k in touched)
pos[c], pos[d] = pos[d], pos[c]
delta = sum(hpwl(k) for k in touched) - before
if delta <= 0 or rng.random() < math.exp(-delta / T):
cost += delta; accepted += 1
else:
pos[c], pos[d] = pos[d], pos[c]
else: # move into an empty site
j = rng.randrange(len(free))
touched = nets_of[c]
before = sum(hpwl(k) for k in touched)
old = pos[c]
pos[c], free[j] = free[j], old
delta = sum(hpwl(k) for k in touched) - before
if delta <= 0 or rng.random() < math.exp(-delta / T):
cost += delta; accepted += 1
else:
pos[c], free[j] = old, pos[c]
moves += 1
T *= 0.92 # cool slowly
assert abs(cost - total()) < 1e-6
print(f"total HPWL: random start {start:.1f}, after annealing {cost:.1f} "
f"({moves} moves tried, {accepted} accepted)")
grid = [["." for _ in range(W)] for _ in range(H)]
for c, (x, y) in pos.items():
grid[y][x] = c[-1] if c[0] != "c" else str(int(c[1:]) - 1) # label each cell with its bit
print("final placement, each cell labelled by the adder bit it belongs to (inputs enter on the left):")
for row in reversed(grid):
print(" " + " ".join(row))Annealing cut the total wirelength from 417 to about 189 units. The map shows why: starting from a random scatter, the cells of each bit have gathered into a band beside that bit's input pins, and the bands are stacked in order, 0 at the bottom to 7 at the top, because the carry runs from each bit to the next. Nobody told the algorithm about bits or carries; it discovered the adder's structure from the wiring alone.
Timing closure and signoff
The router turns placed cells into wires, and then the design must be shown to work at its target clock. Static timing analysis (STA) does that without simulating any input pattern: it treats the netlist as a directed acyclic graph between flip-flops and computes, for every path, whether data launched by one clock edge arrives at the next flip-flop in time.
Definition— Arrival time, setup and hold slack
For each signal, the arrival time is the latest (for setup) or earliest (for hold) time after the launching clock edge at which it settles: the clock-to-Q delay of the source flip-flop plus the delays of the cells along the path. With clock period , the setup slack at a capturing flip-flop is (adjusted for clock skew), and the hold slack is . Negative setup slack means the circuit fails at that clock rate; negative hold slack means it fails at every clock rate. The path with the worst setup slack is the critical path.
Arrival times propagate through the graph in topological order — each gate's latest arrival is the maximum over its inputs plus its own delay — so STA runs in time linear in the netlist's size, the property that lets it check billions of paths. The program below does exactly that for ripple-carry adders between flip-flops, with an invented cell library whose delays depend on fanout (roughly the speed of an older process).
# Static timing analysis of an n-bit ripple-carry adder between two banks of flip-flops.
# Delays in picoseconds, from a made-up cell library: intrinsic delay + a cost per fanout load.
LIB = {"XOR": (32, 6), "AND": (22, 5), "OR": (26, 5)}
CLK_TO_Q, SETUP, HOLD = 40, 25, 10
def ripple_adder(n):
"""Return {gate: (type, [inputs])}; inputs a0.., b0.. and cin come from flip-flops."""
g, carry = {}, "cin"
for i in range(n):
g[f"x{i}"] = ("XOR", [f"a{i}", f"b{i}"])
g[f"g{i}"] = ("AND", [f"a{i}", f"b{i}"])
g[f"s{i}"] = ("XOR", [f"x{i}", carry])
g[f"t{i}"] = ("AND", [f"x{i}", carry])
g[f"c{i+1}"] = ("OR", [f"g{i}", f"t{i}"])
carry = f"c{i+1}"
return g, [f"s{i}" for i in range(n)] + [carry]
def sta(gates, endpoints, period):
fanout = {}
for name, (_, ins) in gates.items():
for s in ins:
fanout[s] = fanout.get(s, 0) + 1
late, early, worst_pred = {}, {}, {}
def arrival(sig): # longest and shortest arrival, memoised (a DAG)
if sig in late:
return late[sig], early[sig]
if sig not in gates: # a flip-flop output
late[sig] = early[sig] = CLK_TO_Q
return CLK_TO_Q, CLK_TO_Q
kind, ins = gates[sig]
base, per_load = LIB[kind]
d = base + per_load * max(1, fanout.get(sig, 1))
arr = [arrival(s) for s in ins]
i_max = max(range(len(ins)), key=lambda i: arr[i][0])
worst_pred[sig] = ins[i_max]
late[sig] = arr[i_max][0] + d
early[sig] = min(a[1] for a in arr) + d
return late[sig], early[sig]
report = []
for e in endpoints:
lt, et = arrival(e)
setup_slack = (period - SETUP) - lt # data must arrive before the next edge
hold_slack = et - HOLD # and must not change too soon after this one
report.append((setup_slack, hold_slack, e))
report.sort()
worst = report[0][2]
path = [worst]
while path[-1] in worst_pred:
path.append(worst_pred[path[-1]])
return report, path[::-1], late[worst]
period = 500 # ps, a 2 GHz clock
gates, ends = ripple_adder(8)
report, path, delay = sta(gates, ends, period)
print(f"8-bit ripple-carry adder, clock period {period} ps")
print("endpoint setup slack hold slack")
for s, h, e in report[:4]:
print(f" {e:6s} {s:6d} ps {h:5d} ps")
print("critical path:", " -> ".join(path))
print(f"critical path arrival {delay} ps; needs a period of at least {delay + SETUP} ps\n")
print(" bits critical delay max clock")
for n in (4, 8, 16, 32, 64):
g, e = ripple_adder(n)
_, _, d = sta(g, e, period)
print(f" {n:4d} {d:6d} ps {1e3 / (d + SETUP):6.2f} GHz")At 2 GHz the 8-bit adder fails: the carry path from bit 0 to bit 8 arrives at 583 ps, and the capture flip-flop needs it by 475 ps, a slack of −108 ps. The table shows the delay growing linearly with width, the reason real adders use carry-lookahead or prefix structures, as you saw in Combinational logic. Hold slack, by contrast, is comfortably positive: the shortest paths are only a couple of gates long.
Timing closure is the work of fixing every negative slack — upsizing cells on the critical path, inserting buffers, swapping in faster (leakier) low-threshold cells, restructuring logic, moving cells, or, if all else fails, changing the RTL to add a pipeline stage. Real signoff STA also models the wires' resistance and capacitance extracted from the layout, crosstalk between neighbouring wires, on-chip variation, and every combination of process corner (slow or fast transistors), voltage and temperature: dozens of corners and operating modes. A late fix applied directly to the netlist and layout, rather than by re-running the whole flow, is an engineering change order (ECO).
Open-source tools and open PDKs
Commercial EDA is dominated by three companies: Synopsys and Cadence (both based in the United States) and Siemens EDA (formerly Mentor Graphics, part of the German group Siemens). Synopsys completed its acquisition of the simulation company Ansys in 2025. Their tools are the ones used for nearly every leading-edge tape-out, and licences for a full flow cost millions of dollars a year for a large team. Smaller and regional vendors exist, including fast-growing ones in China, and a credible open-source flow emerged in the 2020s:
| Job | Open-source tools |
|---|---|
| Simulation | Icarus Verilog (which runs this course's Verilog), Verilator (compiles Verilog to fast C++), cocotb (Python testbenches) |
| Formal | SymbiYosys and the solvers behind it |
| Synthesis | Yosys |
| Place and route, CTS, timing | OpenROAD, with OpenSTA for timing |
| Layout, DRC, LVS | Magic (since the 1980s), KLayout, Netgen |
| Complete RTL-to-GDS flows | OpenROAD-flow-scripts, LibreLane (the successor to OpenLane) |
Tools alone are not enough: you need a PDK, and PDKs were traditionally secret. In 2020 Google and SkyWater released SKY130, a 130 nm process, as an open PDK; GlobalFoundries' GF180MCU (180 nm) followed in 2022, and the German research institute IHP released SG13G2, a 130 nm SiGe BiCMOS process. These are old processes, but entirely adequate for microcontrollers, mixed-signal circuits and teaching — and everything about them can be read, shared and published.
Open PDKs made shared shuttles possible: many designs on one wafer, sharing the mask cost. Google sponsored free shuttles run by the company Efabless from 2020; Efabless shut down in early 2025, and others — including a company founded by Efabless's founders, the wafer-sharing service wafer.space, and IHP's own shuttles — have since offered runs. Tiny Tapeout goes further: it puts hundreds of tiny designs, each a few hundred to a few thousand gates, on one chip with a shared multiplexer, so that a student or hobbyist can have a real design fabricated for the price of a textbook. It survived the loss of Efabless by moving to other fabrication partners (Tiny Tapeout).
The open flow is not at the commercial tools' quality for large, fast designs at advanced nodes, and leading-edge PDKs remain under non-disclosure agreements. But it is good enough to tape out real chips, and it is where much EDA research is now done, because results can be reproduced.
Chiplets, UCIe and 3D integration
The previous lesson showed that big dies yield badly and that no single die can exceed the lithography field, about 26 × 33 mm (half that with high-NA EUV). So large chips are increasingly built as chiplets: several dies, each a manageable size and each made on the process that suits it, joined in one package so that they behave like one chip.
Chiplets have been mainstream since AMD built its 2019 EPYC server processors from up to eight compute dies around a central I/O die made on an older, cheaper process. Since then: Apple joins two laptop-class dies into its "Ultra" chips; Intel's Ponte Vecchio accelerator combined dozens of tiles; AMD's MI300 accelerators stack compute dies on I/O dies; and NVIDIA's Blackwell GPUs join two reticle-sized dies with a high-bandwidth link so that software sees one GPU. What makes this work is the die-to-die interface: thousands of short, slow-ish, very low-energy wires instead of a few fast serial links. UCIe (Universal Chiplet Interconnect Express), an industry standard first published in 2022 by a consortium including AMD, Arm, Intel, Google, Meta, Microsoft, Qualcomm, Samsung and TSMC, specifies such interfaces so that chiplets from different companies can, in principle, be combined; later revisions added faster rates and 3D stacking (UCIe).
3D integration goes vertical. Microbumps between stacked dies sit tens of micrometres apart; hybrid bonding, which joins copper pads and the oxide around them directly, reaches a few micrometres, giving hundreds of times more connections per square millimetre. AMD's 3D V-Cache (from 2022) bonds an extra cache die onto a processor this way, and high-bandwidth memory stacks a dozen or more DRAM dies with through-silicon vias. The difficulties are heat (the top die insulates the bottom one), testing each die before assembly (known good die), and design tools that were built for one die at a time.
Costs, people, and machine learning in EDA as of 2026
Costs. Analysts' estimates of the total cost of designing a large leading-edge system-on-chip run to several hundred million US dollars, most of it engineering salaries, EDA licences and IP, with the mask set and prototype wafers on top; estimates vary widely and should be read as orders of magnitude. A design for a mature process like 28 nm or 180 nm can cost a thousand times less. That ratio is why only products with very large volumes or very high value — phone processors, server CPUs, AI accelerators — go to the leading edge, and why reuse of IP and chiplets matters so much.
Machine learning in EDA. Three kinds of use, with different levels of evidence:
- Optimising the flow. A flow has hundreds of settings, and choosing them is a black-box optimisation problem. Commercial tools such as Synopsys DSO.ai (from 2020) and Cadence Cerebrus (from 2021) use reinforcement learning and related methods to search them automatically, and both vendors report wide use in production tape-outs. This is the most established use.
- Placement by learned policies. Google's 2021 Nature paper (Mirhoseini et al.) used reinforcement learning to place the large memory blocks (macros) of TPU chips; Google has since named the method AlphaChip and says it has been used in several TPU generations (Google DeepMind). Independent researchers who re-implemented and benchmarked it found it did not beat strong conventional placers (Cheng et al., 2023; Markov, 2023), and Google's authors have disputed those evaluations. As of 2026 the disagreement is not settled; the open lesson is that EDA claims need public benchmarks and strong baselines.
- Language models. LLMs fine-tuned on design data answer engineers' questions, write scripts and draft RTL and testbenches (ChipNeMo); benchmarks such as VerilogEval measure how often generated Verilog passes tests, and scores rose quickly in 2024–26. Every EDA vendor now ships an assistant. The bottleneck they meet is the one this lesson started with: generated RTL is only as trustworthy as the verification that checks it, so the most promising uses in 2026 are in writing assertions, testbenches and debug reports rather than in replacing designers.
Common misconceptions
Misconception
"Synthesis is like compiling software." A compiler's output runs on a fixed machine; synthesis creates the machine, and its result must also meet timing, area and power targets that depend on where cells end up physically. That is why synthesis and placement now share timing models and iterate, and why a design that "compiles" can still be far from tape-out.
Misconception
"If the simulation passes, the chip works." Simulation shows only that the tests you ran passed. Coverage tells you how much you exercised; formal checks prove properties for all inputs; and silicon can still fail for physical reasons no logic simulation models — timing at a corner, IR drop, crosstalk, a manufacturing defect. Hence signoff, DFT and lab bring-up.
Misconception
"Chiplets are always cheaper." Small dies yield better, but chiplets add die-to-die interfaces (area and power on every die), advanced packaging (itself a capacity bottleneck in 2023–25), assembly yield and harder testing. For a small chip, one die is cheaper; chiplets win for very large designs and for mixing process nodes.
Exercises
1. How chips are designed
Warm-upHumanA path runs between two flip-flops clocked at 1 GHz. The launching flip-flop's clock-to-Q delay is 45 ps, the logic between them takes 830 ps, and the capturing flip-flop's setup time is 35 ps. Because of clock skew, the clock edge reaches the capturing flip-flop 20 ps later than the launching one. What is the setup slack, in picoseconds?
2. How chips are designed
Warm-upHumanA 32-bit by 32-bit multiplier has possible input pairs. If a simulation farm could check input pairs per second, how many years would exhaustive testing take? Round to the nearest year (use 365.25 days per year).
3. How chips are designed
CoreHumanWhich of these steps normally happen after logic synthesis in a digital design flow? Enter the letters.
- A. Placement
- B. Clock tree synthesis
- C. Writing the RTL
- D. Layout-versus-schematic (LVS) checking
- E. Cycle-level performance modelling of cache sizes
- F. Detailed routing
4. How chips are designed
CoreComputationalWrite hpwl(nets, pos) that returns the total half-perimeter wirelength of a placement. nets is a list of nets, each a list of pin names; pos maps each pin name to an (x, y) position. For each net, the half-perimeter is (largest x − smallest x) + (largest y − smallest y). A net with a single pin contributes 0.
5. How chips are designed
StretchComputationalImplement static timing analysis for setup. gates maps each gate's output name to (delay_ps, [input names]); any input that is not a gate is a flip-flop output, arriving at clk_to_q. Write worst_setup_slack(gates, endpoints, period, clk_to_q, setup) returning (slack, path): the worst setup slack over the endpoints (each feeds a capturing flip-flop), and the critical path as a list of signal names from the flip-flop output to that endpoint. The netlist is acyclic.
6. How chips are designed
CoreHumanWhich is the best explanation of why verification takes more engineering effort than design on most chip projects?
7. How chips are designed
CoreHumanWhich of these is not a reason that large processors and AI accelerators are built from chiplets?
Further reading and resources
- OpenROADAn open-source RTL-to-GDS flow — placement, clock tree synthesis, routing and timing — begun under a DARPA programme.
- OpenROAD-flow-scripts
- Yosys Open SYnthesis Suite · YosysHQ
- Magic VLSI layout tool
- KLayoutLayout viewer and editor with design-rule checking.
- OpenSTAAn open-source static timing analyser.
- Verilator
- cocotbVerification testbenches written in Python.
- LibreLane · FOSSi FoundationA successor to OpenLane, an automated open-source RTL-to-GDS flow.
- SkyWater SKY130 open PDK
- GlobalFoundries GF180MCU open PDK
- IHP SG13G2 open PDK
- Tiny Tapeout
- Universal Chiplet Interconnect Express (UCIe)
- A graph placement methodology for fast chip design · A. Mirhoseini, A. Goldie et al. · 2021
- How AlphaChip transformed computer chip design · Google DeepMind · 2024
- An updated assessment of reinforcement learning for macro placement · C.-K. Cheng, A. B. Kahng, S. Kundu, Y. Wang, Z. Wang · 2023
- The False Dawn: Reevaluating Google's Reinforcement Learning for Chip Macro Placement · I. L. Markov · 2023
- ChipNeMo: Domain-Adapted LLMs for Chip Design · M. Liu et al. (NVIDIA) · 2023
- VerilogEval: Evaluating Large Language Models for Verilog Code Generation · M. Liu, N. Pinckney, B. Khailany, H. Ren · 2023