mein Programm tut folgendes:
- Objekte in eine "Liste" stecken (hinten),
- wieder rausholen (von vorne) und aus der "liste" löschen
- löschen / reinstecken immer im Wechsel bzw am anfang mehr einfügen, am ende mehr löschen
- alle 100 iterationen muss die "Liste" sortiert werden.
- algorithmus terminiert wenn alle knoten gelöscht sind
- insgesamt müssen ca. 400 - 1000 Objekte gleichzeitig gespeichert werden

Ich hoffe das ist verständlich.
So nun meine Frage: Welche Struktur benutze ich am besten für meine "Liste"? Habe bisher einen vector von referenzen genommen.
also:

vector<obj &> liste

gibt es noch eine bessere Wahl? Vielleicht auch mit boost?
Ist es sinnvoll von hinten reinzustecken und vorne zu löschen? oder sollte man das eher umdrehen?
Mein Programm dauert noch zu lange.. habt ihr noch tipps worauf ich dabei noch achten kann? Gibt es geeignete Literatur?
Bin über jeden Hinweis dankbar

ist es sinnvoll von hinten reinzustecken und vorne zu löschen? oder sollte man das eher umdrehen?

Da solltest du dich eher nach den anforderungen des Algorithmus richten, nicht nach dem Container.

Mein Programm dauert noch zu lange..

Falls es kurz ist: Zeig mal her. Falls es lang ist: Mach dich mal damit vertraut was ein Profiler ist und zeig dann die Funktion die am meisten Zeit braucht.

Vielen Dank für die Übersicht und dem Tipp mit der deque, ich werde es mal vergleichen und euch berichten.

Ich kann den Code leider nicht öffentlich machen *gr*
Welche Profiler benutzt ihr so? Ich habe mir mal vor einiger Zeit valgrind angeschaut, könnte das helfen? (ich programmiere unter linux)

"bei mir darf die sortierung aber nur zu bestimmten situationen kommen.."
hm?
Es gibt doch ein std::sort und std::stable_sort und so gar std::heap_sort - da wird ja wohl einer passen, um bei Bedarf zu sortieren!?

Falls die Größe bekannt ist: boost::circular_buffer sollte dann ne tolle Wahl sein - wenn du boost nicht nutzen darfst, kannst du dir ja seblst nen Ringpuffer schreiben.
Wenn dir das zu viel Arbeit ist oder die max. Größe nicht gegeben, oder abgeschätzt werden kann, ist wohl std::deque nicht die allerschlechteste Wahl...
Evtl. lohnt sich auch ein nicht-linearer Container(set / map / hash_map / ...)

Mach am besten nen typedef auf deinen Container am Anfang des Codes und dann guck mal, wie sich die Laufzeit mit verschiedenen Containern ändert.

"Ich kann den Code leider nicht öffentlich machen"
Dann gib uns doch wenigsten mal nen Stichwort, was du da mit dem Programm simulieren/... willst - dann findet sich bestimmt irgend jemand, der weiß, dass man da auch Algorithmus xyz nehmen könnte und nicht nur am Container Zeit einsparen könnte...

PS: Du compilierst aber im Release-Mode, ja?

bb

Der übliche Profiler unter Linux ist der eingebaute Profiler vom gcc (gprof).

Listen sind unsortiert, bringen aber ihren eigenen sehr effizienten Sortieralgorithmus mit.

Oh - da hatte ich mich wohl in der Komplexität geirrt - dachte, die wäre sehr viel höher gewesen, aber auf cplusplus.com steht(gerad kein standard hier) N*log N (Vergleich: std::sort idR N*log N aber im worst case so gar N*N).

Damit ist zumindest das entfernen und sortieren bei der liste am schnellsten - wäre noch zu klären, wie das beim hinzufügen ist (hier könnte aber ein eigener allokator sinnvoll sein, damit man nicht mehr für jedes hinzufügen ein new hat)

bb

Mach am besten nen typedef auf deinen Container am Anfang des Codes und dann guck mal, wie sich die Laufzeit mit verschiedenen Containern ändert.

PS: Du compilierst aber im Release-Mode, ja?

kannst du mir ein kurzes Bsp geben für typedef?

hmm release mode habe ich nur mal bei eclipse gehört... ich benutze kdevelop 4.
ich habe -02 eingeschaltet, kann ich sonst noch was tunen?

unskilled schrieb:

(hier könnte aber ein eigener allokator sinnvoll sein, damit man nicht mehr für jedes hinzufügen ein new hat)

kannst du mir das auch nochmal erklären

Mir scheint es gibt noch viele Möglichkeiten..

Zum Algorithmus.. ist ist eine Art A*-Algorithmus..

typedef std::vector<std::vector> > vector2d;

#include <deque>
#include <list>
#include <vector>

struct foo{};

typedef std::list<foo> foo_container;
//typedef std::deque<foo> foo_container;
//typedef std::vector<foo> foo_container;

int main()
{
  //mach was mit foo_container
}

Nur beim sort musst du halt unterscheiden, ob es eine Liste ist oder nicht(das sollte anhand von typename iterator_traits<foo_container::iterator>::category gehen - oder mittels einer extra Überladung für deine sort-Funktion für die Liste:

template<typename CONTAINER, typename COMPARER>
void sort(CONTAINER& me, const COMPARER& cmp = std::less<typename CONTAINER::value_type>())
{
  std::sort(me.begin(), me.end(), cmp);
}

template<typename VALUE_TYPE, typename ALLOCATOR, typename COMPARER>
void sort(std::list<VALUE_TYPE, ALLOCATOR>& me, const COMPARER& cmp = std::less<VALUE_TYPE>())
{
  me.sort(cmp);
}

/* 1
typedef std::list<foo> foo_container;
*/

/* 2
typedef std::deque<foo> foo_container;
*/

/* 3
typedef std::vector<foo> foo_container;
*/

int main()
{
  foo_container x;

//  x.push_back(foo());

  sort(x);
}

Vll sollte man die sort-Funktion in dem Fall auch inplace_sort nennen, weil man nicht erwartet, dass auf es das Argument verändert, aber da hab ich jz keine lust, das noch zu ändern^^
Aber so in etwa sollte das funktionieren...

Man muss eben nur noch das typedef ändern und den Rest kann man halt so lassen - unheimlich praktisch, um immermal zu testen, welcher Container optimale Ergebnisse liefert...

bb

Ich habe das jetzt mit einem struct gelöst, bringt das Vorteile gegenüber einer eigenen Klasse? Bei ca. 50.000 Objekten, kann das einen Unterschied machen?

Habe momentan folgendes: (wenn ein ptr eines Obj der liste/enqueue/vector hinzugefügt wird)

struct foo{ // 5 Werte + Array
};
foo* ptrFoo = NULL;

// hinzufügen
foo tmp = {bla blub};
ptrFoo = &tmp;
foo_container.push_back(prtFoo);

Gehts noch besser/schlauer?

Thanks!!!!!

Bei einer klasse geht es ja mit

delete *ptrFoo

...

das hinzufügen an sich ist schon doof, weil es definitiv was anderes macht, als du denkst...

mach es doch einfach erst mal so, wie man es normalerweise machen würde... danach kannst du es noch immer kaputt-optimieren...

bb

struct foo{ // 5 Werte + Array
};
foo* ptrFoo = NULL;

// hinzufügen
foo tmp = {bla blub};
ptrFoo = &tmp;
foo_container.push_back(prtFoo);

so würde das aussehen - aber da musst du halt vor allem gucken, dass du to_add nicht vorher irgendwie zerstörst...

bsp., wie man es _nciht_ macht:

void add(Tfoo_container &foo_container)
{
  foo to_add;
  foo_container.push_back(&to_add);
}

int main()
{
  Tfoo_container foo_container;
  add(foo_container);
}

bb

Ich habe gerade mal vector und deque gegeneinander getestet, der Unterschied ist ziemlich groß!!!! Vielen vielen Dank für den Tipp Ich probiere später nochmal std::list.

Aber wenn ich nur Zeiger anstatt Objekte speichere müßte das auch nochmal sehr viel ausmachen oder was denkt ihr?

Aber wenn ich nur Zeiger anstatt Objekte speichere müßte das auch nochmal sehr viel ausmachen oder was denkt ihr?

Was ausmachen? Was erhoffst du dir davon?

Ja das verstehe ich, dass in dem Beispiel das Objekt nicht mehr existiert, ich glaube das dürfte bei mir auch nicht passieren...

Ich habe gerade mal vector und deque gegeneinander getestet, der Unterschied ist ziemlich groß!!!! Vielen vielen Dank für den Tipp Ich probiere später nochmal std::list.

Aber wenn ich nur Zeiger anstatt Objekte speichere müßte das auch nochmal sehr viel ausmachen oder was denkt ihr?

Kommt drauf an. Wenn du die Zeiger jedesmal mit new erstellst und mit delete loescht, dann: ja, wird viel ausmachen, wird naemlich viel langsamer sein. Wenn du die Pointer vorher schon alle hast und erst am Ende loescht: ja, wird vermutlich schneller sein, als dauerndes hin/her kopieren.

ich habe folgendes:
ich erstelle ein objekt, das muss in eine "liste" hinten dran gespeichert werden (momentan deque), dann nehme ich ein neues objekt aus der "liste" von vorne (und lösche es aus der liste) verändere es und stecke es vielleicht wieder rein, bzw vielleicht auch mehrere veränderungen von dem objekt oder es wird ganz verworfen.

Jetzt ist meine Frage, ob es schneller gehen würde von der performance, wenn ich statt dem objekt selbst nur den pointer auf das objekt speichere.. das objekt muss ich ja so oder so erstellen.

Ich hoffe man kann ungefähr verstehen was der algo macht, wie gesagt, eine art A*..

Mein du mit Speicher selbst verwalten new and delete?

Hierzu habe ich noch meine Frage:

wie kann ich wenn ich den pointer habe das struct dahinter löschen?
bsp:

struct foo
{
 /*...*/
};

int main()
{
  foo to_add;
  foo_container.push_back(&to_add);
  foo* ptr = foo_container[0];
  foo_container.pop_front();
  delete *ptr; // so? funktioniert das auch bei einem struct?
  ..;
}

Die Performance ist wie gesagt alles, muss schneller als anderes Programm (anderer algo) sein und muss noch ein bisschen was rausholen...

Könnte der Compiler deinen Code kompilieren, dann würdest du undefiniertes Verhalten hervorrufen, weil du delete auf ein Objekt anwendest, das nicht mit new angefordert wurde.

Und alleine aufrgrund von Code performance auslesen zu wollen ist völliger schwachsinn. Das ist in 99% der Fälle nutzlos. Benutz einen Profiler, wenn dei Programm fertig ist und dann bessere da nach, wo Engpässe sind. Das ist die korrekte Mehtode Code zu optimieren.

Könnte der Compiler deinen Code kompilieren, dann würdest du undefiniertes Verhalten hervorrufen, weil du delete auf ein Objekt anwendest, das nicht mit new angefordert wurde.

Genau das war ja meine Frage: Das struct wurde nicht mit new erstellt... wie lösche ich es nun.. ich habe in meiner liste nur die adressen, wenn ich jetzt nur den ersten knoten aus der liste lösche, lösche ich doch nur die adresse... wir kann ich das struct dahinter löschen? Od geht das automatisch?

Und alleine aufrgrund von Code performance auslesen zu wollen ist völliger schwachsinn. Das ist in 99% der Fälle nutzlos. Benutz einen Profiler, wenn dei Programm fertig ist und dann bessere da nach, wo Engpässe sind. Das ist die korrekte Mehtode Code zu optimieren.

Ich verstehe was du meinst. Nur mein Programm ist fertig und ich habe um Hilfe für Verbesserung gefragt, eine deque anstatt vector zu benutzen war schonmal sehr sehr nützlich.
Die Engstelle liegt darin das ich z.b. bis zu 40.000 Objekte speichern muss. Meine Frage ist nun wie ich die Operationen speichern, löschen, sortieren am effiziesten einsetzen kann.
Deshalb meine Frage auch am Anfang: lieber vorne oder hinten einfügen bzw löschen...

Ich benutze ja gerne einen Profiler, nur leider habe ich nicht verschiedene Methoden die aufgerufen werden, sondern eher eine große schleife mit vielen vielen Objekten..
Ich hoffe mein Problem ist ein wenig klarer geworden.

Könnte der Compiler deinen Code kompilieren, dann würdest du undefiniertes Verhalten hervorrufen, weil du delete auf ein Objekt anwendest, das nicht mit new angefordert wurde.

Genau das war ja meine Frage: Das struct wurde nicht mit new erstellt... wie lösche ich es nun.. ich habe in meiner liste nur die adressen, wenn ich jetzt nur den ersten knoten aus der liste lösche, lösche ich doch nur die adresse... wir kann ich das struct dahinter löschen? Od geht das automatisch?

Wenn du foo in deinem Container speicherst, dann sind da auch foo Objekte drin. Nicht nur dessen Adressen. (intern wird da wahrscheinlich dynamisch Speicher angefordert und verwaltet, aber die Struktur hält prinzipiell nicht nur Zeiger). Und wenn du automatische Objekte speicherst, dann sind die nach dem entfernen auch wieder weg. (von Optimierungen mal abgesehen, dass der Container nicht wirklich Speicher zurückgibt, aber dein Objekt ist sicher korrekt zerstört). Anderst ist es, wenn du selbst Zeiger drin speicherst. Die werden natürlich nicht mit delete freigegeben, da du ja z.B auch ganzu normale Zeiger drin haben könntest.

Und alleine aufrgrund von Code performance auslesen zu wollen ist völliger schwachsinn. Das ist in 99% der Fälle nutzlos. Benutz einen Profiler, wenn dei Programm fertig ist und dann bessere da nach, wo Engpässe sind. Das ist die korrekte Mehtode Code zu optimieren.

Ich verstehe was du meinst. Nur mein Programm ist fertig und ich habe um Hilfe für Verbesserung gefragt, eine deque anstatt vector zu benutzen war schonmal sehr sehr nützlich.
Die Engstelle liegt darin das ich z.b. bis zu 40.000 Objekte speichern muss. Meine Frage ist nun wie ich die Operationen speichern, löschen, sortieren am effiziesten einsetzen kann.
Deshalb meine Frage auch am Anfang: lieber vorne oder hinten einfügen bzw löschen...

Ich benutze ja gerne einen Profiler, nur leider habe ich nicht verschiedene Methoden die aufgerufen werden, sondern eher eine große schleife mit vielen vielen Objekten..
Ich hoffe mein Problem ist ein wenig klarer geworden.

40'000 klingt nicht nach sehr viel. Hast du sicher mal im Release Mode gebuildet? - Das bringt dir enorm viel. 40'000 Objekte sind üblicherweise kein Problem.