Product Documentation
Virtuoso Floorplanner User Guide
Product Version IC23.1, November 2023

Floorplanner Command-Line Flow

Instead of using the GUI commands, you can use the Floorplanner command-line SKILL APIs to generate a layout from a schematic in a hierarchical manner. These APIs are entered in the CIW. The following figure illustrates the overall design flow for developing a layout from a schematic in a hierarchical manner.

Each step in the design flow uses a set of SKILL APIs. The lib:cell:view, which represents the name of the library, cell, and view to be referenced in the schematic, is the input for the process.

The description of the APIs used in each step is as follows.

  1. Define the Physical Configuration (physConfig)
    Use the cphCreatePhysConfig API to create a physical configuration (physConfig) corresponding to the specified top-level lib:cell:view. A physConfig comprises multiple files that store design-specific overrides such as the schematic expansion rules and the instance mapping rules.
  2. Define Global Bindings
    Use the cphSetViewList API to set the logical switch view list for the physical configuration view associated with the specified ID. The list specifies the view names used to descend into a hierarchical design to find schematic views.
    Use the cphSetStopList API to specify the view names to be used to determine the corresponding physical view for a given logical view.
  3. Create Physical Bindings
    Use the cphSetCellPhysicalBinding API to set the physical binding for a specified logical cell in the physical configuration associated with the given ID.
  4. Create Soft Block Definitions
    Use the cphSbDefineSoftBlock API to define a soft block in the physConfig.This API creates CPH data for the soft block to be generated in the layout by using the logical lib:cell:view. The initial I/O pins are automatically generated in the layout and their attributes are configured based on the environment variables.
  5. Edit Soft Block Attributes
    After defining soft blocks in the CPH, use the following APIs to further customize the soft blocks as per your requirements.
  6. Save the Physical Configuration
    The configuration settings remain as the transient data until you save them to the disk. Use the cphSaveConfig API to save the current physical configuration settings. You can save the settings at any point when configuring the physical hierarchy. The saved settings take effect the next time you generate or update the layout view.
  7. Generate the Layout
    After customizing soft blocks, use the vfpCPHGenPhysicalHierNoPropFilevfpCPHGenPhysicalHierNoPropFile API to generate the physical hierarchy. Soft layouts and soft abstracts are created in the layout canvas corresponding to the configuration that you defined.
  8. Perform Floorplanning and Placement
    After generating the physical configuration in the layout canvas, you can perform the following floorplanning and placement tasks:
    • I/O Placement: I/O Placement is a row-based placement methodology in which you perform the following tasks in sequence:
      • Create I/O rows.
      • Place pads inside the I/O rows.
      • Insert filler cells in the gaps between the pads and rows.
      • Place corner cells in the four corners of the design.
    • Floorplanning and Placement: Floorplanning and placement involves placing all instances in a design and minimizing the overall wire length and chip area. Depending on the type of instances that you want to place, choose from the following automatic placement tools:
      • Block Placer (under Virtuoso® Floorplanner): For placing blocks
      • Virtuoso® Custom Placer: For placing standard cells
      • Virtuoso® Analog Placer: For placing Pcells and other custom cells

    During floorplanning and placement, you may need to further edit soft block attributes, such as the boundary, pins, and obstructions.
    In Edit Soft Block Attributes, updates to the soft block and pin attributes were stored in physConfig. At that point, the instances were not available on the layout canvas. However, in Perform Floorplanning and Placement, modifications are made to instances after they are generated on the layout canvas.
    Instead of using the GUI to run the floorplanning commands, you can use the following command-line APIs to perform the corresponding editing tasks.
    Soft Block Boundaries
    Editing I/O Pins
    Editing Obstructions
    Editing Soft Block Attributes
  9. Optimize Pins
    In this step, you optimize the pins. Pin Optimizer optimizes the positions of top-level and soft block pins to achieve the shortest possible aggregated net length.
    Use the vpaOptimizePins command-line API to run pin optimization without opening the Pin Optimization GUI.

Example

This example uses APIs to define and edit soft blocks and pins before generating the physical hierarchy.

In this example, the following environment variables are set before starting the physical configuration. These environment variables provide default values for layer, pin height, and pin width to be applied when defining individual blocks and pins.

envSetVal("layoutXL" "initIOPinLayer" 'string "metal1 pin")
envSetVal("layoutXL" "initPinHeight" 'float 2.0)
envSetVal("layoutXL" "initPinWidth" 'float 2.0)
Setting environment variables is an optional step. If not set, however, you need to specify values for these parameters when defining individual the blocks and pins.

The first step in the design flow is to define a physConfig by using the cphCreatePhysConfig API, with the lib:cell:view of the layout and schematic as parameters. A unique physConfig ID is returned. In the following code, the physConfig ID for the top-level soft block is assigned to variable cphId. 

cphId = cphCreatePhysConfig("design" "top_level" "physConfig_example" "design" "top_viewtest" "schematic")

Next, you define soft blocks by using the cphSbDefineSoftBlock API. This API creates CPH data for the soft block to be generated in the layout by using the specified logical lib:cell:view. Here, sbID is the top-level block and sbB1 and sbB2 are other design-level soft blocks.

sbId = cphSbDefineSoftBlock(cphId 
          "design"
       "top_level"
       "layout_example"
       ?logLib "design"
       ?logCell "top_level"
       ?logView "schematic"
       )
sbB1 = cphSbDefineSoftBlock(cphId 
          "design"
       "block1"
       "layout_example"
       ?logLib "design"
       ?logCell "block1"
       ?logView "schematic"
       )
sbB3 = cphSbDefineSoftBlock(cphId 
          "design"
       "block3"
       "layout_example"
       ?logLib "design"
       ?logCell "block3"
       ?logView "schematic"
       )

After defining soft blocks, their boundaries are defined.

foreach(sb list(sbB1 sbB3)
     cphSbSetRectangularBoundary(cphId sb 50 50)
  )
cphSbSetRectangularBoundary(cphId sbId 400 400)

Here, the foreach(sb list(sbB1 sbB2) function includes the IDs of all the soft blocks for which boundaries need to be created. The cphSbSetRectangualarBoundary specifies that the boundary should be rectangular in shape. The parameters of this API are the physConfig ID, the soft lock ID, and the dimensions of the rectangular boundary.

Next, the pins are defined.

foreach(pinId cphSbGetAllIOPins(cphId sbId)

The cphSbGetAllIOPins API retrieves the IDs of all the pin located at the top level. The parameters for this API are the physConfig ID (cphId) and the corresponding soft block ID (sbId). The dimensions of the pins are based on the values you specified when defining the environment variables. If required, you can edit the dimensions of the pins by using the cphSbEditIOPinByIdcphSbEditIOPinById API. You can also use this API to you can create and edit pins for the remaining soft blocks.

cphSbEditIOPinById(cphId pinId ?lpp "metal3 drawing" ?width 10.0 ?height 10.0 ?sigType "signal")
foreach(pinId cphSbGetAllIOPins(cphId sbB1)
cphSbEditIOPinById(cphId pinId ?lpp "metal1 drawing" ?width 5.0 ?height 5.0 ?sigType "signal")
)
foreach(pinId cphSbGetAllIOPins(cphId sbB3)
cphSbEditIOPinById(cphId pinId ?lpp "metal1 drawing" ?width 3.0 ?height 3.0 ?sigType "signal")
)

After specifying all required configuration settings, the configuration settings are saved to the disk.

cphSaveConfig(cphId)

The final step is to generate the physical hierarchy in the layout canvas without specifying the floorplan property file using the vfpCPHGenPhysicalHierNoPropFile API.

vfpCPHGenPhysicalHierNoPropFile("design" "top_level" "schematic" "design" "top_level" "layout_example")

The lib:cell:view of the schematic and layout are specified as the parameters.

You can now perform floorplanning, placement, and pin optimization.

Related Topics

Edit Soft Block Attributes

Perform Floorplanning and Placement


Return to top
 ⠀
X