Most pedig a Tomcat/Abaddon féle coder-l listán közölt FPU Gems rev 2.01 következik

Hogyan töltsünk fel konstansokat?
Az FLDZ, FLD1 ideje 2 ciklus (méréseim szerint),
az FLDPI, FLDLG2 stb. ideje 3+2 ciklus (ld. 7. pont).Helyette gyorsabb az FLD qword [Zero], FLD qword [Plus1], FLD qword [Pi] ...
   Zero    DQ   0.0    Plus1   DQ   +1.0    L2e     DQ   1.4426950408889634074    Ln2     DQ   0.69314718055994530942    Pi      DQ   3.14159265358979323846    ...
Ami ha dword-ös, ha qword-ös adatról is van szó, ideje csak 1+1 ciklus. (Persze cache találat szukseges, de ha egy csoportba vannak fűzve ezek a konstansok, akkor ez nagyon valoszínű).
Hogyan távolítsuk el a haszontalan adatokat a STACK-ről?
A legtöbb számolás után csak hasznos adatok maradnak az FPU vermében, amiket azután FSTP-vel szedünk ki a valtozókba. A többi részeredmény elnyelődik az FADDP, FSUBP, FMULP, FDIVP utasitások során.

Ha valamiért megis maradt haszontalan adat az FPU vermeben, akkor én korábban azt egy FSTP dword [Trash] utasítással "dobtam a szemetbe".

   Trash   DD    ?
Ez azonban cache találat mellett is 2 ciklus idő. Sőt ha az eredmény még nincs kész az FSTP-t megelőző ciklusban (pipeline overlap), akkor még plusz ciklusok is elveszhetnek.

Ennél jobb megoldás az FSTP ST utasitas, ez 1 ciklus idejű, és nem is kell várni az eredményre. De ugyanolyan jó az FCOMP ST utasítás is (Figyelem: az FCOMP es az FCOMP ST nem ugyanaz, az első csak akkor működik, ha legalább két érték van a veremben!).

Ha viszont két felesleges adat van a vermünkben, akkor azt egyértelműen FCOMPP utasitással éri meg eltávolitani, ami csak 1 ciklus.

Hogyan hasonlitsuk ossze a lebegopontos szamokat?
A normál megoldások kb.:
   FLD     [X]                     FLD     [X]    FCOMP   [Y]                     FTST    FNSTSW  AX                      FNSTSW  AX    SAHF                            SAHF    JB      XkisebbY                JZ      Xnulla
Itt a SHAF és a JB v. JZ nem párosítható utasítások, ezért a hasonlításkor a következő sémák ajánlottak az FNSTSW AX után:
Kisebb vizsgalatára
   SHR     AH,1            vagy:   AND     AH,1    JC      kisebb                  JNZ     kisebb
Nulla vizsgalatára
  AND     AH,40H    JNZ     nulla           ; Figyelem: forditott a FLAG!
Nagyobb vizsgalatára
   AND     AH,41H    JZ      nagyobb
(Figyelem: TEST AH,41H rosszabb a PentiumPro-n mint az AND AH,41H!)

A kovetkező nagyon fontos gondolat, hogy két lebegőpontos számot, amennyiben pozitív, akkor "simán" is összehasonlíthatunk, pl.

  MOV     EAX,[X]    CMP     EAX,[Y]    JB      kisebb
Arrol, hogy X és Y is pozitív legyen, szintén gondoskodhatunk egész aritmetikával:
   AND     BYTE PTR [X] + (TYPE X) - 1, 07FH    AND     BYTE PTR [Y] + (TYPE Y) - 1, 07FH    - ahol a TYPE X, az vagy 4 (dword) vagy 8 (qword)
(Persze itt a két olvas-modosít-ír utasítást felboncolhatnánk a párositható primitíveikre, hogy fele idő alatt fussanak le).

Nullara vizsgalat is atalakithato, itt csak az elojelet kell eltuntetnunk:

  MOV     EAX,DWORD PTR [X] + (TYPE X) - 4    ADD     EAX,EAX    JZ      nulla
A lebegőpontos számok kettes számrendszerű összehasonlíthatóságának még egy nagyon fontos következménye van !*! hogy alkalmazható a radix vagy bytesort rendezés, ami nagy elemszám mellett a leggyorsabb !*! (Persze ez implementáció-függő is, mert bytesort es bytesort között van különbség. Az általam megírt két verziót vizsgálva az egyik több mint 2 és félszer gyorsabban fut mint a masik, a cache memória megfelelő felhasználása miatt).
Hogyan adjunk értéket egy lebegőpontos változónak?
Az FLD [X], FSTP [Y] páros helyett (ami 4 ciklus) használható a
   MOV EAX,DWORD PTR [X]    MOV EBX,DWORD PTR [X] + 4    MOV DWORD PTR [Y],EAX    MOV DWORD PTR [Y] + 4,EBX
utasítás sor, ami csak 2 ciklus idejű (persze már csak ha a cache-ből fut)

Viszont ha egyszerre több változónak akarunk értéket adni, és a célvaltozóink nincsenek a cache-ben, akkor a következő kódsor meg a REP MOVSD -nél is gyorsabb...

        SHL     ECX,2         ADD     ESI,ECX         ADD     EDI,ECX         NEG     ECX   @@1:         FILD    QWORD PTR [ESI+ECX]         FILD    QWORD PTR [ESI+ECX+8]         FXCH         FISTP   QWORD PTR [EDI+ECX]         FISTP   QWORD PTR [EDI+ECX+8]         ADD     ECX,16         JS      @@1
Tovabbá ez néha még gyorsabb:
        SHL     ECX,2         ADD     ESI,ECX         ADD     EDI,ECX         NEG     ECX   @@1:         MOV     EAX,[ECX+EDI]         MOV     EAX,[ECX+ESI]         MOV     EDX,[ECX+ESI+4]         MOV     [ECX+EDI],EAX         MOV     [ECX+EDI+4],EDX         MOV     EAX,[ECX+ESI+8]         MOV     EDX,[ECX+ESI+12]         MOV     [ECX+EDI+8],EAX         MOV     [ECX+EDI+12],EDX         MOV     EAX,[ECX+ESI+16]         MOV     EDX,[ECX+ESI+20]         MOV     [ECX+EDI+16],EAX         MOV     [ECX+EDI+20],EDX         MOV     EAX,[ECX+ESI+24]         MOV     EDX,[ECX+ESI+28]         MOV     [ECX+EDI+24],EAX         MOV     [ECX+EDI+28],EDX         ADD     ECX,32         JS      @@1
Hogyan osszunk konstanssal?
Ne felejtsük el, szorozni SOKKAL GYORSABB mint osztani, vagyis osztás helyett szorozzunk mindig a reciprokkal! Nézzük egy vektor skalárral való osztását:
 
  •  a normál megoldás...
   FLD     x       ;001-001 x
   FDIV    oszto   ;002-040 x/oszto
   FLD     y       ;039-039 y x/oszto
   FDIV    oszto   ;040-078 y/oszto x/oszto
   FLD     z       ;077-077 z y/oszto x/oszto
   FDIV    oszto   ;078-116 z/oszto y/oszto x/oszto
   FXCH    ST(2)   ;079-079 x/oszto y/oszto z/oszto
   FSTP    x       ;115-116 y/oszto z/oszto
   FSTP    y       ;117-118 z/oszto
   FSTP    z       ;119-120                Összesen:  120 ciklus
  • a reciprokos...
    FLD     x       ;001-001 x
   FMUL    rec     ;002-004 rec*x
   FLD     y       ;003-003 y rec*x
   FMUL    rec     ;004-006 rec*y rec*x
   FLD     z       ;005-005 z rec*y rec*x
   FMUL    rec     ;006-008 rec*z rec*y rec*x
   FXCH    ST(2)   ;007-007 rec*x rec*y rec*z
   FSTP    x       ;007-008 rec*y rec*z
   FSTP    y       ;009-010 rec*z
   FSTP    z       ;011-012                Összesen:  12 ciklus
  • s ha nincs kéznél a reciprok...
   FLD     Plus1   ;001-001 +1    FDIV    oszto   ;002-040 rec    FLD     x       ;039-039 x rec    FMUL    ST,ST(1);041-043 rec*x rec    FLD     y       ;042-042 y rec*x rec    FMUL    ST,ST(2);043-045 rec*y rec*x rec    FXCH            ;044-044 rec*x rec*y rec    FLD     z       ;044-044 z rec*x rec*y rec    FMULP   ST(3),ST;045-047 rec*x rec*y rec*z    FSTP    x       ;046-047 rec*y rec*z    FSTP    y       ;048-049 rec*z    FSTP    z       ;050-051                Összesen:  51 ciklus
A fenti kódsorozat TASM SINTAXIS-ban készült, ezért az FLD Plus1, FDIV oszto, stb.-nél a FLD qword [Plus1], stb.-t kell írni.
Hogyan használjuk párhuzamosan az FPU-t és a CPU-t?
Az FPU kódban lesznek holt idők, amiket kitölthetünk a CPU utasításaival, kivéve a szorzás utasítást (IMUL), mert ahhoz kell az FPU is. Ezekre a holt időkre nézzük példaként a térbeli vektor normálását:
   FLD     x       ;001-001 x    FMUL    ST,ST   ;002-004 x2    FLD     y       ;003-003 y x2    FMUL    ST,ST   ;004-006 y2 x2    FLD     z       ;005-005 z y2 x2    FMUL    ST,ST   ;006-008 z2 y2 x2    FXCH    ST(2)   ;007-007 x2 y2 z2    FADDP           ;007-009 x2+y2 z2    db 2 dup(48h)   ;008-009 2 db DEC EAX    FADDP           ;010-012 x2+y2+z2    db 2 dup(48h)   ;011-012 2 db DEC EAX    FSQRT           ;013-082 len    db 69 dup(48h)  ;014-082 69 db DEC EAX    FDIVR   Plus1   ;083-121 rec    db 36 dup(48h)  ;084-119 36 db DEC EAX    FLD     x       ;120-120 x rec    db 1 dup(48h)   ;121-121 1 db DEC EAX    FMUL    ST,ST(1);122-124 rec*x rec    FLD     y       ;123-123 y rec*x rec    FMUL    ST,ST(2);124-126 rec*y rec*x rec    FXCH            ;125-125 rec*x rec*y rec    FLD     z       ;125-125 z rec*x rec*y rec    FMULP   ST(3),ST;126-128 rec*x rec*y rec*z    FSTP    x       ;127-128 rec*y rec*z    FSTP    y       ;129-130 rec*z    FSTP    z       ;131-132
Ez összesen 132 ciklusig tartott, amiben volt 110 ciklus CPU üresjárat.

A hosszabb holt időkbe lehet tenni pl. osztást (IDIV), így akár egyszerre két osztáson is dolgozhat a gép, vagy esetleg egy kamu olvasó utasítással fel lehet tölteni az elkövetkezőkben szükséges cache vonalakat.

Mennyi a végrehajtási ideje az egyes FPU utasításoknak?
Az első adat az FPU utasítás teljes ciklusideje, aztán az ebből az FPU utasitás által átlapolható idő, végül a CPU utasitás által átlapolható idő.
   FLD      1       0       0    FLD1     2       0       0    FLDPI    5       2       2  <- ez a sor hibas az FP5OPT.TXT-ben!    FADD     3       2       2    FMUL     3       2'      2    FDIV    39       2"     38    FSQRT   70       2      69    FSTP     2~      0       0   ' ez csak 1, ha az elozo utasitas is FMUL   " ez csak 1, ha az elozo utasitas is FDIV   ~ ez 3, ha az elozo cilusban meg nincs kiszamolva az eredmeny.