MyStrToHex extrem schnell

[PeterPanino]

Bzw. hier die StringBuilder-Version mit hinzugefügtem const-Modifier:

Delphi-Quellcode:

function MyHexToStr(const s: string): string;
var
  i, L: Integer;
  SB: TStringBuilder;
begin
  Result := '';
  L := Length(s);
  i := 1;
  SB := TStringBuilder.Create;
  try
    while i < L do
    begin
      SB.Append(MyHexToChar(s, i));
      Inc(i, 4);
    end;
    Result := SB.ToString;
  finally
    SB.Free;
  end;
end;

Scheint nochmals um eine kleine Spur schneller zu sein.

[Furtbichler]

Zitat von Uwe Raabe:

Kein Assembler, aber trotzdem recht schnell:

Hmm. Bei ungeraden Stringlängen keine gute Lösung.

Edit: Doch doch, alles ok.

[PeterPanino]

Zitat von Furtbichler:

Zitat von Uwe Raabe:

Kein Assembler, aber trotzdem recht schnell:

Hmm. Bei ungeraden Stringlängen keine gute Lösung.

Meinst du die Länge des an die Funktion übergebenen Strings s oder die Konstante 4?

[Furtbichler]

Bei ungerader Stringlänge wird der letzte Zugriff auf WordRec(s[i]) über das letzte Zeichen des Strings hinaus gehen.

Edit: Blödsinn, wir reden von WideChars... Ich nehme alles zurück.

[Furtbichler]

Hier ist mein Beitrag; 5x schneller als die Variante von Uwe Raabe. Das Ende der Fahnenstange ist bestimmt noch nicht erreicht.

Delphi-Quellcode:

Type
  THexLookup = Array [WideChar] Of Integer;
Var
  HexLookup  : ^THexLookup;

Procedure BuildHexLookup;
Var
  w : Word;
  s : String;

Begin
  New(HexLookup);
  for w := 0 to 65535 do begin
    s := IntToHex(w,4);
    Move(s[1], HexLookup^[WideChar(w)],4);
  end;
End;

function FurtbichlerStrToHex(const s: Widestring): string;
var
   i : Integer;
   p : PIntegerArray;

begin
   SetLength(Result, 4*Length(s));
   p := @Result[1];
   for i := 1 to Length(s) do 
     p^[i-1] := HexLookup^[s[i]];

end;

...
initialization
  BuildHexLookup;

[Bernhard Geyer]

Und wenn man dann auch noch Rangechecks & Co nur für diese Funktion immer abschaltet bekommt man noch ein paar Prozent raus.

[Uwe Raabe]

Zitat von PeterPanino:

Ich habe mir auch überlegt, ob man den Schleifeninhalt nicht etwa in eine inline-Funktion auslagern kann, um die Geschwindigkeit nochmal zu steigern, sehe aber keine Möglichkeit dafür.

Inline bedeutet ja nur, daß der Compiler für dich den Code an den jeweiligen Aufrufen einfügt. Solange du den Schleifeninhalt nicht noch anderweitig verwendest, gewinnst du damit gar nichts.

[PeterPanino]

Zitat von Uwe Raabe:

Zitat von PeterPanino:

Ich habe mir auch überlegt, ob man den Schleifeninhalt nicht etwa in eine inline-Funktion auslagern kann, um die Geschwindigkeit nochmal zu steigern, sehe aber keine Möglichkeit dafür.

Inline bedeutet ja nur, daß der Compiler für dich den Code an den jeweiligen Aufrufen einfügt. Solange du den Schleifeninhalt nicht noch anderweitig verwendest, gewinnst du damit gar nichts.

Ich dachte, mit inline kann man Funktionen beschleunigen, die sehr oft aufgerufen werden?

[Uwe Raabe]

Zitat von PeterPanino:

Ich dachte, mit inline kann man Funktionen beschleunigen, die sehr oft aufgerufen werden?

Bei einem normalen Funktionsaufruf werden die Parameter auf dem Stack übergeben und ein echter Aufruf ausgeführt. Ist eine Methode als inline deklariert, fügt der Compiler den Code aus der Methode bei jedem Aufruf direkt an der Stelle ein, an der die Funktion aufgerufen wird. Es ist faktisch dasselbe als wenn man selbst die Funktion jedesmal an die Aufrufstelle kopiert.

Delphi-Quellcode:

procedure Step(var A, B: Integer); inline;
begin
  Inc(A);
  Inc(B);
end;

var
  I, J, N: Integer;
begin
  I := 0;
  J := I + 1;
  for N := 1 to 10 do 
    Step(I, J);
end;

Ist also vom Compilat her identisch mit

Delphi-Quellcode:

var
  I, J, N: Integer;
begin
  I := 0;
  J := I + 1;
  for N := 1 to 10 do begin 
    Inc(I);
    Inc(J);
  end;
end;

Natürlich ist das schneller als der Funktionsaufruf ohne inline, da einige zusätzliche Befehle eingespart werden. Man kann also mit inline einen Funktionsaufruf schneller machen, aber nur wenn tatsächlich ein Aufruf stattfindet.

[PeterPanino]

Zitat von Furtbichler:

Hier ist mein Beitrag; 5x schneller als die Variante von Uwe Raabe. Das Ende der Fahnenstange ist bestimmt noch nicht erreicht.

Delphi-Quellcode:

Type
  THexLookup = Array [WideChar] Of Integer;
Var
  HexLookup  : ^THexLookup;

Procedure BuildHexLookup;
Var
  w : Word;
  s : String;

Begin
  New(HexLookup);
  for w := 0 to 65535 do begin
    s := IntToHex(w,4);
    Move(s[1], HexLookup^[WideChar(w)],4);
  end;
End;

function FurtbichlerStrToHex(const s: Widestring): string;
var
   i : Integer;
   p : PIntegerArray;

begin
   SetLength(Result, 4*Length(s));
   p := @Result[1];
   for i := 1 to Length(s) do 
     p^[i-1] := HexLookup^[s[i]];

end;

...
initialization
  BuildHexLookup;

Mhmm, irgendwas scheint da nicht zu funktionieren - das Programm braucht nun ca. 100 mal länger als vorher, um den Code auszuführen. Ich verstehe den Code nicht, deswegen kann ich nicht sagen, wo der Fehler liegt.