Skip to content

About

SRAM memory compiler in 45 nm (GPDK045): parameterized SKILL layout generators (0.71 µm² 6T bitcell, sense amp, decoder), Innovus-routed control with per-bank self-timing. 1/2/4/8-bank macros DRC/LVS clean; post-layout PEX, Monte Carlo signoff, .lib/.lef views.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

1 Commit

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

A Custom SRAM Compiler in 45 nm — Design, Layout, Verification and Signoff Report

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


Contents

  1. Summary
  2. What the compiler does
  3. Architecture
  4. Circuit design and sizing
  5. Layout (SKILL generators)
  6. Macro integration (control logic, place and route)
  7. Verification
  8. Post-layout signoff: PEX, Monte Carlo, power
  9. Architecture exploration
  10. Generated views (deliverables)
  11. Problems found and how they were fixed
  12. How to reproduce
  13. Limitations and future work
  14. Appendix

1. Summary

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)

Full 32 Kbit macro layout

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.


2. What the compiler does

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>/.


3. Architecture

3.1 Organisation of the 32 Kbit macro

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

3.2 Bank structure

   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)

Bank corner

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).

Whole bank

Figure 3 — One complete 8 Kbit bank (200.1 × 38.9 µm).

3.3 Read and write data paths

  • 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.

3.4 Timing scheme (self-timed per bank)

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

4. Circuit design and sizing

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.

4.1 Bitcell

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

4.2 Precharge and equalise

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.

4.3 Column mux, sense amplifier, row decoder

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

4.4 Bank-slice verification (pre-layout)

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

5. Layout (SKILL generators)

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.

5.1 Bitcell — 6T "thin cell"

Bitcell layout

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.

4x4 array

Figure 5 — A 4 × 4 array with strap rows. Rows alternate R0/MX and columns R0/MY.

5.2 Strap (well-tap) row

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).

5.3 Peripheral cells

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.

5.4 Bank hard macro

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)

6. Macro integration (control logic, place and route)

6.1 Control netlist

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).

6.2 Floorplan and power

  • 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.

7. Verification

7.1 Physical verification

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.

7.2 Functional and timing verification (gate level)

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.


8. Post-layout signoff: PEX, Monte Carlo, power

8.1 Parasitic extraction and post-layout simulation

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).

Post-layout waveforms

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

Sense margin vs SAE timing

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.

8.2 Monte Carlo (local mismatch)

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 —

Read SNM histogram Write margin histogram SA offset histogram

Figures 8–10 — ViVA Monte Carlo histograms (histogram2D with σ lines and a density estimate).

Butterfly curves

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.

Normal probability plots

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.

Is 1 000 samples enough?

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.

8.3 Power and leakage

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.


9. Architecture exploration

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.


10. Generated views (deliverables)

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.


11. Problems found and how they were fixed

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)

12. How to reproduce

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 screenshots

To 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.

Repository layout

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)

13. Limitations and future work

  • 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.

14. Appendix

14.1 GPDK045 rules used most by the generators (µm)

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

14.2 Interface of the macro

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

About

SRAM memory compiler in 45 nm (GPDK045): parameterized SKILL layout generators (0.71 µm² 6T bitcell, sense amp, decoder), Innovus-routed control with per-bank self-timing. 1/2/4/8-bank macros DRC/LVS clean; post-layout PEX, Monte Carlo signoff, .lib/.lef views.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages