Running the Sequential Modular Design Flows

If you are comfortable running the standard Modular Design flow, you can also run this flow “sequentially.” This means taking information generated from previous module implementations and using it to improve other module implementations and your final design. The two sequential flows (Partial Design Assembly and Sequential Guide) and their advantages are described in the following sections.

Running the Partial Design Assembly Flow

This Modular Design flow allows the team leader to run the Final Assembly phase with only some of the PIMs published. This allows checking a partially assembled design for timing problems before all modules are completed. You can analyze the timing budget for the following:

Nets that connect implemented and unimplemented modules

Nets that connect the implemented modules to one another

The Initial Budgeting and Active Module Implementation phases are the same as in the standard flow. The Final Assembly phase differs slightly, as shown in the following figure.

Enter a design using the guidelines described in "Entering the Design".

Synthesize your HDL files as described in the documentation for your synthesis tool. You must create a separate netlist file for each of the modules as well as the top-level design. For guidelines, see "Synthesizing Designs".

Note: For modules, disable settings that insert I/O pads.

Run Initial Budgeting for your design as described in "Running Initial Budgeting".

Implement and publish the appropriate modules as described in "Implementing an Active Module".

Change directories to the top-level design directory in your “implementation” directory to begin the Final Assembly phase.

To incorporate the logic for the specified modules into the top-level design, run NGDBuild as follows.

ngdbuild -u -modular assemble -pimpath pim_directory_path -use_pim module_name1 -use_pim module_name2... design_name

The –u option instructs NGDBuild to ignore the modules that are missing from the PIMs directory. See "–u (Allow Unexpanded Blocks)" and "–modular assemble (Module Assembly)" in Chapter 8 for information on the NGDBuild options.

Note: Use the –use_pim option to specify only the modules that were published to the PIMs directory. You must use the same naming conventions used during the Active Module Implementation phase, including the proper capitalization.

Map the logic of the partially implemented design as follows:

map design_name.ngd

Note: MAP does not trim port nets associated with unimplemented modules. The MAP report (MRP file) lists each unimplemented module and its associated untrimmed logic.

Place and route the logic of the partially implemented design as follows:

par -w design_name.ncd design_name_routed.ncd

Run TRACE on the implemented design to check the timing report (TWR or TWX file) for timing issues. Verify that your top-level timing constraints are met.

trce design_name_routed.ncd

Note: By default, a summary report is generated. You can also choose to generate an error or verbose report. See "TRACE" chapter for details.

Running the Sequential Guide Flow

This flow allows the team leader to implement the top-level design with both the previously implemented module or modules and the “active” module expanded. By implementing your design this way, you minimize both global resource contention issues and the requirement to assign all pseudo logic, because each active module is aware of the resources used by previously implemented modules.

The Initial Budgeting phase is similar to that of the standard flow. The Active Module Implementation phase differs slightly, as shown in the following figure. In addition, the Final Assembly phase is not needed in this flow.

Note: The NGM and NCD files from the previously implemented modules are automatically read into MAP and PAR. You do not need to specify these files on the command line.

Enter you design using the guidelines described in "Entering the Design".

Synthesize the HDL files as described in the documentation for your synthesis tool. You must create a separate netlist file for each of the modules as well as the top-level design. For guidelines, see "Synthesizing Designs".

Note: For modules, disable settings that insert I/O pads.

Run Initial Budgeting for your design as described in "Running Initial Budgeting".

Note: You do not need to automatically position pseudo logic for the entire design, only pseudo logic associated with the first module. Using the Sequential Guide flow, the logic from the previously implemented module or modules is used rather than the pseudo logic created for the top-level design.

In your “implementation” directory, create a directory for each module to be implemented. These directories are different from those in the PIMs directory.

Implement the first module as described in "Implementing an Active Module".

To implement the next module, copy the following files of the module that you are going to implement to the appropriate module directory in your “implementation” directory:

Synthesized module netlist file (for example, module_name.edf or module_name.ngc).

UCF file you created in the Initial Budgeting phase (from the top-level directory in the “implementation” directory). Rename this file from design_name.ucf to module _name.ucf.

Note: Copying the UCF file ensures that each module is implemented with a consistent set of timing and placement constraints. It also allows you to add module-specific constraints to the local copy of the UCF file as needed.

Change directories to the appropriate module directory.

Run NGDBuild as follows. During this step, the top-level design is implemented with both the previously implemented module or modules and the active module expanded.

ngdbuild -uc design_name.ucf -modular module
-active module_name -pimpath pim_directory_path
-use_pim module_name1 -use_pim module_name2 top_level_directory_path\design_name.ngo

Note: Use the –use_pim option to specify only the modules that were published to the PIMs directory. You must specify all published modules each time you run this command. You must use the same naming conventions used during the Active Module Implementation phase, including the proper capitalization.

If necessary, create module level timing constraints using the Constraints Editor as follows:

Use the following command to invoke the Constraints Editor:

constraints_editor design_name.ngd

In the New dialog box, select the module_name.ucf file and click OK.

Modify the constraints.

Note: If you define an OFFSET constraint relative to a module port, a TPSYNC constraint is automatically created for that port net. The path from the synchronous element within the module to the module port is analyzed to create offset timing. Offset timing does not include the clock delay to the synchronous element within the module.

Select File

Save to save your UCF file and then close the Constraints Editor.

Refer to the Constraints Editor online help for details about commands and settings. Also refer to the Constraints Guide for information on constraints.

Annotate the constraints from the local UCF file to the module using the following command. The –uc option ensures that the constraints from the local UCF file are annotated.

ngdbuild -uc module_name.ucf -modular module -active module_name -pimpath pim_directory_path
-use_pim module_name1 top_level_directory_path\design_name.ngo

Map the module using the following command. In this step, you are mapping the logic of the design with both the “active” module and the previously implemented module or modules expanded.

map design_name.ngd

Place and route the module using the following command. In this step, you are placing and routing the logic of the design with both the “active” module and the previously implemented module or modules expanded.

par -w design_name.ncd design_name_routed.ncd

Note: The “_routed” syntax ensures that you do not overwrite your mapped design. However, you can use any syntax you prefer. The –w options ensures that any previous versions of design_name_routed.ncd are overwritten.

Publish the implemented module file to a centrally located PIMs directory.

pimcreate -ncd design_name_routed.ncd pim_directory_path

This command creates the appropriate module directory inside the PIMs directory that you specify. It then copies the local, implemented module files, including the NGO, NGM and NCD files, to the module directory inside the PIMs directory and renames the NCD and NGM files to module_name.ncd and module_name.ngm.

Repeat steps 6 through 13 for each succeeding module.

There is no need to run Modular Design in Final Assembly phase. When you place and route your last module, your resulting NCD file is your final design file.

Note: If any of the constraints you alter affect your previously implemented modules, you must re-implement the previously implemented modules and also your active module. To do this, start with step 5 of this procedure. If your constraints only affect your active module, you do not need to re-implement your previously implemented modules.