Wie kann man die Zeit für einen großen Codeblock messen, außer wenn er an einem Haltepunkt angehalten wird?

Question

Ich arbeite an einer C++ Spiel/Simulation/Grafik-Anwendung unter Windows.
(edit start) Wenn es darauf ankommt, ich Visual Studio 2013 (edit Ende)

-Setup bin mit: Ich Messe die Zeit von einem Bild zum nächsten mit Queryperformancecounter().

Schritte zum Reproduzieren: An einem Haltepunkt für einige Debuggen anhalten.

Aktuelle Unerwünschte Ergebnis: Wenn die Ausführung der Anwendung wird fortgesetzt, das nächste Mal Queryperformancecounter() aufgerufen wird, wird es einen Zeitwert zurück, die die ganze Zeit einschließt, wurde im Debugger angehalten verbrachte. Dies führt zu einer Rahmenzeitlänge, die ungewöhnlich groß ist.

Gewünschtes Ergebnis: QueryPerformanceCounter() gibt einen Zeitwert zurück, der nicht viel Zeit enthält, die ich an einem Haltepunkt zum Debuggen pausiert habe.

Wie kann ich das gewünschte Ergebnis erzielen?
1. Gibt es eine andere Funktion, die ich anstelle von QueryPerformanceCounter verwenden sollte?
2. Gibt es einige Einstellungen in einer IDE (z. B. Visual Studio), die geändert werden können?
3. Gibt es eine spezielle Möglichkeit, QueryPerformanceCounter oder andere Zeitfunktion zu verwenden?
4. usw.

Referenz Hinweise: Es ist eine etwas ähnliche Frage hier aufgeführt, aber es war nicht hilfreich für mich, eine Lösung zu identifizieren. Tracking Time Spent in Debugger

Answer 1

Ich bin mir nicht sicher, ob ich verstehe, was Sie versuchen zu tun.

• Dauermessung im Debug-Modus ist nutzlos. Die Unterschiede zwischen Debug und Release sind dramatisch. Das Verhältnis zwischen verschiedenen Ausführungszeiten verschiedener Funktionen ist in Debug und Release nicht unbedingt gleich.
• Wenn Sie Engpässe beheben müssen, verwenden Sie einen Profiler (in VC zu Debug | Profiler) gehen.

Wenn Sie noch die Zeit im Debug-Modus messen wollen, dann ist hier eine Idee:

#include <iostream> 
#include <chrono> 
#include <Windows.h> 

struct duration 
{ 
    std::chrono::high_resolution_clock::time_point _s; 

    duration() : _s(std::chrono::high_resolution_clock::now()) 
    { 
    // nop 
    } 

    auto ms() 
    { 
    return std::chrono::duration<double, std::milli>(std::chrono::high_resolution_clock::now() - _s).count(); 
    } 
}; 

struct breakpoint 
{ 
    std::chrono::high_resolution_clock::time_point _s; 
    duration& _d; 

    breakpoint(duration& a_d) : _s(std::chrono::high_resolution_clock::now()), _d(a_d) 
    { 
    __asm {int 3} 
    } 

    ~breakpoint() 
    { 
    _d._s += std::chrono::high_resolution_clock::now() - _s; 
    } 
}; 

int main() 
{ 
    duration d; 

    Sleep(1000); 
    std::cout << d.ms() << std::endl; 

    breakpoint { d }; 

    Sleep(1000); 
    std::cout << d.ms() << std::endl; 

    return 0; 
}