UNITES DE CONTRÔLE – A. DIPANDA
Un système complexe est un système ayant un nombre d’états relativement important.
Un système complexe possède deux parties synchronisées sur une même horloge:
- une unité de traitement - une unité de contrôle
L’analyse d’un système complexe se décompose toujours en deux parties:
l'analyse et la réalisation.
Elle dispose de circuits réalisant des opérations arithmétiques et logiques. Cependant, les opérations ne sont pas activées par l’UAL, mais par l’unité de contrôle.
En entrée de l’UAL, on a des commandes permettant d’activer les opérations, venant de l’unité de contrôle
En sortie, on a les résultats des opérations et
les conditions qui sont en fait les entrées de
l’unité de contrôle.
L’unité de traitement est composée de trois parties :
¾ les registres (mémorisation des données)
¾ l’UAL : (ensemble des opérateurs arithmétiques et logiques)
¾ les chemins de données ; ce sont des liaisons entre les registres et les opérateurs ; ces liaisons peuvent être des connexions simples ou alors peuvent admettre plusieurs entrées sur la même ligne : on parle alors de BUS.
Ces différentes sources seront validées par des
adaptateurs trois états.
L’unité de contrôle réalise le séquencement (prédéfini dans un programme) des opérations.
L’unité de contrôle ne fait aucun traitement ; elle envoie des commandes à l’unité de traitement qui va exécuter les traitements.
Il est tout à fait possible qu’il existe en plus des
liaisons avec l’extérieur.
COMMANDES CONDITIONS
UNITE DE TRAITEMENT
UNITE DE CONTRÖLE E1
E2
S1
S2
1) Ecrire un algorithme (analyse)
Il décrit les fonctionnalités du programme.
Il utilise :
des variables
des opérateurs
des structures de contrôle (qui réaliseront le
séquencement)
2) Choisir l’unité de traitement (réalisation)
L’unité de traitement devra fournir:
les registres servant à la mémorisation des données définies dans l’algorithme.
l’unité arithmétique et logique : un opérateur pour chaque opération qui sera effectuée.
le chemin des données pour faire transiter les données entre les différents éléments de l'UT.
Il est possible de spécialiser l’unité de traitement
pour le rendre plus performant.
3) Définir les commandes et les conditions
Les commandes permettent le déclenchement des opérations ou actions de l’unité de traitement qui vont se dérouler dans un même cycle .
Les conditions permettent la gestion des
structures de contrôle (et donc la réalisation du
séquencement).
4) Etablir le diagramme des états
Il est obtenu à partir de l’algorithme et de l’UT.
un état correspond à un ensemble d’instructions réalisées dans le même cycle.
Une instruction est un ensemble de
commandes.
Exemple:
Réalisation d’une affectation du type:
R3 : = R1 + R2
Les différentes commandes à effectuer sont:
1. chargement du registre R1
2. chargement du registre R2
3. opération “+”
4. chargement du registre R3 (avec le résultat)
Il doit fournir:
• 3 registres (R1, R2, R3 pour le stockage des valeurs)
• Un additionneur
• les chemins des données allant:
1) vers R1 et R2
2) de R1 et R2 vers l’additionneur 3) de l’additionneur vers R3
R1 R2
R3
Arrivée des données Arrivée des données
Arrivée des données ADD
Différents cas:
1. Les lignes d'arrivée de données vers R1, R2 et R3 sont distinctes:
Les chargements de tous les registres peuvent être effectués dans le même top d'horloge ⇒ 1 état
2. Les lignes d'arrivée des données ne sont pas distinctes:
1. Une seule ligne pour les 3 registres:
Les chargements sont effectués séquentiellement en 3 tops d'horloge: (R1, R2 et R3) ou (R2, R1 et R3) ⇒ 3 états
2. Une seule ligne pour R1 et R2 et une autre ligne pour R3
Les chargements sont effectués en 2 tops ⇒ 2 états:
Top1: chargement de R1 (ou R2)
Top2: chargement de R2 (ou R1) et de R3
Remarque:
On suppose que les temps de latence de l'addition et de pré-positionnement des bascules (registres) sont nuls.
R1 R2
R3
Arrivée des données
Arrivée des données ADD
CHR1 CHR2
CHR3
Exemple complet:
Réalisation d’une machine qui calcule et affiche la somme de n nombres saisis par un utilisateur
Début Faire
Lire(n) // n est le nombre de valeurs à lire
S:=0 // permet de gagner un top
Jusqu’à n>0 Faire
Lire(v) S:=S+v n:=n-1 Jusqu’à n=0 Ecrire(S) Fin
1. Algorithme
1b. Algorithme
Faire
Ack:=1
Jusqu’à REQ=0 Faire
Ack:=0 ; RY:=E //RY contient la valeur saisie
Jusqu’à REQ=1
RS:=RS+RY //RS contient la somme
RX:=RX-RU Jusqu’à RX<0
Faire
Ack:=1 ; S:=RS //affichage du résultat
Jusqu’à REQ=0 Fin
2
3 4 5
6 Début
Faire Faire
Ack:=0 ; RX:=E //RX contient n
RS:=0 ; RU:=1 // initialisations
Jusqu’à REQ=1 // validation de la saisie de n
RX←RX - RU Jusqu’à RX≥0
// RU est utilisé pour la comparaison (n>0)
// on fait une soustraction avec 1 et on regarde si on a un // débordement. L’autre solution serait d’utiliser un
// comparateur qui permettrait de comparer n à 0
0 1
Les registres : RX, RS, RU, RY
Les opérations :
+ (addition)
- (soustraction)
= (comparaison) Remarques:
L’addition et la soustraction se feront par l’intermédiaire d’un additonneur/soustracteur.
La comparaison se fait à l’aide de l’additionneur/soustracteur par le biais du débordement
3. Chemin des données :
de l’entrée vers les registres
RX
RY
des registres vers l’UAL
RS
RY
RU
RX
de l’UAL vers les registres
RS
RX
Schéma du circuit
ASC BUSC
RS RX RY RU
ADD/SOUS
RS0 CHRS CHRX CHRY RU1
RSA RXA RYB RUB
EC
BUSA BUSB
A S 0 1
Les commandes :
ACK0 : Ack :=0 ACK1 : Ack :=1
EC : envoi de E sur le bus C
ASC : envoi du résultat sur le bus C
CHRi : chargement des différents registres RU1 : mise à 1 de RU
RS0 : mise à 0 de RS
RSA : envoi du contenu de RS vers le bus A RXA : envoi du contenu de RX vers le bus A RYB : envoi du contenu de RY vers le bus B RUB :envoi du contenu de RU vers le bus B A : active l’addition
S : active la soustraction
Les conditions
REQ=0 ou1: à gérer par l’utilisateur DEB : débordement
EQZ : résultat égal à 0
Diagramme des états
2 3 4 5 6
0 1 DEB EQZ+
REQ
REQ
REQ
REQ REQ DEB
REQ
REQ REQ
DEB
DEB
Remarques :
Lorsque l’on fait l’affectation RU:=1, on utilise un registre pour mémoriser une constante.
Les commandes “REQ” (gérée par l'utilisateur) et
“ACK” (gérée par le système) sont utilisées pour l’entrée et la sortie des valeurs (hand-shake).
L’acquittement final équivaut à la sortie de la somme finale.
1b. Algorithme
Répéter Ack:=1
Jusqu’à REQ=0 Répéter
Ack:=0 ; RY:=E //RY contient la valeur saisie
Jusqu’à REQ=1
RS:=RS+RY //RS contient la somme
RX:=RX-RU Jusqu’à RX<0
Répéter
Ack:=1 ; S:=RS //affichage du résultat
Jusqu’à REQ=0 Fin
2
3 4 5
6 Début
Répéter Répéter
Ack:=0 ; RX:=E //RX contient n
RS:=0 ; RU:=1 // initialisations
Jusqu’à REQ=1 // validation de la saisie de n
RX←RX - RU Jusqu’à RX≥0
// RU est utilisé pour la comparaison (n>0)
// on fait une soustraction avec 1 et on regarde si on a un // débordement. L’autre solution serait d’utiliser un
// comparateur qui permettrait de comparer n à 0
0 1
Organigramme
ACK←0 ; RX←E ; RS←0 ; RU←1
RX←RX-RU
ACK←1
ACK←0 ; RY←E
RS←RS+RY RX←RX-RU
ACK←1 ; S←RS
0
5 4 3 2
1
6
REQ=1
RX≥0
REQ=0
REQ=0 REQ=1
RX<0 oui
non
oui non
non
non
non
non oui
oui
oui
Tableau des commandes par état
Etat 0 Etat 1 Etat 2 Etat 3 Etat 4 Etat 5 Etat 6
ACK0 EC CHRX
RS0 RU1
RXA RUB
S ASC CHRX
ACK1 ACK0
EC CHRY
RSA RYB A ASC CHRS
RXA RUB
S ASC CHRX
ACK1
les états sont numérotés de 0 jusqu’à n et on passe souvent d’un état au suivant par une incrémentation
⇔
compteur ordinal
La fonction de sortie : génération de commandes envoyées à l’UAL ; la fonction de sortie est calculée en fonction du compteur ordinal.
La fonction de transition : permet de changer d’état et donc effectue le séquencement ; ce séquencement
dépend du compteur ordinal et des conditions en entrée de l’unité de contrôle.
Fonction de sortie
Fonction de transfert (séquencement)
Commandes vers l’UAL
Conditions venant de l’UAL Compteur ordinal
1. Unités de contrôle à bascules:
On peut utiliser toutes les techniques de réalisation de systèmes séquentiels.
Exemple: La machine à jetons
A chaque état, on attribue une bascule ; on a 7 états donc on utilisera 7 bascules.
Q0 Q1 Q5 Q6
DEB
INIT
REQ
2. Unité de contrôle à compteur chargeable
En général, on a un comportement de compteur (on passe logiquement de 1 vers 2, puis de 2 vers 3 etc.) mais, il arrive que cette règle de compteur ne soit pas respectée, on dit qu’il y a des sauts
(Exemple: transition de 0 vers 0, de 5 vers 2, etc..).
On a deux entrées:
INC : qui permet d’incrémenter l’état de 1
CH : qui permet le chargement d’un état (lors d’un saut).
Diagramme des états
2 3 4 5 6
0 1 DEB EQZ+
REQ
REQ
REQ
REQ REQ DEB
REQ
REQ REQ
DEB
DEB
2a.Table des cas
REQ DEB
REQ REQ
DEB
ETAT Condition INC CH Valeur
chargée
0 0 1 1 2 2 3 3 4 5 5 6 6
REQ DEB REQ
REQ
DEB REQ
0 1 0 1 0 1 0 1 1 0 1 0 0
1 0 1 0 1 0 1 0 0 1 0 1 1
0 0 2 3
2 0 6 REQ
2b. Shéma
A compléter (mettre toutes
les commandes en sortie) REQ
DEB
REQ DEB
0 1 2 3 4 5 6 7
0 2
ChInc
D CPT
REQ REQ
DEB DEB ACK0
CHRX ACK1
REQ
2c. Commentaires
Le décodeur active l’état sur lequel on arrive.
En fonction de la condition on charge une valeur ou bien on incrémente l’état.
Lorsqu’on est à l’état 0 et qu’on charge l’état 0, c’est comme si on faisait rien ; donc, on peut supprimer toute les lignes de la table des cas correspondant à cette situation, le dessin en est fortement simplifié.
Pour les commandes en sortie, on se sert également du diagramme des états: pour une commande donnée, on fait un “ou” avec toutes les lignes des états dans lesquels la commande est activée.
3. Unité de contrôle microprogrammée
On travaille avec une mémoire qui va contenir le microprogramme ;
Le séquencement et la génération seront assurés par la mémoire adressée par le compteur ordinal.
La réalisation du séquenceur permet soit d’incrémenter soit de charger le compteur ordinal.
Un séquenceur simple permet de faire des sauts conditionnels ;
L’adresse donnée par le séquenceur se trouve dans le champ de contrôle du séquenceur, composé de 2 parties :
-le code du saut
-l’adresse du saut (assimilable aux étiquettes en assembleur)
Le code du saut indique soit : - un saut conditionnel
- un saut inconditionnel (passage sans condition comme de 4 en 5 dans l’exemple)
- un passage en séquence (incrémentation)
Dans l’exemple de la somme, nous avons:
4 conditions, donc 4 codes de saut conditionnels;
le passage en séquence;
le code du saut inconditionnel
⇒ on a 6 codes différents,donc on utilisera 3 bits pour les coder.
Table des sauts
Code saut Séquencement
000 001 010 011 110 111
saut si REQ saut si REQ saut si DEB saut si DEB passage en séquence
saut inconditionnel
schéma
CH
INC
D 0
1 2 3 4 5 6
7 Code-saut Adresse
DEB REQ
REQ DEB
0
1 commandes
cpt
MICR OPROG
RAMME
. . . .
. . . .
Commentaires:
En fonction du code-saut, le multiplexeur permet d’incrémenter ou de charger une nouvelle adresse.
Le nombre de bits d’adresse dépend du nombre de lignes du microprogramme. Dans l’exemple traité on a 8 lignes donc on l’adresse est codée sur 3 bits.
Le décodeur permet de choisir la case mémoire à activer; elle contient le code saut, la nouvelle adresse et les commandes à exécuter (toutes les commandes sont représentées sur chaque ligne (case mémoire) et une commande est exécutée si le bit correspondant est à 1.
Microprogramme
@ commandes A
C K 0
A C K 1
EC C
H R X
C H R S
R S 0
R U 1
R X A
R S A
R U B
R Y B
A S AS
C C H R Y
Code
saut @
0 1 2 3 4 5 6 7
ACK0 EC CHRX RS0 RU1 SAUT SI REQ 0 RXA RUB S ASC CHRX SAUT SI DEB 0 ACK1 SAUT SI REQ 2 ACK0 EC CHRY SAUT SI REQ 3 RSA RYB A ASC CHRS
RXA RUB S ASC CHRX SAUT SI DEB 2 ACK1 SAUT SI REQ 6 ACK1 SAUT SI REQ 0
1 0 0 1 0 0 0 0
0 0 1 0 0 0 1 1
1 0 0 1 0 0 0 0
1 1 0 0 0 1 0 0
0 0 0 0 1 0 0 0
1 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0
0 1 0 0 0 1 0 0
0 0 0 0 1 0 0 0
0 1 0 0 0 1 0 0
0 0 0 0 1 0 0 0
0 0 0 0 1 0 0 0
0 1 0 0 0 1 0 0
0 1 0 0 1 1 0 0
0 0 0 1 0 0 0 0
001 010 000 001 110 011 000 001
000 000 010 011 101 010 110 000
