2. Pre-Defined Flows#

The following are examples are pre-built flows that come with SiliconCompiler which you can use for your own builds.

See the pre-built targets for examples on how these are used in conjunction with pdks, tools and libraries.

2.1. asicflow#

A configurable ASIC compilation flow.

This flow targets ASIC designs, taking RTL through a complete synthesis, place-and-route, and finishing flow.

The flow is divided into the following major steps:

elaborate: RTL elaboration using Slang.

synthesis: RTL synthesis using Yosys.

floorplan: Floorplanning, including macro placement, tapcell/endcap
insertion, power grid generation, and pin placement.

place: Global and detailed placement.

cts: Clock tree synthesis and post-CTS timing repair.

route: Global and detailed routing.

dfm: Design-for-manufacturing steps, primarily metal fill.

write: Writing out final views of the design (GDSII, etc.).

The synthesis, floorplan, place, cts, and route steps support parallel execution to explore different strategies. This can be configured by setting the corresponding ‘_np’ argument to a value greater than 1.

Args:

syn_np (int): Number of parallel synthesis jobs to launch.
floorplan_np (int): Number of parallel floorplan jobs to launch.
place_np (int): Number of parallel placement jobs to launch.
cts_np (int): Number of parallel clock tree synthesis jobs to launch.
route_np (int): Number of parallel routing jobs to launch.

File: asicflow.py

2.1.1. Graph#

2.1.2. Nodes#

2.1.2.1. elaborate/0#

Keypath	Type	Value
`[flowgraph,asicflow,elaborate,0,task]`	`str`	`elaborate`
`[flowgraph,asicflow,elaborate,0,taskmodule]`	`str`	`siliconcompiler.tools.slang.elaborate/Elaborate`
`[flowgraph,asicflow,elaborate,0,tool]`	`str`	`slang`

2.1.2.2. synthesis/0#

Keypath	Type	Value
`[flowgraph,asicflow,synthesis,0,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,asicflow,synthesis,0,task]`	`str`	`syn_asic`
`[flowgraph,asicflow,synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,asicflow,synthesis,0,tool]`	`str`	`yosys`

2.1.2.3. synthesis/1#

Keypath	Type	Value
`[flowgraph,asicflow,synthesis,1,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,asicflow,synthesis,1,task]`	`str`	`syn_asic`
`[flowgraph,asicflow,synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,asicflow,synthesis,1,tool]`	`str`	`yosys`

2.1.2.4. synthesis/2#

Keypath	Type	Value
`[flowgraph,asicflow,synthesis,2,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,asicflow,synthesis,2,task]`	`str`	`syn_asic`
`[flowgraph,asicflow,synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,asicflow,synthesis,2,tool]`	`str`	`yosys`

2.1.2.5. synthesis.min/0#

Keypath	Type	Value
`[flowgraph,asicflow,synthesis.min,0,input]`	`[(str,str)]`	`('synthesis', '0')` `('synthesis', '1')` `('synthesis', '2')`
`[flowgraph,asicflow,synthesis.min,0,task]`	`str`	`minimum`
`[flowgraph,asicflow,synthesis.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,asicflow,synthesis.min,0,tool]`	`str`	`builtin`

2.1.2.6. floorplan.init/0#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.init,0,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,asicflow,floorplan.init,0,task]`	`str`	`init_floorplan`
`[flowgraph,asicflow,floorplan.init,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,asicflow,floorplan.init,0,tool]`	`str`	`openroad`

2.1.2.7. floorplan.init/1#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.init,1,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,asicflow,floorplan.init,1,task]`	`str`	`init_floorplan`
`[flowgraph,asicflow,floorplan.init,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,asicflow,floorplan.init,1,tool]`	`str`	`openroad`

2.1.2.8. floorplan.init/2#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.init,2,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,asicflow,floorplan.init,2,task]`	`str`	`init_floorplan`
`[flowgraph,asicflow,floorplan.init,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,asicflow,floorplan.init,2,tool]`	`str`	`openroad`

2.1.2.9. floorplan.macro_placement/0#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.macro_placement,0,input]`	`[(str,str)]`	`('floorplan.init', '0')`
`[flowgraph,asicflow,floorplan.macro_placement,0,task]`	`str`	`macro_placement`
`[flowgraph,asicflow,floorplan.macro_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,asicflow,floorplan.macro_placement,0,tool]`	`str`	`openroad`

2.1.2.10. floorplan.macro_placement/1#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.macro_placement,1,input]`	`[(str,str)]`	`('floorplan.init', '1')`
`[flowgraph,asicflow,floorplan.macro_placement,1,task]`	`str`	`macro_placement`
`[flowgraph,asicflow,floorplan.macro_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,asicflow,floorplan.macro_placement,1,tool]`	`str`	`openroad`

2.1.2.11. floorplan.macro_placement/2#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.macro_placement,2,input]`	`[(str,str)]`	`('floorplan.init', '2')`
`[flowgraph,asicflow,floorplan.macro_placement,2,task]`	`str`	`macro_placement`
`[flowgraph,asicflow,floorplan.macro_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,asicflow,floorplan.macro_placement,2,tool]`	`str`	`openroad`

2.1.2.12. floorplan.tapcell/0#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.tapcell,0,input]`	`[(str,str)]`	`('floorplan.macro_placement', '0')`
`[flowgraph,asicflow,floorplan.tapcell,0,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,asicflow,floorplan.tapcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,asicflow,floorplan.tapcell,0,tool]`	`str`	`openroad`

2.1.2.13. floorplan.tapcell/1#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.tapcell,1,input]`	`[(str,str)]`	`('floorplan.macro_placement', '1')`
`[flowgraph,asicflow,floorplan.tapcell,1,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,asicflow,floorplan.tapcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,asicflow,floorplan.tapcell,1,tool]`	`str`	`openroad`

2.1.2.14. floorplan.tapcell/2#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.tapcell,2,input]`	`[(str,str)]`	`('floorplan.macro_placement', '2')`
`[flowgraph,asicflow,floorplan.tapcell,2,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,asicflow,floorplan.tapcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,asicflow,floorplan.tapcell,2,tool]`	`str`	`openroad`

2.1.2.15. floorplan.power_grid/0#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.power_grid,0,input]`	`[(str,str)]`	`('floorplan.tapcell', '0')`
`[flowgraph,asicflow,floorplan.power_grid,0,task]`	`str`	`power_grid`
`[flowgraph,asicflow,floorplan.power_grid,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,asicflow,floorplan.power_grid,0,tool]`	`str`	`openroad`

2.1.2.16. floorplan.power_grid/1#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.power_grid,1,input]`	`[(str,str)]`	`('floorplan.tapcell', '1')`
`[flowgraph,asicflow,floorplan.power_grid,1,task]`	`str`	`power_grid`
`[flowgraph,asicflow,floorplan.power_grid,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,asicflow,floorplan.power_grid,1,tool]`	`str`	`openroad`

2.1.2.17. floorplan.power_grid/2#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.power_grid,2,input]`	`[(str,str)]`	`('floorplan.tapcell', '2')`
`[flowgraph,asicflow,floorplan.power_grid,2,task]`	`str`	`power_grid`
`[flowgraph,asicflow,floorplan.power_grid,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,asicflow,floorplan.power_grid,2,tool]`	`str`	`openroad`

2.1.2.18. floorplan.pin_placement/0#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.pin_placement,0,input]`	`[(str,str)]`	`('floorplan.power_grid', '0')`
`[flowgraph,asicflow,floorplan.pin_placement,0,task]`	`str`	`pin_placement`
`[flowgraph,asicflow,floorplan.pin_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,asicflow,floorplan.pin_placement,0,tool]`	`str`	`openroad`

2.1.2.19. floorplan.pin_placement/1#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.pin_placement,1,input]`	`[(str,str)]`	`('floorplan.power_grid', '1')`
`[flowgraph,asicflow,floorplan.pin_placement,1,task]`	`str`	`pin_placement`
`[flowgraph,asicflow,floorplan.pin_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,asicflow,floorplan.pin_placement,1,tool]`	`str`	`openroad`

2.1.2.20. floorplan.pin_placement/2#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.pin_placement,2,input]`	`[(str,str)]`	`('floorplan.power_grid', '2')`
`[flowgraph,asicflow,floorplan.pin_placement,2,task]`	`str`	`pin_placement`
`[flowgraph,asicflow,floorplan.pin_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,asicflow,floorplan.pin_placement,2,tool]`	`str`	`openroad`

2.1.2.21. floorplan.min/0#

Keypath	Type	Value
`[flowgraph,asicflow,floorplan.min,0,input]`	`[(str,str)]`	`('floorplan.pin_placement', '0')` `('floorplan.pin_placement', '1')` `('floorplan.pin_placement', '2')`
`[flowgraph,asicflow,floorplan.min,0,task]`	`str`	`minimum`
`[flowgraph,asicflow,floorplan.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,asicflow,floorplan.min,0,tool]`	`str`	`builtin`

2.1.2.22. place.global/0#

Keypath	Type	Value
`[flowgraph,asicflow,place.global,0,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,asicflow,place.global,0,task]`	`str`	`global_placement`
`[flowgraph,asicflow,place.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,asicflow,place.global,0,tool]`	`str`	`openroad`

2.1.2.23. place.global/1#

Keypath	Type	Value
`[flowgraph,asicflow,place.global,1,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,asicflow,place.global,1,task]`	`str`	`global_placement`
`[flowgraph,asicflow,place.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,asicflow,place.global,1,tool]`	`str`	`openroad`

2.1.2.24. place.global/2#

Keypath	Type	Value
`[flowgraph,asicflow,place.global,2,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,asicflow,place.global,2,task]`	`str`	`global_placement`
`[flowgraph,asicflow,place.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,asicflow,place.global,2,tool]`	`str`	`openroad`

2.1.2.25. place.repair_design/0#

Keypath	Type	Value
`[flowgraph,asicflow,place.repair_design,0,input]`	`[(str,str)]`	`('place.global', '0')`
`[flowgraph,asicflow,place.repair_design,0,task]`	`str`	`repair_design`
`[flowgraph,asicflow,place.repair_design,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,asicflow,place.repair_design,0,tool]`	`str`	`openroad`

2.1.2.26. place.repair_design/1#

Keypath	Type	Value
`[flowgraph,asicflow,place.repair_design,1,input]`	`[(str,str)]`	`('place.global', '1')`
`[flowgraph,asicflow,place.repair_design,1,task]`	`str`	`repair_design`
`[flowgraph,asicflow,place.repair_design,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,asicflow,place.repair_design,1,tool]`	`str`	`openroad`

2.1.2.27. place.repair_design/2#

Keypath	Type	Value
`[flowgraph,asicflow,place.repair_design,2,input]`	`[(str,str)]`	`('place.global', '2')`
`[flowgraph,asicflow,place.repair_design,2,task]`	`str`	`repair_design`
`[flowgraph,asicflow,place.repair_design,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,asicflow,place.repair_design,2,tool]`	`str`	`openroad`

2.1.2.28. place.detailed/0#

Keypath	Type	Value
`[flowgraph,asicflow,place.detailed,0,input]`	`[(str,str)]`	`('place.repair_design', '0')`
`[flowgraph,asicflow,place.detailed,0,task]`	`str`	`detailed_placement`
`[flowgraph,asicflow,place.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,asicflow,place.detailed,0,tool]`	`str`	`openroad`

2.1.2.29. place.detailed/1#

Keypath	Type	Value
`[flowgraph,asicflow,place.detailed,1,input]`	`[(str,str)]`	`('place.repair_design', '1')`
`[flowgraph,asicflow,place.detailed,1,task]`	`str`	`detailed_placement`
`[flowgraph,asicflow,place.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,asicflow,place.detailed,1,tool]`	`str`	`openroad`

2.1.2.30. place.detailed/2#

Keypath	Type	Value
`[flowgraph,asicflow,place.detailed,2,input]`	`[(str,str)]`	`('place.repair_design', '2')`
`[flowgraph,asicflow,place.detailed,2,task]`	`str`	`detailed_placement`
`[flowgraph,asicflow,place.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,asicflow,place.detailed,2,tool]`	`str`	`openroad`

2.1.2.31. place.min/0#

Keypath	Type	Value
`[flowgraph,asicflow,place.min,0,input]`	`[(str,str)]`	`('place.detailed', '0')` `('place.detailed', '1')` `('place.detailed', '2')`
`[flowgraph,asicflow,place.min,0,task]`	`str`	`minimum`
`[flowgraph,asicflow,place.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,asicflow,place.min,0,tool]`	`str`	`builtin`

2.1.2.32. cts.clock_tree_synthesis/0#

Keypath	Type	Value
`[flowgraph,asicflow,cts.clock_tree_synthesis,0,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,asicflow,cts.clock_tree_synthesis,0,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,asicflow,cts.clock_tree_synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,asicflow,cts.clock_tree_synthesis,0,tool]`	`str`	`openroad`

2.1.2.33. cts.clock_tree_synthesis/1#

Keypath	Type	Value
`[flowgraph,asicflow,cts.clock_tree_synthesis,1,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,asicflow,cts.clock_tree_synthesis,1,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,asicflow,cts.clock_tree_synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,asicflow,cts.clock_tree_synthesis,1,tool]`	`str`	`openroad`

2.1.2.34. cts.clock_tree_synthesis/2#

Keypath	Type	Value
`[flowgraph,asicflow,cts.clock_tree_synthesis,2,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,asicflow,cts.clock_tree_synthesis,2,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,asicflow,cts.clock_tree_synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,asicflow,cts.clock_tree_synthesis,2,tool]`	`str`	`openroad`

2.1.2.35. cts.repair_timing/0#

Keypath	Type	Value
`[flowgraph,asicflow,cts.repair_timing,0,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '0')`
`[flowgraph,asicflow,cts.repair_timing,0,task]`	`str`	`repair_timing`
`[flowgraph,asicflow,cts.repair_timing,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,asicflow,cts.repair_timing,0,tool]`	`str`	`openroad`

2.1.2.36. cts.repair_timing/1#

Keypath	Type	Value
`[flowgraph,asicflow,cts.repair_timing,1,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '1')`
`[flowgraph,asicflow,cts.repair_timing,1,task]`	`str`	`repair_timing`
`[flowgraph,asicflow,cts.repair_timing,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,asicflow,cts.repair_timing,1,tool]`	`str`	`openroad`

2.1.2.37. cts.repair_timing/2#

Keypath	Type	Value
`[flowgraph,asicflow,cts.repair_timing,2,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '2')`
`[flowgraph,asicflow,cts.repair_timing,2,task]`	`str`	`repair_timing`
`[flowgraph,asicflow,cts.repair_timing,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,asicflow,cts.repair_timing,2,tool]`	`str`	`openroad`

2.1.2.38. cts.fillcell/0#

Keypath	Type	Value
`[flowgraph,asicflow,cts.fillcell,0,input]`	`[(str,str)]`	`('cts.repair_timing', '0')`
`[flowgraph,asicflow,cts.fillcell,0,task]`	`str`	`fillercell_insertion`
`[flowgraph,asicflow,cts.fillcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,asicflow,cts.fillcell,0,tool]`	`str`	`openroad`

2.1.2.39. cts.fillcell/1#

Keypath	Type	Value
`[flowgraph,asicflow,cts.fillcell,1,input]`	`[(str,str)]`	`('cts.repair_timing', '1')`
`[flowgraph,asicflow,cts.fillcell,1,task]`	`str`	`fillercell_insertion`
`[flowgraph,asicflow,cts.fillcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,asicflow,cts.fillcell,1,tool]`	`str`	`openroad`

2.1.2.40. cts.fillcell/2#

Keypath	Type	Value
`[flowgraph,asicflow,cts.fillcell,2,input]`	`[(str,str)]`	`('cts.repair_timing', '2')`
`[flowgraph,asicflow,cts.fillcell,2,task]`	`str`	`fillercell_insertion`
`[flowgraph,asicflow,cts.fillcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,asicflow,cts.fillcell,2,tool]`	`str`	`openroad`

2.1.2.41. cts.min/0#

Keypath	Type	Value
`[flowgraph,asicflow,cts.min,0,input]`	`[(str,str)]`	`('cts.fillcell', '0')` `('cts.fillcell', '1')` `('cts.fillcell', '2')`
`[flowgraph,asicflow,cts.min,0,task]`	`str`	`minimum`
`[flowgraph,asicflow,cts.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,asicflow,cts.min,0,tool]`	`str`	`builtin`

2.1.2.42. route.global/0#

Keypath	Type	Value
`[flowgraph,asicflow,route.global,0,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,asicflow,route.global,0,task]`	`str`	`global_route`
`[flowgraph,asicflow,route.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,asicflow,route.global,0,tool]`	`str`	`openroad`

2.1.2.43. route.global/1#

Keypath	Type	Value
`[flowgraph,asicflow,route.global,1,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,asicflow,route.global,1,task]`	`str`	`global_route`
`[flowgraph,asicflow,route.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,asicflow,route.global,1,tool]`	`str`	`openroad`

2.1.2.44. route.global/2#

Keypath	Type	Value
`[flowgraph,asicflow,route.global,2,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,asicflow,route.global,2,task]`	`str`	`global_route`
`[flowgraph,asicflow,route.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,asicflow,route.global,2,tool]`	`str`	`openroad`

2.1.2.45. route.antenna_repair/0#

Keypath	Type	Value
`[flowgraph,asicflow,route.antenna_repair,0,input]`	`[(str,str)]`	`('route.global', '0')`
`[flowgraph,asicflow,route.antenna_repair,0,task]`	`str`	`antenna_repair`
`[flowgraph,asicflow,route.antenna_repair,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,asicflow,route.antenna_repair,0,tool]`	`str`	`openroad`

2.1.2.46. route.antenna_repair/1#

Keypath	Type	Value
`[flowgraph,asicflow,route.antenna_repair,1,input]`	`[(str,str)]`	`('route.global', '1')`
`[flowgraph,asicflow,route.antenna_repair,1,task]`	`str`	`antenna_repair`
`[flowgraph,asicflow,route.antenna_repair,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,asicflow,route.antenna_repair,1,tool]`	`str`	`openroad`

2.1.2.47. route.antenna_repair/2#

Keypath	Type	Value
`[flowgraph,asicflow,route.antenna_repair,2,input]`	`[(str,str)]`	`('route.global', '2')`
`[flowgraph,asicflow,route.antenna_repair,2,task]`	`str`	`antenna_repair`
`[flowgraph,asicflow,route.antenna_repair,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,asicflow,route.antenna_repair,2,tool]`	`str`	`openroad`

2.1.2.48. route.detailed/0#

Keypath	Type	Value
`[flowgraph,asicflow,route.detailed,0,input]`	`[(str,str)]`	`('route.antenna_repair', '0')`
`[flowgraph,asicflow,route.detailed,0,task]`	`str`	`detailed_route`
`[flowgraph,asicflow,route.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,asicflow,route.detailed,0,tool]`	`str`	`openroad`

2.1.2.49. route.detailed/1#

Keypath	Type	Value
`[flowgraph,asicflow,route.detailed,1,input]`	`[(str,str)]`	`('route.antenna_repair', '1')`
`[flowgraph,asicflow,route.detailed,1,task]`	`str`	`detailed_route`
`[flowgraph,asicflow,route.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,asicflow,route.detailed,1,tool]`	`str`	`openroad`

2.1.2.50. route.detailed/2#

Keypath	Type	Value
`[flowgraph,asicflow,route.detailed,2,input]`	`[(str,str)]`	`('route.antenna_repair', '2')`
`[flowgraph,asicflow,route.detailed,2,task]`	`str`	`detailed_route`
`[flowgraph,asicflow,route.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,asicflow,route.detailed,2,tool]`	`str`	`openroad`

2.1.2.51. route.min/0#

Keypath	Type	Value
`[flowgraph,asicflow,route.min,0,input]`	`[(str,str)]`	`('route.detailed', '0')` `('route.detailed', '1')` `('route.detailed', '2')`
`[flowgraph,asicflow,route.min,0,task]`	`str`	`minimum`
`[flowgraph,asicflow,route.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,asicflow,route.min,0,tool]`	`str`	`builtin`

2.1.2.52. dfm.metal_fill/0#

Keypath	Type	Value
`[flowgraph,asicflow,dfm.metal_fill,0,input]`	`[(str,str)]`	`('route.min', '0')`
`[flowgraph,asicflow,dfm.metal_fill,0,task]`	`str`	`fillmetal_insertion`
`[flowgraph,asicflow,dfm.metal_fill,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillmetal_insertion/FillMetalTask`
`[flowgraph,asicflow,dfm.metal_fill,0,tool]`	`str`	`openroad`

2.1.2.53. write.gds/0#

Keypath	Type	Value
`[flowgraph,asicflow,write.gds,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,asicflow,write.gds,0,task]`	`str`	`export`
`[flowgraph,asicflow,write.gds,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.export/ExportTask`
`[flowgraph,asicflow,write.gds,0,tool]`	`str`	`klayout`

2.1.2.54. write.views/0#

Keypath	Type	Value
`[flowgraph,asicflow,write.views,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,asicflow,write.views,0,task]`	`str`	`write_data`
`[flowgraph,asicflow,write.views,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.write_data/WriteViewsTask`
`[flowgraph,asicflow,write.views,0,tool]`	`str`	`openroad`

2.2. hlsasicflow#

A High-Level Synthesis (HLS) extension of the ASICFlow.

This class inherits from ASICFlow and modifies it to support C-based HLS. It replaces the initial ‘elaborate’ step with a ‘convert’ step, which handles the conversion of HLS C code to RTL using the Bambu tool.

File: asicflow.py

2.2.1. Graph#

2.2.2. Nodes#

2.2.2.1. convert/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,convert,0,task]`	`str`	`convert`
`[flowgraph,hlsasicflow,convert,0,taskmodule]`	`str`	`siliconcompiler.tools.bambu.convert/ConvertTask`
`[flowgraph,hlsasicflow,convert,0,tool]`	`str`	`bambu`

2.2.2.2. synthesis/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,synthesis,0,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,hlsasicflow,synthesis,0,task]`	`str`	`syn_asic`
`[flowgraph,hlsasicflow,synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,hlsasicflow,synthesis,0,tool]`	`str`	`yosys`

2.2.2.3. synthesis/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,synthesis,1,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,hlsasicflow,synthesis,1,task]`	`str`	`syn_asic`
`[flowgraph,hlsasicflow,synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,hlsasicflow,synthesis,1,tool]`	`str`	`yosys`

2.2.2.4. synthesis/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,synthesis,2,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,hlsasicflow,synthesis,2,task]`	`str`	`syn_asic`
`[flowgraph,hlsasicflow,synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,hlsasicflow,synthesis,2,tool]`	`str`	`yosys`

2.2.2.5. synthesis.min/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,synthesis.min,0,input]`	`[(str,str)]`	`('synthesis', '0')` `('synthesis', '1')` `('synthesis', '2')`
`[flowgraph,hlsasicflow,synthesis.min,0,task]`	`str`	`minimum`
`[flowgraph,hlsasicflow,synthesis.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,hlsasicflow,synthesis.min,0,tool]`	`str`	`builtin`

2.2.2.6. floorplan.init/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.init,0,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,hlsasicflow,floorplan.init,0,task]`	`str`	`init_floorplan`
`[flowgraph,hlsasicflow,floorplan.init,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,hlsasicflow,floorplan.init,0,tool]`	`str`	`openroad`

2.2.2.7. floorplan.init/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.init,1,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,hlsasicflow,floorplan.init,1,task]`	`str`	`init_floorplan`
`[flowgraph,hlsasicflow,floorplan.init,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,hlsasicflow,floorplan.init,1,tool]`	`str`	`openroad`

2.2.2.8. floorplan.init/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.init,2,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,hlsasicflow,floorplan.init,2,task]`	`str`	`init_floorplan`
`[flowgraph,hlsasicflow,floorplan.init,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,hlsasicflow,floorplan.init,2,tool]`	`str`	`openroad`

2.2.2.9. floorplan.macro_placement/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.macro_placement,0,input]`	`[(str,str)]`	`('floorplan.init', '0')`
`[flowgraph,hlsasicflow,floorplan.macro_placement,0,task]`	`str`	`macro_placement`
`[flowgraph,hlsasicflow,floorplan.macro_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,hlsasicflow,floorplan.macro_placement,0,tool]`	`str`	`openroad`

2.2.2.10. floorplan.macro_placement/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.macro_placement,1,input]`	`[(str,str)]`	`('floorplan.init', '1')`
`[flowgraph,hlsasicflow,floorplan.macro_placement,1,task]`	`str`	`macro_placement`
`[flowgraph,hlsasicflow,floorplan.macro_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,hlsasicflow,floorplan.macro_placement,1,tool]`	`str`	`openroad`

2.2.2.11. floorplan.macro_placement/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.macro_placement,2,input]`	`[(str,str)]`	`('floorplan.init', '2')`
`[flowgraph,hlsasicflow,floorplan.macro_placement,2,task]`	`str`	`macro_placement`
`[flowgraph,hlsasicflow,floorplan.macro_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,hlsasicflow,floorplan.macro_placement,2,tool]`	`str`	`openroad`

2.2.2.12. floorplan.tapcell/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.tapcell,0,input]`	`[(str,str)]`	`('floorplan.macro_placement', '0')`
`[flowgraph,hlsasicflow,floorplan.tapcell,0,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,hlsasicflow,floorplan.tapcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,hlsasicflow,floorplan.tapcell,0,tool]`	`str`	`openroad`

2.2.2.13. floorplan.tapcell/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.tapcell,1,input]`	`[(str,str)]`	`('floorplan.macro_placement', '1')`
`[flowgraph,hlsasicflow,floorplan.tapcell,1,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,hlsasicflow,floorplan.tapcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,hlsasicflow,floorplan.tapcell,1,tool]`	`str`	`openroad`

2.2.2.14. floorplan.tapcell/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.tapcell,2,input]`	`[(str,str)]`	`('floorplan.macro_placement', '2')`
`[flowgraph,hlsasicflow,floorplan.tapcell,2,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,hlsasicflow,floorplan.tapcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,hlsasicflow,floorplan.tapcell,2,tool]`	`str`	`openroad`

2.2.2.15. floorplan.power_grid/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.power_grid,0,input]`	`[(str,str)]`	`('floorplan.tapcell', '0')`
`[flowgraph,hlsasicflow,floorplan.power_grid,0,task]`	`str`	`power_grid`
`[flowgraph,hlsasicflow,floorplan.power_grid,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,hlsasicflow,floorplan.power_grid,0,tool]`	`str`	`openroad`

2.2.2.16. floorplan.power_grid/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.power_grid,1,input]`	`[(str,str)]`	`('floorplan.tapcell', '1')`
`[flowgraph,hlsasicflow,floorplan.power_grid,1,task]`	`str`	`power_grid`
`[flowgraph,hlsasicflow,floorplan.power_grid,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,hlsasicflow,floorplan.power_grid,1,tool]`	`str`	`openroad`

2.2.2.17. floorplan.power_grid/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.power_grid,2,input]`	`[(str,str)]`	`('floorplan.tapcell', '2')`
`[flowgraph,hlsasicflow,floorplan.power_grid,2,task]`	`str`	`power_grid`
`[flowgraph,hlsasicflow,floorplan.power_grid,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,hlsasicflow,floorplan.power_grid,2,tool]`	`str`	`openroad`

2.2.2.18. floorplan.pin_placement/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.pin_placement,0,input]`	`[(str,str)]`	`('floorplan.power_grid', '0')`
`[flowgraph,hlsasicflow,floorplan.pin_placement,0,task]`	`str`	`pin_placement`
`[flowgraph,hlsasicflow,floorplan.pin_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,hlsasicflow,floorplan.pin_placement,0,tool]`	`str`	`openroad`

2.2.2.19. floorplan.pin_placement/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.pin_placement,1,input]`	`[(str,str)]`	`('floorplan.power_grid', '1')`
`[flowgraph,hlsasicflow,floorplan.pin_placement,1,task]`	`str`	`pin_placement`
`[flowgraph,hlsasicflow,floorplan.pin_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,hlsasicflow,floorplan.pin_placement,1,tool]`	`str`	`openroad`

2.2.2.20. floorplan.pin_placement/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.pin_placement,2,input]`	`[(str,str)]`	`('floorplan.power_grid', '2')`
`[flowgraph,hlsasicflow,floorplan.pin_placement,2,task]`	`str`	`pin_placement`
`[flowgraph,hlsasicflow,floorplan.pin_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,hlsasicflow,floorplan.pin_placement,2,tool]`	`str`	`openroad`

2.2.2.21. floorplan.min/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,floorplan.min,0,input]`	`[(str,str)]`	`('floorplan.pin_placement', '0')` `('floorplan.pin_placement', '1')` `('floorplan.pin_placement', '2')`
`[flowgraph,hlsasicflow,floorplan.min,0,task]`	`str`	`minimum`
`[flowgraph,hlsasicflow,floorplan.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,hlsasicflow,floorplan.min,0,tool]`	`str`	`builtin`

2.2.2.22. place.global/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.global,0,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,hlsasicflow,place.global,0,task]`	`str`	`global_placement`
`[flowgraph,hlsasicflow,place.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,hlsasicflow,place.global,0,tool]`	`str`	`openroad`

2.2.2.23. place.global/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.global,1,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,hlsasicflow,place.global,1,task]`	`str`	`global_placement`
`[flowgraph,hlsasicflow,place.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,hlsasicflow,place.global,1,tool]`	`str`	`openroad`

2.2.2.24. place.global/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.global,2,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,hlsasicflow,place.global,2,task]`	`str`	`global_placement`
`[flowgraph,hlsasicflow,place.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,hlsasicflow,place.global,2,tool]`	`str`	`openroad`

2.2.2.25. place.repair_design/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.repair_design,0,input]`	`[(str,str)]`	`('place.global', '0')`
`[flowgraph,hlsasicflow,place.repair_design,0,task]`	`str`	`repair_design`
`[flowgraph,hlsasicflow,place.repair_design,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,hlsasicflow,place.repair_design,0,tool]`	`str`	`openroad`

2.2.2.26. place.repair_design/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.repair_design,1,input]`	`[(str,str)]`	`('place.global', '1')`
`[flowgraph,hlsasicflow,place.repair_design,1,task]`	`str`	`repair_design`
`[flowgraph,hlsasicflow,place.repair_design,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,hlsasicflow,place.repair_design,1,tool]`	`str`	`openroad`

2.2.2.27. place.repair_design/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.repair_design,2,input]`	`[(str,str)]`	`('place.global', '2')`
`[flowgraph,hlsasicflow,place.repair_design,2,task]`	`str`	`repair_design`
`[flowgraph,hlsasicflow,place.repair_design,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,hlsasicflow,place.repair_design,2,tool]`	`str`	`openroad`

2.2.2.28. place.detailed/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.detailed,0,input]`	`[(str,str)]`	`('place.repair_design', '0')`
`[flowgraph,hlsasicflow,place.detailed,0,task]`	`str`	`detailed_placement`
`[flowgraph,hlsasicflow,place.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,hlsasicflow,place.detailed,0,tool]`	`str`	`openroad`

2.2.2.29. place.detailed/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.detailed,1,input]`	`[(str,str)]`	`('place.repair_design', '1')`
`[flowgraph,hlsasicflow,place.detailed,1,task]`	`str`	`detailed_placement`
`[flowgraph,hlsasicflow,place.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,hlsasicflow,place.detailed,1,tool]`	`str`	`openroad`

2.2.2.30. place.detailed/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.detailed,2,input]`	`[(str,str)]`	`('place.repair_design', '2')`
`[flowgraph,hlsasicflow,place.detailed,2,task]`	`str`	`detailed_placement`
`[flowgraph,hlsasicflow,place.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,hlsasicflow,place.detailed,2,tool]`	`str`	`openroad`

2.2.2.31. place.min/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,place.min,0,input]`	`[(str,str)]`	`('place.detailed', '0')` `('place.detailed', '1')` `('place.detailed', '2')`
`[flowgraph,hlsasicflow,place.min,0,task]`	`str`	`minimum`
`[flowgraph,hlsasicflow,place.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,hlsasicflow,place.min,0,tool]`	`str`	`builtin`

2.2.2.32. cts.clock_tree_synthesis/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,0,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,0,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,0,tool]`	`str`	`openroad`

2.2.2.33. cts.clock_tree_synthesis/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,1,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,1,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,1,tool]`	`str`	`openroad`

2.2.2.34. cts.clock_tree_synthesis/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,2,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,2,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,hlsasicflow,cts.clock_tree_synthesis,2,tool]`	`str`	`openroad`

2.2.2.35. cts.repair_timing/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.repair_timing,0,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '0')`
`[flowgraph,hlsasicflow,cts.repair_timing,0,task]`	`str`	`repair_timing`
`[flowgraph,hlsasicflow,cts.repair_timing,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,hlsasicflow,cts.repair_timing,0,tool]`	`str`	`openroad`

2.2.2.36. cts.repair_timing/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.repair_timing,1,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '1')`
`[flowgraph,hlsasicflow,cts.repair_timing,1,task]`	`str`	`repair_timing`
`[flowgraph,hlsasicflow,cts.repair_timing,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,hlsasicflow,cts.repair_timing,1,tool]`	`str`	`openroad`

2.2.2.37. cts.repair_timing/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.repair_timing,2,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '2')`
`[flowgraph,hlsasicflow,cts.repair_timing,2,task]`	`str`	`repair_timing`
`[flowgraph,hlsasicflow,cts.repair_timing,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,hlsasicflow,cts.repair_timing,2,tool]`	`str`	`openroad`

2.2.2.38. cts.fillcell/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.fillcell,0,input]`	`[(str,str)]`	`('cts.repair_timing', '0')`
`[flowgraph,hlsasicflow,cts.fillcell,0,task]`	`str`	`fillercell_insertion`
`[flowgraph,hlsasicflow,cts.fillcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,hlsasicflow,cts.fillcell,0,tool]`	`str`	`openroad`

2.2.2.39. cts.fillcell/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.fillcell,1,input]`	`[(str,str)]`	`('cts.repair_timing', '1')`
`[flowgraph,hlsasicflow,cts.fillcell,1,task]`	`str`	`fillercell_insertion`
`[flowgraph,hlsasicflow,cts.fillcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,hlsasicflow,cts.fillcell,1,tool]`	`str`	`openroad`

2.2.2.40. cts.fillcell/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.fillcell,2,input]`	`[(str,str)]`	`('cts.repair_timing', '2')`
`[flowgraph,hlsasicflow,cts.fillcell,2,task]`	`str`	`fillercell_insertion`
`[flowgraph,hlsasicflow,cts.fillcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,hlsasicflow,cts.fillcell,2,tool]`	`str`	`openroad`

2.2.2.41. cts.min/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,cts.min,0,input]`	`[(str,str)]`	`('cts.fillcell', '0')` `('cts.fillcell', '1')` `('cts.fillcell', '2')`
`[flowgraph,hlsasicflow,cts.min,0,task]`	`str`	`minimum`
`[flowgraph,hlsasicflow,cts.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,hlsasicflow,cts.min,0,tool]`	`str`	`builtin`

2.2.2.42. route.global/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.global,0,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,hlsasicflow,route.global,0,task]`	`str`	`global_route`
`[flowgraph,hlsasicflow,route.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,hlsasicflow,route.global,0,tool]`	`str`	`openroad`

2.2.2.43. route.global/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.global,1,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,hlsasicflow,route.global,1,task]`	`str`	`global_route`
`[flowgraph,hlsasicflow,route.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,hlsasicflow,route.global,1,tool]`	`str`	`openroad`

2.2.2.44. route.global/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.global,2,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,hlsasicflow,route.global,2,task]`	`str`	`global_route`
`[flowgraph,hlsasicflow,route.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,hlsasicflow,route.global,2,tool]`	`str`	`openroad`

2.2.2.45. route.antenna_repair/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.antenna_repair,0,input]`	`[(str,str)]`	`('route.global', '0')`
`[flowgraph,hlsasicflow,route.antenna_repair,0,task]`	`str`	`antenna_repair`
`[flowgraph,hlsasicflow,route.antenna_repair,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,hlsasicflow,route.antenna_repair,0,tool]`	`str`	`openroad`

2.2.2.46. route.antenna_repair/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.antenna_repair,1,input]`	`[(str,str)]`	`('route.global', '1')`
`[flowgraph,hlsasicflow,route.antenna_repair,1,task]`	`str`	`antenna_repair`
`[flowgraph,hlsasicflow,route.antenna_repair,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,hlsasicflow,route.antenna_repair,1,tool]`	`str`	`openroad`

2.2.2.47. route.antenna_repair/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.antenna_repair,2,input]`	`[(str,str)]`	`('route.global', '2')`
`[flowgraph,hlsasicflow,route.antenna_repair,2,task]`	`str`	`antenna_repair`
`[flowgraph,hlsasicflow,route.antenna_repair,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,hlsasicflow,route.antenna_repair,2,tool]`	`str`	`openroad`

2.2.2.48. route.detailed/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.detailed,0,input]`	`[(str,str)]`	`('route.antenna_repair', '0')`
`[flowgraph,hlsasicflow,route.detailed,0,task]`	`str`	`detailed_route`
`[flowgraph,hlsasicflow,route.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,hlsasicflow,route.detailed,0,tool]`	`str`	`openroad`

2.2.2.49. route.detailed/1#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.detailed,1,input]`	`[(str,str)]`	`('route.antenna_repair', '1')`
`[flowgraph,hlsasicflow,route.detailed,1,task]`	`str`	`detailed_route`
`[flowgraph,hlsasicflow,route.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,hlsasicflow,route.detailed,1,tool]`	`str`	`openroad`

2.2.2.50. route.detailed/2#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.detailed,2,input]`	`[(str,str)]`	`('route.antenna_repair', '2')`
`[flowgraph,hlsasicflow,route.detailed,2,task]`	`str`	`detailed_route`
`[flowgraph,hlsasicflow,route.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,hlsasicflow,route.detailed,2,tool]`	`str`	`openroad`

2.2.2.51. route.min/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,route.min,0,input]`	`[(str,str)]`	`('route.detailed', '0')` `('route.detailed', '1')` `('route.detailed', '2')`
`[flowgraph,hlsasicflow,route.min,0,task]`	`str`	`minimum`
`[flowgraph,hlsasicflow,route.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,hlsasicflow,route.min,0,tool]`	`str`	`builtin`

2.2.2.52. dfm.metal_fill/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,dfm.metal_fill,0,input]`	`[(str,str)]`	`('route.min', '0')`
`[flowgraph,hlsasicflow,dfm.metal_fill,0,task]`	`str`	`fillmetal_insertion`
`[flowgraph,hlsasicflow,dfm.metal_fill,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillmetal_insertion/FillMetalTask`
`[flowgraph,hlsasicflow,dfm.metal_fill,0,tool]`	`str`	`openroad`

2.2.2.53. write.gds/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,write.gds,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,hlsasicflow,write.gds,0,task]`	`str`	`export`
`[flowgraph,hlsasicflow,write.gds,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.export/ExportTask`
`[flowgraph,hlsasicflow,write.gds,0,tool]`	`str`	`klayout`

2.2.2.54. write.views/0#

Keypath	Type	Value
`[flowgraph,hlsasicflow,write.views,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,hlsasicflow,write.views,0,task]`	`str`	`write_data`
`[flowgraph,hlsasicflow,write.views,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.write_data/WriteViewsTask`
`[flowgraph,hlsasicflow,write.views,0,tool]`	`str`	`openroad`

2.3. vhdlasicflow#

A VHDL-based ASIC synthesis flow.

This class extends the standard ASICFlow to support VHDL input by replacing the initial Verilog-focused ‘elaborate’ step with a ‘convert’ step. This new step uses GHDL to analyze and elaborate the VHDL design before synthesis.

File: asicflow.py

2.3.1. Graph#

2.3.2. Nodes#

2.3.2.1. convert/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,convert,0,task]`	`str`	`convert`
`[flowgraph,vhdlasicflow,convert,0,taskmodule]`	`str`	`siliconcompiler.tools.ghdl.convert/ConvertTask`
`[flowgraph,vhdlasicflow,convert,0,tool]`	`str`	`ghdl`

2.3.2.2. synthesis/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,synthesis,0,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,vhdlasicflow,synthesis,0,task]`	`str`	`syn_asic`
`[flowgraph,vhdlasicflow,synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,vhdlasicflow,synthesis,0,tool]`	`str`	`yosys`

2.3.2.3. synthesis/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,synthesis,1,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,vhdlasicflow,synthesis,1,task]`	`str`	`syn_asic`
`[flowgraph,vhdlasicflow,synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,vhdlasicflow,synthesis,1,tool]`	`str`	`yosys`

2.3.2.4. synthesis/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,synthesis,2,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,vhdlasicflow,synthesis,2,task]`	`str`	`syn_asic`
`[flowgraph,vhdlasicflow,synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,vhdlasicflow,synthesis,2,tool]`	`str`	`yosys`

2.3.2.5. synthesis.min/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,synthesis.min,0,input]`	`[(str,str)]`	`('synthesis', '0')` `('synthesis', '1')` `('synthesis', '2')`
`[flowgraph,vhdlasicflow,synthesis.min,0,task]`	`str`	`minimum`
`[flowgraph,vhdlasicflow,synthesis.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,vhdlasicflow,synthesis.min,0,tool]`	`str`	`builtin`

2.3.2.6. floorplan.init/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.init,0,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,vhdlasicflow,floorplan.init,0,task]`	`str`	`init_floorplan`
`[flowgraph,vhdlasicflow,floorplan.init,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,vhdlasicflow,floorplan.init,0,tool]`	`str`	`openroad`

2.3.2.7. floorplan.init/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.init,1,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,vhdlasicflow,floorplan.init,1,task]`	`str`	`init_floorplan`
`[flowgraph,vhdlasicflow,floorplan.init,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,vhdlasicflow,floorplan.init,1,tool]`	`str`	`openroad`

2.3.2.8. floorplan.init/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.init,2,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,vhdlasicflow,floorplan.init,2,task]`	`str`	`init_floorplan`
`[flowgraph,vhdlasicflow,floorplan.init,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,vhdlasicflow,floorplan.init,2,tool]`	`str`	`openroad`

2.3.2.9. floorplan.macro_placement/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.macro_placement,0,input]`	`[(str,str)]`	`('floorplan.init', '0')`
`[flowgraph,vhdlasicflow,floorplan.macro_placement,0,task]`	`str`	`macro_placement`
`[flowgraph,vhdlasicflow,floorplan.macro_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,vhdlasicflow,floorplan.macro_placement,0,tool]`	`str`	`openroad`

2.3.2.10. floorplan.macro_placement/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.macro_placement,1,input]`	`[(str,str)]`	`('floorplan.init', '1')`
`[flowgraph,vhdlasicflow,floorplan.macro_placement,1,task]`	`str`	`macro_placement`
`[flowgraph,vhdlasicflow,floorplan.macro_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,vhdlasicflow,floorplan.macro_placement,1,tool]`	`str`	`openroad`

2.3.2.11. floorplan.macro_placement/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.macro_placement,2,input]`	`[(str,str)]`	`('floorplan.init', '2')`
`[flowgraph,vhdlasicflow,floorplan.macro_placement,2,task]`	`str`	`macro_placement`
`[flowgraph,vhdlasicflow,floorplan.macro_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,vhdlasicflow,floorplan.macro_placement,2,tool]`	`str`	`openroad`

2.3.2.12. floorplan.tapcell/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.tapcell,0,input]`	`[(str,str)]`	`('floorplan.macro_placement', '0')`
`[flowgraph,vhdlasicflow,floorplan.tapcell,0,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,vhdlasicflow,floorplan.tapcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,vhdlasicflow,floorplan.tapcell,0,tool]`	`str`	`openroad`

2.3.2.13. floorplan.tapcell/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.tapcell,1,input]`	`[(str,str)]`	`('floorplan.macro_placement', '1')`
`[flowgraph,vhdlasicflow,floorplan.tapcell,1,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,vhdlasicflow,floorplan.tapcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,vhdlasicflow,floorplan.tapcell,1,tool]`	`str`	`openroad`

2.3.2.14. floorplan.tapcell/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.tapcell,2,input]`	`[(str,str)]`	`('floorplan.macro_placement', '2')`
`[flowgraph,vhdlasicflow,floorplan.tapcell,2,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,vhdlasicflow,floorplan.tapcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,vhdlasicflow,floorplan.tapcell,2,tool]`	`str`	`openroad`

2.3.2.15. floorplan.power_grid/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.power_grid,0,input]`	`[(str,str)]`	`('floorplan.tapcell', '0')`
`[flowgraph,vhdlasicflow,floorplan.power_grid,0,task]`	`str`	`power_grid`
`[flowgraph,vhdlasicflow,floorplan.power_grid,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,vhdlasicflow,floorplan.power_grid,0,tool]`	`str`	`openroad`

2.3.2.16. floorplan.power_grid/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.power_grid,1,input]`	`[(str,str)]`	`('floorplan.tapcell', '1')`
`[flowgraph,vhdlasicflow,floorplan.power_grid,1,task]`	`str`	`power_grid`
`[flowgraph,vhdlasicflow,floorplan.power_grid,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,vhdlasicflow,floorplan.power_grid,1,tool]`	`str`	`openroad`

2.3.2.17. floorplan.power_grid/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.power_grid,2,input]`	`[(str,str)]`	`('floorplan.tapcell', '2')`
`[flowgraph,vhdlasicflow,floorplan.power_grid,2,task]`	`str`	`power_grid`
`[flowgraph,vhdlasicflow,floorplan.power_grid,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,vhdlasicflow,floorplan.power_grid,2,tool]`	`str`	`openroad`

2.3.2.18. floorplan.pin_placement/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.pin_placement,0,input]`	`[(str,str)]`	`('floorplan.power_grid', '0')`
`[flowgraph,vhdlasicflow,floorplan.pin_placement,0,task]`	`str`	`pin_placement`
`[flowgraph,vhdlasicflow,floorplan.pin_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,vhdlasicflow,floorplan.pin_placement,0,tool]`	`str`	`openroad`

2.3.2.19. floorplan.pin_placement/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.pin_placement,1,input]`	`[(str,str)]`	`('floorplan.power_grid', '1')`
`[flowgraph,vhdlasicflow,floorplan.pin_placement,1,task]`	`str`	`pin_placement`
`[flowgraph,vhdlasicflow,floorplan.pin_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,vhdlasicflow,floorplan.pin_placement,1,tool]`	`str`	`openroad`

2.3.2.20. floorplan.pin_placement/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.pin_placement,2,input]`	`[(str,str)]`	`('floorplan.power_grid', '2')`
`[flowgraph,vhdlasicflow,floorplan.pin_placement,2,task]`	`str`	`pin_placement`
`[flowgraph,vhdlasicflow,floorplan.pin_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,vhdlasicflow,floorplan.pin_placement,2,tool]`	`str`	`openroad`

2.3.2.21. floorplan.min/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,floorplan.min,0,input]`	`[(str,str)]`	`('floorplan.pin_placement', '0')` `('floorplan.pin_placement', '1')` `('floorplan.pin_placement', '2')`
`[flowgraph,vhdlasicflow,floorplan.min,0,task]`	`str`	`minimum`
`[flowgraph,vhdlasicflow,floorplan.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,vhdlasicflow,floorplan.min,0,tool]`	`str`	`builtin`

2.3.2.22. place.global/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.global,0,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,vhdlasicflow,place.global,0,task]`	`str`	`global_placement`
`[flowgraph,vhdlasicflow,place.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,vhdlasicflow,place.global,0,tool]`	`str`	`openroad`

2.3.2.23. place.global/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.global,1,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,vhdlasicflow,place.global,1,task]`	`str`	`global_placement`
`[flowgraph,vhdlasicflow,place.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,vhdlasicflow,place.global,1,tool]`	`str`	`openroad`

2.3.2.24. place.global/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.global,2,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,vhdlasicflow,place.global,2,task]`	`str`	`global_placement`
`[flowgraph,vhdlasicflow,place.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,vhdlasicflow,place.global,2,tool]`	`str`	`openroad`

2.3.2.25. place.repair_design/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.repair_design,0,input]`	`[(str,str)]`	`('place.global', '0')`
`[flowgraph,vhdlasicflow,place.repair_design,0,task]`	`str`	`repair_design`
`[flowgraph,vhdlasicflow,place.repair_design,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,vhdlasicflow,place.repair_design,0,tool]`	`str`	`openroad`

2.3.2.26. place.repair_design/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.repair_design,1,input]`	`[(str,str)]`	`('place.global', '1')`
`[flowgraph,vhdlasicflow,place.repair_design,1,task]`	`str`	`repair_design`
`[flowgraph,vhdlasicflow,place.repair_design,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,vhdlasicflow,place.repair_design,1,tool]`	`str`	`openroad`

2.3.2.27. place.repair_design/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.repair_design,2,input]`	`[(str,str)]`	`('place.global', '2')`
`[flowgraph,vhdlasicflow,place.repair_design,2,task]`	`str`	`repair_design`
`[flowgraph,vhdlasicflow,place.repair_design,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,vhdlasicflow,place.repair_design,2,tool]`	`str`	`openroad`

2.3.2.28. place.detailed/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.detailed,0,input]`	`[(str,str)]`	`('place.repair_design', '0')`
`[flowgraph,vhdlasicflow,place.detailed,0,task]`	`str`	`detailed_placement`
`[flowgraph,vhdlasicflow,place.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,vhdlasicflow,place.detailed,0,tool]`	`str`	`openroad`

2.3.2.29. place.detailed/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.detailed,1,input]`	`[(str,str)]`	`('place.repair_design', '1')`
`[flowgraph,vhdlasicflow,place.detailed,1,task]`	`str`	`detailed_placement`
`[flowgraph,vhdlasicflow,place.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,vhdlasicflow,place.detailed,1,tool]`	`str`	`openroad`

2.3.2.30. place.detailed/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.detailed,2,input]`	`[(str,str)]`	`('place.repair_design', '2')`
`[flowgraph,vhdlasicflow,place.detailed,2,task]`	`str`	`detailed_placement`
`[flowgraph,vhdlasicflow,place.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,vhdlasicflow,place.detailed,2,tool]`	`str`	`openroad`

2.3.2.31. place.min/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,place.min,0,input]`	`[(str,str)]`	`('place.detailed', '0')` `('place.detailed', '1')` `('place.detailed', '2')`
`[flowgraph,vhdlasicflow,place.min,0,task]`	`str`	`minimum`
`[flowgraph,vhdlasicflow,place.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,vhdlasicflow,place.min,0,tool]`	`str`	`builtin`

2.3.2.32. cts.clock_tree_synthesis/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,0,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,0,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,0,tool]`	`str`	`openroad`

2.3.2.33. cts.clock_tree_synthesis/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,1,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,1,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,1,tool]`	`str`	`openroad`

2.3.2.34. cts.clock_tree_synthesis/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,2,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,2,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,vhdlasicflow,cts.clock_tree_synthesis,2,tool]`	`str`	`openroad`

2.3.2.35. cts.repair_timing/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.repair_timing,0,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '0')`
`[flowgraph,vhdlasicflow,cts.repair_timing,0,task]`	`str`	`repair_timing`
`[flowgraph,vhdlasicflow,cts.repair_timing,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,vhdlasicflow,cts.repair_timing,0,tool]`	`str`	`openroad`

2.3.2.36. cts.repair_timing/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.repair_timing,1,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '1')`
`[flowgraph,vhdlasicflow,cts.repair_timing,1,task]`	`str`	`repair_timing`
`[flowgraph,vhdlasicflow,cts.repair_timing,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,vhdlasicflow,cts.repair_timing,1,tool]`	`str`	`openroad`

2.3.2.37. cts.repair_timing/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.repair_timing,2,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '2')`
`[flowgraph,vhdlasicflow,cts.repair_timing,2,task]`	`str`	`repair_timing`
`[flowgraph,vhdlasicflow,cts.repair_timing,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,vhdlasicflow,cts.repair_timing,2,tool]`	`str`	`openroad`

2.3.2.38. cts.fillcell/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.fillcell,0,input]`	`[(str,str)]`	`('cts.repair_timing', '0')`
`[flowgraph,vhdlasicflow,cts.fillcell,0,task]`	`str`	`fillercell_insertion`
`[flowgraph,vhdlasicflow,cts.fillcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,vhdlasicflow,cts.fillcell,0,tool]`	`str`	`openroad`

2.3.2.39. cts.fillcell/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.fillcell,1,input]`	`[(str,str)]`	`('cts.repair_timing', '1')`
`[flowgraph,vhdlasicflow,cts.fillcell,1,task]`	`str`	`fillercell_insertion`
`[flowgraph,vhdlasicflow,cts.fillcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,vhdlasicflow,cts.fillcell,1,tool]`	`str`	`openroad`

2.3.2.40. cts.fillcell/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.fillcell,2,input]`	`[(str,str)]`	`('cts.repair_timing', '2')`
`[flowgraph,vhdlasicflow,cts.fillcell,2,task]`	`str`	`fillercell_insertion`
`[flowgraph,vhdlasicflow,cts.fillcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,vhdlasicflow,cts.fillcell,2,tool]`	`str`	`openroad`

2.3.2.41. cts.min/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,cts.min,0,input]`	`[(str,str)]`	`('cts.fillcell', '0')` `('cts.fillcell', '1')` `('cts.fillcell', '2')`
`[flowgraph,vhdlasicflow,cts.min,0,task]`	`str`	`minimum`
`[flowgraph,vhdlasicflow,cts.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,vhdlasicflow,cts.min,0,tool]`	`str`	`builtin`

2.3.2.42. route.global/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.global,0,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,vhdlasicflow,route.global,0,task]`	`str`	`global_route`
`[flowgraph,vhdlasicflow,route.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,vhdlasicflow,route.global,0,tool]`	`str`	`openroad`

2.3.2.43. route.global/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.global,1,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,vhdlasicflow,route.global,1,task]`	`str`	`global_route`
`[flowgraph,vhdlasicflow,route.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,vhdlasicflow,route.global,1,tool]`	`str`	`openroad`

2.3.2.44. route.global/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.global,2,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,vhdlasicflow,route.global,2,task]`	`str`	`global_route`
`[flowgraph,vhdlasicflow,route.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,vhdlasicflow,route.global,2,tool]`	`str`	`openroad`

2.3.2.45. route.antenna_repair/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.antenna_repair,0,input]`	`[(str,str)]`	`('route.global', '0')`
`[flowgraph,vhdlasicflow,route.antenna_repair,0,task]`	`str`	`antenna_repair`
`[flowgraph,vhdlasicflow,route.antenna_repair,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,vhdlasicflow,route.antenna_repair,0,tool]`	`str`	`openroad`

2.3.2.46. route.antenna_repair/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.antenna_repair,1,input]`	`[(str,str)]`	`('route.global', '1')`
`[flowgraph,vhdlasicflow,route.antenna_repair,1,task]`	`str`	`antenna_repair`
`[flowgraph,vhdlasicflow,route.antenna_repair,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,vhdlasicflow,route.antenna_repair,1,tool]`	`str`	`openroad`

2.3.2.47. route.antenna_repair/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.antenna_repair,2,input]`	`[(str,str)]`	`('route.global', '2')`
`[flowgraph,vhdlasicflow,route.antenna_repair,2,task]`	`str`	`antenna_repair`
`[flowgraph,vhdlasicflow,route.antenna_repair,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,vhdlasicflow,route.antenna_repair,2,tool]`	`str`	`openroad`

2.3.2.48. route.detailed/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.detailed,0,input]`	`[(str,str)]`	`('route.antenna_repair', '0')`
`[flowgraph,vhdlasicflow,route.detailed,0,task]`	`str`	`detailed_route`
`[flowgraph,vhdlasicflow,route.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,vhdlasicflow,route.detailed,0,tool]`	`str`	`openroad`

2.3.2.49. route.detailed/1#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.detailed,1,input]`	`[(str,str)]`	`('route.antenna_repair', '1')`
`[flowgraph,vhdlasicflow,route.detailed,1,task]`	`str`	`detailed_route`
`[flowgraph,vhdlasicflow,route.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,vhdlasicflow,route.detailed,1,tool]`	`str`	`openroad`

2.3.2.50. route.detailed/2#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.detailed,2,input]`	`[(str,str)]`	`('route.antenna_repair', '2')`
`[flowgraph,vhdlasicflow,route.detailed,2,task]`	`str`	`detailed_route`
`[flowgraph,vhdlasicflow,route.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,vhdlasicflow,route.detailed,2,tool]`	`str`	`openroad`

2.3.2.51. route.min/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,route.min,0,input]`	`[(str,str)]`	`('route.detailed', '0')` `('route.detailed', '1')` `('route.detailed', '2')`
`[flowgraph,vhdlasicflow,route.min,0,task]`	`str`	`minimum`
`[flowgraph,vhdlasicflow,route.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,vhdlasicflow,route.min,0,tool]`	`str`	`builtin`

2.3.2.52. dfm.metal_fill/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,dfm.metal_fill,0,input]`	`[(str,str)]`	`('route.min', '0')`
`[flowgraph,vhdlasicflow,dfm.metal_fill,0,task]`	`str`	`fillmetal_insertion`
`[flowgraph,vhdlasicflow,dfm.metal_fill,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillmetal_insertion/FillMetalTask`
`[flowgraph,vhdlasicflow,dfm.metal_fill,0,tool]`	`str`	`openroad`

2.3.2.53. write.gds/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,write.gds,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,vhdlasicflow,write.gds,0,task]`	`str`	`export`
`[flowgraph,vhdlasicflow,write.gds,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.export/ExportTask`
`[flowgraph,vhdlasicflow,write.gds,0,tool]`	`str`	`klayout`

2.3.2.54. write.views/0#

Keypath	Type	Value
`[flowgraph,vhdlasicflow,write.views,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,vhdlasicflow,write.views,0,task]`	`str`	`write_data`
`[flowgraph,vhdlasicflow,write.views,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.write_data/WriteViewsTask`
`[flowgraph,vhdlasicflow,write.views,0,tool]`	`str`	`openroad`

2.4. sv2vasicflow#

A SystemVerilog-to-Verilog extension of the ASICFlow.

This flow is intended for designs written in SystemVerilog that may not be fully supported by downstream synthesis or APR tools. It inserts a ‘convert’ step using SV2V before the standard ‘elaborate’ step to ensure the design is in a compatible Verilog format.

File: asicflow.py

2.4.1. Graph#

2.4.2. Nodes#

2.4.2.1. elaborate/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,elaborate,0,task]`	`str`	`elaborate`
`[flowgraph,sv2vasicflow,elaborate,0,taskmodule]`	`str`	`siliconcompiler.tools.slang.elaborate/Elaborate`
`[flowgraph,sv2vasicflow,elaborate,0,tool]`	`str`	`slang`

2.4.2.2. convert/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,convert,0,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,sv2vasicflow,convert,0,task]`	`str`	`convert`
`[flowgraph,sv2vasicflow,convert,0,taskmodule]`	`str`	`siliconcompiler.tools.sv2v.convert/ConvertTask`
`[flowgraph,sv2vasicflow,convert,0,tool]`	`str`	`sv2v`

2.4.2.3. synthesis/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,synthesis,0,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,sv2vasicflow,synthesis,0,task]`	`str`	`syn_asic`
`[flowgraph,sv2vasicflow,synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,sv2vasicflow,synthesis,0,tool]`	`str`	`yosys`

2.4.2.4. synthesis/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,synthesis,1,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,sv2vasicflow,synthesis,1,task]`	`str`	`syn_asic`
`[flowgraph,sv2vasicflow,synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,sv2vasicflow,synthesis,1,tool]`	`str`	`yosys`

2.4.2.5. synthesis/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,synthesis,2,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,sv2vasicflow,synthesis,2,task]`	`str`	`syn_asic`
`[flowgraph,sv2vasicflow,synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,sv2vasicflow,synthesis,2,tool]`	`str`	`yosys`

2.4.2.6. synthesis.min/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,synthesis.min,0,input]`	`[(str,str)]`	`('synthesis', '0')` `('synthesis', '1')` `('synthesis', '2')`
`[flowgraph,sv2vasicflow,synthesis.min,0,task]`	`str`	`minimum`
`[flowgraph,sv2vasicflow,synthesis.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,sv2vasicflow,synthesis.min,0,tool]`	`str`	`builtin`

2.4.2.7. floorplan.init/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.init,0,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,sv2vasicflow,floorplan.init,0,task]`	`str`	`init_floorplan`
`[flowgraph,sv2vasicflow,floorplan.init,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,sv2vasicflow,floorplan.init,0,tool]`	`str`	`openroad`

2.4.2.8. floorplan.init/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.init,1,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,sv2vasicflow,floorplan.init,1,task]`	`str`	`init_floorplan`
`[flowgraph,sv2vasicflow,floorplan.init,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,sv2vasicflow,floorplan.init,1,tool]`	`str`	`openroad`

2.4.2.9. floorplan.init/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.init,2,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,sv2vasicflow,floorplan.init,2,task]`	`str`	`init_floorplan`
`[flowgraph,sv2vasicflow,floorplan.init,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,sv2vasicflow,floorplan.init,2,tool]`	`str`	`openroad`

2.4.2.10. floorplan.macro_placement/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.macro_placement,0,input]`	`[(str,str)]`	`('floorplan.init', '0')`
`[flowgraph,sv2vasicflow,floorplan.macro_placement,0,task]`	`str`	`macro_placement`
`[flowgraph,sv2vasicflow,floorplan.macro_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,sv2vasicflow,floorplan.macro_placement,0,tool]`	`str`	`openroad`

2.4.2.11. floorplan.macro_placement/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.macro_placement,1,input]`	`[(str,str)]`	`('floorplan.init', '1')`
`[flowgraph,sv2vasicflow,floorplan.macro_placement,1,task]`	`str`	`macro_placement`
`[flowgraph,sv2vasicflow,floorplan.macro_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,sv2vasicflow,floorplan.macro_placement,1,tool]`	`str`	`openroad`

2.4.2.12. floorplan.macro_placement/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.macro_placement,2,input]`	`[(str,str)]`	`('floorplan.init', '2')`
`[flowgraph,sv2vasicflow,floorplan.macro_placement,2,task]`	`str`	`macro_placement`
`[flowgraph,sv2vasicflow,floorplan.macro_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,sv2vasicflow,floorplan.macro_placement,2,tool]`	`str`	`openroad`

2.4.2.13. floorplan.tapcell/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.tapcell,0,input]`	`[(str,str)]`	`('floorplan.macro_placement', '0')`
`[flowgraph,sv2vasicflow,floorplan.tapcell,0,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,sv2vasicflow,floorplan.tapcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,sv2vasicflow,floorplan.tapcell,0,tool]`	`str`	`openroad`

2.4.2.14. floorplan.tapcell/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.tapcell,1,input]`	`[(str,str)]`	`('floorplan.macro_placement', '1')`
`[flowgraph,sv2vasicflow,floorplan.tapcell,1,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,sv2vasicflow,floorplan.tapcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,sv2vasicflow,floorplan.tapcell,1,tool]`	`str`	`openroad`

2.4.2.15. floorplan.tapcell/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.tapcell,2,input]`	`[(str,str)]`	`('floorplan.macro_placement', '2')`
`[flowgraph,sv2vasicflow,floorplan.tapcell,2,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,sv2vasicflow,floorplan.tapcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,sv2vasicflow,floorplan.tapcell,2,tool]`	`str`	`openroad`

2.4.2.16. floorplan.power_grid/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.power_grid,0,input]`	`[(str,str)]`	`('floorplan.tapcell', '0')`
`[flowgraph,sv2vasicflow,floorplan.power_grid,0,task]`	`str`	`power_grid`
`[flowgraph,sv2vasicflow,floorplan.power_grid,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,sv2vasicflow,floorplan.power_grid,0,tool]`	`str`	`openroad`

2.4.2.17. floorplan.power_grid/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.power_grid,1,input]`	`[(str,str)]`	`('floorplan.tapcell', '1')`
`[flowgraph,sv2vasicflow,floorplan.power_grid,1,task]`	`str`	`power_grid`
`[flowgraph,sv2vasicflow,floorplan.power_grid,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,sv2vasicflow,floorplan.power_grid,1,tool]`	`str`	`openroad`

2.4.2.18. floorplan.power_grid/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.power_grid,2,input]`	`[(str,str)]`	`('floorplan.tapcell', '2')`
`[flowgraph,sv2vasicflow,floorplan.power_grid,2,task]`	`str`	`power_grid`
`[flowgraph,sv2vasicflow,floorplan.power_grid,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,sv2vasicflow,floorplan.power_grid,2,tool]`	`str`	`openroad`

2.4.2.19. floorplan.pin_placement/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.pin_placement,0,input]`	`[(str,str)]`	`('floorplan.power_grid', '0')`
`[flowgraph,sv2vasicflow,floorplan.pin_placement,0,task]`	`str`	`pin_placement`
`[flowgraph,sv2vasicflow,floorplan.pin_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,sv2vasicflow,floorplan.pin_placement,0,tool]`	`str`	`openroad`

2.4.2.20. floorplan.pin_placement/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.pin_placement,1,input]`	`[(str,str)]`	`('floorplan.power_grid', '1')`
`[flowgraph,sv2vasicflow,floorplan.pin_placement,1,task]`	`str`	`pin_placement`
`[flowgraph,sv2vasicflow,floorplan.pin_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,sv2vasicflow,floorplan.pin_placement,1,tool]`	`str`	`openroad`

2.4.2.21. floorplan.pin_placement/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.pin_placement,2,input]`	`[(str,str)]`	`('floorplan.power_grid', '2')`
`[flowgraph,sv2vasicflow,floorplan.pin_placement,2,task]`	`str`	`pin_placement`
`[flowgraph,sv2vasicflow,floorplan.pin_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,sv2vasicflow,floorplan.pin_placement,2,tool]`	`str`	`openroad`

2.4.2.22. floorplan.min/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,floorplan.min,0,input]`	`[(str,str)]`	`('floorplan.pin_placement', '0')` `('floorplan.pin_placement', '1')` `('floorplan.pin_placement', '2')`
`[flowgraph,sv2vasicflow,floorplan.min,0,task]`	`str`	`minimum`
`[flowgraph,sv2vasicflow,floorplan.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,sv2vasicflow,floorplan.min,0,tool]`	`str`	`builtin`

2.4.2.23. place.global/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.global,0,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,sv2vasicflow,place.global,0,task]`	`str`	`global_placement`
`[flowgraph,sv2vasicflow,place.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,sv2vasicflow,place.global,0,tool]`	`str`	`openroad`

2.4.2.24. place.global/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.global,1,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,sv2vasicflow,place.global,1,task]`	`str`	`global_placement`
`[flowgraph,sv2vasicflow,place.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,sv2vasicflow,place.global,1,tool]`	`str`	`openroad`

2.4.2.25. place.global/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.global,2,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,sv2vasicflow,place.global,2,task]`	`str`	`global_placement`
`[flowgraph,sv2vasicflow,place.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,sv2vasicflow,place.global,2,tool]`	`str`	`openroad`

2.4.2.26. place.repair_design/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.repair_design,0,input]`	`[(str,str)]`	`('place.global', '0')`
`[flowgraph,sv2vasicflow,place.repair_design,0,task]`	`str`	`repair_design`
`[flowgraph,sv2vasicflow,place.repair_design,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,sv2vasicflow,place.repair_design,0,tool]`	`str`	`openroad`

2.4.2.27. place.repair_design/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.repair_design,1,input]`	`[(str,str)]`	`('place.global', '1')`
`[flowgraph,sv2vasicflow,place.repair_design,1,task]`	`str`	`repair_design`
`[flowgraph,sv2vasicflow,place.repair_design,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,sv2vasicflow,place.repair_design,1,tool]`	`str`	`openroad`

2.4.2.28. place.repair_design/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.repair_design,2,input]`	`[(str,str)]`	`('place.global', '2')`
`[flowgraph,sv2vasicflow,place.repair_design,2,task]`	`str`	`repair_design`
`[flowgraph,sv2vasicflow,place.repair_design,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,sv2vasicflow,place.repair_design,2,tool]`	`str`	`openroad`

2.4.2.29. place.detailed/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.detailed,0,input]`	`[(str,str)]`	`('place.repair_design', '0')`
`[flowgraph,sv2vasicflow,place.detailed,0,task]`	`str`	`detailed_placement`
`[flowgraph,sv2vasicflow,place.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,sv2vasicflow,place.detailed,0,tool]`	`str`	`openroad`

2.4.2.30. place.detailed/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.detailed,1,input]`	`[(str,str)]`	`('place.repair_design', '1')`
`[flowgraph,sv2vasicflow,place.detailed,1,task]`	`str`	`detailed_placement`
`[flowgraph,sv2vasicflow,place.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,sv2vasicflow,place.detailed,1,tool]`	`str`	`openroad`

2.4.2.31. place.detailed/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.detailed,2,input]`	`[(str,str)]`	`('place.repair_design', '2')`
`[flowgraph,sv2vasicflow,place.detailed,2,task]`	`str`	`detailed_placement`
`[flowgraph,sv2vasicflow,place.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,sv2vasicflow,place.detailed,2,tool]`	`str`	`openroad`

2.4.2.32. place.min/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,place.min,0,input]`	`[(str,str)]`	`('place.detailed', '0')` `('place.detailed', '1')` `('place.detailed', '2')`
`[flowgraph,sv2vasicflow,place.min,0,task]`	`str`	`minimum`
`[flowgraph,sv2vasicflow,place.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,sv2vasicflow,place.min,0,tool]`	`str`	`builtin`

2.4.2.33. cts.clock_tree_synthesis/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,0,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,0,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,0,tool]`	`str`	`openroad`

2.4.2.34. cts.clock_tree_synthesis/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,1,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,1,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,1,tool]`	`str`	`openroad`

2.4.2.35. cts.clock_tree_synthesis/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,2,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,2,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,sv2vasicflow,cts.clock_tree_synthesis,2,tool]`	`str`	`openroad`

2.4.2.36. cts.repair_timing/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.repair_timing,0,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '0')`
`[flowgraph,sv2vasicflow,cts.repair_timing,0,task]`	`str`	`repair_timing`
`[flowgraph,sv2vasicflow,cts.repair_timing,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,sv2vasicflow,cts.repair_timing,0,tool]`	`str`	`openroad`

2.4.2.37. cts.repair_timing/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.repair_timing,1,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '1')`
`[flowgraph,sv2vasicflow,cts.repair_timing,1,task]`	`str`	`repair_timing`
`[flowgraph,sv2vasicflow,cts.repair_timing,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,sv2vasicflow,cts.repair_timing,1,tool]`	`str`	`openroad`

2.4.2.38. cts.repair_timing/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.repair_timing,2,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '2')`
`[flowgraph,sv2vasicflow,cts.repair_timing,2,task]`	`str`	`repair_timing`
`[flowgraph,sv2vasicflow,cts.repair_timing,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,sv2vasicflow,cts.repair_timing,2,tool]`	`str`	`openroad`

2.4.2.39. cts.fillcell/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.fillcell,0,input]`	`[(str,str)]`	`('cts.repair_timing', '0')`
`[flowgraph,sv2vasicflow,cts.fillcell,0,task]`	`str`	`fillercell_insertion`
`[flowgraph,sv2vasicflow,cts.fillcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,sv2vasicflow,cts.fillcell,0,tool]`	`str`	`openroad`

2.4.2.40. cts.fillcell/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.fillcell,1,input]`	`[(str,str)]`	`('cts.repair_timing', '1')`
`[flowgraph,sv2vasicflow,cts.fillcell,1,task]`	`str`	`fillercell_insertion`
`[flowgraph,sv2vasicflow,cts.fillcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,sv2vasicflow,cts.fillcell,1,tool]`	`str`	`openroad`

2.4.2.41. cts.fillcell/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.fillcell,2,input]`	`[(str,str)]`	`('cts.repair_timing', '2')`
`[flowgraph,sv2vasicflow,cts.fillcell,2,task]`	`str`	`fillercell_insertion`
`[flowgraph,sv2vasicflow,cts.fillcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,sv2vasicflow,cts.fillcell,2,tool]`	`str`	`openroad`

2.4.2.42. cts.min/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,cts.min,0,input]`	`[(str,str)]`	`('cts.fillcell', '0')` `('cts.fillcell', '1')` `('cts.fillcell', '2')`
`[flowgraph,sv2vasicflow,cts.min,0,task]`	`str`	`minimum`
`[flowgraph,sv2vasicflow,cts.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,sv2vasicflow,cts.min,0,tool]`	`str`	`builtin`

2.4.2.43. route.global/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.global,0,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,sv2vasicflow,route.global,0,task]`	`str`	`global_route`
`[flowgraph,sv2vasicflow,route.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,sv2vasicflow,route.global,0,tool]`	`str`	`openroad`

2.4.2.44. route.global/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.global,1,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,sv2vasicflow,route.global,1,task]`	`str`	`global_route`
`[flowgraph,sv2vasicflow,route.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,sv2vasicflow,route.global,1,tool]`	`str`	`openroad`

2.4.2.45. route.global/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.global,2,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,sv2vasicflow,route.global,2,task]`	`str`	`global_route`
`[flowgraph,sv2vasicflow,route.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,sv2vasicflow,route.global,2,tool]`	`str`	`openroad`

2.4.2.46. route.antenna_repair/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.antenna_repair,0,input]`	`[(str,str)]`	`('route.global', '0')`
`[flowgraph,sv2vasicflow,route.antenna_repair,0,task]`	`str`	`antenna_repair`
`[flowgraph,sv2vasicflow,route.antenna_repair,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,sv2vasicflow,route.antenna_repair,0,tool]`	`str`	`openroad`

2.4.2.47. route.antenna_repair/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.antenna_repair,1,input]`	`[(str,str)]`	`('route.global', '1')`
`[flowgraph,sv2vasicflow,route.antenna_repair,1,task]`	`str`	`antenna_repair`
`[flowgraph,sv2vasicflow,route.antenna_repair,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,sv2vasicflow,route.antenna_repair,1,tool]`	`str`	`openroad`

2.4.2.48. route.antenna_repair/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.antenna_repair,2,input]`	`[(str,str)]`	`('route.global', '2')`
`[flowgraph,sv2vasicflow,route.antenna_repair,2,task]`	`str`	`antenna_repair`
`[flowgraph,sv2vasicflow,route.antenna_repair,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,sv2vasicflow,route.antenna_repair,2,tool]`	`str`	`openroad`

2.4.2.49. route.detailed/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.detailed,0,input]`	`[(str,str)]`	`('route.antenna_repair', '0')`
`[flowgraph,sv2vasicflow,route.detailed,0,task]`	`str`	`detailed_route`
`[flowgraph,sv2vasicflow,route.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,sv2vasicflow,route.detailed,0,tool]`	`str`	`openroad`

2.4.2.50. route.detailed/1#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.detailed,1,input]`	`[(str,str)]`	`('route.antenna_repair', '1')`
`[flowgraph,sv2vasicflow,route.detailed,1,task]`	`str`	`detailed_route`
`[flowgraph,sv2vasicflow,route.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,sv2vasicflow,route.detailed,1,tool]`	`str`	`openroad`

2.4.2.51. route.detailed/2#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.detailed,2,input]`	`[(str,str)]`	`('route.antenna_repair', '2')`
`[flowgraph,sv2vasicflow,route.detailed,2,task]`	`str`	`detailed_route`
`[flowgraph,sv2vasicflow,route.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,sv2vasicflow,route.detailed,2,tool]`	`str`	`openroad`

2.4.2.52. route.min/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,route.min,0,input]`	`[(str,str)]`	`('route.detailed', '0')` `('route.detailed', '1')` `('route.detailed', '2')`
`[flowgraph,sv2vasicflow,route.min,0,task]`	`str`	`minimum`
`[flowgraph,sv2vasicflow,route.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,sv2vasicflow,route.min,0,tool]`	`str`	`builtin`

2.4.2.53. dfm.metal_fill/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,dfm.metal_fill,0,input]`	`[(str,str)]`	`('route.min', '0')`
`[flowgraph,sv2vasicflow,dfm.metal_fill,0,task]`	`str`	`fillmetal_insertion`
`[flowgraph,sv2vasicflow,dfm.metal_fill,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillmetal_insertion/FillMetalTask`
`[flowgraph,sv2vasicflow,dfm.metal_fill,0,tool]`	`str`	`openroad`

2.4.2.54. write.gds/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,write.gds,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,sv2vasicflow,write.gds,0,task]`	`str`	`export`
`[flowgraph,sv2vasicflow,write.gds,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.export/ExportTask`
`[flowgraph,sv2vasicflow,write.gds,0,tool]`	`str`	`klayout`

2.4.2.55. write.views/0#

Keypath	Type	Value
`[flowgraph,sv2vasicflow,write.views,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,sv2vasicflow,write.views,0,task]`	`str`	`write_data`
`[flowgraph,sv2vasicflow,write.views,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.write_data/WriteViewsTask`
`[flowgraph,sv2vasicflow,write.views,0,tool]`	`str`	`openroad`

2.5. chiselasicflow#

A Chisel-based ASIC synthesis flow.

This class extends the standard ASICFlow to support designs written in the Chisel hardware construction language. It replaces the Verilog-focused ‘elaborate’ step with a ‘convert’ step that uses the Chisel compiler to generate Verilog from the Chisel source before synthesis.

File: asicflow.py

2.5.1. Graph#

2.5.2. Nodes#

2.5.2.1. convert/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,convert,0,task]`	`str`	`convert`
`[flowgraph,chiselasicflow,convert,0,taskmodule]`	`str`	`siliconcompiler.tools.chisel.convert/ConvertTask`
`[flowgraph,chiselasicflow,convert,0,tool]`	`str`	`chisel`

2.5.2.2. synthesis/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,synthesis,0,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,chiselasicflow,synthesis,0,task]`	`str`	`syn_asic`
`[flowgraph,chiselasicflow,synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,chiselasicflow,synthesis,0,tool]`	`str`	`yosys`

2.5.2.3. synthesis/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,synthesis,1,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,chiselasicflow,synthesis,1,task]`	`str`	`syn_asic`
`[flowgraph,chiselasicflow,synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,chiselasicflow,synthesis,1,tool]`	`str`	`yosys`

2.5.2.4. synthesis/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,synthesis,2,input]`	`[(str,str)]`	`('convert', '0')`
`[flowgraph,chiselasicflow,synthesis,2,task]`	`str`	`syn_asic`
`[flowgraph,chiselasicflow,synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,chiselasicflow,synthesis,2,tool]`	`str`	`yosys`

2.5.2.5. synthesis.min/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,synthesis.min,0,input]`	`[(str,str)]`	`('synthesis', '0')` `('synthesis', '1')` `('synthesis', '2')`
`[flowgraph,chiselasicflow,synthesis.min,0,task]`	`str`	`minimum`
`[flowgraph,chiselasicflow,synthesis.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,chiselasicflow,synthesis.min,0,tool]`	`str`	`builtin`

2.5.2.6. floorplan.init/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.init,0,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,chiselasicflow,floorplan.init,0,task]`	`str`	`init_floorplan`
`[flowgraph,chiselasicflow,floorplan.init,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,chiselasicflow,floorplan.init,0,tool]`	`str`	`openroad`

2.5.2.7. floorplan.init/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.init,1,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,chiselasicflow,floorplan.init,1,task]`	`str`	`init_floorplan`
`[flowgraph,chiselasicflow,floorplan.init,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,chiselasicflow,floorplan.init,1,tool]`	`str`	`openroad`

2.5.2.8. floorplan.init/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.init,2,input]`	`[(str,str)]`	`('synthesis.min', '0')`
`[flowgraph,chiselasicflow,floorplan.init,2,task]`	`str`	`init_floorplan`
`[flowgraph,chiselasicflow,floorplan.init,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.init_floorplan/InitFloorplanTask`
`[flowgraph,chiselasicflow,floorplan.init,2,tool]`	`str`	`openroad`

2.5.2.9. floorplan.macro_placement/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.macro_placement,0,input]`	`[(str,str)]`	`('floorplan.init', '0')`
`[flowgraph,chiselasicflow,floorplan.macro_placement,0,task]`	`str`	`macro_placement`
`[flowgraph,chiselasicflow,floorplan.macro_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,chiselasicflow,floorplan.macro_placement,0,tool]`	`str`	`openroad`

2.5.2.10. floorplan.macro_placement/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.macro_placement,1,input]`	`[(str,str)]`	`('floorplan.init', '1')`
`[flowgraph,chiselasicflow,floorplan.macro_placement,1,task]`	`str`	`macro_placement`
`[flowgraph,chiselasicflow,floorplan.macro_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,chiselasicflow,floorplan.macro_placement,1,tool]`	`str`	`openroad`

2.5.2.11. floorplan.macro_placement/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.macro_placement,2,input]`	`[(str,str)]`	`('floorplan.init', '2')`
`[flowgraph,chiselasicflow,floorplan.macro_placement,2,task]`	`str`	`macro_placement`
`[flowgraph,chiselasicflow,floorplan.macro_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.macro_placement/MacroPlacementTask`
`[flowgraph,chiselasicflow,floorplan.macro_placement,2,tool]`	`str`	`openroad`

2.5.2.12. floorplan.tapcell/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.tapcell,0,input]`	`[(str,str)]`	`('floorplan.macro_placement', '0')`
`[flowgraph,chiselasicflow,floorplan.tapcell,0,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,chiselasicflow,floorplan.tapcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,chiselasicflow,floorplan.tapcell,0,tool]`	`str`	`openroad`

2.5.2.13. floorplan.tapcell/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.tapcell,1,input]`	`[(str,str)]`	`('floorplan.macro_placement', '1')`
`[flowgraph,chiselasicflow,floorplan.tapcell,1,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,chiselasicflow,floorplan.tapcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,chiselasicflow,floorplan.tapcell,1,tool]`	`str`	`openroad`

2.5.2.14. floorplan.tapcell/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.tapcell,2,input]`	`[(str,str)]`	`('floorplan.macro_placement', '2')`
`[flowgraph,chiselasicflow,floorplan.tapcell,2,task]`	`str`	`endcap_tapcell_insertion`
`[flowgraph,chiselasicflow,floorplan.tapcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.endcap_tapcell_insertion/EndCapTapCellTask`
`[flowgraph,chiselasicflow,floorplan.tapcell,2,tool]`	`str`	`openroad`

2.5.2.15. floorplan.power_grid/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.power_grid,0,input]`	`[(str,str)]`	`('floorplan.tapcell', '0')`
`[flowgraph,chiselasicflow,floorplan.power_grid,0,task]`	`str`	`power_grid`
`[flowgraph,chiselasicflow,floorplan.power_grid,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,chiselasicflow,floorplan.power_grid,0,tool]`	`str`	`openroad`

2.5.2.16. floorplan.power_grid/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.power_grid,1,input]`	`[(str,str)]`	`('floorplan.tapcell', '1')`
`[flowgraph,chiselasicflow,floorplan.power_grid,1,task]`	`str`	`power_grid`
`[flowgraph,chiselasicflow,floorplan.power_grid,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,chiselasicflow,floorplan.power_grid,1,tool]`	`str`	`openroad`

2.5.2.17. floorplan.power_grid/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.power_grid,2,input]`	`[(str,str)]`	`('floorplan.tapcell', '2')`
`[flowgraph,chiselasicflow,floorplan.power_grid,2,task]`	`str`	`power_grid`
`[flowgraph,chiselasicflow,floorplan.power_grid,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.power_grid/PowerGridTask`
`[flowgraph,chiselasicflow,floorplan.power_grid,2,tool]`	`str`	`openroad`

2.5.2.18. floorplan.pin_placement/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.pin_placement,0,input]`	`[(str,str)]`	`('floorplan.power_grid', '0')`
`[flowgraph,chiselasicflow,floorplan.pin_placement,0,task]`	`str`	`pin_placement`
`[flowgraph,chiselasicflow,floorplan.pin_placement,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,chiselasicflow,floorplan.pin_placement,0,tool]`	`str`	`openroad`

2.5.2.19. floorplan.pin_placement/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.pin_placement,1,input]`	`[(str,str)]`	`('floorplan.power_grid', '1')`
`[flowgraph,chiselasicflow,floorplan.pin_placement,1,task]`	`str`	`pin_placement`
`[flowgraph,chiselasicflow,floorplan.pin_placement,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,chiselasicflow,floorplan.pin_placement,1,tool]`	`str`	`openroad`

2.5.2.20. floorplan.pin_placement/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.pin_placement,2,input]`	`[(str,str)]`	`('floorplan.power_grid', '2')`
`[flowgraph,chiselasicflow,floorplan.pin_placement,2,task]`	`str`	`pin_placement`
`[flowgraph,chiselasicflow,floorplan.pin_placement,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.pin_placement/PinPlacementTask`
`[flowgraph,chiselasicflow,floorplan.pin_placement,2,tool]`	`str`	`openroad`

2.5.2.21. floorplan.min/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,floorplan.min,0,input]`	`[(str,str)]`	`('floorplan.pin_placement', '0')` `('floorplan.pin_placement', '1')` `('floorplan.pin_placement', '2')`
`[flowgraph,chiselasicflow,floorplan.min,0,task]`	`str`	`minimum`
`[flowgraph,chiselasicflow,floorplan.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,chiselasicflow,floorplan.min,0,tool]`	`str`	`builtin`

2.5.2.22. place.global/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.global,0,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,chiselasicflow,place.global,0,task]`	`str`	`global_placement`
`[flowgraph,chiselasicflow,place.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,chiselasicflow,place.global,0,tool]`	`str`	`openroad`

2.5.2.23. place.global/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.global,1,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,chiselasicflow,place.global,1,task]`	`str`	`global_placement`
`[flowgraph,chiselasicflow,place.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,chiselasicflow,place.global,1,tool]`	`str`	`openroad`

2.5.2.24. place.global/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.global,2,input]`	`[(str,str)]`	`('floorplan.min', '0')`
`[flowgraph,chiselasicflow,place.global,2,task]`	`str`	`global_placement`
`[flowgraph,chiselasicflow,place.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_placement/GlobalPlacementTask`
`[flowgraph,chiselasicflow,place.global,2,tool]`	`str`	`openroad`

2.5.2.25. place.repair_design/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.repair_design,0,input]`	`[(str,str)]`	`('place.global', '0')`
`[flowgraph,chiselasicflow,place.repair_design,0,task]`	`str`	`repair_design`
`[flowgraph,chiselasicflow,place.repair_design,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,chiselasicflow,place.repair_design,0,tool]`	`str`	`openroad`

2.5.2.26. place.repair_design/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.repair_design,1,input]`	`[(str,str)]`	`('place.global', '1')`
`[flowgraph,chiselasicflow,place.repair_design,1,task]`	`str`	`repair_design`
`[flowgraph,chiselasicflow,place.repair_design,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,chiselasicflow,place.repair_design,1,tool]`	`str`	`openroad`

2.5.2.27. place.repair_design/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.repair_design,2,input]`	`[(str,str)]`	`('place.global', '2')`
`[flowgraph,chiselasicflow,place.repair_design,2,task]`	`str`	`repair_design`
`[flowgraph,chiselasicflow,place.repair_design,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_design/RepairDesignTask`
`[flowgraph,chiselasicflow,place.repair_design,2,tool]`	`str`	`openroad`

2.5.2.28. place.detailed/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.detailed,0,input]`	`[(str,str)]`	`('place.repair_design', '0')`
`[flowgraph,chiselasicflow,place.detailed,0,task]`	`str`	`detailed_placement`
`[flowgraph,chiselasicflow,place.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,chiselasicflow,place.detailed,0,tool]`	`str`	`openroad`

2.5.2.29. place.detailed/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.detailed,1,input]`	`[(str,str)]`	`('place.repair_design', '1')`
`[flowgraph,chiselasicflow,place.detailed,1,task]`	`str`	`detailed_placement`
`[flowgraph,chiselasicflow,place.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,chiselasicflow,place.detailed,1,tool]`	`str`	`openroad`

2.5.2.30. place.detailed/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.detailed,2,input]`	`[(str,str)]`	`('place.repair_design', '2')`
`[flowgraph,chiselasicflow,place.detailed,2,task]`	`str`	`detailed_placement`
`[flowgraph,chiselasicflow,place.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_placement/DetailedPlacementTask`
`[flowgraph,chiselasicflow,place.detailed,2,tool]`	`str`	`openroad`

2.5.2.31. place.min/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,place.min,0,input]`	`[(str,str)]`	`('place.detailed', '0')` `('place.detailed', '1')` `('place.detailed', '2')`
`[flowgraph,chiselasicflow,place.min,0,task]`	`str`	`minimum`
`[flowgraph,chiselasicflow,place.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,chiselasicflow,place.min,0,tool]`	`str`	`builtin`

2.5.2.32. cts.clock_tree_synthesis/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,0,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,0,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,0,tool]`	`str`	`openroad`

2.5.2.33. cts.clock_tree_synthesis/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,1,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,1,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,1,tool]`	`str`	`openroad`

2.5.2.34. cts.clock_tree_synthesis/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,2,input]`	`[(str,str)]`	`('place.min', '0')`
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,2,task]`	`str`	`clock_tree_synthesis`
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.clock_tree_synthesis/CTSTask`
`[flowgraph,chiselasicflow,cts.clock_tree_synthesis,2,tool]`	`str`	`openroad`

2.5.2.35. cts.repair_timing/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.repair_timing,0,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '0')`
`[flowgraph,chiselasicflow,cts.repair_timing,0,task]`	`str`	`repair_timing`
`[flowgraph,chiselasicflow,cts.repair_timing,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,chiselasicflow,cts.repair_timing,0,tool]`	`str`	`openroad`

2.5.2.36. cts.repair_timing/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.repair_timing,1,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '1')`
`[flowgraph,chiselasicflow,cts.repair_timing,1,task]`	`str`	`repair_timing`
`[flowgraph,chiselasicflow,cts.repair_timing,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,chiselasicflow,cts.repair_timing,1,tool]`	`str`	`openroad`

2.5.2.37. cts.repair_timing/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.repair_timing,2,input]`	`[(str,str)]`	`('cts.clock_tree_synthesis', '2')`
`[flowgraph,chiselasicflow,cts.repair_timing,2,task]`	`str`	`repair_timing`
`[flowgraph,chiselasicflow,cts.repair_timing,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.repair_timing/RepairTimingTask`
`[flowgraph,chiselasicflow,cts.repair_timing,2,tool]`	`str`	`openroad`

2.5.2.38. cts.fillcell/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.fillcell,0,input]`	`[(str,str)]`	`('cts.repair_timing', '0')`
`[flowgraph,chiselasicflow,cts.fillcell,0,task]`	`str`	`fillercell_insertion`
`[flowgraph,chiselasicflow,cts.fillcell,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,chiselasicflow,cts.fillcell,0,tool]`	`str`	`openroad`

2.5.2.39. cts.fillcell/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.fillcell,1,input]`	`[(str,str)]`	`('cts.repair_timing', '1')`
`[flowgraph,chiselasicflow,cts.fillcell,1,task]`	`str`	`fillercell_insertion`
`[flowgraph,chiselasicflow,cts.fillcell,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,chiselasicflow,cts.fillcell,1,tool]`	`str`	`openroad`

2.5.2.40. cts.fillcell/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.fillcell,2,input]`	`[(str,str)]`	`('cts.repair_timing', '2')`
`[flowgraph,chiselasicflow,cts.fillcell,2,task]`	`str`	`fillercell_insertion`
`[flowgraph,chiselasicflow,cts.fillcell,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillercell_insertion/FillCellTask`
`[flowgraph,chiselasicflow,cts.fillcell,2,tool]`	`str`	`openroad`

2.5.2.41. cts.min/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,cts.min,0,input]`	`[(str,str)]`	`('cts.fillcell', '0')` `('cts.fillcell', '1')` `('cts.fillcell', '2')`
`[flowgraph,chiselasicflow,cts.min,0,task]`	`str`	`minimum`
`[flowgraph,chiselasicflow,cts.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,chiselasicflow,cts.min,0,tool]`	`str`	`builtin`

2.5.2.42. route.global/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.global,0,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,chiselasicflow,route.global,0,task]`	`str`	`global_route`
`[flowgraph,chiselasicflow,route.global,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,chiselasicflow,route.global,0,tool]`	`str`	`openroad`

2.5.2.43. route.global/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.global,1,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,chiselasicflow,route.global,1,task]`	`str`	`global_route`
`[flowgraph,chiselasicflow,route.global,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,chiselasicflow,route.global,1,tool]`	`str`	`openroad`

2.5.2.44. route.global/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.global,2,input]`	`[(str,str)]`	`('cts.min', '0')`
`[flowgraph,chiselasicflow,route.global,2,task]`	`str`	`global_route`
`[flowgraph,chiselasicflow,route.global,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.global_route/GlobalRouteTask`
`[flowgraph,chiselasicflow,route.global,2,tool]`	`str`	`openroad`

2.5.2.45. route.antenna_repair/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.antenna_repair,0,input]`	`[(str,str)]`	`('route.global', '0')`
`[flowgraph,chiselasicflow,route.antenna_repair,0,task]`	`str`	`antenna_repair`
`[flowgraph,chiselasicflow,route.antenna_repair,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,chiselasicflow,route.antenna_repair,0,tool]`	`str`	`openroad`

2.5.2.46. route.antenna_repair/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.antenna_repair,1,input]`	`[(str,str)]`	`('route.global', '1')`
`[flowgraph,chiselasicflow,route.antenna_repair,1,task]`	`str`	`antenna_repair`
`[flowgraph,chiselasicflow,route.antenna_repair,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,chiselasicflow,route.antenna_repair,1,tool]`	`str`	`openroad`

2.5.2.47. route.antenna_repair/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.antenna_repair,2,input]`	`[(str,str)]`	`('route.global', '2')`
`[flowgraph,chiselasicflow,route.antenna_repair,2,task]`	`str`	`antenna_repair`
`[flowgraph,chiselasicflow,route.antenna_repair,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.antenna_repair/AntennaRepairTask`
`[flowgraph,chiselasicflow,route.antenna_repair,2,tool]`	`str`	`openroad`

2.5.2.48. route.detailed/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.detailed,0,input]`	`[(str,str)]`	`('route.antenna_repair', '0')`
`[flowgraph,chiselasicflow,route.detailed,0,task]`	`str`	`detailed_route`
`[flowgraph,chiselasicflow,route.detailed,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,chiselasicflow,route.detailed,0,tool]`	`str`	`openroad`

2.5.2.49. route.detailed/1#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.detailed,1,input]`	`[(str,str)]`	`('route.antenna_repair', '1')`
`[flowgraph,chiselasicflow,route.detailed,1,task]`	`str`	`detailed_route`
`[flowgraph,chiselasicflow,route.detailed,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,chiselasicflow,route.detailed,1,tool]`	`str`	`openroad`

2.5.2.50. route.detailed/2#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.detailed,2,input]`	`[(str,str)]`	`('route.antenna_repair', '2')`
`[flowgraph,chiselasicflow,route.detailed,2,task]`	`str`	`detailed_route`
`[flowgraph,chiselasicflow,route.detailed,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.detailed_route/DetailedRouteTask`
`[flowgraph,chiselasicflow,route.detailed,2,tool]`	`str`	`openroad`

2.5.2.51. route.min/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,route.min,0,input]`	`[(str,str)]`	`('route.detailed', '0')` `('route.detailed', '1')` `('route.detailed', '2')`
`[flowgraph,chiselasicflow,route.min,0,task]`	`str`	`minimum`
`[flowgraph,chiselasicflow,route.min,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,chiselasicflow,route.min,0,tool]`	`str`	`builtin`

2.5.2.52. dfm.metal_fill/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,dfm.metal_fill,0,input]`	`[(str,str)]`	`('route.min', '0')`
`[flowgraph,chiselasicflow,dfm.metal_fill,0,task]`	`str`	`fillmetal_insertion`
`[flowgraph,chiselasicflow,dfm.metal_fill,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.fillmetal_insertion/FillMetalTask`
`[flowgraph,chiselasicflow,dfm.metal_fill,0,tool]`	`str`	`openroad`

2.5.2.53. write.gds/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,write.gds,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,chiselasicflow,write.gds,0,task]`	`str`	`export`
`[flowgraph,chiselasicflow,write.gds,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.export/ExportTask`
`[flowgraph,chiselasicflow,write.gds,0,tool]`	`str`	`klayout`

2.5.2.54. write.views/0#

Keypath	Type	Value
`[flowgraph,chiselasicflow,write.views,0,input]`	`[(str,str)]`	`('dfm.metal_fill', '0')`
`[flowgraph,chiselasicflow,write.views,0,task]`	`str`	`write_data`
`[flowgraph,chiselasicflow,write.views,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.write_data/WriteViewsTask`
`[flowgraph,chiselasicflow,write.views,0,tool]`	`str`	`openroad`

2.6. drcflow#

A design rule check (DRC) flow.

This flow is designed to perform a DRC run on an input GDSII file using KLayout.

File: drcflow.py

2.6.1. Graph#

2.6.2. Nodes#

2.6.2.1. drc/0#

Keypath	Type	Value
`[flowgraph,drcflow,drc,0,task]`	`str`	`drc`
`[flowgraph,drcflow,drc,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.drc/DRCTask`
`[flowgraph,drcflow,drc,0,tool]`	`str`	`klayout`

2.7. dvflow-icarus#

A configurable constrained random stimulus DV flow.

The verification pipeline includes the following steps:

compile: RTL sources are compiled into an intermediate format.

sim: The compiled design is simulated with a generated testbench.

The dvflow can be parametrized using the ‘np’ parameter. Setting ‘np’ > 1 results in multiple independent verification pipelines being launched in parallel.

Supported tools are:

‘icarus’: Compiles and simulates with the Icarus Verilog simulator.

‘icarus-cocotb’: Compiles with Icarus and runs cocotb Python testbenches.

‘verilator’: Compiles and simulates with Verilator.

‘verilator-cocotb’: Compiles with Verilator and runs cocotb Python testbenches.

‘xyce’: Simulates a netlist with the Xyce circuit simulator.

‘xdm-xyce’: Converts a design to a Xyce-compatible format and simulates.

File: dvflow.py

2.7.1. Graph#

2.7.2. Nodes#

2.7.2.1. compile/0#

Keypath	Type	Value
`[flowgraph,dvflow-icarus,compile,0,task]`	`str`	`compile`
`[flowgraph,dvflow-icarus,compile,0,taskmodule]`	`str`	`siliconcompiler.tools.icarus.compile/CompileTask`
`[flowgraph,dvflow-icarus,compile,0,tool]`	`str`	`icarus`

2.7.2.2. simulate/0#

Keypath	Type	Value
`[flowgraph,dvflow-icarus,simulate,0,input]`	`[(str,str)]`	`('compile', '0')`
`[flowgraph,dvflow-icarus,simulate,0,task]`	`str`	`exec_input`
`[flowgraph,dvflow-icarus,simulate,0,taskmodule]`	`str`	`siliconcompiler.tools.execute.exec_input/ExecInputTask`
`[flowgraph,dvflow-icarus,simulate,0,tool]`	`str`	`execute`

2.8. fpgaflow-nextpnr#

An open-source FPGA flow using Yosys and NextPNR.

This flow is tailored for FPGAs supported by the NextPNR tool, which handles placement, routing, and bitstream generation in a single step.

The flow consists of the following steps:

syn_fpga: Synthesize RTL into a device-specific netlist using Yosys.

apr: Perform automatic place and route (APR) and generate the
bitstream using NextPNR.

File: fpgaflow.py

2.8.1. Graph#

2.8.2. Nodes#

2.8.2.1. elaborate/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-nextpnr,elaborate,0,task]`	`str`	`elaborate`
`[flowgraph,fpgaflow-nextpnr,elaborate,0,taskmodule]`	`str`	`siliconcompiler.tools.slang.elaborate/Elaborate`
`[flowgraph,fpgaflow-nextpnr,elaborate,0,tool]`	`str`	`slang`

2.8.2.2. syn_fpga/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-nextpnr,syn_fpga,0,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,fpgaflow-nextpnr,syn_fpga,0,task]`	`str`	`syn_fpga`
`[flowgraph,fpgaflow-nextpnr,syn_fpga,0,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_fpga/FPGASynthesis`
`[flowgraph,fpgaflow-nextpnr,syn_fpga,0,tool]`	`str`	`yosys`

2.8.2.3. apr/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-nextpnr,apr,0,input]`	`[(str,str)]`	`('syn_fpga', '0')`
`[flowgraph,fpgaflow-nextpnr,apr,0,task]`	`str`	`apr`
`[flowgraph,fpgaflow-nextpnr,apr,0,taskmodule]`	`str`	`siliconcompiler.tools.nextpnr.apr/APRTask`
`[flowgraph,fpgaflow-nextpnr,apr,0,tool]`	`str`	`nextpnr`

2.9. fpgaflow-vpr#

An open-source FPGA flow using Yosys, VPR, and GenFasm.

This flow is designed for academic and research FPGAs, utilizing VPR (Versatile Place and Route) for placement and routing.

The flow consists of the following steps:

elaborate: Elaborate the RTL design from sources.

synthesis: Synthesize the elaborated design into a netlist using Yosys.

place: Place the netlist components onto the FPGA architecture using VPR.

route: Route the connections between placed components using VPR.

bitstream: Generate the final bitstream using GenFasm.

File: fpgaflow.py

2.9.1. Graph#

2.9.2. Nodes#

2.9.2.1. elaborate/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr,elaborate,0,task]`	`str`	`elaborate`
`[flowgraph,fpgaflow-vpr,elaborate,0,taskmodule]`	`str`	`siliconcompiler.tools.slang.elaborate/Elaborate`
`[flowgraph,fpgaflow-vpr,elaborate,0,tool]`	`str`	`slang`

2.9.2.2. synthesis/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr,synthesis,0,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,fpgaflow-vpr,synthesis,0,task]`	`str`	`syn_fpga`
`[flowgraph,fpgaflow-vpr,synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_fpga/FPGASynthesis`
`[flowgraph,fpgaflow-vpr,synthesis,0,tool]`	`str`	`yosys`

2.9.2.3. place/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr,place,0,input]`	`[(str,str)]`	`('synthesis', '0')`
`[flowgraph,fpgaflow-vpr,place,0,task]`	`str`	`place`
`[flowgraph,fpgaflow-vpr,place,0,taskmodule]`	`str`	`siliconcompiler.tools.vpr.place/PlaceTask`
`[flowgraph,fpgaflow-vpr,place,0,tool]`	`str`	`vpr`

2.9.2.4. route/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr,route,0,input]`	`[(str,str)]`	`('place', '0')`
`[flowgraph,fpgaflow-vpr,route,0,task]`	`str`	`route`
`[flowgraph,fpgaflow-vpr,route,0,taskmodule]`	`str`	`siliconcompiler.tools.vpr.route/RouteTask`
`[flowgraph,fpgaflow-vpr,route,0,tool]`	`str`	`vpr`

2.9.2.5. bitstream/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr,bitstream,0,input]`	`[(str,str)]`	`('route', '0')`
`[flowgraph,fpgaflow-vpr,bitstream,0,task]`	`str`	`bitstream`
`[flowgraph,fpgaflow-vpr,bitstream,0,taskmodule]`	`str`	`siliconcompiler.tools.genfasm.bitstream/BitstreamTask`
`[flowgraph,fpgaflow-vpr,bitstream,0,tool]`	`str`	`genfasm`

2.10. fpgaflow-vpr-open-sta#

An open-source FPGA flow using Yosys, VPR, GenFasm, and OpenSTA.

This flow is designed for academic and research FPGAs, utilizing VPR (Versatile Place and Route) for placement and routing and OpenSTA for post-implementation timing analysis.

The flow consists of the following steps:

elaborate: Elaborate the RTL design from sources.

synthesis: Synthesize the elaborated design into a netlist using Yosys.

place: Place the netlist components onto the FPGA architecture using VPR.

route: Route the connections between placed components using VPR.

bitstream: Generate the final bitstream using GenFasm.

timing: Perform post-implementation static timing analysis of the design.

File: fpgaflow.py

2.10.1. Graph#

2.10.2. Nodes#

2.10.2.1. elaborate/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr-open-sta,elaborate,0,task]`	`str`	`elaborate`
`[flowgraph,fpgaflow-vpr-open-sta,elaborate,0,taskmodule]`	`str`	`siliconcompiler.tools.slang.elaborate/Elaborate`
`[flowgraph,fpgaflow-vpr-open-sta,elaborate,0,tool]`	`str`	`slang`

2.10.2.2. synthesis/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr-open-sta,synthesis,0,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,fpgaflow-vpr-open-sta,synthesis,0,task]`	`str`	`syn_fpga`
`[flowgraph,fpgaflow-vpr-open-sta,synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_fpga/FPGASynthesis`
`[flowgraph,fpgaflow-vpr-open-sta,synthesis,0,tool]`	`str`	`yosys`

2.10.2.3. place/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr-open-sta,place,0,input]`	`[(str,str)]`	`('synthesis', '0')`
`[flowgraph,fpgaflow-vpr-open-sta,place,0,task]`	`str`	`place`
`[flowgraph,fpgaflow-vpr-open-sta,place,0,taskmodule]`	`str`	`siliconcompiler.tools.vpr.place/PlaceTask`
`[flowgraph,fpgaflow-vpr-open-sta,place,0,tool]`	`str`	`vpr`

2.10.2.4. route/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr-open-sta,route,0,input]`	`[(str,str)]`	`('place', '0')`
`[flowgraph,fpgaflow-vpr-open-sta,route,0,task]`	`str`	`route`
`[flowgraph,fpgaflow-vpr-open-sta,route,0,taskmodule]`	`str`	`siliconcompiler.tools.vpr.route/RouteTask`
`[flowgraph,fpgaflow-vpr-open-sta,route,0,tool]`	`str`	`vpr`

2.10.2.5. bitstream/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr-open-sta,bitstream,0,input]`	`[(str,str)]`	`('route', '0')`
`[flowgraph,fpgaflow-vpr-open-sta,bitstream,0,task]`	`str`	`bitstream`
`[flowgraph,fpgaflow-vpr-open-sta,bitstream,0,taskmodule]`	`str`	`siliconcompiler.tools.genfasm.bitstream/BitstreamTask`
`[flowgraph,fpgaflow-vpr-open-sta,bitstream,0,tool]`	`str`	`genfasm`

2.10.2.6. timing/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-vpr-open-sta,timing,0,input]`	`[(str,str)]`	`('route', '0')`
`[flowgraph,fpgaflow-vpr-open-sta,timing,0,task]`	`str`	`fpga_timing`
`[flowgraph,fpgaflow-vpr-open-sta,timing,0,taskmodule]`	`str`	`siliconcompiler.tools.opensta.timing/FPGATimingTask`
`[flowgraph,fpgaflow-vpr-open-sta,timing,0,tool]`	`str`	`opensta`

2.11. fpgaflow-xilinx#

An FPGA compilation flow targeting Xilinx devices using Vivado.

This flow uses the commercial Vivado toolchain for synthesis, placement, routing, and bitstream generation.

The flow consists of the following steps:

syn_fpga: Synthesize RTL into a device-specific netlist.

place: Place the synthesized netlist onto the FPGA fabric.

route: Route the connections between placed components.

bitstream: Generate the final bitstream for device programming.

File: fpgaflow.py

2.11.1. Graph#

2.11.2. Nodes#

2.11.2.1. elaborate/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-xilinx,elaborate,0,task]`	`str`	`elaborate`
`[flowgraph,fpgaflow-xilinx,elaborate,0,taskmodule]`	`str`	`siliconcompiler.tools.slang.elaborate/Elaborate`
`[flowgraph,fpgaflow-xilinx,elaborate,0,tool]`	`str`	`slang`

2.11.2.2. syn_fpga/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-xilinx,syn_fpga,0,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,fpgaflow-xilinx,syn_fpga,0,task]`	`str`	`syn_fpga`
`[flowgraph,fpgaflow-xilinx,syn_fpga,0,taskmodule]`	`str`	`siliconcompiler.tools.vivado.syn_fpga/SynthesisTask`
`[flowgraph,fpgaflow-xilinx,syn_fpga,0,tool]`	`str`	`vivado`

2.11.2.3. place/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-xilinx,place,0,input]`	`[(str,str)]`	`('syn_fpga', '0')`
`[flowgraph,fpgaflow-xilinx,place,0,task]`	`str`	`place`
`[flowgraph,fpgaflow-xilinx,place,0,taskmodule]`	`str`	`siliconcompiler.tools.vivado.place/PlaceTask`
`[flowgraph,fpgaflow-xilinx,place,0,tool]`	`str`	`vivado`

2.11.2.4. route/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-xilinx,route,0,input]`	`[(str,str)]`	`('place', '0')`
`[flowgraph,fpgaflow-xilinx,route,0,task]`	`str`	`route`
`[flowgraph,fpgaflow-xilinx,route,0,taskmodule]`	`str`	`siliconcompiler.tools.vivado.route/RouteTask`
`[flowgraph,fpgaflow-xilinx,route,0,tool]`	`str`	`vivado`

2.11.2.5. bitstream/0#

Keypath	Type	Value
`[flowgraph,fpgaflow-xilinx,bitstream,0,input]`	`[(str,str)]`	`('route', '0')`
`[flowgraph,fpgaflow-xilinx,bitstream,0,task]`	`str`	`bitstream`
`[flowgraph,fpgaflow-xilinx,bitstream,0,taskmodule]`	`str`	`siliconcompiler.tools.vivado.bitstream/BitstreamTask`
`[flowgraph,fpgaflow-xilinx,bitstream,0,tool]`	`str`	`vivado`

2.12. generate_rcx / 0#

A flow to generate OpenRCX parasitic extraction decks for OpenROAD.

This flow automates the process of characterizing a parasitic extraction tool to generate the necessary configuration files (RCX decks) for OpenROAD’s built-in OpenRCX engine. It works by comparing the output of a third-party “golden” extraction tool against OpenRCX’s results and calibrating OpenRCX accordingly.

The flow consists of the following main steps for each specified corner:

bench: A benchmark design with simple structures is created.

pex: A user-provided third-party PEX tool is run on the benchmark
to generate a “golden” SPEF file.

extract: The golden SPEF is used to generate a calibrated OpenRCX
deck.

File: generate_openroad_rcx.py

2.12.1. Graph#

2.12.2. Nodes#

2.12.2.1. bench/0#

Keypath	Type	Value
`[flowgraph,generate_rcx,bench,0,task]`	`str`	`rcx_bench`
`[flowgraph,generate_rcx,bench,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.rcx_bench/ORXBenchTask`
`[flowgraph,generate_rcx,bench,0,tool]`	`str`	`openroad`

2.12.2.2. pex/0#

Keypath	Type	Value
`[flowgraph,generate_rcx,pex,0,input]`	`[(str,str)]`	`('bench', '0')`
`[flowgraph,generate_rcx,pex,0,task]`	`str`	`nop`
`[flowgraph,generate_rcx,pex,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.nop/NOPTask`
`[flowgraph,generate_rcx,pex,0,tool]`	`str`	`builtin`

2.12.2.3. pex/1#

Keypath	Type	Value
`[flowgraph,generate_rcx,pex,1,input]`	`[(str,str)]`	`('bench', '0')`
`[flowgraph,generate_rcx,pex,1,task]`	`str`	`nop`
`[flowgraph,generate_rcx,pex,1,taskmodule]`	`str`	`siliconcompiler.tools.builtin.nop/NOPTask`
`[flowgraph,generate_rcx,pex,1,tool]`	`str`	`builtin`

2.12.2.4. pex/2#

Keypath	Type	Value
`[flowgraph,generate_rcx,pex,2,input]`	`[(str,str)]`	`('bench', '0')`
`[flowgraph,generate_rcx,pex,2,task]`	`str`	`nop`
`[flowgraph,generate_rcx,pex,2,taskmodule]`	`str`	`siliconcompiler.tools.builtin.nop/NOPTask`
`[flowgraph,generate_rcx,pex,2,tool]`	`str`	`builtin`

2.12.2.5. extract/0#

Keypath	Type	Value
`[flowgraph,generate_rcx,extract,0,input]`	`[(str,str)]`	`('pex', '0')` `('bench', '0')`
`[flowgraph,generate_rcx,extract,0,task]`	`str`	`rcx_extract`
`[flowgraph,generate_rcx,extract,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.rcx_extract/ORXExtractTask`
`[flowgraph,generate_rcx,extract,0,tool]`	`str`	`openroad`

2.12.2.6. extract/1#

Keypath	Type	Value
`[flowgraph,generate_rcx,extract,1,input]`	`[(str,str)]`	`('pex', '1')` `('bench', '0')`
`[flowgraph,generate_rcx,extract,1,task]`	`str`	`rcx_extract`
`[flowgraph,generate_rcx,extract,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.rcx_extract/ORXExtractTask`
`[flowgraph,generate_rcx,extract,1,tool]`	`str`	`openroad`

2.12.2.7. extract/2#

Keypath	Type	Value
`[flowgraph,generate_rcx,extract,2,input]`	`[(str,str)]`	`('pex', '2')` `('bench', '0')`
`[flowgraph,generate_rcx,extract,2,task]`	`str`	`rcx_extract`
`[flowgraph,generate_rcx,extract,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.rcx_extract/ORXExtractTask`
`[flowgraph,generate_rcx,extract,2,tool]`	`str`	`openroad`

2.13. generate_rcx / 1#

A flow to generate OpenRCX parasitic extraction decks for OpenROAD.

The flow consists of the following main steps for each specified corner:

bench: A benchmark design with simple structures is created.

pex: A user-provided third-party PEX tool is run on the benchmark
to generate a “golden” SPEF file.

extract: The golden SPEF is used to generate a calibrated OpenRCX
deck.

File: generate_openroad_rcx.py

2.13.1. Graph#

2.13.2. Nodes#

2.13.2.1. bench/0#

Keypath	Type	Value
`[flowgraph,generate_rcx,bench,0,task]`	`str`	`rcx_bench`
`[flowgraph,generate_rcx,bench,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.rcx_bench/ORXBenchTask`
`[flowgraph,generate_rcx,bench,0,tool]`	`str`	`openroad`

2.13.2.2. pex/0#

Keypath	Type	Value
`[flowgraph,generate_rcx,pex,0,input]`	`[(str,str)]`	`('bench', '0')`
`[flowgraph,generate_rcx,pex,0,task]`	`str`	`nop`
`[flowgraph,generate_rcx,pex,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.nop/NOPTask`
`[flowgraph,generate_rcx,pex,0,tool]`	`str`	`builtin`

2.13.2.3. extract/0#

Keypath	Type	Value
`[flowgraph,generate_rcx,extract,0,input]`	`[(str,str)]`	`('pex', '0')` `('bench', '0')`
`[flowgraph,generate_rcx,extract,0,task]`	`str`	`rcx_extract`
`[flowgraph,generate_rcx,extract,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.rcx_extract/ORXExtractTask`
`[flowgraph,generate_rcx,extract,0,tool]`	`str`	`openroad`

2.13.2.4. pex/1#

Keypath	Type	Value
`[flowgraph,generate_rcx,pex,1,input]`	`[(str,str)]`	`('bench', '0')` `('pex', '0')`
`[flowgraph,generate_rcx,pex,1,task]`	`str`	`nop`
`[flowgraph,generate_rcx,pex,1,taskmodule]`	`str`	`siliconcompiler.tools.builtin.nop/NOPTask`
`[flowgraph,generate_rcx,pex,1,tool]`	`str`	`builtin`

2.13.2.5. extract/1#

Keypath	Type	Value
`[flowgraph,generate_rcx,extract,1,input]`	`[(str,str)]`	`('pex', '1')` `('bench', '0')`
`[flowgraph,generate_rcx,extract,1,task]`	`str`	`rcx_extract`
`[flowgraph,generate_rcx,extract,1,taskmodule]`	`str`	`siliconcompiler.tools.openroad.rcx_extract/ORXExtractTask`
`[flowgraph,generate_rcx,extract,1,tool]`	`str`	`openroad`

2.13.2.6. pex/2#

Keypath	Type	Value
`[flowgraph,generate_rcx,pex,2,input]`	`[(str,str)]`	`('bench', '0')` `('pex', '1')`
`[flowgraph,generate_rcx,pex,2,task]`	`str`	`nop`
`[flowgraph,generate_rcx,pex,2,taskmodule]`	`str`	`siliconcompiler.tools.builtin.nop/NOPTask`
`[flowgraph,generate_rcx,pex,2,tool]`	`str`	`builtin`

2.13.2.7. extract/2#

Keypath	Type	Value
`[flowgraph,generate_rcx,extract,2,input]`	`[(str,str)]`	`('pex', '2')` `('bench', '0')`
`[flowgraph,generate_rcx,extract,2,task]`	`str`	`rcx_extract`
`[flowgraph,generate_rcx,extract,2,taskmodule]`	`str`	`siliconcompiler.tools.openroad.rcx_extract/ORXExtractTask`
`[flowgraph,generate_rcx,extract,2,tool]`	`str`	`openroad`

2.14. interposerflow#

A flow to perform Redistribution Layer (RDL) routing and generate a GDS.

This flow is designed for creating interposers or other simple routing layers. It uses OpenROAD for RDL routing and KLayout to export the final layout to a GDSII file.

The flow consists of the following steps:

rdlroute: Performs RDL routing on the input design.

write_gds: Exports the routed design to a GDSII file.

File: interposerflow.py

2.14.1. Graph#

2.14.2. Nodes#

2.14.2.1. rdlroute/0#

Keypath	Type	Value
`[flowgraph,interposerflow,rdlroute,0,task]`	`str`	`rdlroute`
`[flowgraph,interposerflow,rdlroute,0,taskmodule]`	`str`	`siliconcompiler.tools.openroad.rdlroute/RDLRouteTask`
`[flowgraph,interposerflow,rdlroute,0,tool]`	`str`	`openroad`

2.14.2.2. write_gds/0#

Keypath	Type	Value
`[flowgraph,interposerflow,write_gds,0,input]`	`[(str,str)]`	`('rdlroute', '0')`
`[flowgraph,interposerflow,write_gds,0,task]`	`str`	`export`
`[flowgraph,interposerflow,write_gds,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.export/ExportTask`
`[flowgraph,interposerflow,write_gds,0,tool]`	`str`	`klayout`

2.15. lintflow-slang#

An RTL linting flow.

This flow is designed to check RTL source files for stylistic, semantic, and syntactic issues using a specified linting tool.

Supported tools:

‘slang’: A linter based on the Slang compiler.

‘verilator’: A linter based on the Verilator tool.

File: lintflow.py

2.15.1. Graph#

2.15.2. Nodes#

2.15.2.1. lint/0#

Keypath	Type	Value
`[flowgraph,lintflow-slang,lint,0,task]`	`str`	`lint`
`[flowgraph,lintflow-slang,lint,0,taskmodule]`	`str`	`siliconcompiler.tools.slang.lint/Lint`
`[flowgraph,lintflow-slang,lint,0,tool]`	`str`	`slang`

2.16. showflow#

A minimal flow to display a design file using its associated viewer.

This flow is automatically generated and consists of a single node that runs a specific ‘show’ or ‘screenshot’ task for a given file format (e.g., GDS, DEF).

File: showflow.py

2.16.1. Graph#

2.16.2. Nodes#

2.16.2.1. show/0#

Keypath	Type	Value
`[flowgraph,showflow,show,0,task]`	`str`	`show`
`[flowgraph,showflow,show,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.show/ShowTask`
`[flowgraph,showflow,show,0,tool]`	`str`	`klayout`

2.17. signoffflow#

A flow for running LVS/DRC signoff on a GDS layout.

This flow performs two key physical verification steps in parallel:

Design Rule Checking (DRC) using Magic.

Layout Versus Schematic (LVS) checking using Netgen.

The LVS step first requires extracting a SPICE netlist from the layout, which is also handled by Magic. A final ‘join’ step ensures that both DRC and LVS tasks must complete successfully for the flow to finish.

File: signoffflow.py

2.17.1. Graph#

2.17.2. Nodes#

2.17.2.1. drc/0#

Keypath	Type	Value
`[flowgraph,signoffflow,drc,0,task]`	`str`	`drc`
`[flowgraph,signoffflow,drc,0,taskmodule]`	`str`	`siliconcompiler.tools.magic.drc/DRCTask`
`[flowgraph,signoffflow,drc,0,tool]`	`str`	`magic`

2.17.2.2. extspice/0#

Keypath	Type	Value
`[flowgraph,signoffflow,extspice,0,task]`	`str`	`extspice`
`[flowgraph,signoffflow,extspice,0,taskmodule]`	`str`	`siliconcompiler.tools.magic.extspice/ExtractTask`
`[flowgraph,signoffflow,extspice,0,tool]`	`str`	`magic`

2.17.2.3. lvs/0#

Keypath	Type	Value
`[flowgraph,signoffflow,lvs,0,input]`	`[(str,str)]`	`('extspice', '0')`
`[flowgraph,signoffflow,lvs,0,task]`	`str`	`lvs`
`[flowgraph,signoffflow,lvs,0,taskmodule]`	`str`	`siliconcompiler.tools.netgen.lvs/LVSTask`
`[flowgraph,signoffflow,lvs,0,tool]`	`str`	`netgen`

2.17.2.4. signoff/0#

Keypath	Type	Value
`[flowgraph,signoffflow,signoff,0,input]`	`[(str,str)]`	`('drc', '0')` `('lvs', '0')`
`[flowgraph,signoffflow,signoff,0,task]`	`str`	`join`
`[flowgraph,signoffflow,signoff,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.join/JoinTask`
`[flowgraph,signoffflow,signoff,0,tool]`	`str`	`builtin`

2.18. synflow#

A configurable ASIC synthesis flow with static timing analysis.

This flow translates RTL designs into a gate-level netlist and then performs static timing analysis (STA) on the result. It allows for parallel execution of both synthesis and timing steps to explore different strategies or speed up execution.

The flow consists of the following steps:

elaborate: Elaborates the RTL design from its source files.
synthesis: Translates the elaborated RTL into a gate-level netlist
using Yosys.
timing: Performs static timing analysis on the synthesized netlist
using OpenSTA.

File: synflow.py

2.18.1. Graph#

2.18.2. Nodes#

2.18.2.1. elaborate/0#

Keypath	Type	Value
`[flowgraph,synflow,elaborate,0,task]`	`str`	`elaborate`
`[flowgraph,synflow,elaborate,0,taskmodule]`	`str`	`siliconcompiler.tools.slang.elaborate/Elaborate`
`[flowgraph,synflow,elaborate,0,tool]`	`str`	`slang`

2.18.2.2. synthesis/0#

Keypath	Type	Value
`[flowgraph,synflow,synthesis,0,goal,errors]`	`float`	`0.0`
`[flowgraph,synflow,synthesis,0,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,synflow,synthesis,0,task]`	`str`	`syn_asic`
`[flowgraph,synflow,synthesis,0,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,synflow,synthesis,0,tool]`	`str`	`yosys`

2.18.2.3. synthesis/1#

Keypath	Type	Value
`[flowgraph,synflow,synthesis,1,goal,errors]`	`float`	`0.0`
`[flowgraph,synflow,synthesis,1,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,synflow,synthesis,1,task]`	`str`	`syn_asic`
`[flowgraph,synflow,synthesis,1,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,synflow,synthesis,1,tool]`	`str`	`yosys`

2.18.2.4. synthesis/2#

Keypath	Type	Value
`[flowgraph,synflow,synthesis,2,goal,errors]`	`float`	`0.0`
`[flowgraph,synflow,synthesis,2,input]`	`[(str,str)]`	`('elaborate', '0')`
`[flowgraph,synflow,synthesis,2,task]`	`str`	`syn_asic`
`[flowgraph,synflow,synthesis,2,taskmodule]`	`str`	`siliconcompiler.tools.yosys.syn_asic/ASICSynthesis`
`[flowgraph,synflow,synthesis,2,tool]`	`str`	`yosys`

2.18.2.5. synmin/0#

Keypath	Type	Value
`[flowgraph,synflow,synmin,0,input]`	`[(str,str)]`	`('synthesis', '0')` `('synthesis', '1')` `('synthesis', '2')`
`[flowgraph,synflow,synmin,0,task]`	`str`	`minimum`
`[flowgraph,synflow,synmin,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.minimum/MinimumTask`
`[flowgraph,synflow,synmin,0,tool]`	`str`	`builtin`

2.18.2.6. timing/0#

Keypath	Type	Value
`[flowgraph,synflow,timing,0,input]`	`[(str,str)]`	`('synmin', '0')`
`[flowgraph,synflow,timing,0,task]`	`str`	`timing`
`[flowgraph,synflow,timing,0,taskmodule]`	`str`	`siliconcompiler.tools.opensta.timing/TimingTask`
`[flowgraph,synflow,timing,0,tool]`	`str`	`opensta`

2.18.2.7. timing/1#

Keypath	Type	Value
`[flowgraph,synflow,timing,1,input]`	`[(str,str)]`	`('synmin', '0')`
`[flowgraph,synflow,timing,1,task]`	`str`	`timing`
`[flowgraph,synflow,timing,1,taskmodule]`	`str`	`siliconcompiler.tools.opensta.timing/TimingTask`
`[flowgraph,synflow,timing,1,tool]`	`str`	`opensta`

2.18.2.8. timing/2#

Keypath	Type	Value
`[flowgraph,synflow,timing,2,input]`	`[(str,str)]`	`('synmin', '0')`
`[flowgraph,synflow,timing,2,task]`	`str`	`timing`
`[flowgraph,synflow,timing,2,taskmodule]`	`str`	`siliconcompiler.tools.opensta.timing/TimingTask`
`[flowgraph,synflow,timing,2,tool]`	`str`	`opensta`

2.19. screenshotflow / 0#

A high resolution screenshot flow.

This flow is designed to generate a high resolution design image from a GDS or OAS file by preparing the layout, taking tiled screenshots, and merging them into a single image.

File: highresscreenshotflow.py

2.19.1. Graph#

2.19.2. Nodes#

2.19.2.1. import/0#

Keypath	Type	Value
`[flowgraph,screenshotflow,import,0,task]`	`str`	`importfiles`
`[flowgraph,screenshotflow,import,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.importfiles/ImportFilesTask`
`[flowgraph,screenshotflow,import,0,tool]`	`str`	`builtin`

2.19.2.2. prepare/0#

Keypath	Type	Value
`[flowgraph,screenshotflow,prepare,0,input]`	`[(str,str)]`	`('import', '0')`
`[flowgraph,screenshotflow,prepare,0,task]`	`str`	`operations`
`[flowgraph,screenshotflow,prepare,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.operations/OperationsTask`
`[flowgraph,screenshotflow,prepare,0,tool]`	`str`	`klayout`

2.19.2.3. screenshot/0#

Keypath	Type	Value
`[flowgraph,screenshotflow,screenshot,0,input]`	`[(str,str)]`	`('prepare', '0')`
`[flowgraph,screenshotflow,screenshot,0,task]`	`str`	`screenshot`
`[flowgraph,screenshotflow,screenshot,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.screenshot/ScreenshotTask`
`[flowgraph,screenshotflow,screenshot,0,tool]`	`str`	`klayout`

2.19.2.4. merge/0#

Keypath	Type	Value
`[flowgraph,screenshotflow,merge,0,input]`	`[(str,str)]`	`('screenshot', '0')`
`[flowgraph,screenshotflow,merge,0,task]`	`str`	`tile`
`[flowgraph,screenshotflow,merge,0,taskmodule]`	`str`	`siliconcompiler.tools.montage.tile/TileTask`
`[flowgraph,screenshotflow,merge,0,tool]`	`str`	`montage`

2.20. screenshotflow / 1#

A high resolution screenshot flow.

This flow is designed to generate a high resolution design image from a GDS or OAS file by preparing the layout, taking tiled screenshots, and merging them into a single image.

File: highresscreenshotflow.py

2.20.1. Graph#

2.20.2. Nodes#

2.20.2.1. import/0#

Keypath	Type	Value
`[flowgraph,screenshotflow,import,0,task]`	`str`	`importfiles`
`[flowgraph,screenshotflow,import,0,taskmodule]`	`str`	`siliconcompiler.tools.builtin.importfiles/ImportFilesTask`
`[flowgraph,screenshotflow,import,0,tool]`	`str`	`builtin`

2.20.2.2. screenshot/0#

Keypath	Type	Value
`[flowgraph,screenshotflow,screenshot,0,input]`	`[(str,str)]`	`('import', '0')`
`[flowgraph,screenshotflow,screenshot,0,task]`	`str`	`screenshot`
`[flowgraph,screenshotflow,screenshot,0,taskmodule]`	`str`	`siliconcompiler.tools.klayout.screenshot/ScreenshotTask`
`[flowgraph,screenshotflow,screenshot,0,tool]`	`str`	`klayout`

2.20.2.3. merge/0#

Keypath	Type	Value
`[flowgraph,screenshotflow,merge,0,input]`	`[(str,str)]`	`('screenshot', '0')`
`[flowgraph,screenshotflow,merge,0,task]`	`str`	`tile`
`[flowgraph,screenshotflow,merge,0,taskmodule]`	`str`	`siliconcompiler.tools.montage.tile/TileTask`
`[flowgraph,screenshotflow,merge,0,tool]`	`str`	`montage`