Several DVT directives can help you reduce this duration, by shrinking the analysis of the full build or by limiting some functionalities in some sections of code.

This application note responds to performance related questions in terms of full build duration and memory consumption.

How can I stop compiling some files?

All you need for this is to use the +dvt_skip_compile directive.

It allows DVT to completely skip some files during the full build process.

The advantage of skipping compilation can be seen both in terms of build duration and memory consumption.

Note that, by skipping files from compilation, you might end up with false positive errors. This is caused by DVT not compiling the definition of some types (classes, modules, typedefs etc.). To fix this issue you will need Compile_Waivers.

The directive comes in several flavors:

In a simple pattern you can use wildcards such as '*' (any string) and '?' (any character). The absolute paths are considered for pattern matching.

If you want to skip compile all the files under */dir1/*, you can add in the build configuration the following line:

If you want to skip compile all the files besides those under */dir1/*, use:

If you want to skip compile all the files besides those under */dir1/* and */dir2/*, use:

All the directives are considered when determining which files to be skip compiled. Matching any of the filters results in the file not being analyzed during build. For this reason, the following configuration will result in no file being compiled (considering the paths are disjoint):

Skipped files are decorated distinctively in the Navigator View / Explorer View.

DVT Eclipse:

DVT for VS Code:

How can I compile the API only?

When you want to use some IPs, or internal code you don not need to change, the shallow compilation mode can help you.

This will ensure that DVT parses the shallow compiled files and extracts the API from them, leaving aside the details at the same time. This means DVT will still detect all the classes, modules, interfaces and so on, but it will only take into consideration the minimum necessary to use their API. For example, only the ports and parameters will be collected from within a module and only arguments will be collected for functions and tasks.

This approach will lower the build time and memory consumption, but a smaller scale compared to +dvt_skip_compile.

The advantage of using shallow compilation resides in the ability to use the shallow compiled API. Modules and functions will appear in the Autocomplete proposal list, hyperlinks like "Open Declaration" will work and, most importantly, no new errors will be triggered, meaning there is no need to add Compile Waivers.

The directive comes in several flavors:

The first four flavors work similarly to +dvt_skip_compile. This will apply shallow compilation to each file that matches, no matter the content (module, functions or task).

The last flavor allows you to easily shallow compile all the modules for example, without needing to manually specify to paths to them. This last flavor also works in conjunction with the first four.

Consider the following example:

The result will be that all modules, functions or tasks that DVT encounters under */dir1/* will be shallow compiled and all the modules, no matter the path, will also be shallow compiled.

Visual indicators are added in multiple places:

A notification at the top of the editor	Not available in VS Code
An "[S]" indicator in the views: Compile Order, Types, Design Hierarchy, Verification Hierarchy
An "[S]" indicator in the diagrams: Schematic Diagrams, UVM Component Diagrams
A "(shallow)" indicator in the Console View during full build

Note: Design Hierarchy and Verification Hierarchy will not show instances for shallow compiled elements (modules/UVM components).

Note: Some functionalities may not fully work in shallow compiled API (i.e. show usages, refactoring)

How to improve the elaboration time

To improve the elaboration time, you can configure it with the directives found in the Elaboration Performance documentation page.