siliconcompiler 0.28.9__py3-none-any.whl → 0.29.1__py3-none-any.whl

siliconcompiler/flows/asicflow.py

@@ -4,13 +4,22 @@ from siliconcompiler.flows._common import setup_multiple_frontends
 from siliconcompiler.flows._common import _make_docs
 
 from siliconcompiler.tools.yosys import syn_asic
-from siliconcompiler.tools.openroad import floorplan
-from siliconcompiler.tools.openroad import physyn
-from siliconcompiler.tools.openroad import place
-from siliconcompiler.tools.openroad import cts
-from siliconcompiler.tools.openroad import route
-from siliconcompiler.tools.openroad import dfm
-from siliconcompiler.tools.openroad import export as openroad_export
+from siliconcompiler.tools.openroad import init_floorplan
+from siliconcompiler.tools.openroad import macro_placement
+from siliconcompiler.tools.openroad import endcap_tapcell_insertion
+from siliconcompiler.tools.openroad import power_grid
+from siliconcompiler.tools.openroad import pin_placement
+from siliconcompiler.tools.openroad import global_placement
+from siliconcompiler.tools.openroad import repair_design
+from siliconcompiler.tools.openroad import detailed_placement
+from siliconcompiler.tools.openroad import clock_tree_synthesis
+from siliconcompiler.tools.openroad import repair_timing
+from siliconcompiler.tools.openroad import fillercell_insertion
+from siliconcompiler.tools.openroad import global_route
+from siliconcompiler.tools.openroad import antenna_repair
+from siliconcompiler.tools.openroad import detailed_route
+from siliconcompiler.tools.openroad import fillmetal_insertion
+from siliconcompiler.tools.openroad import write_data
 from siliconcompiler.tools.klayout import export as klayout_export
 
 from siliconcompiler.tools.builtin import minimum
@@ -70,33 +79,53 @@ def setup(flowname='asicflow',
     flow = siliconcompiler.Flow(flowname)
 
     # Linear flow, up until branch to run parallel verification steps.
-    longpipe = ['syn',
-                'synmin',
-                'floorplan',
-                'floorplanmin',
-                'place',
-                'placemin',
-                'cts',
-                'ctsmin',
-                'route',
-                'routemin',
-                'dfm']
+    longpipe = [
+        'syn',
+        'syn.min',
+        'floorplan.init',
+        'floorplan.macro_placement',
+        'floorplan.tapcell',
+        'floorplan.power_grid',
+        'floorplan.pin_placement',
+        'floorplan.min',
+        'place.global',
+        'place.repair_design',
+        'place.detailed',
+        'place.min',
+        'cts.clock_tree_synthesis',
+        'cts.repair_timing',
+        'cts.fillcell',
+        'cts.min',
+        'route.global',
+        'route.antenna_repair',
+        'route.detailed',
+        'route.min',
+        'dfm.metal_fill'
+    ]
 
     # step --> task
     tasks = {
         'syn': syn_asic,
-        'synmin': minimum,
-        'floorplan': floorplan,
-        'floorplanmin': minimum,
-        'physyn': physyn,
-        'physynmin': minimum,
-        'place': place,
-        'placemin': minimum,
-        'cts': cts,
-        'ctsmin': minimum,
-        'route': route,
-        'routemin': minimum,
-        'dfm': dfm
+        'syn.min': minimum,
+        'floorplan.init': init_floorplan,
+        'floorplan.macro_placement': macro_placement,
+        'floorplan.tapcell': endcap_tapcell_insertion,
+        'floorplan.power_grid': power_grid,
+        'floorplan.pin_placement': pin_placement,
+        'floorplan.min': minimum,
+        'place.global': global_placement,
+        'place.repair_design': repair_design,
+        'place.detailed': detailed_placement,
+        'place.min': minimum,
+        'cts.clock_tree_synthesis': clock_tree_synthesis,
+        'cts.repair_timing': repair_timing,
+        'cts.fillcell': fillercell_insertion,
+        'cts.min': minimum,
+        'route.global': global_route,
+        'route.antenna_repair': antenna_repair,
+        'route.detailed': detailed_route,
+        'route.min': minimum,
+        'dfm.metal_fill': fillmetal_insertion
     }
 
     np = {
@@ -114,7 +143,8 @@ def setup(flowname='asicflow',
     for step in longpipe:
         task = tasks[step]
         if task == minimum:
-            if prevstep in np and np[prevstep] > 1:
+            np_step = prevstep.split('.')[0]
+            if np_step in np and np[np_step] > 1:
                 flowpipe.append(step)
         else:
             flowpipe.append(step)
@@ -126,24 +156,30 @@ def setup(flowname='asicflow',
 
     # Programmatically build linear portion of flowgraph and fanin/fanout args
     prevstep = setup_multiple_frontends(flow)
+    prev_fanout = 1
     for step, task in flowtasks:
         fanout = 1
-        if step in np:
-            fanout = np[step]
+        np_step = step.split('.')[0]
+        if np_step in np and task != minimum:
+            fanout = np[np_step]
+
         # create nodes
         for index in range(fanout):
             # nodes
             flow.node(flowname, step, task, index=index)
 
+        # create edges
+        for index in range(fanout):
             # edges
+            fanin = prev_fanout
             if task == minimum:
-                fanin = 1
-                if prevstep in np:
-                    fanin = np[prevstep]
                 for i in range(fanin):
                     flow.edge(flowname, prevstep, step, tail_index=i)
             elif prevstep:
-                flow.edge(flowname, prevstep, step, head_index=index)
+                if fanin == fanout:
+                    flow.edge(flowname, prevstep, step, tail_index=index, head_index=index)
+                else:
+                    flow.edge(flowname, prevstep, step, head_index=index)
 
             # metrics
             goal_metrics = ()
@@ -151,7 +187,11 @@ def setup(flowname='asicflow',
             if task in (syn_asic, ):
                 goal_metrics = ('errors',)
                 weight_metrics = ()
-            elif task in (floorplan, physyn, place, cts, route, dfm):
+            elif task in (init_floorplan, macro_placement, endcap_tapcell_insertion,
+                          power_grid, pin_placement, global_placement, repair_design,
+                          detailed_placement, clock_tree_synthesis, repair_timing,
+                          fillercell_insertion, global_route, antenna_repair, detailed_route,
+                          fillmetal_insertion):
                 goal_metrics = ('errors', 'setupwns', 'setuptns')
                 weight_metrics = ('cellarea', 'peakpower', 'leakagepower')
 
@@ -160,12 +200,13 @@ def setup(flowname='asicflow',
             for metric in weight_metrics:
                 flow.set('flowgraph', flowname, step, str(index), 'weight', metric, 1.0)
         prevstep = step
+        prev_fanout = fanout
 
     # add write information steps
-    flow.node(flowname, 'write_gds', klayout_export)
-    flow.edge(flowname, prevstep, 'write_gds')
-    flow.node(flowname, 'write_data', openroad_export)
-    flow.edge(flowname, prevstep, 'write_data')
+    flow.node(flowname, 'write.gds', klayout_export)
+    flow.edge(flowname, prevstep, 'write.gds')
+    flow.node(flowname, 'write.views', write_data)
+    flow.edge(flowname, prevstep, 'write.views')
 
     return flow
 

siliconcompiler/flows/showflow.py

@@ -1,12 +1,12 @@
 import siliconcompiler
 from siliconcompiler import SiliconCompilerError
-from siliconcompiler.targets import freepdk45_demo
 
 
 ############################################################################
 # DOCS
 ############################################################################
 def make_docs(chip):
+    from siliconcompiler.targets import freepdk45_demo
     chip.use(freepdk45_demo)
     return setup(filetype='gds', showtools=chip._showtools, np=3)
 

siliconcompiler/libs/__init__.py

@@ -0,0 +1,5 @@
+def get_libs():
+    '''
+    Returns a dict of builtin libraries
+    '''
+    return {}

siliconcompiler/optimizer/__init__.py

@@ -0,0 +1,199 @@
+class Optimizer:
+    def __init__(self, chip):
+        self._chip = chip
+
+        self._parameters = {}
+        self._goals = {}
+        self._assertions = {}
+
+        self.__results = []
+
+    def __generate_print_name(self, key, step, index):
+        name = f'[{",".join(key)}]'
+
+        node_name = None
+        if step is not None:
+            node_name = step
+
+            if index is not None:
+                node_name += f'{index}'
+
+        if node_name:
+            name += f' ({node_name})'
+
+        return name
+
+    def __generate_param_name(self, key, step, index):
+        name = ",".join(key)
+
+        if step is not None:
+            name += f'-step-{step}'
+
+        if index is not None:
+            name += f'-index-{index}'
+
+        return name
+
+    def add_parameter(self, key, values, value_type=None, step=None, index=None):
+        if value_type is None:
+            value_type = self._chip.get(*key, field='type')
+            if value_type.startswith('['):
+                value_type = value_type[1:-1]
+            elif value_type.startswith('('):
+                value_type = value_type[1:-1].split(",")
+                value_type = [value.strip() for value in value_type]
+                if not all([value == value_type[0] for value in value_type]):
+                    raise ValueError("Cannot support unequal tuples")
+                value_type = value_type[0]
+
+        if value_type not in ('float', 'int', 'bool', 'enum', 'str'):
+            raise ValueError(f"{value_type} is not supported")
+
+        if value_type in ('float', 'int'):
+            if 'max' not in values:
+                raise ValueError("value must have a max key")
+            if 'min' not in values:
+                raise ValueError("value must have a min key")
+            values = [values["min"], values["max"]]
+        elif value_type in ('enum', 'str', 'bool'):
+            if not isinstance(values, (tuple, list, set)):
+                raise ValueError("value must be a list")
+            if value_type == 'str':
+                value_type = 'enum'
+
+        if value_type == 'bool' and not values:
+            values = [True, False]
+
+        self._parameters["param-" + self.__generate_param_name(key, step, index)] = {
+            "print": self.__generate_print_name(key, step, index),
+            "key": tuple(key),
+            "type": value_type,
+            "values": tuple(values),
+            "step": step,
+            "index": index
+        }
+
+    def _set_parameter(self, parameter, value, chip, flow_prefix=None):
+        param_entry = self._parameters[parameter]
+
+        self._chip.logger.info(f'  Setting {param_entry["print"]} = {value}')
+        if param_entry["step"]:
+            if not flow_prefix:
+                flow_prefix = ""
+            step = f'{flow_prefix}{param_entry["step"]}'
+        else:
+            step = param_entry["step"]
+
+        key_type = chip.get(*param_entry["key"], field='type')
+        if key_type[0] == "(":
+            key_type = key_type[1:-1].split(",")
+            value = len(key_type) * [value]
+
+        chip.set(
+            *param_entry["key"],
+            value,
+            step=step,
+            index=param_entry["index"])
+
+    def add_assertion(self, key, criteria, step=None, index=None):
+        if not callable(criteria):
+            raise ValueError('criteria must be a function')
+
+        if not step:
+            raise ValueError('step is required')
+
+        if not index:
+            raise ValueError('index is required')
+
+        self._assertions["assert-" + self.__generate_param_name(key, step, index)] = {
+            "print": self.__generate_print_name(key, step, index),
+            "key": tuple(key),
+            "criteria": criteria,
+            "step": step,
+            "index": index
+        }
+
+    def _check_assertions(self, chip, step_prefix):
+        if not step_prefix:
+            step_prefix = ""
+
+        for info in self._assertions.values():
+            value = chip.get(
+                *info["key"],
+                step=f'{step_prefix}{info["step"]}',
+                index=info["index"])
+            if not info["criteria"](value):
+                self._chip.logger.error(f"Failed to meet assertion: {info['print']} with {value}")
+                return False
+
+        return True
+
+    def add_goal(self, key, goal, stop_goal=None, step=None, index=None):
+        if goal not in ('min', 'max'):
+            raise ValueError(f"{goal} is not supported")
+
+        if not step:
+            raise ValueError('step is required')
+
+        if not index:
+            raise ValueError('index is required')
+
+        self._goals["goal-" + self.__generate_param_name(key, step, index)] = {
+            "print": self.__generate_print_name(key, step, index),
+            "key": tuple(key),
+            "goal": goal,
+            "stop": stop_goal,
+            "step": step,
+            "index": index
+        }
+
+    def _check_stop_goal(self, measurements):
+        cont = []
+
+        for param, info in self._goals.items():
+            if info["stop"] is None:
+                continue
+
+            if param not in measurements:
+                cont.append(False)
+                continue
+
+            if info["goal"] == "min":
+                if measurements[param] <= info["stop"]:
+                    cont.append(True)
+            elif info["goal"] == "max":
+                if measurements[param] >= info["stop"]:
+                    cont.append(True)
+
+        if not cont:
+            return False
+
+        return all(cont)
+
+    def run(self, experiments=None, parallel=None):
+        raise NotImplementedError
+
+    def _clear_results(self):
+        self.__results.clear()
+
+    def _add_result(self, parameters, measurements):
+        self.__results.append({
+            "parameters": parameters,
+            "measurements": measurements
+        })
+
+    def report(self, count=None):
+        for n, result in enumerate(self.__results):
+            if count and n >= count:
+                return
+
+            self._chip.logger.info(f"Result {n+1} / {len(self.__results)}:")
+            self._chip.logger.info("  Parameters:")
+            for param_name, param_key in result["parameters"].items():
+                param_print = self._parameters[param_name]['print']
+                self._chip.logger.info(f"    {param_print} = {param_key}")
+
+            self._chip.logger.info("  Measurements:")
+            for meas_name, meas_key in result["measurements"].metrics.items():
+                goal_print = self._goals[meas_name]['print']
+                self._chip.logger.info(f"    {goal_print} = {meas_key.value}")

siliconcompiler/optimizer/vizier.py

@@ -0,0 +1,259 @@
+import logging
+import uuid
+import math
+from siliconcompiler import Chip
+from siliconcompiler.optimizer import Optimizer
+from siliconcompiler.flowgraph import _get_flowgraph_nodes
+
+try:
+    from vizier.service import clients as vz_clients
+    from vizier.service import pyvizier as vz
+
+    from jax import config
+    config.update("jax_enable_x64", True)
+    _has_vizier = True
+
+    logging.getLogger('absl').setLevel(logging.CRITICAL)
+    logging.getLogger('jax').setLevel(logging.CRITICAL)
+except ModuleNotFoundError:
+    _has_vizier = False
+
+
+class VizierOptimizier(Optimizer):
+    def __init__(self, chip):
+        if not _has_vizier:
+            raise RuntimeError("vizier is not available")
+
+        super().__init__(chip)
+
+        self.__problem = None
+        self.__study = None
+
+        self.__owner = chip.design
+        self.__experiment_rounds = None
+        self.__parallel_experiment = None
+
+    def __init_parameters(self):
+        search_space = self.__problem.search_space.root
+        for name, info in self._parameters.items():
+            values = info["values"]
+            if info["type"] == 'float':
+                search_space.add_float_param(name, values[0], values[1])
+            elif info["type"] == 'int':
+                search_space.add_int_param(name, values[0], values[1])
+            elif info["type"] == 'bool':
+                search_space.add_discrete_param(name, values)
+            elif info["type"] == 'enum':
+                if any([isinstance(v, str) for v in values]):
+                    search_space.add_categorical_param(name, values)
+                else:
+                    search_space.add_discrete_param(name, values)
+
+    def __init_goals(self):
+        metric_information = self.__problem.metric_information
+
+        for name, info in self._goals.items():
+
+            vz_goal = None
+            if info["goal"] == 'max':
+                vz_goal = vz.ObjectiveMetricGoal.MAXIMIZE
+            elif info["goal"] == 'min':
+                vz_goal = vz.ObjectiveMetricGoal.MINIMIZE
+            else:
+                raise ValueError(f'{info["goal"]} is not a supported goal')
+
+            metric_information.append(vz.MetricInformation(name, goal=vz_goal))
+
+    def __init_study(self):
+        # Setup client and begin optimization
+        # Vizier Service will be implicitly created
+        study_config = vz.StudyConfig.from_problem(self.__problem)
+        study_config.algorithm = 'DEFAULT'
+        if len(self._goals) > 1:
+            if self.__parallel_experiment == 1:
+                study_config.algorithm = 'GAUSSIAN_PROCESS_BANDIT'
+            else:
+                study_config.algorithm = 'QUASI_RANDOM_SEARCH'
+
+        self.__study = vz_clients.Study.from_study_config(
+            study_config,
+            owner=self.__owner,
+            study_id=uuid.uuid4().hex)
+
+    def run(self, experiments=None, parallel=None):
+        if not experiments:
+            experiments = 10 * len(self._parameters)
+            self._chip.logger.debug(f'Setting number of optimizer experiments to {experiments}')
+
+        if not parallel:
+            parallel = 1
+
+        self.__parallel_experiment = parallel
+
+        # Algorithm, search space, and metrics.
+        self.__problem = vz.ProblemStatement()
+
+        self._clear_results()
+
+        self.__init_parameters()
+        self.__init_goals()
+
+        self.__init_study()
+
+        self.__experiment_rounds = int(math.ceil(float(experiments) / parallel))
+        accept = True
+        try:
+            for n in range(self.__experiment_rounds):
+                if self.__run_round(n):
+                    break
+        except KeyboardInterrupt:
+            pass
+        except Exception as e:
+            self._chip.logger.error(f"{e}")
+            accept = False
+        finally:
+            if accept:
+                self.__record_optimal()
+
+            self.__study.delete()
+            self.__study = None
+
+    def __run_round(self, experiment_round):
+        # create a new chip with a copy of its schema
+        chip = Chip(self._chip.design)
+        chip.schema = self._chip.schema.copy()
+
+        suggestions = self.__setup_round(experiment_round, chip)
+
+        # Start run
+        try:
+            chip.logger.info(
+                f"Starting optimizer run ({experiment_round+1} / {self.__experiment_rounds})")
+            chip.run()
+        except KeyboardInterrupt:
+            raise
+        except Exception as e:
+            chip.logger.error(f"{e}")
+
+        return self.__record_round(chip, suggestions)
+
+    def __setup_round(self, experiment_round, chip):
+        org_flow = self._chip.get("option", "flow")
+        org_jobname = self._chip.get("option", "jobname")
+
+        jobname = f"{org_jobname}-{org_flow}-{experiment_round+1}"
+
+        flow_map = {}
+
+        if self.__parallel_experiment > 1:
+            flow = f'optimize_{org_flow}'
+            # Create new graph
+            for m in range(self.__parallel_experiment):
+                graph_name = f'opt{m+1}'
+                flow_map[m] = {
+                    "name": f'{jobname}/{graph_name}',
+                    "prefix": f"{graph_name}.",
+                    "suggestion": None
+                }
+                chip.graph(flow, org_flow, name=graph_name)
+
+            # Complete nodes
+            nodes = _get_flowgraph_nodes(chip, org_flow)
+            for step, _ in list(nodes):
+                nodes.append((step, None))
+            nodes = set(nodes)
+
+            # Forward node specific values
+            for key in chip.schema.allkeys():
+                if key[0] == 'history':
+                    continue
+
+                for value, step, index in chip.schema._getvals(*key):
+                    node = (step, index)
+
+                    if node in nodes:
+                        for info in flow_map.values():
+                            chip.set(
+                                *key,
+                                value,
+                                step=f'{info["prefix"]}{step}',
+                                index=index)
+        else:
+            flow = org_flow
+            flow_map[0] = {
+                "name": jobname,
+                "prefix": "",
+                "suggestion": None
+            }
+
+        # Setup each experiment
+        for m, suggestion in enumerate(self.__study.suggest(count=self.__parallel_experiment)):
+            self._chip.logger.info(f'Setting parameters for {flow_map[m]["name"]}')
+            flow_map[m]["suggestion"] = suggestion
+
+            for param_name, param_value in suggestion.parameters.items():
+                self._set_parameter(
+                    param_name,
+                    param_value,
+                    chip,
+                    flow_prefix=flow_map[m]["prefix"])
+
+        chip.set('option', 'jobname', jobname)
+        chip.set('option', 'flow', flow)
+        chip.set('option', 'quiet', True)
+
+        steps = set()
+        for info in list(self._goals.values()) + list(self._assertions.values()):
+            for flow in flow_map.values():
+                steps.add(f'{flow["prefix"]}{info["step"]}')
+        chip.set('option', 'to', steps)
+
+        return flow_map
+
+    def __record_round(self, chip, suggestions):
+        jobname = chip.get('option', 'jobname')
+
+        # Record history
+        self._chip.schema.cfg['history'][jobname] = chip.schema.history(jobname).cfg
+
+        stop = False
+
+        for trial_entry in suggestions.values():
+            trial_suggestion = trial_entry['suggestion']
+
+            measurement = {}
+            self._chip.logger.info(f'Measuring {trial_entry["name"]}')
+            for meas_name, meas_entry in self._goals.items():
+                measurement[meas_name] = chip.get(
+                    *meas_entry["key"],
+                    step=f'{trial_entry["prefix"]}{meas_entry["step"]}',
+                    index=meas_entry["index"])
+
+                self._chip.logger.info(f'  Measured {meas_entry["print"]} = '
+                                       f'{measurement[meas_name]}')
+
+            failed = None
+            if any([value is None for value in measurement.values()]):
+                failed = "Did not record measurement goal"
+            elif not self._check_assertions(chip, trial_entry["prefix"]):
+                failed = "Failed to meet assertions"
+
+            if failed:
+                self._chip.logger.error(f'{trial_entry["name"]} failed: {failed}')
+                trial_suggestion.complete(vz.Measurement(),
+                                          infeasible_reason=failed)
+            else:
+                trial_suggestion.complete(vz.Measurement(measurement))
+                stop |= self._check_stop_goal(measurement)
+
+        return stop
+
+    def __record_optimal(self):
+        optimal_trials = list(self.__study.optimal_trials())
+        for n, optimal_trial in enumerate(optimal_trials):
+            optimal_trial = optimal_trial.materialize()
+
+            self._add_result(
+                optimal_trial.parameters,
+                optimal_trial.final_measurement
+            )

siliconcompiler/pdks/__init__.py

@@ -0,0 +1,5 @@
+def get_pdks():
+    '''
+    Returns a dict of builtin pdks
+    '''
+    return {}

siliconcompiler/remote/__init__.py

@@ -34,3 +34,14 @@ class JobStatus():
     TIMEOUT = "timeout"
 
     UNKNOWN = "unknown"
+
+
+from siliconcompiler.remote.client import Client, ConfigureClient # noqa E402
+
+
+__all__ = [
+    "NodeStatus",
+    "JobStatus",
+    "Client",
+    "ConfigureClient"
+]