Sky130 - Convert to Pydantic, support sky130_scl

doc/Technology/Tech-class.rst

@@ -28,6 +28,7 @@ HammerTechnology Class
 
 The HammerTechnology class is the base class that all technology plugins should inherit from and is defined in ``hammer/tech/__init__.py``. Particularly useful methods are:
 
+* ``gen_config``: the plugin subclass should override this method to generate the tech config. See the next section (:ref:`tech-json`) for details.
 * ``post_install_script``: the plugin subclass should override this method to apply any non-default PDK installation steps or hotfixes in order to set up the technology libraries for use with Hammer.
 * ``read_libs``: this is a particularly powerful method to read the libraries contained in the ``tech.json`` file and filter them using the filters also contained the same file. See the :ref:`filters` section for details.
 * ``get_tech_<action>_hooks``: these methods are necessary if tech--specific hooks are needed, and must return a list of hooks when a given tool name implementing the relevant action is called. Refer to the :ref:`hooks` section for details about how to write hooks. 

e2e/Makefile

@@ -45,4 +45,4 @@ $(HAMMER_D_MK):
 -include $(HAMMER_D_MK)
 
 clean:
-    rm -rf $(OBJ_DIR) hammer-vlsi-*.log
+	rm -rf $(OBJ_DIR) hammer-vlsi-*.log

hammer/par/openroad/__init__.py

@@ -1448,7 +1448,9 @@ def write_gds(self) -> str:
             ilm_gds = list(map(lambda ilm: ilm.gds, self.get_input_ilms()))
             gds_files.extend(ilm_gds)
 
-        layer_map_file=self.get_setting('par.inputs.gds_map_file')
+        layer_map_file=self.get_gds_map_file()
+        if layer_map_file is None:
+            raise FileNotFoundError(f"Must have GDS layer map for write_gds! KLayout won't be able to write GDS file. ({layer_map_file}")
 
         # the first entry of $KLAYOUT_PATH will be the one where the configuration is stored when KLayout exits
         #   otherwise KLayout tries to write everything to the same directory as the klayout binary and throws an error if it is not writeable

hammer/tech/__init__.py

@@ -353,8 +353,12 @@ def __init__(self):
         self.time_unit: Optional[str] = None
         self.cap_unit: Optional[str] = None
 
+    def gen_config(self) -> None:
+        """For subclasses to set self.config (type: TechJSON) directly, instead of from static JSON file"""
+        pass
+
     @classmethod
-    def load_from_module(cls, tech_module: str) -> Optional["HammerTechnology"]:
+    def load_from_module(cls, tech_module: str) -> "HammerTechnology":
         """Load a technology from a given module.
 
         :param tech_module: Technology module (e.g. "hammer.technology.asap7")
@@ -375,8 +379,8 @@ def load_from_module(cls, tech_module: str) -> Optional["HammerTechnology"]:
         elif tech_yaml.is_file():
             tech.config = TechJSON.model_validate_json(json.dumps(load_yaml(tech_yaml.read_text())))
             return tech
-        else: #TODO - from Pydantic model instance
-            return None
+        else: # Assume tech implents gen_config()
+            return tech
 
     def get_lib_units(self) -> None:
         """
@@ -648,15 +652,15 @@ def prepend_dir_path(self, path: str, lib: Optional[Library] = None) -> str:
 
         1. Absolute path: the path starts with "/" and refers to an absolute path on the filesystem
             /path/to/a/lib/file.lib -> /path/to/a/lib/file.lib
-        2. Tech plugin relative path: the path has no "/"s and refers to a file directly inside the tech plugin folder
+        2. Tech plugin relative path: the path has no "/"s and refers to a file directly inside the tech plugin folder (no subdirectories allowed, else it conflicts with 3-5. below!)
             techlib.lib -> <tech plugin package>/techlib.lib
-        3. Tech cache relative path: the path starts with an identifier which is "cache" (this is used in the SKY130 tech JSON)
+        3. Tech cache relative path: the path starts with an identifier which is "cache" (this is used in the SKY130 Libraries)
             cache/primitives.v -> <tech plugin cache dir>/primitives.v
         4. Install relative path: the path starts with an install/tarball identifier (installs.id, tarballs.root.id)
         and refers to a file relative to that identifier's path
             pdkroot/dac/dac.lib -> /nfs/ecad/tsmc100/stdcells/dac/dac.lib
         5. Library extra_prefix path: the path starts with an identifier present in the provided
-            library's extra_prefixes
+            library's extra_prefixes Field
             lib1/cap150f.lib -> /design_files/caps/cap150f.lib
         """
         assert len(path) > 0, "path must not be empty"

hammer/technology/sky130/README.md

@@ -45,6 +45,22 @@ Now in your Hammer YAML configs, point to the location of this install:
 technology.sky130.sky130A: "<PREFIX>/share/pdk/sky130A"
 ```
 
+### Cadence PDK
+
+Cadence has also created a PDK and standard cell library based on the original open PDK, and optimized for use with Cadence tools. Usage of this PDK is purely optional, but enables DRC/LVS with Pegasus, and IR drop analysis with Voltus.
+
+You can download them from [here](https://support.cadence.com/apex/ArticleAttachmentPortal?id=a1Od000000051TqEAI&pageName=ArticleContent) (Cadence Support account is required). After downloading and untar-ing the packages, point to the location of this install:
+
+```yaml
+technology.sky130.sky130_cds: "<path/to/sky130_pdk>"
+technology.sky130.sky130_scl: "<path/to/sky130_scl>"
+```
+
+To select this standard cell library (instead of the default `sky130_fd_sc_hd`):
+
+```yaml
+technology.sky130.stdcell_library: "sky130_scl"
+```
 
 SRAM Macros
 -----------

hammer/technology/sky130/__init__.py

@@ -9,20 +9,234 @@
 from typing import NamedTuple, List, Optional, Tuple, Dict, Set, Any
 import importlib
 import json
+import functools
 
-import hammer.tech
-from hammer.tech import HammerTechnology
+from hammer.tech import *
 from hammer.vlsi import HammerTool, HammerPlaceAndRouteTool, TCLTool, HammerDRCTool, HammerLVSTool, \
     HammerToolHookAction, HierarchicalMode
-
-import hammer.tech.specialcells as specialcells
-from hammer.tech.specialcells import CellType, SpecialCell
+from hammer.utils import LEFUtils
 
 class SKY130Tech(HammerTechnology):
     """
     Override the HammerTechnology used in `hammer_tech.py`
     This class is loaded by function `load_from_json`, and will pass the `try` in `importlib`.
     """
+    def gen_config(self) -> None:
+        """Generate the tech config, based on the library type selected"""
+        slib = self.get_setting("technology.sky130.stdcell_library")
+        SKY130A = self.get_setting("technology.sky130.sky130A")
+
+        # Common tech LEF and IO cell spice netlists
+        libs = [
+            Library(lef_file = "cache/sky130_fd_sc_hd__nom.tlef", verilog_sim = "cache/primitives.v", provides = [Provide(lib_type = "technology")]),
+            Library(spice_file = "$SKY130A/libs.ref/sky130_fd_io/spice/sky130_ef_io__analog.spice", provides = [Provide(lib_type = "IO library")])
+        ]
+        # Generate IO cells
+        library='sky130_fd_io'
+        SKYWATER_LIBS = os.path.join('$SKY130A', 'libs.ref', library)
+        LIBRARY_PATH  = os.path.join(  SKY130A,  'libs.ref', library, 'lib')
+        lib_corner_files=os.listdir(LIBRARY_PATH)
+        lib_corner_files.sort()
+        for cornerfilename in lib_corner_files:
+            # Skip versions with no internal power
+            if ('nointpwr' in cornerfilename) : continue
+
+            tmp = cornerfilename.replace('.lib','')
+            # Split into cell, and corner strings
+            # Resulting list if only one ff/ss/tt in name: [<cell_name>, <match 'ff'?>, <match 'ss'?>, <match 'tt'?>, <temp & voltages>]
+            # Resulting list if ff_ff/ss_ss/tt_tt in name: [<cell_name>, <match 'ff'?>, <match 'ss'?>, <match 'tt'?>, '', <match 'ff'?>, <match 'ss'?>, <match 'tt'?>, <temp & voltages>]
+            split_cell_corner = re.split('_(ff)|_(ss)|_(tt)', tmp)
+            cell_name = split_cell_corner[0]
+            process = split_cell_corner[1:-1]
+            temp_volt = split_cell_corner[-1].split('_')[1:]
+
+            # Filter out cross corners (e.g ff_ss or ss_ff)
+            if len(process) > 3:
+                if not functools.reduce(lambda x,y: x and y, map(lambda p,q: p==q, process[0:3], process[4:]), True):
+                    continue
+            # Determine actual corner
+            speed = next(c for c in process if c is not None).replace('_','')
+            if (speed == 'ff'): speed = 'fast'
+            if (speed == 'tt'): speed = 'typical'
+            if (speed == 'ss'): speed = 'slow'
+
+            temp = temp_volt[0]
+            temp = temp.replace('n','-')
+            temp = temp.split('C')[0]+' C'
+
+            vdd = ('.').join(temp_volt[1].split('v')) + ' V'
+            # Filter out IO/analog voltages that are not high voltage
+            if temp_volt[2].startswith('1'): continue
+            if len(temp_volt) == 4:
+                if temp_volt[3].startswith('1'): continue
+
+            # gpiov2_pad_wrapped has separate GDS
+            if cell_name == 'sky130_ef_io__gpiov2_pad_wrapped':
+                file_lib = 'sky130_ef_io'
+                gds_file = cell_name + '.gds'
+                lef_file = 'cache/sky130_ef_io.lef'
+                spice_file = os.path.join(SKYWATER_LIBS,'cdl', file_lib + '.cdl')
+            elif 'sky130_ef_io' in cell_name:
+                file_lib = 'sky130_ef_io'
+                gds_file = file_lib + '.gds'
+                lef_file = 'cache/' + file_lib + '.lef'
+                spice_file = os.path.join(SKYWATER_LIBS,'cdl', file_lib + '.cdl')
+            else:
+                file_lib = library
+                gds_file = file_lib + '.gds'
+                lef_file = os.path.join(SKYWATER_LIBS,'lef', file_lib + '.lef')
+                spice_file = os.path.join(SKYWATER_LIBS,'spice', file_lib + '.spice')
+
+            lib_entry = Library(
+                nldm_liberty_file =  os.path.join(SKYWATER_LIBS,'lib', cornerfilename),
+                verilog_sim =        os.path.join(SKYWATER_LIBS,'verilog', file_lib + '.v'),
+                lef_file =           lef_file,
+                spice_file =         spice_file,
+                gds_file =           os.path.join(SKYWATER_LIBS,'gds', gds_file),
+                corner = Corner(
+                    nmos = speed,
+                    pmos = speed,
+                    temperature = temp
+                ),
+                supplies = Supplies(
+                    VDD = vdd,
+                    GND  ="0 V"
+                ),
+                provides = [Provide(
+                    lib_type = cell_name,
+                    vt = "RVT"
+                    )
+                ]
+            )
+            libs.append(lib_entry)
+
+        # Stdcell library-dependent lists
+        stackups = []  # type: List[Stackup]
+        phys_only = []  # type: List[Cell]
+        dont_use = []  # type: List[Cell]
+        spcl_cells = []  # type: List[SpecialCell]
+
+        # Select standard cell libraries
+        if slib == "sky130_fd_sc_hd":
+            phys_only = [
+                "sky130_fd_sc_hd__tap_1", "sky130_fd_sc_hd__tap_2", "sky130_fd_sc_hd__tapvgnd_1", "sky130_fd_sc_hd__tapvpwrvgnd_1",
+                "sky130_fd_sc_hd__fill_1", "sky130_fd_sc_hd__fill_2", "sky130_fd_sc_hd__fill_4", "sky130_fd_sc_hd__fill_8",
+                "sky130_fd_sc_hd__diode_2"]
+            dont_use = [
+                "*sdf*",
+                "sky130_fd_sc_hd__probe_p_*",
+                "sky130_fd_sc_hd__probec_p_*"
+            ]
+            spcl_cells = [
+                SpecialCell(cell_type = CellType("tiehilocell"), name = ["sky130_fd_sc_hd__conb_1"]),
+                SpecialCell(cell_type = CellType("tiehicell"), name = ["sky130_fd_sc_hd__conb_1"], output_ports = ["HI"]),
+                SpecialCell(cell_type = CellType("tielocell"), name = ["sky130_fd_sc_hd__conb_1"], output_ports = ["LO"]),
+                SpecialCell(cell_type = CellType("endcap"), name = ["sky130_fd_sc_hd__tap_1"]),
+                SpecialCell(cell_type = CellType("tapcell"), name = ["sky130_fd_sc_hd__tapvpwrvgnd_1"]),
+                SpecialCell(cell_type = CellType("stdfiller"), name = ["sky130_fd_sc_hd__fill_1", "sky130_fd_sc_hd__fill_2", "sky130_fd_sc_hd__fill_4", "sky130_fd_sc_hd__fill_8"]),
+                SpecialCell(cell_type = CellType("decap"), name = ["sky130_fd_sc_hd__decap_3", "sky130_fd_sc_hd__decap_4", "sky130_fd_sc_hd__decap_6", "sky130_fd_sc_hd__decap_8", "sky130_fd_sc_hd__decap_12"]),
+                SpecialCell(cell_type = CellType("driver"), name = ["sky130_fd_sc_hd__buf_4"], input_ports = ["A"], output_ports = ["X"]),
+                SpecialCell(cell_type = CellType("ctsbuffer"), name = ["sky130_fd_sc_hd__clkbuf_1"])
+            ]
+
+            # Generate standard cell library
+            library=slib
+
+            SKYWATER_LIBS = os.path.join('$SKY130A', 'libs.ref', library)
+            LIBRARY_PATH  = os.path.join(  SKY130A,  'libs.ref', library, 'lib')
+            lib_corner_files=os.listdir(LIBRARY_PATH)
+            lib_corner_files.sort()
+            for cornerfilename in lib_corner_files:
+                if (not (library in cornerfilename) ) : continue
+                if ('ccsnoise' in cornerfilename): continue # ignore duplicate corner.lib/corner_ccsnoise.lib files
+
+                tmp = cornerfilename.replace('.lib','')
+                if (tmp+'_ccsnoise.lib' in lib_corner_files):
+                    cornerfilename=tmp+'_ccsnoise.lib' # use ccsnoise version of lib file
+
+                cornername = tmp.split('__')[1]
+                cornerparts = cornername.split('_')
+
+                speed = cornerparts[0]
+                if (speed == 'ff'): speed = 'fast'
+                if (speed == 'tt'): speed = 'typical'
+                if (speed == 'ss'): speed = 'slow'
+
+                temp = cornerparts[1]
+                temp = temp.replace('n','-')
+                temp = temp.split('C')[0]+' C'
+
+                vdd = cornerparts[2]
+                vdd = vdd.split('v')[0]+'.'+vdd.split('v')[1]+' V'
+
+                lib_entry = Library(
+                    nldm_liberty_file =  os.path.join(SKYWATER_LIBS,'lib', cornerfilename),
+                    verilog_sim =        os.path.join('cache',             library+'.v'),
+                    lef_file =           os.path.join(SKYWATER_LIBS,'lef', library+'.lef'),
+                    spice_file =         os.path.join('cache',             library+'.cdl'),
+                    gds_file =           os.path.join(SKYWATER_LIBS,'gds', library+'.gds'),
+                    corner = Corner(
+                        nmos = speed,
+                        pmos = speed,
+                        temperature = temp
+                    ),
+                    supplies = Supplies(
+                        VDD = vdd,
+                        GND = "0 V"
+                    ),
+                    provides = [Provide(
+                        lib_type = "stdcell",
+                        vt = "RVT"
+                        )
+                    ]
+                )
+
+                libs.append(lib_entry)
+
+            # Generate stackup
+            tlef_path = os.path.join(SKY130A, 'libs.ref', library, 'techlef', f"{library}__min.tlef")
+            metals = list(map(lambda m: Metal.model_validate(m), LEFUtils.get_metals(tlef_path)))
+            stackups.append(Stackup(name = slib, grid_unit = Decimal("0.001"), metals = metals))
+
+        elif slib == "sky130_scl":
+            raise NotImplementedError(f"sky130_scl not yet supported")
+        else:
+            raise ValueError(f"Incorrect standard cell library selection: {slib}")
+
+        self.config = TechJSON(
+            name = "Skywater 130nm Library",
+            grid_unit = "0.001",
+            shrink_factor = None,
+            installs = [
+                PathPrefix(id = "$SKY130_NDA", path = "technology.sky130.sky130_nda"),
+                PathPrefix(id = "$SKY130A", path = "technology.sky130.sky130A"),
+                PathPrefix(id = "$SKY130_CDS", path = "technology.sky130.sky130_cds")
+            ],
+            libraries = libs,
+            gds_map_file = "sky130_lefpin.map",
+            physical_only_cells_list = phys_only,
+            dont_use_list = dont_use,
+            drc_decks = [
+                DRCDeck(tool_name = "calibre", deck_name = "calibre_drc", path = "$SKY130_NDA/s8/V2.0.1/DRC/Calibre/s8_drcRules"),
+                DRCDeck(tool_name = "klayout", deck_name = "klayout_drc", path = "$SKY130A/libs.tech/klayout/drc/sky130A.lydrc"),
+                DRCDeck(tool_name = "pegasus", deck_name = "pegasus_drc", path = "$SKY130_CDS/Sky130_DRC/sky130_rev_0.0_1.0.drc.pvl")
+            ],
+            additional_drc_text = "",
+            lvs_decks = [
+                LVSDeck(tool_name = "calibre", deck_name = "calibre_lvs", path = "cache/lvsControlFile_s8"),
+                LVSDeck(tool_name = "pegasus", deck_name = "pegasus_lvs", path = "$SKY130_CDS/Sky130_LVS/Sky130_rev_0.0_0.1.lvs.pvl")
+            ],
+            additional_lvs_text = "",
+            tarballs = None,
+            sites = [
+                Site(name = "unithd", x = Decimal("0.46"), y = Decimal("2.72")),
+                Site(name = "unithddbl", x = Decimal("0.46"), y = Decimal("5.44"))
+            ],
+            stackups = stackups,
+            special_cells = spcl_cells,
+            extra_prefixes = None
+        )
+
     def post_install_script(self) -> None:
         self.library_name = 'sky130_fd_sc_hd'
         # check whether variables were overriden to point to a valid path
@@ -94,7 +308,7 @@ def setup_verilog(self) -> None:
                     line = line.replace('wire 1','// wire 1')
                     line = line.replace('`endif SKY130_FD_SC_HD__LPFLOW_BLEEDER_FUNCTIONAL_V','`endif // SKY130_FD_SC_HD__LPFLOW_BLEEDER_FUNCTIONAL_V')
                     df.write(line)
-                    
+
         # Additionally hack out the specifies
         sl = []
         with open(dest_path, 'r') as sf:
@@ -127,16 +341,16 @@ def setup_verilog(self) -> None:
         for list_idx, pattern_tuple in enumerate(pattern_idx):
             if list_idx != len(pattern_idx)-1:
                 search_range = range(pattern_tuple[0]+1, pattern_idx[list_idx+1][0])
-            else: 
+            else:
                 search_range = range(pattern_tuple[0]+1, len(sl))
             for idx in search_range:
                 list = re.findall(capture_pattern, sl[idx])
                 for elem in list:
                     if elem != pattern_tuple[1]:
                         sl[idx] = sl[idx].replace(elem, pattern_tuple[1])
                         self.logger.info(f"Incorrect reference `{elem}` to be replaced with: `{pattern_tuple[1]}` on raw line {idx}.")
-                    
-        # Write back into destination 
+
+        # Write back into destination
         with open(dest_path, 'w') as df:
             df.writelines(sl)
 
@@ -234,7 +448,7 @@ def setup_io_lefs(self) -> None:
                         # Fix
                         if idx_end_broken_macro < idx_start_next_macro:
                             sl[idx_end_broken_macro] = end_fixed_macro
-                
+
                 df.writelines(sl)
 
     def get_tech_par_hooks(self, tool_name: str) -> List[HammerToolHookAction]:

hammer/technology/sky130/defaults.yml

@@ -11,6 +11,9 @@ technology.sky130:
 
   sky130_cds: "/path/to/sky130_cds" # This contains the Cadence PDK
   # this key is OPTIONAL, and is only required if you are running Pegasus DRC/LVS.
+
+  sky130_scl: "/path/to/sky130_cdl" # This contains the Cadence standard cell library
+  # this key is OPTIONAL, and is only required if you want to do Voltus IR drop analysis.
 
   sram22_sky130_macros: "/path/to/sram22_sky130_macros"  # SRAM path
   # /path/to/sram22_sky130_macros
@@ -32,7 +35,8 @@ technology.sky130:
 
   io_file: "extra/efabless_template.io"  # IO ring - take this template and modify for your own use
   io_file_meta: prependlocal
-
+
+  stdcell_library: "sky130_fd_sc_hd"  # Choose between "sky130_fd_sc_hd" (open-source) or "sky130_scl" (Cadence)
 
 mentor.extra_env_vars_meta: lazydeepsubst # Mentor environment variables
 # Override this in project
@@ -109,9 +113,6 @@ synthesis.yosys:
 
 par.inputs:
   gds_merge: true
-  gds_map_mode: manual
-  gds_map_file: "extra/sky130_lefpin.map"
-  gds_map_file_meta: prependlocal
 
 par.openroad:  # openroad setup/files
   setrc_file: "extra/setRC.tcl"