Problem mit Geschwindigkeit

[TomyN]

Hallo,

Ich habe hier eine seltsames Phänomen, das ich nicht einsortieren kann.
Ich nutze Delphi 10.3
In meiner Software brauche ich oft eine FFT und da gerade etwas Zeit ist, habe ich mich seit Jahren wieder mal damit beschäftigt und ein kleines Testprogramm für die FFT Unit geschrieben. Das läuft soweit alles recht schön.
Aber: Da ich oft zwei FFTs mit der gleichen Auflösung gleichzeitig brauche, hab ich mir gedacht, ich erweitere die Procedure so, dass ich die Berechnung der Indexe sowie der Sin und Cos werter nur einmal mache und damit Zeit spare. Soweit so gut, nur dauert die neue Procedure deutlich länger als wenn ich zweimal die 'normale' FFT mache.

Ich habe nur den Code aus der 'Single FFT' kopiert und führe dann die Berechnungen anstelle mit einem Array mit zwei Arrays aus. Hier mal der Ausschnitt, auf den sich der 'Geschwindigkeitsverlust' reduzieren lässt.

Code:

a:= e;
       For j:=2 to n8 do begin
          Math.SinCos(a, ss1, cc1);
          Math.SinCos(3.0 * a, ss3, cc3);
           a:= j * e;
           i:= 0;
           id:= n2 shl 1;
           while i< Anzahl do begin
              While i < Anzahl do begin
                  i1:= i+j-1;
                  i2:= i1+n4;
                  i3:= i2+n4;
                  i4:= i3+n4;
                  i5:= i+n4-j+1;
                  i6:= i5+n4;
                  i7:= i6+n4;
                  i8:= i7+n4;
//Alter Teil
                  t1:= datenA[i3]*cc1+datenA[i7]*ss1;
                  t2:= datenA[i7]*cc1-datenA[i3]*ss1;
                  t3:= datenA[i4]*cc3+datenA[i8]*ss3;
                  t4:= datenA[i8]*cc3-datenA[i4]*ss3;
                  t5:= t1+t3;
                  t6:= t2+t4;
                  t3:= t1-t3;
                  t4:= t2-t4;
                  t2:= datenA[i6]+t6;
                  datenA[i3]:= t6-datenA[i6];
                  datenA[i8]:= t2;
                  t2:= datenA[i2]-t3;
                  datenA[i7]:= - datenA[i2]-T3;
                  datenA[i4]:= T2;
                  t1:= datenA[i1]+T5;
                  datenA[i6]:= datenA[i1]-t5;
                  datenA[i1]:= T1;
                  t1:= datenA[i5]+t4;
                  datenA[i5]:= datenA[i5]-t4;
                  datenA[i2]:= t1;
//Neuer Teil
                  t1:= datenB[i3] * cc1 + datenB[i7] * ss1;
                  t2:= datenB[i7] * cc1 - datenB[i3] * ss1;
                  t3:= datenB[i4] * cc3 + datenB[i8] * ss3;
                  t4:= datenB[i8] * cc3 - datenB[i4] * ss3;
                  t5:= t1+t3;
                  t6:= t2+t4;
                  t3:= t1-t3;
                  t4:= t2-t4;
                  t2:= datenB[i6]+t6;
                  datenB[i3]:= t6-datenB[i6];
                  datenB[i8]:= t2;
                  t2:= datenB[i2]-t3;
                  datenB[i7]:= - datenB[i2]-T3;
                  datenB[i4]:= T2;
                  t1:= datenB[i1]+T5;
                  datenB[i6]:= datenB[i1]-t5;
                  datenB[i1]:= T1;
                  t1:= datenB[i5]+t4;
                  datenB[i5]:= datenB[i5]-t4;
                  datenB[i2]:= t1;
//Ende Einschub
                  Inc(i, id);
              end;
              id:= id shl 1;
              i:= id-n2;
              id:= id shl 1;
           end;
       end;
       k:= k Shr 1;

Ich habe schon verschiedene FFT Größen und auch 32Bit oder 64Bit Kompilierung probiert, die 'Duale' Version ist immer um ca. 25% langsamer als zweimal die 'Single' Version. Und das kann ich mir einfach nicht erklären. Irgendwelche Ideen?