3. größtmögliche Effizienz / vector? / boost

größtmögliche Effizienz / vector? / boost

  • W

    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?

    0
  • N

    windschief schrieb:

    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?

    0
  • B

    windschief schrieb:

    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.

    0
  • W

    hmm, ich glaube ich habe nicht ganz verstanden was du meinst..

    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*..

    0
  • N

    Das kommt wohl auf das Objekt an. Ist es eher klein, lohnen sich Zeiger wahrscheinlich nicht. Wenn du hingegen viel Kopieraufwand sparen kannst, wäre der Ansatz schon eine Überlegung wert. Jedoch müsstest du selbst Speicher verwalten, und das kann (abgesehen von der Mühseligkeit) z.B. bei std::deque wie erwähnt auch langsamer sein. Ich würde am besten weiterhin std::deque oder std::list benutzen, es sei denn, du hast wirklich ein Performance-Problem. In diesem Fall misst du am besten die Zeit in beiden Fällen. Aber nur aufgrund vager Vermutungen würde ich mir keine zusätzliche Mühe machen.

    0
  • W

    wie schon gesagt, mein objekt (struct) besteht aus 5 elementen und einem array/vector. Ist das eher klein?

    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...

    0
  • N

    Bevor du dich an solche Optimierungen machst, solltest du vielleicht schon die Grundkonzepte der Sprache verstehen. Manuelle Speicherverwaltung und Zeiger gehören definitiv dazu. Hast du kein C++-Buch, in dem diese Dinge erklärt werden?

    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.

    0
  • D

    Was verstehst du unter löschen? - delete braucht man um dynamischen Speicher wieder frei zu geben. Mir schwebt was vor, dass du aber ganz was anderes willst. Wenn du das Element aus dem Container entfernst, dann wird das schon beseitigt. Keine Angst.

    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.

    0
  • W

    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.

    0
  • D

    windschief schrieb:

    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.

    0
  • W

    Die werden natürlich nicht mit delete freigegeben, da du ja z.B auch ganzu normale Zeiger drin haben könntest.

    das meinte ich =).
    und wie kann ich jetzt mein struct das hinter der adresse ist löschen?

    0
  • U

    windschief schrieb:

    wie schon gesagt, mein objekt (struct) besteht aus 5 elementen und einem array/vector. Ist das eher klein?

    Hier reicht ein spezialisiertes swap vollkommen aus - vector hat ein O(1) swap und der aufwand um 5 Elemente zu tauschen ist auch eher vernachlässigbar...
    Falls dir das zu langsam ist, kannst du dein Objekt noch immer "pimpeln", wenn sie eine relativ lange lebensdauer haben würde sich das denke ich wieder lohnen - ansonsten eher weniger...

    noch ein kurzer kommentar zu deinem quellcoden:

    int main()
{
  foo to_add;
  foo_container.push_back(&to_add);
  foo* ptr = foo_container[0];
  foo_container.pop_front();
  delete *ptr; // BÄM!
  ..;
} //oder spätestens hier BÄM!

    Wie bereits gesagt, gibt es keinen Unterschied zwischen class und struct (außer der default-access-aber der spielt hier keine rolle)...

    bb

    0
  • W

    also sollte ich mein struct in eine class umwandeln, jedes objekt mit new erstellen und dann kann ich es auch mit delete löschen?

    also so:

    class foo{
};

int main()
{
  to_add = new foo();
  foo_container.push_back(&to_add);
  foo* ptr = foo_container[0];
  foo_container.pop_front();
  delete *ptr; // kein BÄM! mehr??
  ..;
}

    also struct in class, damit ich das objekt hinter der adresse löschen kann?

    0
  • D

    windschief schrieb:

    Die werden natürlich nicht mit delete freigegeben, da du ja z.B auch ganzu normale Zeiger drin haben könntest.

    das meinte ich =).
    und wie kann ich jetzt mein struct das hinter der adresse ist löschen?

    Du HAST keine Zeiger drin (zumindest habe ich das hier bis jetzt nicht gesehen). Also brauchst du auch nichts freizugeben. Für das Element, was du entfernst wird der Destruktor aufgerufen und aus dem Container entfernt. Fertig.

    /EDIT
    NEIN! Wenn du Objekte vom Typ foo drin haben willst, dann speichere Objekte vom Typ foo dort drin! Ansonsten führst du den Container ad absurdum. (zu einem gewissen Teil).

    0
  • W

    Du HAST keine Zeiger drin

    *lach* aber ich will 🙂

    wenn ich sowas habe:

    typedef std::deque<foo*> foo_container;

    habe ich dann welceh?

    0
  • U

    dein c++ - code zeigt mal wieder, dass du kein c++ kannst - oder du hast ausversehen 100 fehler reingemacht... ><
    in c++ progrmmiert man nicht mittels try and error - und wenn du schon in nem forum postest, könnte man ja wenigsten davon ausgehen, dass du zumindest ein ganz klein wenig eigeninitiative zeigst...
    du nimmst hier jedes mal wieder fremden code und änderst ihn dann so lang um, bis du so viele fehler drin hast, dass man nicht mal mehr erraten kann, was jetzt ausversehen war und was du vll doch schon weist und nur vergessen hast, zu ändern...
    also gib dir jz mal ein wenig mühe, sonst wird hier bald gar keiner mehr lust haben, was zu erklären...

    bb

    edit: hast du mal nen swap spezialisiert und zählen lassen, wie oft es aufgerufen wird und kannst du uns mal sagen, wie lang dein gesamtes programm ungefährt rechnet - etc....
    das sind alles angaben, ohne die es total sinnlos ist, optimieren zu wollen - wie schon öfter gesagt, kann man nur mit nem profiler sinnvoll optimieren...

    0
  • W

    dein c++ - code zeigt mal wieder, dass du kein c++ kannst - oder du hast ausversehen 100 fehler reingemacht... ><

    von beidem wahrscheinlich etwas..

    wo habe ich denn schon wieder fehler reingemacht?
    hier:

    class foo{
};

int main()
{
  to_add = new foo();
  foo_container.push_back(&to_add);
  foo* ptr = foo_container[0];
  foo_container.pop_front();
  delete *ptr; // kein BÄM! mehr??
  ..;
}

    oder

    typedef std::deque<foo*> foo_container;

    ich wollte jetzt ausprobieren und messen, wieviel unterschied es macht objekte oder einfach nur deren adressen zu speichern. Wenn es keinen macht, ist es auch gut ausgetestet zu haben und definitiv zu wissen!

    Dabei habe ich jetzt aber das Problem das ich nicht weiß, wie ich das Objekt dahinter löschen kann bzw. ich dachte was ich eben gepostet habe wäre richtig.
    Danach machen ich natürlich noch Auswertungen mit gprof.

    Was genau meinst du mit swap spezialisiert und zählen lassen?
    Ich habe eine Funktion für die sortierung der Objekte, soll ich da einen Zähler einbauen und schauen wie oft er aufgerufen wird um die Liste zu sortieren?

    Ich mache gerne noch ganz viele Angaben bzgl Zeit usw. Nur wollte ich erstmal diese Sache mit den Adressen probieren..

    0
  • D

    unskilled schrieb:

    also gib dir jz mal ein wenig mühe, sonst wird hier bald gar keiner mehr lust haben, was zu erklären...

    Schon passiert.. 🙄

    Ohne Selbstinitiative zu sehen habe ich keine Lust zu helfen.. n8

    0
  • W

    Schon passiert.. 🙄

    Ohne Selbstinitiative zu sehen habe ich keine Lust zu helfen.. n8

    hmmm.. Ich verstehe nicht ganz warum ihr denkt, ich mache nichts bzw denke nicht nach..

    ihr habt doch gesagt: ohne new kein delete.
    Daraufhin habe ich das struct in eine klasse umgewandelt und mit new erstellt.
    also new und delete..
    welche selbstinitative wollt ihr denn genau??
    Wie gesagt ich wollte das jetzt austesten und danach weiter optimieren..

    0
  • U
     

    class foo{
};

int main()
{
  to_add = new foo(); //1. was ist to_add? allem anschein nach ein Zeiger
  foo_container.push_back(&to_add); //wieso also die adresse eines zeigers?
  foo* ptr = foo_container[0]; //besser: foo_container.front() - nicht alle container haben einen op[]
  foo_container.pop_front();
  delete *ptr;
  ..;
}

    das hier wird aber zu 90% langsamer sein als foo_container<foo>
    das wurde hier aber auch schon mal geschrieben...

    "Was genau meinst du mit swap spezialisiert und zählen lassen?"
    boar...

    struct xyz
{
  explicit xyz(int a) : a(a) /*b, c, d, e, f*/ {}

  void swap(xyz& other)
  {
    using std::swap;
    swap(a, other.a);
    swap(b, other.b);
    swap(c, other.c);
    swap(d, other.d);
    swap(e, other.e);
  }

  int get_a() const
  {
    return a;
  }
private:
  int a, b;
  double c, d;

  std::vector<float> e;
};

bool operator< (const xyz& lhs, const xyz& rhs)
{ //...
  return lhs.get_a() < rhs.get_a();
}

void std::swap(xyz& lhs, xyz& rhs)
{
  lhs.swap(rhs);
}

    swap ist also jetzt spezialisiert...

    int main()
{
  std::vector<xyz> bla;

  bla.push_back(xyz(6));
  bla.push_back(xyz(4));
  bla.push_back(xyz(5));
  bla.push_back(xyz(7));
  bla.push_back(xyz(3));
  bla.push_back(xyz(1));
  bla.push_back(xyz(2));

  std::sort(bla.begin(), bla.end());
}

    so würden wir also sortieren...
    wenn wir jetzt noch wissen wollen, wie oft getauscht wurde, lassen wir also in der swap-funktion einen zähler mitlaufen...
    das geht eigtl relativ einfach, in dem wir dort ne static-variable reinmachen und die bei jedem fkt-aufruf incrementieren - nur wollen wir die noch ausgeben, also nehmen wir einfach ne globale variable:

    unsigned int swap_counter = 0;

void std::swap(xyz& lhs, xyz& rhs)
{
  ++swap_counter;
  lhs.swap(rhs);
}

int main()
{
/*...*/

  std::sort(bla.begin(), bla.end());

  std::cout << swap_counter << std::endl;
}

    ihr habt doch gesagt: ohne new kein delete.
    Daraufhin habe ich das struct in eine klasse umgewandelt und mit new erstellt.
    also new und delete..

    kannst du lesen?
    ich hab jetzt schon mindestens zweimal geschrieben, dass es _keinen_ unterschied zwischen struct und class gibt(zumindest keinen, der hier eine rolle spielen würde - also war es mal wieder völlig sinnlos das "struct in eine klasse umzuwandeln" - das zeigt mir recht deutlich, wie du die hier gegebenen antworten liest)

    bb

    PS: Mit deinen Pointern hast du 3 Zuweisungen, das richtige swap hat vermutlich irgendetwas um die 21Zuweisungen - du sparst also pro swap 18Takte(kannst ja mal googlen, wie viel Takte dein Prozessor pro Sekunde schafft - dann wirst du auch sehen, dass sich das ganze nicht lohnt... :P) - dafür verlierst du aber beim erstellen und zerstören des Objekts deutlich mehr Takte - außerdem wird die Lesbarkeit nicht unbedingt erhöht werden und nicht zu letzt verzichtest du (völlig grundlos) auf RAII... Ich könnte noch ne ganze Weile weitermachen, Nachteile aufzuzählen, aber das sollte selbst dir inzwischen reichen, um es einzusehen...

    0
Anmelden zum Antworten