ASR2 - Architecture et Programmation PDF

Preview

Summary

Cours sur l'Architecture et Programmation...

Description

ASR 2 : S.Laplace : Architecture et Programmation I/ Définitions

Langage d’application Langage d’assemblage Système d’exploitation Couche machine Couche microprogrammation Couche physique

------

Java Assemblage routines binaire interne au microprogramme

Microordinateur : - carte mère - alimentation - mémoires de masse - périphériques Carte mère : - micro-processeur - mémoire - unité d’échange - connecteurs d’e/s (série, parallèle...) - connecteurs d’extension - connecteurs d’alimentation Micro processeur  Unité centrale de traitement  CPU (central processing unit) CPU = UC + UT + Registres

UC (unité de contrôle) : - séquenceur : description en séquences des opérations élémentaires qui permettent l’exécution d’une instruction - ordres à tous les organes du microprocesseur UT (unité de traitement)  UAL (Unité arithmétique et logique)  Unité de calcul : - réalisation des calculs - résultats dans l’accumulateur Registre : - registre d’instruction (RI) : Instruction en cours d’exécution - Registre d’adresse mémoires (RAM) : Adresse mémoires de la donnée à laquelle accéder - Compteur ordinal (CO) : Adresse de a prochaine instruction à exécuter - Registres de données(Ri) : Stockage des informations à stocker ou extraire de la mémoire centrale. Le micro processeur vu par un programmeur : -

µp : exécute des instructions jeu d’instruction

* transfert => Mémoire * traitement => UT=UAL * E/S => Unité d’échange * Ruptures de séquences => UC -

-

utilisation de registres comme opérandes à ces instructions => accès plus rapide qu’en mémoire - RISC registre généraux - CISC registres spécialisés Registres inaccessibles au programmeur : CO, RI, RAM L’UE vue par un programmeur :

-

-

UE = registres accessibles par les instructions d’E/S Lecture des registres d’état => ce que fait ou a fait l’UE Ecriture dans les registres de commande : - Paramétrer le fonctionnement de l’UE - Commander le fonctionnement de l’UE (faire faire) Registres de données : échanges d’information avec les périphériques

II/Programmation Programmation : suite d’instructions Instructions = code de l’opération + désignation des opérandes Instructions connues par le µp : - en binaire - en assembleur : * code opération mnémoniques (LD, ADD, JMP…) * opérandes : noms de registres (R5..), variables Passage du langage aux instructions de µp - langage de programmation : un compilateur - langage machine : un assembleur Registre : - opérande dans un registre - décrite par le registre qui la contient Immédiat : valeur dans l’instruction Direct : - opérande en mémoire - décrite par son adresse en mémoire Indirect : - opérande en mémoire - décrite par le registre ou la variable contenant son adresse (pointeur) Indirect avec déplacement : - opérande en mémoire - décrite par le registre ou la variable contenant une adresse et un déplacement à partir de cette adresse Indirect avec en post ou pré une incrémentation ou une décrémentation : -

Opérande en mémoire Décrite par le registre ou la variable contenant une adresse et une incrémentation ou décrémentation soit de l’adresse soit de la variable

. Avec un segment => protection des données . Une combinaison de tout cela : -

Segment + Indirect + Déplacement + Post incrément …

. Syntaxe : [etiq i] COP [OP1] [OP2]] commentaire . Différents types d’instructions : -

-

Déplacements d’informations : . De mémoire a mémoire . De mémoire a registre . De registre a registre Traitement :

-

. Arithmétique . Logique . Comparaison . Décalage Traitements spécifiques a certain µp . Mathématique . Vectoriel . Chaine de caractère . Traitement de l’image

. Différents types d’instructions : -

-

Rupture de séquence : . Passage d’une instruction a une autre selon ne condition . Condition selon le registre d’état de l’UT UAL Description de l’instruction destinataire : étiquette (adresse)

. Contrôle : -

Appel : retour de procédure Manipulation de pile Gestion des interruptions

. Registre : -

-

32 bits Accessible par programme : . R0 a R6, 7 registres d’usage général . SP pointeur de pile Non accessible pour un programmeur : . CO . RI . Registre d’état. . RA, RB, RC : registre de l’UT

. UT : -

Opération de type arithmétique, logique et décalage uniquement Entiers naturels, entiers relatifs en complément a deux

. UE : -

-

Gestion : . Clavier, 6 touches + une souris . Ecran graphique (256x256 couleur) 8 registres : . Un clavier + boutons de la souris . 5 écrans . 2 coordonnées de la souris

. Mémoire = 1kmo de 32bits Remarque : 7 en complément en deux 7 : 0111 Complément : 1000 Complément +1 => Complément à deux soit 7 soit 1001

. Programme en langage machine : définition -

Variables : adresse en mémoire + taille Instructions : COP + opérandes

.3 zones en mémoire : -

Code Variables Pile : Utilisée pour les procédures

. Organisations possibles des 3 zones mémoires : -

Mélangées Par segment si le µp les gère => protection

.Squelette d’un programme pour simulateur : .DATA Déclaration des variables et constantes .CODE Ecriture du code .STACK Réservation de place pour la pile . Déclaration des variables et constantes -

-

Définition : . Réservation de place en mémoire pour une variable . Attribution d’un nom Absence de typage :

. Connu seulement par programmeur . Au programmeur d’effectuer les bons traitements -

Manipulation des informations par leur nom (adresse) . Possibilité de manipuler toute la mémoire : variables, instructions . Responsabilité du programmeur

. Déclaration des variables et constantes : -

Variables non initialisées :

-

Variables initialisées : Nom DW Valeur o Valeur : - Convertie en binaire par le compilateur - Types : >> Entier décimal positif ou négatif >> Entier Hexadécimal

Nom

DSW taille (en mots mémoire)

-

>> Entier Binaire >> Caractère ASCII >> Chaine de caractères Une variable = un mot mémoire (sauf pour chaîne)

Ecriture du code -

Désignation des opérandes o Immédiat : Valeur Val o Registre : nom du registre RG o Direct : nom de la variable Var o Indirect : [RG+d]  Déplacement positif : 0 > Sans délimiteur du langage : ‘ « ; , [ ] >> Sans espace >> Caractères accentués possibles >> Terminé par :

-

Instructions de décalage o

Oper : Var, RG, [RG], [RG+d]

o

DEBER : Indicateur de débordement des entiers naturels du registre d’état de l’UT

o

Logique :

o



SHR oper (droite)



SAL oper (gauche) (identique SHL)

Cyclique



ROR oper (droite)



ROL oper (gauche)

-------- Exemples ----------------------------------------------------------------------------------------------------Logique : -droite : SHR -gauche SHL Arithmétique : SAR droite Division puissance 2

Cyclique

Structure de contrôle en langage machine Pb : traduction des structures de contrôle en langage machine Traduites avec les opérations de rupture de séquence conditionnelles ou inconditionnelles Compilateur : réalise cela Contraintes possibles imposées par les langages sur la machine : - vérification des types des variables - interdiction de la modification du code - limitation des structures de contrôle Machine seule : pas de contraintes, tout est possible Action conditionnelle - évaluation de la condition - si faux branchement à instruction associée - effectuer l’opération associée à condition vérifié - effectuer l’opération associée à condition fausse Alternative : - évaluation de la condition - si faux branchement à instruction associée - effectuer l’opération associée à condition vérifiée - branchement après opération pour faux - effectuer l’opération associée à condition fausse Itération : - première opération de la boucle - évaluation de la condition de sortie - branchement si condition de sortie vérifié - autres opérations - branchement à boucle - opération associée à la sortie de la boucle

--------------------------------------------------------------------------------------------------------------------------Exemples : Boucle : ADD x, 2 ; oper A COMP x, y

BEQ sortie NULU x, 2 ; Oper B JMP boucle Sortie : LD R1, x ; Oper C --------------------------------------------------------------------------------------------------------------------------------------

Manipulation d’adresse et pointeurs Pb : Manipulation d’adresse et pointeurs Accès aux variables : - directement : nom  adresse - indirectement : - adresse  pointeur - [Reg] : Reg = registre contenant l’adresse de la variable Intérêt des pointeurs : accès à des variables composées : - enregistrements - tableaux Pointeurs utilisés par systèmes d’exploitation : - processus - fichiers - mémoire - … --------------------------------------------------------------------------------------------------------------------------------------

Exemples : LD R0 ; 25 ST R0 ; Total

 25 => Total

Accès direct par registre

LEA R1, Total  25 => Total LD [R1], 25

Accès indirect

LD R0, var1 ST R0, var2

 var1 => var2

Accès direct par registre

LEA R1, var1 ST [R1], var2

 var1 => var2

Accès indirect

-------------------------------------------------------------------------------------------------------------------------------------Variables composées : Coordonnées d’un point (2entiers) Déclaration de la variable : - coordonnées DSW 2 {x, y} Initialisation à 10, 40 : . LEA R0, coordonnées . LD [R0], 10 . LD [R0+1], 40

[R0]+1  [R0+1] Tableau de 10 entiers Déclaration : Tableau DSW 10 Initialisation à 0 : . LEA R0, Tableau . LD R1, 10 InitTab: . LD [R0], 0 . INC R0 . DEC R1 . CMP R1, 0 . BNE InitTab

Tableaux utilisés par les systèmes d’exploitation : - Eléments : o variables de type enregistrement o certains champs de l’enregistrement pointeurs - Exemple d’élément de tableau pour un processus : o n° du processus : PID o n° de l’utilisateur : UID o adresse de l’instruction à exécuter o tableau de n éléments (sauvegarde registres) - Accès à cet élément par un pointeur : o n+4 pour accéder à l’élément suivant o accès par déplacement : +1 UID, +2 adresses Systèmes d’exploitation : utilisation de structures de données très complexes EX : tableau de pointeurs vers d’autres tableaux…

Principe : -

Morceau de code exécutable a la demande Transmission de paramètres Restitution d’une valeur si besoin

Appel de procédure -

Quitter programme en cours Exécuter procédure Revenir au programme la ou on l’a laissé  Nécessite de conserver l’adresse de retour

Solutions : -

Registre spécial contenant l’adresse de retour :  Pb : impossible d’appeler la procédure dans la procédure

Mémorisation de l’adresse de retour dans une structure de données adéquate : laquelle ?

III/ Programmation avancée

Procédures et fonctions Retour à l’adresse la plus récemment mémorisées  LIFO  PILE Gestion de pile : - Registre spécial SP : - SP : Sommet de pile - 1ere entrée occupée - Réservation de place mémoire pour la pile : - Directive .STACK taille - Fin de code - Initialisation du registre SP sur le début de la pile : - Instruction LEA SP, STACK - En début de code - STACK en majuscule Squelette du programme : .DATA (Déclaration des variables et des constantes .CODE : CO initialisé sur l’instruction qui suit .CODE LEA SP, STACK (Écriture du code) .STACK taille (Réservation de place pour la pile) Rq : possibilité d’utiliser une instruction HLT pour arrêter le processeur en fin de programme Instruction de type rupture de séquence pour les procédures : - Appel : o CALL étiquette o Empile l’adresse de retour  SP  SP- 1  [SP]  CO o Branchement à la procédure ≈ JMP étiquette - Retour : o RET o Dépile l’adresse de retour  CO  [SP]  SP SP + 1 Exemple : c’est une pile que l’on dépile grâce à cette instruction, SP – 1 on revient en arrière. Inconvénients liés aux procédures : - Double accès aux registres de la machine et aux registrer de variables globales : o Depuis le programme o Depuis les procédures - Danger : modification par la procédure d’un registre utilisé par le programme qui l’appelle  Perte de données - Solution 1 : o Utiliser des registrer différents : procédures/programmes

Difficile :  Nombre limité de registres  Certains registres spécialisés pour instructions  Appel de procédures écrites par d’autres (primitives du système d’exploitation) Solution 2 : o Sauvegarder les registres en début de procédures e les restituer à la fin o Hypothèse : sauvegarder dans des variables  Trop de variables  Impossible de s’assurer que chaque procédure utilise des variables différentes  Interdit la récursivité  Impossible o Conclusion : utilisation de la pile pour sauvegarder les registres  Début de procédure : empilage des registres  Fin de la procédure : dépilage des registres o

-

Instructions : - Empiler : o PUSH oper : empiler oper o Réalise :  SP  SP – 1  [SP]  oper - Dépiler : o PULL oper : dépiler oper o Réalise :  Oper  [SP]  SP  SP + 1 - Oper : Var, RG, [RG], [RG +1] Nécessité de prévoir une taille de pile suffisante pour : - Nécessité de prévoir une taille de pile suffisante pour : o Stocker les adresses de retour o Stocker les sauvegarder de registres Pour certains microprocesseurs : - existence d’instructions pour empiler et dépiler tous les registres - en pratique inutile : aucune procédure n’utilise tous les registres Variable locale des langages de programmation : - utilisation de la pile - mécanisme : o début de procédure Réservation d’espace mémoire dans la pile pour ces variables o fin de procédure Libération de cet espace Passage de paramètre à une procédure dans les langages habituels : - par valeur : o en entrée o pas de possibilité de modification

-

par référence : o en entrée et en sortie o possibilité de modification Ici étude de passage de paramètre en langage machine Passage de paramètres par valeur : - Avant l’appel de la procédure : valeur placée dans un registre o Utilisation du registre par la procédure : modification possible du registre mais valeur du paramètre inchangée o Exemple LD R0, param CALL calcul - Avant l’appel de la procédure : valeur placée dans la pile o Utilisation de la pile par la procédure : modification possible de la pile mais valeur du paramètre inchangée o Exemple : PUSH param CALL calcul Passage de paramètre par référence : - avant l’appel de la procédure : adresse du paramètre placée dans un registre o procédure : accès au paramètre par indirection o exemple : LEA R0, param CALL calcul - avant l’appel de la procédure : valeur placée dans la pile o utilisation de la pile par la procédure o exemple : LEA R0, param PUSH R0 CALL calcul Passage de paramètre à une procédure en langage machine : - par registre : o plus rapide o limité en nombre et en taille des registres - par pile : o pas de limite en nombre et en taille o utilisée par les compilateurs Retour de la valeur d’une fonction : retour d’une unique valeur  Différent du cas des procédures - utilisation d’un registre : plus simple - (pile : plus compliquée pas rentables pour une seule valeur) Utilisation de l’instruction : RET n - retour avec vidage de la pile de n mots - réalise : o CO  [SP] RET classique o SP  SP + 1 o SP  SP + n

Exemple : Fonction calcul (a,b) ; a +2b Programme : a  a + 2b

1) Passage par valeur Par le registre : A  R0 B  R1 Retourner la valeur par R0 Programme : LD R0, a LD R1, b CALL calcul ST RD, a Fonction : Calcul : ADD R0, R1 ADD R0, R1

R0  RO + R1 R0  R0 + R1

Par la pile : Programme : PUSH a PUSH b CALL calcul ST R0, a Etat de la pile au début de la fonction SP  adresse Valeur b Valeur Fonction : Calcul : LD R0, [SP + 2] R0  a ADD R0, [SP + 1] R0  R0 + b ADD R0, [SP + 1] RET 2 Etat de la pile à la fin de la fonction SP  b a Danger de débordement : 2 solutions ADD SP, 2 après la fonction RET n

2) Passage par référence

Par registre : Adresse de a dans R0 B dans R1 Programme : LEA R0, a : adresse de a dans R0 LD R1, b CALC calcul Fonction : Calcul ADD [R0], R1 ADD [R0], R1 RET Directement le résultat dans a Par Pile : Adresse de a dans R0, Programme : LEA R0, a PUSH R0 PUSH R0 CALL calcul Fonction : Calcul : LD R0, [SP+2] ADD [R0], [SP+1] ADD [R0], [SP+1] RET 2

Etat de la pile à l’appel de la procédure SP Adresse de retour

Valeur de b Valeur de a

Fonction ne retourne rien car elle modifie directement la variable.  R0 ne devait pas être modifié Sauvegarde de R0 Nouvelle version : Calcul : PUSH LD ADD ADD PULL RET

R0 R0, [SP+2] [R0], [SP+2] [R0], [SP+2] R0 2

Sauvegarde de R0 Adresse de retour Valeur de b Valeur de a

Solution : ne plus utiliser SP pour accéder la pile mais une copie de SP faite en début de la fonction avant de sauvegarder les registres. Ex : ici SP copié dans R6. Calcul :

LD PUSH LD ADD ADD PULL RET

R6, SP R0 R0, [R6+2] [R0], [R6+1] [R0], [R6+1] R0 2

Pb : sauvegarder R6

VERSION FINALE : Calcul : PUSH LD PUSH LD ADD ADD PULL PULL RET

R6 R6, SP R0 R0, [R6+3] R0, [R6+2] R0, [R6+2] R0 R6 2

RO R6 Adresse de retour Valeur de b Adresse de a Pile

Entrées/Sorties

-

Unité d’échange (UE) : constituée de contrôleurs de périphériques Contrôleur : o Pilote un ou plusieurs périphériques o Deux visions : ensemble de registres appelés PORTS qui sont accessibles par des instructions spéciales mots en mémoire avec une adresse

UE : - registres de contrôles : pilotage des périphériques - registres d’état : surveillance de périphériques - registres de données : communication avec les périphériques -

-

UE DU SIMULATEUR : 8 registres de 8 bits correspondant au n° de ports 0 à 7 UE : o Connaître l’état des touches o Dessiner ou écrire dans la fenêtre graphique du périphérique o Détecter les mouvements et les clics de souris dans la zone graphique de l’écran du périphérique 2 instructions : o IN oper, port ;oper : octet du registre de l’UE désigné par son n° o OUT oper, port ;oper : octet du registre de l’UE désigné par son n°

Simulateur : -

Clavier : o Port 0 = registre d’état et de données

État du clavier Bit7 Bit6 o

Bit5

Numéro de la touche Bit4 Bit3 Bit2 Bit1

État du clavier :  Action qui a lieu sir le clavier depuis la dernière fois que le port0 a été lu  Lecture du port0 => remise à 0 de B7 – B6 00 Aucune action 01 Une touche appuyée 10 Une touche relâchée 

B7 : une action ? b6 : laquelle ?

Simulateur : -

Clavier : o Numéro de la touche sur B5 – B0

-

Souris : o

o

-

Port 0 pour l'état 

appui sur le bouton souris = appui touche n°7



remise à 0 après lecture de son contenu

Port 6 à 7 pour les données 

en permanence les coordonnées de la souris



en X : port 6, en Y : port 7

Écran o

port 1 - 5 

port 1 à 4 : registre de donnée paramètre de l'opération à exécuter



port5 registre de commande

Bit0

opération a exécuter

couleur du tracé bit 7
...