{"id":278,"date":"2015-03-21T17:21:16","date_gmt":"2015-03-21T16:21:16","guid":{"rendered":"http:\/\/www.fabienm.eu\/flf\/?p=278"},"modified":"2015-03-23T08:20:00","modified_gmt":"2015-03-23T07:20:00","slug":"icarus-vs-verilator","status":"publish","type":"post","link":"https:\/\/www.fabienm.eu\/flf\/icarus-vs-verilator\/","title":{"rendered":"Icarus vs Verilator"},"content":{"rendered":"

Plusieurs solutions de simulations s’offrent \u00e0 nous quand on d\u00e9veloppe un composant en Verilog. On peut \u00e9crire le testbench en Verilog, de mani\u00e8re \u00e0 \u00eatre compatible avec la plupart des simulateurs du march\u00e9. Dans ce cas, le simulateur libre le plus c\u00e9l\u00e8bre est Icarus.<\/a><\/p>\n

Mais la solution du \u00abtout Verilog\u00bb est relativement lente en temps de simulation, et l’utilisation du langage Verilog est restrictive,\u00a0 en effet il n’est pas facile de s’approprier toutes les subtilit\u00e9s du langage.<\/p>\n

C’est l\u00e0 que la solution de Verilator<\/a> devient tr\u00e8s int\u00e9ressante. Verilator permet de convertir un mod\u00e8le de composant \u00e9crit en Verilog synth\u00e9tisable<\/strong> en un mod\u00e8le C++. De cette mani\u00e8re, \u00e9crire le code du testbench revient \u00e0 instancier notre composant dans un main() en C++ et \u00e0 d\u00e9crire nos tests avec toute la libert\u00e9 qu’offre ce langage.<\/p>\n

Mieux encore, il est possible d’\u00e9crire notre testbench en SystemC<\/a>, et de profiter ainsi de cette librairie con\u00e7ue pour la simulation de circuit num\u00e9rique.<\/p>\n

L’id\u00e9e va \u00eatre ici de mesurer le temps effectif de simulation de chacune de ses deux solutions. On se servira pour cela du composant d’antirebond du projet \u00abblinking led project\u00bb (blp) disponible sur github<\/a>.<\/p>\n

Le composant synth\u00e9tisable<\/strong><\/p>\n

Le composant button_deb<\/a> commute sa sortie button_valid<\/em> \u00e0 chaque front montant du signal d’entr\u00e9e button_in<\/em>. Pour que le fonctionnement soit un peu plus complexe qu’une simple commutation, et surtout pour bien coller au fonctionnement r\u00e9el, le composant est muni d’un antirebond de 20 ms (par d\u00e9faut). Quand le premier front survient, un compteur est d\u00e9clench\u00e9 et aucun autre front n’est pris en compte pendant 20 ms.<\/p>\n

Voici ce que cela donne avec gtkwave<\/a>:<\/p>\n

\"blp_button_deb\"<\/a>
Chronogramme du testbench avec GTKwave<\/figcaption><\/figure>\n

Le testbench verilog (Icarus)<\/strong><\/p>\n

Tout comme en VHDL, un testbench en Verilog se pr\u00e9sente sous la forme d’un module sans entr\u00e9e\/sortie.<\/p>\n

La premi\u00e8re chose \u00e0 d\u00e9finir est le temps, avec la directive `timescale:<\/p>\n

`timescale 1ns\/100ps;<\/code><\/pre>\n
Le premier chiffre indique le pas de simulation, cela correspondra au temps d’attente que l’on retrouvera tout au long du code avec l’\u00abinstruction\u00bb ‘#’.\u00a0 Le deuxi\u00e8me nombre indique la pr\u00e9cision maximum.<\/p>\n
Par exemple, pour simuler l’horloge \u00e0 95Mhz on \u00e9crira :<\/p>\n
\/* Make a regular pulsing clock. *\/\r\nalways\r\n    #5.263158 clk = !clk;\r\n<\/code><\/pre>\n
Mais comme la pr\u00e9cision indiqu\u00e9e en d\u00e9but de code est de 100ps, seule le 5.2 sera pris en compte pour la simulation, ce qui dans notre cas est tout \u00e0 fait suffisant.<\/p>\n
La simulation de l’appui sur le bouton avec rebond se fait ensuite dans un process que l’on appel souvent \u00abstimulis\u00bb par convention :<\/p>\n
\/* Stimulis *\/\r\ninitial begin\r\n    $display(\"begin stimulis\");\r\n    $dumpfile(\"simu\/button_deb_tb.vcd\");\r\n    $dumpvars(1, clk, rst, button_in, button_valid, button);\r\n    $monitor(\"At time %t, value = %h (%0d)\",\r\n        $time, button_in, button_in);\r\n[...]\r\nend\r\n<\/code><\/pre>\n
Le Verilog fourni tout un tas de primitive permettant de simplifier le debuggage. Notamment $display() et $monitor(), pour afficher du texte pendant la simulation. $display() ne fait qu’afficher du texte au moment o\u00f9 la fonction est appel\u00e9e, alors que monitor va afficher le texte \u00e0 chaque changement d’\u00e9tat de ses param\u00e8tres.<\/p>\n
Les functions $dump* permettent de d\u00e9finir le format de fichiers des traces ainsi que les signaux a dumper. Dans ce cas pr\u00e9cis on choisira le format vcd qui est un format non compress\u00e9, de mani\u00e8re \u00e0 am\u00e9liorer la comparaison avec verilator qui lui ne sait faire que du vcd. Mais cela g\u00e9n\u00e8re vite de tr\u00e8s gros fichiers, il sera pr\u00e9f\u00e9rable d’utiliser le format compress\u00e9 lxt2, fst ou fsdb pour des simulations plus longues.<\/p>\n
Pour factoriser un peu de code d’attente on d\u00e9crit des t\u00e2ches d’attentes wait_ms et wait_us :<\/p>\n
\r\n\/* some usefull functions *\/\r\ntask wait_us;\r\n    input integer another_time;\r\n    begin\r\n        repeat(another_time) begin\r\n            # 1_000;\r\n        end\r\n    end\r\nendtask\r\n\r\ntask wait_ms;\r\n[...]\r\n<\/code><\/pre>\n
T\u00e2ches qui seront appel\u00e9es lors de la simulation des rebonds :<\/p>\n
[...]\r\n        button_in = 1;\r\n        wait_us(`DEBOUNCE_PER_MS * 8);\r\n        button_in = 0;\r\n        wait_us(`DEBOUNCE_PER_MS * 8);\r\n        button_in = 1;\r\n        wait_us(`DEBOUNCE_PER_MS * 10);\r\n        button_in = 0;\r\n        wait_us(`DEBOUNCE_PER_MS * 10);\r\n        button_in = 1;\r\n\r\n        wait_ms(`DEBOUNCE_PER_MS * 2);\r\n[...]\r\n<\/code><\/pre>\n
Pour lancer notre testbench avec Icarus, la premi\u00e8re chose \u00e0 faire est de compiler le code au moyen de la commande suivante :<\/p>\n
iverilog -o simu\/button_deb test\/test_button_deb.v src\/button_deb.v\r\n<\/code><\/pre>\n
Icarus va ainsi cr\u00e9er un binaire ex\u00e9cutable nomm\u00e9 simu\/button_deb que l’on lancera avec les arguments de dumps:<\/p>\n
vvp simu\/button_deb -lvcd\r\n<\/code><\/pre>\n
Le fichier de traces (VCD) g\u00e9n\u00e9r\u00e9 fait une taille v\u00e9n\u00e9rable de 752Mo et peut \u00eatre visualis\u00e9 avec gtkwave en l’indiquant simplement en param\u00e8tre de la commande :<\/p>\n
gtkwave simu\/button_deb_tb.vcd\r\n<\/code><\/pre>\n
Sur un Lenovo T430, la simulation prend 1 minute et 17 secondes<\/strong>, ce qui est tout de m\u00eame relativement lent pour une simulation d\u2019appui sur un boutton \ud83d\ude09<\/p>\n
Voyons maintenant ce que nous donne Verilator.<\/p>\n
Le testbench C++<\/strong><\/p>\n
Un testbench Verilator se pr\u00e9sente sous la forme d’un main() C++. Dans le main() du testbench nous instancierons l’objet correspondant au model verilog transform\u00e9 par verilator.
\nPour cela nous devons donc convertir notre bouton_deb.v en C++ au moyen de la commande Verilator suivante :<\/p>\n
verilator -Wall -cc src\/button_deb.v --trace --exe test\/test_button_deb.cpp\r\n<\/code><\/pre>\n
Cette commande va nous cr\u00e9er un projet avec le code source du mod\u00e8le ainsi que le makefile pour compiler. Il suffira donc de se rendre dans le r\u00e9pertoire obj_dir et de faire \u00abmake\u00bb pour compiler le mod\u00e8le.<\/p>\n
Il ne nous restera plus qu’\u00e0 instancier notre bouton dans notre testbench test_button_deb.cpp :<\/p>\n
    Vbutton_deb* top = new Vbutton_deb;\r\n<\/code><\/pre>\n
Ainsi que l’objet tfp pour les dump VCD:<\/p>\n
    VerilatedVcdC* tfp = new VerilatedVcdC;<\/code><\/pre>\n
Pour simuler notre objet \u00abtop\u00bb il faut assigner des valeurs aux signaux d’entr\u00e9es :<\/p>\n
    top->rst = 1;\r\n    top->button_in = 0;\r\n    top->clk = 0;\r\n<\/code><\/pre>\n
Puis \u00e9valuer les sorties avec la m\u00e9thode eval() :<\/p>\n
        top->eval();\r\n<\/code><\/pre>\n
\u00c0 chaque front d’horloge il faut donc changer la valeur de clk et \u00e9valuer :<\/p>\n
        top->clk = !top->clk;\r\n        top->eval();\r\n<\/code><\/pre>\n
Dans tout ce que nous venons de voir le temps n’intervient pas. En r\u00e9alit\u00e9, le temps n’est tout simplement pas g\u00e9r\u00e9 dans les mod\u00e8les Verilator, le mod\u00e8le ne fait qu’\u00e9valuer les sorties en fonction des entr\u00e9es, c’est \u00e0 nous de g\u00e9rer le temps comme nous le souhaitons.<\/p>\n
Nous allons donc g\u00e9rer le temps au moment du dump des signaux en lui indiquant le temps en argument:<\/p>\n
        tfp->dump(10);\r\n<\/code><\/pre>\n
Pour \u00e9viter d’avoir \u00e0 taper tout \u00e7a \u00e0 chaque fois on pourra cr\u00e9er une fonction \u00abtime_pass\u00bb qui fait passer le temps, avec un compteur global pour incr\u00e9menter le temps:<\/p>\n
#define BASE_TIME_NS ((1000*1000)\/(CLK_FREQ*2))\r\nint base_time = 0;\r\n\r\n\/* the time is passing *\/\r\nvoid time_pass(VerilatedVcdC *tfp, Vbutton_deb *top) {\r\n        top->clk = !top->clk;\r\n        tfp->dump(base_time*BASE_TIME_NS);\r\n        top->eval();\r\n        base_time++;\r\n}\r\n<\/code><\/pre>\n
\u00c0 l’image du testbench verilog, on pourra aussi cr\u00e9er des fonctions d’attente wait_ms et wait_us:<\/p>\n
\/* wait for us *\/\r\nvoid wait_us(VerilatedVcdC *tfp, Vbutton_deb *top, int timeus) {\r\n    int wait_time = 0;\r\n    while((wait_time * BASE_TIME_NS) < (timeus * 1000)) {\r\n        wait_time++;\r\n        time_pass(tfp, top);\r\n    }\r\n}\r\n\r\n\/* wait for ms *\/\r\nvoid wait_ms(VerilatedVcdC *tfp, Vbutton_deb *top, int timems) {\r\n    int wait_time = 0;\r\n    while((wait_time * BASE_TIME_NS) < (timems * 1000 * 1000)) {\r\n        wait_time++;\r\n        time_pass(tfp, top);\r\n    }\r\n}\r\n<\/code><\/pre>\n
Le code simulant les rebonds du bouton ressemble ainsi \u00e0 s’y m\u00e9prendre au code Verilog:<\/p>\n
[...]\r\n        top->button_in = 1;\r\n        wait_us(tfp, top, DEBOUNCE_PER_MS);\r\n        top->button_in = 0;\r\n        wait_us(tfp, top, DEBOUNCE_PER_MS);\r\n        top->button_in = 1;\r\n        wait_us(tfp, top, DEBOUNCE_PER_MS * 5);\r\n        top->button_in = 0;\r\n        wait_us(tfp, top, DEBOUNCE_PER_MS * 5);\r\n        top->button_in = 1;\r\n        wait_us(tfp, top, DEBOUNCE_PER_MS * 8);\r\n        top->button_in = 0;\r\n        wait_us(tfp, top, DEBOUNCE_PER_MS * 8);\r\n        top->button_in = 1;\r\n        wait_us(tfp, top, DEBOUNCE_PER_MS * 10);\r\n        top->button_in = 0;\r\n        wait_us(tfp, top, DEBOUNCE_PER_MS * 10);\r\n        top->button_in = 1;\r\n\r\n        wait_ms(tfp, top, DEBOUNCE_PER_MS * 2);\r\n[...]\r\n<\/code><\/pre>\n
Pour lancer la simulation on va d’abord compiler le tout :<\/p>\n
make -C obj_dir\/ -j -f Vbutton_deb.mk Vbutton_deb\r\n<\/code><\/pre>\n
Puis le lancer simplement comme un vulgaire binaire ex\u00e9cutable :<\/p>\n
.\/Vbutton_deb\r\n<\/code><\/pre>\n
La simulation cr\u00e9e un fichier VCD de 654Mo que nous pouvons visualiser avec gtkwave.
\nSur le m\u00eame Lenovo T430 la simulation ne dure cette fois que 17 secondes<\/strong>, ce qui est tr\u00e8s nettement plus rapide qu’Icarus !<\/p>\n
Mieux, si on optimise le code \u00e0 la compilation avec l’option -O3 :<\/p>\n
verilator -Wall -cc src\/button_deb.v --trace -O3<\/strong> -noassert --exe test\/test_button_deb.cpp\r\n<\/code><\/pre>\n
Le temps de simulation tombe \u00e0 3 secondes<\/strong> !<\/p>\n
La rapidit\u00e9 d’ex\u00e9cution est telle que certain r\u00e9ussissent \u00e0 faire \u00abtourner\u00bb un soft-core avec son programme, \u00e0 des fr\u00e9quences allant jusqu\u2019\u00e0 la centaine de kilohertz.<\/p>\n
Formidable !<\/strong><\/p>\n
C’est un peu l’expression que l’on a lors des premiers tests de verilator, pouvoir faire de la simulation 20 fois plus rapidement qu’Icarus semble formidable. Surtout quand cela passe par de la simplicit\u00e9 d’\u00e9criture du testbench en C++ ou SystemC.<\/p>\n
N\u00e9anmoins il faut relativiser un peu notre ferveur, Verilator a encore un gros point noir: il ne g\u00e8re pas le temps. Verilator n’est capable que de g\u00e9rer des mod\u00e8le Verilog synth\u00e9tisable. <\/strong>Mais si ce code synth\u00e9tisable inclu des primitives du constructeurs : RAM, Multiplieur, … et surtout PLL. Verilator ne sera pas capable de les simuler.<\/p>\n
En ce qui concerne les Ram ou les multiplieurs cela ne pose pas trop de probl\u00e8me dans la mesure ou il est assez simple de les inf\u00e9rer<\/a>. Mais pour les PLL cela devient bien plus compliqu\u00e9, et je ne parle m\u00eame pas des composants sp\u00e9cifique au constructeur (Bus serie, transceiver, core, …).<\/p>\n
Ce \u00abbug\u00bb a \u00e9t\u00e9 r\u00e9pertori\u00e9 il y 5 ans <\/a>d\u00e9j\u00e0 mais pour l’instant personne ne semble s’\u00eatre attel\u00e9 \u00e0 la t\u00e2che. D’apr\u00e8s un des auteur de Verilator ajouter cette fonctionnalit\u00e9 devrait prendre quelques mois de programmation et de test. Mais cela vaudrait quand m\u00eame le coup !<\/p>\n
Alors qui s’y colle ?<\/p>\n","protected":false},"excerpt":{"rendered":"
Plusieurs solutions de simulations s’offrent \u00e0 nous quand on d\u00e9veloppe un composant en Verilog. On peut \u00e9crire le testbench en Verilog, de mani\u00e8re \u00e0 \u00eatre compatible avec la plupart des simulateurs du march\u00e9. Dans ce cas, le simulateur libre le plus c\u00e9l\u00e8bre est Icarus. Mais la solution du \u00abtout Verilog\u00bb est relativement lente en temps … Continuer la lecture de Icarus vs Verilator<\/span> →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","footnotes":""},"categories":[3,27,20],"tags":[31,28,29,30],"class_list":["post-278","post","type-post","status-publish","format-standard","hentry","category-langages","category-verilator","category-verilog","tag-icarus","tag-simulation","tag-verilator","tag-verilog"],"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false,"post-thumbnail":false},"uagb_author_info":{"display_name":"Fabien Marteau","author_link":"https:\/\/www.fabienm.eu\/flf\/author\/admin\/"},"uagb_comment_info":0,"uagb_excerpt":"Plusieurs solutions de simulations s’offrent \u00e0 nous quand on d\u00e9veloppe un composant en Verilog. On peut \u00e9crire le testbench en Verilog, de mani\u00e8re \u00e0 \u00eatre compatible avec la plupart des simulateurs du march\u00e9. Dans ce cas, le simulateur libre le plus c\u00e9l\u00e8bre est Icarus. Mais la solution du \u00abtout Verilog\u00bb est relativement lente en temps\u2026","_links":{"self":[{"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts\/278","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/comments?post=278"}],"version-history":[{"count":23,"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts\/278\/revisions"}],"predecessor-version":[{"id":308,"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/posts\/278\/revisions\/308"}],"wp:attachment":[{"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/media?parent=278"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/categories?post=278"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.fabienm.eu\/flf\/wp-json\/wp\/v2\/tags?post=278"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}