Performance-Frage - C++ (German)

C++Talk.NET
C++ language newsgroups

Archives

FAQ

Memberlist

Usergroups

Profile

Performance-Frage
Goto page 1, 2 Next

C++Talk.NET Forum Index -> C++ (German)

View previous topic :: View next topic

Author

Message

Torsten Hensel
Guest

Posted: Wed May 26, 2004 7:31 am Post subject: Performance-Frage

Hi! Ich habe eine Performance-Frage. Mir ist klar, dass es bei der Performance auf viele Dinge ankommen (Compiler, Prozessor, Optimierung), daher geht es mir eher ums Prinzip als um das letzte bisschen Rechenleistung. Ich habe eine recht aufwändige Berechnungsfunktion, die in zwei großen while-Schleifen die eigentliche Berechnung durchführt. Davor und dazwischen sind in erster Linie Vorbereitungen und Initialisierungen. Nun möchte ich diese Funktion in mehrere kleine Funktionen unterteilen. Meine Frage ist jetzt: Wie sehr macht sich der Overhead durch die Funktionsaufrufe bemerkbar? Jede while-Schleife wird mehrere tausend Mal durchlaufen, und in jeder while-Schleife werden schon jetzt zahlreiche Hilfsfunktionen (häufig Get-, Set- und Insert-Routinen) aufgerufen. Ich möchte nun Blöcke zwischen 10 und 70 Zeilen in externe Funktionen auslagern. In welcher Größenordnung liegt dabei der Overhead? Ciao, Torsten -- de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Daniel Albuschat
Guest

Posted: Wed May 26, 2004 9:07 am Post subject: Re: Performance-Frage

Torsten Hensel wrote:

Quote:

Ich habe eine Performance-Frage. Mir ist klar, dass es bei der
Performance auf viele Dinge ankommen (Compiler, Prozessor,
Optimierung), daher geht es mir eher ums Prinzip als um das letzte
bisschen Rechenleistung.

Das Allerwichtigste hast du vergessen: Der Algorithmus.
Aber keine bange, du bist nicht allein mit dem Problem... </rant>

Quote:

Jede while-Schleife wird mehrere tausend Mal durchlaufen, und in jeder
while-Schleife werden schon jetzt zahlreiche Hilfsfunktionen (häufig
Get-, Set- und Insert-Routinen) aufgerufen. Ich möchte nun Blöcke
zwischen 10 und 70 Zeilen in externe Funktionen auslagern. In welcher
Größenordnung liegt dabei der Overhead?

Wenn die Funktionen inline sind, ist der Overhead = 0.

MfG,
Daniel Albuschat

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Ralf Bartzke
Guest

Posted: Wed May 26, 2004 9:54 am Post subject: Re: Performance-Frage

Torsten Hensel schrieb:

Quote:

Hi!

Ich habe eine recht aufwändige Berechnungsfunktion, die in zwei großen
while-Schleifen die eigentliche Berechnung durchführt. Davor und
dazwischen sind in erster Linie Vorbereitungen und Initialisierungen.
Nun möchte ich diese Funktion in mehrere kleine Funktionen
unterteilen. Meine Frage ist jetzt: Wie sehr macht sich der Overhead
durch die Funktionsaufrufe bemerkbar?

Jede while-Schleife wird mehrere tausend Mal durchlaufen, und in jeder
while-Schleife werden schon jetzt zahlreiche Hilfsfunktionen (häufig
Get-, Set- und Insert-Routinen) aufgerufen. Ich möchte nun Blöcke
zwischen 10 und 70 Zeilen in externe Funktionen auslagern. In welcher
Größenordnung liegt dabei der Overhead?

Ciao,
Torsten

Kommt drauf an. Möglicherweise bleibt der Code trotz Auslagerung in

Funktionen aufgrund der Optimierung inline.

Ein einfacher Funktionsaufruf ohne Parameter und Rückgabewert(e) braucht
eigentlich nur 2 Maschinenbefehle, call & Return. Zusätzlich werden
eventuell einige CPU-Register gesichert und wiederhergestellt. Wieviele
und welche das sind, hängt davon ab, was deine Funktionen genau machen.

Haben die Funktionen wie üblich einige Parameter und Rückgabewert(e),
ist der Aufwand wesentlich höher, da alle Parameter auf den Stack oder
zumindest in bestimmte CPU-Register kopiert werden müssen.

Grob über den Daumen gepeilt würde ich sagen, ein Funktionsaufruf
braucht so 7 ... 16 Maschinenbefehle.

Bei 10 ... 70 Zeilen Code würde ich den Overhead zwischen 0.5 und 30 %
vermuten. Stark abhängig davon, was die Funktionen machen, wie der
Compiler optimiert und was für eine CPU genutzt wird. Da hilft nur
probieren und nachmessen.

Ralf

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Hannah Schroeter
Guest

Posted: Wed May 26, 2004 10:27 am Post subject: Re: Performance-Frage

Hallo!

Daniel Albuschat <daniel (AT) viming (DOT) de> wrote:

Quote:

[...]

Jede while-Schleife wird mehrere tausend Mal durchlaufen, und in jeder
while-Schleife werden schon jetzt zahlreiche Hilfsfunktionen (häufig
Get-, Set- und Insert-Routinen) aufgerufen. Ich möchte nun Blöcke
zwischen 10 und 70 Zeilen in externe Funktionen auslagern. In welcher
Größenordnung liegt dabei der Overhead?

Wenn die Funktionen inline sind, ist der Overhead = 0.

Und wenn sie nicht inline sind und mehr als einmal in der Schleife
aufgerufen werden, kann der Overhead unterm Strich sogar < 0 sein
(Funktionsaufruf-Aufwand < Gewinne durch bessere Ausnutzung I-Cache).

Gruß,

Hannah.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Rolf Magnus
Guest

Posted: Wed May 26, 2004 11:07 am Post subject: Re: Performance-Frage

Ralf Bartzke wrote:

Quote:

Torsten Hensel schrieb:
Hi!

Ich habe eine recht aufwändige Berechnungsfunktion, die in zwei
großen while-Schleifen die eigentliche Berechnung durchführt. Davor
und dazwischen sind in erster Linie Vorbereitungen und
Initialisierungen. Nun möchte ich diese Funktion in mehrere kleine
Funktionen unterteilen. Meine Frage ist jetzt: Wie sehr macht sich
der Overhead durch die Funktionsaufrufe bemerkbar?

Jede while-Schleife wird mehrere tausend Mal durchlaufen, und in
jeder while-Schleife werden schon jetzt zahlreiche Hilfsfunktionen
(häufig Get-, Set- und Insert-Routinen) aufgerufen. Ich möchte nun
Blöcke zwischen 10 und 70 Zeilen in externe Funktionen auslagern. In
welcher Größenordnung liegt dabei der Overhead?

Ciao,
Torsten

Kommt drauf an. Möglicherweise bleibt der Code trotz Auslagerung in
Funktionen aufgrund der Optimierung inline.

Ein einfacher Funktionsaufruf ohne Parameter und Rückgabewert(e)
braucht eigentlich nur 2 Maschinenbefehle, call & Return. Zusätzlich
werden eventuell einige CPU-Register gesichert und wiederhergestellt.
Wieviele und welche das sind, hängt davon ab, was deine Funktionen
genau machen.

Haben die Funktionen wie üblich einige Parameter und Rückgabewert(e),
ist der Aufwand wesentlich höher, da alle Parameter auf den Stack oder
zumindest in bestimmte CPU-Register kopiert werden müssen.

Grob über den Daumen gepeilt würde ich sagen, ein Funktionsaufruf
braucht so 7 ... 16 Maschinenbefehle.

Bei 10 ... 70 Zeilen Code würde ich den Overhead zwischen 0.5 und 30 %
vermuten. Stark abhängig davon, was die Funktionen machen, wie der
Compiler optimiert und was für eine CPU genutzt wird. Da hilft nur
probieren und nachmessen.

Ich habe schon mal ein für mich doch erstaunliches Ergebnis gehabt, das
andeutet, daß der Overhead von Funktionsaufrufen wesentlich größer ist
als allgemein angenommen. Es war zwar in C, aber das sollte wohl keinen
Unterschied machen. Da hatte ich ein existierendes Programm, das ich
ein wenig optimieren wollte. Ich habe dazu folgende Funktion in ein
Makro umgewandelt:

void MInvTransPoint (VECTOR result, VECTOR vector,
TRANSFORM *transform)
{
register int i;
DBL answer_array[4];
MATRIX *matrix;

matrix = (MATRIX *) transform->inverse;
for (i = 0 ; i < 3 ; i++)
{
answer_array[i] = vector[X] * (*matrix)[0][i] +
vector[Y] * (*matrix)[1][i] +
vector[Z] * (*matrix)[2][i] + (*matrix)[3][i];
}

result[X] = answer_array[0];
result[Y] = answer_array[1];
result[Z] = answer_array[2];
}

Immerhin sind darin 9 double-Multiplikationen und 9 Additionen
enthalten. Das Umwandeln in ein Makro hat dafür gesorgt, daß diese
Operation nur noch halb so viel Zeit verbraucht hat! Der
Funktionsaufruf alleine hat also so viel Zeit gekostet wie der ganze
Inhalt der Funktion.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Markus Schaaf
Guest

Posted: Wed May 26, 2004 12:51 pm Post subject: Re: Performance-Frage

"Rolf Magnus" <ramagnus (AT) t-online (DOT) de> schrieb:

Quote:

void MInvTransPoint (VECTOR result, VECTOR vector,
TRANSFORM *transform)
{
register int i;
DBL answer_array[4];
MATRIX *matrix;

matrix = (MATRIX *) transform->inverse;
for (i = 0 ; i < 3 ; i++)
{
answer_array[i] = vector[X] * (*matrix)[0][i] +
vector[Y] * (*matrix)[1][i] +
vector[Z] * (*matrix)[2][i] + (*matrix)[3][i];
}

result[X] = answer_array[0];
result[Y] = answer_array[1];
result[Z] = answer_array[2];
}

Immerhin sind darin 9 double-Multiplikationen und 9 Additionen
enthalten. Das Umwandeln in ein Makro hat dafür gesorgt, daß diese
Operation nur noch halb so viel Zeit verbraucht hat! Der
Funktionsaufruf alleine hat also so viel Zeit gekostet wie der ganze
Inhalt der Funktion.

Glaube ich nicht ganz. Vielmehr wird der Optimierer nach der Inline-
Expansion ziemlich zugeschlagen haben.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Rolf Magnus
Guest

Posted: Wed May 26, 2004 3:07 pm Post subject: Re: Performance-Frage

Markus Schaaf wrote:

Quote:

"Rolf Magnus" <ramagnus (AT) t-online (DOT) de> schrieb:

void MInvTransPoint (VECTOR result, VECTOR vector,
TRANSFORM *transform)
{
register int i;
DBL answer_array[4];
MATRIX *matrix;

matrix = (MATRIX *) transform->inverse;
for (i = 0 ; i < 3 ; i++)
{
answer_array[i] = vector[X] * (*matrix)[0][i] +
vector[Y] * (*matrix)[1][i] +
vector[Z] * (*matrix)[2][i] + (*matrix)[3][i];
}

result[X] = answer_array[0];
result[Y] = answer_array[1];
result[Z] = answer_array[2];
}

Immerhin sind darin 9 double-Multiplikationen und 9 Additionen
enthalten. Das Umwandeln in ein Makro hat dafür gesorgt, daß diese
Operation nur noch halb so viel Zeit verbraucht hat! Der
Funktionsaufruf alleine hat also so viel Zeit gekostet wie der ganze
Inhalt der Funktion.

Glaube ich nicht ganz. Vielmehr wird der Optimierer nach der Inline-
Expansion ziemlich zugeschlagen haben.

Mag sein, aber da genau abläuft, ist eigentlich egal. Es zeigt, daß mit
Inlining die Perfomance ganz beträchtlich erhöht werden kann.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Torsten Robitzki
Guest

Posted: Wed May 26, 2004 5:55 pm Post subject: Re: Performance-Frage

Rolf Magnus wrote:

<snip>

Quote:

Bei so einfachen Operationen die wahrscheinlich auf eine Masse von Daten
angewandt werden lohnt es sich vielleicht mal zu überlegen, ob es nicht
Sinn macht die Funktion mit einer Liste (Array) von VECTORen aufzurufen.
Dadurch wird die Funtion nicht unnötig komplizierter, die Kosten für den
Funktionsaufruf werden aber vernachläßigbar gering.

mfg Torsten

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Volker Glave
Guest

Posted: Thu May 27, 2004 7:26 am Post subject: Re: Performance-Frage

Rolf Magnus <ramagnus (AT) t-online (DOT) de> wrote

Quote:

Ralf Bartzke wrote:

Torsten Hensel schrieb:

Ich habe eine recht aufwändige Berechnungsfunktion, die in zwei
großen while-Schleifen die eigentliche Berechnung durchführt.
[...]

Kommt drauf an. Möglicherweise bleibt der Code trotz Auslagerung in
Funktionen aufgrund der Optimierung inline.

Ein einfacher Funktionsaufruf ohne Parameter und Rückgabewert(e)
braucht eigentlich nur 2 Maschinenbefehle, call & Return. Zusätzlich
werden eventuell einige CPU-Register gesichert und wiederhergestellt.
Wieviele und welche das sind, hängt davon ab, was deine Funktionen
genau machen.

[...]

Bei 10 ... 70 Zeilen Code würde ich den Overhead zwischen 0.5 und 30 %
vermuten. Stark abhängig davon, was die Funktionen machen, wie der
Compiler optimiert und was für eine CPU genutzt wird. Da hilft nur
probieren und nachmessen.

Ich habe schon mal ein für mich doch erstaunliches Ergebnis gehabt, das
andeutet, daß der Overhead von Funktionsaufrufen wesentlich größer ist
als allgemein angenommen. Es war zwar in C, aber das sollte wohl keinen
Unterschied machen. Da hatte ich ein existierendes Programm, das ich
ein wenig optimieren wollte. Ich habe dazu folgende Funktion in ein
Makro umgewandelt:

void MInvTransPoint (VECTOR result, VECTOR vector,
TRANSFORM *transform)
{
register int i;
DBL answer_array[4];
MATRIX *matrix;

matrix = (MATRIX *) transform->inverse;
for (i = 0 ; i < 3 ; i++)
{
answer_array[i] = vector[X] * (*matrix)[0][i] +
vector[Y] * (*matrix)[1][i] +
vector[Z] * (*matrix)[2][i] + (*matrix)[3][i];
}

result[X] = answer_array[0];
result[Y] = answer_array[1];
result[Z] = answer_array[2];
}

Immerhin sind darin 9 double-Multiplikationen und 9 Additionen
enthalten. Das Umwandeln in ein Makro hat dafür gesorgt, daß diese
Operation nur noch halb so viel Zeit verbraucht hat! Der
Funktionsaufruf alleine hat also so viel Zeit gekostet wie der ganze
Inhalt der Funktion.

In das letzte Element von answer_array wird nicht hineingeschrieben.
Warum hast du answer_array überdimensioniert?

Wozu die Schleife?

Dienen die langen Variablen der Verschleierung, oder was soll das?

Ich komme auf folgendes:

void MInvTransPoint(VECTOR res, VECTOR vec, TRANSFORM* trans) {
const MATRIX& m = *(const MATRIX*)trans->inverse;
VECTOR t;
t[X] = vec[X] * m[0][0] + vec[Y] * m[1][0] + vec[Z] * m[2][0] + m[3][0];
t[Y] = vec[X] * m[0][1] + vec[Y] * m[1][1] + vec[Z] * m[2][1] + m[3][1];
t[Z] = vec[X] * m[0][2] + vec[Y] * m[1][2] + vec[Z] * m[2][2] + m[3][2];
res = t;
}

(Ist jetzt C++, in C aber nicht groß anders.)

Wie immer kapiere ich nicht, warum Sachen, die in wenigen Zeilen
klar verständlich hingeschrieben werden können, permanent verkompliziert
werden.

Gruß
Volker

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Rolf Magnus
Guest

Posted: Thu May 27, 2004 9:23 am Post subject: Re: Performance-Frage

Volker Glave wrote:

Quote:

Ich habe diese Funktion nicht geschrieben. Das Programm war schon da,
aber es lief mir zu langsam. Deshalb habe ich nach Optimierunspotenzial
gesucht und dabei den (zumindest für mich) erstaunlichen
Performance-Zuwachs durch's inlining entdeckt.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Albrecht Fritzsche
Guest

Posted: Fri May 28, 2004 6:53 am Post subject: Re: Performance-Frage

Torsten Hensel wrote:

Quote:

Hi!

Ich habe eine Performance-Frage. Mir ist klar, dass es bei der
Performance auf viele Dinge ankommen (Compiler, Prozessor,
Optimierung), daher geht es mir eher ums Prinzip als um das letzte
bisschen Rechenleistung.

Ich habe eine recht aufwändige Berechnungsfunktion, die in zwei großen
while-Schleifen die eigentliche Berechnung durchführt. Davor und
dazwischen sind in erster Linie Vorbereitungen und Initialisierungen.
Nun möchte ich diese Funktion in mehrere kleine Funktionen
unterteilen. Meine Frage ist jetzt: Wie sehr macht sich der Overhead
durch die Funktionsaufrufe bemerkbar?

Die neueste CUJ-Ausgabe hat dazu einen erhellenden Beitrag (Koenig/Moo):
Ausgehend von einen Programm

int main() {
int n=1000000000;
while (--n >= 0) {}
return 0;
}

wurde die Zeit gemessen (jeweils mit Opt., 0.64 s). Eine Aenderung nach

void f() {}

int main() {
int n=1000000000;
while (--n >= 0) {
f();
}
return 0;
}

erbrachte 4.1s, dh 3.5 nanosec pro Aufruf. Mit inlining ging jeglicher
Overhead weg - 0.64s. Der Aufruf einer Memberfkt. brachte einen kleinen
Overhead, 0.68s. Aber der Aufruf einer virtual Memberfkt brachte dann
immerhin schon eine Laufzeit von 5.77s, dh 5.13 nanosec pro virtual
function.

Weitere Erkenntnisse waren, dass Fkt-pointer mitunter nie ge-inlined
werden (was nicht ganz neu ist), wohingegen Functors, dh
Funktionsobjekte sehr gut inlinen.

Hope it helps
Ali

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Markus Becker
Guest

Posted: Mon May 31, 2004 11:13 pm Post subject: Re: Performance-Frage

Rolf Magnus schrieb:

Quote:

Hast Du die Performance mal mit Volkers umgebauter Version
verglichen? Wuerde mich mal interessieren, ob der Compiler
da evtl. besser optimieren kann...

Markus

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Torsten Hensel
Guest

Posted: Tue Jun 01, 2004 6:43 am Post subject: Re: Performance-Frage

Ralf Bartzke <ralf.bartzke (AT) t-online (DOT) de> wrote:

Quote:

Kommt drauf an. Möglicherweise bleibt der Code trotz Auslagerung in
Funktionen aufgrund der Optimierung inline.

Wenn ich eine Funktion explizit inline deklariere muss ich sie doch
auch im Header definieren, oder kann ich die Deklaration im Header
inline machen und die Definition trotzdem in eine .cpp-Datei packen?
Wäre halt übersichtlicher...

Quote:

.... und genau das wird mein Problem sein. Ich werde wohl mehrere
Parameter übergeben müssen *nachzähl* - so zwischen 5 und 10
Parameter, entweder double oder Zeiger bzw. Referenzen.

Quote:

In den Funktionen werden eigentlich nur sehr einfache Sachen gemacht,
Vergleiche, Zuweisungen, einfache Berechnungen wie + oder *. Und: Die
einzelnen Funktionen werden nicht mehrmals innerhalb eines Durchlaufs
einer Schleife ausgeführt, sondern nur einmal pro Schleifendurchlauf -
jedoch evt. in beiden Schleifen.

Ciao,
Torsten

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Andreas Huennebeck
Guest

Posted: Tue Jun 01, 2004 7:58 am Post subject: Re: Performance-Frage

Torsten Hensel wrote:

Quote:

Nein, sie muss im Header stehen, oder eben in einer Datei, die
inkludiert wird. Der Compiler kann nur Code inlinen, den er auch
gesehen hat ...

Tschau
Andreas
--
Andreas Hünnebeck | email: [email]ah (AT) despammed (DOT) com[/email]
----- privat ---- | www : http://www.huennebeck-online.de
Fax/Anrufbeantworter: 0721/151-284301 o. 0180/50525-5232659 (24 Pfg/Min)
SMS: D1=72617 D2=0172/7366-042 E-Plus=0177/7934-396 Viag=0179/2029-894
GPG-Key: http://www.huennebeck-online.de/public_keys/andreas.asc

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Rolf Magnus
Guest

Posted: Tue Jun 01, 2004 10:22 am Post subject: Re: Performance-Frage

Torsten Hensel wrote:

Quote:

Ralf Bartzke <ralf.bartzke (AT) t-online (DOT) de> wrote:
Kommt drauf an. Möglicherweise bleibt der Code trotz Auslagerung in
Funktionen aufgrund der Optimierung inline.

Wenn ich eine Funktion explizit inline deklariere muss ich sie doch
auch im Header definieren, oder kann ich die Deklaration im Header
inline machen und die Definition trotzdem in eine .cpp-Datei packen?
Wäre halt übersichtlicher...

Ja, das kannst du. Dann ist das Inlining der Funktion allerdings nur bei
Aufrufen aus der selben .cpp-Datei heraus möglich.

Quote:

Haben die Funktionen wie üblich einige Parameter und Rückgabewert(e),
ist der Aufwand wesentlich höher, da alle Parameter auf den Stack
oder zumindest in bestimmte CPU-Register kopiert werden müssen.

... und genau das wird mein Problem sein. Ich werde wohl mehrere
Parameter übergeben müssen *nachzähl* - so zwischen 5 und 10
Parameter, entweder double oder Zeiger bzw. Referenzen.

Das empfinde ich schon als zu viel, aber nicht aus Performance-Gründen,
sondern aus Gründen der Lesbarkeit. Mehr als drei oder vier Parameter
sollte man schon relativ selten haben, 10 eigentlich nie.

Quote:

Bei 10 ... 70 Zeilen Code würde ich den Overhead zwischen 0.5 und 30
% vermuten. Stark abhängig davon, was die Funktionen machen, wie der
Compiler optimiert und was für eine CPU genutzt wird. Da hilft nur
probieren und nachmessen.

In den Funktionen werden eigentlich nur sehr einfache Sachen gemacht,
Vergleiche, Zuweisungen, einfache Berechnungen wie + oder *. Und: Die
einzelnen Funktionen werden nicht mehrmals innerhalb eines Durchlaufs
einer Schleife ausgeführt, sondern nur einmal pro Schleifendurchlauf -
jedoch evt. in beiden Schleifen.

Wie schon erwähnt, ist es am besten, wenn du einfach ausprobierst, wie
schnell es ist. Kannst ja dann hier mal schreiben, was das Ergebnis
war ;-)

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Display posts from previous:

	C++Talk.NET Forum Index -> C++ (German)	All times are GMT Goto page 1, 2 Next
Page 1 of 2

You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum