ein kleiner Vorschlag:
wie oben gesagt, kann man auch mit integerarithmetik arbeiten, dann bietet es sich auch an, die Sprünge zu reduzieren, also zB. sechzehn mal die Operation (für n ... n+15) hinzuschreiben in der Hoffnung, dass sich durch pipelining noch etwas rausholen lässt. Auf die Schnelle konnte ich das jetzt nicht testen :/
Ach und noch etwas: dieses ständige
fstp
wait
ist der blanke Unfug. Ich würde alle Werte im Stack halten, wozu immer speichern und laden?
Man muss übrigens nicht ständig prüfen, man kann auch Testen, wann das oft besungene Kind in den Brunnen gefallen ist und dann die letzten Glieder wieder wegsubtrahieren. Eine Vorwärtsberechnung im 16er-Pack sieht dann so aus:
Delphi-Quellcode:
// init
fld [Ergebnisvariable] // 0
fld [const_1] // const = 1
fld [const_1] // n
// Schleifenanfang
fld st(1) // st(0) = 1
fdiv st(0), st(1) // st(0) = st(0) / n
faddp st(3), st(0) // ergebnis = ergebnis + st(0), pop st(0)
fadd st(0) st(1) // n = n + 1
fld st(1) // st(0) = 1
fdiv st(0), st(1) // st(0) = st(0) / n
faddp st(3), st(0) // ergebnis = ergebnis + st(0), pop st(0)
fadd st(0) st(1) // n = n + 1
fld st(1) // st(0) = 1
fdiv st(0), st(1) // st(0) = st(0) / n
faddp st(3), st(0) // ergebnis = ergebnis + st(0), pop st(0)
fadd st(0) st(1) // n = n + 1
fld st(1) // st(0) = 1
fdiv st(0), st(1) // st(0) = st(0) / n
faddp st(3), st(0) // ergebnis = ergebnis + st(0), pop st(0)
fadd st(0) st(1) // n = n + 1
// ... noch weitere 12x
// Abbruchtest und Schleifenende ...
// end
FCOMPP // pop st(0) + st(1)
fstp [Ergebnisvariable] // save, pop
// überschüssige Glieder wieder wegsubtrahieren
// ...
Man arbeitet da zwar nicht ganz nach den Vorstellungen einer Stackmaschine... aber wer hat gefragt, ob es der FPU gefällt
Die Idee, viele Befehle untereinander zu schreiben reduziert den Schleifenoverhead
Befehlsreferenz