Architecture des ordinateurs

Mémoires, périphériques et interruptions

Jérémy Fix

CentraleSupélec

2026-10-07

Au menu

Cours

• les mémoires et la mémoire cache
• les périphériques : quoi ? canal d’échange, protocole d’échange, prise en compte par interruption

TP

• TP : Interruptions : écoute passive des périphériques
• TP : ordonnanceur : exécuter plusieurs programmes en parallèle avec un chemin de données
• TP Bonus : place au jeu !

Mémoires

Caractéristique des mémoires

Caractéristiques

• Mode d’accès : aléatoire (RAM), séquentiel (disque dur), associatif (cache)
• Capacité d’écriture : ROM (en lecture seule), \(\overline{\mathtt{ROM}}\) (en lecture et écriture)
• volatilité : maintien des informations en l’absence de courant ? (ROM : forcément non volatile, RAM : ça dépend; SDRAM : volatile ; NVRAM : non volatile ou RAM + pile : CMOS)

Les mémoires mortes : non volatiles, en lecture seule (\(\approx\))

• ROM : Read Only Memory (programmée à la fabrication)
• PROM : Programmable Read Only Memory (fusibles; programmable une fois)
• EPROM : Erasable Programmable Read Only Memory (Ultraviolet)
• EEPROM : Electrically Programmable Read Only Memory (e.g. pour contenir le BIOS : Basic Input Output System; les paramètres sont mémorisés avec une RAM volatile + batterie)

Les mémoires vives: accès aléatoire, volatiles, en lecture/écriture

• Registres : bascules D maître/esclave
• Static RAM (SRAM)
• Dynamic RAM (DRAM)

Les mémoires en lecture/écriture : non-Volatiles

• accès séquentiel : Disques durs magnétiques
• accès aléatoire : disques durs SSD et mémoire flash (NAND/NOR), nvSRAM (non volatile SRAM), ..

Les mémoires vives

Registres

Memory register

Transistors pour \(n\) bits \(\approx 30 n\) Capacité \(\approx\) 32-64 bits
Temps d’accès \(\approx\) 1 ps (\(10^{-12}s\))
Volatile

Les mémoires vives

Static Random Access Memory (SRAM)

SRAM inner

Capacité : 10 Ko - 10 Mo
Temps d’accès \(\approx\) 1ns
Volatile Usage: Caches L1-L2-L3

Les mémoires vives

Dynamic random access memory (DRAM)

DRAM inner

Capacité : 10 Go
Temps d’accès : 80 ns (réécriture toutes les ms)
Volatile Usage : “Les barrettes de RAM”

Les mémoires de masse

Disque dur magnétique

DD

Capacité : 1 To (plusieurs pistes découpées en secteurs de \(512\) octets) Temps d’accès : 10 ms (révolution à \(7400\) tr/min) Non volatile

Synthèse des mémoires vives et de masse

Compromis ?

Type	Capacité	Latence	Coût (au Gi-octet)
Registre	100 bits	20 ps	très cher
SRAM	10 Ko - 10 Mo	1-10 ns	≈ 1000 €
DRAM	10 Go	80 ns	≈ 10 €
Flash	100 Go	100 μs	≈ 1 €
Disque dur Magnétique	1 To	10 ms	≈ 0.1 €

Une mémoire rapide et de grosse capacité ??

Mémoire cache

La clé : le principe de localité

Les principes de localité

Localité

• localité spatiale : les accès futures en RAM se feront à des addresses proches des accès courants
• localité temporelle : une donnée accédée récemment sera certainement réutilisée prochainement

Idée: combiner une petite mémoire rapide avec une grosse mémoire lente

• Localité temporelle : on charge en mémoire rapide une donnée à laquelle on accède
  
• Localité spatiale : on charge aussi les voisines

Problème de doublons ? Politique de remplacement ? Dépends de la réalisation…

Comment exploiter les principes de localité ?

Solution 1) A la charge du programmeur

→ Pas très pratique…

Solution 2) Hierarchie de mémoires

Cache mem

Performances du cache

• Cache hit : la donnée est dans le cache ⇒ accès rapide ; Hit ratio : \(\frac{hits}{hits+misses}\)
  
• Cache miss : la donnée n’est pas dans le cache ⇒ accès lent ; Miss Ratio : \(\frac{misses}{hits+misses}\)

Temps moyen d’accès mémoire \(T_m \approx HR. t_{cache} + MR. t_{mem}\)
Pour \(HR = 90\%\) : \(T_m = 17 ns\).

Réalisation matérielle: principe de fonctionnement d’un cache

Principe

A partir d’une petite information (clé), on retrouve le reste (valeur).

Analogie : annuaire téléphone

En pratique

L’adresse demandée est divisée en plusieurs parties dont une sert de clé.

Tableau associatif : Cache[clé] = {adr, valeur, ..}

• Si la donnée est présente en cache : valide et accès rapide
  
• Sinon il faut récupérer la donnée et la placer dans le cache.

Réalisations matérielles d’un cache

Mémoire à \(2^{16}\) mots, Cache à \(2^{4}\) mots.

1 mot mémoire ne peut aller que dans une ligne de cache.

1 ligne de cache peut possiblement recevoir \(n\) mots mémoires.

Cache à correspondance directe

Direct cache

RAM[Adr] → Cache[Adr₃Adr₂Adr₁Adr₀]
pourquoi les bits de poids faibles comme index ? 2 adresses proches ne doivent pas viser la même ligne de cache

Réalisations matérielles d’un cache

Cache à correspondance directe par bloc

Direct cache block

Un bloc : \(2^{|offset|}\) mots; L’offset sert de bits de sélection d’un multiplexeur par ligne.

On charge directement un bloc de mots consécutifs.

Réalisations matérielles d’un cache

Prenons le contre-pieds : Une donnée peut occuper n’importe quelle ligne de cache.

Cache associatif

Associatif cache

Lourd matériellement. Politique de remplaçement ? e.g. Least Recently Used

Réalisations matérielles d’un cache

Compromis entre le cache direct et le cache associatif : le cache associatif à \(n\) voies

Cache associatif à n entrées

Nway cache

Indexable comme les caches directs, cache[index] étant associatif

Cohérence cache/mémoire centrale

Problème

Une donnée d’une même adresse peut être à la fois en cache, mémoire centrale, voir même sur le disque (e.g. swap)

Politiques d’écriture

• Write through : propagation immédiate d’une modification vers la mémoire principale
• Write back : écriture différée; écriture au remplacement (dirty bit)

Périphériques

Les périphériques d’entrée/sortie

Les périphériques d’entrée/sortie

Périphérique

http://www.wikipedia.org

Structure d’un périphérique

Au périphérique est associé un contrôleur (e.g. contrôleur disque) qui possède :

• des registres
• des machines à état
• …

Le périphérique est couplé aux bus d’adresses, données, contrôle.

Exemple d’un contrôleur clavier (e.g. Intel 8042)

Contrôleur clavier minimaliste sur notre architecture :

Bus : Interconnexion des périphériques et du chemin de données

Chemin périphérique

Interconnexion des périphériques et du chemin de données

Buses

Les bus

Bus	Largeur (bits)	Clk (MHz)	Débit (Mo/s)	Année
ISA 16	16	8.33	15.9	1984
PCI 32	32	33	125	1993
AGP	32	66	250	1997
PCI-E 3 (x16)	16	8000	16000	2011

Bus parallèles (échange de mots, large mais court) / Bus série (bit à bit, e.g. USB)

Comment contacter les entrées/sorties ?

Il faut pouvoir contacter les registres du contrôleur du périphérique.

E/S mappées en mémoire

• comme pour un accès mémoire LDA, STA
• avec des adresses réservées, ciblant les périphériques

IO mapped

Autre solution : pas de bus d’adresse; placer dans le message un identifiant du destinataire.

Comment discuter sur le bus avec un interlocuteur ?

Protocoles d’échange : e.g. lecture mémoire

Echange synchrone

True sync comm

Les données doivent être disponibles au prochain front montant d’horloge.

\(\Rightarrow\) Fréquence d’horloge : ajustée au périphérique le plus lent

Protocoles d’échange : e.g. lecture mémoire

Echange “semi” synchrone

Semi synchronous communication

Un signal permet d’indiquer la présence de la donnée \(\Rightarrow\) le processeur peut vaquer à d’autres occupations.

Protocoles d’échange : e.g. lecture mémoire

Echange asynchrone : Master/Slave

Async comm

Pas d’horloge mais des signaux d’état : handshaking
Plus réactif mais plus compliqué à mettre en oeuvre.

Et si on est plusieurs à vouloir parler ?

On sait :

• comment interconnecter un périphérique avec le chemin de données : bus
• comment réaliser un transfert synchrone/asynchrone

mais on a :

• “un” bus
• plusieurs acteurs : mémoires, périphériques, CPU, …

Nécessité d’arbitrer, e.g. le premier dans un certain ordre.

Et comment la demande d’échange avec le périphérique est prise en charge ?

Gestion des périphériques par interruption

Evènements synchrones

Déroutements (trap, exception): événements synchrones avec l’exécution d’un programme, liés à une erreur : division par zéro, overflow, accès invalide à la mémoire : e.g. stack overflow

Ex : Overflow

Comment prendre en charge des débordements lors d’opérations arithmétiques ?

1. le programme teste, après “chaque” opération, le bit overflow (Status register)
   • programme plus long en mémoire et à l’exécution et plus compliqué à écrire
2. dérouter le fil d’exécution si un débordement a lieu (à la JZA); pas de surcoût !

Au regard d’un programme, on peut prévoir quand un déroutement peut avoir lieu.

Interruptions : Evènements asynchrones

Evènements asynchrones; e.g. appui sur un bouton, une touche de clavier, bourrage papier, lecture mémoire terminée, …

Prise en charge par scrutation

On interroge régulièrement le périphérique

• programmation explicite
• surcoût à l’exécution

Prise en charge par interruption

Ecoute passive du périphérique : exécute un programme particulier que lorsque le périphérique lève une demande d’interruption

→ sollicite moins le processeur (e.g. lecture sur disque : données prêtes)

Modification du chemin de données

On ajoute :

• une ligne de requête d’interruption (INTR - INTerrupt Request) qu’un périphérique peut mettre à l’état haut.
• Registre IF - Interrupt Flag - pour y être sensible ou non.
• des signaux de contrôle SetIF/ClearIF et INTA - INTerrupt Acknowledge

Ajout du signal d’interruption + registre associé

Ecoute passive des demandes d’interruption

Avant le fetch/decode, en \(0x00\), on teste si une demande d’interruption est levée :

• si oui, on part en interruption
• sinon, on entre dans la phase de fetch/decode (saut du \(\mu\)-PC en 0x08) et exécution de l’instruction, comme d’habitude

CodeMCount	Z	INTR & IF	\(S_1S_0\)	Sémantique
000	-	-	00	MicroPC := MicroPC+1
001	-	-	01	MicroPC := @Adr
010	-	-	10	MicroPC := Instruction
011	0	-	00	MicroPC := MicroPC+1 si \(S≠0\)
011	1	-	01	MicroPC := @Adr si \(S=0\)
100	-	0	01	MicroPC := @Adr si \(\overline{INTR \& IF}\)
100	-	1	00	MicroPC := MicroPC+1 si \(INTR \& IF\)

Prise en charge de la demande d’interruption

Principe

L’interruption doit être gérée de manière transparente pour le programme interrompu
⇒ sauvegarde du contexte d’exécution (sur la pile)

Nouvelles instructions

• INT (0xE000) : partir en interruption :
  1. sauvegarde du contexte d’exécution sur la pile
  2. chargement de l’adresse du programme d’interruption depuis le vecteur d’interruptions
• RTI (0xE800): revenir d’une interruption :
  1. restauration du contexte d’exécution du programme interrompu
• STI (0xD400) : démasque les interruptions : IF := 1
• CLI (0xD000) : Masque les interruptions : IF := 0

Vecteur d’interruptions

Comment savoir quel programme exécuter en cas d’interruptions

Vecteur d’interruption : programme à exécuter en cas d’interruption

On stocke une table des vecteurs d’interruption en mémoire. L’adresse \(0x02\) est placée sur le bus pour adresser la bonne routine lorsque INTA est signalé.

      JMP init
      JMP introutine
init: ... ; le programme principal
      ...

introutine: ... ; la routine d'interruption
            ...
            RTI ; le retour d'interruption

Chez nous : une seule interruption

Pour le moment, avec une seule interruption, l’adresse de la routine d’interruption est codée en dur, dans le registre INTAdr

INTAdr

Résumons

1. le périphérique lève une requête d’interruption INTR=1,
2. le processeur détecte la requête lors du prochain fetch/decode et \(\mu\)-PC se déroute si besoin,
3. le processeur sauvegarde l’état courant
4. le processuer se branche sur la routine d’interruption (vecteur d’interruption ou interrupt handler) en accusant réception INTA,
5. le processeur exécute la routine d’interruption,
6. le processeur restaure l’état au RTI.

Attention

La gestion de l’interruption implique la pile !! Phase d’initialisation (JMP init) minimale :

# par défaut IF = 0
LDSPI ...
STI

Exemple jouet : En TP

Un bouton comme premier périphérique, qui n’a pas besoin d’accéder aux bus D/Addr

Plusieurs interruptions ?

On s’est limité pour le moment à un seul périphérique.

Prise en charge de plusieurs interruptions

1. Plusieurs lignes d’interruptions
2. Centralisation et arbitrage des demandes d’interruptions; Le vecteur d’interruption est récupéré sur le bus de données

Avec un Programmable Interrupt Controller - PIC - 8259A

Petits pas vers le système d’exploitation

Ordonnanceur

Problème

Comment exécuter plusieurs programmes “en même temps” :

1. avec plusieurs chemins de données (architectures multi-coeurs)
2. avec un seul chemin de données partagé par deux programmes avec un basculement de contexte régulier, rythmé par l’interruption d’un timer..

Initialisation

Les piles des \(2\) fils d’exécution

Basculement de contexte

Dynamique des piles lors du changement de contexte

Rétrospective et conclusion

Cours 1-2 : Codage en binaire, Transistors, logique combinatoire

Codage/décodage

Couche physique / logique

Cours 3-4 : Logique séquentielle, premier chemin de données

Cours 5-6 : pile et programmation

Pile et procédures

Respo pile

Programmation

⇒ Ouverture vers la programmation (C++, etc..)

Cours 7 : mémoires caches, périphériques, interruptions

Hierarchie de mémoire

Interruptions