Zeit messen

C++ Forumbot

Dieser Thread wurde von Moderator/in Jochen Kalmbach aus dem Forum C++/CLI mit .NET in das Forum C++ (auch C++0x und C++11) verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Thuruk

timeval start,ende;

Edit: ach das ist ein Variablentyp, kannte ich noch net.

#include <iostream>

using namespace std;

#include <ctime>

int main()
{
	time_t start, ende;
	time(&start);

	//Newton

	time(&ende);
	start-=ende;

	cout << "Hat " << start << " Sekunden gebraucht.\n";
	for(;;){}
	return 0;
}

So würde ich das machen.

SeppJ

Einen deutlichen Tacken genauer als das fast immer nur sekundengetaktete time() wäre die Benutzung von clock(). Damit bekommt man die Messung im zehntel bis hundertstel Sekundentakt genau (systemabhängig, aber das sind typische Werte). Genau dafür ist clock auch gedacht, wohingegen time dazu da ist, die tatsächliche Uhrzeit zu bestimmen (die man normalerweise nicht so genau braucht). Für noch genauerer Zeitmessung muss man dann Systemfunktionen benutzen.

unskilled

für windows nehme ich immer so was in der richtung:

/*timer.hpp*/ 

#include "windows.h" 

#include <cassert> 
#include <stdexcept> 

struct large_integer_t 
{ 
    typedef __int64 integral_type; 
    operator float() const 
    { 
        return static_cast<float>( static_cast<integral_type>(*this) ); 
    } 

    operator integral_type() const 
    { 
        return data.QuadPart; 
    } 
    operator integral_type() 
    { 
        return data.QuadPart; 
    } 

    large_integer_t() 
    :    data(LARGE_INTEGER()) 
    {} 

    large_integer_t(const LARGE_INTEGER& data) 
    :    data(data) 
    {} 

    large_integer_t& operator-= (const large_integer_t& other) 
    { 
        data.QuadPart -= other.data.QuadPart; 
        return *this; 
    } 
private: 
    LARGE_INTEGER data; 
}; 

large_integer_t operator- (const large_integer_t& lhs, const large_integer_t& rhs)
 { 
    large_integer_t tmp(lhs); 
    tmp -= rhs; 
    return tmp; 
} 

class timer_t 
{ 
public: 
    typedef float second_t; 

    timer_t() 
    :    begin(get_timestamp()) 
#if !defined (NDEBUG) 
    ,    stopped(false) 
#endif //#if !defined (_NDEBUG) 
    { 
        end = begin; 
    } 

    void stop() 
    { 
#if !defined (NDEBUG) 
        stopped = true; 
#endif //#if !defined (_NDEBUG) 

        end = get_timestamp(); 
    } 

    second_t get_seconds() const 
    { 
        assert(stopped); 

        return (end-begin)/static_cast<second_t>(get_frequency()); 
    } 

private: 
#if !defined (NDEBUG) 
    bool stopped; 
#endif //#if !defined (_NDEBUG) 

    static large_integer_t get_frequency() 
    { 
        LARGE_INTEGER ret_val; 
        BOOL succeed = QueryPerformanceFrequency(&ret_val); 

        if(!succeed) 
            throw std::runtime_error("calling QueryPerformanceFrequency failed");

        return ret_val; 
    } 

    static large_integer_t get_timestamp() 
    { 
        LARGE_INTEGER ret_val; 
        BOOL succeed = QueryPerformanceCounter(&ret_val); 

        if(!succeed) 
            throw std::runtime_error("calling QueryPerformanceCounter failed"); 

        return ret_val; 
    } 

    large_integer_t begin; 
    large_integer_t end; 
};

zu verwenden:

#include <iostream>
#include "timer.hpp"

int main()
{
  timer_t time;
  do_stuff();
  time.stop();

  std::cout << "Sekunden: " << time.get_seconds() << std::endl;
}

bb

SeppJ schrieb:

Einen deutlichen Tacken genauer als das fast immer nur sekundengetaktete time() wäre die Benutzung von clock(). Damit bekommt man die Messung im zehntel bis hundertstel Sekundentakt genau (systemabhängig, aber das sind typische Werte). Genau dafür ist clock auch gedacht, wohingegen time dazu da ist, die tatsächliche Uhrzeit zu bestimmen (die man normalerweise nicht so genau braucht). Für noch genauerer Zeitmessung muss man dann Systemfunktionen benutzen.

SeppJ, schau dir C++11s oder boosts <chrono> an. Soweit ich das richtig verstanden habe, bietet <chrono> eine hochauflösende Zeitmessung an.

zahlenfreund

Danke für die Antoworten,besonders unskilled. Mit deinem Programm geht das sehr gut. Ich brauch das aber für ein Projekt und nutz dein Programm ungern um keinen Ärger zu kriegen. Deswegen will ich timeofday()nutzen denn time() ist zu ungenau aber welche H-datei brauch ich nun dazu? Warum läuft das nicht? Ich hab das genau so aud dem c++ Buch von Willemer abgeschrieben.

Incocnito

Benutz' doch einfach wie erwähnt std::clock().
Das funktioniert ziemlich einfach so:

#include <ctime>
#include <iostream>

int main()
{
    double start = std::clock();
    //Das, was Zeit frisst..
    double end = std::clock();
    std::cout << "Elapsed time: " << (end - start) / CLOCKS_PER_SEC << "\n";
    return 0;
}

Näheres siehe http://www.cplusplus.com/reference/clibrary/ctime/clock/.

_matze

zahlenfreund schrieb:

Ich brauch das aber für ein Projekt und nutz dein Programm ungern um keinen Ärger zu kriegen.

Meinst du wegen Urheberrechten? Das wäre kein Problem. Ich glaube, alles was hier ins Forum reingestellt wird, darf man sich klauen (korrigiert mich ggf.).

Falls du meinst, dass du nichts Fremdes verwenden sollst, bastele dir doch einfach selbst was mit QueryPerformanceCounter . Die Funktion ist nicht schwer zu benutzen, siehe Doku. Genauer wirst du es unter Windows vermutlich nicht hinbekommen.

zahlenfreund

clock() funktoniert ist aber zu ungenau, weil die Verfahren nur 10^-5 s braucht.
gettimeofday ist am besten geeignet, womit ich zum ursprünglichen Problem zurückkomme. gettimeofday wird nicht erkannt, wie ich vermute, weil keine h-Datei erkannt wird.Welche h-Datie brauche ich um gettimeofday zu nutzen?

SeppJ

Google: gettimeofday

pyhax

http://suacommunity.com/dictionary/gettimeofday-entry.php schrieb:

There is no direct analog of the gettimeofday() in Windows; developers porting codes that use this function must provide a conversion.