INF2171 Organisation des ordinateurs et assembleur
CORRIGÉ
Examen
Final (25%) Eté 2020
Présenté le vendredi 14 août 9h30.
A remettre le vendredi 14 août 23h59 dans Moodle.
En cas de doute, un test oral sera exigé.
Aucune question ne sera répondue par le professeur ou par les démonstrateurs.
Veuillez créer un document bloc-notes (NOTEPAD) appelé "final.txt" et répondre aux 4 questions suivantes:
Chapitre 9.1 Les sous-programmes
Chapitre 9.2 Les paramètres des sous-programmes
Chapitre 9.3.1 Adressage sur la pile (S)
Chapitre 9.3.2 Adressage indexé sur la pile (SX et SF)
Chapitre 9.3.4 Adressage indirect indexé sur la pile (SXF)
Chapitre 9.4 Réalisation du passage de paramètres
Chapitre 9.5 Conventions d’utilisation des registres
Question 1)
Le programme "NOMBRES" suivant lit des nombres et appelle un sous-programme pour
en faire la sommation.
Cependant l'auteur du programme a été négligent et n'a pas documenté le
sous-programme SOMME.
On vous demande d'ajouter les commentaires explicatifs manquants à chaque
ligne du sous-programme (18 lignes).
Bien que le programme "NOMBRES" ne soit pas selon les règles de l'art,
vous ne devez pas le modifier.
; programme qui lit des nombres dans un tableau
; et qui appelle le sous-programme SOMME pour en faire la sommation
;
; Les débordements n'ont pas à être traités.
NOMBRES: LDX 0,i
lecture: DECI tableau,x ; lecture d'un nombre
BREQ finlire ; arrêt si zéro
ADDX 2,i ; nombre suivant
BR lecture
;
finlire: LDA tableau,i ; adresse du tableau
STA -4,s
ASRX ; nombre d'éléments du tableau
STX -2,s
SUBSP 4,i ; allouer espace sur la pile
CALL SOMME ; appel au sous-programme pour effectuer la sommation
DECO 0,s ; somme
ADDSP 2,i ; libérer espace sur la pile
STOP
;
SOMME: SUBSP 2,i ; allouer de l'espace sur la pile pour conserver le TOTAL
LDA 0,i ; A <- 0
STA 0,s ; initialiser le TOTAL à zéro
LDX 0,i ; X <- 0
addition:LDA 0,s ; récupérer le TOTAL
ADDA 4,sxf ; additionner un nombre du tableau
ADDX 2,i ; nombre suivant
STA 0,s ; sauver le TOTAL
LDA 6,s ; récupérer le nombre d'éléments du tableau
SUBA 1,i ; un de moins
STA 6,s ; nombre d'éléments restant conservé
BRGT addition ; si le nombre d'éléments restant est > 0, on additionne de nouveau
LDA 0,s ; le TOTAL est terminé, on le récupère
STA 6,s ; on sauve le TOTAL en bas de la pile pour le retourner au programme principal
LDA 2,s ; récupérer l'adresse de retour
STA 4,s ; copier au-dessus du TOTAL à retourner
ADDSP 4,i ; libérer la pile des 4 octets maintenant superflus
RET0 ; retour au programme principal
;
tableau: .BLOCK 0
.END
On vous demande de modifier légèrement le programme LISTET
afin de réduire le maillon à sa taille réelle.
ex: pour l'input: "salut", le texte n'occupe que 6 caractères incluant le "ENTREE"
au lieu de 999.
; Programme qui manipule une liste chaînée
; Jean Privat (c) 2010
;
; ; // Lit la liste (à l'envers)
LISTET: LDA heap,i ; ADDRSS heap
STA hpPtr,d
;
LDA 5,i
STA cpt,d
loop_in: CPA 0,i
BRLE out ; for(cpt=5; cpt>0; cpt--) {
LDA mLength,i
CALL new ; X = new Maillon(); #mVal #mNext
STX début,d
lecture: CHARI mVal,x ; X.val = getInt();
LDA 0,i
LDBYTEA mVal,x ; lecture de la ligne caractère par caractère
CPA "\n",i
BREQ finlire
ADDX 1,i
BR lecture
;----------------------------------------------------------------------------------------------- finlire: ADDX 3,i ; prochain octet disponible sur le heap <---------------------- STX hpPtr,d ; ajustement du pointeur du heap <---------------------- ;----------------------------------------------------------------------------------------------- LDA head,d LDX début,d ; début du maillon STA mNext,x ; X.next = head; STX head,d ; head = X; LDA cpt,d SUBA 1,i STA cpt,d BR loop_in ; } // fin for ; ; ; // Affiche la liste out: LDX head,d loop_out:CPX 0,i BREQ fin ; for (X=head; X!=null; X=X.next) { STX début,d affiche: LDA 0,i LDBYTEA mVal,x CPA "\n",i BREQ finaffic CHARO mVal,x ; affichage de la ligne caractère par caractère ADDX 1,i BR affiche finaffic:LDX début,d LDX mNext,x CHARO "\n",i BR loop_out ; } // fin for fin: STOP head: .BLOCK 2 ; #2h tête de liste (null (aka 0) si liste vide) cpt: .BLOCK 2 ; #2d compteur de boucle début: .BLOCK 2 ; #2h adresse du début du maillon ; ;******* Structure de liste d'entiers ; Une liste est constituée d'une chaîne de maillons. ; Chaque maillon contient une valeur et l'adresse du maillon suivant ; La fin de la liste est marquée arbitrairement par l'adresse 0 mNext: .EQUATE 0 ; #2h maillon suivant (null (aka 0) pour fin de liste) mVal: .EQUATE 2 ; #1h999a valeur de l'élément dans le maillon mLength: .EQUATE 1001 ; taille d'un maillon en octets ; ; ;******* operator new ; Precondition: A contains number of bytes ; Postcondition: X contains pointer to bytes new: LDX hpPtr,d ;returned pointer ADDA hpPtr,d ;allocate from heap STA hpPtr,d ;update hpPtr RET0 hpPtr: .BLOCK 2 ;#2h ADDRSS heap (address of next free byte) heap: .BLOCK 1 ;first byte in the heap .END
Chapitre 10. Programmes et sous-programmes : documentation (FACTURE)
Question 3)
Si vous
aviez à modifier le programme FACTURE pour y ajouter le traitement #8,
expliquez-moi en bon français,
sans effectuer le travail de
programmation,
quelles seraient les modifications que vous devriez y apporter.
coût du traitement #8: 50$ plus 0.10$ la minute pour les 2 premières heures et 0.05$ la minute pour les minutes excédant des 2 premières heures
Voici, en bon français, la recette à appliquer au programme FACTURE:
- il faut accepter le traitement #8: changer dans la vérification des types, la limite de type 6 à type 8
- il faut ajouter l'adresse des traitements #7 et #8 dans le tableau des cas "TabCas"
afin d'envoyer le traitement #7 vers l'étiquette Others
et le traitement #8 vers un nouveau paragraphe appelé Cas8
- il faut ajouter le nouveau paragraphe Cas8 après le Cas6
- si la durée est <=8 (quarts d'heures) alors
mettre 150 sur la pile ($0.10 la minute soit $1.50 pour 15 minutes)
mettre la durée sur la pile
appeler la multiplication une seule fois
récupérer le produit
additionner le montant fixe de 5000 (50$)
désempiler le résultat de la multiplication
continuer à la fin du Cas8
continuer à la fin des Cas
- sinon la durée est >8 (quarts d'heures) alors
mettre 75 sur la pile ($0.05 la minute soit $0.75 pour 15 minutes)
mettre (la durée - 8) sur la pile
appeler la multiplication une seule fois
récupérer le produit
additionner 6200 (62$), soit 1200 (12$) pour les 8 premiers quarts d'heures (0.10 * 120 minutes)
et le montant fixe de 5000 (50$)
désempiler le résultat de la multiplication
continuer à la fin du Cas8
continuer à la fin des Cas
Chapitres 12.4 et 12.5. Interruptions de PEP8
Question 4)
Parmi les 2 programmes suivants, lequel serait le plus rapide d'exécution ? Justifiez votre choix ?
programme 1:
;
CHARO "B",i
CHARO "o",i
CHARO "n",i
CHARO "j",i
CHARO "o",i
CHARO "u",i
CHARO "r",i
;
STOP
;
.END
programme 2:
;
STRO bonjour,d
;
STOP
;
bonjour: .ASCII "Bonjour\x00"
.END
Le programme 1 est "considérablement" plus rapide que le programme 2 car il ne nécessite que 7 instructions
au lieu d'une centaine faites par une boucle avec STRO.L'instruction STRO n'est pas une instruction simple mais plutôt une "interruption de sortie de chaîne".
Une interruption PEP8 se trouve dans le système d'exploitation PEP8.
Celle-ci doit en autre, copier l'environnement, analyser l'instruction STRO,
l'exécuter en affichant dans une boucle les caractères un par un ,
pour finalement, restaurer l'environnement et retourner à l'instruction STRO.
Vous avez un seul document à déposer dans Moodle à la semaine 15 avant le vendredi 14 août 23h59.
-> final.txt