Discussion :

[Zhangdar]

Bonjour,
je code pour une console portable n'ayant pas de processeur pour virgule flottante. Du coup dès que je commence à faire pas mal de calculs avec des float les perfomances chutent...
N'ayant pas trouvé de librairie ou code gérant les nombres à virgule fixe simplement, je dois en coder une simplifiée. J'ai des problèmes pour le codage des multiplications: lorsque les 2 nombres sont positifs mon code semble bien marcher, mais quand il y a un nombre négatif les résultats sont faux.

Extraits du code test pour mes fonctions:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
 
#include <nds.h>
#include <stdio.h>
 
#define Fixed19_12tofloat(i) (((float)(i)) / (float)(1<<(12)))
#define floattoFixed19_12(i) ((int)((i) * (float)(1<<(12))))
 
typedef int fixed19_12;      // 1 signe, 19 partie entière, 12partie décimale
 
 
// fonction posant problème
// le calcul en morceaux est nécessaire pour ne pas tronquer la partie entière
fixed19_12 multf19_12(fixed19_12 n1, fixed19_12 n2) {
    int i1,i2,f1,f2;
    f1=(n1&0x0FFF);                // récupération des parties décimales
    f2=(n2&0x0FFF);
    i1=((n1&0xFFFFF000)>>12); // récupération des parties entières
    i2=((n2&0xFFFFF000)>>12);
    return (((f1*f2)>>12) + (f1*i2) + (i1*f2) + ((i1*i2)<<12));
}
 
 
 
int main() {
    fixed19_12 a = floattoFixed19_12(0.625f);
    fixed19_12 b = floattoFixed19_12(-7.0625f);
 
    // calculs tests
 
    printf("a: %f   b: %f\n", Fixed19_12tofloat(a), Fixed19_12tofloat(b));
    printf("a+b: %f\n", Fixed19_12tofloat(a+b));
    printf("a-b: %f\n", Fixed19_12tofloat(a-b));
    printf("ax(-b): %f\n", Fixed19_12tofloat(multf19_12(a,-b)));
    printf("axb: %f\n", Fixed19_12tofloat(multf19_12(a,b)));
 
    /* Résultats:
    a: 0,625000  b: -7.062500
    a+b: -6.437500
    ax(-b): 4.414062
    axb: -393220.406250
    */
}

Voilà, la multiplication signée pose problème et je ne sais pas comment le résoudre. De plus ces multiplications devront intervenir dans des instants assez critiques de mon programme donc il faudrait qu'elles soient optimisées.

Merci d'avance.

[diogene]

Code :

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

    i1=((n1&0xFFFFF000)>>12); // récupération des parties entières

0xFFFFF000 est un unsigned int. n1 sera converti automatiquement en unsigned int et le résultat du & sera un unsigned int. Le décalage va entrer des 0 en bits de poids forts et non pas étendre le bit de signe et le résultat est "faux" (si tes entiers signés sont en complément à 2)

Pourquoi ne pas faire simplement :

Code :

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

1
2
3
fixed19_12 multf19_12(fixed19_12 n1, fixed19_12 n2) {
    return (n1*n2)>>12 ;
}

Attention, le résultat d'un décalage >> pour un nombre signé et négatif est défini par l'implémentation. Il faut vérifier que, pour ta console, ce décalage effectue bien une extension du signe . Sinon on peut écrire explicitement n1*n2/1000000000. A vérifier, les dépassements de capacités.

[Zhangdar]

Le problème si je fais une multiplication directement entre les 2 nombres, c'est que j'aurais une partie entière tronquée: si dans mon exemple je prend:
a = b = 0x100
Le résultat devrait tenir sans dépassement de capacité dans mon type. Or avec la multiplication directe, j'obtiens 0 comme résultat, à cause de la troncature des 12 bits les plus forts de ma partie entière.

Par contre le problème venait bien de la conversion int / unsigned int, du coup j'ai refait mon code et ca semble marcher

Code :

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

1
2
3
4
5
6
7
8
9
 
fixed19_12 multf19_12(fixed19_12 n1, fixed19_12 n2) {
    int i1,i2,f1,f2;
    f1=(n1&0x0FFF);
    f2=(n2&0x0FFF);
    i1=((n1-f1)>>12);
    i2=((n2-f2)>>12);
    return (((f1*f2)>>12) + (f1*i2) + (i1*f2) + ((i1*i2)<<12));
}

Donc merci du conseil . Maintenant si quelqu'un sait s'il y a moyen de l'optimiser (avec de l'assembleur ?) ca serait bien.

[diogene]

C'est vrai qu'avec une multiplication directe, c'est plus rapide mais on a un dépassement de capacité si le résultat de la multiplication des nombres n'est pas compris entre -128.0 et ~128 (pour des int de 32 bits).

Avec l'assembleur si la multiplication entière du processeur donne le résultat sur 64 bits, tu peux y trouver avantage en envisageant de coder directement (n1*n2) >>12 sans cette restriction.

[Zhangdar]

Il y a bien en effet une instruction assembleur sur le processeur pour avoir un résultat de multiplication sur 64bit en sauvant le résultat sur 2 registres. Mais j'ai jamais codé en assembleur alors je n'arrive pas à l'implémenter. Je pense avoir réussi le codage du calcul mais je ne sais pas où mettre la valeur de retour de la fonction (dans la pile, un registre spécifique, ou ailleurs ?).
Je suppose que ca dépend du compilateur (gcc arm) et/ou du processeur (un ARM9). J'ai du mal a trouver de la doc la dessus.

Code actuel:

Code :

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

1
2
3
4
5
6
7
8
9
 
fixed19_12 asmmult(fixed19_12 n1, fixed19_12 n2) {
    asm (
    " LDMFD sp!,{r2,r3}      @ récupération de n1 et n2 dans la pile\n"
    " SMULL r0,r1,r2,r3      @ r0 = partie basse de r2*r3 ; r1 = partie haute\n"
    " MOV r0,r0,LSR #0x0C    @ r0 = r0>>8 \n"
    " ADD r0,r0,r1,LSL #0x14 @ r0 = r0 + r1<<20  Résultat de la fonction"
);
}

[diogene]

as-tu consulté ce document ?
ARM GCC Inline Assembler Cookbook

[Zhangdar]

Je ne l'avais pas vu, j'ai pu remarqué que mon code était à moitié faux . Après 1h a me casser la tete j'ai toujours pas réussi à la faire marcher... Je ne comprends toujours pas ce qu'il faut faire de la valeur de retour.

[diogene]

Tu as des info plus complètes ici :
6.39 Assembler Instructions with C Expression Operands
et dans les paragraphes suivants.

[Zhangdar]

Merci pour la doc ! Ca m'aura donné une belle migraine, mais c'est bon cette fois. La nouvelle fonction est 2x plus rapide que celle en C, c'est parfait.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
fixed19_12 asmmult(fixed19_12 n1, fixed19_12 n2) {
    asm (
    " STMFD sp!,{r2-r3}             @ sauvegarde de r2-r3 (sinon plantage)\n"
    " SMULL r2,r3,%[n1],%[n2]       @ r2 = partie basse de r0*r1 ; r3 = partie haute\n"
    " MOV r0,r2,ASR #12             @ r0 = r2>>12 \n"
    " ORR %[res],r0,r3,ASL #20      @ (res) = r0 + r3<<20  Résultat de la fonction\n"
    " LDMFD sp!,{r2-r3}"
    : [res] "=r" (n1)
    : [n1] "r" (n1), [n2] "r" (n2)
);
    return n1;
}

Edit: version finale du code