\documentclass[11pt,a4paper]{../../template/template_cours}
\usepackage{float}

\title{Architectures matérielles — Découvrir Von Neumann}
\author{Adrian Amaglio}
\def\thesequence{NSI première}

\usepackage{tikz}

\begin{document}
\maketitle

% ---
\section{Architecture Von Neumann}
\begin{figure}[h!]
    \center
    \includegraphics[width=\textwidth]{archVN.png}
    \caption{Architecture Von Neumann. Les registres sont sur fond clair}
\end{figure}


% ---
\section{La mémoire vive (ou RAM)}
Il s’agit d’un tableau de bits (64 dans les ordinateurs récents).
\begin{figure}[h!]
\begin{tabular}{r|l}
    Adresse (ici sur 4 bits) & valeur (ici sur 8 bits) \\
    \hline
    0000 & 0110 1010 \\
    0001 & 1111 1111 \\
    0010 & 1111 0000 \\
    … & … \\
\end{tabular}
\end{figure}


% ---
\section{Les Registres}
Le processeur ne traite pas directement les données en RAM, il utilise pour cela des registres (de la mémoire directement inclue dans le processeur).\\
Parmi ces registres, nous allons utiliser les trois suivants :
\begin{description}
    \item[RI] le registre d'instruction ; il contient l'instruction en cours ;
    \item[CO] le compteur ordinal ; il contient l'adresse de la prochaine instruction à exécuter ;
    \item[ACC] l'accumulateur ; registre de l'UAL chargé de stocker une des opérandes avant l'exécution puis le résultat de l'opération.
\end{description}

% ---
\section{Les instructions}
Un processeur est capable d’exécuter des instructions.
\begin{definition}
    Le \textbf{langage machine} est un ensemble d’instructions binaire que le processeur peut suivre.\\
    Un \textbf{langage assembleur} est la version lisible (par les humain·e·s) de ce langage binaire.
\end{definition}
Un langage assembleur est souvent spécifique un type de processeur.

\begin{figure}[h!]
\begin{tabular}{l|l|l}
    Instruction machine & Instruction Assembleur & Effet \\
    \hline
    0000 aaaa & LD A     & Lit le contenu de la cellule A (ACC ← A) \\
    0001 aaaa & STO A    & Enregistre dans la cellule A (A ← ACC) \\
    0010 aaaa & ADD N    & Ajoute le contenu de la cellule A (ACC ← ACC + N) \\
    0011 aaaa & SUB N    & Soustrait le contenu de la cellule A (ACC ← ACC - N) \\
    0100 aaaa & JMP A    & Saute à l'adresse A (CO ← A) \\
    0101 aaaa & JMPZ A   & Saute à l'adresse A (CO ← A) si ACC = 0\\
    0110 aaaa & JMPP A   & Saute à l'adresse A (CO ← A) si ACC > 0 \\
    0111 aaaa & JMPN A   & Saute à l'adresse A (CO ← A) si ACC < 0 \\
\end{tabular}
    \caption{Un exemple de langage machine, dont une opération est numérotée sur 4 bits et un paramètre sur 4 bits également.\\
    \#A signifie, la valeur de la case d’adresse A.}
\end{figure}

Voici un exemple d’état de la mémoire et des registres.
Que va faire le processeur ainsi démarré ?
\begin{figure}[h!]
    \centering
\begin{tabular}{l|l}
    Adresse & Contenu \\
    \hline
    0 & 25 \\
    1 & 14 \\
    … & … \\
    8 & LD 0 \\
    9 & SUB 1 \\
    10 & STO 2 \\
    11 & END \\
\end{tabular}\hspace{5em}
\begin{tabular}{l|l|l|l}
    Étape & RI & CO & Acc\\
    \hline
    Initiale & & 8 &  \\
    1 & & & \\
    2 & & & \\
    3 & & & \\
    4 & & & \\
\end{tabular}
\end{figure}


\subsection{Exercice}
Voici un exemple d’état de la mémoire et des registres.
Complétez le tableau de droite pour simuler les actions du processeur et essayez de décrire ce que fait ce programme.
\begin{figure}[h!]
    \centering
\begin{tabular}{l|l}
    Adresse & Contenu \\
    \hline
    0 & 3 \\
    1 & 20 \\
    … & … \\
    8 & LD 0 \\
    9 & ADD 10 \\
    10 & STO 2 \\
    11 & END \\
\end{tabular}\hspace{5em}
\begin{tabular}{l|l|l|l}
    Étape & RI & CO & Acc \\
    \hline
    Initiale &  & 8 & \\
    1 & & & \\
    2 & & & \\
    3 & & & \\
    4 & & & \\
\end{tabular}
\end{figure}

\subsection{Exercice}
Voici un exemple d’état de la mémoire et des registres.
Complétez le tableau de droite pour simuler les actions du processeur et essayez de décrire ce que fait ce programme.
\begin{figure}[h!]
    \centering
\begin{tabular}{l|l}
    Adresse & Contenu \\
    \hline
    0 & 3 \\
    1 & 20 \\
    … & … \\
    8 & LD 0 \\
    9 & ADD 10 \\
    10 & JMP 8 \\
    11 & END \\
\end{tabular}\hspace{5em}
\begin{tabular}{l|l|l|l}
    Étape & RI & CO & Acc \\
    \hline
    Initiale &  & 8 &   \\
    1 & & & \\
    2 & & & \\
    3 & & & \\
    4 & & & \\
    5 & & & \\
    6 & & & \\
    7 & & & \\
    8 & & & \\
\end{tabular}
\end{figure}

\subsection{Exercice}
    \textbf{Bonus.}
    Écrire un programme en langage assembleur qui récupère la valeur en RAM à l’adresse 0, à ajoute 1 et stock le résultat à l’adresse 0.

\subsection{Exercice}
\textbf{Bonus.} Voici un exemple d’état de la mémoire et des registres.
Complétez le tableau de droite pour simuler les actions du processeur et essayez de décrire ce que fait ce programme.
\begin{figure}[h!]
    \centering
\begin{tabular}{l|l}
    Adresse & Contenu \\
    \hline
    0 & 3 \\
    1 & 20 \\
    … & … \\
    8 & LD 0 \\
    9 & SUB 1 \\
   10 & JUMPZ 13 \\
   11 & JUMP 9 \\
   12 & JMP 8 \\
   13  & STO 0 \\
   14 & END \\
\end{tabular}\hspace{5em}
\begin{tabular}{l|l|l|l}
    Étape & RI & CO & Acc \\
    \hline
    Initiale &  & 8 &  \\
    1 & & & \\
    2 & & & \\
    3 & & & \\
    4 & & & \\
    5 & & & \\
    6 & & & \\
    7 & & & \\
    8 & & & \\
\end{tabular}
\end{figure}

\subsection{Exercice}
    \textbf{Bonus.}
    Écrire un programme en langage assembleur qui récupère la valeur en RAM à l’adresse 0, à ajoute 1 et stock le résultat à l’adresse 0.
\subsection{Exercice}
    \textbf{Bonus.}
    Écrire un programme en langage assembleur qui récupère la valeur en RAM à l’adresse 0, à ajoute 1 si elle est négative (et retranche 1 si elle est positive) et stock le résultat à l’adresse 0.
\subsection{Exercice}
    \textbf{Bonus.}
    Écrire un programme en langage assembleur qui récupère la valeur en RAM à l’adresse 0, à ajoute 1 si elle est négative (et retranche 1 si elle est positive) et stock le résultat à l’adresse 0, puis recommence jusqu’à ce que la valeur soit nulle.


\end{document}