brauche kleine Hilfe in ASM, Flaschenhals

[Amateurprofi]

Und so geht es noch simpler und schneller.

Delphi-Quellcode:

function xSmallToDouble(CodZahl: Integer): Double;
const scale:array[0..7] of double=
     (1/100,1/10000,1/1000000,1.0,1/100,1/10000,1/1000000,1.0);
begin
  if CodZahl>=0 then result:=(CodZahl and $9FFFFFFF)*scale[CodZahl shr 29]
   else result:=(CodZahl or $60000000)*scale[CodZahl shr 29];
end;

Diese Funktion braucht durchschnittlich 53 CPU-Ticks.
Die von negaH schon sehr schön konstruierte Lösung braucht durchschnittlich 88 CPU-Ticks.
Die Resultate sind bei beiden Funktionen identisch (getestet für alle 2^32-1 möglichen Integer-Werte)

Die Ticks wurden so ermittelt.

Delphi-Quellcode:

PROCEDURE TMain.Test;
var v:double; i:integer; q1,q2,qs,qe,tsdelay:int64;
FUNCTION TimeStamp:int64;
asm
   rdtsc
end;
FUNCTION TimeStampDelay:int64;
var i:integer; ts0,ts1:int64;
begin
   result:=maxint;
   for i:=1 to 3 do begin
      ts0:=TimeStamp;
      ts1:=TimeStamp;
      dec(ts1,ts0);
      if ts1<result then result:=ts1;
   end;
end;
begin
   tsdelay:=TimeStampDelay;
    q1:=High(int64);
   for i:=1 to 10 do begin
      qs:=TimeStamp;
      v:=SmallToDouble($FFFFFFFF);
      v:=SmallToDouble($EFFFFFFF);
      v:=SmallToDouble($DFFFFFFF);
      v:=SmallToDouble($CFFFFFFF);
      v:=SmallToDouble($BFFFFFFF);
      v:=SmallToDouble($AFFFFFFF);
      v:=SmallToDouble($9FFFFFFF);
      v:=SmallToDouble($8FFFFFFF);
      v:=SmallToDouble($7FFFFFFF);
      v:=SmallToDouble($6FFFFFFF);
      v:=SmallToDouble($5FFFFFFF);
      v:=SmallToDouble($4FFFFFFF);
      v:=SmallToDouble($3FFFFFFF);
      v:=SmallToDouble($2FFFFFFF);
      v:=SmallToDouble($1FFFFFFF);
      v:=SmallToDouble($0FFFFFFF);
      qe:=TimeStamp;
      dec(qe,qs);
      if qe<q1 then q1:=qe;
   end;
   dec(q1,tsdelay);
   q2:=High(int64);
   for i:=1 to 10 do begin
      qs:=TimeStamp;
      v:=xSmallToDouble($FFFFFFFF);
      v:=xSmallToDouble($EFFFFFFF);
      v:=xSmallToDouble($DFFFFFFF);
      v:=xSmallToDouble($CFFFFFFF);
      v:=xSmallToDouble($BFFFFFFF);
      v:=xSmallToDouble($AFFFFFFF);
      v:=xSmallToDouble($9FFFFFFF);
      v:=xSmallToDouble($8FFFFFFF);
      v:=xSmallToDouble($7FFFFFFF);
      v:=xSmallToDouble($6FFFFFFF);
      v:=xSmallToDouble($5FFFFFFF);
      v:=xSmallToDouble($4FFFFFFF);
      v:=xSmallToDouble($3FFFFFFF);
      v:=xSmallToDouble($2FFFFFFF);
      v:=xSmallToDouble($1FFFFFFF);
      v:=xSmallToDouble($0FFFFFFF);
      qe:=TimeStamp;
      dec(qe,qs);
      if qe<q2 then q2:=qe;
   end;
   dec(q2,tsdelay);
   showmessage(inttostr(q1 div 16)+#13+inttostr(q2 div 16));
end;

[stoxx]

Zitat:

Zitat von Amateurprofi

Und so geht es noch simpler und schneller.

Delphi-Quellcode:

function xSmallToDouble(CodZahl: Integer): Double;
const scale:array[0..7] of double=
     (1/100,1/10000,1/1000000,1.0,1/100,1/10000,1/1000000,1.0);
begin
  if CodZahl>=0 then result:=(CodZahl and $9FFFFFFF)*scale[CodZahl shr 29]
   else result:=(CodZahl or $60000000)*scale[CodZahl shr 29];
end;

das ist ja cool ! also das ist wirklich praktisch nicht mehr zu unterscheiden, als wenn man die Double Werte einliest.
Auch wenn ich noch nicht wirklich verstehe, was Du da machst und warum das schneller ist !
Bringt ungefähr 10 Prozent beim Einlesen von Daten.

Bei Deiner Messfunktion kommt bei mir 32 zu 20 raus und nicht 88 zu 53 wie bei Dir. Hat das was mit der CPU Geschwindigkeit zu tun ?
Sollte doch eigentlich nicht ? (Prozessor Typ AMD-Intel)
Ist Dein rdtsc gleichbedeutend mit : queryperformancecounter ? Damit messe ich immer.
Vielen Dank !

[Amateurprofi]

Zitat:

Auch wenn ich noch nicht wirklich verstehe, was Du da machst

Die unterschiedlichen Scales werden durch die Bits 29-30 bestimmt.
Um 29 Bits nach rechts verschoben ergeben sich (wenn Bit 31=0 ist) also 4 mögliche Werte, nämlich 0..3.
Da Bit 31 aber auch 1 sein könnte, ergibt die Verschiebung um 29 Bits 8 mögliche Werte, wobei die Werte 4..7 den Werten 0..3 entsprechen.
Das Array scale[0..7] enthält diese 2*4 möglichen Scales und mit

Delphi-Quellcode:

scale[CodZahl shr 29]

hole ich den passenden Scale aus dem Array.

Zitat:

und warum das schneller ist

Weil der Zugriff auf ein Array, zudem eines, dessen Felder 8 Bytes lang (double=64 Bit) sind, deutlich schneller ist, als den Scale in einer Case-Struktur zu ermitteln.

Zitat:

Bei Deiner Messfunktion kommt bei mir 32 zu 20 raus und nicht 88 zu 53 wie bei Dir

Bei mir werkelt eine Intel P4 CPU.
AMD-CPUs schaffen wohl mehr in einem CPU-Takt, arbeiten aber (glaube ich, weiß ich aber nicht) mit niedrigeren Taktraten, als Intel-CPUs.

Zitat:

Hat das was mit der CPU Geschwindigkeit zu tun

Nein, sondern mit der unterschiedlichen Prozessor-Architektur.
Vorausgesetzt du benutzt gleiche Prozessor-Architekturen, sollten die benötigten CPU-Ticks auch bei unterschiedlichen CPU-Taktfrequenzen übereinstimmen. (meine Meinung....).

Zitat:

Ist Dein rdtsc gleichbedeutend mit : queryperformancecounter ? Damit messe ich immer.

Nein!
QueryPerformanceCounter tickt mit (bei mir) knapp 3.6 MHz.
RDTSC tickt mit dem CPU-Takt (bei mir) knapp 2.7 GHz, also um den Faktor 750 schneller. Bei AMD liegt dieser Faktor vermutlich niedriger.
Um sehr kleine Performance-Unterschiede zu messen, ist (meine Meinung) RDTSC besser geeignet.

[stoxx]

Hi Amateurprofi !
auf den ersten Blick hatte ich befürchtet, Du würdest das Vorzeichen Bit verwurschteln.
Aber ist ja nicht der Fall !
Ziemlich elegante Lösung, vielen Dank nochmal !!

Zitat:

AMD-CPUs schaffen wohl mehr in einem CPU-Takt, arbeiten aber (glaube ich, weiß ich aber nicht) mit niedrigeren Taktraten, als Intel-CPUs.

ja, ich habe einen AMD, war schon meine Vermutung, interessant !
Die Sache mit dem Array Zugriff werde ich mal als Anlass nehmen, meinen Quelltext mal nach Optimierungen zu durchsuchen !

Um nach einem Hin und Herwandeln wieder wirklich auf (Bit)-Gleichheit prüfen zu können, verwende ich meine xRound Funktion.
Dann ist 0,47 wieder wirklich gleich 0,47. Und man kann sich "abs(a-b) < Toleranz" sparen.

http://www.delphipraxis.net/internal...037&highlight=

Die sieht schon vom Quelltext sehr optimierungsfähig aus. Darf ich Dich da nochmal bemühen ?
Hast Du da auch noch eine wunderschöne Idee ?
Vielen Dank nochmal !!

[Amateurprofi]

Zitat:

Zitat von stoxx

Um nach einem Hin und Herwandeln wieder wirklich auf (Bit)-Gleichheit prüfen zu können, verwende ich meine xRound Funktion.
Dann ist 0,47 wieder wirklich gleich 0,47. Und man kann sich "abs(a-b) < Toleranz" sparen.
http://www.delphipraxis.net/internal...037&highlight=

Die sieht schon vom Quelltext sehr optimierungsfähig aus. Darf ich Dich da nochmal bemühen ?
Hast Du da auch noch eine wunderschöne Idee ?
Vielen Dank nochmal !!

Hallo Stoxx,
ja, habe ich, gehört aber wohl in den anderen Thread und da stelle ich das rein.