Performanz Unterschiede bei memory schreibender Funktion

Sewing

habe zwei leicht unterschiedliche Implementierungen derselben funktion, List ist dabei eine POD, mit ein paar nativen Datentypen und Stack-basierten Arrays als member. Die eigentliche Implementierung der funktion ist bei meiner Frage jetzt weniger wichtig...

Version 1

List* uncompressScanPointList(char const *src) {
  List *list = new List;
  auto copyIdx = 0;
  auto copySize = sizeof(List) - (16*sizeof(XXX));
  memcpy(list, &(src[copyIdx]), copySize);
  copyIdx += copySize;
  copySize = (sizeof(XXX) - (20*sizeof(YYY)))
        + ((YYY *) (&src[copyIdx]))->XXX*sizeof(XXX);
  memcpy(&(list->XXX[0]), &(src[copyIdx]), copySize);
  return list;
}

wieso ist diese Variante ca. um nen Faktor 10^3 langsamer als die folgende mit nem Output Parameter und vor dem function call erfolgter Heap Allocation von ner List Instanz?

Version 2

void uncompressScanPointList(char const *src, List* list) {

  auto copyIdx = 0;
  auto copySize = sizeof(List) - (16*sizeof(XXX));
  memcpy(list, &(src[copyIdx]), copySize);
  copyIdx += copySize;
  copySize = (sizeof(XXX) - (20*sizeof(YYY)))
        + ((YYY *) (&src[copyIdx]))->XXX*sizeof(XXX);
  memcpy(&(list->XXX[0]), &(src[copyIdx]), copySize);
}

Beide calls habe ich getimed mit

char* data = ....


auto start = std::chrono::system_clock::now();
//uncompressScanPointList(data);
List *list = new List;
uncompressScanPointList(data, list);
auto stop = std::chrono::system_clock::now();
auto d = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count();
std::cerr << "Exection time: " << d << std::endl;

Die 1. Variante braucht ca. 1ms aber die 2. Variante nur ~2us und ich verstehe nicht wieso

Das ist nicht dein Testcode. Copy&Paste!

Sewing

Hatte das Code fragment vereinfacht um es für euch lesbarer zu machen. Ist gefixed. Es geht darum, dass hier Inhalte von einem Speicherbereich in einen anderen kopiert werden und ich verstehe nicht, wieso der einzige Unterschied mit dem Output parameter hier so einen Unterschied bewirkt

@sewing sagte in Performanz Unterschiede bei memory schreibender Funktion:

Ist gefixed

Nein. Das ist nicht der Code zu dem du Fragen hast!

Sewing

verstehe nicht was du meinst. Deutlichere Posts wären hilfreich

@sewing sagte in Performanz Unterschiede bei memory schreibender Funktion:

verstehe nicht was du meinst

Welchen Teil von Copy&Paste hast du nicht verstanden?

Sewing

ist noch früh am morgen

glaube jetzt stimmts

Th69

Bei der 1. Variante hast du den Aufruf von List *list = new List; mitgemessen und bei der 2. Variante (entsprechend deines Aufruf-Codes) nicht.

Sewing

klar, aber das macht ja nicht eine differenz in dieser Größenordnung aus oder?

Zusatzfrage:

Unter C++17 und RVO wäre es möglich, die Liste aufem Stack anzulegen und return per value zu machen? Oder ist das per se nicht so effektiv wie die pointer Variante?

@sewing sagte in Performanz Unterschiede bei memory schreibender Funktion:

klar, aber das macht ja nicht eine differenz in dieser Größenordnung aus oder?

Du hast zwei Funktionen, die das gleiche machen - bis auf das new List. Es kann aber nicht sein, dass dies der Grund für den Unterschied ist. Ernsthaft?

Sewing

nein, denn das Problem besteht fort. ob ich jetzt zwischen den Timern List aufem heap allokiere und an die function übergebe, oder das Heap Objekt lokal in der function erst erzeuge, macht offenbar einen Unterschied

@sewing sagte in Performanz Unterschiede bei memory schreibender Funktion:

nein, denn das Problem besteht fort

Nicht nein denn! Satt zu messen hast du diskutiert!

Egal was hier nocht kommt: du zeigst vermutlich immer noch nicht den richtigen Code (vollständig ist er sowiso nicht). Viel Spaß noch mit deinem Problem.

Sewing

find deine Vorwürfe haltlos und unverschämt

ich bemühe mich hier nach bestem Wissen und Gewissen

Swordfish

@sewing sagte in Performanz Unterschiede bei memory schreibender Funktion:

ich bemühe mich hier nach bestem Wissen und Gewissen

Du sollst ~~verdammt nochmal~~ endlich vollständigen Code liefern den man so wie er ist durch einen Compiler jagen kann ohne sich etwas dazudichten zu müssen.

Sewing

der code stammt aus einer toolbox, die ich nicht einfach so posten kann...

Bashar

Dann musst du den Code aus der Toolbox-Umgebung herauslösen und in eine rudimentäre Umgebung, die ansonsten nur eine main-Funktion usw. enthält einfügen. Wenn dann das Problem noch auftritt, kannst du es hier posten. Wenn dabei das Problem verschwindet, ist dir hoffentlich aufgefallen, an welcher Stelle das war.

SeppJ

@sewing sagte in Performanz Unterschiede bei memory schreibender Funktion:

der code stammt aus einer toolbox, die ich nicht einfach so posten kann...

Du bist seit 3 Jahren dabei und in beinahe jedem Thread beschwert man sich über deinen nicht nachvollziehbaren Code. Und sag jetzt nicht, man hätte dir noch nie diesen Link gezeigt: Wie man Probleme nachstellbar und nachvollziehbar macht. Der kommt auch in fast jedem deiner Threads. Halte dich doch endlich mal daran! Ich jedenfalls lese Fragen von dir schon lange nicht mehr, weil ich einfach weiß, dass jedes Mal erst einmal mindestens 2 Seiten dafür nötig sind, dir überhaupt eine brauchbare Fragestellung mit Code zu entlocken.

hustbaer

@sewing sagte in Performanz Unterschiede bei memory schreibender Funktion:

find deine Vorwürfe haltlos und unverschämt

So lange du keinen Code zeigst den wir selbst compilieren und ausprobieren könnten, ist das ganze uninteressant.

Dass die Vorwürfe nicht "haltlos und unverschämt" sind, sieht man schon daran, dass du Dinge wie "glaube jetzt stimmts" schreibst. Wenn du Copy+Paste genau das posten würdest was du kompiliert und gemessen hast, dann gäbe es nix zu glauben, dann könntest du dir sicher sein.

Und wenn der Code dann noch vollständig wäre, so dass wir ihn auch kompilieren und messen können, dann bestünde sogar berechtigter Grund Angst zu haben dass wir dir am Ende sogar noch helfen können.