RISCV-BOOM (Berkeley Out-of-Order Machine) est un processeur RISC-V open-source performant et synthétisable, implémenté avec le langage de description matériel Chisel. En tant que processeur paramétrable pour la recherche architecturale, il supporte l'ensemble d'instructions RV64GC avec des fonctionnalités telles que le calcul en virgule flottante IEEE 754, les opérations atomiques, la mémoire cache et la mémoire virtuelle. Ce processeur peut être déployé sur FPGA pour exécuter Linux. Ce guide détaille le processus complet pour contribuer à la communauté RISCV-BOOM.

Raisons de Contribuer à RISCV-BOOM

RISCV-BOOM, avec sa troisième génération SonicBOOM, atteint des performances comparables aux processeurs commerciaux hors-ordre. Contribuer permet d'approfondir la conception de processeurs modernes et de favoriser l'écosystème matériel open-source. La communauté accueille toutes les contributions, qu'il s'agisse de corriger des bogues, d'optimiser les performances ou de développer de nouvelles fonctionnalités.

Préparation Initiale

1. Configuration de l'Environnement

Pour instancier le noyau BOOM, utilisez le générateur SoC Chipyard. Procédez comme suit :

git clone https://repository.example.com/riscv-boom-clone
cd riscv-boom-clone
# Consulter le fichier REFERENCE.hash pour les versions compatibles avec Chipyard

2. Structure du Projet

Le code source se trouve dans le répertoire src/main/scala, avec des versions v3 et v4 :

• v3/ : Implémentation de l'architecture SonicBOOM, incluant les unités d'exécution hors-ordre, le prédicteur de branchement et la logique de renommage.
• v4/ : Développement d'une architecture nouvelle génération avec des unités de lancement et un système mémoire plus flexibles.
• Documentation : Le répertoire docs/ contient des documents architecturaux et des guides utilisateurs.
• Scripts utilitaires : Le dossier util/ fournit des outils pour les tests et le débogage.

Conventions de Style de Code

Adopter un style cohérent est crucial pour la maintenabilité du projet. RISCV-BOOM suit ces normes :

Nomenclature

• Variables Scala : utiliser la notation camelCase (ex. scalaVariableLocale).
• Variables Chisel : utiliser des underscores (ex. chisel_variable_locale).
• Noms de classes : utiliser PascalCase (ex. FichierRegistres).
• Variables d'étape : inclure l'information de cycle (ex. f2_valide pour le signal valide au deuxième cycle de la phase de fetch).

Formatage

Les structures de contrôle (if/when/for) ont les accolades sur la même ligne que la condition :

if (condition) {
  // Bloc de code
} else {
  // Branche alternative
}

Les classes et objets ont les accolades sur une nouvelle ligne :

class ModuleExemple extends Module
{
  // Implémentation du module
}

Utiliser une indentation de 2 espaces (pas de tabulation), et séparer les blocs de code avec des commentaires :

//----------------------------
// Nouveau module fonctionnel
//----------------------------

La commande make verifier_style peut valider la conformité, mais certaines règles nécessitent une vérification manuelle. Les spécifications complètes sont dans le fichier CONTRIB_ET_STYLE.md.

Processus de Contribution

1. Idantifier les Axes de Contribution

• Correction de bogues : fournir des fragments de code reproductibles et comparer avec le simulateur RISC-V Spike.
• Développement de fonctionnalités : discuter préalablement de la conception via la liste de diffusion (riscv-boom@groupes.example.com) ou les issues GitHub.
• Amélioration de la documentation : compléter les explications architecturales, notamment dans le répertoire docs/sections/.
• Tâches en attente : se référer au fichier TODO.md, incluant :
  • Ajouter des bits d'attente pour la désambiguïsation mémoire.
  • Implémenter le hit-under-miss pour le cache d'instructions.
  • Développer un prélecteur de données.
  • Supporter la sous-configuration des ports de fichiers de registres.

2. Développement et Soumission

• Stratégie de branches : créer des branches fonctionnelles à partir de master, nommées fonctionnalite/xxx ou correction_bogue/xxx.
• Messages de commit : utiliser des descriptions claires, comme "[Décodeur] Correction de l'extension de signe immédiate dans les instructions de type J".
• Revue de code : après la soumission d'un PR, il doit passer les vérifications CI et être approuvé par au moins un développeur principal.

3. Exemple de Développement : Ajouter un Prédicteur de Branchement

En guise d'illustration, pour implémenter un nouvel algorithme de prédiction de branchement :

1. Définir l'interface : étendre le trait PredicteurBranchement dans src/main/scala/v3/ifu/bpd/predicteur.scala.
2. Implémenter la logique : s'inspirer du prédicteur TAGE existant (tage.scala) pour coder la prédiction.
3. Tester l'intégration : utiliser le framework de test Chipyard pour valider la précision de la prédiction.
4. Évaluer les performances : mesurer les gains via des benchmarks comme CoreMark ou SPEC.

Tests et Vérification

1. Tests Unitaires

Écrire des tests unitaires pour les nouvelles fonctionnalités dans src/test/scala. Utiliser ChiselTest pour vérifier le comportement des modules :

tester(monNouveauComposant) { composant =>
  appliquerSignaux(composant.io.entree, ...)
  verifierSorties(composant.io.sortie, valeurs_attendues)
}

2. Tests d'Intégration

Exécuter des tests système complets via Chipyard :

• Tests d'ensemble d'instructions : valider la compatibilité ISA RISC-V.
• Tests de performance : utiliser CoreMark et Dhrystone pour évaluer la vitesse.
• Tests fonctionnels : faire tourner le noyau Linux et des applications.

3. Prototypage sur FPGA

Utiliser FireSim sur AWS F1 FPGA pour une vérification à grande échelle, garantissant que le design est synthétisable et atteint les objectifs de performance.

Échanges au Sein de la Communauté

• Liste de diffusion : envoyer questions et suggestions à riscv-boom@groupes.example.com.
• Issues GitHub : soumettre des rapports de bogues et des demandes de fonctionnalités.
• Discussions architecturales : participer à des ateliers comme CARRV (Computer Architecture Research with RISC-V).