Games / Command flash cards / Layout and parasitic formats / How they fit together

How they fit together

Each card shows a command to explain. A missed card returns later in the round and starts the schedule over. A card answered correctly moves up the schedule and next appears after 1, 3, 7, then 21 days. Keys 1 to 4 choose an option, h shows a hint, and Enter moves on. A hint keeps the card where it is on the schedule. An ordering card is answered by clicking its items in order, and one wrong click ends it. Time values are in nanoseconds. Progress is stored in this browser.

SourceFour formats carry a design between tools: LEF (Library Exchange Format) for the technology and the cells, DEF (Design Exchange Format) for the layout, SPEF (Standard Parasitic Exchange Format) for extracted wires, and SDF (Standard Delay Format) for annotated delays. The LEF (Library Exchange Format) excerpts here are quoted from the Nangate45 files that OpenROAD-flow-scripts ships; the rest follow the formats as OpenROAD and OpenSTA read them. Reference: the OpenSTA command reference (the open flow on GitHub).
All 6 cards in this section, with answers
  • read_lef nangate45.tech.lef read_lef nangate45.macro.lef read_verilog gcd.v read_def gcd.def read_spef gcd.spef
    Technology, cell shapes, netlist, layout, then the wires' cost.

    Hint: Ask what each file adds that the ones before it could not.

    In order: what the process allows, what the cells look like, what is connected to what, where everything sits, and what the wires cost. Timing needs one more, the Liberty library, which none of these carry. the open flow reference

  • LEF (Library Exchange Format) against DEF (Design Exchange Format)
    One describes the technology and cells, the other one design.

    Hint: One is per library, the other per design. Ask which is which.

    LEF (Library Exchange Format) is the library side and DEF (Design Exchange Format) the design side. A LEF (Library Exchange Format) file is written once per technology or library and reused by every design; a DEF (Design Exchange Format) file belongs to one design at one stage. This is why DEF (Design Exchange Format) refers to cells by name and never repeats their shapes. the open flow reference

  • SPEF (Standard Parasitic Exchange Format) against SDF (Standard Delay Format)
    One gives the wires' parasitics, the other computed delays.

    Hint: Both describe timing. Ask which one has already been through delay calculation.

    SPEF (Standard Parasitic Exchange Format) holds parasitics and SDF (Standard Delay Format) holds delays. With SPEF (Standard Parasitic Exchange Format) the reading tool computes delays itself, so it can re-time after a change. With SDF (Standard Delay Format) the delays are fixed, which is what a gate-level simulation wants. Handing a simulator SPEF (Standard Parasitic Exchange Format), or a timer SDF (Standard Delay Format), works but answers a different question. the open flow reference

  • write_db against write_def
    The database keeps everything; the other is the portable subset.

    Hint: Ask which one another vendor's tool can read, and which keeps everything.

    DEF (Design Exchange Format) is the portable one. OpenROAD's own database carries the technology, the netlist, the layout, and tool-specific state together, which is why stages hand it along. DEF (Design Exchange Format) carries what other tools can read, and loses whatever has no representation in the format. the open flow reference

  • gcd.v against gcd.def
    The same instances, with connections in one and positions in the other.

    Hint: Both list the same instances. Ask what each adds to the list.

    A layout exchange file does carry connectivity, but tools treat the netlist as the authority on it and the layout file as the authority on geometry. That is why a flow reads both, and why an instance renamed in one and not the other breaks the link between them. the open flow reference

  • block.lef block.lib block.gds block.v
    The four views a finished block hands up to the level above.

    Hint: The level above needs to place, time, and finally merge this block.

    The abstract lets the top level place and route around the block, the Liberty model lets it be timed without its internals, the layout is merged at streamout, and the netlist supports layout versus schematic. A hard macro such as a memory arrives the same way. the open flow reference