Une Fonction En Assembleur 8086!

[invite7dd04031]

Bonjour à tous!

J'aimerais écrire une fonction en assembleur 8086 dont j'ai le "template" en "C".

Je sais exactement comment le faire en "C", mais quand vient le temps de l'écrire en Assembleur, je suis un peu perdu !!!

Voici la fonction en C :

********************

unsigned int FonctionDeHash(unsigned char *AdresseDeChaine, unsigned short TailleDeChaine)
{
unsigned int hash = 5381;
unsigned short i;
for(i = 0; i < TailleDeChaine; i++)
{
hash = ((hash << 5) + hash) + AdresseDeChaine[i]; /* hashi = hashi-1 * 33 + xi */
}
return hash;
}

********************

Pouvez-vous m'aider? Des astuces?

PS : Je dois faire une fonction propre, donc utiliser les push et pop pour la pile et utiliser le registre bp (pour ceux et celles qui savent de quoi je parle :P)
-----

[invite2d7144a7]

Bonjour,

Compte tenu de ton "ps", il s'agit d'un exercice.

Donc, montre-nous ce que tu as fait, explique-nous ce qui te bloque ... et on verra.

Pour information, même pour du code 8086, le moindre compilateur suffisamment récent optimisera mieux que ce que tu pourras faire à la main, surtout dans le cas d'un code aussi trivial.

[Jack]

/* hashi = hashi-1 * 33 + xi */

bizarre ce -1. Je me trompe ou on ne le retrouve pas dans le code?

hash = ((hash << 5) + hash) + AdresseDeChaine[i];

A+

[invite7dd04031]

En gros voici ce que j'ai commencé, mais comme je le disais, je ne sais vraiment pas comment procéder ... et pour répondre à Jack, en gros, la fonction est hash = (hash*33) - adresse(du caractere en boucle) ....

et je précise, je ne sais pas comment initialiser une variable comme il le faut!

*************
org 100h

jmp start

matricule1 ; déclaration des variables
matricule2
resultat1 DW 0000h, 0002h
resultat2 DW


start:
LEA AX, adresseChaine
Pusha
CALL fonctionHash
popa
ret

fonctionHash PROC
Push CX ; contiendra nbre de caractere du string entrée en parametre
Push AX ; contiendra caractère actuel
Push BX ; contiendra adresse du caractere hashé
Push BP ; adresse de la pile du début
MOV BP,SP


******************

et après le néant ... que dale!

[A voir en vidéo sur Futura]

[Jack]

start:
LEA AX, adresseChaine
Pusha
CALL fonctionHash

A mon avis, il faudra empiler AX ainsi que la longueur de la chaine avant d'appeler le sous-programme.

fonctionHash PROC
Push CX ; contiendra nbre de caractere du string entrée en parametre
Push AX ; contiendra caractère actuel 
Push BX ; contiendra adresse du caractere hashé
Push BP ; adresse de la pile du début

Du coup je ne comprends pas ce que tu empiles dans le sous-programme. Au contraire, il faudrait dépiler les paramètres que tu as passés, après avoir dépilé l'adresse de retour. Le but est ensuite d'effectuer le calcul, d'empiler le résultat, replacer l'adresse de retour (à moins que tu l'aies déjà mise en place auparavant) avant de sortir du sous-programme.

Je te conseille d'installer emu8086 qui permet de simuler tout çà. Le débugger est très pratique et la doc suffisamment succincte et détaillée.
A+

[Garion]

Pour information, même pour du code 8086, le moindre compilateur suffisamment récent optimisera mieux que ce que tu pourras faire à la main, surtout dans le cas d'un code aussi trivial.

Ca je demande à voir. En général quand je réécrit en assembleur les fonctions critiques de mes logiciels, j'ai en général un gain en vitesse qui va de 2 à 10 (cela dépend si je peux utiliser les fonctions SSE).
Les compilateurs ont fait des progrès mais on reste loin de la qualité d'optimisation manuelle en assembleur.

[invite2d7144a7]

Bonjour,

Bien entendu, tout dépend du code C.

Ce que j'ai écrit vaut parfaitement pour du code trivial comme celui de ce sujet.

Et toujours bien entendu, il est rarissime qu'un compilateur utilise tout ce qui est SSE et autres (rare, pas exclu).

Et il est des cas qu'aucun compilateur ne sait optimiser, voire même ne sait pas faire si on ne lui détaille pas l'algorithme "à la main", une bibliothèque de calcul multi-précision (genre GMP) le montre bien.

Et bien entendu encore, pour avoir ces optimisations, il faut activer le processus d'optimisation du compilateur, et GCC ou G++ sont très performants dans ce domaine, Visual C++ également.

En résumé, si tes "fonctions critiques" ne sont pas du calcul bête et méchant, il est normal que l'assembleur te permette d'aller plus vite, mais il ne faut pas généraliser : pour une bonne partie du code, le compilateur fera au moins aussi bien que toi, et souvent mieux.

[yoda1234]

@ newylox: Merci d'utiliser les balises code.