TP1
Architecture des ordinateurs
▪ BOUZEKRAOUI
FATIMA-EZZAHRAE
▪ ELMEHDI ELHOUAT
▪ FAICAL BHAR
▪ YOUSSEF ARGANE
TABLE DES MATIERES
a. Introduction
b. Explication du programme
c. Execution du programme
d. Calcul du factoriel n
e. Conclusion
Architecture des ordinateurs PAGE 2
Introduction
Le présent rapport documente le travail réalisé dans le cadre du Travaux Pratiques
portant sur le langage d'assemblage MIPS et l'implémentation d'une opération de
puissance. L'objectif de ce TP est de mettre en pratique les concepts fondamentaux de
l'architecture MIPS, en se concentrant particulièrement sur l'utilisation des instructions
d'arithmétique et de contrôle de flux.
Dans ce contexte, le programme en langage d'assemblage MIPS fourni dans ce rapport
illustre la mise en œuvre d'une boucle pour calculer une opération de puissance, où un
nombre donné est élevé à une puissance spécifiée. Le programme utilise des registres
pour stocker les valeurs et des instructions de contrôle de flux pour itérer à travers une
boucle.
Avant d'analyser en détail le code source, nous commencerons par expliquer les
principaux concepts de l'architecture MIPS nécessaires à la compréhension du
programme. Ensuite, nous détaillerons chaque ligne du code, mettant en lumière la
logique sous-jacente à chaque instruction.
Enfin, nous procéderons à l'exécution du programme, en observant son comportement
étape par étape. Cette approche vise à renforcer la compréhension des participants
quant à la programmation en langage d'assemblage MIPS et à leur permettre d'acquérir
une expérience pratique dans le domaine
Architecture des ordinateurs PAGE 3
Explication du programme
Le but principal du programme en langage d'assemblage MIPS est de calculer la puissance d'un
nombre donné. Plus précisément, le programme prend deux valeurs, a et b, où a est le nombre de
base et b est l'exposant.
Ce programme en langage d'assemblage MIPS fourni vise à réaliser une opération de puissance
en utilisant une boucle et des registres pour stocker les valeurs impliquées. Voici une explication
détaillée du code :
▪ Initialisation des données:
.data
a: .word 3
b: .word 5
===>Ces lignes déclarent la section de données et initialisent deux variables, a avec la valeur 3 et b
avec la valeur 5.
▪ Chargement des valeurs dans les registres:
.text
lw $t0, a
lw $t1, b
===>Ces instructions chargent les valeurs de a et b dans les registres $t0 et $t1, respectivement.
▪ Initialisation du résultat:
li $t2, 1
===>Cette instruction initialise le registre $t2 à 1. $t2 sera utilisé comme accumulateur pour stocker
le résultat de la multiplication.
▪ Boucle de Calcul de Puissance:
boucle: beq $t1, $zero, affiche
mul $t2, $t0, $t2
subi $t1, $t1, 1
j boucle
===>La première ligne (beq $t1, $zero, affiche) vérifie si la valeur de $t1 (b) est égale à zéro. Si c'est
le cas, la boucle se termine et passe à l'étiquette affiche.
===>La deuxième ligne (mul $t2, $t0, $t2) multiplie la valeur de $t0 (a) par la valeur actuelle de $t2 et
stocke le résultat dans $t2.
===>La troisième ligne (subi $t1, $t1, 1) décrémente la valeur de $t1 (b) de 1.
===>La dernière ligne (j boucle) saute à l'étiquette boucle, permettant de répéter le processus jusqu'à
ce que $t1 soit égal à zéro.
▪ Affichage du Résultat:
affiche: li $v0, 1
add $a0, $zero, $t2
syscall
===>La première ligne (li $v0, 1) charge le code de système pour imprimer dans le registre $v0.
===>La deuxième ligne (add $a0, $zero, $t2) place la valeur de $t2 dans le registre d'argument $a0.
===>La dernière ligne (syscall) appelle le système pour exécuter l'impression de la valeur stockée
dans $a0.
Exécution du programme
Architecture des ordinateurs PAGE 4
L'exécution du programme consiste à itérer à travers une boucle où le résultat est
mis à jour à chaque itération par la multiplication avec la valeur de base. Une fois la
boucle terminée, le résultat final est affiché.
Architecture des ordinateurs PAGE 5
Modification du programme pour calculer factoriel
de n
Nouveau programme:
.data
n: .word 5 # Remplacez 5 par la valeur de n que vous souhaitez utiliser
result: .word 1
.text
lw $t0, n # Charger la valeur de n dans le registre $t0
li $t1, 1 # Initialiser le compteur à 1
li $t2, 1 # Initialiser le résultat à 1
boucle:
bge $t1, $t0, affiche # Si le compteur est supérieur ou égal à n, passer à l'affichage
mul $t2, $t2, $t1 # Multiplier le résultat actuel par la valeur du compteur
addi $t1, $t1, 1 # Incrémenter le compteur
j boucle
affiche:
li $v0, 1
lw $a0, result
syscall
Exécution :
Architecture des ordinateurs PAGE 6
Conclusion
En conclusion de ce Travaux Pratiques, nous avons exploré et mis en pratique
les concepts fondamentaux de l'architecture MIPS à travers la réalisation d'un
programme en langage d'assemblage. L'objectif principal était d'implémenter une
opération mathématique significative, à savoir le calcul de la puissance d'un nombre,
en utilisant des instructions MIPS telles que les chargements de registres, les
opérations arithmétiques et les boucles de contrôle de flux.
Au cours de cette expérience, nous avons renforcé notre compréhension des
caractéristiques spécifiques de l'architecture MIPS, telles que la gestion des
registres et l'utilisation d'instructions spécialisées. La manipulation des données en
mémoire et l'interaction avec le système via les appels systèmes ont également été
des points saillants de cet exercice.
Par ailleurs, nous avons étendu nos compétences en adaptant le programme pour
calculer le factoriel d'un nombre, démontrant ainsi la flexibilité du langage
d'assemblage MIPS pour des applications variées.
En réfléchissant sur ce TP, nous avons acquis une vision plus approfondie de la
programmation à bas niveau, ce qui est essentiel pour comprendre le fonctionnement
interne des processeurs et des systèmes informatiques. Les défis rencontrés lors de
la conception du programme ont contribué à améliorer notre résolution de
problèmes et notre capacité à traduire des algorithmes en instructions spécifiques au
matériel.
En somme, ce TP a constitué une expérience enrichissante, combinant la théorie de
l'architecture MIPS avec une mise en pratique concrète. Il a fourni une base solide
pour la compréhension des langages d'assemblage et des architectures de
processeurs, ouvrant ainsi la voie à des explorations plus avancées dans le domaine
de l'informatique bas niveau
Fin
Architecture des ordinateurs PAGE 7
