Schneller Code - Von Delete und Insert -> Copy -> ???

[-Lucky-]

Ich gebe gerade alles um meinen Quellcode so effektiv wie möglich zu machen. Kurz zum Thema, mein Programm führt ein paar Millionen Prozesse aus, was genau tut nix zur Sache.

Vor einiger Zeit bin ich schon dahinter gestiegen, dass Delete und Insert ein großes Problem darstellen. Bei mehreren Tausend aufrufen ist schon spürbar eine lange Zeitdauer erkennbar. Diesbezüglich habe ich Insert und Delete schon entfert und durch andere Prozeduren ersetzt. Durch die Funktion Copy war dies schon eine einfache Lösung, es geht nun um ein x faches schneller, aus mehreren Tagen Arbeitszeit wurden wenige Minuten - lol -

Nun wäre es aber optimal, wenn wir Copy auch noch durch etwas anderes in irgendeiner weise ersetzen können. Denn Copy dauert mir auch viel zu lange um es auf den Punkt zu bringen. Aber ich weiß auch, dass man nicht alles im Leben haben kann

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var text1,text2: string;
i: integer;
begin
  ShowMessage('Messung starten');
  for i := 1 to 50 do
  begin
    text1 := FileToString('abc.xyz');  // datei hat nix zu sagen, dient als temp. Datenquelle
    text2 := copy(text1,20000,500000) + copy(text1,1,19999) + copy(text1,500001,length(text1));
  end;
  ShowMessage('Fertig');
end;

-->> Dies dauert knapp 3 Sekunden

Ein Versuch Copy effektiver zu machen scheiterte jedoch

Delphi-Quellcode:

procedure TForm1.Button3Click(Sender: TObject);
var text1,text2: string;
i,j: integer;
begin
  ShowMessage('Messung starten');
  for i := 1 to 50 do
  begin
    text2 := '';
    text1 := FileToString('abc.xyz');  // große Datei als temp. Datenquelle
    for j := 20000 to 500000 do
    text2 := text2 + text1[j];
    for j := 1 to 19999 do
    text2 := text2 + text1[j];
    for j := 500001 to length(text1) do
    text2 := text2 + text1[j];
  end;
  ShowMessage('Fertig');
end;

Dies dauert nun ca. 62 Minuten, damit habe ich also das Gegenteil erreicht von dem, was ich erreichen wollte.

Würde man dies oben, statt mit Copy, durch Delete und Insert versuchen zu erreichen, dann würde der ganze Prozess halt auch keine 3 Sekunden mehr dauern, sondern um einiges Länger. Wer mir nicht glaubt, einfach ausprobieren, hab hierfür auch nen Analyseprogramm geschrieben.

Nun ist die Frage, ob wir etwas noch effektiveres als Copy finden. Ich weiß, dass Copy im Vergleich zu Delete und Insert sehr, sehr effektiv ist, als schnelle Alternative. Aber könnte man das noch etwas umschreiben dass man hier noch schneller arbeitet?

Wenn das Programm einige Milliarde Zeichenketten analysieren soll, dann dauert dies so immer noch zu lange, da bin ich Opa bevor ich das Ergebnis habe

Sollte jedoch insgesammt nicht länger dauern, als dass man zwischendurch nen trinken kann. Max. ne Stunde. Falls euch da was schnelleres einfällt, einfach sagen. Der Quellcode oben dient nur zum Zeitmessen, hat also keine Bedeutung. Die Datei ist ca. 12MB groß und besteht aus sinnlosen Daten.

[nicodex]

Die drei extrahierten Strings zu addieren dauert auch seine Zeit.
Du könntest den Zielstring bereits auf die richtige Länge bringen und die Daten per Move kopieren.
Schau dann mal im CPU-Fenster nach, ob diverse Compiler-Funktionen aufgerufen werden (UniqueString etc).

[-Lucky-]

Was ich mit diesem Delete und Insert meine ist folgendes. In diesem Beispiel werden einfach zwei Zeichen in einer in einem beliebigen Text getauscht, habe jetzt mal nur die Prozeduren aufgeführt:

Delphi-Quellcode:

procedure tauschen1(VAR text: string; x,y: integer);
var a,b: char;
Begin
  a := text[x];
  b := text[y];
  delete(text,x,1);
  insert(b,text,x);
  delete(text,y,1);
  insert(a,text,y);
End;

procedure tauschen2(VAR text: string; x,y: integer);
var b: char;
Begin
  b := text[x];
  text[x] := text[y];
  text[y] := b;
End;

Das Analyseergebnis:

Bei Tauschen 1:

Zeichen: - Zeit:
1.000 - 7,1 s
1.000.000 - 116 min, 0 s
1.000.000.000 - 80d, 13h, 12min


Bei Tauschen 2:

Zeichen: - Zeit:
1.000 - <0,1 s
1.000.000 - <0,1 s
1.000.000.000 - 14,6 s


Warum die eine Prozedur wesentlich länger braucht ist mir klar, ich kann logisch nachvollziehen wie Delete und Insert funktionieren, und dass dort mehr Schritte nötig sind, als wenn der Text einfach nur überschrieben wird, also dieses eine Zeichen.

Kann man irgendwo nachlesen, was bei den einzelnen Funktionen und Prozeduren genau gemacht wird? Weil diese setzen sich sicherlich aus anderen kleineren Bestandteilen zusammen wenn ihr versteht was ich meine. Versteht ihr?

[-Lucky-]

Zitat von nicodex:

Du könntest den Zielstring bereits auf die richtige Länge bringen und die Daten per Move kopieren.

So genau habe ich das jetzt nicht verstanden... Könntest du mir einen Beispielquellcode geben damit ich das nachvollziehen kann? Dann werde ichs ausprobieren und analysieren.

[himitsu]

für 2 Strings:

Delphi-Quellcode:

S := S1 + S2;

>>

SetLength(s, Length(s1) + Length(s2));
MoveMemory(@s[1], @s1[1], Length(s1));
MoveMemory(@s[1 + Length(s1)], @s2[1], Length(s2));

nja, aber eigentlich macht Delphi intern auch nix anderes und wandelt das etwa in S := LStrCat(s1, s2); um, welches auch sowas macht

aber

Delphi-Quellcode:

s := Copy(s1, 10, 20) + Copy(s2, 1, 10);

>>

SetLength(s, 30);
MoveMemory(@s[1], @s1[10], 20);
MoveMemory(@s[21], @s2[1], 10);

Copy würde ja je einen neuen temporären String anlegen.

!! alles ohne Prüfung der Parameter

[grenzgaenger]

sag mal, was willste da kopieren? ist das willkürlich oder gibt es da 'ne logik dahinter? falls logik, könnt man da vielleicht die grossen zeitfresser ausscheiden... . aber so, schichtest du den ganzen speicher 'n paar mal um, und das kostet halt zeit...

<HTH>

[-Lucky-]

Also erstmal danke @ himitsu, ich werde gleich mal testen, wieviel % das schneller ist als mit der copy Methode, und das Ergebnis hier bekannt geben.

@grenzgaenger, nein, das hat in diesem Fall keine Logik

Aber das Ergebnis kann man logisch verwenden. Es geht um das Thema Kryptologie. Der Quellcode muss so effektiv sein, dass man ihn mit keiner anderen Programmiersprache oder anderen Mitteln nachprogrammieren könnte, und es dann schneller weil der PC taktisch weniger Rechnen muss. Verstehen musst du das nicht. Die großen Zeitfresser habe ich ja schon aussortiert, aber da muss alles raus, was man womöglich mit anderen Mitteln effektiver erreichen kann. Es soll quasi unmöglich sein, den Code so zu schreiben, dass der PC es schneller entschlüsseln kann, als mit diesem Programm. Hierbei ist wirklich jeder Bruchteil einer Sekunde entscheidend.

[nicodex]

Vielleicht solltest du dir AQtime ansehen...

[grenzgaenger]

Zitat von -Lucky-:

Also erstmal danke @ himitsu, ich werde gleich mal testen, wieviel % das schneller ist als mit der copy Methode, und das Ergebnis hier bekannt geben.

@grenzgaenger, nein, das hat in diesem Fall keine Logik

Aber das Ergebnis kann man logisch verwenden. Es geht um das Thema Kryptologie. Der Quellcode muss so effektiv sein, dass man ihn mit keiner anderen Programmiersprache oder anderen Mitteln nachprogrammieren könnte, und es dann schneller weil der PC taktisch weniger Rechnen muss. Verstehen musst du das nicht. Die großen Zeitfresser habe ich ja schon aussortiert, aber da muss alles raus, was man womöglich mit anderen Mitteln effektiver erreichen kann. Es soll quasi unmöglich sein, den Code so zu schreiben, dass der PC es schneller entschlüsseln kann, als mit diesem Programm. Hierbei ist wirklich jeder Bruchteil einer Sekunde entscheidend.

machst da einen wettbewerb mit 'n kollegen? denn sonst, wirst du das ziel nicht erreichen. auf der anderen seite sitzen profis, welche das ganze jahr nix anderes zu tun haben ausser deinen code zu knacken ... und die haben auch die schnellsten rechner... also, das ziel, wirst du nicht erreichen. ausserdem, heisst es nicht, dass 'n andere das nicht auch knacken kann, wenn er 'n paar minuten warten kann.

tja, wenn es keine logik hat, solltest du beim copy bleiben. das ist das beste. falls doch etwas mehr logik... den speicher zuerst ausrechnen und dann gemeinsam dort hin kopieren (himitsu hat den code bereits gequoted). sollte das noch nicht ausreichen kannst du nach der logischen optimeriung noch mit assembler anfangen... wenn die logik passt, dann wirst du da auch nicht mehr das grosse rausholen. denn der move in 'n bestimmten bereich ist schon sehr schnell.

Zitat von nicodex:

Vielleicht solltest du dir AQtime ansehen...

aber erst, wenn die logik sauber durchdacht und optimiert ist...

<HTH> GG

[QuickAndDirty]

Ich weiß nicht aber Delphi Strings sind ja verwaltete Objekte vielleicht macht es sinn nicht mit Strings zu arbeiten,
sondern mit Speicherblöcken und dann mit den Zeichenketten Verarbeitungs Befehlen des Assemblers zu kopieren.

Einerseits fällt das bei 12MB Großen Strings auch nicht mehr ins Gewicht andererseits könnte jemand
anderes dadurch schneller sein.

Überhaupt hat eine Hochsprache keine Chance gegen einen handoptimierten Assemblercode ,
es ist meist nur einfach unwirtschaftlich.