ADO

0xFEDC4321 & 0xCDEF1234

0xFED3421

&

0xCDEF1234

On transforme ça en binaire

1111 1110 1101 1100 0100 0011 0010 0001

&

1100 1101 1110 1111 0001 0010 0011 0100

1100 1100 1100 1100 0000 0010 0010 0000

Mais on veut la réponse à printf("(1)%x\n",N1 & N2) ;

On retransforme le binaire en héxa (à cause du %x pour heXa)

CCCC0202

ATTENTION! Ne pas oublier le 0x pour dire que c'est de l'hexa et pas du choux fleur.

L'expression notée (1) afffiche 0xCCCC0202.

0xFEDC4321 ^ 0xCDEF1234

0xFED3421

^

0xCDEF1234

On transforme ça en binaire

1111 1110 1101 1100 0100 0011 0010 0001

^

1100 1101 1110 1111 0001 0010 0011 0100

0011 0011 0011 0011 0101 0001 0001 0101

Mais on veut la réponse à printf("(2)%x\n",N1 ^ N2) ;

On retransforme le binaire en héxa (à cause du %x pour heXa)

33335115

ATTENTION! Ne pas oublier le 0x pour dire que c'est de l'hexa et pas du choux fleur.

L'expression notée (2) afffiche 0x33335115.

( 0xFEDC4321 | 0xCDEF1234)>>1)

Commençons par 0xFEDC4321 | 0xCDEF1234

0xFEDC4321

|

0xCDEF1234

On transforme ça en binaire

1111 1110 1101 1100 0100 0011 0010 0001

|

1100 1101 1110 1111 0001 0010 0011 0100

1111 1111 1111 1111 0101 0011 0011 0101

FFFF 5335

0xFFFF 5335 >> 1 On conserve le bit le plus à gauche donc on décale tous les autres bits de 1 vers la droite

1111 1111 1111 1111 1010 1001 1001 1010

L'expression notée (3) affiche 0xFFFF A99A

(unsigned) (0xFEDC4321 | 0xCDEF1234)>>1)

Commençons par 0xFEDC4321 | 0xCDEF1234

0xFEDC4321

|

0xCDEF1234

On transforme ça en binaire

1111 1110 1101 1100 0100 0011 0010 0001

|

1100 1101 1110 1111 0001 0010 0011 0100

1111 1111 1111 1111 0101 0011 0011 0101

FFFF 5335

(unsigned) 0xFFFF 5335 >> 1 On ne conserve pas le bit le plus à gauche et on décale tous les autres bits de 1 vers la droite.

0111 1111 1111 1111 1010 1001 1001 1010

L'expression notée (4) affiche 0x7FFFA99A

-99 en hexa

Commençons par mettre 99 en binaire

99=0b 0110 0011

On ajoute tous les 0 à la gauche

0b0000 0000 0000 0000 0000 0000 0110 0011

On inverse tous les bits et on rajoute 1

0b1111 1111 1111 1111 1111 1111 1001 1101

0xFFFF FF9D

while ((n&1)==0) {n=n >> 1;}

le while ((n&1) ===0) il permet de sortir de la boucle quand le bit de droite est égal à 1, qu'importe ce qu'il y a avant

Si il restait un 1 on passe à 0 avec le n=n>>1 hors de la boucle

en gros, tu décales à droite jusqu'à ce que tu trouves le premier 1. A partir de là, tu redécales encore d'un cran. T'as 2 possibilités : soit le bout qu'il te reste vaut 0, et ça veut dire que ton nombre s'écrivait 0....010....0 (donc c'est une puissance de 2) soit le bout qui te reste contient encore des 1, et ça veut dire que ton nombre s'écrivait avec plusieurs 1 (et donc c'est pas une puissance de 2)

Pour passer de float à binaire

99,75 = 0b 110 0011,11

0b 1,10 001111*2^6

Exposant 127+6=133=0b 1000 0101

Signe mantisse:0

On enlève le premier 1 de la mantisse

mantisse= 1000 1111 000 0000 0000 000

Mémoire= 0b0 1000 0101 1000 1111 000 0000 0000 0000

0b 0100 0010 1100 0111 1000 0000 0000 0000

0x42C78000

$(unsigned*)&f convertit un entier en float

.data

n: .word 17 # Paramètre = unsigned n de la fonction foo

res: .word 0 # Réponse qui sera affichée

.text

lui $t0, 0x1001 # (1) Chargement des données utilisateurs

lw $a0, 0($t0) # (2) Chargement dans le registre $a0 la valeur $t0 ($a0 = argument procedure)

jal foo # (3) Appel de la fonction foo avec en paramètre $a0 = 17

sw $v0, 4($t0) # Enregistrement dans la pile le retour de fonction foo

add $a0, $0, $v0 # (4) Copie du résultat dans le $a0 pour print

addi $v0, $0, 34 # Print en hexadecimal (34)

syscall # Appel système

li $v0, 10 # (5) Fin de programme (10)

syscall # Appel système

foo: # début procedure

bne $a0, $0, fooNotZero # if (n != 0)

add $v0, $0, $0 # (6) Donc n == 0 soit on return 0 donc n = 0;

jr $ra # (7) return n;

fooNotZero: # début procedure si ce n'est pas 0

sw $t0, 0($sp) # On enregistre dans la pile $t0

sw $t1, 4($sp) # On enregistre dans la pile $t1 qui sera = au résultat final

addi $sp, $sp -8 # (8) On bouge le pointeur de pile de -8 car c'est un enregistrement

add $t0, $0, $a0 # (9) On copie dans $t0 l'argument

fooBoucle: # Début procédure soit début de la boucle

andi $t1, $a0, 1 # (10) On enregistre dans $t1 : n & 1

bne $t1, $0, fooFinBoucle # (11) si $t1 == 0 on sort ( (n & 1) == 0)

srl $a0, $a0, 1 # (12) n = n >> 1

beq $0, $0, fooBoucle # (13) if 0 == 0 (Vrai) donc on boucle

fooFinBoucle: # début procédure de fin de boucle

srl $a0, $a0, 1 # (14) n = n >> 1

beq $a0, $0, fooNotZero2 # (15) if (n != 0) on jump a fooNotZero2

add $v0, $0, $0 # (16) Sinon on return 0

beq $0, $0, fooFin # (17) On jump à la fin

fooNotZero2: # début procédure si n != 0

#addi $v0, $0, 0 # (18) ERREUR ENONCE

add $v0, $0, $t0 # (18) On copie dans $v0 le résultat

fooFin: # Procédure de fin

addi $sp, $sp, 8 # (19) On déplace de 8 le pointeur de pile

lw $t0, 0($sp) # Premier chargement de la pile

lw $t1, -4($sp) # (20) Second chargement de la pile

jr $ra # Retour fonction

Exercice 3 : Hiérarchie mémoire

Question 1 :

La fonction test présentée sur le listing 4 chaerche à copier une châine de caractères dans une autre. 16 itérations sont effectuées.

Question 2 :

Pour le cache pédagogique de 256 octets, organisés par blocs de 4 octets , on a :

256/4=64=2⁶. La taille de l’index pour la correspondance directe est de 6.

blocs de 4 octets=2².La taille de déplacement est de 2 pour les 2 correspondances.

L’étiquette de la correspondance directe a pour taille 32-6-2=24.

load immédiate a0,01

$a0=src

$a1=dest

load dans t0

le programme copie src dans dest

Correspondance associative par esnemble de 4

Mémoire cache = 256, taille bloc == 8 ctests, associatif par esnsemble de 4 soit 256/(8*4)=8 ensembles

Le cache contient 8 ensembles, 8=2^3 soit 3 bits

Déplacement: 1 bloc = 8 octets= 2^3 donc 3 bits

32-TD-TI=32-3-3=26 bits