IFT1227 – Architecture des ordinateurs I
Cours 1, lundi 8 janvier 2007 TP: 30 points
Intra: 30 points
Final: 30 points (cumulatif) [seuil à 45% (I+F)]
Livre: Architecture de l'ordinateur, Andrew Tanenbaum, 5e edition Utile: MultiMedia Logic (Simulateur de circuit logiques)
ISA: Instruction Set Application (Vue programmeur)
RISC: Environ 100 opérations (Le code opération tient sur un octet) CISC: Complex ... (environ 300)
FPGA: Créer un circuit logique à partir d'une programmation.
Revoir tables de Karnaugh
Début: [chap. 3]
Circuit combinatoire: Sans mémoire
Circuit séquentiel: Avec mémoire
Machines à états finis: Déterministes ou Non-déterministes
Pour deux variables booléennes, on peut associer 16 fonctions différentes (voir tableau) Nombre de fonctions associé à n variables:
2
(2 )nAlgèbre de bool: ({0,1}, et, ou, neg) minimal pourrait être ({0,1}, nor) -ou- ({0,1}, nand)
À partir de E = {1,2,3}, on se souvient que P(E) = {, {1}, {2}, {3}, {1,2}, ...} de cardinalité 2|E|
On remarque que les opérations sur les éléments de P(E) suivent l'algèbre de bool (Union, Intersection, Négation)
(P(E), , )
Tout le reste se prouve (théorèmes), par exemple pour prouver que AA = A:
A = 1A = (A + A)A = A (A+A) = AA + AA = AA + 0 = AA (Idempotence)
Loi de DeMorgan (appliquée):
Table de Karnaugh: Utile dans les fonctions à une seule sortie.
(Et limité dès qu'on beaucoup d'entrées, car la table de vérité est trop grande)
Fonction majorité: M = ABC + ABC + ABC + ABC = m3 + m5 + m6 + m7 = (3,5,6,7) [011+101+110+111]
(minterm) (sommes des produits)
Les maxterm: A+B+C A+B+C A+B+C A+B+C (produits des sommes)
Donc, si on a beaucoup de '1', on veut choisir le produit de sommes et inversément si on a beaucoup de '0'. Mais dans ce cours on utilisera le plus souvent la somme de produits.
Intégration:
Une porte nécessite environ 10 transistors.
SSI (small): 10 à 100 portes MSI (medium): 100 à 1000 portes LSI (large): 1000 à 10000 portes VLSI (very): 10000+
Aujourd'hui: de l'ordre de 100 000 000 de transistors (limités par la chaleur)
Multiplexeur: Avec une ou des variables de contôle on choisit le signal d'entrée à laisser passer.
Cours 2, jeudi 11 janvier 2007 Multiplexeur:
Démultiplexeur:
Décodeur: (va sélectionner une des sorties et la mettre à 1)
sera utile pour, par exemple, sélectionner un mot mémoire depuis l'adresse.
exemple de la mémoire: 1 Gig de RAM, nécessite 30 bits d'adressage:
le truc consiste à le faire en deux (plus) étapes... (matrice)
PLA: Programmable Logic Array (voir p.36: matrice de ET sur les entrées et matrice de OU ensuite)
Cours 3, lundi 15 janvier 2007 Machine à état fini (FSM):
H: Horloge D: Donné
Donc, pendant un cycle d'horloge, Q est stable (le FSM ne changera que lorsqu'on aura un signal montant sur l'horloge)
Pendant un cycle d'horloge, Q est stable
Toute opération doit prendre (au maximum) un cycle Cycle: Période
fréquence (Horloge) ~ 1 GHz = f avec p = 1/f f=1GHz=109Hz p=10-9s=1ns (donc si une opération prend plus d'une ns, plus d'une opération, on a besoin de mémoire...) (voir p. A-41)
La majorité des circuits aujourd'hui sont synchrones (séquencés par une horloge). Ils sont moins rapides que les circuits asynchrones, mais ce sont les seuls qui fonctionnent bien aujourd'hui.
On note qu'en réalité (physique oblige) les données doivent rester stables un petit temps avant et après la montée de l'horloge (avantsetup, aprèshold) ~ 1%.
Loquet (latch): [versus Bascule (flip flop)]
(asynchrone pcq pas d'horloge)
Implémentation du NAND se fait facilement en prenant simplement S et R plutôt que S et R comme entrées.
Des problèmes peuvent survenir quand on utilise des entrées pas totalement synchrones en entrée... (voir p.A-45), par exemple sur un XOR... c'est pourquoi on a besoin d'une synchronisation.
Loquet avec horloge:
Permet d'éviter le problème susmentionné.
[pour prétèger contre le cas S et R à 1, on peut utiliser une entrée D et D et alors la mémoire est conservée pendant le cycle de l'horloge – Je peux alors faire tous les calculs voulus sur le front bas de l'horloge, ce qui me donne 0,5 ns pour travailler (concrètement on a des 0 plus long que les 1 sur l'horloge)]
Le loquet est passant durant tout le niveau «1» de l'horloge:
On utilise D ici
Pour isoler le loquet, on va se faire une bascule avec un loquet maître et un loquet esclave:
Bascule (Flip-Flop): Symbole:
Q ne changera donc qu'au front descendant.
Front Front montant descendant Q
présent S R Q suivant
-- 1 0 1 set
-- 0 1 0 reset
0 0 0 0 mémoire
1 0 0 1
-- 1 1 Q=Q et
ocille interdit
Loquet J-K: (p.A-51)
Pour éliminer le problème du S=R=1 du loquet de base S-R, on peut faire:
(l'horloge permet de stabiliser le tout et d'éviter l'oscillation)
Cours 4, jeudi 18 janvier 2007
Compteur: 00 01 10 11 Machine à état fini:
On va donc utiliser des bascules D pour réaliser la table:
Donc: f0 = ¯p0p1 + p0¯p1
et: f1 = ¯p0¯p1 + p0¯p1 = ¯p1(¯p0+p0) = ¯p1
Pour n bits, on peut faire (en remarquant les conditions de passage à 1 d'un bit):
Additionneur à 4 bits:
Retenue: fonction majorité Somme: un genre d'«impair»
transition J K
x1 1 --
x0 -- 1
00 0 --
11 -- 0
xx 0 0
inverse 1 1
Présent Futur
p0 p1 f0 f1
0 0 0 1
0 1 1 0
1 0 1 1
1 1 0 0
Démo 1, vendredi 19 janvier 2007
A B AND OR XOR NAND NOR
0 0 0 0 0 1 1
0 1 0 1 1 1 0
1 0 0 1 1 1 0
1 1 1 1 0 0 0
#A.1- Faire un ET avec des NAND
#A.2- Faire un OR avec NOR Faire un AND avec NOR Faire un NOT avec un NOR
#A.3-
#A.4- XOR à trois branches
#A.5- Il y a 10 portes d'entrées dans le shéma associé au numéro A3 (pas A.31)
#A.6- Implémenter
f A B C ( , , ) ABC ABC ABC
A B C AB ¯A ¯A+B ¯C F G
0 0 0 0 1 1 1 0 1
0 0 1 0 1 1 0 1 0
0 1 0 0 1 1 1 0 1
0 1 1 0 1 1 0 1 0
1 0 0 0 0 0 1 0 0
1 0 1 0 0 0 0 1 0
1 1 0 1 0 1 1 1 1
1 1 1 1 0 1 0 1 0
A B C XOR3
0 0 0 0
0 0 1 1
0 1 0 1
0 1 1 0
1 0 0 1
1 0 1 0
1 1 0 0
1 1 1 1
#A.8-
f A B C ( , , ) ABC ABC
est-il équivalent àg A B C ( , , ) ( A C B )
Par table:En simplifiant les équations:
( , , ) ( ) ( ) ...
g A B C A C B AC AC B ABC ABC
#A.10- Faire un comparateur de mots de 4 bits 0 si identiques, 1 sinon.
#A.12- Utiliser deux MUX pour faire:
#A.14- Utiliser décomposition pour implémenter f avec deux MUS 4-1.
( , , , )
f A B C D ABCD ABCD ABC D AB
( , , , ) ( )
f A B C D AB CD CD C D AB ( CD CD C D )
(...) AB
A B C ABC ¯A ¯C ¯AB¯C A(+)C F G
0 0 0 0 1 1 0 0 0 0
0 0 1 0 1 0 0 1 0 0
0 1 0 0 1 1 1 0 1 0
0 1 1 0 1 0 0 1 0 1
1 0 0 0 0 1 0 1 0 0
1 0 1 0 0 0 0 0 0 0
1 1 0 0 0 1 0 1 0 1
1 1 1 1 0 0 0 0 1 0
A B F0 F1
0 0 0 0
0 1 1 0
1 0 1 0
1 1 0 1
C D
0 0 0
0 1 1
1 0 1
1 1 1
A B
0 0 0
0 1 1
1 0 0
1 1 Z
#A.15- Utiliser deux décodeurs ainsi qu'un OR pour faire un XOR sur A et B.
Mémo: Décodeur, envoi un 1 sur la ligne spécifiée par le nombre binaire spécifié par les entrées.
Cours 5, lundi 22 janvier 2007
Reset asynchrone: Met à 0 immédiatement (versus synchrone qui attendrait le cycle d'horloge) Détecteur de séquence: (indiquer «1» si on a reçu exactement 2x «1» dans les trois dernières entrées.
Entrées: 011011100 Sorties: 001111010
Bâtissons une machine à état fini: A: Initial
B: un '0' C: un '1' D: "00" E: "01"
F: "10" G: "11"
Note: Si on a n états à distinguer, nous aurons besoin de
lg n
bits pour coder l'état.Codons-le à partir de multiplexeurs:
En résumé: 1- FSM symbolique
2- Se code en lg(n) états (table d'états) 3- Réalisation avec MUX
Tampon à 3 états:
Exemple de simplification algébrique:
M ABC ABC ABC ABC
M ABC ABC ABC ABC ABC ABC
idempotence( ) ( ) ( )
M A A BC B B AC C C AB
distributivitéM BC AC AB
deux niveaux( )
M BC A B C
multi-niveau Tables de Karnaugh:Code Grey: chaque colonne ou rangée ne diffèrera que d'un seul bit ...
Cours 6, jeudi 25 janvier 2007
Distance de Hamming: (distance entre deux vecteurs binaires)
ex.: 0100100 et 0111010 4 (nombre de bits où les deux vecteurs diffèrent)
Note: Deux cellules adjacentes d'une table de Karnaugh ont une distance de Hamming de 1.
Code Grey:
1 bit: 0 1
2 bits: 00 01 11 10
3 bits: 000 001 011 010 110 111 101 100
Démo 2, vendredi 26 janvier 2007 absent
Cours 7, lundi 29 janvier 2007
Simplification tabulaire Quine-MacCluskey:
On remarque que si on a:
poids(v) = nb de «1». ex.: poids(0111)=3
on note que deux vecteurs distincts qui ont le même poids sont distant d'au moins 2.
Ctrl in out
1 x x
0 déconnecté déconnecté
Première étape, on regroupe les «cubes» (vecteurs) ayant le même poids. Dans un même groupe, il ne pourra donc pas y avoir de simplification. (Pas une distance de 1 qui était ntore critère avec Karnaugh.)
Ensuite, on comparera chaque élément d'un groupe avec tout ceux du groupe suivant pour simplifier. (On ne peut pas aller plus loin: différence de plus de 1)
Crochet dès qu'on s'en sert!
Étoile quand on s'en sert pas du tout.
Les tirets sont considérés comme une «3e» terme distincts pour les comparaisons.
( On note qu'un XOR ne sera jamais simplifiable par cette méthode. ) On prend ensuite tous les termes notés par des *:
On commence par conserver les essentiels (ceux qui sont seuls à couvrir un terme.
On élimine ensuite tout ce qui est couvert par les essentiels.
On prend ce dont on a besoin ensuite pour couvrir le reste... (commençant par les plus petits)
(erreur dans le tableau, il manque 0000 et 1111) On obtient donc:
Cours 8, jeudi 1er février 2007
Remarques: Nombre de transistors par cm2: 1010 Donc, linéairement,105 par cm Taille du transistor: 10-7 m = 0,1 µ Cellule végétale: 10µ
www.rense.com/general72/size.htm
www.micro.magnet.fsu.edu/primer/java/scienceopticsu/powersof10/
Mémo: 103 ~ 210 106 ~ 220 109 ~ 230
RAS/CAS: Rows & Columns pour diviter la tâche. Permet d'utiliser moins d'entrées, mais nécessite un délais (2 étapes) Mémoires: SRAM: static RAM bit bascules (6 transistors), doit donc être rafraîchi régulièrement
DRAM: dynamic RAM 1 transistor + 1 capacitor, conserve donc sa valeurs quelques milisecondes.
Démo 2, vendredi 26 janvier 2007 absent: #A.17 A.25 @ A.28
Démo 3, vendredi 2 février 2007
#A.33- A: dernier bit = 0
B: dernier bit = 1
0 1
A:0 A/0 B/1 B:1 A/1 B/0
#1.15- 0,079 (1.6x)
#3.7- f(A,B,C,D) (1011)2 sur [A,B,C,D] nombre de bits à un est pair?
pair F=0 impair F = 1
#3.8- Comment réaliser:
x3 x2 x1 x0 z1 z0
0 1
A:0 0/0 1/1 B:1 0/1 1/0
E x z Et+1
0 0 0 0
0 1 1 1
1 0 1 0
1 1 0 1
0 0 0 1 0 0
0 0 1 0 0 1
0 1 0 0 1 0
1 0 0 0 1 1
#3.9- Représenter démultiplexeur: 1 ligne d'entrée, 2 lignes sélection, 4 sorties.
#3.10- Faire la focntion majorité sur PLA
#3.13- Additionneur à 8 bits.
... impliquerait 8 cycles d'horloge pour une addition
naturel: à 8 bits.
x A B z0 z1 z2 z3
0 0 0 0 0 0 0
0 0 1 0 0 0 0
0 1 0 0 0 0 0
0 1 1 0 0 0 0
1 0 0 1
1 0 1 1
1 1 0 1
1 1 1 1
mieux: C0 = 0 Ci = Pi-1 + Si-1Ci-1
C1 = P0 + S0C0 = P0 Pi = Ai-1Bi-1
C2 = P1 + S1C1 = P1+P0S1
C3 = P2 + S2C2 = P2 + P1S2 + P0S1S2
#3.15-
Oui, parce que dans l'unité A+L on peut inverser A et ajouter ensuite 1, c'est-à-dire faire le Cà2 auquel on peut ajouter B, ce qui donne la différence.
(pour ajouter un, on n'a qu'à prendre le bit d'entrée de retenue (normalement à 0 et le mettre à 1) A, Cà1, +1, +B ...
#3.20-
On a ce diagramme, on veut savoir avec 256x8 combien on aura de ET et de OU.
ET:
On remarque qu'on a 2 portes ET pour lecture/écriture 2x nombre de lignes
1x par bascule
2+2x256+256x2048 OU:8 portes OU
#3.22- Imaginer une manière d'adresser 2n adresses au moyen de moins de n broches.
avant: après:
en multiplexant dans le temps, c'est-à-dire en stockant par exemple ½ la moitié des bits pour ensuite en recevoir une seconde série.
#3.23- On a un meg x 1 bit par chip On a 32 bits d'adressage
On peut donc avoir 32 bits x 1 mb = 32 mb = 4 megaoctets.
Cours 9, lundi 5 février 2007
Quand on passe d'un modèle de LMC à un modèle à plusieurs registres, il faut modifier la syntaxe des instructions:
add 52 (ajouter le contenu de la case mémoire 52 dans l'accumulateur)
Nécessite accès mémoire et n'utilise qu'un registre add R17, R15 (ajouter le contenu de R15 dans R17)
Ne nécessite pas d'accès mémoire et agit entre deux registres ld R15, x (charge dans le registre)
Les machines où toutes les opérations s'effectuent entre les registres (avec une instruction de load et une de store) sont de type load-store RISC [spark, etc.]* Notons également qu'on lira deux registres pour une opération et on en écrira un, le tout décalé permettant de lire pendant l'exécution du l'instruction précédente, etc.
CPU ~ 1 GHz
PCI ~ 33 MHz, 66 MHz ou 100 MHz ~15 ns
Cours 10, jeudi 8 février 2007 Pentium 4:
32 bits [ vue programmeur 32 bits, mais architecture 64, voir p.3.12
transistors 2000: 55 millions / 2004: 125 millions (pour référence: 8088~29 000 transistors) 2000: 0,18µ 2004: 0,09µ (cheveu de 20µ à 100µ)
Prédiction de branchement: Par exemple en prédisant qu'on va tourner à l'infini dans une boucle (for/while) et admettant qu'on va se tromper une fois (à la sortie).
[ Le circuit qui «prédit» le branchement occupe à lui seul 29 000 transistors. ]
Horloge 3,2 GHz
63 à 82 Watts
Adressage: 233 23 = 236 = 64 Gigaoctets. [ 23?: 64 bits d'adresses = 23 octets ]
Note: Snooping: espionnage pour s'assurer de la cohérence des données en cache cpu et sur la ram pour éviter les erreurs en cas de multi-cpu. (Observe le bus)
Pipelinage: Avantage en passant de n (étapes) x p (cycles) versus n + p -1.
à la limite, on aura accéléré d'un facteur p (on fait p tâches en même temps)
Démo 4, vendredi 9 février 2007
#3.24- 10ns 10ns + 10ns – 3ns – 2ns = 15ns 20ns 20ns + 10ns – 3ns – 2ns = 35ns
#3.25- 10ns + 10ns – 3ns – 4ns = 13ns > 10ns ok.
#3.26- À la lecture, on peut y survivre tant que le signal de lecture (RD) n'est pas reçu... mais à l'écriture, cela écraserait la valeur précédente.
#3.27-
On a trois données par cycle plutôt que une
donc on va trois fois plus vite après les deux initiaux.
#3.28- TA1 < TMSYN1 TMSYN1 < TD1 TSSYN1 < TMSYN2 TMSYN2 < TD2
TMREQ1 < TMSYN1 TD1 < TSSYN1 TSSYN1 < TRD2 TMSYN2 < TSSYN2
TRD1 < TMSYN1 TSSYN1 < TMREQ2
TSSYN1 < TA2
#3.29-
Oui, certains chips "justifiés" vont par contre déplacer dans le groupe moins significatif vers le groupe le plus
significatif...
#3.30- oui
#3.31- 64bits 200MHz 4cycles 64 bits on veut ?B/s 1 / 200 000 000 = 5ns
4 cycles x 5ns = 20ns 64bits / 8 = 8 octets
400MB/s
#3.32- CPU: 32bits avec A2 à A31
Il «manque» donc A0 et A1 qui, étant les bits les moins significatifs, ne sont pas utiles si on lit les octets 4 par 4.
Comme on lit 2 par 2 (qu'on lit 16 bits à la fois), on n'a accès qu'à la section "gauche' de façonb naturelle.
- Soit sortir 3 bits du processeurs qui permettent de déterminer chacune des 7 combinaisons parmi les 4 octets...
- Masquage interne au CPU - etc
* [ Pas de bonne manière, juste un choix ]
#3.33- bus 32bits / 33 fils... pourquoi?
236 octets adressables
mots de 32 bits (4 octets), mais 2 à la fois (8 octets)
234 adresses possibles, mais 2 à la fois, donc 33 fils.
Cours 11, lundi 12 février 2007
Pentium 4 (CISQ) UltraSparc III (RISQ)
Données 32 bits 64 bits
Horloge 3.2GHz 600MHz
1.2 GHz (2002) 4 instructions par cycle ~4.8GHz 6 pipelines:
2 x arithmétique 2 x virgule flottante 1 x Load/Store 1 x Branch cache (niveau 1) 8k (intégré) 32k instruction
64k données cache (niveau 2) 256k à 1024k externe au cpu
1à8 meg (120o/ligne)
broches 478 1368
bits d'adresse 36 (64 Go) 43 (8 To)
Étapes: Recherche Décodage Exécution Accès mémoire Écriture
Comme la recherche nécessite un accès mémoire qui peut entrer en conflit avec l'accès mémoire lors d'une situation de pipeline d'instructions. Donc pour régler ce problème, il y a deux caches de niveau 1.
UltraSparc: - «quasi pur RISK» ont été ajoutées des instructions 3D, MPEG, temps réel et compression.
- Problèmes d'ordre des opérations dans le fait qu'on puisse lancer 4 opérations à la fois. Il faut donc que la machine pusise retrouver ce qui peut se faire en parallèle. "Exécution Out of Order"
Processeurs enfouis: (embeded / micro-controlleurs) IEEE Spectrum
Peut adresser 64ko externe (16 bits)
Utilisera donc 8 des broches d'adressage pour recevoir les données...
Souvent le logiciel sera contenu dans un ROM interne de 4 à 8k...
Les BUS:
ISA: [ 8088 ] ~ 1979 -1982
20 bits d'adresse qui furent augmentés à 24 (286) [16M] puis à 32 (386).
8 bits pour les données 31 contacts 61 contacts 8,33 MHz (vitesse du BUS) PCI:
besoin: 1024x768 pixels et 3 octets/pixel et 30 écrans/seconde 67,5 Mo/s 33 MHz et 4 octets/cycle 133 Mo/s
passé à 66 MHz et 8 octets/cycle 528 Mo/s PCI Express:
Fonctionne comme réseau.
USB:
série
12 Mbits/s devenu 480 Mbits/s
1. pas besoin de cavaliers (jumpers) 2. pas besoin d'ouvrir le boîtier 3. un seul type de câble 4. alimentation intégrée 5. Temps réel
6. Sans redémarrage de la machine 7. Pas de réinitialisation
jusqu'à 127 unités.
1.5 Mb/s / 12 Mb/s / 480 Mb/s
Toutes les miliseconde, les unités sont "poolés" par la racine...
Cours 12, jeudi 15 février 2007 absent
Cours 13, lundi 19 février 2007
Prochaine micro-instruction: MBR: code de l'instruction machine
- contenu dans la micro-instruction précédente MPC: Micro-PC, soit le 'PC' de la micro-machine
Registres:
SP (Stack Pointer): Pointe au sommet de la pile en mémoire TOS (Top of stack): Valeur du sommet de la pile
ex.: Mettre dans MDR la valeur de SP
SPout, MDRin flèche blanche de SP à 1, flèche noire de MDR à 1.
Additionner MDR=SP+MDR (ne peut se faire en une seule micro-instruction!)
H = SP Hin, SPout
MDR = MDR + H MDRout, add, MDRin
Il faut faire attention à certaines séries d'instructions, par exemple:
MAR = SP; read.
MDR = H.
n'a pas de sens, parce que le MDR est occupé au même moment par le read (qui dure 2 cycles).
Par contre,
SP = MDR = SP+1
est valable, parce que le premier SP est en sortie alors que le second est en entrée. La valeur de SP changera simplement en fin de cycle.
SPin, MDRin, inc(sp)
Interdit aussi:
H = H – MDR
parce que le deuxième argument de la soustraction est H
TOS = TOS
servira à mettre N et Z à 0
Il existe une notation pour faire cela: Z=TOS
Démo 6, vendredi 23 février 2007
Instruction: généré automatiquement par le compilateur (ou écrit à la main!)
Micro-instruction: sous-partie simple du développement de l'instruction DANS le processeur Micro instructions d'un load: (p.280) ILOAD
iload1: H=LV exemple: ... | 000000000 | 000 | 0101 |
iload2: MAR=MBRU+H; RD iload3: MAR=SP=SP+1 iload4: PC=PC+!; FETCH; WR iload5: TOS=MDR; Goto main1
(on se souvient que le RD sera en exécution un peu après, au niveau du iload3)
Description des iloads:
iload1: (MBR=INDEX) H=Base des Variabels locales iload2: MAR=Adresse variable locale, lire variable iload3: MAR et SP = Nouveau sommet
iload4: Extrait le prochain code d'opération, Écrire le nouveau sommet iload5: Actualise TOS
Cours 14, jeudi 1er mars 2007
Démo 5, vendredi 2 mars 2007
IFLT (if less then) en micro-instructions (voir bouquin) Pour TP:
Cours 15, 16, 17 absent
Cours 18, jeudi 22 mars 2007
Fenêtrage, Renommage, Concept du LRU (Least Recently Used) P4/Sparc: Espace mémoire homogène
8051: Espace programme / Espace d'adressage pour les données ROM: 4ko
RAM: 128 octets Mémoire extérieure: 64ko
Mémoire structurée par ensembles: R0 à R7 par exemple (registres d'un octets)
En tout moment, on n'a accès qu'à 4 ensembles en même temps.
Pour le traitement d'une interruption, par exemple, on changera simplement d'ensemble, tel que spécifié par PSW (Program Status Word) dans la section RS.
Mots 0 à 31: Registres
Mots 32 à 48: 128 bits individuellements adressables.
Démo 8, vendredi 13 mars 2007
#13- ISHR décale les bits à droite Donc divisé par 2k
#14- Même chose, mais multiplié par 2k
#15- Pour pouvoir aller chercher le object ref on a besoin de savoir combien de paramètres il y avait (bon décalage)
#16- (sur mic2 : 2 bus)
bad good
DLOAD1 | MAR = LV = MBR1U; RD plutôt: MAR = LV + MBR1U; RD / et H =
DLOAD2 | H = MAR + 1 on ne peut lire dans MAR plutôt: H=H+1
DLOAD3 | MAR = SP = SP + 1; WR
DLOAD4 | MAR = H; RD * il faudrait attendre une opération ici (RD)
DLOAD5 | MAR = SP = SP + 1; WR DLOAD6 | TOS = MDR; GOTO MBR
#19-
donc, on utilise un prédicteur (pour p.325, le prédicteur à 2 bits – 4.42)
2 bits: premier bit: bit de prédiction
second bit: bit de pardon
3 bits:
#20-
5: oui ça marcherait 4: non, manque de place
Cours 19, jeudi 29 mars 2007
Adressage: Immédiat / Direct / Registre ...
Cours 20, lundi 2 avril 2007 Modes d'adressage:
- Immédiat - Direct (absolu)
- Registre (mode registre) - Indirect par registre
Dans notre exemple: # static / direct pour array?
() dynamique / indirect
(Rx) tout seul contenu à l'adresse indiquée par le registre (Rx) var(Rx) array (déplacement)
(page 5, en haut à droite)
En registre, ça donne: mov R1,#8 mov R2,#2 mov R3,#5 mult R2,R3 add R1,R2
Orthogonalité ~=~ correspondance syntaxique universelle des codes d'opération (pas toujours possible!) Le dernier bit du code opération nous informe s'il s'agit d'un mot ou d'un octet
Coop Mod SIB Déplacement imm
[ | ] [ | | ] [échelle| index|base] [ ] [ ]
Démo 9, jeudi 5 avril 2007
FSR0: Pour indirection (référence) utilisé par: INDF0
POSTINC0 et PREINC0 pour incrémenter avant ou après FSR0 … p.48 FW_VALUE_LOW horloge (changé à tous les 100e de seconde)
_HI (changé plus lentement…)
_UP (etc.)
Cours 21, jeudi 12 avril 2007 Gestion des interruptions:
Pour rendre le processus des interruptions cohérent, il faut:
- Conserver l'état des registres et l'adresse de retour.
- Avoir la possibilité (pour certaines opérations) d'être ininterruptible.
On a aussi un vecteur d'adresses de gestionaires d'interruptions (liste en position fixe d'adresses de g.) Fin du cours
