Calcul FP et SSE

**Alexko** · 24/08/2007, 11h02

Tiens, y'a des gens qui codent en Delphi pour de vrai :D Je croyais que c'était une espèce disparue...

**braoru** · 24/08/2007, 11h12

Ouais notre prof de diplôme ne jurait que par ça ! Donc on s’est envoyé un gros tas de Delphi (manda extérieur et autres..)

**ToToNaBuKo** · 24/08/2007, 11h14

Il y a vraiment differents niveaux de C, pour en faire toute la journee ce n'est jamais aussi bas niveau...
Bon des fois je m'amuse un peu et fais des trucs plus corses pour embeter mes collegues

**Franck@x86** · 24/08/2007, 11h53

Envoyé par Alexko

Tiens, y'a des gens qui codent en Delphi pour de vrai :D Je croyais que c'était une espèce disparue...

Borland offre sa version 10 de Delphi, on aurait tort de s'en priver.
Par contre pfiou j'ai rarement vu une IDE aussi longue à démarrer.

(dispo sur http://www.codegear.com/, mais le serveur est souvent occupé ...)

**Yasko** · 24/08/2007, 12h17

Oui, Borland ne va très bien en ce moment, surtout au niveau de ses *Builder qui se vendent mal (c'est sur qu'entre VS et Eclipse, il n'y plus beaucoup de place).
Apparemment, ils se recentrent sur l'Application Lifecycle Management, domaine ou leurs ventes sont meilleures (TeamSystem, Caliber, Together, rachat de Segue, ...).

**Møgluglu** · 24/08/2007, 16h10

Envoyé par Franck@x86

Les compilos font ceci :

Code:

#define LONG(L, F)\
_asm { fld dword ptr F}\
_asm { fistp dword ptr L}

Plutôt un fisttp en deuxième, sinon la sémantique du cast C n'est pas respectée.
(Même si je ne vois pas trop dans quels circonstances en pratique on voudrait faire une troncature plutôt qu'un arrondi au plus près ou vers -infini, c'est le C qui veut ça...)

Donc finalement cette macro, bien que super peu pratique par rapport à un simple "(int)f", reste le meilleur compromis à mon avis.

Mon gcc 4.1.3 (x86-64, aucune optim) compile (int)f en utilisant un cvttsd2si (SSE2 Convert with Truncation Scalar Double-Precision Floating-Point Value to Signed Doubleword Integer).
Difficile de faire plus efficace... (Enfin si avec un cvttpd2pi :D)

**Alexko** · 24/08/2007, 17h40

Envoyé par Franck@x86

Borland offre sa version 10 de Delphi, on aurait tort de s'en priver.
Par contre pfiou j'ai rarement vu une IDE aussi longue à démarrer.

(dispo sur http://www.codegear.com/, mais le serveur est souvent occupé ...)

Sa version 10 ? Tu veux dire la 2005 ?

**Franck@x86** · 24/08/2007, 21h39

c'est bien la 10 :

Borland® Delphi® for Microsoft® Windows™ Version 10.0.2288.42451

**jihef** · 24/08/2007, 21h41

Envoyé par Møgluglu

Mon gcc 4.1.3 (x86-64, aucune optim) compile (int)f en utilisant un cvttsd2si (SSE2 Convert with Truncation Scalar Double-Precision Floating-Point Value to Signed Doubleword Integer).
Difficile de faire plus efficace... (Enfin si avec un cvttpd2pi :D)

C'est du au fait que ce soit justement un gcc x86-64. Si c'était juste un gcc x86, il ferait ça avec x87, à moins de compiler avec -mfpu=sse.

**Franck@x86** · 24/08/2007, 23h14

Envoyé par Møgluglu

Plutôt un fisttp en deuxième, sinon la sémantique du cast C n'est pas respectée.
(Même si je ne vois pas trop dans quels circonstances en pratique on voudrait faire une troncature plutôt qu'un arrondi au plus près ou vers -infini, c'est le C qui veut ça...)

Un peu risqué, fisttp est une instruction SSE3

**Møgluglu** · 25/08/2007, 15h07

Sur une machine i386 j'obtiens :

(désolé pour la syntaxe Gnu, j'ai pas trouvé dans les 500 pages du man comment faire cracher autre chose à gcc [Edit: -masm=intel, pour la prochaine fois])

-march=k8 -mfpmath=387 :

Code:

        fstpl   -24(%ebp)
        movlpd  -24(%ebp), %xmm0
        cvttsd2si       %xmm0, %eax

Tiens, du SSE2 même quand on ne lui en demande pas... Pourquoi pas, mais ça oblige à passer par un store-load.

-march=prescott -mfpmath=387 :

Code:

        fisttpl -12(%ebp)

Le SSE3 c'est bon mangez-en :P

-march=i686 :

Code:

        fnstcw  -26(%ebp)
        movzwl  -26(%ebp), %eax
        orw     $3072, %ax
        movw    %ax, -28(%ebp)
        fldcw   -28(%ebp)
        fistpl  -12(%ebp)
        fldcw   -26(%ebp)
        movl    -12(%ebp), %eax

Ahhh, du grand art.
- Sauvegarde du registre de contrôle x87
- Changement du mode d'arrondi en troncature (avec un passage par la mémoire mais on n'est plus à ça près, on a déjà cassé le pipeline de toute façon)
- Conversion en entier, avec le mode d'arrondi sélectionné
- Restauration du registre de contrôle

Du coup effectivement, pour ces processeurs-là la bidouille avec la constante est largement plus efficace qu'un changement du mode d'arrondi.

Mais tout ça c'est la faute du C et sa sémantique euh... étrange.

Donc il reste 2 solutions
- hardware : compiler en X87+SSE3, ou en SSE2
- software : programmer en C99 et faire le cast avec lrint.

Et tout ça parce que quelqu'un dans les années 70 s'est dit que ce serait plus simple d'implémenter le cast float -> int par une troncature plutôt qu'avec un vrai arrondi... :fou:

**Foudge** · 25/08/2007, 21h05

Purée le code que ça fait en i686 pour un simple cast, j'aurais jamais cru

uch:

**Møgluglu** · 25/08/2007, 22h17

Envoyé par Foudge

Purée le code que ça fait en i686 pour un simple cast, j'aurais jamais cru

uch:

Je te rassure, ça c'était la version naïve et lente de gcc. La version "rapide" d'Intel est bien pire.

Aller, juste pour le fun :
(http://developer.intel.com/design/pr...als/248966.pdf, 3.8.3.1)

Code:

_fto132proc
   lea      ecx, [esp-8]
   sub      esp, 16          ; Allocate frame
   and      ecx, -8          ; Align pointer on boundary of 8
   fld      st(0)            ; Duplicate FPU stack top
   fistp    qword ptr[ecx]
   fild     qword ptr[ecx]
   mov      edx, [ecx+4]     ; High DWORD of integer
   mov      eax, [ecx]       ; Low DWIRD of integer
   test     eax, eax
   je       integer_QnaN_or_zero
arg_is_not_integer_QnaN:
   fsubp     st(1), st		; TOS=d-round(d), { st(1) = st(1)-st & pop ST}
   test      edx, edx		; What's sign of integer
   jns       positive		; Number is negative
   fstp      dword ptr[ecx]	; Result of subtraction
   mov       ecx, [ecx]		; DWORD of diff(single-precision)
   add       esp, 16
   xor       ecx, 80000000h
   add       ecx,7fffffffh	; If diff<0 then decrement integer [increment plutôt??]
   adc       eax,0			; INC EAX (add CARRY flag)
   ret
positive:
    fstp      dword ptr[ecx]    ; 17-18 result of subtraction
    mov       ecx, [ecx]        ; DWORD of diff(single precision)
    add       esp, 16
    add       ecx, 7fffffffh    ; If diff<0 then decrement integer
    sbb       eax, 0            ; DEC EAX (subtract CARRY flag)
    ret
integer_QnaN_or_zero:
    test      edx, 7fffffffh
    jnz       arg_is_not_integer_QnaN
    add esp, 16
    ret

En gros :
- On convertit en entier dans le mode d'arrondi actuel
- On reconvertit dans l'autre sens en flottant
- On fait la différence des deux pour savoir dans quel sens s'est fait l'arrondi, et s'il s'est fait dans le mauvais sens on corrige en ajoutant/retranchant 1, en considérant les cas positif/négatif.

Remarquer la touche de l'artiste : le add ecx,7fffffffh sur la représentation binaire d'un flottant pour récupérer le signe et le faire passer dans le flag carry, suivi d'un adc/sbb eax,0 pour incrémenter/décrémenter ou pas le nombre suivant la valeur de ce signe.

t1cable:

Et puis un peu de code spaghetti pour distinguer les overflows des NaNs...

Oui, tout ça pour un simple cast.

**Foudge** · 25/08/2007, 22h37

En fait, le C est un langage de haut niveau, il n'y a aucun doute :D

**Lissyx** · 25/08/2007, 22h44

Clairement

**braoru** · 26/08/2007, 10h24

Envoyé par Lissyx

Clairement

Si jamais il y a des trucs comme ça et d’autres qui sont expliqués dans les blue books d’Intel !

Discussion: Calcul FP et SSE

Outils de la discussion

Règles de messages