Il reste 75% de l'article à découvrir.
Vous devez être abonné•e pour lire la suite de cet article.
Déjà abonné•e ? Générez une clé RSS dans votre profil.

Cocotb, le cadriciel libre de vérification matérielle en Python, vient de publier sa version majeure 2.0. Cette sortie marque une étape importante dans l’évolution de ce projet qui permet de tester des circuits numériques décrits en VHDL ou Verilog directement depuis Python, sans avoir à écrire de testbench en HDL.

Pour celles et ceux qui ne connaissent pas encore cocotb, il s’agit d’un outil qui facilite grandement la vie des personnes travaillant sur la conception de circuits intégrés. Plutôt que d’écrire des bancs de test complexes en VHDL ou Verilog, cocotb permet d’utiliser Python et son écosystème riche (NumPy, pytest, etc.) pour vérifier le comportement des circuits.
Cocotb (Coroutines-based Cosimulation Test-Bench) permet d’écrire en python des bancs de test qui vont piloter directement le simulateur HDL via différentes interfaces (VPI, VHPI, FLI). La plupart des simulateurs HDL du marché sont supportés, qu’ils soient libres ou non.

Sommaire

• Une version majeure synonyme de changements
  • Principales ruptures de compatibilité
• Les nouveautés marquantes
  • Amélioration des performances
  • Prise en charge étendue des simulateurs
  • Gestion améliorée des tâches
  • Nouvelles fonctionnalités pour les signaux
  • Améliorations du typage
  • Décorateur @cocotb.parametrize
  • Gestion du logging améliorée
• Nouvelles structures de données
• Améliorations de l’écosystème
  • Flux de test en Python
  • Queues asyncio
  • Gestion des packages SystemVerilog
• Considérations sur l’adoption
• Remerciements et perspectives

Une version majeure synonyme de changements

Comme l’indique le numéro de version, cocotb 2.0 introduit des changements incompatibles avec les versions précédentes. L’équipe de développement a profité de cette version majeure pour nettoyer l’API, supprimer du code obsolète et moderniser l’architecture du projet. Un guide de migration détaillé est disponible pour accompagner la transition.

Principales ruptures de compatibilité

La transition vers cocotb 2.0 nécessite quelques adaptations du code existant :

• Suppression des coroutines à base de générateurs : La syntaxe yield (avec le décorateur @cocotb.coroutine) a été supprimée. Il faut désormais utiliser exclusivement la syntaxe moderne async/await.

• Nouvelles conventions de nommage : Les variables d’environnement ont été renommées pour éviter les conflits avec les simulateurs. Par exemple, MODULE devient COCOTB_TEST_MODULES, TOPLEVEL devient COCOTB_TOPLEVEL, etc.

• Changements dans les types de données : Les objets BinaryValue ont été remplacés par LogicArray, offrant une API plus cohérente et moderne pour manipuler les valeurs logiques.

• Modifications des déclencheurs : L’objet Join est devenu obsolète au profit d’une utilisation directe des tâches. La syntaxe await task.join() devient simplement await task.

Les nouveautés marquantes

Amélioration des performances

La nouvelle version apporte des gains de performance significatifs, notamment grâce à l’implémentation en C++ d’un générateur d’horloge (GpiClock). Cette optimisation réduit les échanges entre Python et l’interface GPI, permettant des simulations plus rapides, particulièrement pour les designs utilisant de nombreuses horloges.

Prise en charge étendue des simulateurs

Cocotb 2.0 élargit sa prise en charge des simulateurs commerciaux et libres :

• DSim (Siemens) est maintenant officiellement géré
• Questa bénéficie d’un nouveau flux de compilation qisqrun utilisant le Questa Information System pour de meilleures performances
• NVC, le simulateur VHDL libre, est désormais géré
• Verilator (version 5.036 minimum) avec le flag --timing est maintenant pleinement fonctionnel

Gestion améliorée des tâches

L’API de gestion des tâches a été modernisée pour s’aligner sur celle d’asyncio` :

# Nouvelle fonction pour démarrer une tâche
cocotb.start_soon(ma_coroutine())

# Nouveau déclencheur pour attendre la fin d’une tâche
await task.complete  # au lieu de await Join(task)

# Annulation de tâches
task.cancel()  # au lieu de task.kill()

# Variables locales aux tâches
task.locals.ma_variable = valeur

Nouvelles fonctionnalités pour les signaux

Cocotb 2.0 enrichit les possibilités d’interaction avec les signaux HDL :

• Dépôts sans délai : La classe Immediate permet d’effectuer des assignations immédiates
• Nouvelle méthode set() : Une alternative à la propriété value avec un typage plus strict
• Gestion étendue des actions : Force, Freeze, Release et Deposit pour un contrôle fin des signaux

# Différents types d’assignations
dut.signal.set(42)                    # Assignation normale
dut.signal.set(42, Immediate())       # Assignation immédiate
dut.signal.set(42, Force())           # Forcer une valeur
dut.signal.set(Release())             # Libérer un signal forcé

Améliorations du typage

Cocotb 2.0 intègre maintenant mypy dans son processus de CI, garantissant une meilleure qualité du typage. Les utilisateurs bénéficient ainsi d’une meilleure expérience avec les IDE modernes et les vérificateurs de types.

Décorateur @cocotb.parametrize

Un nouveau décorateur simplifie la création de tests paramétrés, offrant une alternative plus moderne à TestFactory :

@cocotb.parametrize(
    width=[8, 16, 32],
    signed=[True, False]
)
@cocotb.test()
async def test_additionneur(dut, width, signed):
    # Test avec différentes combinaisons de paramètres
    pass

Gestion du logging améliorée

Le système de logging a été revu pour être moins intrusif :

• Nouvelle variable COCOTB_LOG_PREFIX pour personnaliser le préfixe des logs
• Séparation des niveaux de log pour GPI avec GPI_LOG_LEVEL
• Meilleure gestion de la capture des warnings Python
• Timestamps de simulation accessibles dans les LogRecord

Nouvelles structures de données

La version 2.0 enrichit considérablement le module cocotb.types :

• LogicArray : Représentation des tableaux de valeurs logiques avec gestion des états X, Z, etc.
• Logic : Valeur logique unique avec gestion des 9 états VHDL
• Méthodes de conversion : to_signed(), to_unsigned(), to_bytes(), from_bytes() pour faciliter les conversions

from cocotb.types import LogicArray, Range

# Création d’un tableau logique
data = LogicArray("10XZ01", Range(5, "downto", 0))

# Conversions
valeur_entier = data.to_unsigned(resolve=True)
octets = data.to_bytes()

Améliorations de l’écosystème

Flux de test en Python

Le flux de test Python (Python Test Runner), introduit expérimentalement en version 1.8, est maintenant mature et constitue l’alternative recommandée au système de Makefile traditionnel. Il permet une intégration plus naturelle avec pytest et simplifie la configuration des simulations.

Queues asyncio

Cocotb 2.0 introduit des files d’attente compatibles avec asyncio (Queue, PriorityQueue, LifoQueue), facilitant la communication entre coroutines.

Gestion des packages SystemVerilog

L’accès aux packages SystemVerilog est maintenant possible via cocotb.packages, permettant d’interagir avec les définitions globales du design.

Considérations sur l’adoption

Cette version majeure représente un investissement conséquent de l’équipe de développement. Pour les utilisatrices et utilisateurs existants, la migration nécessitera quelques ajustements, mais les bénéfices en termes de maintenabilité et de performances en valent la peine.

Le projet cocotb, développé principalement par la communauté et utilisé dans l’industrie comme dans l’enseignement, continue de démontrer la pertinence de l’approche Python pour la vérification matérielle. Cette version 2.0 consolide les bases pour les évolutions futures.

Pour les personnes qui débutent avec cocotb, c’est le moment idéal pour se lancer : la documentation a été revue, les exemples mis à jour, et l’API est désormais plus cohérente.

Remerciements et perspectives

Cette version est le fruit du travail de nombreuses personnes contributrices. Le projet est hébergé sur GitHub et accepte volontiers les contributions, qu’il s’agisse de code, de documentation ou de retours d’expérience.

Les prochaines versions devraient continuer à améliorer les performances, étendre la prise en charge des simulateurs et enrichir l’écosystème de bibliothèques de vérification. La communauté cocotb est active et accueillante, n’hésitez pas à la rejoindre !