Architectures matérielles

L’architecture de von Neumann est un modèle d'ordinateur qui utilise une structure de stockage unique pour conserver à la fois les instructions et les données demandées ou produites. 

De telles machines sont aussi connues sous le nom d’ordinateur à programme enregistré.
Tous nos ordinateurs sont basés sur cette architecture.

C'est le mathématicien John von Neumann qui a élaboré en juin 1945 dans le cadre du projet EDVAC1 la première description d’un ordinateur dont le programme est stocké dans sa mémoire.

L’architecture de von Neumann décompose l’ordinateur en 4 parties distinctes :

• L’unité arithmétique et logique (UAL) appelée aussi unité de traitement.
  Cette unité effectue les opérations de base (calculs, tests logiques, etc.) ;
• L’unité de contrôle, qui réalise le « séquençage » des opérations : : c’est-à-dire qu’elle gère les actions des différents composants de l’ordinateur ;
• La mémoire qui contient les données et le programme à exécuter.
  Le programme indique à l’unité de contrôle quels sont les calculs à effectuer et avec quelles données.
  La mémoire se divise entre :
• La mémoire volatile : RAM (Random Access Memory)
  Les programmes et données en cours d'exécution sont stockées dans la RAM.
• La mémoire permanente : ROM (Read Only Memory)
  Les programmes et les données de base sont stockées de manière permanente dans la ROM.
• Les interfaces d’entrée-sortie, qui permettent de communiquer avec le monde extérieur.

• Le processeur

Le processeur ou CPU ( Central Processing Unit) est le cerveau de l’ordinateur.
Il organise les échanges de données entre les composants (mémoire RAM, disque dur, carte graphique).

Ces principales tâches sont :

• Lire les données en mémoire,
• Traiter les données,
• Ecrire des données en mémoire.

Le nombre d'opérations effectuées par seconde par un processeur s'exprime en gigahertz (Ghz).

Aujourd’hui, les processeurs tournent entre 1.5 et 3,5 GHz
Certains ordinateurs sont équipés de plusieurs processeurs (multi-processeurs) ce qui permet d'effectuer des traitements en parallèle.

• Les barrettes de RAM

Elles forment la mémoire centrale de l’ordinateur. Elles stockent, de manière volatile, tout ce qui est actuellement en cours d’exécution sur l’ordinateur : cela comprend l’instance en cours du système d’exploitation (c’est-à-dire les données et programmes faisant fonctionner le système d’exploitation), ainsi que tous les codes-sources et les données des programmes en cours d’exécution.

• Le stockage de masse

C’est la mémoire d'archivage de l’ordinateur.
Son rôle est de stocker des données. 

Le disque dur contient le système d'exploitation, les programmes installés et les données personnelles de l’utilisateur.
Les données sont stockées sous forme binaire. 

Aujourd’hui, les stockages de masse peuvent stocker plusieurs Tera octets (To) de données (soit $10^24$ octets), ce qui correspond à des centaines de milliers de photographies, des milliers de films, des millions de documents textes.

Il existe plusieurs technologies de stockage de masse :

• Les disques durs magnétiques : ils contiennent des pièces mécaniques dont une tête de lecture qui lit et écrit les données;
• Les SSD (Solid State Drive) : sans pièce mécanique, ils lisent les données plus rapidement;
• Les disques durs externes

• La carte mère

C’est une carte électronique qui sert de support à tous les éléments de l’unité centrale : la carte mère sert de support au processeur, disque dur/SDD, barrettes de RAM, etc.
Elle relie tous ces composants par des bus de communication, pour qu’ils s’échangent des données.

• La carte graphique
• La carte son
• La carte réseau.

La plupart des composants d'un ordinateur sont basés sur le transistor.
Ce composant électronique, inventé en 1947, se comporte comme un interrupteur.
Soit le transistor laisse passer le courant électrique (interrupteur fermé), soit il ne le laisse pas passer (interrupteur ouvert).
Ainsi un ordinateur fonctionne uniquement avec deux états, un état "haut" symbolisé par le chiffre 1 et un état "bas" symbolisé par le chiffre 0.

Les transistors présents dans les ordinateurs sont gravés sur des plaques de silicium pour former des circuits intégrés.

Un circuit intégré peut comporter plusieurs millions de transistors.

Les transistors permettent d'implémenter des circuits logiques qui sont basés sur l'algèbre de Bool.

Un circuit logique prend en entrée et en sortie des signaux électriques (chaque entrée ou sortie est dans un état "haut" (symbolisé par un "1") ou à un état "bas".

• La porte NON : elle inverse le signal en entrée.

Table de vérité de la porte NON :

\[\color{black}{\begin{array}{|c|c|}
\hline
\text{E (entrée)} & \text{S (sortie)}\\
\hline
1 & 0\\
\hline
0 & 1\\
\hline
\end{array}}\]

• La porte OU :

Table de vérité de la porte OU :

• La porte ET :

Table de vérité de la porte ET :

\[\color{black}{\begin{array}{|c|c|c|}
\hline
\text{E1} & \text{E2} & \text{ET(E1,E2)}\\
\hline
1 & 1 & 1\\
\hline
1 & 0 & 0\\
\hline
0 & 1 & 0\\
\hline
0 & 0 & 0\\
\hline
\end{array}}\]

• La porte OU Exclusif (XOR) :

Table de vérité de la porte XOR :

\[\color{black}{\begin{array}{|c|c|c|}
\hline
\text{E1} & \text{E2} & \text{XOR(E1,E2)}\\
\hline
1 & 1 & 0\\
\hline
1 & 0 & 1\\
\hline
0 & 1 & 1\\
\hline
0 & 0 & 0\\
\hline
\end{array}}\]

On peut combiner plusieurs portes logiques pour obtenir un circuit logique.

Exemple : additionneur 2 bits avec prise en compte de la retenue.

Les entrées sont les 2 bits (E1 et E2) la retenue Cin (pour Carry in).
Les sorties sont le bit de résultat S et la retenue Cout (pour Carry out).

Table de vérité de l'additionneur 2 bits :

\[\color{black}{\begin{array}{|c|c|c|c|c|}
\hline
\text{E1} & \text{E2} & \text{Cin} & \rm S &\text{Cout}\\
\hline
1 & 1 & 1 & 1 & 1\\
\hline
1 & 1 & 0 & 0 & 1\\
\hline
1 & 0 & 1 & 0 & 1\\
\hline
1 & 0 & 0 & 1 & 0\\
\hline
0 & 1 & 1 & 1 & 0\\
\hline
0 & 1 & 0 & 1 & 0\\
\hline
0 & 0 & 1 & 1 & 0\\
\hline
0 & 0 & 0 & 0 & 0\\
\hline
\end{array}}\]

On peut montrer (avec des maths !) que toutes les fonctions booléennes peuvent s'exprimer avec uniquement les portes logiques non() et ou().

Le microprocesseur est le "cœur" d'un ordinateur : les instructions sont exécutées au niveau du microprocesseur.

Il est constitué de 3 parties essentielles :

1. Les registres permettent de mémoriser de l'information (donnée ou instruction) au sein même du CPU. Leur nombre et leur taille sont variables en fonction du type de microprocesseur.
   Ces registres sont nommés R0, R1, R2, R3...
2. L'unité arithmétique et logique (UA) est chargée de l'exécution de tous les calculs que peut réaliser le microprocesseur.
3. L'unité de commande permet d'exécuter les programmes.

Les programmes sont exécutés à partir d'instructions machines qui sont codées en binaire.
Une instruction machine est composée de deux parties :

• Le champ code opération qui indique au processeur l'opération à effectuer (par exemple additionner, soustraire, multiplier).
•  Le champ "opérandes" qui indique les données à traiter.

Un programme exécuté par le microprocesseur est donc une suite de 0 et de 1 très longue. Le langage utilisé dans ce cas se nomme le langage machine.

Un langage de programmation de type assembleur est un langage qui permet d'écrire des instructions dans un langage très proche du langage machine (binaire). Il existe plusieurs langages assembleurs.

Voici un programme très simple écrit en Python :

$\color{blue}{\textit{x = 4}\\
\textit{y = 8}\\
\textit{if x == y:}\\
\quad \textit{y = y + 1}\\
\textit{else :}\\
\quad\textit{x = x+ 1}}$

Et voilà une traduction possible de ce programme Python en assembleur :

$\scriptstyle\color{blue}{\begin{array}{llll}
\text{    MOV R0,#4} & \text{: place le nombre 4 dans le registre R0}\\
\text{    MOV R1,#8} & \text{: place le nombre 8 dans le registre R1}\\
\text{    SUB R2,R1,R0} & \text{: soustrait le contenu du registre R1}\\
& \text{au contenu du registre R0 et place}\\
& \text{le résultat dans le registre R2}\\
\text{    CMP R2,#0} & \text{: compare le contenu du registre 2 avec 0}\\
\text{    BEQ egal} & \text{: si le résultat de la comparaison est bon,}\\
& \text{on fait un saut à l'étiquette nommée egal}\\
\text{    ADD R1,R1,#1} & \text{: ajoute 1 au contenu du registre 1}\\
& \text{et place le résultat dans R1}\\
\text{    HALT} & \text{: arrêt du programme}\\
\text{egal:} & \text{: étiquette egal}\\
\text{    ADD R0,R0#1} & \text{: ajoute 1 au contenu du registre 0}\\
& \text{et place le résultat dans R0}\\
\text{    HALT} & \text{: arrêt du programme}\end{array}}$

Il est possible d'utiliser un simulateur en ligne développé par Peter L Higginson.

Dans ce simulateur basé sur une architecture de von Neumann, on retrouve une RAM, et un processeur. On peut écrire des programmes en assembleur à l'aide de cet outil.

Ce simulateur est disponible ici : http://www.peterhigginson.co.uk/AQA/.

Les premiers programmes ont été écrits en assembleur.

Ensuite, des langages de plus haut niveau (comme Python, C, Java, ….) ont été mis au point afin de rendre la programmation plus aisée pour les développeurs.

Ces langages de plus haut niveau utilise une syntaxe (ou une grammaire) avec des mots souvent en anglais.

Des programmes appelés compilateur (ou interpréteur) se chargent de traduire un langage de plus haut niveau vers le langage binaire machine compris par le processeur.