c++ frage

[Dr. Picasso]

oh mein gott google hat das erste mal für mich versagt
aber vermutlich nur weil ich nicht den richtigen suchbefehl benutzt habe

ich will ein code stück auf schnelligkeit optimieren

ergo brauch ich irgendwas was mir anzeigt/ausliest/berechnet wie lange das programm gebraucht hat bis es fertig war
eine zusätzliche anzeige für die compilierzeit wäre auch ganz nett

 

[Bronzegraf]

Mit anderen Worten: Du suchst also einen C++ - Profiler?

 

[Annihilator]

Reicht dir dafür nicht time?

 

[Picard]

jo nen profiler
oder ganz billig:

beim start des programmes timestamp speichern
vorm ende des programmes timestamp speichern

differenz aus beiden bilden
gg

 

[Dr. Picasso]

ich brauche leider etwas ausführlichere hilfe

googeln nach timestamp hat mir nicht so recht helfen können, vor allem da ich den eindruck habe die auflösung sein nicht besonders präzise (sekundentakt?)

ich brauche etwas was mir ausgibt wieviel 'prozessorzeit' das programm beansprucht hat, und das möglich in sowas wie microsekunden

ich lerne c++ erst, und möchte relativ kurze codeabschnitte optimieren, um ein gefühl dafür zu bekommen wie man schnellen code programmiert

ich benutze den borland c++builderX als compiler

 

[Wesen]

Unter Windows per QueryPerformanceCounter():
http://msdn2.microsoft.com/en-us/library/bb173458.aspx

Unter Linux gettimeofday()

Alternativ: kostenloser "benutzbarer" C++ Profiler:
http://www.compuware.com/media.asp?cid=701000000004ej0
kA, ob man das teil zur zusammenarbeit mit borland bewegen kann.

 

[Meta123Tron]

Hat g++ nicht sowieso compiler-optionen die sowas erledigen?
Ich habe die noch nie verwendet, weiß also nicht ob es das ist was Du brauchst.

-ftime-report
Makes the compiler print some statistics about the time consumed by each pass when it finishes.

-fmem-report
Makes the compiler print some statistics about permanent memory allocation when it finishes.

-fprofile-arcs
Add code so that program flow arcs are instrumented. During execution the program records how many times each branch and call is executed and how many times it is taken or returns. When the compiled program exits it saves this data to a file called auxname.gcda for each source file. The data may be used for profile-directed optimizations (-fbranch-probabilities), or for test coverage analysis (-ftest-coverage). Each object file's auxname is generated from the name of the output file, if explicitly specified and it is not the final executable, otherwise it is the basename of the source file. In both cases any suffix is removed (e.g. foo.gcda for input file dir/foo.c, or dir/foo.gcda for output file specified as -o dir/foo.o).

-time
Report the CPU time taken by each subprocess in the compilation sequence. For C source files, this is the compiler proper and assembler (plus the linker if linking is done). The output looks like this:

# cc1 0.12 0.01
# as 0.00 0.01
The first number on each line is the "user time", that is time spent executing the program itself. The second number is "system time", time spent executing operating system routines on behalf of the program. Both numbers are in seconds.

 

[PiZzA]

g++ > all

 

[ROOT]

Lol, also open source schön und gut, aber wer unter Windows ernsthafte Projekte tatsächlich mitm g++ kompilieren will der ist doch selbst schuld.
Selbst vom Microsoftcompiler gibts die Express Version jetzt schon umsonst.

wenn du c++ erst lernst sollten dir laufzeitmessungen nicht wirklich weiterhelfen können deinen code zu optimieren.

 

[Dr. Picasso]

irgendwie hat mir keine antwort hier wirklich weiterhelfen können :\

ich will/wollte wirklich nur einen codefetzen den ich einfach in mein programm reinkopiere und der mir ausspuckt wie viel rechenzeit das programm beansprucht hat

jetzt lese ich den post von ag-root und bin verwirrt:
wieso sollte mir sowas nicht weiterhelfen?
ich möchte ein gefühl dafür entwickeln wie schnell bestimmte rechenoperationen durchgeführt werden (ob es sich zB lohnt möglichst lange in integer zu rechnen oder ob man von anfang an auch floats nutzen kann). ich spiele also einfach ein wenig mit matrizenmultiplikationen herum und möchte rauskriegen wie die geschwindigkeits- und genauigkeitsunterschiede entstehen

 

[ViperDK]

Du bist auch selbst schuld wenn du so ne frage stellst und nichtmal dazuschreibst welches betriebssystem du benutzt.
mal davon abgesehen, dass mir der sinn der anzeige der *compilierzeit* kein stueck einleuchtet. willst du deinen code darauf optimieren, dass er schnell compiliert? stell die optimierung aus dann haste den effekt


Ausserdem wurde oben QueryPerformanceCounter erwaehnt. *wenn* du unter windows arbeitest ist das das mittel der wahl wenn du keinen guten profiler hast.

BOOL QueryPerformanceCounter(
LARGE_INTEGER *lpPerformanceCount
);

=> In etwa so (seit jahren nur noch c#.net, garantiere fuer nix)

#include <iostream>
#include <windows.h>

void f()
{
LARGE_INTEGER start, end;
QueryPerformanceCounter(&start);
for(int i = 0; i < 1000; i++)
{
bescheuerteBerechnung();
}
QueryPerformanceCounter(&end);

cout << "ticks: " << (end-start) << endl;

}

 

[The_Company]

Original geschrieben von l-AG-lROOT
Lol, also open source schön und gut, aber wer unter Windows ernsthafte Projekte tatsächlich mitm g++ kompilieren will der ist doch selbst schuld.
Selbst vom Microsoftcompiler gibts die Express Version jetzt schon umsonst.

Ich find das lustig, das es noch Leute gibt, die ernsthaft nen C++ Compiler gut finden, der noch mit dem C++ Standard von vor 20 Jahren so seine Problemchen hat. Ausserdem kannst Du mit GCC Programme unter Windows 100x einfacher kompilieren, die primär unter Linux entwickelt werden, wie zB Gimp, XChat, Inkscape odert Pidgin.

 

[ROOT]

Original geschrieben von Picasso
ich will/wollte wirklich nur einen codefetzen den ich einfach in mein programm reinkopiere und der mir ausspuckt wie viel rechenzeit das programm beansprucht hat

http://www.willemer.de/informatik/cpp/timelib.htm
Unter Linux theoretisch Messgenauigkeiten bis zu 1 µs, unter Windows MinGW habe ich nur ca. 1-3ms hinbekommen.
Du wirst hier trotzdem noch etliche Aufrufe starten müssen um halbwegs genaue Ergebnisse zu bekommen.

Original geschrieben von Picasso
ich möchte ein gefühl dafür entwickeln wie schnell bestimmte rechenoperationen durchgeführt werden (ob es sich zB lohnt möglichst lange in integer zu rechnen oder ob man von anfang an auch floats nutzen kann). ich spiele also einfach ein wenig mit matrizenmultiplikationen herum und möchte rauskriegen wie die geschwindigkeits- und genauigkeitsunterschiede entstehen

Ob du in Integer oder Float multiplizierst wird kaum einen Unterschied in der Rechenzeit machen, sieh lieber zu Matrizenmultiplikationen zu vermeiden, die sind nämlich höllisch teuer. Generell wirst du gerade als Anfänger für eine Laufzeitoptimierung viel eher deine Algorithmen und Programmstrukturen überdenken müssen als dir Sorgen darüber zu machen ob eine float-Multiplikation schnell genug abläuft. Sowas würde man im extrem kritischen Zweifelsfall sowieso strukturenausnutzend extrem lowlevel selbst implementieren (karatsuba,..)
Ob du in Integer oder Float rechnen musst ist dir meist sowieso durch die Problemstellung vorgegeben.

Original geschrieben von The_Company
Ich find das lustig, das es noch Leute gibt, die ernsthaft nen C++ Compiler gut finden, der noch mit dem C++ Standard von vor 20 Jahren so seine Problemchen hat. Ausserdem kannst Du mit GCC Programme unter Windows 100x einfacher kompilieren, die primär unter Linux entwickelt werden, wie zB Gimp, XChat, Inkscape odert Pidgin.

Bei den ganzen Problemen die der g++ macht verzichte ich gerne auf den ein oder anderen ANSI-Korinthenkack, wenigstens hat MS nen anständigen Debugger abgeliefert samt ziemlich gescheiter Entwicklungsumgebung, gängige Software wird halt einfach für Windows geschrieben und da nimmt man nunmal MS oder in welcher Firma hast du schon mit MinGW kompiliert?
Und wozu soll man überhaupt Linux-Programme unter Windows kompilieren, da gibts nunmal fertige Executables. :P
Ich bin zwar weißgott kein Windows-Fanatiker, aber wenn man schon für Windows schreibt dann muss man sich ja nicht auch noch künstlich beschneiden.