Funktionsaufruf: Dauert immer länger. Warum?

[3_of_8]

Zitat von Christian Seehase:

Wenn Du dieses verlängerst, muss, normaler Weise, jedesmal der Speicher neu angefordert, und der bisherige Inhalt dort hineinkopiert werden.

Naja, ned unbedingt. Ich bin mir jetzt nicht ganz sicher, aber ich denke schon, dass der Delphi-Speichermanager schlau genug ist, um das Array einfach zu vergrößern, wenn noch genug Platz dahinter frei ist - also es wird nicht bei jeder Größenänderung das gesamte Array kopiert.
Trotzdem ist es natürlich besser, eher einmal zu viel anzufordern als mehrmals stückchenweise.

EDIT: @Go2EITS: Strings sind, wie alle dynamischen Arrays, sowieso intern Pointer auf dem Stack, die auf irgendeinen Bereich auf dem Heap zeigen. Wenn du da was mit Pointern machst, ist das intern genau das gleiche, nur schwerer zu lesen.

[Go2EITS]

@3_of_8
Bin mir da nicht so sicher, ob es mit Pointern manchmal doch schneller geht...
Vielleicht, weil man dann maschinennäher programmiert?

[3_of_8]

Das kann man so allgemein nicht sagen. Du kannst auch in Assembler langsamen Code programmieren. Delphi verwaltet Strings intern auch einfach als Pointer auf den Heap. Anders kannst du es auch nicht machen.

[Go2EITS]

Ich habe die Version von Christian einfach mal probeweise mit der Mengenabfrage probiert.
Und das Ergebnis ist, 145 ms zu 45ms mit der Mengenabfrage! So sieht der momentan schnellste Code aus:

Delphi-Quellcode:

function ClearStr4(const Str: string): String;
const
ValidChars = ['a'..'z','A'..'Z','ä','ö','ü','Ä','Ö','Ü','ß',' '];
var
  i,x,count: Integer;
  begin
  if Str = '' then Exit;
  result:= '';
  count:= 1;
  SetLength(Result, Length(Str));
  for i:= 1 to Length(Str) do
      begin
      if str[i] in ValidChars then //Hier fragen wir die Menge ab.
         begin
         Result[Count]:= Str[i];
         Inc(Count);
         end;
      end;
  SetLength(result, Count-1);
  end;

Tabelle schlägt Menge ist hiermit wiederlegt. Mit FastMM4 und FastMove.pas gibt es nochmals einen Geschwindigkeitsschub.
Im Anhang die einzelnen Exen und den Source incl. der Exen beigefügt.
[Edit: Move.pas heißt FastMove.pas und //Break... aus Source entfernt]

[jaenicke]

Ich würde noch die impliziten Aufrufe von UniqueString unterdrücken indem ich diese Automatik durch Pointer aushebele. Damit komme ich auf ca. 20ms:

Delphi-Quellcode:

function ClearStr5(const Str: string): String;
const
  ValidChars = ['a'..'z','A'..'Z','ä','ö','ü','Ä','Ö','Ü','ß',' '];
var
  i, Len: Integer;
  CurIn, CurOut: ^Char;
begin
  Len := Length(Str);
  SetLength(Result, Len);
  CurIn := Pointer(Str);
  CurOut := Pointer(Result);
  for i := 1 to Len do
  begin
    if CurIn^ in ValidChars then
    begin
      CurOut^ := CurIn^;
      Inc(CurOut);
    end;
    Inc(CurIn);
  end;
  SetLength(Result, Integer(CurOut) - Integer(Pointer(Result)));
end;

[jbg]

Zitat von jaenicke:

CurIn, CurOut: ^Char;

Und hierfür gibt es bereits den Datentyp PChar.

Zitat:

SetLength(Result, Integer(CurOut) - Integer(Pointer(Result)));

Einen Zeiger in einen Integer zu konvertieren funktioniert unter Win32, aber unter Win64 wird der Code dann so nicht mehr funktionieren. Und da der Compiler eine Spezialbehandlung für PChar bereitstellt, kann man sich die Konvertierung nach Integer auch ganz sparen.

Zitat:

SetLength(Result, CurOut - PChar(Pointer(Result)));

[Go2EITS]

@Janicke
Was Pointer, richtig eingesetzt, bewirken können. Das Ergebnis und die vorhergehenden Vorschläge sind sehr lehrreich und wohl auch für andere DP'ler interessant. Vielen Dank!

[jaenicke]

Es hilft zur Optimierung oft in den generierten Assemblercode zu schauen. Ich wusste das ja nun schon, aber wenn man da nachschaut, dann sieht man, dass bei jedem Zugriff auf ein Zeichen UniqueString aufgerufen wird, wenn man normale Strings benutzt.

Mit PChar wie jbg sagte kann man das genauso verhindern, da diese Automatik nur bei Delphi-Strings passiert, deshalb ist das natürlich besser, wenn du das noch entsprechend änderst.

Der Grund für den Aufruf von UniqueString ist, dass Delphi (in 4 Byte beginnend 8 Byte vor dem Beginn des Strings, auf den der Pointer in der String-Variable zeigt) bei Strings einen Referenzzähler mitführt, der die Anzahl der Referenzen auf den String zählt um den String bei 0 verbleibenden Referenzen freizugeben. Deshalb wird bei jeder Veränderung des Strings mit UniqueString sichergestellt, dass man nicht einen anderweitig referenzierten String verändert. Und das eben bei jedem Zeichen.