MyStrToHex extrem schnell

[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;

[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.

[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.

[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.

[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?