Hallo,

Kann mir jemand, der die Vollversion von Delphi 2007 hat, sagen, wie die Funktionen UpperCase() und LowerCase() dort intern implementiert sind? (Ich hoffe, dass ist erlaubt.)
Ich habe leider nur die Testversion.

Ich frage das, weil mich erstens interessiert, wieso diese Funktionen so extrem schnell sind - keine 2 Sekunden für 100.000.000 Durchläufe! Selbst eine Funktion, mit gerade mal einer einzigen Zuweisung, ist fast 3x so langsam! Wie kann das sein?
Optimierte UpperCase() Funktionen, wie z.B diese hier, sind auch viel langsamer.

Und zweitens brauche ich genau diese schnellen Funktionen als Prozedur mit Referenzparameter, also so, dass der Eingabestring direkt verändert wird. (Diese würde ich mir dann selber bauen, wenn ich den Quellcode hätte.)

Ich hoffe auf Hilfe, Danke!

Hatte sogar eine Null vergessen^^

Lade Dir die FastCode Library runter, da ist die UpperCase Variante (fast) die gleiche.

Interessant wäre auch, wie Du die Funktionen testest. Nicht das Du einer Optimierung in die Falle gegangen bist.

ich glaub da bist du eher einer Speicheroptimierung zum Opfer gefallen

UpperCase macht nicht viel, außer
den Eingabestring zu kopieren und dabei bei allen Zeichen von "a" bis "z" um Ord(32) anzuheben

die Stringrückgabewerde in Delphi werden intern als Var-Parameter übergeben

also

markieren

Delphi-Quellcode:

function UpperCase(const S: String): String;
  begin
    ...
  end;

for i := 1 to 1000 do
  UpperCase(S);

wird in das hier übersetzt

zusammenfalten · markieren

Delphi-Quellcode:

procedure UpperCase(const S: String Var Result: String);
  var i: Integer;
    C: Char;

  begin
    SetLength(Result, Length(S));
    for i := 1 to Length(S) do begin
      C := S[i];
      if C in ['a'..'z'] then Inc(C, 32);
      Result[i] := C;
    end;
  end;

for i := 1 to 1000 do
  UpperCase(S, TempString);

und wie du nun bemerkst, wird hier kaum etwas gemacht, außer die Zeichen zu kopieren

der Flaschenhals bei Stringoperationen ist aber das reservieren/freigeben des Strings und dieses wird hier nur je einmal am Anfang und am Ende gemacht und ansonsten ist der String selber ja komplett unverändert.


PS: das UpperCase da oben ist die unoptimierte Kurzfassung dessen, was die Funktion macht


Und FastUpcase ruft intern je Zeichen auch noch eine Extrafunktion (UpCase) auf, wärend UpperCase das selber macht (pro Zeichen 2 Sprungoperationen weniger)

ein Test mit AnsiUpperCase würde in Delphi wohl auch andere Ergebnisse liefern, da dieses etwas genauer übersetzt (samt umlauten wie äöü)

oder versuche mal diese Version

zusammenfalten · markieren

Delphi-Quellcode:

function FastUpperCase(const S: String): String;
var
  C: ^Char;
  I: Integer;
begin
  SetLength(Result, Length(S);
  C := Addr(Result[1]);
  for I := 0 to Length(Result) - 1 do
  begin
    C^ := UpCase(C^);
    C := Ptr(Integer(C) + SizeOf(Char));
  end;
end;

in der anderen Version (siehe dein Link)
wird eine Kopie von S angelegt, das die eigentliche Result-Variable freigegeben und durch die Kopie ersetzt (also Speicher freigeben+Speicher reservieren)

SetLength sorgt aber auch für einen "unique" String, allerdings ändert (oder auch nicht, wenn er es schon ist) es hier nur den Result und ersetzt ihn nicht

@Satty: Danke, das sieht schon ganz gut aus, nur leider kann ich davon nichts ändern, weil ich von Assembler keine Ahnung habe.
Diese ganzen FastCode Sachen sind auch etwas langsamer (~500ms)
Getestet habe ich das übrigens so:

markieren

Delphi-Quellcode:

var a:cardinal;i:integer;s:string;
begin
a:=gettickcount;
for i := 1 to 100000000 do s:=uppercase('hallo');
showmessage(inttostr(gettickcount-a));
end;

(Ich weiss, GetTickCount() ist sehr ungenau, aber hier sollte es doch reichen?)

Also Eigentlich suche ich nur eine Funktion, die genauso oder schneller ist und so arbeitet: procedure UpperCase(var S: string);
@himitsu
Danke, ich habe es jetzt mal so gemacht:

zusammenfalten · markieren

Delphi-Quellcode:

procedure FastUpperCase(var S: String); //inline;
var
  C: ^Char;
  I,j: Integer;
begin
  C := Addr(S[1]); j:=sizeof(char);
  for I := 0 to Length(S) - 1 do
  begin
    if (C^ >= 'a') and (C^ <= 'z') then C^ := UpCase(C^);
    C := Ptr(Integer(C) + j);
  end;
end;

Weit unter 2 Sekunden Damit kann ich leben.

dieser Test entspricht aber keinesfalls den realen Bedingungen, also im Grunde kannst du diese Testergebnisse vergessen, da sich ja wohl im Normalfalls der Eingangsstring unterscheidet.

um wenigstens ein bissl den Realbedingungen nahzukommen, versuch mal die Funktionen hiermit zu testen:

zusammenfalten · markieren

Delphi-Quellcode:

var a:cardinal;i:integer;s,s1,s2:string;

a:=gettickcount;
s1:='hallo';
s2:='hallo2';
for i := 1 to 10000000 do begin
  if Odd(i) then s := s1 else s := s2;
  s := uppercase(s);
  if s = '' then ;
end;
showmessage(inttostr(gettickcount-a));

Zitat von luke2:

Danke, ich habe es jetzt mal so gemacht:

zusammenfalten · markieren

Delphi-Quellcode:

procedure FastUpperCase(var S: String); //inline;
var
  C: ^Char;
  I,j: Integer;
begin
  C := Addr(S[1]); j:=sizeof(char);
  for I := 0 to Length(S) - 1 do
  begin
    if (C^ >= 'a') and (C^ <= 'z') then C^ := UpCase(C^);
    C := Ptr(Integer(C) + j);
  end;
end;

Da stehen einem ja die Haare zu Berge. Wenn man schon mit Zeigern um sich wirft, dann aber bitte richtig und vor allem ohne S über die Hintertür zu manipulieren und somit andere Strings zu verändern, die zufälligerweise auf den selben Speicherplatz zeigen (Copy-On-Write). Und vor allem sollte man keine konstanten (=read only) Strings beschreiben, da das nur zu Schutzverletzungen führt.

zusammenfalten · markieren

Delphi-Quellcode:

procedure FastUpperCase(var S: String);
var
  P: PChar;
  Len: Integer;
begin
  { Garantieren, dass keine andere String-Referenz auf unseren Speicher
    zeigt (Copy-on-Write) }
  UniqueString(S);

  {$STRINGCHECKS OFF} // grrr... Wir wollen diesen Unsinn nicht, der den Code
  Len := Length(S); // nur aufbläht, verlangsamt und für Delphi und gescheite
  {$STRINGCHECKS ON}  // C++Builder Entwickler keinen Mehrwehrt bringt.
  P := PChar(S);
  for Len := Len downto 1 do
  begin
    case P^ of // Delphi 2009 Workaround für "in ['a'..'z']" Warnung, gleicher Maschinencode
      'a'..'z':
        P^ := Char(Ord(P^) xor $20); // Die Eigenschaften der ASCII-Tabelle ausnutzen
    end;
    Inc(P);
  end;
end;

{$STRINGCHECKS OFF} // grrr... Wir wollen diesen Unsinn nicht, der den Code Das existiert bei mit gar nicht:
-> [DCC Fehler] mlUtils.pas(6165): E1030 Ungültige Compileranweisung: 'STRINGCHECKS'

Hier aber nochmal die Deutsche Version (ö,ä,ü) + LowerCase:

zusammenfalten · markieren

Delphi-Quellcode:

procedure UpCaseFst(var S: string); overload;
var
  P: PChar;
  Len: Integer;
begin
  { Garantieren, dass keine andere String-Referenz auf unseren Speicher zeigt (Copy-on-Write) }
  UniqueString(S);
              
  Len := Length(S); // nur aufbläht, verlangsamt und für Delphi und gescheite
  P := PChar(S);
  for Len := Len downto 1 do
  begin
    case P^ of // Delphi 2009 Workaround für "in ['a'..'z']" Warnung, gleicher Maschinencode
      'a'..'z':
        P^ := Char(Ord(P^) xor $20); // Die Eigenschaften der ASCII-Tabelle ausnutzen
      'ö': P^ := 'Ö';
      'ä': P^ := 'Ä';
      'ü': P^ := 'Ü';
    end;
    Inc(P);
  end;
end;

zusammenfalten · markieren

Delphi-Quellcode:

procedure LwCaseFst(var S: string); overload;
var
  P: PChar;
  Len: Integer;
begin
  { Garantieren, dass keine andere String-Referenz auf unseren Speicher zeigt (Copy-on-Write) }
  UniqueString(S);

  Len := Length(S); // nur aufbläht, verlangsamt und für Delphi und gescheite
  P := PChar(S);
  for Len := Len downto 1 do
  begin
    case P^ of // Delphi 2009 Workaround für "in ['a'..'z']" Warnung, gleicher Maschinencode
      'A'..'Z': P^ := Char(Ord(P^) or $20); // Die Eigenschaften der ASCII-Tabelle ausnutzen
      'Ö': P^ := 'ö';
      'Ä': P^ := 'ä';
      'Ü': P^ := 'ü';
    end;
    Inc(P);
  end;
end;

Ob das jetzt immernoch die Highendoptimierung ist, weiß ich nicht.

Zitat von mleyen:

Das existiert bei mit gar nicht:
-> [DCC Fehler] mlUtils.pas(6165): E1030 Ungültige Compileranweisung: 'STRINGCHECKS'

das ist so'nen Delphi2009-Dingens, wo man versuchte, anstatt alles "nur" auf Unicode umzustellen, eine Prüfung zu machen, was stattdessen übergeben wurde, oder irgendwie so

Zitat von mleyen:

Hier aber nochmal die Deutsche Version (ö,ä,ü) + LowerCase...

Es gibt keine 'deutsche Version' von 'Uppercase', also ist deine Variante nicht mehr kompatibel und liefert andere Ergebnisse. Außerdem funktioniert das dann auch nicht mehr für eingestreute Fremdwörter, was im Deutschen ja durchaus gebräuchlich ist.

Zitat von alzaimar:

Außerdem funktioniert das dann auch nicht mehr für eingestreute Fremdwörter, was im Deutschen ja durchaus gebräuchlich ist.

Solche deutsche Wörter, wo die Up/LwCase Prozedur nicht funktioniert, sind mir jetzt zwar nicht bekannt, aber du hast schon recht.
Delphi lässt öäü einfach wie es ist. Nur dieses Verhalten wurd mir gestern heute morgen zum Verhängnis und beim Ändern hab ich nicht drauf geachtet wie Delphi das handhabt.
Eigentlich wollte ich hier nur die LowCase Variante mit dem or-Operator darstellen.
Wer öäü immer selber im Programm behandeln will, kann das ja schnell rausnehmen.