+

Cours d’Architecture des Ordinateurs Andrei Doncescu

+Généralités

n  Langage successeur du langage B dans les années 60, premières normes en 1978 puis norme ANSI en 1989 et ISO en 1990.

n  Langage de base sous UNIX

n  Langage généraliste de syntaxe « simple »

n  Langage compilé (et non interprété)

n  Usage des pointeurs, récursivité

+ Programmation Informatique

n  Un programme est un ensemble d’instructions exécutées dans un ordre bien déterminé.

n  Un programme est exécuté par un processeur ( machine ).

n  Un programme est généralement écrit dans un langage évolué (Pascal, C, VB, Java, etc.).

n  Les instructions qui constituent un programme peuvent être classifiées en 4 catégories : n  Les Instructions d’affectations : permet de faire le transfert

des données n  Les instructions arithmétiques et logiques. n  Les Instructions de branchement ( conditionnelle et

inconditionnelle ) n  Les Instructions d’entrées sorties.

+

4

Exécution d’un Programme

n  Pour exécuter un programme par une machine, on passe par les étapes suivantes :

1.  Édition : on utilise généralement un éditeur de texte pour écrire un programme et le sauvegarder dans un fichier.

2.  Compilation : un compilateur est un programme qui convertit le code source ( programme écrit dans un langage donné ) en un programme écrit dans un langage machine ( binaire ). Une instruction en langage évolué peut être traduite en plusieurs instructions machine.

3.  Chargement : charger le programme en langage machine dans mémoire afin de l’exécuter .

+Comment créer un programme « exécutable » ?

prog_principal.c sous_prog1.c sous_prog2.c

prog_principal.o sous_prog1.o sous_prog2.o

prog_executable

1) Compilation

2) Edition des liens

0) Ecriture des fichiers sources *.c 1) Compilation : cc -c prog_principal.c (idem pour les sous programmes) 2) Liens : cc prog_principal.o sous_prog1.o sous_prog2.o -o prog_executable 3) Reste à lancer prog_executable … La procédure de compilation est souvent automatisée à l ’aide d ’un fichier nommé Makefile

(fichiers sources)

(fichiers objets)

+Structure d’un programme

n Un programme est composé de plusieurs fonctions qui échangent et modifient des variables

n Chaque fonction, y compris la fonction main, comprend les éléments suivants : n Directives du préprocesseur n Déclaration d ’objets externes (variables,

fonctions) n Interface de la fonction n Bloc d’instructions

+

Système à base 10 à Système Décimal [72069.45]10 = 72069.45 = 7x104 + 2x103 + 0x102 + 6x101 + 9x100 + 4x10-1 + 5x10-2

Système à base 16 à Système HexaDécimal

[7A6C9D.F5]16=[7x165 + Ax164 + 6x163 + Cx162 + 9x161 + Dx160 + Fx16-1 + 5x16-2 ]10=[?]10

Système à base 8 à Système Octal

[726041.53]8 = [7x85 + 2x84 + 6x83 + 0x82 + 4x81 + 1x80 + 5x8-1 + 3x8-2]10 =[?] 10

Système à base 2 à Système Binaire

[1001010.01]2 = [1x26 + 0x25 + 0x24 + 1x23 + 0x22 + 1x21 + 0x20 + 0x2-1 + 1x2-2 ]10=[?]10

EXEMPLES

=[?]10 è 2x à …, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16, 32, 32, 64, 128, 256, 512, 1024, 2048, … Note 1: 210 = 1K (kilo), 220 = 1M (Mega), 230 = 1G (Giga), 240 = 1T (Tira), Note 2: 16x=24x et 8x=23x à d’ou l’importance des systèmes : Octal et Hexadécimale en microélectronique. [10 110 001 101 011 . 111 100 110] 2 = [26153.746] 8 = [26153.746] 8 = [2C6B.F3]16

X=0

+

Règle: [Ne.Nf]10 = [?]R Ne / R : Quotient à Ne0, et Reste0 à d0 Ne0 / R : Quotient à Ne1, et Reste1 à d1 Ne1 / R : Quotient à Ne2, et Reste1 à d2 …, etc. Nf X R : (Résultat1 - P_Ent1) à Nf1, et P_Ent1 àd-1 Nf1 X R : (Résultat2 - P_Ent2) à Nf2, et P_Ent2 àd-2 Nf3 X R : (Résultat2 - P_Ent2) à Nf3, et P_Ent2 àd-2 …, etc.

CONVERTION DECIMALE à R (2, 8, 16)

Conversion Décimale à RADIX (2, 8, 16)

+

•  Le complément à ‘1 ’ d’un nombre binaire consiste simplement à inverser ses bits.

• 

Complément à ‘2’ et Complément à ‘1’

Le complément à ‘2 ’ d’un nombre binaire consiste à ajouter 1 à son complément à 1

C’2 de 010110 à 101010

C’1 de 010110 à 101001 Exemple

+

n  Octet Signé à

n  Mot Signé à

n 

D7 D6 D0

Magnitude Signe

. . . . . +127 0111 1111

+126 0111 1110

… …

+2 0000 0010

+1 0000 0001

0 0000 0000

-1 1111 1111

-2 1111 1110

… …

-127 1000 0001

-128 1000 0000

Nombres négatifs à ‘C’2’ des magnitudes de leurs équivalents positifs - n = NOT (+ n) + 1

Exemple: -32 à NOT (+32d = 00100000b) + 1 à 11011111 + 1 à 11100000b

Nombres positifs

Magnitude

D7 D6 D0

Signe

. . . . . D15 D14 D8 +32767 0111 1111 1111 1111

+1 0000 0000 0000 0001

0 0000 0000 0000 0000

-1 1111 1111 1111 1111

-32768 1000 0000 0000 0000

[ - 32768 à + 32767 ]

[ - 128 à + 127 ]

L’ORDINATEUR représente les nombres en nombre limité de bits: 8, 16, 32, 64 bits

+

Code ASCII

+Types de variables manipulées en C

n  Toutes les variables doivent être explicitement typées (pas de déclaration implicite comme en fortran)

n  Il y a globalement trois (quatre?) types de variables : n  Les entiers : int, short int, long int n  Les réels : float, double, long double n  Les caractères : char n  Rien … : void

n  exemples : short int mon_salaire; double cheese; char avoile;

n  NB : la présence d ’une ou plusieurs étoiles devant le nom de la variables indique un pointeur, dans nos applications il s ’agira en général de tableaux. ex : double **mat permet de définir une matrice

+

N = [dmdm-1 ... d1d0 . d-1d-2 ... d-n ]R

avec m et n étant entiers

R = Radix (2, 8, 10, 16, etc.) di entier = [0, 1,2, …, R-1]

Soit:

N = dm.Rm + dm-1.Rm-1 + … +d1.R + d0 + d-1.R-1 +… d-n.R-n

En général un nombre dans un système à base R (Radix) est noté comme suit: Partie Entière Partie Fractionnaire

Representation d’un nombre BINAIRE

+Le programme principal

•  La fonction « main » contient le programme principal

•  Le programme exécutable binaire commence par exécuter les instructions de ce programme principal

•  Sans fonction main, il est impossible de générer un programme exécutable

+ Directives du préprocesseur

n #include <math.h> : insère les interfaces des fonctions mathématiques comme par exemple fabs() qui évalue la valeur absolue d ’un réel

n #include <stdio.h> : entrées sorties standard

n #define chaine1 chaine2 : remplacement littéral de la chaîne de caractères chaine1 par chaine2

+ Les opérateurs arithmétiques Addition +

a = 3;

c = a + 2; // c = 5

Soustraction - a = 3;

c = a - 2; // c = 1

Multiplication * a = 3;

b = 11;

c = a + b; // c = 33

Division / a = 75;

b = 3;

c = a / b; // c = 25

Modulo % Reste de la division

a = 75; diz = a / 10; // diz = 7

unite = a % 10 // unite = 5 c ’est à dire le reste

+Qu’est-ce qu’un bloc d ’instructions ?

n Un bloc débute par une accolade ouvrante et se termine par une accolade fermante

n Il contient des déclarations de variables internes au bloc et des instructions

n Les instructions peuvent être elles aussi des blocs ou des commandes du langage C.

n Les lignes d ’instructions se terminent par des points virgules.

+Les entrées sorties : printf, scanf

n Le prototype de ces fonctions est dans <stdio.h>

n printf permet d ’afficher du texte à l ’écran n scanf permet d ’entrer du texte au clavier n fprintf et fscanf permettent de lire et d ’écrire

dans des fichiers Le programme de résolution de l’équation d’advection linéaire scalaire donne de nombreux exemples d’usage de ces fonctions

+printf, scanf (suite)

n  Ces fonctions utilisent des formats qui permettent de lire/écrire des variables de différents types : %e , %f : réels %le, %lf : réels de type double %d : entiers %ld : entiers long int %s : chaîne de caractères %c : un caractère

+printf, scanf (suite)

n  Le caractère « \ » (backslash) permet d ’utiliser certains caractères « non imprimables » , les plus utilisés sont les suivants : \n : fin de ligne \t : tabulation horizontale \a : sonnerie

+ printf, scanf : exemples

#include<stdio.h> int i; printf(" i = %d \n",i); /* Imprime i = valeur de i et va à la ligne */ fscanf(infile, "%d ",&i); /* lit dans le fichier infile la valeur de i, on passe à fscanf l ’adresse de i c ’est à dire &i */ nb: Comme fscanf doit modifier la variable i, le paramètre passé à la fonction est l ’adresse de la variable i.

+

n La boucle for : for (initialisation ; test ; instruction) { instructions };

n Exemple : for (i = 0 ; i <= 50 ; i++) { printf(« i = %d\n »,i);

} « Commencer à i =0, tant que i <= 50 , exécuter l ’instruction printf et incrémenter i »

+ Les tests

n Syntaxes : n if (expression_test)

bloc d ’instructions 1 Si expression_test est vraie on exécute le bloc d ’instructions 1, sinon on passe à la suite.

n if (expression_test) bloc d ’instructions 1

else bloc d ’instructions 2

Si expression_test est vraie on exécute le bloc d ’instructions 1 sinon on exécute le bloc 2.

+Instruction conditionnelle IF…. ELSE

Condition ?

Action 1 Action 2

Vrai

Fausse

if( condition ) action1;

else action2;

if( a > b ) c = c - a;

else c = c- b;

if( a > b )

{ c = c - a;

d = c - a;

}

else { c = c - b;

d = c - b;

}

if( a > b )

{ c = c - a;

d = c - a;

}

if( (a > b) && ( b > 0) ) c = c - a;

else c = c- b;

Si la condition est vrai

• faire l ’action 1

• sinon faire action 2

+Tests (suite)

•  Enchaînement de if : if (expression_test1)

bloc_d_instructions_1 else if (expression_test2)

bloc_d_instructions_2 else if (expression_test3)

bloc_d_instructions_3 ... else bloc_d_instructions_final

+Expressions évaluées dans les tests

•  if (a = b) : erreur fréquente, expression toujours vraie !

•  if (a == b) : a égal à b

•  if (a != b) : a différent de b

•  if (a > b) : a supérieur à b

•  if ((a >=b)&&(a>0)) : a supérieur ou égal à b et a positif

•  if ((a<=b)||(a>0)) : a inférieur ou égal à b ou a positif

•  ...

+ Instruction conditionnelle SWITCH … CASE

Remplace une suite de IF .. ELSE

• expression doit être un entier ou un caractère.

• Switch compare cette expression aux valeurs des différents case.

• L ’instruction break permet de sortir d ’un bloc. Ici cela permet de ne pas tester les case suivants.

• Default est effectué si aucun des case n ’est effectué.

switch ( expression )

{

case valeur1 : instruction(s) 1; break;

case valeur2 : instruction(s) 2; break;

case valeur3 : instruction(s) 3; break;

default : instruction(s) par défaut;

}

switch ( valeur )

{

case 1 : led1 = 1; led2 = 0; led3 = 0; break;

case 2 : led1 = 0; led2 = 1; led3 = 0; break;

case 7 : led3 = 1;

case 3 : led1 = 1; led2 = 1; break;

default : led1 = 0; led2 = 0; led3 = 0;

}

Valeur led1 led2 led3

0

1

2

3

4

5

6

7

0 0 0

1 0 0

0 1 0

1 1 x

0 0 0

0 0 0

0 0 0

1 1 1

Répondre par •  0 •  1 •  x si pas de modification

+ Boucles et branchements

n La boucle while : while(test) { instructions;}

n exemple … int i;

i = 0; while (i < 10) {

printf(« i = %d \n »,i); i++; }

… « Tant que i est inférieur à 10, écrire i à l ’écran, incrémenter i »

+

n  La boucle do … while : do { instructions; } while (test);

n  permet d ’exécuter au moins une fois les instructions avant d ’évaluer le test

+

Boucle WHILE

while (condition)

{

action;

… ;

}

x = 0;

while ( x < 5 )

{

action;

x++;

}

x = 10;

while ( x < 5 )

{

action;

x++;

}

Cette boucle est identique à une boucle FOR

while ( bouton == 0 )

{

action;

}

Tant que condition vraie faire...

while ( 1 )

{

action;

… … ;

}

Condition ?

Action

Sortie de la boucle

+

Nombre d ’exécutions de la boucle : A la sortie de la boucle total =

5 10

Boucle DO … WHILE

Faire... tant que condition vraie

do

{

action;

… ;

}

while (condition);

Action est toujours exécutée au moins une fois

que condition soit vraie ou fausse.

x = 0;

total = 0;

do

{

total = total + x;

x++;

}

while ( x < 5 );

Condition ?

Action

Sortie de la boucle

+ Exemple de fonction

/*Directives du preprocesseur*/ #include <math.h> #include <stdio.h> #define MAX(a,b) ((a) > (b) ? (a) : (b))

/* Variables externes, globales, déclarées dans le programme principal */ extern double a; extern long int imax; extern double * rho; extern double * fphy; extern double * fnum; void flux_numerique (void) /* Interface de la fonction */ { /* Debut de bloc d ’instructions */ long int i; /* Variable locale */ /* Schema decentre */ for (i = 0 ; i <= imax-1 ; i++) { fnum[i] = 0.5*(fphy[i] + fphy[i+1]) - 0.5*fabs(a)*(rho[i+1]-rho[i]); } } /* Fin de bloc */

+

35

La mémoire centrale

n  La mémoire centrale (MC) représente l’espace de travail

de l’ordinateur .

n  C’est l’organe principal de rangement des informations utilisées par le processeur.

n  Dans un ordinateur pour exécuter un programme il faut le charger ( copier ) dans la mémoire centrale .

n  Le temps d’accès à la mémoire centrale et sa capacité sont deux éléments qui influent sur le temps d’exécution d’un programme ( performances d’une machine ).

+

36

0001100 0011100

0111100

0001100

0001100

0000

0001

0002

…….

……. ……..

FFFF

Une adresse

Contenu d’une case (un mot)mémoire

• La mémoire centrale peut être vu comme un large vecteur ( tableau ) de mots ou octets. • Un mot mémoire stocke une information sur n bits.

• Chaque mot possède sa propre adresse. • La mémoire peut contenir des programmes et les données utilisées par les programmes.

+Structure d’un programme en MC

Partie données ( variables )

Partie instructions …………. ……….

} 11100001 11100001 11000001 11100001 11000001 11110000

1111111 1000000

0000000

Addition Soustraction

+

38

L’Unité Centrale ( UC)

n  L’unité centrale (appelée aussi processeur , microprocesseur) à pour rôle d’exécuter les programmes.

n  L’UC est composée d’une unité arithmétique et logique (UAL) et d’une unité de contrôle. - L’unité arithmétique et logique réalise les opérations élémentaires

(addition, soustraction, multiplication, . . .) . - L’unité de commande contrôle les opérations sur la mémoire

(lecture/écriture) et les opérations à réaliser par l’UAL selon l’instruction en cours d’exécution.

+Architecture matérielle d’une machine Von Neumann

UC

+

40

L’UAL

n  L’unité arithmétique et logique réalise une opération élémentaire (addition, ,soustraction, multiplication, . . .).

n  L’UAL regroupe les circuits qui assurent les fonctions logiques et arithmétiques de bases ( ET,OU,ADD,SUS,…..).

n  L’UAL comporte un registre accumulateur ( ACC ) : c’est un registre de travail qui sert a stocker un opérande (données )au début d’une opération et le résultat à la fin.

+

41

Unité de contrôle

n  Le rôle de l'unité de contrôle (ou unité de commande ) est de : n  coordonner le travail de toutes les autres unités ( UAL , mémoire,…. )

n  et d'assurer la synchronisation de l'ensemble.

n  Elle assure : n  la recherche ( lecture ) de l’instruction et des données à partir de la

mémoire, n  le décodage de l’instruction et l’exécution de l’instruction en cours n  et prépare l’instruction suivante.

+

42

Schéma d’une UC