Discussion :

[bipbip2006]

Bonjour à tous.
Je suis inscrit au cours en FOD d'architecture des systèmes d'information au cnam et j'avoue que je ne m'attendais pas à toucher de l'assembleur... Bref
Je colle méchant sur une série d'exercice, et j'aimerai avoir des éclaircissements...
Voici l'énoncé :

Une machine fonctionne avec les caractéristiques suivantes :

- adresse mémoire et mot mémoire ont une taille de 2 octets,
- la mémoire lit ou écrit 1 seul mot à la fois,
- un seul cpu est disponible dans cette machine,
- une instruction machine est toujours constituée :
- d'un code opération (opcode) de 1 octet,
- d'opérandes qui sont dans cet exercice des adresses en mémoire.

Je suppose que le fait qu'un seul CPU soit présent est pour éviter de se prendre trop la tête sur certaines choses...
Voici l'exercice 1
Exemple d'instruction et mnémonique :
mult X, Y, Z # Z = X * Y
add X, Y, Z # Z = X + Y
Soit
mult B, C, A
add D, A, A
1.a/ Donner la taille en octet de ce programme.
Je dirai 14 octets, 1 octet pour chaque opérande (mult et add) et 12 pour les autres mots (sachant que chaque mots est codés sur 2 octets)

1.b/ Donner le nombre d'octets échangés avec la mémoire pour
exécuter ce programme.
J'avoue que je ne sais pas trop, je dirai (un peu au pif) 4
Pourquoi, on multiplie b et c que l'on met dans A (on écrit donc 2 octets) et on additionne D et A que l'on place dans A (donc 2 octets de plus)
Ce qui me perturbe un peu, c'est que l'on ne lit à aucun moment des informations (me semble s'il)...
J'espère qu'une âme charitable passera par là pour confirmer (ou pas) ma pensée...

[Obsidian]

Mouais, c'est ce qui se passe parfois quand on essaie de simplifier. On fait encore plus obscur.

1.a/ Donner la taille en octet de ce programme.
Je dirai 14 octets, 1 octet pour chaque opérande (mult et add) et 12 pour les autres mots (sachant que chaque mots est codés sur 2 octets)

C'est ce que je dirais également.

1.b/ Donner le nombre d'octets échangés avec la mémoire pour
exécuter ce programme.
J'avoue que je ne sais pas trop, je dirai (un peu au pif) 4

Là, non, par contre. :-)

Pourquoi, on multiplie b et c que l'on met dans A (on écrit donc 2 octets) et on additionne D et A que l'on place dans A (donc 2 octets de plus)

Oui, mais B, C et D, il faut bien aller lire leur valeur en mémoire pour mener une opération dessus ! C'est là que l'on met en évidence que la RAM fonctionne en read/write.

Maintenant, pourquoi lit-on A pour réécrire dedans dans la même opération ? C'est ce qu'on appelle un accumulateur : c'est le même registre qui sert d'opérande à ton calcul et qui en reçoit le cumul. L'écran d'une calculatrice 4 opérations peut être considéré comme un accu lui aussi : il affiche toujours le résultat de la dernière opération, lequel peut immédiatement servir de paramètre à l'opération suivante.

Ce qui me perturbe un peu, c'est que l'on ne lit à aucun moment des informations (me semble s'il)...
J'espère qu'une âme charitable passera par là pour confirmer (ou pas) ma pensée...

Si, si. La clé du mystère se trouve dans :

- d'opérandes qui sont dans cet exercice des adresses en mémoire.

Donc, les opérandes A, B, C et D de tes instructions représentent toutes des adresses en mémoire. Autrement dit : des pointeurs. On considère que tu passes trois paramètres à chacune de tes instructions, les deux premiers étant les adresses des deux nombres à lire, et la troisième étant celle où il faut déposer le résultat.

J'ajoute que c'est un assembleur très abstrait. Il est très rare de trouver, en pratique, des processeurs dont les instructions attendent directement trois pointeurs. En général, tu dois au moins passer par un des registres du processeur, qui servent précisément à cela.

[Obsidian]

Une précision supplémentaire :

Je dirai 14 octets, 1 octet pour chaque opérande (mult et add) et 12 pour les autres mots (sachant que chaque mots est codés sur 2 octets)

Les « opérandes » sont les paramètres d'une opération. Donc, ici, l'instruction est MULT ou ADD (on pourrait même parler de commande) et les opérandes sont tes fameuses adresses A, B, C et D.

[bipbip2006]

Merci beaucoup, j'avais effectivement un gros doute sur la dernière question.
Si je comprends bien, la réponse à la dernière question est 12.
Détail de mon calcul
On lit 2*2 octets, et on écrit 2 octets pour chaque instructions.
Concernant les accu, est t-il juste de dire qu'en c, dans l'instruction x=x+y, x est t-il un accumulateur également ?
Merci de me corriger éventuellement

[Obsidian]

Si je comprends bien, la réponse à la dernière question est 12. Détail de mon calcul : On lit 2*2 octets, et on écrit 2 octets pour chaque instructions.

C'est comme ça que je le vois aussi. Je peux me tromper également.

Concernant les accu, est t-il juste de dire qu'en c, dans l'instruction x=x+y, x est t-il un accumulateur également ? Merci de me corriger éventuellement

Oui, mais on utilise surtout le terme quand on définit à l'avance un terme ou une ressource dédiée à ce genre de tâche. Dans une équation toute seule, beaucoup moins puisque l'on n'a pas spécifiquement besoin d'un accumulateur pour la mener à bien.

[bipbip2006]

Ok, merci beaucoup

[Obsidian]

Ok, merci beaucoup

Attention il y a probablement un piège : le programme a bien lu ou écrit 12 octets en tout, mais il faut probablement ajouter la lecture des codes-opérations eux-mêmes (soit les 14 octets).

[Belgitaes]

je dit peut etre une betise mais cela est comme cela que je le voit moi

Instructions arithmétiques

MUL ; Multiply unsigned
Multiplie deux registre l'un avec l'autre, sans signe

ADD
Ajoute deux enregistrements sans tenir en compte le carry .
(operando1 = operando1 + operando2). Operando2 reste intact après l'opération.

adresse mémoire = +00000000:
mot mémoire = FFFF

+00000000: FFFF
+00000001: FFFF
+00000002: FFFF

mult X, Y, Z # Z = X * Y ;(X=1 Octet +Y= 1 Octet, Z= 2 Octet )le resultat dans = 2 Octets
add X, Y, Z # Z = X + Y ;Z = X + Y( Z= 2 Octets +(X + Y= 1 Octet) le resultat dans = 2 Octets

Voici l'exercice 1

instruction et mnémonique = 9D9F et 0FE9
adresse mémoire et mot mémoire ont une taille de 2 octets = 0001 et 0002

MUL R25,R15 ; 0001 9D9F ;Multiplie deux registre l'un avec l'autre, sans signe
ADD R30,R25 ; 0002 0FE9 ;Ajoute deux enregistrements sans tenir en compte le carry .

1.a/ Donner la taille en octet de ce programme.= 8 Octets
1.b/ Donner le nombre d'octets échangés avec la mémoire pour exécuter ce programme.= 4 Octets

j´espere que tu nous donneras bien la solucion quand ton prof l´auras corrigié

[bipbip2006]

Bonjour à tous.
Le professeur m'a donné le corrigé, et j'avoue que j'ai mis un moment à comprendre tout bien clair....
Pour la première partie, il s'agissait bien de 14, voici le corrigé (copier coller) du professeur.
1.a/ Donner la taille en octet de ce programme.

Pour chaque instruction de cette première question, il faut :
- relire l'énoncé, ce qui donne :
- 1 octet pour coder le code opération
- 2 octets pour coder l'adresse d'un opérande
et comme 3 opérandes sont présents par instruction, on obtient :
1 + 2 + 2 + 2 = 7 octets pour chaque instruction.

La taille totale du programme est donc de : (2 * 7) = 14 octets.
Pour la partie B, j'avoue que ça été plus rude pour ma part pour tout comprendre

Il faut commencer par LIRE l'instruction en mémoire...
PUIS LIRE les opérandes de cette instruction
PUIS ECRIRE le résultat en mémoire.

Puisque la mémoire ne sait lire ou écrire qu'un mot de 2 octets
à la fois, cette mémoire va délivrer 2 octets lors de la lecture
du code opération (opcode) : un octet utile et un octet inutile.
La pour ma part, je n'avais déjà pas compris que la mémoire devait lire 2 octets à la fois (et non pas 1)
Mais j'avoue que la suite à encore été plus rude à comprendre....
Je cite :
Après la lecture du code opération (2 octets), il faut ensuite lire
chacun des 3 opérandes (2 octets à chaque fois).

La lecture d'UNE instruction et de ses 3 opérandes nécessite donc
un transfert de : (1 * 2) + (3 * 2) = 8 octets depuis la mémoire.


Mais ce n'est pas fini !!


Un opérande est (dans cet exercice) une adresse en mémoire...
Ou encore un pointeur vers une donnée.

Il faut donc ensuite demander à lire la valeur de cet opérande
en mémoire pour pouvoir exécuter l'instruction.
- l'accès aux valeurs des 2 opérandes de l'instruction nécessite donc
un transfert de : (2 * 2) = 4 octets,
- puis l'instruction est exécutée,
- et l'écriture du résultat nécessite un transfert de (2 * 1) = 2 octets.

L'exécution seule d'UNE instruction nécessite donc un transfert de :
4 + 2 = 6 octets.


L'exécution du programme (lecture puis exécution) demande donc un
transfert total de : 2 * (8 + 6) = 28 octets.

Bref, je pense avoir compris mais sans le corrigé, je n'aurai vraiment pas pensé à cela....
Voila
Bien cordialement pour toute l'aide qui m'a été apporté.

[Belgitaes]

mult X, Y, Z # Z = X * Y ;(X=2 Octet +Y= 2 Octet, Z= 2 Octet )+ mult= le resultat = 7 Octets
add X, Y, Z # Z = X + Y ;Z = X + Y( Z= 2 Octets +(X + Y= 4 Octets)+add le resultat = 7 Octets

Bon j´ai compris donc je suposse qu´il traite de registres double

6 enregistrements sont traités (R26 à R31) qui peuvent être combinés en groupes de deux
3 entrées sous forme de double 2 octets chacun:

• Registre-X: formé par XH (haut de X, ce qui correspond à R27) et XL( bas de X, ce qui correspond à R26).
• Registre-Y: formé par YH (haut de Y, ce qui correspond à R29) et YL( bas de Y, ce qui correspond à R28).
• Registro Z: formé par ZH (haut de Z, ce qui correspond à R31) et ZL( bas de Z, ce qui correspond à R30).

Ces Registres permettent routé à double autour de la zone de mémoire
- 2 octets pour coder l'adresse d'un opérande r27-r26 (X),r29-r28 (Y),r31-r30 (Z)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
Puisque la mémoire ne sait lire ou écrire qu'un mot de 2 octets
à la fois, cette mémoire va délivrer 2 octets lors de la lecture
du code opération (opcode) : un octet utile et un octet inutile.
La pour ma part, je n'avais déjà pas compris que la mémoire devait lire 2 octets à la fois(et non pas 1)

dans cet enregistrement le processeur 16-bit
contient l'adresse de la mémoire sur le fonctionnement à ce moment-là

Par exemple, je vais chargé par le pointeur X adresse 0x0120
LDI XH, 0x01
LDI XL, 0x20

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Si je comprend bien donc il lit le registre un octet utile et un octet inutile 
dependant si la valeur est dans XH ou XL ;X=XH:XL=R31:R30
Par exemple, je vais chargé par le pointeur X adresse 0x0003

LDI XH, 0x00 ;un octet inutile = 00
LDI XL, 0x03 ;un octet utile = 03

bon jái compris

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
Il faut donc ensuite demander à lire la valeur de cet opérande
en mémoire pour pouvoir exécuter l'instruction.
- l'accès aux valeurs des 2 opérandes de l'instruction nécessite donc
un transfert de : (2 * 2) = 4 octets,
 
- puis l'instruction est exécutée,
- et l'écriture du résultat nécessite un transfert de (2 * 1) = 2 octets.
 
Mais ce n'est pas fini !!

Un opérande est (dans cet exercice) une adresse en mémoire...
Ou encore un pointeur vers une donnée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
L'exécution seule d'UNE instruction nécessite donc un transfert de :
4 + 2 = 6 octets.??

+00000000: E0B0 LDI R27,0x00 Load immediate
+00000001: E0A3 LDI R26,0x03 Load immediate
+00000002: E0D0 LDI R29,0x00 Load immediate
+00000003: E0C4 LDI R28,0x04 Load immediate
+00000004: 0FCA ADD R28,R26 Add without carry
+00000005: 9FEC MUL R30,R28 Multiply unsigned

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
L'exécution du programme (lecture puis exécution) demande donc un
transfert total de : 2 * (8 + 6) = 28 octets.

L'exécution seule d'UNE instruction nécessite donc un transfert de :2 + 2 = 4 octets.

ben je dit peut etre une autre betise mais cela est comme cela que je le voit moi
le logiciel serait dans notre mémoire 16 octets NO???
il faut bien pointé sur Z no ??

LDI ZH, 0x00 ; = 00
LDI ZL, 0x00 ; = 00
LDI XH, 0x00 ;un octet inutile = 00
LDI XL, 0x03 ;un octet utile = 03
LDI YH, 0x00 ;un octet inutile = 00
LDI YL, 0x04 ;un octet utile = 04
MUL R28,R26 ; X * Y = 12
ADD R30,R28 ; R31- R30 = 12 (0C)


Code:
:020000020000FC
:10000000F0E0E0E0B0E0A3E0D0E0C4E0CA0F9FEC95
:00000001FF

Où: 10 00 00 00 est la direccion , la longueur de la chaîne et le type de données
F0E0E0E0B0E0A3E0D0E0C4E0CA0F9FEC est le code ejecutable
et 95 est le checksum de la ligne
Ensuite, pour le compilateur
ce qui compte est ce que signifie chaque Opcode
si tu décompile, vous laissant faire quelque chose comme ceci:

+2 octets: + 2 octets
+00000000: E0F0 LDI R31,0x00 \
+00000001: E0E0 LDI R30,0x00 / = Z = 4 octets
+00000002: E0B0 LDI R27,0x00 \
+00000003: E0A3 LDI R26,0x03 / = X = 4 octets
+00000004: E0D0 LDI R29,0x00 \
+00000005: E0C4 LDI R28,0x04 / = Y = 4 octets
+00000006: 0FCA ADD R28,R26 = 2 octets
+00000007: 9FEC MUL R30,R28 = 2 octets

L'exécution du programme (lecture puis exécution) demande donc un
transfert total de : 3 * 4 = 12 octets +4 = 16 octets
et la taille du programme 32 octets enfin conptant avec le registre Z

[bipbip2006]

Moi ce que j'ai compris c'est que l'assembleur, c'est pas pour moi
Le prend pas mal, mais j'ai rien compris à ce que tu racontes, comme dirait une de mes anciens profs de math de fac, c'est d'un trop haut niveau....
Le truc "simple" que je crois avoir compris, c'est qu'il faut lire l'adresse du registre PUIS relire pour connaitre le contenu (ce qui explique en double)
Enfin, j'avoue que des fois..... C'est vraiment pas clair

[Belgitaes]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
c'est qu'il faut lire l'adresse du registre 
PUIS relire pour connaitre le contenu (ce qui explique en double)
Enfin, j'avoue que des fois..... C'est vraiment pas clair

Le programe dans son environnement, est destiné à traiter des informations en “ temps réel ”
L’application est couplée au monde extérieur

Un langage assembleur spécifique au type du microprocesseur qui est traduit
en code machine lors de l’opération d’assemblage

Un programe exécute séquentiellement les instructions stockées dans la mémoire programme
et contient les instructions du programme que doit exécuter le microprocesseur.

la mémoire programme est constituée de mot de 16bits
Cela explique pourquoi on rencontre dans le programme ce type d’instruction : ldi zh ;high est l’adresse

Un registre de direction pour une configuration en entrée ou en sortie
Dans ce mode d’adressage l’opérande correspond à une adresse où est située la donnée de l’opération
Les modes d’adressages sont les différents moyens qui permettent au microprocesseur
d’accéder à une opérande en vue de tester ou de modifier le contenu d’un registre ou d’une mémoire.

Les données envoyées ou reçues se présentes sous la forme de valeurs binaires d’un mot de 16bits
Le codage d’une instruction s’effectue de la façon suivante :

Registre-X: formé par
XH ( poids fort (HIGH) de X, ce qui correspond au Registre R27)
XL ( poids faible (LOW) de X, ce qui correspond au Registre R26)

LDI XH, 0x00 ; Chargement du Registre R27 par la valeur pointée 00 hex (0000) binaire
LDI XL, 0x03 ; Chargement du Registre R26 par la valeur pointée 03 hex (0011) binaire

LDI est une instruction LDI (Load Immédiate)
l´instructions LDI est en Mode d’adressage immédiat
donc tu charge la valeur 0003 dans le registre X

Registre-Y: formé par
YH (haut de Y, ce qui correspond à R29)
YL ( bas de Y, ce qui correspond à R28).

LDI YH, 0x00 ; Chargement du Registre R29 par la valeur pointée 00 hex (0000) binaire
LDI YL, 0x04 ; Chargement du Registre R28 par la valeur pointée 04 hex (0100) binaire
donc tu charge la valeur 0004 dans le registre Y

maintenant on multiplie les 2 registres( X * Y ) c´est a dire (0000 0011 * 0000 0100)
et on met le resultat de la multiplicacion dans un registre qui sera dans ce cas le registre R28
qui recevras la totalité de la multiplicacion

MUL R28,R26 ; Chargement du Registre R28 par la valeur X * Y
maintenant le registre R28 auras la valeur de 0000 1100 binaire = 0C hex 12 dec

ADD R30,R28 ; R31- R30 = 12 (0C)
ADD est une instruction Aritmetique donc elle calcule maintenant le contenu de la multiplicacion
et l´ajoute au contenu dans le registre Z comme le registre Z vaut 0000 0000 dans ce cas
ben il aurras la valeur de R28
si on aurait chargé Z avec une valeur avant
on aurait la valeur de 0000 1100 binaire du registre 28 + la valeur du registre Z ( r31 r30)

j´espere que au moins tu aurras un petit peu mieux compris maintenant
cela est asser dificile de savoir s´expliquer et que les autres te comprennes
mais quand meme on essaye