Technology: Cadence GPDK045 v5.0 (45 nm, 1.0 V core devices) + gsclib045 standard cells
Tools: Virtuoso IC25.1 (SKILL, OCEAN, ViVA), Spectre 25.1 / APS, Pegasus 25.1 (DRC/LVS),
Quantus 25.1 (PEX), Innovus 25.1 (P&R, power), Xcelium 25.09 (gate-level simulation), Genus 25.1 (.lib check)
Reference macro: sram_1024x32_b4 — 32 Kbit (1024 words × 32 bit), 4 banks, 4:1 column mux
- Summary
- What the compiler does
- Architecture
- Circuit design and sizing
- Layout (SKILL generators)
- Macro integration (control logic, place and route)
- Verification
- Post-layout signoff: PEX, Monte Carlo, power
- Architecture exploration
- Generated views (deliverables)
- Problems found and how they were fixed
- How to reproduce
- Limitations and future work
- Appendix
A memory compiler was built that takes depth / width / banks and produces a
complete, verified SRAM hard macro. All transistor-level blocks (bitcell, precharge,
column mux, sense amplifier, row decoder and word-line driver) are drawn by
parameterised SKILL generators; the control logic is built from gsclib045
standard cells and placed and routed by Innovus; Python orchestrates the flow and
the characterisation.
Results for the reference 32 Kbit macro (sram_1024x32_b4):
| Item | Result |
|---|---|
| Bitcell | 6T thin cell, 1.500 × 0.475 µm = 0.7125 µm² |
| Macro size | 454.2 × 127.7 µm = 0.058 mm² (array efficiency 40 %) |
| Full-macro DRC (Pegasus, all layers) | clean |
| Full-macro LVS (≈217 k transistors, layout vs. routed netlist) | match |
| Gate-level simulation, post-route SDF, slow corner | pass — 1867 writes / 876 reads, 0 data errors, 0 protocol violations |
| Minimum cycle / CLK→Q (std-cell slow corner) | 5.5 ns measured (6.0 ns in .lib) / 3.7 ns |
| Post-layout read, SS / worst RC / 125 °C, farthest cell | pass, 272 mV at the sense amp |
| Sensing margin vs. sense-amp offset (Monte Carlo) | required 56 mV (|μ|+6σ) → 33 σ margin |
| Bitcell read SNM, worst corner (FS), 10 000 MC samples | 181 ± 6.3 mV, ≥ 26.7 σ from failure |
| Bitcell write margin, worst corner (SF), 10 000 MC samples | 200 ± 15.2 mV, ≥ 12.4 σ from failure |
| Read / write energy per access (TT) | 5.38 / 6.76 pJ (post-layout bank + routed control) |
| Leakage | 1.62 µW (TT, 25 °C) / 60.3 µW (FF, 125 °C) |
Figure 1 — The complete 32 Kbit macro in Virtuoso (streamed in from the final GDS): four 8 Kbit banks (bottom two mirrored) around a central band of standard-cell control logic, with the M7/M8 power ring and M6 power stripes.
generate_sram(depth=1024, width=32, banks=4, mux=4)
python3 compile_sram.py --depth 1024 --width 32 --banks 4 runs five steps:
| Step | What happens | Tools |
|---|---|---|
bank |
SKILL draws every leaf cell and assembles one bank as a hard macro; the bank is streamed out, DRC- and LVS-checked, and its LEF and a black-box Liberty are written | Virtuoso (batch), Pegasus |
top |
A structural Verilog netlist of the control logic is generated; Innovus floorplans the banks, builds the power grid, places, routes, fixes DRVs and streams out a merged GDS | Python, Innovus |
sim |
The routed netlist is simulated with post-route SDF and protocol-checking bank models: sequential fill + random reads, writes and idle cycles (Section 7.2) | Xcelium |
verify |
Pegasus DRC and LVS of the complete macro (standard cells + banks + routing) | Pegasus |
views |
.lib, behavioural Verilog model, datasheet |
Python, Genus (check) |
Parameters: banks ∈ {1, 2, 4, 8}, rows per bank 8 … 256 (power of two), mux fixed
at 4:1, any word width. Every compiled macro is written to its own OA library
SRAMC_<name> and to macros/<name>/.
A single 1024-row array would put 1024 cells on each bit line, giving a large bit-line capacitance and a slow, energy-hungry read. The macro is therefore split into banks. The reference configuration uses
32 Kbit = 4 banks × (64 rows × 128 physical columns)
= 4 banks × 256 words × 32 bits (4:1 column mux)
so each bit line sees only 64 cells. Other bank counts are compared in Section 9.
Address mapping (A[9:0]):
| Bits | Use |
|---|---|
| A[1:0] | column select (1 of 4 columns per output bit) |
| A[4:2] | row predecode PA[7:0] |
| A[7:5] | row predecode PB[7:0] (row = 8·PB + PA) |
| A[9:8] | bank select |
y ↑ precharge row (1 cell per column)
strap row (well taps, M3 VDD/VSS rails)
64 rows of bitcells (rows alternate R0 / MX, columns R0 / MY)
strap row
4:1 column mux (1 cell per 4 columns = 6 µm)
sense amplifier (1 per 4 columns)
──────────────────────────────────────────────────────────────── x →
predecode tracks | row decoder + WL driver | array columns … | power spine (M4 VSS, VDD, PCB)
Figure 2 — Lower-left corner of a bank in Virtuoso: predecode tracks (far left), row decoders with word-line drivers, the bottom strap row, bitcell rows (top), the column mux and the sense amplifiers (bottom).
Figure 3 — One complete 8 Kbit bank (200.1 × 38.9 µm).
- Write: the data input D is registered, buffered onto the write data lines WDL/WDLB, and passed to the selected bit lines through an NMOS write mux (WSEL).
- Read: the selected bit lines are connected to the sense amplifier through a PMOS read mux (RSELB). A PMOS passes the precharged-high bit lines without a Vt drop. A latch-type sense amplifier resolves the differential when SAE fires, and an output latch holds the result on Q.
Separate read and write data lines mean that no tristate write driver is needed inside the bank: the write "driver" is a standard-cell buffer in the control band.
CLK high is the access phase and CLK low is the precharge phase. The bank control signals are derived from the bank's actual word-line and read-mux inputs. Fixed delay chains alone are not enough: post-route simulation showed that wire delay differs by hundreds of picoseconds between banks.
| Signal | Generated as | Guarantees |
|---|---|---|
| WL enable | CLK delayed by 2 × DLY4 (+1 × DLY2 for 8 banks) | predecoders have settled before any word line opens |
PCB_b (precharge, active low) |
OR(CLK, any PA_b) → DLY1 → BUFX16 | precharge is released before the word line and restored only after the bank's word lines are really off |
RSELB_b<k> |
NAND(column select, CLK & read & bank) | read mux open for the whole access phase |
SAE_b |
AND(delay(any PA_b AND any RSELB_b active), CLK) | fires a fixed time after both the word line and the read mux are on; scales with bank height |
| output latch | transparent while SAE (+1 delay cell) | closes before the bank precharges and DOUT resets |
All transistors use L = 45 nm except the sense-amp latch pair (L = 60 nm, for
matching). Sizes are kept in one place (python/sramgen/circuits.py), which feeds
both the Spectre testbenches and the LVS netlists, so the simulated circuit and the
drawn circuit cannot drift apart.
The sizing was chosen from a Spectre sweep (TT, 1.0 V, 27 °C). Read SNM uses the Seevinck 45° method on the butterfly curves; write margin is the bit-line voltage at which the cell flips while BL is ramped down.
| PD W (µm) | PG W (µm) | Cell ratio | Hold SNM | Read SNM | Write margin | Iread |
|---|---|---|---|---|---|---|
| 0.16 | 0.12 | 1.33 | 416.8 mV | 195.7 mV | 286.8 mV | 30.9 µA |
| 0.20 | 0.12 | 1.67 | 414.4 mV | 204.8 mV | 275.8 mV | 34.1 µA |
| 0.24 | 0.12 | 2.00 | 412.3 mV | 212.4 mV | 267.1 mV | 36.5 µA |
| 0.28 | 0.12 | 2.33 | 410.5 mV | 218.9 mV | 260.0 mV | 38.4 µA |
| 0.32 | 0.12 | 2.67 | 409.1 mV | 224.9 mV | 253.8 mV | 39.9 µA |
| 0.24 | 0.16 | 1.50 | 412.3 mV | 196.0 mV | 302.3 mV | 42.8 µA |
Chosen: PD = 0.24 µm, PG = 0.12 µm, PU = 0.12 µm (cell ratio 2, pull-up ratio 1). This is the classic balance point between read stability and writability.
Process corners (nominal, no mismatch):
| Corner | Hold SNM | Read SNM | Write margin | Iread |
|---|---|---|---|---|
| TT | 412 mV | 212 mV | 267 mV | 36.5 µA |
| SS | 418 mV | 223 mV | 226 mV | 26.2 µA |
| FF | 402 mV | 201 mV | 303 mV | 46.8 µA |
| SF | 422 mV | 236 mV | 201 mV (worst write) | 30.6 µA |
| FS | 387 mV | 187 mV (worst read) | 338 mV | 42.5 µA |
Two pull-ups (BL, BLB → VDD) and an equaliser, all gated by PCB. They were sized for full-swing recovery (after a write) of a 64-row bit line plus 6 fF of wire:
| Pull-up W (µm) | Equaliser W (µm) | t_recover TT | t_recover SS |
|---|---|---|---|
| 0.24 | 0.24 | 148 ps | 178 ps |
| 0.36 | 0.24 | 112 ps | 132 ps |
| 0.48 | 0.24 | 92 ps | 106 ps |
| 0.72 | 0.24 | 70 ps | 82 ps |
0.48 / 0.24 µm was chosen; wider devices give diminishing returns. A read only swings the bit line by a few hundred mV, so normal recovery is much faster than this.
| Block | Devices (W in µm) |
|---|---|
| Column mux (per column) | NMOS write pass 0.48 (gate WSEL), PMOS read pass 0.36 (gate RSELB) |
| Sense amplifier (per 4 columns) | cross-coupled latch N 0.48 / P 0.24 at L = 60 nm; 2-finger tail 2 × 0.48 (SAE); 3-device precharge 0.24 (PCB); output inverter N 0.24 / P 0.48 plus a matched dummy on the other side |
| Row decoder | NAND2(PA, PB): N 0.40 (series), P 0.30 |
| Word-line driver | 2-finger inverter: N 2 × 0.60, P 2 × 1.20 |
A Spectre "bank slice" (64 rows × 4 columns of real bitcells, precharge, mux, sense amp, word-line driver with the load of a 128-column word line) runs write 0 → read → write 1 → read. With the read mux kept open during sensing (the final scheme) and 300 ps from word line to SAE:
| Corner | ΔBL at SAE | ΔRDL at the SA | SAE → DOUT | Result |
|---|---|---|---|---|
| TT | 339 mV | 260 mV | 32 ps | pass |
| SS | 180 mV | 140 mV | 51 ps | pass |
| FS | 402 mV | 272 mV | 32 ps | pass |
| SF | 279 mV | 230 mV | 37 ps | pass |
| FF | 522 mV | 364 mV | 24 ps | pass |
Signal at the sense amp (SS, same timing) versus bank height — this is why the compiler scales the SAE delay with the number of rows:
| Rows / bank | 32 | 64 | 128 | 256 |
|---|---|---|---|---|
| ΔRDL at SAE (SS) | 157 mV | 140 mV | 115 mV | 85 mV |
| SAE delay chain chosen by the compiler | DLY2 | DLY2 | DLY2 + DLY1 | DLY4 |
Every cell is drawn by a SKILL procedure from a geometry description derived from the
transistor widths and the design rules (skill/*.il). Shapes are written as
(layer x1 y1 x2 y2) records; symmetric cells draw one half and generate the other by
rotation or mirroring, so symmetry is exact by construction.
Figure 4 — The 6T bitcell (1.500 × 0.475 µm) in Virtuoso.
- Four vertical diffusion stripes N | P | P | N, horizontal poly gates, and 180° rotational symmetry.
- Left NMOS stripe, bottom to top: BL contact, PG_L (word line), Q contact, PD_L (gate QB), VSS contact. The right stripe is the same rotated.
- The NMOS stripe steps from 0.12 µm (PG) to 0.24 µm (PD). The step is placed 0.1 µm from the PD gate so the gate keeps its full source/drain extension (POLY.E.3).
- Contacts on the top and bottom edges, and the word-line poly contacts on the left and right edges, are shared with the mirrored neighbour, so they cost half a contact each.
- Routing: M1 for local cross-coupling; M2 vertical for BL, VDD, BLB; M3 horizontal for the WL and for VSS rails on the cell edges (shared); M4 vertical VSS joins both M3 rails inside every cell.
Rules that set the cell size (GPDK045): contact 0.06, contact-to-gate 0.05, gate length 0.045, poly end-cap 0.10, N+ active to n-well 0.16, n-well enclosure of P+ 0.06, P+ active spacing 0.08, M1 end-of-line spacing 0.08.
Figure 5 — A 4 × 4 array with strap rows. Rows alternate R0/MX and columns R0/MY.
0.54 µm tall. It contains an N+ tap in the n-well (→ VDD), P+ taps in the NMOS columns (→ VSS), and M3 VDD and VSS rails that tie together every column's VDD (M2) and VSS (M4). Strap rows sit at the bottom and top of the array and every 32 rows in banks taller than 64 rows, so that no diffusion is more than 20 µm from a tap (LATCHUP rules).
| Cell | Size (µm) | Layout |
|---|---|---|
| precharge (1 column) | 1.50 × 1.38 | ![]() |
| column mux (4 columns) | 6.00 × 3.20 | ![]() |
| sense amplifier (4 columns) | 6.00 × 2.30 | ![]() |
| row decoder + WL driver (1 row) | 4.10 × 0.475 | ![]() |
- Column mux — PMOS read pass on top, so its n-well merges with the strap row above; NMOS write pass below; M1 data lines across the group; 8 select rails (WSEL0–3, RSELB0–3) on M3 at a 0.24 µm pitch, which leaves room for router via landings at the bank pins. It also contains a P+ substrate-tap strip (see Section 11, item 5).
- Sense amplifier — laid out like a standard-cell row (M1 VSS rail with a P+ tap at the bottom, M1 VDD rail with an N+ tap at the top). Four slots: latch, tail, precharge and output inverters. Cross-coupling is done on M1 in the gap between the NMOS and PMOS strips; RDL/RDLB arrive on M4 from the mux and are distributed on M3.
- Row decoder — pitch-matched to the 0.475 µm row. Diffusion stripes run vertically through all rows with shared edge contacts, like the bitcell. Each row taps its PA/PB predecode tracks with a short M1 stub, and the word-line driver output drops straight onto the bitcells' M3 word line.
sramcBank assembles the decoder column, predecode tracks, array, precharge row,
mux row, sense-amp row and the right-hand power spine. Bank pins:
| Edge | Pins |
|---|---|
| bottom (0.5 µm pin strip with no other metal) | PA0–7, PB0–7 (M2), WDL/WDLB (M4), DOUT (M2) |
| right | SAE, WSEL0–3, RSELB0–3 (M3) |
| over the bank | VDD and VSS on 1 µm M5 straps (via4 pairs onto every column's M4 VSS and the spine) |
top_verilog() writes a structural gsclib045 netlist (≈390 cells before
optimisation, 806 after Innovus buffering). It contains: input DFFs (A, D, CEN, WEN),
the column / PA / PB / bank decoders, the timing chains of Section 3.4, per-bank
PA/WSEL/RSELB/SAE/PCB drivers, shared write-data buffers, the bank output mux and
the SAE-timed output latches. The generator checks that every net has exactly one
driver (see Section 11, item 6).
- Banks are placed in two rows facing a central logic band. The bottom-row banks are mirrored (MX), so all bank pin edges face the logic.
- Power: M7/M8 core ring; M6 stripes every 12 µm plus a pair at the right edge; the M6 stripes drop vias onto the banks' M5 straps and onto the standard-cell M1 rails. Rails are not extended toward the macros.
- Innovus runs timing-driven placement with DRV fixing (max transition 0.15 ns), NanoRoute up to M6, post-route DRV optimisation and fillers. It then writes the routed netlist, the SDF and a GDS merged with the gsclib045 and bank GDS.
| Cell / design | DRC | LVS |
|---|---|---|
| bitcell, strap, 2×2 and 4×4 arrays | clean | match |
| precharge, column mux, sense amp, row decoder, decoder strap | clean¹ | match |
| bank cores 4×4, 8×8; full banks 16×8, 64×128, 128×128, 32×128, 256×128 | clean | match |
| full macros, 1 / 2 / 4 / 8 banks | clean | match |
¹ The bare leaf cells have no well taps by design (the taps live in the strap rows), so only the tap-presence and LATCHUP checks are waived, and only for those single cells. Every array, bank and macro is checked with no waivers.
The routed netlist is simulated with the post-route SDF (gsclib045 slow corner). Each bank is replaced by a behavioural model that both stores data and checks the bank protocol — the rules the analog circuits rely on:
- never two word lines on at once;
- the word line is never on while the bank is precharging;
- the read and write muxes are never on together;
- WDL ≠ WDLB during a write;
- SAE only fires during a read, and at least t_WL→SAE after the word line.
The testbench runs 3000 clock cycles in two phases:
| Phase | Cycles | What happens |
|---|---|---|
| Sequential fill | 0–1023 (1,024 cycles) | each address written once, in order |
| Random traffic | 1024–2999 (1,976 cycles) | random address and data; CEN = 1 (idle) with probability 1/8, otherwise a random read or write |
The reference run issued 1,024 + 843 = 1,867 writes and 876 reads, with 257 idle cycles (2,743 accesses in total; the 1/8 idle probability predicts ≈ 247). Inputs are applied 0.5 ns before each rising edge, and every read is compared with a reference model 0.5 ns before the next rising edge.
A hole in the testbench, and how it was closed. Each read is checked one loop iteration late (its data is only valid in the following cycle), so the read issued in the last cycle was never compared — and in the reference run cycle 3000 was a read. A final check after the loop, at the same sampling point, now compares and counts it. The rerun gives 876 reads instead of 875, still with 0 data errors and 0 protocol violations: the read that used to slip through was correct.
| Clock period (slow corner) | Result |
|---|---|
| 8.0 ns | pass — 0 data errors, 0 protocol violations |
| 6.0 ns | pass |
| 5.5 ns | pass |
| 5.0 ns | fail (the access no longer fits in the CLK-high phase) |
The minimum cycle is therefore 5.5 ns (≈180 MHz) at the slow corner; CLK→Q is 3.7 ns. The .lib uses 6.0 ns.
The full 64 × 128 bank was extracted with Quantus (RC, coupling folded to ground)
from a Pegasus LVS run with -rc_data: 50 976 transistors, 160 107 resistors,
135 441 capacitors. Spectre APS simulates the extracted bank with its pins driven by
the timing the control logic produces. The cells under test are the far cell
(row 63, column 127: far end of both the word line and the bit line) and the near
cell (row 0, column 0). Internal nets (BL, RDL) are probed by mapping their schematic
names onto the extracted layout nets through the LVS cross-reference (.nxf).
Figure 6 — Post-layout waveforms in ViVA (SS, worst RC, 125 °C), far cell: write 1, then read 1. When SAE fires, BLB127 has fallen to 0.66 V and the sense-amp input RDLB31 to 0.73 V; the latch resolves and DOUT31 rises.
| Corner | WL → SAE (design) | Result | ΔRDL at SAE | ΔBL at SAE | SAE → DOUT |
|---|---|---|---|---|---|
| TT, typical RC, 27 °C | 0.45 ns | pass (W/R 0 and 1, far and near) | ±306 mV | ±403 mV | 103 ps |
| SS, worst RC, 125 °C | 0.73 ns | pass | ±272 mV | ±345 mV | 155 ps |
Figure 7 — Post-layout signal at the sense amp versus WL→SAE delay. The dashed line is the requirement from the sense-amp Monte Carlo (Section 8.2).
At SS / worst RC the bank needs about 0.43 ns to reach the required 56 mV; the control logic fires SAE at 0.73 ns, which leaves ≈0.3 ns of timing slack. At the design point the margin is (272 − 6.8) / 8.15 ≈ 33 σ of sense-amp offset.
Why Monte Carlo. No two transistors are identical: random dopant fluctuation and line-edge roughness shift each device's threshold voltage independently. Corner simulations (TT/SS/FF/…) move the whole die together and cannot capture this. Monte Carlo draws every transistor's parameters from the PDK's mismatch statistics and repeats the simulation many times. For an SRAM:
- a 32 Kbit macro has 32 768 cells, and a single cell that cannot be read or written breaks the whole memory, so what matters is how many σ the mean is from the failure point (≈5–6 σ for 99.9 % array yield);
- the sense amplifier's offset sets the minimum bit-line signal it can read.
Setup: GPDK045 stat_mis_std mismatch, Spectre montecarlo with one sample per run
(run in parallel). Bitcell read SNM and hold SNM come from a full butterfly of two
independently mismatched half cells; write margin comes from the full 6T cell; the
sense-amp offset is the input differential at which the decision flips (sweep in 4 mV
steps).
| Corner | N | Mean | σ | Worst sample | Mean / σ | |
|---|---|---|---|---|---|---|
| Bitcell read SNM | TT | 1 000 | 206.7 mV | 6.3 mV | 183.3 mV | 33 |
| Bitcell read SNM | FS (worst) | 10 000 | 181.4 mV | 6.3 mV | 157.3 mV | 29 |
| Bitcell hold SNM | FS | 10 000 | 380.3 mV | 7.5 mV | 347.0 mV | 51 |
| Bitcell write margin | TT | 1 000 | 266.1 mV | 15.3 mV | 213.6 mV | 17 |
| Bitcell write margin | SF (worst) | 10 000 | 200.3 mV | 15.2 mV | 133.2 mV | 13 |
| Sense-amp offset | TT | 500 | 1.0 mV | 8.2 mV | 30 mV | — |
| Sense-amp offset | SS, 125 °C | 5 000 | 6.8 mV | 8.2 mV | 38 mV | — |
Figures 8–10 — ViVA Monte Carlo histograms (histogram2D with σ lines and a density
estimate).
Figure 11 — Read butterfly curves of individual Monte Carlo samples (FS). Each sample's two inverters are mismatched differently, so the two "eyes" shrink by different amounts; read SNM is the side of the largest square that fits in the smaller eye.
Figure 12 — Normal probability plots. Write margin and sense-amp offset lie on the line (Gaussian). Read SNM bends below the line in its lower tail: the tail is heavier than Gaussian.
The 1 000-sample runs were repeated with 10 000 (bitcell) and 5 000 (sense amp)
samples using the same seed (python/mc_stats.py):
| Metric | N | Mean (95 % CI) | σ (95 % CI) | σ from lower tail | Below / above μ±3σ (Gaussian expects) | Worst sample | Distance to failure |
|---|---|---|---|---|---|---|---|
| read SNM (FS) | 1 000 | 181.4 ± 0.38 mV | 6.17 ± 0.27 mV | 8.02 mV | 4 / 0 (1.4 each) | 157.3 mV | 22.6 σ |
| read SNM (FS) | 10 000 | 181.4 ± 0.12 mV | 6.32 ± 0.09 mV | 6.80 mV | 37 / 7 (13.5 each) | 157.3 mV | 26.7 σ |
| write margin (SF) | 1 000 | 199.5 ± 0.94 mV | 15.15 ± 0.66 mV | 17.57 mV | 1 / 3 (1.4 each) | 146.8 mV | 11.4 σ |
| write margin (SF) | 10 000 | 200.3 ± 0.30 mV | 15.24 ± 0.21 mV | 16.10 mV | 19 / 20 (13.5 each) | 133.2 mV | 12.4 σ |
| SA offset (SS 125 °C) | 500 | 6.8 ± 0.71 mV | 8.13 ± 0.50 mV | 6.95 mV | 0 / 1 (0.7 each) | 38.0 mV | — |
| SA offset (SS 125 °C) | 5 000 | 6.8 ± 0.23 mV | 8.15 ± 0.16 mV | 8.25 mV | 7 / 8 (6.8 each) | 38.0 mV | — |
Conclusions:
- For the mean and σ, 1 000 is enough. The 1 000- and 10 000-sample estimates agree within their 95 % confidence intervals (σ is known to about ±4 % from 1 000 samples).
- For the tail, 1 000 is not enough. A Gaussian puts 0.135 % of the samples below μ−3σ — about 1.4 of 1 000, too few to see the tail's shape. With 10 000 samples the read-SNM lower tail holds 37 samples instead of 13.5: it is heavier than Gaussian. Margins are therefore quoted with the σ fitted to the lower tail (26.7 σ instead of 28.7 σ for read SNM).
- Proving 6 σ directly would need about 10⁹ samples. That is the job of high-sigma methods (importance sampling, scaled-sigma sampling). They are not needed for this design: the weakest metric (write margin at SF) is 12 σ from failure, and the sense amp gets 272 mV against a 56 mV requirement.
Note: GPDK045 is a generic teaching PDK with a mild mismatch model (σVt ≈ 13 mV for the 0.12 µm devices), so the σ margins are larger than a production 45 nm process would give.
| Item | Value | Method |
|---|---|---|
| Bank, read | 2.39 pJ | post-layout bank (TT, typical RC): VDD energy + energy delivered by the pin drivers |
| Bank, write | 3.77 pJ | same |
| Control logic and routing | 2.99 pJ / cycle | Innovus report_power with the VCD of the SDF gate-level simulation (100 % of nets annotated) |
| Macro read / write | 5.38 / 6.76 pJ | sum |
| Bank leakage | 0.338 µA (TT 25 °C) / 15.0 µA (FF 125 °C) | DC operating point of the device-level bank netlist with every cell initialised (checkerboard) |
| Standard-cell leakage | 0.14 µW (slow lib) / 0.27 µW (fast lib) | state-averaged leakage_power of the 806 placed cells |
| Macro leakage | 1.62 µW (TT 25 °C) / 60.3 µW (FF 125 °C) | 4 banks + standard cells |
The .lib (slow corner) carries the FF 125 °C leakage as a conservative upper bound. A pure DC operating point without cell initialisation leaves every 6T cell at its metastable point and reports a false 11 mA; a power-up transient did not settle within 40 ns. Both were discarded in favour of the initialised DC analysis.
The same 32 Kbit (1024 × 32) memory was compiled with 1, 2, 4 and 8 banks. Every configuration went through the full flow and passed DRC, LVS and the SDF gate-level simulation.
| Banks | Rows × cols | W × H (µm) | Area (µm²) | Array efficiency | CLK→Q, slow (ns) | E_read / E_write (pJ)² | DRC | LVS | Gate sim |
|---|---|---|---|---|---|---|---|---|---|
| 1 | 256 × 128 | 234.0 × 183.7 | 42 993 | 0.54 | 3.42 | 2.02 / 2.86 | clean | match | pass |
| 2 | 128 × 128 | 231.4 × 191.7 | 44 362 | 0.53 | 3.38 | 1.92 / 2.42 | clean | match | pass |
| 4 | 64 × 128 | 454.2 × 127.7 | 57 992 | 0.40 | 3.74 | 1.86 / 2.05 | clean | match | pass |
| 8 | 32 × 128 | 900.0 × 97.3 | 87 552 | 0.27 | 4.46 | 1.79 / 1.82 | clean | match | pass |
² Bank-slice estimates, for relative comparison between configurations only. The signoff numbers for the 4-bank macro are in Section 8.3.
All four configurations are Pareto-optimal: fewer banks give a smaller area, more banks give lower energy. Because the SAE delay is scaled with bank height, access time is dominated by the standard-cell control and the global wires rather than by the bit line, so tall banks are not slower here. Two banks of 128 rows is the best overall balance; the 4- and 8-bank macros pay mostly in area, because their banks sit side by side and need longer global wires.
For every compiled macro, in macros/<name>/:
| File | Content |
|---|---|
<name>.gds |
final layout (banks + standard cells + routing), DRC clean and LVS matched |
<name>.lef |
abstract for place and route (Innovus write_lef_abstract) |
<name>.lib |
Liberty timing and power model (setup/hold, CLK→Q, min period, energy, leakage); read cleanly by Genus |
<name>_model.v |
behavioural Verilog model |
<name>.v, pnr/<name>.pnr.v |
control netlist as generated / as routed |
pnr/<name>.sdf |
post-route delays |
<name>.cdl |
LVS netlist of the whole macro |
bank_*.gds/.lef/.lib/.cdl |
bank hard macro views |
datasheet.json, char.json |
datasheet and signoff characterisation (traceable to the raw results) |
drc/, lvs/, pex*/ |
Pegasus and Quantus reports (condensed in docs/signoff_summary.md) |
OA libraries SRAMC_<name> (in virtuoso/) hold every cell for viewing in Virtuoso.
What this repository contains. The generators, the flow and characterisation
scripts, the figures, the raw characterisation data (sim/) and the small text views
of each macro (.lib, .lef, Verilog, top-level CDL, datasheet.json, char.json).
Not included: GDS and OA layouts (they contain gsclib045 cells), the flat bank CDL
netlists (up to 13 MB, regenerated by the bank step), the Innovus databases, SDF,
Quantus extractions and the raw Pegasus reports. The DRC/LVS results of every macro are
summarised in docs/signoff_summary.md.
These are the issues the verification flow caught during development. Each was fixed in the generator, so every future macro inherits the fix. The full discussion — layout decisions with alternatives, root causes, proposed further fixes and a reflection — is in docs/DESIGN_NOTES.md.
| # | Found by | Problem | Fix |
|---|---|---|---|
| 1 | DRC | PD/PG diffusion step too close to the PD gate (POLY.E.3) | step moved 25 nm toward PG |
| 2 | LVS | Pegasus collapsed the hierarchical schematic into a recognised "SRAM array" but not the layout | LVS netlists of arrays and banks are written flat |
| 3 | LVS | the VDD M2 lines of different columns were separate nets | M3 VDD rail added to every strap row |
| 4 | LVS | decoder NAND2 series stack drawn VSS–PA–PB–out, netlist written in the other order | netlist written in the drawn order (also correct for timing) |
| 5 | DRC (LATCHUP.2) | the column-mux NMOS band is an isolated strip of p-substrate between two full-width n-wells, with no tap | P+ tap strip in the mux, strapped to the sense amp's VSS |
| 6 | gate-level sim | net-name collision: data register bit 1 (d1) and the WL-enable delay net (d1) |
nets renamed; generator now asserts one driver per net |
| 7 | gate-level sim (SDF) | precharge and word line overlapped at CLK fall; SAE fired before the read mux connected; unbuffered 400 µm control wires took ~3 ns | per-bank self-timing from the actual PA/RSELB nets; Innovus DRV fixing |
| 8 | gate-level sim (SDF) | predecoder glitch: two word lines briefly on | longer WL-enable delay, stronger decoder drivers |
| 9 | gate-level sim (SDF) | output latch closed before the slowest DOUT bits arrived | latch held open one delay cell past SAE (DOUT stays valid until precharge) |
| 10 | full-macro DRC/LVS | router used the un-obstructed bottom of the bank; sroute blockPin ran power across the select-rail pins; banks were placed in die (not core) coordinates; row rails jogged next to bank pins |
full M1–M4 obstruction; PG pins only on M5 straps; core-relative placement; rails along rows only plus editPowerVia; 0.5 µm pin strip; 0.24 µm select-rail pitch |
| 11 | testbench | Q was sampled 0.5 ns before the falling edge (first rising edge is at period/2) | sampling phase corrected |
| 12 | leakage | DC operating point without initialisation left all cells metastable (false 11 mA) | DC with nodesets on every cell |
| 13 | Monte Carlo (10 000 samples) | read SNM lower tail heavier than Gaussian | margins quoted with the tail-fitted σ |
| 14 | testbench review | reads are checked one iteration late, so the read in the last cycle was never compared | final check after the loop (876 instead of 875 reads checked, 0 errors) |
Requires a licensed Cadence installation and the GPDK045 v5.0 PDK with the gsclib045 standard-cell library; none of these are distributed with this repository. Point the flow at them with environment variables:
| Variable | Meaning |
|---|---|
GPDK045_HOME |
root of the GPDK045 v5.0 installation (models, layer map, Pegasus decks) |
GSCLIB045_HOME |
the gsclib045 directory (LEF, Liberty, GDS, CDL) |
SRAMC_CDS_SETUP |
tcsh script that sets up Virtuoso, Spectre, Pegasus and Quantus |
SRAMC_DIG_SETUP |
tcsh script that sets up Innovus, Xcelium and Genus |
tcsh
source $SRAMC_CDS_SETUP # Virtuoso, Spectre, Pegasus, Quantus
source $SRAMC_DIG_SETUP # Innovus, Xcelium, Genus
cd sram_compiler/python
# the compiler
python3 compile_sram.py --depth 1024 --width 32 --banks 4 # all steps
python3 explore_report.py --depth 1024 --width 32 # Section 9 table
# leaf-cell regression (DRC + LVS of every cell and test array)
python3 run_cells.py
# characterisation
python3 bitcell_char.py --corners # bitcell SNM / WM / Iread
python3 periph_char.py precharge # precharge sizing
python3 bank_slice.py --tsae 0.30 --mux-hold --corner ss
python3 run_pex.py --corner worst # Quantus extraction of the bank
python3 postlayout_bank.py --tws-list 0.40,0.73 --corner ss --rc worst --temp 125
python3 mc.py bitcell --n 10000 --corner fs
python3 mc.py senseamp --n 5000 --corner ss --temp 125
python3 mc_stats.py # "is N enough" table
python3 leak_bank.py --corner ff --temp 125
python3 characterize.py # -> macros/<name>/char.json
python3 compile_sram.py --steps views # .lib with the signoff numbers
# figures (rendered by Virtuoso on a virtual display)
python3 virtuoso_figs.py # waveforms, histograms, butterfly
python3 layout_figs.py # layout screenshotsTo view the layouts interactively, add for example
DEFINE SRAMC_sram_1024x32_b4 <path to sram_compiler>/virtuoso/SRAMC_sram_1024x32_b4
to your cds.lib, or launch Virtuoso from sram_compiler/virtuoso.
skill/ sramc_util.il helpers: snapping, layer map, pins, transforms
sramc_bitcell.il bitcell, strap row, array tiler
sramc_precharge.il precharge / equalise
sramc_colmux.il 4:1 column mux (+ substrate tap strip)
sramc_senseamp.il latch sense amplifier
sramc_rowdec.il row decoder + WL driver, decoder strap
sramc_bank.il bank core, bank hard macro, pin dump
python/ compile_sram.py compiler driver (bank, top, sim, verify, views)
sramgen/circuits.py transistor netlists (single source for SPICE and LVS)
sramgen/macro.py control netlist, Innovus script, LEF/.lib, Verilog->CDL
sramgen/models.py bank protocol model, macro model, testbench
sramgen/verify.py Pegasus DRC/LVS; pex.py Quantus
sramgen/virtuoso.py batch Virtuoso + strmout
*.py characterisation, Monte Carlo, figures
macros/ one directory per compiled macro (views, reports)
sim/ Spectre runs, Monte Carlo data, post-layout results
docs/ figures (rendered by Virtuoso)
cells/ LVS netlists of the leaf cells and test arrays
virtuoso/ OA libraries, cds.lib, batch logs (generated; not in this repository)
- Timing views: the .lib timing comes from the standard-cell slow corner via SDF. The bank's analog timing is verified post-layout at TT and SS/worst RC, but multi-corner .lib files (TT, FF) are not yet generated.
- Signoff coverage: PEX, post-layout simulation and Monte Carlo were run for the
reference macro's bank (64 × 128). The other configurations use the same scripts
(
run_pex.py --macro … --bank …) but have not been run. - High-sigma: the bitcell tail is characterised to about 3.8 σ with 10 000 samples; importance sampling would be needed for direct 6 σ evidence.
- Architecture: mux fixed at 4:1; banks ∈ {1, 2, 4, 8}; rows per bank 8 … 256; clock-phase timing (the access must fit in the CLK-high phase). A replica-bit-line self-timed scheme would remove the 50 % duty-cycle dependence and shorten the cycle.
- Area: the bitcell (0.71 µm²) uses generous spacing for a first, rule-clean version; the 4- and 8-bank floorplans could share periphery between bank pairs.
| Rule | Value | Rule | Value |
|---|---|---|---|
| active width / gate width | 0.05 / 0.12 | poly width / gate length | 0.045 |
| N+–N+ / P+–P+ / N+–P+ active | 0.08 / 0.08 / 0.10 | poly space (gate) | 0.06 |
| gate end-cap / S-D extension | 0.10 / 0.10 | poly to unrelated active | 0.05 |
| contact size / space | 0.06 / 0.06 | contact to gate | 0.05 |
| active / poly enclosure of contact | 0.03 / 0.02 (0.03 two sides) | implant enclosure of active | 0.07 (0.01 for taps) |
| implant enclosure of gate | 0.10 | n-well enclosure of P+ / space to N+ | 0.06 / 0.16 |
| M1 width / space / end-of-line | 0.06 / 0.06 / 0.08 | M2–M6 width / space | 0.08 / 0.07 |
| via size / space | 0.07 / 0.07 | metal enclosure of via | 0.005 (0.03 two sides) |
| wide metal (> 0.1 µm, run > 0.32 µm) spacing | M1 0.10, M3 0.15 | min metal area | 0.02 µm² |
| latch-up: max distance to tap | 20 | ≥ 2 vias under metal wider than 0.4 µm | VIA*.X.1/2 |
| Pin | Direction | Function |
|---|---|---|
| CLK | in | clock; inputs sampled at the rising edge; CLK high = access, low = precharge |
| CEN | in | chip enable, active low |
| WEN | in | write enable, active low (0 = write D to A, 1 = read A) |
| A[9:0] | in | address |
| D[31:0] | in | write data |
| Q[31:0] | out | read data, valid within the CLK-high phase and held until the next read |
| VDD, VSS | power | 1.0 V supply |















