Post-synthesis simulation for pulp

[Athena]

Hello, 

I have synthesised a particular IP of the pulp system for  ASIC using a certain compiler. Now I want to re-insert the synthesised netlist into the system and perform a post-synthesis simulation for verification. How do I go about with this?

From what I understand, when a certain simulation for say hello example (given under pulp-rt-examples) is run, all the IPS are being fetched directly from the git-hub repository instead from the locally cloned repository IP folder. Is my understanding correct?

How do I add my own changes to the exisiting IP and still run an example simulation ?


Thanks!


Regards,
Athena

[fconti]

Hi Athena, I will start from the last question.
When you run a simulation, you use the IPs that you have locally in your filesystem. More specifically, when you follow the instructions here (https://github.com/pulp-platform/pulp#bu...n-platform) what you actually do is the following:

1. you download the IPs with the `update-ips` command
   
2. you generate simulation and synthesis scripts. This is done automatically by `update-ips`, but can also be triggered separately using `generate-scripts`.
   
3. you build the simulation platform in the sim folder with `make clean lib build opt`.
   

When you perform a simulation, you use the RTL simulation platform prebuilt using these steps.

When you change the IPs internally, you might have to regenerate the scripts with `generate-scripts`, for example if you added a new file. The flow uses a simple information file inside each IP, called `src_files.yml`, to propagate information on sources (you can find more details in the folder ipstools/doc).
You can also add entirely new IPs which are listed in the file `ips_list.yml` in the PULP root (or inside each IP).

Now coming to the first question, this is not typically the best way to integrate netlists as you typically want to separate your postsynth flow apart, and the advantage of a flow generating automatically simulation scripts is modest for postsynthesis, where the number of involved files is low.
What I often do is create a special makefile (similar to the ones created by the automatic flow) to build a postsynthesis IP with netlists and, if necessary, a special testbench (see this Gist for an example https://gist.github.com/FrancescoConti/c...54c4d6b3eb ).

Then I integrate it with two new rules in the root Makefile used to build the RTL platform (e.g. by modifying the build rule to a build-ps one) and to optimize it (with the appropriate vopt command). This is by no means the only way to do this... in most cases you will have to get your hands a bit dirty with the scripts.
Let me know for any further doubt!