Architecture des Ordinateurs, corrig e TD 4

Machines de Turing
Exercice 1. Ecrire le programme qui additionne 1 ` a toute conguration binaire en rempla cant la s equence initiale par le r esultat. Correction. Lid ee est de lire la s equence initiale de gauche a ` droite, puis a ` partir du dernier bit de poids faible) de revenir vers la gauche en changeant tous les 1 en 0 (propagation de la retenue) jusquau premier 0 rencontr e quon change en 1 avant de sarr eter. Si on revient ainsi au d ebut de la s equence au bit de poids fort il peut etre n ecessaire d ecrire un 1 a ` gauche de la s equence (propagation de la retenue) avant de sarr eter. Par exemple : 1011 + 1 ____ 1100 On voit que lobtention du r esultat consiste a ` inverser les 1 et les 0 de droite a ` gauche jusquau troisi` eme bit (premier 0 rencontr e en allant de droite a ` gauche). Le programme est le suivant : q0 1 q0 0 q0 b q1 0 q1 1 q1 b q0 1D q0 0D q1 bG qF 1 q1 0G qF b : lecture du nombre : de gauche a ` droite : le bit de poids faible vaut 0 : propagation de la retenue

Exercice 2. Ecrire le programme qui eectue le compl ement ` a deux dune conguration binaire en rempla cant la s equence initiale par le r esultat. Correction. Puisque le compl ement a ` deux dune conguration binaire sexprime comme lajout de 1 au compl ement a ` un de cette conguration, il sut dappliquer le programme ecrit dans lexercice pr ec edent au compl ement a ` un de la conguration dentr ee. Pour calculer le compl ement a ` un dun nombre, on commute les 1 et les 0 de ce nombre ; or cette op eration peut etre eectu ee d` es la lecture du nombre de gauche a ` droite par la t ete de lecture- ecriture. Autrement dit, il sut de modier l eg` erement les deux premi` eres r` egles du programme de lexercice pr ecedent pour obtenir le programme recherch e: q0 1 q0 0 q0 b q1 0 q1 1 q1 b q0 0D q0 1D q1 bG qF 1 q1 0G qF b : lecture du nombre et inversion : de gauche a ` droite : le bit de poids faible vaut 0 : propagation de la retenue

Exercice 3. Soit = {0, 1}, = {0, 1}, Q = {q0 , q1 , q2 , q3 , qY , qN }. Que fait le programme suivant : q0 0 q0 0D q0 1 q0 1D q0 b q1 bG q1 0 q2 bG q1 1 q3 bG q1 b qN bG q2 0 qY bG q2 1 qN bG q2 b qN bG q3 0 qN bG q3 1 qN bG q3 b qN bG

Remarque : 0, 1, repr esentant les symboles du calcul binaire, qY est un etat nal dacceptation, qN , un etat nal de rejet. Conseil : Tester sur les s equences 10100 et 110. Correction. Trace sur 10100 :
b b b b b b 1 0 1 0 0 b

Ce programme teste la divisibilit e par 4 dune conguration binaire et renvoie comme s equence de sortie le quotient de cette division. 10100 est divisible par 4 : la s equence se termine par deux 0, lex ecution du programme sarr ete dans l etat qY . En outre, le programme eace les deux derniers z eros de la s equence dentr ee, donnant ainsi le quotient de la division. 110 nest pas divisible par 4 : lex ecution du programme sarr ete dans l etat qN . Exercice 4. (optionnel) Ecrire un programme qui duplique une s equence de 1. Donner sa repr esentation sous forme de graphe d etats nis. Conseil : 1. Commencer par un programme qui duplique un seul 1. 2. Passer au cas g en eral : si n ecessaire, penser ` a la possibilit e de se munir dun caract` ere suppl ementaire sur la bande.

Correction. Le programme qui duplique un seul 1 est el ementaire a priori : q0 1 q0 1D q0 b q1 bD q1 b qF 1 La copie de plusieurs 1 appara t plus dicile. . .Une premi` ere approche, naive, consiste a ` essayer de compter les 1 de la s equence initiale pour en faire une copie de m eme longueur. On peut ainsi envisager de copier n fois le caract` ere 1 avec une machine a ` n etats : chaque etat sert a ` compter un 1 de la s equence : l etat q0 permet de compter le premier 1, l etat q1 , le second 1 et ainsi de suite jusquau n-i` eme 1. Mais dune part, cela revient a ` ecrire un programme par s equence de 1 de longueur di erente ce qui est peu el egant, et dautre part, par hypoth` ese, le nombre d etats ne doit pas cro tre ind eniment. On doit donc trouver une m ethode pour copier une suite sans avoir a ` compter ses el ements. Lid ee est de placer un marqueur qui parcourt la s equence initiale de gauche a ` droite pour m emoriser lemplacement de la case en cours de duplication sur le ruban. Le marqueur en question est, par exemple, le caract` ere qui va prendre successivement la place de chaque 1 dans la s equence initiale. A chaque pas du marqueur dune case a ` la case suivante, les instructions disent a ` la t ete de lecture ecriture daller a ` la derni` ere case de la s equence, de sauter la case qui contient le caract` ere b de d elimitation, de sauter les caract` eres 1 d ej` a recopi es, puis de transformer le prochain b rencontr e en 1. Si la t ete de lecture- ecriture eectue cette op eration autant de fois que le marqueur avance dune case, il en r esulte une nouvelle suite de n 1 ecrite imm ediatement apr` es la premi` ere, et s epar ee de celle-ci par le caract` ere blanc (b). 1. Un seul caract` ere 1 en entr ee : q0 1 q1 D q1 b q2 bD q2 b q3 1G q3 b q3 bG q3 q0 1D q0 b qF b 3

On obtient la trace suivante :

b b 1 b b

Etape 1 : la t ete lit le caract` ere 1, le remplace par 0 (marqueur), et se d eplace vers la droite. Etape 2 : la t ete lit le caract` ere b et se d eplace vers la droite. Etape 3 : la t ete lit le caract` ere b, le remplace par 1, et se d eplace vers la gauche. Etape 4 : la t ete lit le caract` ere b et se d eplace vers la droite. Etape 5 : la t ete lit le caract` ere 0 (marqueur), le remplace par 1, et se d eplace vers la gauche. Etape 6 : la t ete lit le caract` ere b et sarr ete. Le graphe d etats nis correspondant au programme est :

b qF

b q0 1 G b * q3

1 D

* q1 b

G b G 1 b

D q2

2. Cas g en eral : q0 1 q1 D q1 1 q1 1D : nouvelle r` egle q1 b q2 bD q2 b q3 1G q2 1 q2 1D : nouvelle r` egle q3 1 q3 1G : nouvelle r` egle q3 b q3 bG q3 q0 1D q0 b qF b 4

Le graphe d etats nis compl et e est :

1 b qF b q0 1 G b * 1 G 1 q3 1 G b G b 1 D q2 b 1 D 1 D * q1 b D 1

Exercice 5. (optionnel) A partir du programme de r eplication con cu dans lexercice , concevoir un programme qui eectue la multiplication dune s equence de 1 par une autre. Correction. Soit a ` multiplier 111 par 11, on va r epliquer trois fois la s equence 11 pour obtenir 111111. On lit donc la premi` ere s equence et on r eplique la seconde en faisant appel au sous-programme vu dans lexercice pr ec edent. La lecture de la premi` ere s equence se fait en utilisant un marqueur (par exemple # 1 ) quon d eplace au fur et a ` mesure de gauche a ` droite avec, a ` chaque d eplacement du marqueur, duplication de la seconde s equence. On peut commencer par traiter le cas simple de la multiplication de la s equence 1 par 11. Le programme complet est ecrit de la fa con suivante : on conserve les etats du programme de lexercice pr ec edent, et on ajoute ). de nouveaux etats q (par exemple l etat de d epart est maintenant q0
1 q0 1 q1 b q1 1 q2

. . .

#D q1 1D q1 bD q2 q0 1

: initialisation du marqueur : lecture de la 1` ere s equence : passage au sous-programme de r eplication : retour du sous-programme de r eplication : qF nest plus un etat nal : d eplacement du marqueur : nouvel etat nal

q0 b qF 1 qF # # q0 b q0

qF bG qF 1G # q0 1D q0 qF

On peut aussi choisir de r eutiliser le marqueur * dans la mesure o` u il ny a pas ici de risque de confusion avec son utilisation dans le sous-programme.

Machines RAM
Exercice 6. Pour chacune des instructions C++ suivantes, ecrire un programme qui la simule sur la machine RAM : 1. A = 1 ; 2. A = A + 10 ; 3. A = A + B ; Remarque : les variables A et B sont suppos ees rang ees respectivement aux adresses 0 et 1 de la m emoire. Le contenu de la variable B nest pas suppos e etre d etruit apr` es ex ecution de linstruction A = A + B ; Correction. Les programmes qui simulent les instructions C++ donn ees sont respectivement : 1. Pour A = 1 ; : LOAD# 1 ; STORE@ 0 ; 2. Pour A = A + 10 ; : il sagit dincr ementer dix fois laccumulateur avant de ranger enn la valeur obtenue a ` ladresse 0 de la m emoire ; il est donc n ecessaire de se munir dun compteur, quon range (par exemple) a ` ladresse 2 de la m emoire, et qui sera d ecr ement e dautant de fois que laccumulateur sera incr ement e dans une boucle pour obtenir la valeur nale de A. LOAD# 10 ; STORE@ 2 ; LOAD@ 0 ; INCR ; STORE@ 0 ; LOAD@ 2 ; DECR ; JZ FIN ; STORE@ 2 ; JUMP ADD ; HALT ;

ADD :

FIN :

En remarquant quil est possible de factoriser linstruction STORE@ 2 ; pr esente simultan ement avant lentr ee et en n de boucle, on obtient un programme l eg` erement plus court (mais pas plus rapide en ex ecution) :

ADD :

FIN :

LOAD# 10 ; STORE@ 2 ; LOAD# 1 ; INCR ; STORE@ 0 ; LOAD@ 2 ; DECR ; JZ FIN ; JUMP ADD ; HALT ;

3. Pour A = A + B ; : On proc` ede comme pour le programme pr ec edent, a ` ceci pr` es que cest la valeur de B qui sert de valeur initiale a ` un compteur ind ependant (n ecessaire pour ne pas d etruire la donn ee B), rang ea ` ladresse 2 de la m emoire. Il est alors n ecessaire de tester si B est strictement positif (A sera incr ement e), egal a ` z ero (A nest pas modi e), ou strictement n egatif (A sera d ecr ement e). LOAD@ 1 ; JZ INFEQZ ; STORE@ 2 ; LOAD@ 0 ; INCR ; STORE@ 0 ; LOAD@ 2 ; DECR ; JZ FIN ; JUMP SUPZ ; INCR ; JZ INFZ ; JUMP FIN ; STORE@ 2 ; LOAD@ 0 ; DECR ; STORE@ 0 ; LOAD@ 2 ; INCR ; JZ INFZ ; HALT ;

SUPZ :

INFEQZ :

INFZ :

FIN :

Exercice 7. Ecrire un programme qui etant donn e un entier rang e dans la m emoire a ladresse 0, calcule sa valeur absolue et la range ` ` a la m eme adresse. Correction. La question a ` poser au d ebut du programme est de savoir si lentier rang e a ` ladresse 0 est sup erieur ou egal a ` z ero : si cest le cas, le programme sarr etera imm ediatement ; sinon, et puisquil sagit dun entier inf erieur a ` z ero, on se munit dun compteur initialis ea ` z ero et incr ement e simultan ement au contenu de ladresse 0 jusqu` a ce que celui-ci atteigne la valeur z ero. Le compteur contient alors la valeur absolue de lentier initial et il sut de recopier sa valeur a ` ladresse 0. Il y a toutefois une dicult e technique suppl ementaire, due au fait que le jeu dinstruc7

tions dont on dispose ne permet pas de tester si un entier est sup erieur ou egal a ` z ero (ou, dualement, strictement inf erieur a ` z ero), mais seulement sil est inf erieur ou egal a ` z ero. Pour cette raison, il est n ecessaire dincr ementer le compteur au del` a de z ero (cest a ` dire jusqu` a un) et il faudra donc le d ecr ementer une fois avant de ranger sa valeur a ` ladresse 0. LOAD# 0 ; STORE@ 1 ; LOAD@ 0 ; JZ INFEQZ ; HALT ; LOAD@ 1 ; INCR ; STORE@ 1 ; LOAD@ 0 ; INCR ; STORE@ 0 ; JZ INFEQZ ; LOAD@ 1 ; DECR ; STORE@ 0 ; JUMP FIN ;

FIN : INFEQZ :

Bien s ur, une autre solution est alors dinitialiser le compteur a ` 1, de fa con a ` eviter davoir a ` le d ecr ementer une fois en plus a ` la n du programme. On obtient alors : LOAD# -1 ; STORE@ 1 ; LOAD@ 0 ; JZ INFEQZ ; HALT ; LOAD@ 1 ; INCR ; STORE@ 1 ; LOAD@ 0 ; INCR ; STORE@ 0 ; JZ INFEQZ ; LOAD@ 1 ; STORE@ 0 ; JUMP FIN ;

FIN : INFEQZ :