Abschlussprojekt FIAE (Optimierung von Algorithmen) -> Vergleich von Polygonen

[TiGü]

Zitat:

Zitat von Gyrospeter (Beitrag 1503414)

Zitat:

Zitat von TiGü (Beitrag 1503402)

Bei RemoveIdenticalFromList musst du anhand deiner Testdaten prüfen, wie oft es wirklich vorkommt, dass wirklich doppelte und aufeinanderfolgende Einträge existieren.

Durch das Delete wird TListHelper.InternalDoDeleteN aufgerufen und das sorgt durch den Move Befehl für teure Speicheroperationen.
Vielleicht wäre hier ein Ansatz mit temporärer Liste mit vor initialisierter Länge besser, in der du nur die Elemente packst, die nicht doppelt sind.

Das ist eine gute Idee, müsste also dementsprechend nur jedes Element einzeln in die neue Liste packen und die Capacity der temporären Liste vordefinieren. Wie weiß ich denn dennoch, wie viele Elemente ich da reinpacken muss? Oder muss ich die Capacity nach jedem neu hinzugefügten Element um 1 erweitern?

Die Capacity der temporären Liste würde ich so wählen, dass ohne große Neuallokation von Speicher der Inhalt der zu überprüfenden Liste reinpasst.
Also NewCapacity := Round(1.5 * OldList.Count) so als Startwert, man kann sich rantasten.
Damit ist der Platz schonmal vor reserviert und es kann ja durchaus vorkommen, dass keine Doppelungen vorkommen.
Immer wenn not IsListItemEqual dann wahr wird, kann der aktuelle Eintrag hinzugefügt werden.

[freimatz]

Hoi,
gemeint ist das.
Gemeint ist also das Messen der Zeiten in Deinen alten Code um herauszufinden wo es klemmt.

[TurboMagic]

In manchen Delphi Versionen war eine Lite Version von AQTime dabei, es gibt aber auch andere Profiler.
Hat man ein neu genuges Delphi findet man glaube ich auch einen in GetIt, was ja aber in XE2 noch nicht
vorhanden ist, falls das wirklich die von dir genutzte Version ist.

Natürlich haben neuere Delphi versionen auch die eine oder andere Performance Verbesserung mit drin...

[Gyrospeter]

Zitat:

Zitat von freimatz (Beitrag 1503426)

Hoi,
gemeint ist das.
Gemeint ist also das Messen der Zeiten in Deinen alten Code um herauszufinden wo es klemmt.

Vielen Dank. Jetzt bin ich wieder etwas schlauer geworden =)

Zitat:

Zitat von TurboMagic (Beitrag 1503428)

In manchen Delphi Versionen war eine Lite Version von AQTime dabei, es gibt aber auch andere Profiler.
Hat man ein neu genuges Delphi findet man glaube ich auch einen in GetIt, was ja aber in XE2 noch nicht
vorhanden ist, falls das wirklich die von dir genutzte Version ist.

Natürlich haben neuere Delphi versionen auch die eine oder andere Performance Verbesserung mit drin...

Hab meine Delphi-Version korrigiert. Bei GetIt gibt es tatsächlich einen Profiler (AQTime). Muss ich beim hinzufügen etwas beachten oder gibt es ein gutes Manual über die Nutzung darüber?

Wäre den Threading einen Blick wert, z.B. beim Hinzufügen nicht doppelter Elemente zu den temporären Listen, also um das befüllen beider temporärer Listen zu parallelisieren oder macht es bei nur zwei Listen keinen Sinn?

[Gyrospeter]

Zitat:

Zitat von TiGü (Beitrag 1503422)

Die Capacity der temporären Liste würde ich so wählen, dass ohne große Neuallokation von Speicher der Inhalt der zu überprüfenden Liste reinpasst.
Also NewCapacity := Round(1.5 * OldList.Count) so als Startwert, man kann sich rantasten.
Damit ist der Platz schonmal vor reserviert und es kann ja durchaus vorkommen, dass keine Doppelungen vorkommen.
Immer wenn not IsListItemEqual dann wahr wird, kann der aktuelle Eintrag hinzugefügt werden.

Reicht es nicht einfach die NewCapacity einfach auf OldList.Count zu setzen, immerhin wird die neue Liste nie größer werden als die alte Liste, nur kleiner?
Deshalb zu Beginn mit NewCapacity := OldList.Count allokieren und nach dem Hinzufügen ein TrimExcess?
Oder sollte die Allokation besser blockweise (256, 512, 1024) geschehen?

[Stevie]

Ein paar Anmerkungen:
Es benötigt ein bisschen mehr als den oben von dir skizzierten Test, denn diese Testdaten verursachen nicht die durchaus teuren Operationen in deinem Code (z.B. Liste rotieren)
Generell sei gesagt, dass es nur schneller werden kann, wenn du auf die temporäre Liste verzichtest und sowohl identische Vektoren als auch unterschiedliche Startpositionen direkt abhandelst.

Bei Code, der auf jeden Fall garantiert, dass du auf gültige List Indizes zugreifst (durch eine 0 to Count-1 Schleife gegeben), kann es durchaus einen kleinen Schub geben, wenn du AList.List[i] benutzt, dadurch wird der getter übergangen, der noch einen Index in range check durchführt und deshalb obwohl geinlined den Code etwas aufbläht.

IsListItemEqual auf jeden Fall als inline markieren (daran denken, diese Funktion vor die anderen zu setzen, da der Compiler nur dann wirklich inlined)


Zum Profilen würde ich dir SamplingProfiler für den Anfang empfehlen (funktioniert am besten mit map file also unter Projektoptionen->Compiler->Linking diese auf detailed setzen). Obwohl der Profiler in der Oberfläche die neusten Delphi Versionen nicht auflistet funktioniert er tadellos. Für Fortgeschrittene empfehle ich Intel VTune (oder uProf, sollte man eine AMD CPU haben, das ist aber nicht ganz so cool wie VTune), dafür muss man aber eine pdb Datei erzeugen, dafür benötigt man map2pdb.

Zum Benchmarken möchte ich benchmark empfehlen, damit kannst du sehr einfach verschiedene Tests bauen, ohne groß mit Stopwatch und Co zu messen.

[Gyrospeter]

Zitat:

Zitat von Stevie (Beitrag 1503439)

Ein paar Anmerkungen:
Es benötigt ein bisschen mehr als den oben von dir skizzierten Test, denn diese Testdaten verursachen nicht die durchaus teuren Operationen in deinem Code (z.B. Liste rotieren)
Generell sei gesagt, dass es nur schneller werden kann, wenn du auf die temporäre Liste verzichtest und sowohl identische Vektoren als auch unterschiedliche Startpositionen direkt abhandelst.

Bei Code, der auf jeden Fall garantiert, dass du auf gültige List Indizes zugreifst (durch eine 0 to Count-1 Schleife gegeben), kann es durchaus einen kleinen Schub geben, wenn du AList.List[i] benutzt, dadurch wird der getter übergangen, der noch einen Index in range check durchführt und deshalb obwohl geinlined den Code etwas aufbläht.

IsListItemEqual auf jeden Fall als inline markieren (daran denken, diese Funktion vor die anderen zu setzen, da der Compiler nur dann wirklich inlined)


Zum Profilen würde ich dir SamplingProfiler für den Anfang empfehlen (funktioniert am besten mit map file also unter Projektoptionen->Compiler->Linking diese auf detailed setzen). Obwohl der Profiler in der Oberfläche die neusten Delphi Versionen nicht auflistet funktioniert er tadellos. Für Fortgeschrittene empfehle ich Intel VTune (oder uProf, sollte man eine AMD CPU haben, das ist aber nicht ganz so cool wie VTune), dafür muss man aber eine pdb Datei erzeugen, dafür benötigt man map2pdb.

Zum Benchmarken möchte ich benchmark empfehlen, damit kannst du sehr einfach verschiedene Tests bauen, ohne groß mit Stopwatch und Co zu messen.

Erst einmal vielen Dank für die Tipps bzgl. des Profilings.
Den Programmen werde ich mich morgen bzw. das Wochenende an meinem privaten Rechner zuhause widmen.
Hat denn AQtime auch in der Standard-Version aus dem GetIt-Manager einfache Profiling-Strukturen wie
z.B. das Aufzeigen von Speicherressourcen, oder muss ich dafür die PRO-Version erwerben?
Oder ist gar der SamplingProfiler kostenlos? Sieht mir etwas altbacken aus, funktioniert der gar mit
Delphi 10.4?

[Gausi]

Ich würde hier nicht mit Profiling ansetzen, um irgendwo ein paar Takte zu sparen, sondern an dem Algorithmus an sich ...

Wenn ich nicht komplett danebenliege, würde ich an der (ziemlich teuren) RotateList-Funktion ansetzen - die kann doch so ziemlich ersatzlos weg!

Diese Rotation um den StartIndex wird doch nur benutzt, damit du in der Schleife ListA[i] mit ListB[i] vergleichen kannst. Warum lässt du das nicht weg, und vergleichst ListA[i] mit ListB[(StartIdx + i) mod ListB.Count]? Dann ersparst du dir sämtliches Umkopieren der Listen (nach dem "Aufräumen"), und dein Algorithmus dürfte um ein Vielfaches schneller werden, da du damit einen Faktor von O(n^2) aus der Laufzeit rausnimmst (solange dauert das Rotate nämlich im Mittel!)

Dazu musst du ggf. die beiden Polygondarstellungen auf "offen" normieren (dazu hats du ja die passenden Funktionen), damit Start/Endpunkt auf keinen Fall doppelt vorkommen.

Interessant wird da höchstens noch der Fall, wenn du Kantenzüge zulässt, die sich selbst kreuzen, und somit ggf. eine Koordinate mehr als einmal auftauchen darf. Aber dann wird das Problem ohnehin schwieriger, weil du an diesen Kreuzungen ggf. anders "abbiegen" kannst, was letztlich auf Graphisomorphie rausläuft. Und das ist dann so schwierig, dass man nichteinmal weiß, ob es NP-vollständig ist oder nicht. :stupid: (Wobei es für den Spezialfall "Graphen mit Eulerweg" auch eventuell effiziente Tests geben könnte, da bin ich jetzt aber überfragt).

[Stevie]

Zitat:

Zitat von Gyrospeter (Beitrag 1503537)

Oder ist gar der SamplingProfiler kostenlos?

Ja

Zitat:

Zitat von Gyrospeter (Beitrag 1503537)

funktioniert der gar mit Delphi 10.4?

Ja, das habe ich mit

Zitat:

Obwohl der Profiler in der Oberfläche die neusten Delphi Versionen nicht auflistet funktioniert er tadellos.

aussagen wollen.

Zitat:

Zitat von Gausi (Beitrag 1503543)

Wenn ich nicht komplett danebenliege, würde ich an der (ziemlich teuren) RotateList-Funktion ansetzen - die kann doch so ziemlich ersatzlos weg!

Zu diesem Schluss war ich in den ersten beiden Sätzen meiner Anmerkungen auch gekommen. ;)

Die Anmerkung zum Profiling war zur Unterstützung und Bestätigung, denn bei entsprechenden Testdaten (die ebend nicht die sind, die weiter oben im Thread gezeigt wurden) dürfte man ziemlich schnell und einfach sehen, dass das befüllen der temp Liste und das rotieren nen dicken Anteil der Laufzeit beansprucht. Nicht jeder sieht seinem Code gleich sein asymptotisches Verhalten an :)

[Gausi]

Zitat:

Zitat von Stevie (Beitrag 1503549)

Zu diesem Schluss war ich in den ersten beiden Sätzen meiner Anmerkungen auch gekommen. ;)

Ups, sorry, das habe ich anscheinend überlesen.

Aber vielleicht als Ergänzung: Das haut natürlich besonders stark in dieser Zeile des Originalcodes rein, wenn AStartIdx = 0 ist.

Delphi-Quellcode:

RotateList(LTmpList, (LTmpList.Count - 1) - AStartIdx);

Dann wird die Liste mit 1000 Einträgen 1000 mal im Speicher hin und her kopiert, bevor mit der Überprüfung auf Gleichheit der beiden Listen begonnen wird.

Das mit der Index-Rechnerei mag zwar aufwändiger erscheinen, ist es aber nicht. Schon alleine deswegen, weil bei ungleichen Polygonen es sehr schnell zu einem Abbruch kommen wird, während sich die Rotation grade erst warmgelaufen hat.