UNIVERSITE D’ANTANANARIVO

ECOLE SUPERIEURE POLYTECHNIQUE D’ANTANANARIVO

MENTION ELECTRONIQUE

Parcours : Electronique Automatique

Niveau : M2

Rapport sur “Pratical Computer Architecture with Python and ARM”

RAZANAJATOVO Ornella Princy

Année universitaire : 2023-2024

1
 Sommaire
INTRODUCTION ....................................................................................................................................... 1
Chapitre 1 Machines à états finis aux ordinateurs", ............................................................................... 2
1.Généralités sur La machine à états finis........................................................................................... 2
2. Résolution d'un problème simple de manière algorithmique et construction d'un algorithme .... 3
Chapitre 2 Introduction Rapide à Python" .............................................................................................. 5
1.Chaine de caractères et listes........................................................................................................... 5
1.1 Chaine de caractère ................................................................................................................... 5
1.2 Listes .......................................................................................................................................... 5
2.Les fonctions..................................................................................................................................... 6
3. Exemple de programme Python pour simuler la mémoire d’un ordinateur ou simulation de la
mémoire avec python ......................................................................................................................... 6
Chapitre 3 Flux de Données dans un Ordinateur..................................................................................... 8
1 . L'ordinateur de von Neumann et le cycle fetch-execute ............................................................... 8
2. Flux d'informations et format d'instruction .................................................................................... 9
3.Assembleur ....................................................................................................................................... 9
4 .Langage machine ........................................................................................................................... 11
4.1 Langage machine RISC ............................................................................................................. 11
4.2 Langage machine CISC ............................................................................................................. 11
Chapitre 4 Création d'un Interpréteur .................................................................................................. 12
1 Construction d’un simple interpréteur avec python ...................................................................... 12
2 Décodage et exécution des instructions ........................................................................................ 13
Chapitre 5 Un Peu Plus de Python" ....................................................................................................... 15
1 .Fonctionnalités clés de Python...................................................................................................... 15
2 .Étude des listes et des chaînes de caractères comme structures de données essentielles. ........ 16
3. Introduction du dictionnaire comme une structure de données permettant de rechercher des
informations par clé. ......................................................................................................................... 17
4.Utilisation des list comprehensions pour simplifier le traitement du texte des instructions de
langage d'assemblage en nettoyant l'entrée .................................................................................... 18
Chapitre 6 TC1 Assembleur et Conception du Simulateur" ................................................................. 20
2.Description de l'architecture du jeu d'instructions de TC1 ............................................................ 20
3 . Présentation des deux composants de base du simulateur : l'assembleur et l'interpréteur. ..... 21
4. Explorations des caractéristiques inhabituelles de TC1, ............................................................... 22

2
 INTRODUCTION
Le livre "Practical Computer Architecture with Python and ARM"s'agit d'un ouvrage
qui vise à enseigner les principes fondamentaux de l'architecture informatique en utilisant
Python comme langage de programmation et l'architecture ARM comme exemple.

ARM est une architecture de processeur qui signifie "Advanced RISC Machine"
(Machine à jeu d'instructions réduit avancé) .Elle se distingue par sa conception de jeu
d'instructions RISC (Reduced Instruction Set Computing) et sa consommation d'énergie
relativement faible. Ces processeurs sont largement utilisés dans les smartphones, les
tablettes, les appareils IoT (Internet des Objets), les systèmes embarqués dans les
automobiles, les appareils ménagers intelligents, les routeurs, et même dans certains serveurs

Le livre comprend deux parties .Dans ce rapport, nous allons étudier la première
partie « Utilisation de Python pour simuler un ordinateur ».Cette partie introduit deux thèmes
l'ordinateur numérique et le langage de programmation Python que nous allons étudier dans
ce rapport

1
 Chapitre 1 Machines à états finis aux ordinateurs",
Les notions que j’ai acquises dans ce chapitre sont l’introduction les ordinateurs
numériques en utilisant les machines à états finis pour modéliser des systèmes de contrôle
simples. Ce chapitre aborde le concept d'algorithmes et de programmes .

1.Généralités sur La machine à états finis

Une machine à états finis, également connue sous le nom de machine à états finis
déterministe (MEF) ou automate fini, est un modèle mathématique abstrait qui représente le
comportement d'un système sous forme d'un ensemble fini d'états, de transitions entre ces
états et d'actions associés à ces transitions. Une machine à états finis est constituée des
éléments suivants :

États : Des conditions dans lesquelles le système peut se trouver à un moment donné.

Transitions : Des conditions ou des événements qui déclenchent le passage d'un état à un
autre.

Actions : Les actions associées à chaque transition, qui peuvent inclure des opérations ou des
modifications de l'environnement du système.

Exemple 1

Un ascenseur peut être dans l'état de montée, de descente ou de vol horizontal, et il peut
passer de l'un à l'autre de manière bien définie à travers des actions spécifiques (boutons
d'appel d'ascenseur, boutons d'étage, etc.

Exemple 2 : Feu de circulation

 États: Feu vert, feu orange, feu rouge.

 Transitions:
o Feu vert -> Feu orange après un certain temps.
o Feu orange -> Feu rouge après un certain temps.
o Feu rouge -> Feu vert après un certain temps.
 Événements:
o Changement de temps.
o Détection de véhicules en attente.

On utilise le modèle abstrait d’une machine à états finis pour comprendre comment
fonctionne un ordinateur . Ils possèdent un ensemble d'états et de transitions qui définissent
leur comportement. Les instructions du programme, les données et les événements externes
déclenchent des changements d'état. Par exemple, dans un ordinateur, les états pourraient
représenter différents modes de fonctionnement comme "en attente", "en cours d'exécution"
ou "en veille".

Les programmes informatiques fonctionnent souvent de manière séquentielle, où les

instructions sont exécutées à des moments discrets. De même, les transitions entre les états

2
dans les machines à états se produisent à des moments spécifiques, ce qui est analogue à
l'exécution d'instructions dans un programme informatique.

Comme les ordinateurs et de nombreux autres systèmes numériques peuvent être modélisés à
l'aide de machines à états, leur étude sert souvent d'introduction à ces domaines

2. Résolution d'un problème simple de manière algorithmique et construction d'un

algorithme
Les algorithmes sont des séquences d'instructions bien définies utilisées pour résoudre des
problèmes spécifiques, comme trier des données ou effectuer des calculs complexes. Leur
conception repose sur des concepts abstraits et leur utilisation est universelle,
indépendamment du langage de programmation ou de la plateforme. L'efficacité est un critère
important : les algorithmes sont conçus pour être rapides et utiliser un minimum de
ressources. En somme, les algorithmes sont des outils essentiels dans de nombreux domaines,
offrant des solutions systématiques à une variété de problèmes.

Prenons l’exemple de l'algorithme de tri par fusion

Fonction fusionner_gauche_droite(liste, gauche, milieu, droite)

n1 = milieu - gauche + 1

n2 = droite - milieu

gauche_temp = tableau de taille n1

droite_temp = tableau de taille n2

Pour i de 0 à n1-1

gauche_temp[i] = liste[gauche + i]

Pour j de 0 à n2-1

droite_temp[j] = liste[milieu + 1 + j]

i=0

j=0

k = gauche

Tant que i < n1 et j < n2

Si gauche_temp[i] <= droite_temp[j]

liste[k] = gauche_temp[i]

i=i+1

Sinon

3
 liste[k] = droite_temp[j]

j=j+1

k=k+1

Tant que i < n1

liste[k] = gauche_temp[i]

i=i+1

k=k+1

Tant que j < n2

liste[k] = droite_temp[j]

j=j+1

k=k+1

Fonction tri_fusion(liste, gauche, droite)

Si gauche < droite

milieu = (gauche + droite) / 2

tri_fusion(liste, gauche, milieu)

tri_fusion(liste, milieu + 1, droite)

fusionner_gauche_droite(liste, gauche, milieu, droite)

Liste = [12, 11, 13, 5, 6, 7]

tri_fusion(Liste, 0, taille(Liste) - 1)

Afficher "Liste triée par fusion:", Liste

4
 Chapitre 2 Introduction Rapide à Python"

Ce chapitre m'a offert un rappel des principes fondamentaux de la programmation en Python.

1.Chaine de caractères et listes

Dans le contexte de la conception d'un simulateur d'ordinateur en Python, les chaînes de
caractères et les listes sont des éléments cruciaux pour manipuler efficacement les données.

1.1 Chaine de caractère

Les chaînes de caractères sont utilisées pour représenter du texte, des instructions, des
messages et d'autres données textuelles dans un programme Python. Dans le contexte d'un
simulateur d'ordinateur :

 Représentation des instructions

Les instructions de l'ordinateur, telles que les opcodes, les opérandes et les adresses mémoire,
peuvent être stockées sous forme de chaînes de caractères.

Exemple instruction = "ADD 10, 20"

# Cette chaîne de caractères représente une instruction d'addition avec les opérandes 10 et 20.

 Messages et rapports

Les chaînes de caractères peuvent également être utilisées pour afficher des messages à
l'utilisateur, des rapports sur l'état de la simulation, des erreurs ou des résultats intermédiaires.

1.2 Listes
Les listes sont des structures de données polyvalentes en Python qui peuvent contenir une
séquence ordonnée d'éléments. Dans le contexte d'un simulateur d'ordinateur :

 Stockage de données séquentielles

Les listes peuvent être utilisées pour stocker des données séquentielles telles que des
instructions à exécuter, des valeurs de registres, des adresses mémoire, etc.

instructions = ["LOAD 10", "ADD 20", "STORE 30"]

# Cette liste stocke une séquence d'instructions à exécuter dans l'ordre.

 Manipulation des données

Les opérations de manipulation de listes telles que l'ajout, la suppression, la recherche et la

modification d'éléments sont essentielles pour gérer les données de la simulation. Par
exemple, lors de l'exécution d'un programme simulé, les listes peuvent être utilisées pour
stocker les instructions et les valeurs des registres, et ces listes seront modifiées au fur et à
mesure de l'exécution du programme.

registres = [0, 0, 0, 0] # Initialise les registres à zéro

5
registres[1] = 10 # Modifie la valeur du registre 1

registres[2] += 20 # Ajoute 20 à la valeur du registre 2

print(registres)

 Accès séquentiel

Les listes permettent un accès séquentiel aux éléments, ce qui est souvent nécessaire lors de la
lecture et de l'exécution des instructions dans un simulateur d'ordinateur.

for instruction in instructions:

if instruction.startswith("LOAD"):

# Exécuter l'instruction de chargement

elif instruction.startswith("ADD"):

# Exécuter l'instruction d'addition

elif instruction.startswith("STORE"):

# Exécuter l'instruction de stockage

else:

# Gérer les instructions inconnues ou incorrectes

2.Les fonctions
Le concept des fonctions est introduit comme des morceaux de code réutilisables pour
effectuer des opérations spécifiques, rendant le code plus lisible et plus facile à déboguer

3. Exemple de programme Python pour simuler la mémoire d’un ordinateur ou

simulation de la mémoire avec python
Voici un exemple de programme simple en Python qui simule la mémoire d'un ordinateur à
l'aide d'une liste et de fonctions pour lire et écrire des données à ces emplacements

# Fonction pour initialiser la mémoire avec une taille donnée

def init_memory(taille):

return [0] * taille # Crée une liste de taille avec des zéros

# Fonction pour écrire une valeur à une adresse mémoire spécifique

def write_memory(memory, adresse, valeur):

if 0 <= adresse < len(memory): # Vérifie si l'adresse est valide

memory[adresse] = valeur

6
 print(f"Écriture de la valeur {valeur} à l'adresse {adresse}")

else:

print("Erreur : Adresse mémoire hors limites")

# Fonction pour lire la valeur à une adresse mémoire spécifique

def read_memory(memory, adresse):

if 0 <= adresse < len(memory): # Vérifie si l'adresse est valide

valeur = memory[adresse]

print(f"Lecture de la valeur {valeur} depuis l'adresse {adresse}")

return valeur

else:

print("Erreur : Adresse mémoire hors limites")

return None

# Exemple d'utilisation des fonctions

taille_memoire = 100

memoire = init_memory(taille_memoire)

# Écrire des valeurs à des adresses mémoire spécifiques

write_memory(memoire, 0, 10)

write_memory(memoire, 1, 20)

# Lire les valeurs à partir des adresses mémoire spécifiques

valeur1 = read_memory(memoire, 0)

valeur2 = read_memory(memoire, 1)

# Afficher les valeurs lues

print("Valeur lue depuis l'adresse 0 :", valeur1)

print("Valeur lue depuis l'adresse 1 :", valeur2)

7
 Chapitre 3 Flux de Données dans un Ordinateur

Les notions que j’ai acquises dans ce chapitre sont l’architecture de Von Neumann et
le langage assembleur

1 . L'ordinateur de von Neumann et le cycle fetch-execute

Le modèle de l'ordinateur de von Neumann repose sur une architecture où les instructions et
les données résident dans la même mémoire et sont manipulées par un processeur utilisant un
cycle fetch-execute, où chaque instruction est récupérée, décodée et exécutée
séquentiellement.

L'ordinateur de von Neumann, est un concept fondamental en informatique qui décrit une
architecture informatique commune à la plupart des ordinateurs modernes. Ce modèle
architectural repose sur plusieurs principes clés :

 Unité de traitement centrale (CPU):

o Unité de contrôle (UC): Cerveau de l'ordinateur, elle interprète les instructions et orchestre le
fonctionnement.
o Unité arithmétique et logique (UAL): Effectue les calculs et les opérations logiques.
 Mémoire: Stocke les instructions et les données sous forme d'unités élémentaires appelées
"mots".
 Registres: Petites zones de stockage ultra-rapides accessibles à l'UC pour stocker
temporairement des données et des instructions.

Le cycle fetch-execute est le processus fondamental par lequel l'ordinateur de von Neumann
exécute les programmes. Ce cycle se déroule en plusieurs étapes :

Fetch (Récupération) :L'unité de contrôle récupère (fetch) l'instruction suivante depuis la

mémoire principale. Cela implique de lire l'instruction située à une adresse spécifique en
mémoire.

Décode (Décodage) : Une fois que l'instruction est récupérée, l'unité de contrôle la décode
pour déterminer quelle opération doit être effectuée et sur quelles données.

Execute (Exécution) : L'unité de contrôle transmet l'instruction à l'unité arithmétique et

logique (ALU) ou à d'autres parties de l'ordinateur pour qu'elles effectuent l'opération requise.
Cela peut impliquer des calculs arithmétiques, des transferts de données entre la mémoire et le
processeur, des opérations de comparaison, etc.

Une fois que l'étape d'exécution est terminée, le cycle fetch-execute se répète avec la
récupération de la prochaine instruction à exécuter. Ce cycle se poursuit jusqu'à ce que le
programme se termine ou soit interrompu.,

8
2. Flux d'informations et format d'instruction
Lors de l'exécution d'une instruction, des données sont transférées entre les différentes
parties du système informatique, y compris le processeur, la mémoire et les périphériques. Le
format d'une instruction comprend des champs tels que l'opcode (code opération) qui spécifie
l'action à effectuer, ainsi que d'autres données nécessaires à cette action, comme des adresses
mémoire, des valeurs littérales ou des numéros de registre

Par exemple, pour une instruction d'addition dans un format d'instruction hypothétique, le
format pourrait ressembler à ceci :

Opcode: ADD

Registre1: 2

Registre2: 3

Cela signifierait que l'opération à effectuer est une addition, et les données à additionner sont
situées dans les registres 2 et 3.

3.Assembleur
L'assembleur et les instructions conditionnelles, syntaxes mnémoniques et littéraux

L'assembleur est un langage de programmation de bas niveau qui permet de programmer un

ordinateur en langage symbolique plus proche du langage machine que du langage naturel. Il
offre un contrôle précis sur le fonctionnement du processeur et de la mémoire.

 Exécution des instructions conditionnelles:

Les instructions conditionnelles permettent d'exécuter une instruction ou un groupe

d'instructions uniquement si une condition est vraie. Elles sont essentielles pour créer des
programmes logiques et réactifs.

Syntaxe des instructions conditionnelles:

Forme générale:

Extrait de code

si condition alors

instructions

sinon

autres instructions

finsi

Utilisez ce code avec précaution.

Exemples d'instructions conditionnelles:

9
Extrait de code

; Si le registre EAX est supérieur à 10

si EAX > 10 alors

; Afficher "EAX est supérieur à 10"

mov eax, 1 ; Affichage de la valeur 1

int 80h

finsi

; Si le registre EBX est égal à 0

si EBX = 0 alors

; Sauter l'instruction suivante

jmp $+5

finsi

Utilisez ce code avec précaution.

 Syntaxes mnémoniques

L'assembleur utilise des mnémoniques pour représenter les instructions du processeur.

Chaque instruction a un mnémonique unique qui facilite la lecture et la compréhension du
code.

Exemples de mnémoniques:

mov: Déplacer une valeur d'un registre à un autre

add: Additionner deux valeurs

sub: Soustraire deux valeurs

jmp: Sauter à une autre instruction

 Assignation des littéraux

Les littéraux sont des valeurs constantes qui peuvent être assignées à des variables ou utilisées
directement dans les instructions.

Syntaxe d'assignation d'un littéral:

Extrait de code

variable = valeur

10
 Utilisez ce code avec précaution.

Exemples d'assignation de littéraux:

Extrait de code

; Afficher la valeur 10

mov eax, 10

int 80h

; Définir la variable "message" à "Hello World!"

message db "Hello World!", 10 ; 10 pour le caractère

4 .Langage machine

Le langage machine, quel que soit le type d'architecture (RISC ou CISC), est un ensemble
d'instructions codées en binaire que le processeur peut comprendre et exécuter directement.
Cependant, la façon dont ces instructions sont conçues diffère entre les architectures RISC
(Reduced Instruction Set Computer) et CISC (Complex Instruction Set Computer).

4.1 Langage machine RISC

 Instructions simples: Les instructions RISC sont généralement plus simples et plus courtes
que les instructions CISC. Elles se concentrent sur des opérations de base comme le
déplacement de données entre registres et la réalisation d'opérations arithmétiques et logiques
simples.
 Décodage rapide: En raison de leur simplicité, les instructions RISC peuvent être décodées
plus rapidement par le processeur, ce qui peut améliorer les performances.
 Pipeline efficace: L'architecture RISC favorise un pipeline d'instructions plus efficace, où le
processeur peut commencer à décoder l'instruction suivante pendant que l'instruction courante
est toujours en cours d'exécution.
 Besoin de plus d'instructions: Pour effectuer des tâches complexes, un programme RISC
peut nécessiter plus d'instructions qu'un programme CISC équivalent.

4.2 Langage machine CISC

 Instructions complexes: Les instructions CISC peuvent être plus complexes et plus longues
que les instructions RISC. Elles peuvent inclure des opérations multi-étapes, comme le
chargement d'une valeur en mémoire et son addition à une autre valeur en une seule
instruction.
 Décodage plus lent: Le décodage des instructions CISC peut prendre plus de temps en raison
de leur complexité.
 Pipeline moins efficace: La complexité des instructions CISC peut compliquer le pipeline
d'instructions.
 Code plus compact: Un programme CISC peut nécessiter moins d'instructions pour effectuer
la même tâche qu'un programme RISC équivalent.

11
 Chapitre 4 Création d'un Interpréteur
1 Construction d’un simple interpréteur avec python
Un interpréteur est un programme informatique qui lit et exécute du code source écrit dans un
langage de programmation particulier. Dans cet article, nous allons voir comment construire
un simple interpréteur avec Python.

Un interpréteur fonctionne généralement en plusieurs étapes :

­ Analyse lexicale : L'interpréteur décompose le code source en jetons, qui sont les
éléments de base du langage de programmation.
­ Analyse syntaxique: L'interpréteur vérifie que la structure du code source est correcte.
­ Analyse sémantique: L'interpréteur détermine la signification du code source.
­ Génération de code : L'interpréteur génère du code machine que le processeur peut
exécuter.
­ Exécution: L'interpréteur exécute le code machine généré.

Pour construire un simple interpréteur avec Python, nous pouvons utiliser les modules
suivants :

`re` : Ce module fournit des fonctions pour l'analyse lexicale.

`ast` : Ce module fournit des fonctions pour l'analyse syntaxique et l'analyse sémantique.

`exec : Ce module fournit des fonctions pour la génération de code et l'exécution.

Exemple de code Python pour un simple interpréteur :

import re

import ast

def interprete(code):

# Analyse lexicale

tokens = re.findall(r'\w+', code)

# Analyse syntaxique et analyse sémantique

arbre = ast.parse(code)

# Génération de code

code_machine = compile(arbre, '', 'exec')

# Exécution

exec(code_machine)

# Exemple d'utilisation

12
interprete("print('Hello, world!')")

Cet interpréteur est très simple et ne peut exécuter que des expressions simples. Cependant, il
peut être utilisé comme base pour construire des interpréteurs plus complets

2 Décodage et exécution des instructions

Le décodage et l'exécution d'une instruction sont deux étapes cruciales du cycle d'instruction
d'un processeur.:

 Décodage

Récupération de l'instruction : Le processeur récupère l'instruction suivante à partir de la

mémoire. L'adresse de l'instruction est généralement stockée dans le registre d'instruction
(PC).

Décodage du code d'opération :Le processeur décode le code d'opération de l'instruction. Le

code d'opération est un nombre binaire qui indique au processeur quelle opération doit être
effectuée.

Décodage des opérandes: Le processeur décode les opérandes de l'instruction. Les opérandes
sont les valeurs sur lesquelles l'opération est effectuée.

 Exécution

Exécution de l'opération: Le processeur exécute l'opération spécifiée par le code d'opération.

Cela peut impliquer de charger des valeurs dans des registres, d'effectuer des calculs
arithmétiques ou logiques, ou de stocker des valeurs dans la mémoire.

Mise à jour du PC: Le processeur met à jour le registre d'instruction (PC) pour pointer vers
l'instruction suivante à exécuter.

Exemple

Considérons l'instruction suivante :

ADD R1, R2, R3

Cette instruction additionne les valeurs des registres R2 et R3 et stocke le résultat dans le
registre R1. Voici comment cette instruction serait décodée et exécutée :

Décodage

1. Le processeur récupère l'instruction de la mémoire.

2. Le processeur décode le code d'opération, qui est `ADD` dans ce cas.

3. Le processeur décode les opérandes, qui sont les registres `R1`, `R2` et `R3`.

13
Exécution

1. Le processeur charge les valeurs des registres `R2` et `R3` dans l'unité arithmétique et
logique (ALU).

2. L'ALU additionne les deux valeurs.

3. Le processeur stocke le résultat dans le registre `R1`.

4. Le processeur met à jour le PC pour pointer vers l'instruction suivante.

Le décodage et l'exécution d'une instruction peuvent être influencés par plusieurs facteurs, tels
que :

Le type d'instruction: Le décodage et l'exécution d'une instruction complexe prendront plus de

temps que ceux d'une instruction simple.

Le nombre d'opérandes: Le décodage et l'exécution d'une instruction avec plusieurs opérandes

prendront plus de temps que ceux d'une instruction avec un seul opérande.

La technologie du processeur: Les processeurs modernes disposent de pipelines et d'autres

techniques qui permettent de décoder et d'exécuter les instructions plus rapidement.

14
 Chapitre 5 Un Peu Plus de Python"
1 .Fonctionnalités clés de Python.
Ce point implique l'exploration des fonctionnalités fondamentales de Python, telles que les
boucles, les structures de données, les fonctions, etc. Cela peut inclure l'étude de la syntaxe de
base, des opérateurs, des types de données et des concepts de programmation spécifiques à
Python.

Exemple

noms = ["Alice", "Bob", "Charlie", "David", "Eve"]

print("Liste de noms :")

for nom in noms:

print(nom)

print("\nNombres de 1 à 5 :")

i=1

while i <= 5:

print(i)

i += 1

ages = {"Alice": 25, "Bob": 30, "Charlie": 35, "David": 40, "Eve": 45}

def afficher_age(nom):

if nom in ages:

print(f"{nom} a {ages[nom]} ans.")

else:

print(f"{nom} n'est pas dans la liste des âges.")

print("\nAffichage des âges :")

afficher_age("Alice")

afficher_age("Bob")

afficher_age("Frank")

nombres_pairs = set(range(0, 11, 2))

print("\nEnsemble de nombres pairs de 0 à 10 :", nombres_pairs)

15
nombres_pairs.add(12)

print("Ensemble de nombres pairs mis à jour :", nombres_pairs)

2 .Étude des listes et des chaînes de caractères comme structures de données essentielles.
Il s'agit de comprendre comment utiliser efficacement les listes et les chaînes de caractères en
Python. Les listes sont des collections ordonnées d'éléments modifiables, tandis que les
chaînes de caractères sont des séquences de caractères immuables. On étudie comment créer,
accéder, modifier et manipuler ces stru ctures de données.

# Création d'une liste contenant des fruits

fruits = ["pomme", "banane", "orange", "fraise"]

# Affichage de la liste de fruits

print("Liste de fruits :", fruits)

# Accès à un élément de la liste par son index

print("Premier fruit de la liste :", fruits[0])

# Modification d'un élément de la liste

fruits[1] = "kiwi"

print("Liste de fruits après modification :", fruits)

# Ajout d'un nouvel élément à la liste

fruits.append("ananas")

print("Liste de fruits après ajout d'un nouvel élément :", fruits)

# Suppression d'un élément de la liste

del fruits[2]

print("Liste de fruits après suppression :", fruits)

# Création d'une chaîne de caractères

chaine = "Bonjour, monde !"

# Affichage de la chaîne de caractères

print("Chaîne de caractères :", chaine)

# Accès à un caractère de la chaîne par son index

print("Premier caractère de la chaîne :", chaine[0])

16
# Concaténation de chaînes de caractères

chaine_concatenee = chaine + " C'est une belle journée."

print("Chaîne de caractères concaténée :", chaine_concatenee)

# Recherche d'une sous-chaîne dans la chaîne de caractères

if "jour" in chaine_concatenee:

print("La sous-chaîne 'jour' est présente dans la chaîne de caractères.")

else:

print("La sous-chaîne 'jour' n'est pas présente dans la chaîne de caractères.")

3. Introduction du dictionnaire comme une structure de données permettant de

rechercher des informations par clé.
Le dictionnaire est une structure de données de type clé-valeur, où chaque élément est associé
à une clé unique. On explore comment créer et manipuler des dictionnaires en Python, ainsi
que leur utilisation pour stocker et rechercher des informations efficacement

# Création d'un dictionnaire contenant des informations sur des étudiants

etudiants = {

"A123": {"nom": "Alice", "age": 20, "ville": "Paris"},

"B456": {"nom": "Bob", "age": 22, "ville": "Lyon"},

"C789": {"nom": "Charlie", "age": 21, "ville": "Marseille"}

# Affichage du dictionnaire d'étudiants

print("Dictionnaire d'étudiants :", etudiants)

# Accès aux informations sur un étudiant par sa clé

cle_etudiant = "B456"

print("Informations sur l'étudiant avec la clé", cle_etudiant, ":", etudiants[cle_etudiant])

# Modification des informations sur un étudiant

etudiants["C789"]["age"] = 23

print("Dictionnaire d'étudiants après modification :", etudiants)

# Ajout d'un nouvel étudiant au dictionnaire

17
etudiants["D987"] = {"nom": "David", "age": 24, "ville": "Bordeaux"}

print("Dictionnaire d'étudiants après ajout d'un nouvel étudiant :", etudiants)

# Suppression d'un étudiant du dictionnaire

del etudiants["A123"]

print("Dictionnaire d'étudiants après suppression :", etudiants)

# Vérification de l'existence d'une clé dans le dictionnaire

if "A123" in etudiants:

print("La clé 'A123' est présente dans le dictionnaire.")

else:

print("La clé 'A123' n'est pas présente dans le dictionnaire.")

4.Utilisation des list comprehensions pour simplifier le traitement du texte des

instructions de langage d'assemblage en nettoyant l'entrée
Les list comprehensions sont une fonctionnalité puissante de Python permettant de créer des
listes de manière concise à partir de séquences existantes. On étudie comment utiliser les list
comprehensions pour transformer et nettoyer des données, par exemple en filtrant des
éléments, en appliquant des fonctions à chaque élément, ou en combinant des éléments de
plusieurs listes.

Exemples

Imaginons que nous ayons une liste d'instructions de langage d'assemblage sous forme de
chaînes de caractères, mais ces instructions contiennent des caractères spéciaux ou des
espaces supplémentaires que nous voulons nettoyer. Nous pouvons utiliser les list
comprehensions pour simplifier ce processus.

# Liste d'instructions avec des caractères spéciaux et des espaces supplémentaires

instructions_assembleur = [

"MOV AX, [BX]",

" ADD CX, [DX] ",

"MOV [SI], DX",

"CMP AX, BX",

"JMP LABEL"

18
# Utilisation de list comprehensions pour nettoyer les instructions

instructions_nettoyees = [instruction.strip().replace(",", "") for instruction in

instructions_assembleur]

# Affichage des instructions nettoyées

print("Instructions nettoyées :")

for instruction in instructions_nettoyees:

print(instruction)

Nous avons une liste instructions_assembleur contenant des instructions de langage

d'assemblage avec des caractères spéciaux et des espaces supplémentaires.

Nous utilisons une list comprehension pour nettoyer chaque instruction en utilisant les
méthodes strip() pour supprimer les espaces en début et fin de chaîne et replace(",", "") pour
supprimer les virgules.

Le résultat est stocké dans une nouvelle liste appelée instructions_nettoyees.

Enfin, nous parcourons la liste instructions_nettoyees et affichons chaque instruction

nettoyée.

19
 Chapitre 6 TC1 Assembleur et Conception du Simulateur"
1 .Le simulateur TC1
Le simulateur TC1 est présenté comme un outil capable de prendre un fichier texte écrit en
langage d'assemblage TC1, de le traduire en code machine et de l'exécuter. Cela permet aux
utilisateurs de programmer en langage d'assemblage TC1 et de voir comment leurs
programmes sont exécutés sur un ordinateur virtuel.

Le simulateur TC1 fonctionne généralement en plusieurs étapes :

 . Chargement du fichier d'assemblage:

Le simulateur charge le fichier texte contenant le code d'assemblage TC1 en mémoire.

Il vérifie ensuite la syntaxe du code pour s'assurer qu'il est correct.

 Traduction en code machine:

Le simulateur traduit ensuite le code d'assemblage en code machine que le processeur peut
exécuter.

Cette étape implique de convertir les instructions symboliques en opérandes et codes

d'opération binaires.

 . Exécution du code machine:

Le simulateur charge ensuite le code machine en mémoire et l'exécute instruction par

instruction.

Il suit l'état du processeur, y compris les registres, la mémoire et le compteur d'instructions.

 Affichage des résultats:

Le simulateur peut afficher les résultats de l'exécution du programme, tels que la valeur des
registres et la sortie du programme.

Il peut également afficher des informations de débogage, telles que la trace d'exécution et les
valeurs de la mémoire.

2.Description de l'architecture du jeu d'instructions de TC1

L'architecture du jeu d'instructions de TC1 est expliquée comme étant similaire à une
architecture RISC classique. Cela signifie que les opérations sur les données se font
directement entre les registres du processeur, sans impliquer de mémoire ex Description de
l'architecture du jeu d'instructions de TC1

20
Similarités avec une architecture RISC classique:

­ Opérations sur les registres: Comme vous l'avez mentionné, l'architecture du jeu
d'instructions de TC1 est similaire à une architecture RISC classique. Cela signifie que
la plupart des instructions opèrent sur des données stockées dans les registres du
processeur.
­ Réduction de la mémoire externe: Cette approche permet de réduire l'utilisation de la
mémoire externe pour les calculs, ce qui peut améliorer la vitesse d'exécution du
programme.
­ Instructions simples: Les architectures RISC, y compris TC1, ont tendance à avoir un
ensemble d'instructions plus simple que les architectures CISC. Cela facilite la
conception du processeur et peut également améliorer la vitesse d'exécution.
­

Caractéristiques spécifiques du jeu d'instructions de TC1:

­ Taille des registres: Le jeu d'instructions TC1 utilise généralement des registres de 32
bits.
­ Types de données: Le jeu d'instructions prend en charge les types de données courants
tels que les entiers, les flottants et les caractères.
­ Instructions arithmétiques et logiques: Le jeu d'instructions inclut des instructions pour
les opérations arithmétiques et logiques basiques, telles que l'addition, la soustraction,
la multiplication, la division, et le ET/OU/NON logique.
­ Instructions de transfert de données: Le jeu d'instructions inclut des instructions pour
charger et stocker des données dans la mémoire, ainsi que pour copier des données
entre les registres.
­ Instructions de branchement: Le jeu d'instructions inclut des instructions pour les sauts
conditionnels et inconditionnels, permettant de contrôler le flux d'exécution du
programme.
­ Instructions d'appel et de retour: Le jeu d'instructions inclut des instructions pour
appeler des sous-programmes et pour revenir de l'appel.terne pour les calculs.

3 . Présentation des deux composants de base du simulateur : l'assembleur et

l'interpréteur.
Le simulateur TC1 est composé de deux éléments principaux : l'assembleur et l'interpréteur.
L'assembleur prend en charge la traduction des mnémoniques (instructions en langage
d'assemblage) en instructions binaires compréhensibles par le processeur, tandis que
l'interpréteur lit ces instructions binaires et les exécute.

21
Exemple:

Supposons que nous avons le code d'assemblage suivant :

ADD R1, R2, R3 ; Additionne les valeurs des registres R2 et R3 et stocke le résultat dans R1

SUB R4, R5, R6 ; Soustrait la valeur de R6 de la valeur de R5 et stocke le résultat dans R4

L'assembleur:

Analyse du code: L'assembleur lit le code d'assemblage ligne par ligne et analyse chaque
instruction.

Conversion en binaire: L'assembleur convertit chaque instruction mnémonique en son

équivalent binaire.

Génération du fichier objet: L'assembleur génère un fichier objet qui contient le code binaire
et d'autres informations symboliques.

L'interpréteur:

Chargement du fichier objet: L'interpréteur charge le fichier objet généré par l'assembleur en
mémoire.

Exécution des instructions: L'interpréteur lit chaque instruction binaire et l'exécute une par
une.

Suivi de l'état du processeur: L'interpréteur suit l'état du processeur, y compris les registres, la
mémoire et le compteur d'instructions.

Exemple d'exécution:

Lorsque l'interpréteur exécute le code d'assemblage ci-dessus, il effectue les étapes suivantes :

Il charge les valeurs des registres R2 et R3 dans l'unité arithmétique et logique (ALU).

Il additionne les deux valeurs et stocke le résultat dans le registre R1.

Il charge les valeurs des registres R5 et R6 dans l'ALU.

Il soustrait la valeur de R6 de la valeur de R5 et stocke le résultat dans le registre R4.

4. Explorations des caractéristiques inhabituelles de TC1,

TC1 est décrit comme ayant des caractéristiques inhabituelles telles qu'une structure de code
source libre, ce qui signifie que la syntaxe des instructions peut être flexible. De plus, TC1
prend en charge différentes représentations de nombres (décimal, binaire, hexadécimal) et
utilise des dictionnaires Python pour gérer les étiquettes, simplifiant ainsi la gestion des
adresses mémoire.

22
 CONCLUSION

La simulation d'un ordinateur avec Python est un outil pédagogique précieux pour
apprendre les concepts fondamentaux de l'architecture informatique. Cette approche m’a
permis d'expérimenter et de visualiser le fonctionnement d'un ordinateur de manière
accessible et interactive.

On nous a demandé de lire le livre Pratical Computer Architecture with Python and
ARM et faire un rapport de ce qu'on a appris du livre.J'ai lu que la 1ère partie Utilisation de
Python pour simuler un ordinateur ».Qu'est ce que je peux faire comme conclusion de mon
rapport

23