Je dois donc créer un programme d'assemblage MIPS qui lit 2 nombres sur 2 registres ($ s0 et $ s1) et calcule le nombre de bits par lesquels ces 2 nombres diffèrent. Et stocke le résultat dans le registre $ s2. Je dois également remplir tout ce qui précède avec le moins de commandes possible. J'ai essayé quelques trucs sur papier avec des opérations XOR mais je n'arrive pas à comprendre comment calculer la quantité de bits différents.
Si quelqu'un peut vous aider, vous êtes le bienvenu. Merci d'avance
3 Réponses :
XOR les bits ensemble, puis compter le nombre de bits dans le nombre résultant. Pour ce faire, vous pouvez effectuer une boucle sur chaque bit, vérifier s'il est défini (en utilisant un masque de bits et un décalage de bits), puis incrémenter un compteur.
Je laisse délibérément ce vague car c'est à vous de comprendre.
Décalez autant de fois que la largeur de votre registre et ajoutez zéro avec report à un autre
Voici un moyen qui évite de boucler sur les 32 bits. Il efface de manière répétitive tous les bits, mais le plus à gauche, tout en comptant leur nombre.
// x and y are the bits to compare
int z=x^y; // only bits different between x and y are set
int w;
int cnt=0;
while(w=z&-z) { //w only has the left bit in z set
cnt++;
z^=w; // clear the processed bit
}
Il est basé sur la propriété bien connue que x & -x est égal à le bit de poids inférieur défini dans x .
La boucle intérieure nécessite des instructions de 5 mips.
Plus rapide pour utiliser l'idiome z & = z-1 pour effacer le bit le plus bas, au lieu de l'isoler et puis utiliser XOR pour l'effacer. Juste 2 instructions plus un incrément de compteur et bne . Donc un total de 4, contre 5.
Exemple en C utilisant le code de comptage de pop sans boucle:
int x, y, z;
// ...
z = x^y; // x and y are inputs
z -= (z >> 1) & 0x55555555; // 16 2 bit counts
z = (z & 0x33333333) + ((z >> 2) & 0x33333333); // 8 4 bit counts
z = (z + (z >> 4)) & 0x0f0f0f0f; // 4 8 bit counts
z = (z * 0x01010101) >> 24; // 1 32 bit count