MyStrToHex extrem schnell

[PeterPanino]

Hallo! Ich möchte folgende Funktion auf extreme Geschwindigkeit optimieren:

Delphi-Quellcode:

function MyStrToHex(s: string): string;
var
  i: Integer;
begin
  Result := '';
  for i := 1 to Length(s) do
    Result := Result + IntToHex(Ord(s[i]), 4);
end;

Kennt jemand eine Assembler-Version davon?

[Bernhard Geyer]

Du brauchst keine Assembler um zu beschleunigen

1, Ergänze ein const beim Aufrufparameter
2, Verwende den Stringbuilder den es in neueren Delphiversionen gibt.

[PeterPanino]

Meinst etwa so?:

Delphi-Quellcode:

function MyStrToHex(const s: TStringBuilder): TStringBuilder;
var
  i: Integer;
begin
  Result := TStringBuilder.Create;
  for i := 0 to s.Length - 1 do  
    Result.Append(IntToHex(Ord(s.Chars[i]), 4));  
end;

SB := TStringBuilder.Create;
SB.Append('Tᾯest');
SB := MyStrToHex(SB);
Self.Caption := SB.ToString;
SB.Free;

Aber damit scheint der Code nicht schneller, sondern eher langsamer geworden zu sein.

Außerdem mache ich mir Sorgen: Muss die in der Funktion MyStrToHex in Result erzeugte StringBuilder-Instanz nicht irgendwie freigegeben werden?

[Medium]

Wie wäre es damit:

Delphi-Quellcode:

function MyStrToHex(const s: string): string;
var
   i: Integer;
begin
   SetLength(Result, Length(s)*4);
   for i := 0 to Length(s)-1 do
     Move(IntToHex(Ord(s[i+1]), 4), Result[i*4+1], 4);
end;

Ich habe gerade kein Delphi zur Hand, eventuell ließe sich IntToHex() noch effizienter implementieren und inlinen.

[Bernhard Geyer]

Zitat von PeterPanino:

Meinst etwa so?:

Für die Methodensignatur kannst du weiter Strings nehmen.
Nur beim Zusammenbauen des Strings den Stringbuilder nehmen:

Delphi-Quellcode:

function MyStrToHex(const s: String): String;
var
  i: Integer;
  StrBuilder: TStringBuilder;
begin
  StrBuilder := TStringBuilder.Create;
  try
    for i := 0 to s.Length - 1 do 
      StrBuilder.Append(IntToHex(Ord(s[i]), 4)); 

    result := STrBuilder.ToString;
  finally
    StrBuilder.Free;
  end;
end;

Ansonsten probier Medium's Version.

[Uwe Raabe]

Kein Assembler, aber trotzdem recht schnell:

Delphi-Quellcode:

function MyStrToHex(const s: string): string;
const
  hex: array[0..15] of WideChar = '0123456789ABCDEF';
var
  I: Integer;
  W: WordRec;
  P: PChar;
begin
  SetLength(Result, 4*Length(S));
  P := PChar(Result);
  for I := 1 to Length(S) do
  begin
    W := WordRec(S[I]);
    P[0] := hex[W.Hi shr 4];
    P[1] := hex[W.Hi and $F];
    P[2] := hex[W.Lo shr 4];
    P[3] := hex[W.Lo and $F];
    Inc(P, 4);
  end;
end;

[Furtbichler]

IntToHex sollte sich optimieren lassen, z.B. über eine Lookuptabelle.

[PeterPanino]

Zitat von Bernhard Geyer:

Zitat von PeterPanino:

Meinst etwa so?:

Für die Methodensignatur kannst du weiter Strings nehmen.
Nur beim Zusammenbauen des Strings den Stringbuilder nehmen:

Delphi-Quellcode:

function MyStrToHex(const s: String): String;
var
  i: Integer;
  StrBuilder: TStringBuilder;
begin
  StrBuilder := TStringBuilder.Create;
  try
    for i := 0 to s.Length - 1 do 
      StrBuilder.Append(IntToHex(Ord(s[i]), 4)); 

    result := STrBuilder.ToString;
  finally
    StrBuilder.Free;
  end;
end;

Ansonsten probier Medium's Version.

Du meintest wahrscheinlich so:

Delphi-Quellcode:

function MyStrToHex(s: string): string;
var
  i: Integer;
  SB: TStringBuilder;
begin
  Result := '';
  SB := TStringBuilder.Create;
  try
    for i := 1 to Length(s) do
      SB.Append(IntToHex(Ord(s[i]), 4));
    Result := SB.ToString;
  finally
    SB.Free;
  end;
end;

Vielen Dank für den Tipp! Gibt es aber eine Erklärung dafür, wieso TStringBuilder.Append schneller sein soll als das traditionelle Zusammenfügen von Strings mit dem Additionszeichen?

[PeterPanino]

Zitat von Uwe Raabe:

Kein Assembler, aber trotzdem recht schnell:

Delphi-Quellcode:

function MyStrToHex(const s: string): string;
const
  hex: array[0..15] of WideChar = '0123456789ABCDEF';
var
  I: Integer;
  W: WordRec;
  P: PChar;
begin
  SetLength(Result, 4*Length(S));
  P := PChar(Result);
  for I := 1 to Length(S) do
  begin
    W := WordRec(S[I]);
    P[0] := hex[W.Hi shr 4];
    P[1] := hex[W.Hi and $F];
    P[2] := hex[W.Lo shr 4];
    P[3] := hex[W.Lo and $F];
    Inc(P, 4);
  end;
end;

Vielen Dank für den Tipp! Diese Version ist tatsächlich noch schneller als die StringBuilder-Version!

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.

[PeterPanino]

Für die Umkehrfunktion verwende ich folgende Konstruktion:

Delphi-Quellcode:

function MyStrToIntSafe(const Value: string; const ExceptionResult: Integer): Integer; inline;
begin
  try
    Result := StrToInt(Value);
  except
    Result := ExceptionResult;
  end;
end;

function MyHexToChar(const s: string; const i: Integer): Char; inline;
begin
  Result := Chr(MyStrToIntSafe('$' + Copy(s, i, 4), 63));
end;

function MyHexToStr(s: string): string;
var
  i, L: Integer;
begin
  Result := '';
  L := Length(s);
  i := 1;
  while i < L do
  begin
    Result := Result + MyHexToChar(s, i);
    Inc(i, 4);
  end;
end;

Hier habe ich durch Auslagerung von Schleifeninhalten in inline-Funktionen nochmals eine Geschwindigkeitssteigerung erreicht.