Wie schnellste Berechnung in einer Datenreihe ?

[Stefanie]

Ich habe eine Datenreihe mit ca. 5000 Werten in einem Array gespeichert. Nun möchte ich mit jedem Wert im Array Berechnungen mit anderen Werten durchführen lassen. Das hat eine hohe Anzahl von Schleifendurchläufen zur Folge. Unteres Bsp. soll mein Vorhaben ein wenig erklären. Bis die untere Procedure abgearbeitet ist dauerts auf meinem Rechner ca. 0,7 Sek. , bei 10000 Berechnungen – ist ja noch OK.
Aber bei 10 Mio Berechnungen pro Wert im QuellArray sind’s schon 7000 Sek. = 116 min und das ist mir ein wenig zu lang.
Gibt’s ne andere Möglichkeit, wie die ganze Sache effektiver berechnet wird oder ist gar die Sache mit dem Array nicht optimal.
Erfolgen Berechnungen in Datenbanken schneller ?

Bin dankbar für jeden Tip.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var i,j : integer;
    QuellDataArray, ZielDataArray : array[0..5000] of integer;
    starttime : tdatetime;
begin

  for i := 0 to 5000 do QuellDataArray[i] := random(1000000);

  starttime := now;

  for i := 5 to 4995 do
    for j := 0 to 10000 do ZielDataArray[i] := QuellDataArray[i] + QuellDataArray[i – 5 + random(10)];


  button1.Caption := formatdatetime('ss:zzz "Sek."' ,now - starttime);
end;

[roderich]

hallo Stefanie,

was mich wundert, daß sich die Rechenzeit offensichtlich nicht linear zur Arraygröße verhält. Bei 10 Mio Werten müßte es theoretisch 5000 mal so lange dauern, bei dir ist es aber der Faktor 10000. Möglicherweise passt das größere Array nicht in den Prozessorcache (first/second)....?!? Verwundern kann die Rechenzeit jedenfalls nicht bei 5000*10000 (=50 Mio) bzw. 10000000*10000 (=100 Milliarden) Operationen, von denen jede aus einer mehrteiligen Berechnung und Indizierung besteht.

Ich denke nicht (weiß es aber ehrlich auch nicht), daß es in einer Datenbank schneller ginge. Es sei denn, die Hardwarevoraussetzungen auf dem DB-Server sind deutlich besser.

Was aber auf jeden Fall mein Tip ist: Das Ausschalten aller Compiler-Direktiven wie Range check bringt bei Arrays mit indiziertem Zugriff enorm viel an Geschwindigkeit -> {$R-} bzw. Projekt-Optionen/Compiler/Bereichsüberprüfung, Überlaufprüfung, Debug etc.


Roderich

[Binärbaum]

Mir kommt dieser Abschnitt etwas seltsam vor:

Delphi-Quellcode:

...
  for i := 5 to 4995 do
    for j := 0 to 10000 do ZielDataArray[i] := QuellDataArray[i] + QuellDataArray[i – 5 + random(10)];
...

Wozu brauchst du die zweite for-Schleife, wenn die Variable j nicht benutzt wird?
Letztlich wird in diesem Abschnitt doch 10001 mal ein Wert zugewiesen, obwohl nur die letzte Zuweisung entscheidend ist, da alle vorigen Werte wieder überschrieben werden. Also ist die zweite for-Schleife doch eigentlich garnicht nötig, oder?
Es müsste also

Delphi-Quellcode:

...
  for i := 5 to 4995 do
    ZielDataArray[i] := QuellDataArray[i] + QuellDataArray[i – 5 + random(10)];
...

reichen, um den selben Effekt zu erzielen.

MfG
Binärbaum

[Stefanie]

Danke euch beiden

Zitat:

Was aber auf jeden Fall mein Tip ist: Das Ausschalten aller Compiler-Direktiven wie Range check bringt bei Arrays mit indiziertem Zugriff enorm viel an Geschwindigkeit -> {$R-} bzw. Projekt-Optionen/Compiler/Bereichsüberprüfung, Überlaufprüfung, Debug etc.

Ich hab's mal so probiert, hat aber leider bei mir keinen Geschwindigkeitsvorteil gebracht. Sind trotz aller Deaktivierungen immer noch 0,7 Sek.

Zitat:

Mir kommt dieser Abschnitt etwas seltsam vor:

Delphi-Quellcode:

...
  for i := 5 to 4995 do
    for j := 0 to 10000 do ZielDataArray[i] := QuellDataArray[i] + QuellDataArray[i – 5 + random(10)];
...

Das mag in meinem Bsp. wirklich ein wenig unsinnig aussehen - ist eben nur ein Bsp. (in meiner Anwendung brauche ich 'j')

Das mit den XXX-Mrd. Operationen stimmt, aber ich denke wie man dies programmiert macht auch einen Unterschied in der Performance.
Ursprünglich war mein Array ja 'of Double', da ich aber meine Werte mit einem Faktor auf ganze Zahle krieg geht auch ein 'Array of Integer' Allein das brachte eine ca.3-fach höhere Performance.

Vielleicht gibts ja noch ein paar andere Sachen, die die "Performancebremse" lösen :-).

[Jelly]

@Stefanie:
was willst du denn überhaupt rechnen... Wenn du eine for...next Schleife einige Milliarden mal durchläfst, dauert das nun halt mal. Aber eventuell gibts einen gescheiteren Algorithmus, der effizienter arbeitet... Es gibt auch schnelle und langsame Sortierverfahren.

[Blechwolf]

Evtl. (bei o.g. Beispiel fällt mir jetzt nicht auf wie das gehen sollte) kannst Du auch folgenden Trick benutzen.

Beispiel mit konkreten Zahlen

Wert1 := 1+2+3+4+5+6+7
Wert2 := 2+3+4+5+6+7+8
Wert3 := 3+4+5+6+7+8+9
...

Dann kann man Wert1 einmal berechnen und dann einfach folgende Vereinfachung verwenden
Wert1 := 1+2+3+4+5+6+7
Wert2 := (Wert1 - 1) + 8
Wert3 := (Wert2 - 2) + 9
etc.

Wenn man den konkreten Quellcode hätte, könnte man evtl. genauere Aussagen treffen wo Du die Performance verlierst. Generelle Aussagen zum Tuning sind immer sehr schwer zu treffen.

Grüße

Wolf

[roderich]

@Stefanie

habs jetzt auch mal probiert, bei mir bringen die Compiler-Schalter ungefähr 30% schnellere Geschwindigkeit.
Du mußt vermutlich dein Projekt neu erzeugen, damit die Compiler-Schalter auch in der Unit wirken.

Roderich

[Stefanie]

Danke euch allen. :-)