Bridging from NVC to Python

[Paebbels]

Some time ago, I wrote a generic VHDL language model pyVHDLModel in Python. This model can be produced (instantiated) by a parser like pyVHDLParser or pyGHDL.dom and it can be consumed by tools wanting to work with VHDL. A consumer could be a VHDLDomain for Sphinx.

I would like to discuss if NVC is interested in a NVC to Python bridge?

If so, I have a few questions:

• Can NVC be compiled as a shared library (*.so/*.dll/*.dylib)?
• Is there a list of function and parameter descriptions that can be called from Python?
  In GHDL, a Python script auto generates most of the binding files. Then a decorator is used for interfacing.

  @export
  @BindToLibGHDL("files_map__location_to_file")
  def Location_To_File(Location: LocationType) -> SourceFileEntry:
    """
    Convert :obj:`Location` to a source file.
  
    :param Location: Location
    :return:         Source file. Return ``No_Source_File_Entry`` if location is incorrect.
    """
    return 0  # pragma: no cover

• Can NVC preserve comments for documentation extraction?

[nickg]

* Can NVC be compiled as a shared library (`*.so`/`*.dll`/`*.dylib`)?

No, this is something of an anti-goal for the project: see #1211 which was a similar request.

* Is there a list of function and parameter descriptions that can be called from Python?

Yes! See src/vhpi/vhpi_user.h, it has a stable ABI and is even documented in the LRM ;-). Ideally VHPI would be the main extension point for NVC, rather than having multiple proprietary interfaces for different use cases. The problems at the moment are:

• VHPI only has a C API, although I expect it would easy to generate Python bindings for it. I started on some incomplete Rust bindings at nickg/rust-vhpi which were intended for use in Surfer.
• Your program needs to be a shared library passed to --load which makes using it from Python or other scripting languages a bit painful, although this is exactly how Cocotb works. Another approach is to have a VHPI plugin that dumps e.g. JSON and then run NVC as a sub-process.
• You probably want to hook vhpiCbEndOfAnalysis and then iterate over vhpi_iterator(vhpiDesignUnits, NULL), neither of which are implemented in NVC today, although I can fix that relatively easily.

* Can NVC preserve comments for documentation extraction?

No, unfortunately the way the parser is written doesn't really make this possible at the moment. I want to keep NVC as tightly focussed on just being a simulator as possible and not trying to do too many things at once (i.e. no LSP server, not a generic HDL parsing library, etc.). The problem with trying to do too much is that the code base rapidly becomes complex and unmaintainable.

[Paebbels]

VHPI is a programming interface for simulation runtime and elaborated design exploration, it doesn't give access to a parser. So it's impossible to create a CodeDOM via VHPI.

Python is written and C and binds best to C APIs.

JSON or similar intermediate formats was way too slow when processing a CodeDOM. Besides that, it's dirty programming and avoiding to write a good interface.

I don't want to run a the Python code as a plugin in the NVC process. I want to run NVC (like GHDL) in the Python process, so I can run e.g. Sphinx.

Without having access to comments and preserving information of the original input, my idea needs to be buried. Thanks for the quick feedback.

[nickg]

VHPI is a programming interface for simulation runtime and elaborated design exploration,

While VHPI may not be appropriate for your use case, this is not correct. VHPI also models uninstantiated design units and these can be accessed prior to elaboration (e.g. in the vhpiCbEndOfAnalysis callback). See the class diagram in section 19.5 "The stdUninstantiated package" in the 2008 LRM.

FWIW NVC doesn't implemented much of this yet, but only because Cocotb doesn't use it and no one has asked for it.

[m-kru]

I was recently interested in a very similar thing. I wanted to use nvc to build a linter on top of it. Is it possible to use the VHPI C API on analysis results? Without running elaboration or simulation steps?