Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Systèmes informatiques

Entrées et sorties : scrutation, interruptions, DMA et bus

Registres mappés en mémoire avec un exemple en C, scrutation (polling), interruptions et routines de service, latence et coût, DMA, bus I²C, SPI, UART, CAN, USB et PCI Express.

https://www.electronics-engineering.com/fr/entrees-sorties-scrutation-interruptions-dma-bus/

Pas encore de vote : soyez le premier à noter cette page.

Un processeur qui ne communique pas avec le monde extérieur est inutile : il doit lire des capteurs, des claviers et des réseaux, et piloter des moteurs, des écrans et des disques. Les périphériques d’entrée et de sortie sont lents et imprévisibles comparés à l’unité centrale, et le problème est d’échanger des données avec eux sans perdre de temps. Dans cette leçon, nous voyons comment le processeur voit les périphériques, les trois techniques de transfert (scrutation, interruptions, DMA) et les bus les plus courants.

Dialoguer avec un périphérique

Chaque périphérique a des registres : de données (l’octet reçu, celui à émettre), d’état (prêt, occupé, erreur), de commande (vitesse, mode). Dans les systèmes modernes, ils sont mappés en mémoire : ils occupent des adresses réservées, et se lisent et s’écrivent avec les instructions ordinaires de chargement et de rangement. En C, on y accède par un pointeur volatile, qui empêche le compilateur de supprimer ou de réordonner les accès :

#define UART_STATUS (*(volatile uint32_t *)0x40011000)
#define UART_DATA   (*(volatile uint32_t *)0x40011004)
#define TX_EMPTY    (1u << 7)

void send(char c) {
    while (!(UART_STATUS & TX_EMPTY)) { }   /* wait until the transmitter is free */
    UART_DATA = c;
}

C’est la scrutation (polling) : l’unité centrale vérifie continuellement le registre d’état.

Scrutation

Elle est simple et a une latence minimale, mais elle gaspille l’unité centrale : pendant qu’elle attend, elle ne fait rien d’autre. C’est acceptable quand l’attente est très courte ou que l’unité centrale n’a rien d’autre à faire ; c’est inacceptable pour des événements rares et imprévisibles comme l’appui sur une touche, ou quand il faut gérer de nombreux périphériques.

Interruptions

Avec les interruptions, c’est le périphérique qui alerte l’unité centrale, en activant une ligne de requête (IRQ). À la fin de l’instruction en cours, le processeur :

  1. sauvegarde le PC et l’état ;
  2. saute à la routine de service de l’interruption (ISR) associée à cette interruption, dont l’adresse se trouve dans une table de vecteurs ;
  3. exécute la routine, qui lit ou écrit les registres du périphérique ;
  4. restaure l’état et reprend le programme exactement là où il s’était arrêté.
Traitement d'une interruption dans le temps
Le programme principal s’exécute quand la requête d’interruption arrive. Après un court temps de sauvegarde de l’état (la latence), le processeur exécute la routine de service ; à la fin, il restaure l’état et reprend le programme au point où il avait été interrompu.

Les interruptions ont des priorités : une interruption plus importante peut interrompre la routine d’une moins importante. Le temps entre la requête et le début de la routine est la latence ; dans les systèmes temps réel (commande de moteurs, airbags), elle doit être garantie, et dans les microcontrôleurs elle se mesure en dizaines ou centaines de nanosecondes.

Règles pour les routines de service. Elles doivent être courtes : elles font le strict minimum (lire la donnée, signaler l’événement) et laissent le reste au programme principal, car pendant qu’elles s’exécutent, les interruptions de priorité égale ou inférieure attendent. Les variables partagées entre la routine et le programme doivent être déclarées volatile et accédées avec soin, car la routine peut arriver à tout moment, même au milieu d’une opération.

Le coût. Chaque interruption coûte la sauvegarde et la restauration de l’état, quelques centaines de nanosecondes, ou quelques microsecondes avec un système d’exploitation. Une carte réseau à 10 Gbit/s reçoit plus d’un million de paquets par seconde : à 2 µs par interruption, il faudrait 2 secondes d’unité centrale chaque seconde, ce qui est impossible. On regroupe donc les interruptions (une tous les nombreux paquets) et on utilise le DMA.

DMA

Avec l’accès direct à la mémoire (DMA), un contrôleur dédié transfère des blocs de données entre le périphérique et la mémoire sans l’unité centrale. Le processeur programme le transfert (adresse de départ, quantité, direction) et continue d’autres tâches ; le contrôleur DMA utilise le bus tout seul et, à la fin, déclenche une seule interruption. C’est ainsi que sont lus les disques, les cartes réseau, les convertisseurs analogique-numérique rapides et l’audio.

Il y a un détail délicat : le DMA écrit en mémoire, mais l’unité centrale peut garder dans son cache une ancienne copie de ces données. Les architectures résolvent cela par une cohérence de cache vis-à-vis des périphériques, ou bien le logiciel doit vider ou invalider le cache avant et après le transfert.

Bus

BusUsage typiqueCaractéristiques
I²Ccapteurs, petites mémoires2 fils, jusqu’à quelques Mbit/s, de nombreux périphériques adressés
SPIécrans, convertisseurs, mémoires flash4 fils, des dizaines de Mbit/s, simple et rapide
UARTconsole, modules radio, GPS2 fils, asynchrone, jusqu’à quelques Mbit/s
CANautomobile, industrie2 fils différentiels, robuste au bruit, priorités des messages
USBpériphériques d’ordinateurde 12 Mbit/s à des dizaines de Gbit/s, alimentation comprise
PCI Expresscartes graphiques, SSD, réseauliaisons série point à point, jusqu’à des dizaines de Go/s avec plusieurs voies

La tendance est claire : les bus parallèles à nombreux fils ont été remplacés presque partout par des liaisons série rapides, car à haute fréquence il est impossible de garder des dizaines de signaux alignés entre eux (leçon de Champs électromagnétiques sur les lignes de transmission).

S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x