Architecture des ordinateurs

Réalisation électronique d’une machine programmable manipulant des représentations numériques

Jérémy Fix

CentraleSupélec

2026-08-11

La couche logique : logique séquentielle

C’est tout ?

Problème : un bouton (0/1) - une lumière (0/1)

Allumons

Éteignons

⇒ mince ?!?!

Solution

Problème : un bouton (0/1) - une lumière (0/1)

Solution

Le nouvel état lumière dépend de l’entrée bouton et de l’ancien état lumière.

Ici, la sortie est caractéristique de l’état du système.

Plus généralement : logique séquentielle

On reboucle simplement la sortie sur l’entrée ?

Ce n’est pas forcément la sortie qui est utilisée en entrée puisque je peux très bien avoir besoin de produire la même sortie dans des états différents

Transducteur fini (automate fini avec sorties)

Verrou Reset-Set (RS)

Schéma et Chronogramme

\((S,\bar{R})\) fait transiter et rester à l’état \((Q, \bar{Q}) = (1,0)\)
\((\bar{S},R)\) fait transiter et rester à l’état \((Q, \bar{Q}) = (0,1)\)
\((\bar{S}, \bar{R})\) effet mémoire

En fait … c’est plus compliqué : Machine à états finis pour un circuit symétrique

Supprimer les états instables

Et si \(R.S = 0\) ?

Mémoriser un bit sur niveau haut : Verrou D

Schéma et chronogramme

On présente une donnée \(D\) écrite sur niveau haut \(Enable\).

Important

\(Set = D \cdot Enable\)
\(Reset = \overline{D} \cdot Enable\)
\(Q(t) = Enable \cdot D + \overline{Enable} \cdot Q(t-1)\)

Chronogramme du verrou D

Important

\(E=1 \Rightarrow Q = D\) : le verrou est transparent,
\(E=0 \Rightarrow\) le verrou est dans un état mémoire, sa sortie ne change pas même si \(D\) change

Mémoriser un bit sur un front : Bascule D

Bascule D : maître-esclave; Schéma et chronogramme

\(Q=D\) au front montant d’horloge

Registre à \(n\) bits

Mémoire Random Access Memory RAM

Lecture : on place Adr et Load=1 ⇒ \(D_o\) = RAM[Adr]
Écriture : on place Adr, \(D_i\) et Store=1 + front d’horloge ⇒ RAM[Adr] = \(D_{i}\)

Résumons

Logique combinatoire

Logique séquentielle

Notre premier chemin de données

Spécifications

données et adresses sur 16 bits; RAM : \(2^{16}\) mots de 16 bits = 128 ko
des registres génériques : A, B ; des registres particuliers PC et RADM
RAM pour stocker (pour le moment) les données
des signaux de contrôle : Read<A,B,PC,Mem>, Set<A,B,PC,RADM,Mem>, UAL
Architecture Register/Register (Load/Store) : opérations avec des opérandes en registres

Voir cette comparaison d’architectures ISA pour de vrais examples.

Les registres

A, B : registres d’opérandes pour effectuer des opérations (general purpose)
PC (Program counter, ou CO : compteur ordinal): index la position de la donnée en cours d’utilisation
RADM : Registre d’Adresse Mémoire : quel mot est adressé en mémoire (≠ PC)

Exemple de séquencement manuel

Problème

Additionner 16=0x0010 et 1=0x0001 et stocker le résultat à l’adresse 0x000A

Adresses de base	Contenu
0x0000	0010	0001	000A
0x0004	0000	0000	0000
0x0008	0000	0000	0000

Chargement immédiat dans A (1/3)

Chargement immédiat dans A (2/3)

Chargement immédiat dans A (3/3)

Chargement immédiat dans B (1/3)

Chargement immédiat dans B (2/3)

Chargement immédiat dans B (3/3)

Addition : A := A + B

Sauvegarde du contenu du registre A en mémoire (1/4)

Sauvegarde du contenu du registre A en mémoire (2/4)

Sauvegarde du contenu du registre A en mémoire (3/4)

Sauvegarde du contenu du registre A en mémoire (4/4)

Modes d’adressage

Adressage immédiat : le mot mémoire est la valeur à charger
Adressage direct : le mot mémoire est l’adresse en mémoire de la valeur à charger, e.g. incrémenter un compteur dont la valeur courante est stockée à une adresse donnée en mémoire
Adressage indirect : le mot mémoire est l’adresse à laquelle trouver l’adresse de la valeur à charger
Adressage relatif : le mot mémoire contient l’adresse et un décalage, e.g. accéder aux éléments d’un tableau A[i]

La couche ISA (Instruction Set Architecture) - CM4

La couche ISA

Approche par couches d’abstractions successives

En plus des données, définissons le programme

Architecture de von Neumann : mémoire (data+prog) ↔︎ processeur

Les instructions

Adresses	Contenu
0000	0010	0001	000A
0004	0000	0000	0000
0008	0000	0000	0000

Instructions en assembleur

Architecture de von Neumann : mémoire (data+prog) ↔︎ processeur

Les instructions

Adresses	Contenu
0000	LDAi	0010	LDBi	0001
0004	ADDA	STA	000A	0000
0008	0000	0000	0000	0000

Codage des instructions

Nom de l’instruction	Code de l’instruction
LDAi	0×1000
LDAd	0×1400
LDBi	0×2000
STA	0×1c00
ADDA	0×3000

Adresses	Contenu
0000	1000	0010	2000	0001
0004	3000	1c00	000A	0000
0008	0000	0000	0000	0000

⇒ Programme en langage machine

Récupérer l’instruction (fetch)

Une première possibilité avec un registre dédié

L’instruction est :

récupérée en mémoire
placée dans le registre d’instruction (RI)
qui est une entrée du séquenceur

Séquencement du chemin de données

Séquenceur

Séquence de signaux de contrôle spécifique :

pour récupérer l’instruction fetch
en fonction de l’instruction, pour la réaliser

⇒ machine à états finis qui génère les micro-instructions et dont l’état est stocké dans un registre dédidé microPC

Générer les signaux de contrôle : le séquenceur

Fetch

Chargement immédiat dans A : LDAi

Chargement immédiat dans B : LDBi

Chargement direct dans A : LDAd

Addition A:= A + B : ADDA

Sauvegarde de A en mémoire : STA

Machine à états finis pour le séquenceur

Réalisation matérielle ? Soyons astucieux sur le codage des états en codant les instructions à partir de l’adresse définie par les 8 bits de poids forts.

Séquenceur micro-programmé

Notre première architecture interne

En ajoutant le séquenceur

Les micro-instructions

ROM[0x00] : saut à fetch
ROM[0x08,0x09,0x0A,0x0B] : fetch/decode
ROM[0x10,0x11,0x12,0x13] : LDAi
ROM[0x14,0x15,0x16,0x17] : LDAd
ROM[0x1c,0x1d,0x1e,0x1f] : LDAd
ROM[0x20,0x21,0x22,0x23] : LDBi
ROM[0x30,0x31,0x32,0x33] : ADDA

Les branchements

\[fact(n) = \begin{cases} \text{si } n=0 \text{ alors}& 1\\ \text{sinon }& n \times fact(n-1) \end{cases}\]

si … alors … sinon ? Indicateurs de l’UAL

Instructions de branchement

JMP (0×7000) \[\texttt{JMP op} \Leftrightarrow PC := op\]
JZA (0×7400) \[\texttt{JZA op} \Leftrightarrow \begin{cases} PC := op & \text{si } A==0\\ PC := PC+1 & \text{sinon} \end{cases}\]
JZB (0×7800) \[\texttt{JZB op} \Leftrightarrow \begin{cases} PC := op & \text{si } B==0\\ PC := PC+1 & \text{sinon} \end{cases}\]

Architecture avec branchement

Table de vérité du branchement

CodeMCount	Z	\(S_1S_0\)	Sémantique
000	0 ou 1	00	MicroPC := MicroPC+1
001	0 ou 1	01	MicroPC := @Adr
010	0 ou 1	10	MicroPC := Instruction
011	0	00	MicroPC := MicroPC+1 si la sortie de l’UAL ≠ 0
011	1	01	MicroPC := @Adr si la sortie de l’UAL == 0

Petite synthèse

Petit retour sur l’architecture v0

Architecture à Jeu d’instructions (ISA)

Code	Nom	Mots	Description
0x0c00	END	1	Fin du programme
0x1000	LDAi	2	Charge la valeur de l’opérande dans le registre A. [A:=opérande]
0x1400	LDAd	2	Charge la valeur dans la RAM pointée par l’opérande dans le registre A. [A:=Mem[opérande]].
0x1c00	STA	2	Sauvegarde en mémoire la valeur du registre A à l’adresse donnée par l’opérande. [Mem[opérande]:= A]
0x2000	LDBi	2	Charge la valeur de l’opérande dans le registre B. [B:=opérande]
0x2400	LDBd	2	Charge la valeur dans la RAM pointée par l’opérande dans le registre B. [B:=Mem[opérande]].
0x2c00	STB	2	Sauvegarde en mémoire la valeur du registre B à l’adresse donnée par l’opérande. [Mem[opérande]:= B]
0x3000	ADDA	1	Ajoute le contenu des registres A et B et mémorise le résultat dans le registre A. [A:=A+B]
0x3400	ADDB	1	Ajoute le contenu des registres A et B et mémorise le résultat dans le registre B. [B:=A+B]
0x3800	SUBA	1	Soustrait le contenu des registres A et B et mémorise le résultat dans le registre A. [A:=A-B]
0x3c00	SUBB	1	Soustrait le contenu des registres A et B et mémorise le résultat dans le registre B. [B:=A-B]
0x4000	MULA	1	Multiplie le contenu des registres A et B et mémorise le résultat dans le registre A. [A:=AxB]
0x4400	MULB	1	Multiplie le contenu des registres A et B et mémorise le résultat dans le registre B. [B:=AxB]
0x4800	DIVA	1	Divise le contenu du registre A par deux et mémorise le résultat dans A. [A:=A/2]
0x5000	ANDA	1	Calcule un ET logique entre le contenu des registres A et B et mémorise le résultat dans A. [A:=A&B]
0x5400	ANDB	1	Calcule un ET logique entre le contenu des registres A et B et mémorise le résultat dans B. [B:=A&B]
0x5800	ORA	1	Calcule un OU logique entre le contenu des registres A et B et mémorise le résultat dans A. [A:=A\|B]
0x5c00	ORB	1	Calcule un OU logique entre le contenu des registres A et B et mémorise le résultat dans B. [B:=A\|B]
0x6000	NOTA	1	Mémorise dans A la négation de A. [A:=!A]
0x6400	NOTB	1	Mémorise dans B la négation de B. [B:=!B]
0x7000	JMP	2	Saute inconditionnellement à l’adresse donnée par l’opérande. [PC:=operande]
0x7400	JZA	2	Saute à l’adresse donnée par l’opérande si le contenu du registre A est nul. [PC:=operande si A=0]
0x7800	JZB	2	Saute à l’adresse donnée par l’opérande si le contenu du registre B est nul. [PC := operande si B=0]

Automate à états finis du séquenceur

Séquenceur et programme

Séquenceur

Sémantique des instructions
Générique
Automate à états finis : état dans MicroPC, signaux de contrôle ROM[MicroPC]

Programme

Qu’est ce que je veux calculer ?
Spécifique
Séquence de codes d’instructions et de données en RAM

Aperçu de quelques architectures

La notre

2 registres banalisés : A et B
2 registres internes : RADM et PC
adresses sur 16 bits, données sur 16 bits
Format des instructions : \(1\) mot de \(16\) bit pour l’instruction, \(1\) mot pour l’opérande éventuelle
jeu d’instructions : LDAi, LDBi, ADDA, ANDB, JMP, JZA
horloge maximale sous logisim : 4 kHz

Beaucoup d’architectures :
https://en.wikipedia.org/wiki/List_of_instruction_sets

Intel x86 IA32-64

Du Intel 8086(1978) jusqu’au Intel Core i7 (2015)

Note

4 registres banalisés 32 bits EAX, EBX, ECX, EDX,
4 registres d’index : ESI, EDI, EBP (Base pointer), ESP (Stack pointer)
6 registres de segments 16 bits : CS, DS, SS,ES, FS, GS
1 registre de status 32 bits : EFLAGS
x registres internes : EIP (Instruction Pointer == PC) (32 bits)

Intel 64 and IA-32 Architectures Software Developer Manuals
https://software.intel.com/en-us/articles/intel-sdm

Intel x86 IA32-64

Intel x86 IA32-64

Le registre de statut EFLAGS

Carry Flag (CF), Sign Flag (SF), Zero Flag (ZF),

Intel x86 IA32-64

Beaucoup d’instructions : 1.300 mnémoniques, plusieurs modes d’adressages, ..

Note

Opérations arithmétiques : ADD(0x01, 0x02, 0x03), AND(0x21,0x22, ..)..
Branchements (in)conditionnels: JMP (0xFF), JZ, JNZ, JG, conditions à partir des bits de statut
Lecture/Ecriture : MOV(0x8B, 0xC7, …)

Documentation des instructions https://cdrdv2.intel.com/v1/dl/getContent/671110.

ARM (téléphones, tablettes, consoles)

Acorn RISC Machine architecture (1980) jusqu’au ARMv8.3-A (2016)

Note

16 registres \(R_i\) 32 bits dont :
- \(R_0-R_3\) : arguments/résultats pour une routine
- \(R_4-R_8\) : variables temporaires
- \(R_9\) : Plateform register
- \(R_{10}\) : Stack limit pointer
- \(R_{11}\) : Frame pointer
- \(R_{12}\) : registre temporaire
- \(R_{13}\) : Stack Pointer
- \(R_{14}\) : Link register (adresse de retour)
- \(R_{15}\) : Programm Counter
1 registre de statut CPSR 32 bits

http://infocenter.arm.com/help/index.jsp

Voir l’intervention de ST Micro.

ARM (téléphones, tablettes, consoles)

Note

Le registre CPSR

ARM - Jeu d’instructions

Note

Data Processing avec opcode: AND(0000), ADD(0100), SUB(0010)

Branchements : BX, BL, ..

et bien d’autres…

http://infocenter.arm.com/help/index.jsp