FONCTIONNEMENT INTERNE
DES ORDINATEURS
L'algèbre de Boole, les réels et les segments
AU MENU
FONCTIONNEMENT INTERNE
DES ORDINATEURS
L'algèbre de Boole, les réels et les segments
AU MENU
Depuis le début du cours, on mentionne que les circuits numériques qui constituent l'ordinateur fonctionnent en mode binaire, c'est-à-dire un mode dans lequel les courants électriques sont représentés par des 0 ou des 1.
Ce qui permet à ces deux seules valeurs de faire fonctionner l'ordinateur tel que nous le connaissons aujourd'hui est l'incroyable multiplicité des composantes soumises à l'algèbre de Boole. Ce cours nous permettra donc de comprendre davantage comme fonctionne cette algèbre logique, comment les circuits font pour nous offrir cet outil fascinant qu'est l'ordinateur et comment le microprocesseur fait pour additionner ou appliquer les règles de cet algèbre binaire pour établir des valeurs de vérité sur des connecteurs ET, OU, OU exclusif, NON... etc..
L'algèbre de Boole, également appelée treillis de Boole, branche des mathématiques dont les lois et les propriétés sont analogues à celles de l'algèbre classique. L'algèbre de Boole est utile pour la logique et pour la théorie des ensembles, car elle s'intéresse davantage aux propositions et à leur valeur de vérité qu'aux variables et à leurs valeurs numériques.
D'un point de vue formel, une algèbre de Boole est un système mathématique constitué d'un ensemble d'éléments, que l'on peut appeler B, doté de deux opérations binaires, notées
On peut noter les opérations précédentes par deux symboles quelconques : V et ^. Les éléments de l'ensemble B d'une algèbre de Boole peuvent être des éléments abstraits ou concrets, tels que des nombres, des propositions, des ensembles ou des réseaux électriques. Dans la théorie originelle de Boole, les éléments d'une algèbre de Boole étaient une liste de propositions ou des phrases affirmatives simples ayant la propriété d'être soit vraies, soit fausses, mais jamais les deux à la fois. La plupart des opérations étaient des conjonctions et des disjonctions, notées respectivement ^ et V.
Si x et y représentent deux propositions, l'expression x V y (lire «x ou y») est vraie si, et seulement si, l'une au moins des propositions x ou y est vraie.
L'assertion x ^ y (lire «x et y») est vraie si, et seulement si, les deux propositions x et y sont vraies. Dans ce type d'algèbre de Boole, le complément d'un élément est simplement la négation de la proposition.
Les algèbres de Boole ont de nombreuses applications pratiques en physique, notamment en informatique et en électronique. Comme exemple d'application des algèbres de Boole à la théorie des circuits électriques, considérons deux propositions p et q, c'est-à-dire des affirmations qui sont soit vraies soit fausses, mais pas vraies et fausses à la fois. Si chacune des propositions p et q est associée à un interrupteur qui sera fermé si la proposition est vraie, et ouvert si la proposition est fausse, alors on peut représenter l'affirmation p^q par un circuit où les interrupteurs sont en série. Le courant passera dans ce circuit si, et seulement si, les deux interrupteurs sont fermés, c'est-à-dire si p et q sont toutes les deux vraies.
De même, le circuit peut servir à représenter l'affirmation p V q. Dans ce cas, le courant passera si l'une ou l'autre des affirmations p ou q, ou les deux, sont vraies, et si les interrupteurs correspondants sont fermés. Des affirmations plus complexes conduiront à des circuits plus complexes.
L'algèbre booléenne se distingue principalement de l'algèbre ordinaire par des constantes et des variables qui ne peuvent prendre que deux valeurs possibles 0 et 1. Ces valeurs représentent donc des niveaux logiques.
Ces valeurs binaires peuvent donc être représentées par des valeurs de vérité : vrai ou faux. Regardons les tableaux suivants :
Soit Q et P deux propositions :
Table de vérité pour le AND (et): Table de vérité pour le OR (ou inclusif):
Q Q
AND | 0 1 OR | 0 1
------------ ------------
0 | 0 0 0 | 0 1
P | P |
1 | 0 1 1 | 1 1
Table de vérité pour le NOT (non) Table de vérité pour le XOR (ou exclusif):
Q
NOT | XOR | 0 1
------- -------------
0 | 1 0 | 0 1
P | P |
1 | 0 1 | 1 0
Utilisez l'applet ci-dessous pour tester les différents
connecteurs logiques :
Table de vérité pour P AND Q: (autre format) P Q | P AND Q ------------- 0 0 | 0 | 0 1 | 0 | 1 0 | 0 | 1 1 | 1 Table de vérité pour le (P AND Q) OR R: P Q R | (P AND Q) (P AND Q) OR R ------------------------------------ 0 0 0 | 0 0 | 0 0 1 | 0 1 | 0 1 0 | 0 0 | 0 1 1 | 0 1 | 1 0 0 | 0 0 | 1 0 1 | 0 1 | 1 1 0 | 1 1 | 1 1 1 | 1 1
Les circuits font ce type d'opérations sur les courants
de l'ordinateur et c'est cela qui nous permet de le faire fonctionner
logiquement. Voyons ensemble à titre d'information, différentes
combinaisons d'opérations logiques électriques.
L'unité arithmétique et logique ou UAL représente les muscles de l'ordinateur ; c'est le dispositif qui effectue les opérations arithmétiques telles que l'addition ou les opérations logiques comme ET ou OU. Pour réaliser ces opérations mathématiques sur 16 bits ou 32 bits, nous aurons besoin de 16 ou 32 unités semblables à celle présentée à la figure précédente. Notez la présence des circuits OU, ET, NON qui constituent le cœur de ces puces.
Représentation en point flottant
(retour au menu)
Lorsqu'on doit manipuler des valeurs numériques de grande taille et lorsqu'on veut pouvoir conserver des parties fractionnaires
(la précision !) on se tourne vers l'arithmétique
«réelle» où les objets sont des nombres, dits réels qui possèdent une partie entière et une partie fractionnaire.
Les nombres binaires réels ont la forme normalisée 1.f x 2e où f représente la partie significative de la partie fractionnaire. Le premier chiffre est toujours 1, la mantisse suit et on termine la formule à notation scientifique par la valeur de l'exposant.
Comment contenir les nombres réels dans l'ordinateur ?
Dans l'ordinateur INTEL utilise la version IEEE 754/854 pour la représentation des nombres réels. Ces derniers peuvent avoir plusieurs tailles: 32 bits en simple précision (float), 64 bits en double précision (double) et même jusqu'à 80 bits en précision étendue; précision retenue par le coprocesseur mathématique pour faire tous les calculs. Et ils sont représentés en binaire sous cette forme apprises à la petite école pour la base 10:
Comme pour les
entiers, un réel peut être trop grand ou trop petit, ce qui causera un débordement (overflow si trop grand ou underflow si trop petit). Pour éviter ce problème et garder la meilleure précision, on utilisera une mantisse normalisée c'est à dire qu'elle ne contiendra pas de 0 en tête (donc le premier bit de la mantisse sera 1); comme dans le monde de la base 10.pour une représentation sur 32 bits : 1 bit de signe, un exposant sur 8 bits biaisé à 127 = 28-1 -1, une mantisse sur 23 bits
En double précision (double) l'exposant occupe 11 bits et la partie fractionnaire 52.
Voyons un exemple :
Prenons 1039d,
1039 décimal = 40F hexadécimal = 0000 0100 0000 1111 binaire
normalisons : 1, mantisse
0000 0100 0000 1111 = 1,00 0000 1111 x 210
( 210 opère un décalage de dix chiffres vers la droite après la virgule )
étendons la partie fractionnaire à 23 bits
1,00 0000 1111 = 1,00 0000 1111 0000 0000 0000 0
rangé autrement :
1,000 0001 1110 0000 0000 0000
mantisse sur 23 bits = 000 0001 1110 0000 0000 0000
(on ne mémorise pas le 1 implicite d'avant la virgule)constituons l'exposant en simple précision 8 bits : 128 - 1 = 127
exposant = 10 + décalage = 137
137 décimal = 1000 1001 binaire
Voici maintenant le résultat : bit de signe - exposant - mantisse
|
Bits |
31 |
30 |
29 |
28 |
27 |
26 |
25 |
24 |
23 |
22 |
21 |
20 |
19 |
18 |
17 |
16 |
15 |
14 |
13 |
12 |
11 |
10 |
9 |
8 |
7 |
6 |
5 |
4 |
3 |
2 |
1 |
0 |
|
0 |
1 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
en hexadécimal 44 81 E0 00
le bit de signe (#31) positionné à 0 indique un nombre réel positif !
L'opposé de 1039, soit -1039, s'obtient en mettant le bit de signe #31 à 1
|
Bits |
31 |
30 |
29 |
28 |
27 |
26 |
25 |
24 |
23 |
22 |
21 |
20 |
19 |
18 |
17 |
16 |
15 |
14 |
13 |
12 |
11 |
10 |
9 |
8 |
7 |
6 |
5 |
4 |
3 |
2 |
1 |
0 |
|
1 |
1 |
0 |
0 |
0 |
1 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
0 |
- 1039 se code C4 81 E0 00 en hexadécimal
 |
 |
Les nombres ainsi représentés vont
de 2-128 à 2128 (10±38) en simple précision,
et de 2-1023 à 21023 (10±308) en double précision.
Le nombre 1.0 est représenté en simple précision par:
0
011 1111 1 000 000000000000000000000 (3F800000)soit 1.0000 X 20 (exposant = 0 + 127, la mantisse = 0)
le 1 à gauche du point est implicite.
De même le nombre -10.5 (-1,0101 x 23) sera représenté, par:
1
100 0001 0 010 100000000000000000000 (C1280000)soit -1.0101 x 23, (exposant = 3 + 127 = 130, la mantisse = 0101)
le 1 à gauche du point est implicite.
De la même manière le nombre 0.875 sera représenté par
0
011 1111 0 110 0000000000000000000 (3F600000)soit 1.11 x 2-1, (exposant = -1 + 127 = 126, la mantisse = 1100)
le 1 à gauche du point est implicite.
Vérifiez maintenant vos propres exemples
avec cette applet de Jacques
Longchamp
La différence entre un .COM et
.EXE
(retour au menu)
Nous avons vu que le DOS est capable d'exécuter deux types
de programmes : ceux possédant l'extension EXE et ceux
possédant l'extension COM. Nous devons faire clairement
la distinction entre les deux, car il s'agit de formes différentes.
Le programme EXE est une procédure FAR appelée à
partir d'un autre segment et le programme COM est une procédure
NEAR appelée de l'intérieur du segment code. II
existe une complication supplémentaire car les programmes
COM ont, à un certain moment de leur création, l'extension
EXE. Cependant ils ne peuvent pas être exécutés
sous cette forme. C'est d'ailleurs la raison pour laquelle on
transforme le programme COM en véritable programme .COM
avec l'aide l'option /t de Turbo Debug ou le logiciel EXE2COM.
Le programme .EXE
(retour au menu)
Avec un programme EXE, nous pouvons définir quatre segments différents : code, données, extra, et pile. Cette conception est particulièrement pratique car nous pouvons ainsi placer le code dans le segment code, les données dans le segment données, et la pile dans le segment pile.
Examinons maintenant une structure d'un programme EXE qui affiche
le message :
Bonjour le monde !
TITLE BONJOUR
------------------------------------------------------
pile SEGMENT
DB 80 DUP('STACK ')
pile ENDS
------------------------------------------------------
data SEGMENT
mes DB 'Bonjour, le monde !'
data ENDS
------------------------------------------------------
code SEGMENT
ASSUME CS:code, DS:data, SS:pile
debut : ; initialisation DS
MOV AX,data ; récupération de l'adresse du segment data
MOV DS,AX ; on place l'adresse du segment dans le registre DS (data segment)
MOV DX, OFFSET mes ; adresse du texte (segment : offset)
MOV AH,9 ;fonction DOS pour afficher une chaîne
INT 21h ; appel de l'interruption
MOV AH,4Ch
INT 21h ;fin
code ENDS
END debut
Ce programme source en assembleur est assemblé en un fichier exécutable EXE. Trois segments distincts sont définis : le segment stack appelé pile, le segment données appelé data, et le segment des instructions appelé code. Les symboles code, data, et pile sont arbitraires. N'importe quels symboles pourraient être utilisés. Détaillons maintenant le fonctionnement de ce programme.
Le segment pile est défini par le nom symbolique pile. La zone de pile est fixée à 80 fois 1 octet et initialisée avec les lettres STACK suivies de trois blancs. Le segment de données reçoit le nom data et contient la chaîne que nous voulons afficher. La chaîne est terminée par un signe dollar qui permet au sous-programme d'impression d'en déterminer la fin. Le segment code suit le segment données ; il est défini par les directives SEGMENT et ENDS (end segment) comme nous l'avons vu avec les fichiers .COM.
Ce segment de code génère les instructions destinées à l'ordinateur. II commence par la directive ASSUME qui indique à l'assembleur que les symboles code et data feront respectivement référence au segment code et au segment données. Là, il y a une différence avec les fichiers .COM.
Lorsqu'un programme EXE est exécuté, le registre CS pointe vers le début du segment code. D'autre part, les registres DS et ES pointent vers l'adresse nécessaire pour le retour au DOS une fois le programme terminé. Comme nous devons utiliser le registre DS pour faire référence au segment de données, notre premier travail est de le faire pointer vers le segment de données. L'opération consiste à charger le registre DS pour qu'il fasse référence au segment de données. Cela est effectué à l'aide de deux instructions. L'adresse du segment de données est tout d'abord placée dans le registre AX, puis le registre AX est copié dans le registre DS. Le registre AX doit être utilisé, car les opérations sur les registres de segment sont limitées au transfert avec d'autres registres et avec le contenu d'adresses mémoire. Nous ne pouvons donc pas charger directement DS avec le déplacement d'une adresse mémoire. Nous devons utiliser le registre AX pour faire transiter cette valeur. Ici encore, n'importe quel registre général pourrait remplacer AX.
MOV AX,data ; récupération de l'adresse du segment data MOV DS,AX ; on place l'adresse du segment dans le registre DS
Par rapport aux programmes COM. les programmes EXE présentent l'avantage de ne pas être limités à une longueur maximale de 64 K pour le code, les données et la pile. Le prix à payer en échange de cet avantage est représenté par la plus grande complexité de ces fichiers qui est due à la présence dans un fichier EXE de toute une série d'informations autres que le programme lui-même.
Comme nous venons de le voir, les programmes EXE comportent des segments distincts pour le code, les données et la pile. Ces segments peuvent se présenter dans n'importe quel ordre. Contrairement aux programmes COM. les programmes EXE ne sont pas chargés de la disquette ou du disque dur dans la mémoire pour être exécutés directement. Avant d'être exécutés, ils subissent en effet une préparation effectuée par une routine de la fonction EXEC. Les programmes EXE ne sont pas non plus chargés dans un emplacement de la mémoire défini d'avance mais en n'importe quelle adresse (multiple entier de 16). Nous verrons en détail ce fonctionnement du chargement dans le cours INF-C32 sur les systèmes d'exploitation.
Laboratoire :
(retour au menu)
La première partie du laboratoire de cette semaine consiste à vous
familiariser avec les notions de connecteurs logiques et tables de vérité. Il
arrivera de plus en plus souvent ou vous devrez y recourir pour vous assurez que
vos conditions de branchement se produiront toujours de façon attendue
et optimale !
p1 && p2 && ... & pn
l’évaluation est stoppée si pn est évaluée à faux. Dans le cas:
p1 || p2 || ... || pn
l’évaluation est stoppée si pn est évaluée à vrai; permet d’éviter une erreur
i!=0 && x > ( y/i); // (y/i) n’est pas évalué si i égale 0
La deuxième partie du labo consiste à vous
familiariser avec les notions de segments dans les programmes
EXE et les notions de la représentation des nombres réels.
de décimal en représentation des réels 7.5, -1/4, -16, 19.75, -7
de la représentation des réels en décimal : 40F00000, C1800000, 419E0000, 44640000, C0E00000
Lectures obligatoires:
(retour au menu)
Les notes précédentes
Questions au sujet des notes par courrier
!
Dernière mise à jour : 30 mars 2006
par Yves Bergeron, professeur au collège de Bois-de-Boulogne,
Montréal
URL : http://www.colvir.net/prof/yves.bergeron/infc22/