\chapter{Partie simulateur}

\section{Unité arithmétique et logique}
\paragraph{}
L'unité arithmétique et logique (ou ALU) a été programmée de deux manières distinctes:
\begin{itemize}
\item Un premier module de calcul binaire, calculant sur les entiers bits à bits, lent
mais collant à la définition du sujet.
\item Un second module de calcul entier, rapide, mais s'écartant du sujet.
\end{itemize}
Il est possible d'utiliser l'un ou l'autre des modules. Nous désirons écrire le module
de calcul entier fonctionnant à l'aide des routines de calcul du C pour des raisons de
tests. Dans un premier temps, nous pouvons comparer l'exécution d'un code source assembleur
avec l'un ou l'autre des deux modules de calcul, et dans un deuxième temps, nous pouvons
tester si nos codes sources assembleur marchent sans être freinés par la lenteur du module
de calcul binaire.
\paragraph{}
Pour pouvoir être implémenté de manière efficace, nous passons par un tableau de pointeurs
sur fonctions, tableau a double entrées. Les "lignes" du tableau représentant les fonctions
de l'ALU (ADD,~MUL, AND,~...) repérées par un enum\{\} en C, et les colonnes seront au nombre
de deux: la première colonne contiendra les fonctions normales (binaires) et la seconde
contiendra les fonctions rapides (entières).

\section{Unité de contrôle}
L'unité de contrôle est le c{\oe}ur du simulateur. Elle va s'occuper de lire les instructions
les unes après les autres, de les décoder, et de faire appel aux fonctions adéquates pour
exécuter l'instruction. Les appels aux unités de calculs (ALU et FPU) seront mis en place
par des tableaux de pointeurs sur fonctions, afin de permettre une modularité plus aisée.

\section{Unité de mémoire}
Cette unité doit uniquement lire ou écrire un mot dans la mémoire. Une coupe de fonctions
Init/Deinit permet d'initialiser la mémoire au début et à la fin de la simulation, afin
de réserver la quantité de mémoire demandée. Elle doit aussi vérifier si les décalages
demandés ne dépassent pas la quantité de mémoire présente. Elle servira aussi à l'extension
pour l'interface décrit plus bas.

\section{Unité de registres}
Cette unité doit uniquement lire ou écrire un registre. Cette unité est présente
pour bien dissocier les différents rôles des différents composants de notre microprocesseur.

\section{Unité FPU}
Cette unité ne possède qu'une seule fonction: celle de "planter" avec l'erreur
"FPU not present". Elle est présente uniquement pour permettre une évolution future.

\section{Interface}
\label{Interface}
\newcommand{\calcultaille}{$= 2^{32} * 4 \approx 16^9$}
Nous nous proposons d'effectuer une interface simple entre le simulateur et le monde
extérieur, via le \textit{MiniOS}\footnote{Voir section~\ref{MiniOS}, page~\pageref{MiniOS}}.
Des zones mémoires seront réservées pour l'interaction avec le MiniOS. C'est l'Unité de
mémoire qui va intercepter ces lectures/écritures et interfacer avec le MiniOS. Comme nous
n'avons aucune chance d'avoir 16Go\footnote{32 bits d'adressage sur des mots de 32 bits \calcultaille octets}
de mémoire sur notre machine virtuelle, nous allons utiliser des mots mémoire situés à de très hautes adresses.\\
\begin{footnotesize}
\begin{center}
\begin{tabular}{|c|c|l|}
\hline
\textbf{Adresse} & \textbf{Accès} & \textbf{Signification}\\
\hline
0xffffff00 &
Lecture &
\parbox[t]{14cm}{Ce mot passe à 1 si une touche est enfoncée. Il repasse à zéro après une lecture s'il n'y a plus de touches
disponibles dans le buffer.\\}\\
\hline
0xffffff01 &
Lecture &
\parbox[t]{14cm}{Ce mot contient le premier caractère disponible sur le buffer clavier du MiniOS.\\}\\
\hline
0xffffff02 &
Écriture &
\parbox[t]{14cm}{Ce mot correspond à l'adresse d'une zone de mémoire libre.
Lors de l'écriture de ce mot, le MiniOS lira une chaîne au clavier jusqu'au
caractère entrée, et placera la chaîne à l'adresse indiquée. Il y rajoutera un zéro terminal.
\\}\\
\hline
0xffffff03 &
Ecriture &
\parbox[t]{14cm}{Lors de l'écriture de ce mot, le MiniOS affichera le caractère ASCII correspondant.\\}\\
\hline
0xffffff04 &
Écriture &
\parbox[t]{14cm}{Ce mot correspond à l'adresse d'une chaîne ASCIIZ qui doit être affichée par le MiniOS. L'affichage
se fait dès l'écriture de ce mot.\\}\\
\hline
0xffffff05 &
Lecture &
\parbox[t]{14cm}{Lors d'une lecture de ce mot, le MiniOS tentera de lire un nombre sur le clavier, et de
le transcrire en binaire. Le résultat lu par le simulateur sera donc ce nombre lu par le MiniOS.\\}\\
\hline
0xffffff06 &
Écriture &
\parbox[t]{14cm}{Lors de l'écriture de ce mot, le MiniOS affichera sa valeur en décimal.\\}\\
\hline
0xffffff07 &
Écriture &
\parbox[t]{14cm}{Lors de l'écriture de ce mot, le MiniOS affichera sa valeur en hexadécimal.\\}\\
\hline
0xffffff08 &
Écriture &
\parbox[t]{14cm}{Lors de l'écriture de ce mot, le MiniOS affichera sa valeur en octal.\\}\\
\hline
0xffffff09 &
Écriture &
\parbox[t]{14cm}{Lors de l'écriture de ce mot, le MiniOS affichera sa valeur en binaire.\\}\\
\hline
0xffffff0a &
Écriture &
\parbox[t]{14cm}{Ce mot correspond à l'adresse d'une chaîne ASCIIZ. Elle indique le nom
d'un autre exécutable à charger en mémoire. Le MiniOS chargera le deuxième programme indiqué,
en le relogeant à la fin du segment non initialisé du programme appelant. Le deuxième programme
s'exécutera, puis l'exécution reviendra au programme appelant dès que le deuxième programme
aura terminé.\\}\\
\hline
\end{tabular}
\end{center}
\end{footnotesize}
\subparagraph{}
La colonne accès est très importante. En effet, les accès ne sont autorisés que dans le mode indiqué.
Si il y a par exemple un accès en lecture sur le mot d'adresse 0xffffff07, alors l'Unité mémoire
considérera qu'il y a une erreur d'adressage.
