Qu'est-ce que le processeur RISC V : architecture, fonctionnement et ses applications

RISC V est une architecture de jeu d'instructions développée par l'Université de Californie à Berkeley. Le concept de RISC était motivé par le fait que la plupart des instructions du processeur n'étaient pas utilisées par la plupart des programmes informatiques. Ainsi, une logique de décodage inutile était utilisée dans les conceptions de processeurs , consommant plus de puissance ainsi que la zone. Pour raccourcir le jeu d'instructions et investir davantage dans les ressources du registre, le Processeur RISC V a été mis en œuvre.

Cette technologie a été remarquée par de nombreux géants de la technologie et start-ups car elle est entièrement open source et gratuite. La plupart des types de processeurs sont disponibles avec un contrat de licence, mais avec ce type de processeur ; n'importe qui peut concevoir ses nouveaux processeurs. Cet article présente donc un aperçu du fonctionnement d'un processeur RISC V et de ses applications.

Qu'est-ce que le processeur RISC V ?

Dans le processeur RISC V, le terme RISC signifie 'ordinateur à jeu d'instructions réduit' qui exécute peu d'instructions informatiques alors que 'V' représente la 5ème génération. Il s'agit d'un matériel ISA open-source (architecture de jeu d'instructions) basé sur le principe établi de RISQUE .

Par rapport aux autres conceptions ISA, cet ISA est disponible avec une licence open source. Ainsi, un certain nombre d'entreprises de fabrication ont annoncé et également fourni du matériel RISC-V, avec des systèmes d'exploitation open source.

Il s'agit d'une nouvelle architecture et est disponible en licences ouvertes, non restrictives et gratuites. Ce processeur bénéficie d'un support étendu des industries des fabricants de puces et d'appareils. Il est donc principalement conçu pour être librement extensible et personnalisable pour être utilisé dans de nombreuses applications.

Historique du RISC V

Le RISC a été inventé par le professeur David Patterson vers 1980 à l'Université de Californie à Berkeley. Le professeur David et le professeur John Hennessy ont présenté leurs efforts dans deux livres, à savoir 'Computer Organization and Design' et 'Computer Architecture at Stanford University'. Ainsi, ils ont reçu l'ACM A.M. Prix ​​Turing en 2017.

De l'année 1980 à l'année 2010, la recherche de développement RISC de cinquième génération a été lancée et a finalement été identifiée comme RISC-V qui se prononce comme risque cinq.

Architecture et fonctionnement RISC V

L'architecture RV12 RISC V est illustrée ci-dessous. Le RV12 est hautement configurable avec un processeur RISC monocœur compatible RV32I et RV64I qui est utilisé dans les champs embarqués. Le RV12 appartient également à une famille de processeurs 32 ou 64 bits en fonction du jeu d'instructions RISC-V standard industriel.

Le RV12 exécute simplement une architecture Harvard pour un accès simultané aux instructions ainsi qu'à la mémoire de données. Il comprend également un pipeline en 6 étapes qui aide à optimiser les chevauchements entre l'exécution ainsi que les accès à la mémoire pour améliorer l'efficacité. Cette architecture comprend principalement la prédiction de branche, le cache de données, l'unité de débogage, le cache d'instructions et les unités de multiplicateur ou de diviseur en option.

Les principales caractéristiques du RV12 RISC V sont les suivantes.

• Il s'agit d'un jeu d'instructions standard de l'industrie.
• Paramétré avec des données 32 ou 64 bits.
• Il a des interruptions précises et rapides.
• Des instructions personnalisées permettent l'ajout d'accélérateurs matériels propriétaires.
• Exécution d'un seul cycle.
• Pipeline à six étages avec optimisation pliée.
• Prise en charge de la protection de la mémoire.
• Caches facultatifs ou paramétrés.
• Extrêmement paramétré.
• Les utilisateurs peuvent sélectionner des données 32/64 bits et une unité de prédiction de branche.
• Les utilisateurs peuvent sélectionner des caches d'instructions/de données.
• Structure, taille et architecture du cache sélectionnables par l'utilisateur.
• Prise en charge du diviseur ou du multiplicateur matériel par latence définie par l'utilisateur.
• L'architecture du bus est flexible et prend en charge Wishbone & AHB.
• Cette conception optimise la puissance et la taille.
• La conception est entièrement paramétrée, ce qui offre des performances ou des compromis de puissance.
• Conception Gated CLK pour diminuer la puissance.
• Support logiciel selon la norme de l'industrie.
• Simulateur d'architecture.
• Eclipse IDE est utilisé pour Linux/Windows.

Le pipeline d'exécution RISC V

Il comprend cinq étapes telles que IF (extraction d'instructions), ID (décodage d'instructions), EX (exécution), MEM (accès à la mémoire) et WB (réécriture de registre).

Extraction d'instructions

Dans l'étape Instruction Fetch ou IF, une seule instruction est lue à partir du compteur de programme (PC) et de la mémoire d'instructions qui est mise à jour à l'instruction suivante.

Pré-décodage d'instruction

Une fois que la prise en charge RVC est autorisée, l'étape de pré-décodage d'instruction décode une instruction compressée 16 bits en une instruction 32 bits native.

Décodage des instructions

Dans l'étape de décodage d'instruction (ID), le fichier de registre est autorisé et les contrôles de contournement sont décidés.

Exécuter

Dans l'étape d'exécution, le résultat est calculé pour une instruction ALU, DIV, MUL, la mémoire autorisée pour une instruction de stockage ou de chargement, et les branches et les sauts sont mesurés par rapport à leurs résultats attendus.

Mémoire

Dans cette étape de mémoire, la mémoire est accessible via le pipeline. L'inclusion de cette phase assure la haute performance du pipeline.

Répondre

Dans cette étape, le résultat de l'étape d'exécution est écrit dans le fichier de registre.

Prédicteur de branche

Ce processeur comprend une unité de prédiction de branche ou BPU qui est utilisée pour stocker les données passées afin de guider le processeur RISC V pour décider si une branche spécifique est prise ou non. Ces données de prédicteur sont simplement mises à jour une fois la branche exécutée.

Cette unité comprend différents paramètres qui déterminent son comportement. Par exemple, HAS_BPU est utilisé pour déterminer si une branche prédit qu'une unité est présente, BPU_GLOBAL_BITS déterminera combien de bits passés doivent être utilisés et BPU_LOCAL_BITS déterminera combien de LSB du compteur de programme doivent être utilisés. La combinaison de BPU_LOCAL_BITS et BPU_GLOBAL_BITS créera un vecteur qui est principalement utilisé pour adresser la Branch-Prediction-Table.

Cache de données

Ceci est principalement utilisé pour accélérer l'accès à la mémoire de données en mettant en mémoire tampon les emplacements de mémoire nouvellement accédés. Ceci est capable de gérer les accès demi-mot, octet et mot lorsque  XLEN = 32 s'ils sont sur leurs propres limites. Il est également capable de gérer les accès demi-mot, octet, mot et double mot lorsque XLEN=64 s'ils sont sur leurs propres limites.

Tout au long d'un manque de cache, un bloc entier peut être réécrit en mémoire. Ainsi, si nécessaire, un nouveau bloc peut être chargé dans le cache. Le cache de données est désactivé en définissant DCACHE_SIZE sur zéro. Après cela, les emplacements de mémoire sont accessibles directement via le Interface de données .

Cache d'instructions

Ceci est principalement utilisé pour accélérer la récupération des instructions en mettant en mémoire tampon les instructions nouvellement récupérées. Ce cache est utilisé pour extraire une parcelle pour chaque cycle sur n'importe quelle limite de 16 bits mais pas à travers une limite de bloc. Tout au long d'un manque de cache, un bloc entier peut être chargé à partir de la mémoire d'instructions. La configuration de ce cache peut se faire en fonction des besoins de l'utilisateur. La taille du cache, l'algorithme de remplacement et la longueur de bloc sont configurables.

Le cycle d'instructions sera désactivé en mettant ICACHE_SIZE à zéro. Après cela, les colis sont extraits directement de la mémoire via le Interface d'instructions.

Unité de débogage

L'unité de débogage permettra à l'environnement de débogage de s'arrêter et d'examiner le processeur. Les principales caractéristiques de ceci sont le traçage de branche, le traçage en une seule étape jusqu'à 8 points d'arrêt matériels.

Enregistrer le fichier

Ceci est conçu avec 32 emplacements de registre de X0 à X31 où le registre X9 est toujours à zéro. Le fichier de registre comprend 1 port d'écriture et 2 ports de lecture.

Interface configurable

Il s'agit d'une interface externe où ce processeur prend en charge différentes interfaces de bus externes.

Comment fonctionne RISC V ?

RISC-V est une architecture de jeu d'instructions ancrée dans les principes RISC (ordinateur à jeu d'instructions réduit). Ce processeur est tout à fait unique et également révolutionnaire car il s'agit d'un ISA gratuit, commun et open source où le matériel peut être développé, le logiciel peut être porté et les processeurs peuvent être conçus pour le prendre en charge.

Différence N/B RISC V Vs MIPS

La différence entre RISC V et MIPS comprend les éléments suivants.

Différence N/B RISC V Vs ARM

La différence entre RISC V et ARM comprend les éléments suivants.

Code Verilog RISC V

Le code verilog de la mémoire d'instructions pour RISC est illustré ci-dessous.

// Code Verilog pour le processeur RISC
// Code Verilog pour la mémoire d'instructions

module Instruction_Memory(
entrée[15:0] pc,
instruction sortie[15:0]
);

reg [`col – 1:0] mémoire [`row_i – 1:0] ;
fil [3 : 0] rom_addr = pc[4 : 1] ;
initial
commencer
$readmemb(“./test/test.prog”, mémoire,0,14);
fin
assigner instruction = mémoire[rom_addr] ;

module final

Code Verilog pour le processeur RISC V 16 bits :

module Risc_16_bit(
entrée clk
);

saut de fil, bne, beq, mem_read, mem_write, alu_src, reg_dst, mem_to_reg, reg_write ;
fil[1:0] alu_op ;
câbler l'opcode [3:0] ;

// Chemin de données

Datapath_Unit DU
(
.clk(clk),
.saute saute),
.grenouille(grenouille),
.mem_read(mem_read),
.mem_write(mem_write),
.alu_src(alu_src),
.reg_dst(reg_dst),
.mem_to_reg(mem_to_reg),
.reg_write(reg_write),
.bne(bne),
.alu_op(alu_op),
.opcode(opcode)
);

// Unité de contrôle
Control_Unit contrôle
(
.opcode(opcode),
.reg_dst(reg_dst),
.mem_to_reg(mem_to_reg),
.alu_op(alu_op),
.saute saute),
.bne(bne),
.grenouille(grenouille),
.mem_read(mem_read),
.mem_write(mem_write),
.alu_src(alu_src),
.reg_write(reg_write)
);
module final

Ensembles d'instructions

Les jeux d'instructions RISC V sont décrits ci-dessous.

Opérations arithmétiques

Les opérations arithmétiques RISC V sont listées ci-dessous.

Opérations logiques

Les opérations logiques RISC V sont répertoriées ci-dessous.

Opérations de chargement/stockage

Les opérations de chargement/stockage RISC V sont répertoriées ci-dessous.

Opérations de branchement

Les opérations de branchement RISC V sont répertoriées ci-dessous.

Avantages

La avantages du RISC Processeur V inclure les éléments suivants.

• En utilisant RISCV, nous pouvons économiser du temps de développement, de développement de logiciels, de vérification, etc.
• Ce processeur présente de nombreux avantages tels que la simplicité, l'ouverture, la modularité, la conception épurée et l'extensibilité.
• Ceci est pris en charge par plusieurs compilateurs de langage comme le GCC (GNU Compiler Collection), un compilateur de logiciel libre et via le Système d'exploitation Linux .
• Cela peut être utilisé librement par les entreprises en raison de l'absence de redevances, de frais de licence et d'aucune condition liée.
• Le processeur RISC-V n'inclut aucune fonctionnalité nouvelle ou innovante car il suit simplement les principes établis de RISC.
• Semblable à plusieurs autres ISA, cette spécification de processeur définit simplement différents niveaux de jeu d'instructions. Cela contient donc des variantes 32 et 64 bits ainsi que des extensions pour prendre en charge les instructions en virgule flottante.
• Ceux-ci sont gratuits, simples, modulaires, stables, etc.

Désavantages

La inconvénients du processeur RISC V inclure les éléments suivants.

• Les instructions complexes sont fréquemment utilisées par les compilateurs et les programmeurs.
• L'o / p d'un RISC peut changer en fonction du code lorsque les instructions suivantes dans une boucle dépendent de l'instruction précédente pour l'exécution.
• Ces processeurs doivent enregistrer rapidement une variété d'instructions, ce qui nécessite un grand ensemble de mémoire cache pour répondre à l'instruction en temps opportun.
• Les fonctionnalités complètes, les capacités et les avantages de RISC dépendent principalement de l'architecture.

Applications

La applications du RISC V processeur inclure les éléments suivants.

• RISC-V est utilisé dans les systèmes embarqués, l'intelligence artificielle et l'apprentissage automatique.
• Ces processeurs sont utilisés dans des applications de systèmes embarqués à hautes performances.
• Ce processeur convient à une utilisation dans certains domaines particuliers tels que l'informatique de pointe, l'IA et les applications de stockage.
• RISC-V est important car il permet aux petits fabricants d'appareils de concevoir du matériel sans payer.
• Ce processeur permet simplement aux chercheurs et aux développeurs de concevoir et de rechercher avec une architecture ISA ou un jeu d'instructions librement disponible.
• Les applications de RISC V vont des petits microcontrôleurs embarqués aux ordinateurs de bureau et aux superordinateurs, y compris les processeurs vectoriels.

Ainsi, ceci est un aperçu d'un processeur RISC V – architecture, travail avec des applications. Voici une question pour vous, qu'est-ce qu'un processeur CISC ?