cours-snt/nsi/nsi-von-neumann/cours.tex

\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[AC] 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 une succession de bits qui est interprétable par le processeur d'un ordinateur.\\
    Un \textbf{langage assembleur} est le langage machine machine ou des combinaisons de bits sont représentées par des "symboles" qu'un être humain peut mémoriser.
\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 xxxx & LD X & Lit le contenu de la cellule X (ACC ← \#X) \\
    0001 xxxx & STO X & Enregistre dans la cellule X (\#X ← ACC) \\
    0010 xxxx & ADD X & Ajoute le contenu de la cellule X (ACC ← ACC + \#X) \\
    0011 xxxx & SUB X & Soustrait le contenu de la cellule X (ACC ← ACC - \#X) \\
    0100 aaaa & JMP ADR & Saute à l'adresse ADR (CO ← A) \\
    0101 aaaa & JMPZ ADR & Saute à l'adresse ADR si nul \\
    0110 aaaa & JMPP ADR & Saute à l'adresse ADR si positif \\
    0111 aaaa & JMPN ADR & Saute à l'adresse ADR si négatif \\
\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.}
\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|l|l}
    Étape & RI & CO & Acc & RAM1 & RAM2 \\
    \hline
    Initiale & Ø & 8 & Ø & 25 & 14 \\
    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|l|l}
    Étape & RI & CO & Acc & RAM1 & RAM2 \\
    \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|l|l}
    Étape & RI & CO & Acc & RAM1 & RAM2 \\
    \hline
    Initiale &  & 8 &  &  &  \\
    1 & & & & & \\
    2 & & & & & \\
    3 & & & & & \\
    4 & & & & & \\
    5 & & & & & \\
    6 & & & & & \\
    7 & & & & & \\
    8 & & & & & \\
\end{tabular}
\end{figure}


\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|l|l}
    Étape & RI & CO & Acc & RAM1 & RAM2 \\
    \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}