123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466 |
- /* Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * * Neither the name of NVIDIA CORPORATION nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
- // Helper Timing Functions
- #ifndef COMMON_HELPER_TIMER_H_
- #define COMMON_HELPER_TIMER_H_
- #ifndef EXIT_WAIVED
- #define EXIT_WAIVED 2
- #endif
- // includes, system
- #include <vector>
- // includes, project
- #include <exception.h>
- // Definition of the StopWatch Interface, this is used if we don't want to use
- // the CUT functions But rather in a self contained class interface
- class StopWatchInterface {
- public:
- StopWatchInterface() {}
- virtual ~StopWatchInterface() {}
- public:
- //! Start time measurement
- virtual void start() = 0;
- //! Stop time measurement
- virtual void stop() = 0;
- //! Reset time counters to zero
- virtual void reset() = 0;
- //! Time in msec. after start. If the stop watch is still running (i.e. there
- //! was no call to stop()) then the elapsed time is returned, otherwise the
- //! time between the last start() and stop call is returned
- virtual float getTime() = 0;
- //! Mean time to date based on the number of times the stopwatch has been
- //! _stopped_ (ie finished sessions) and the current total time
- virtual float getAverageTime() = 0;
- };
- //////////////////////////////////////////////////////////////////
- // Begin Stopwatch timer class definitions for all OS platforms //
- //////////////////////////////////////////////////////////////////
- #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
- // includes, system
- #define WINDOWS_LEAN_AND_MEAN
- #include <windows.h>
- #undef min
- #undef max
- //! Windows specific implementation of StopWatch
- class StopWatchWin : public StopWatchInterface {
- public:
- //! Constructor, default
- StopWatchWin()
- : start_time(),
- end_time(),
- diff_time(0.0f),
- total_time(0.0f),
- running(false),
- clock_sessions(0),
- freq(0),
- freq_set(false) {
- if (!freq_set) {
- // helper variable
- LARGE_INTEGER temp;
- // get the tick frequency from the OS
- QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER *>(&temp));
- // convert to type in which it is needed
- freq = (static_cast<double>(temp.QuadPart)) / 1000.0;
- // rememeber query
- freq_set = true;
- }
- }
- // Destructor
- ~StopWatchWin() {}
- public:
- //! Start time measurement
- inline void start();
- //! Stop time measurement
- inline void stop();
- //! Reset time counters to zero
- inline void reset();
- //! Time in msec. after start. If the stop watch is still running (i.e. there
- //! was no call to stop()) then the elapsed time is returned, otherwise the
- //! time between the last start() and stop call is returned
- inline float getTime();
- //! Mean time to date based on the number of times the stopwatch has been
- //! _stopped_ (ie finished sessions) and the current total time
- inline float getAverageTime();
- private:
- // member variables
- //! Start of measurement
- LARGE_INTEGER start_time;
- //! End of measurement
- LARGE_INTEGER end_time;
- //! Time difference between the last start and stop
- float diff_time;
- //! TOTAL time difference between starts and stops
- float total_time;
- //! flag if the stop watch is running
- bool running;
- //! Number of times clock has been started
- //! and stopped to allow averaging
- int clock_sessions;
- //! tick frequency
- double freq;
- //! flag if the frequency has been set
- bool freq_set;
- };
- // functions, inlined
- ////////////////////////////////////////////////////////////////////////////////
- //! Start time measurement
- ////////////////////////////////////////////////////////////////////////////////
- inline void StopWatchWin::start() {
- QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER *>(&start_time));
- running = true;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Stop time measurement and increment add to the current diff_time summation
- //! variable. Also increment the number of times this clock has been run.
- ////////////////////////////////////////////////////////////////////////////////
- inline void StopWatchWin::stop() {
- QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER *>(&end_time));
- diff_time = static_cast<float>(((static_cast<double>(end_time.QuadPart) -
- static_cast<double>(start_time.QuadPart)) /
- freq));
- total_time += diff_time;
- clock_sessions++;
- running = false;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Reset the timer to 0. Does not change the timer running state but does
- //! recapture this point in time as the current start time if it is running.
- ////////////////////////////////////////////////////////////////////////////////
- inline void StopWatchWin::reset() {
- diff_time = 0;
- total_time = 0;
- clock_sessions = 0;
- if (running) {
- QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER *>(&start_time));
- }
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Time in msec. after start. If the stop watch is still running (i.e. there
- //! was no call to stop()) then the elapsed time is returned added to the
- //! current diff_time sum, otherwise the current summed time difference alone
- //! is returned.
- ////////////////////////////////////////////////////////////////////////////////
- inline float StopWatchWin::getTime() {
- // Return the TOTAL time to date
- float retval = total_time;
- if (running) {
- LARGE_INTEGER temp;
- QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER *>(&temp));
- retval += static_cast<float>(((static_cast<double>(temp.QuadPart) -
- static_cast<double>(start_time.QuadPart)) /
- freq));
- }
- return retval;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Time in msec. for a single run based on the total number of COMPLETED runs
- //! and the total time.
- ////////////////////////////////////////////////////////////////////////////////
- inline float StopWatchWin::getAverageTime() {
- return (clock_sessions > 0) ? (total_time / clock_sessions) : 0.0f;
- }
- #else
- // Declarations for Stopwatch on Linux and Mac OSX
- // includes, system
- #include <sys/time.h>
- #include <ctime>
- //! Windows specific implementation of StopWatch
- class StopWatchLinux : public StopWatchInterface {
- public:
- //! Constructor, default
- StopWatchLinux()
- : start_time(),
- diff_time(0.0),
- total_time(0.0),
- running(false),
- clock_sessions(0) {}
- // Destructor
- virtual ~StopWatchLinux() {}
- public:
- //! Start time measurement
- inline void start();
- //! Stop time measurement
- inline void stop();
- //! Reset time counters to zero
- inline void reset();
- //! Time in msec. after start. If the stop watch is still running (i.e. there
- //! was no call to stop()) then the elapsed time is returned, otherwise the
- //! time between the last start() and stop call is returned
- inline float getTime();
- //! Mean time to date based on the number of times the stopwatch has been
- //! _stopped_ (ie finished sessions) and the current total time
- inline float getAverageTime();
- private:
- // helper functions
- //! Get difference between start time and current time
- inline float getDiffTime();
- private:
- // member variables
- //! Start of measurement
- struct timeval start_time;
- //! Time difference between the last start and stop
- float diff_time;
- //! TOTAL time difference between starts and stops
- float total_time;
- //! flag if the stop watch is running
- bool running;
- //! Number of times clock has been started
- //! and stopped to allow averaging
- int clock_sessions;
- };
- // functions, inlined
- ////////////////////////////////////////////////////////////////////////////////
- //! Start time measurement
- ////////////////////////////////////////////////////////////////////////////////
- inline void StopWatchLinux::start() {
- gettimeofday(&start_time, 0);
- running = true;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Stop time measurement and increment add to the current diff_time summation
- //! variable. Also increment the number of times this clock has been run.
- ////////////////////////////////////////////////////////////////////////////////
- inline void StopWatchLinux::stop() {
- diff_time = getDiffTime();
- total_time += diff_time;
- running = false;
- clock_sessions++;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Reset the timer to 0. Does not change the timer running state but does
- //! recapture this point in time as the current start time if it is running.
- ////////////////////////////////////////////////////////////////////////////////
- inline void StopWatchLinux::reset() {
- diff_time = 0;
- total_time = 0;
- clock_sessions = 0;
- if (running) {
- gettimeofday(&start_time, 0);
- }
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Time in msec. after start. If the stop watch is still running (i.e. there
- //! was no call to stop()) then the elapsed time is returned added to the
- //! current diff_time sum, otherwise the current summed time difference alone
- //! is returned.
- ////////////////////////////////////////////////////////////////////////////////
- inline float StopWatchLinux::getTime() {
- // Return the TOTAL time to date
- float retval = total_time;
- if (running) {
- retval += getDiffTime();
- }
- return retval;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Time in msec. for a single run based on the total number of COMPLETED runs
- //! and the total time.
- ////////////////////////////////////////////////////////////////////////////////
- inline float StopWatchLinux::getAverageTime() {
- return (clock_sessions > 0) ? (total_time / clock_sessions) : 0.0f;
- }
- ////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////
- inline float StopWatchLinux::getDiffTime() {
- struct timeval t_time;
- gettimeofday(&t_time, 0);
- // time difference in milli-seconds
- return static_cast<float>(1000.0 * (t_time.tv_sec - start_time.tv_sec) +
- (0.001 * (t_time.tv_usec - start_time.tv_usec)));
- }
- #endif // WIN32
- ////////////////////////////////////////////////////////////////////////////////
- //! Timer functionality exported
- ////////////////////////////////////////////////////////////////////////////////
- //! Create a new timer
- //! @return true if a time has been created, otherwise false
- //! @param name of the new timer, 0 if the creation failed
- ////////////////////////////////////////////////////////////////////////////////
- inline bool sdkCreateTimer(StopWatchInterface **timer_interface) {
- // printf("sdkCreateTimer called object %08x\n", (void *)*timer_interface);
- #if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
- *timer_interface = reinterpret_cast<StopWatchInterface *>(new StopWatchWin());
- #else
- *timer_interface =
- reinterpret_cast<StopWatchInterface *>(new StopWatchLinux());
- #endif
- return (*timer_interface != NULL) ? true : false;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Delete a timer
- //! @return true if a time has been deleted, otherwise false
- //! @param name of the timer to delete
- ////////////////////////////////////////////////////////////////////////////////
- inline bool sdkDeleteTimer(StopWatchInterface **timer_interface) {
- // printf("sdkDeleteTimer called object %08x\n", (void *)*timer_interface);
- if (*timer_interface) {
- delete *timer_interface;
- *timer_interface = NULL;
- }
- return true;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Start the time with name \a name
- //! @param name name of the timer to start
- ////////////////////////////////////////////////////////////////////////////////
- inline bool sdkStartTimer(StopWatchInterface **timer_interface) {
- // printf("sdkStartTimer called object %08x\n", (void *)*timer_interface);
- if (*timer_interface) {
- (*timer_interface)->start();
- }
- return true;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Stop the time with name \a name. Does not reset.
- //! @param name name of the timer to stop
- ////////////////////////////////////////////////////////////////////////////////
- inline bool sdkStopTimer(StopWatchInterface **timer_interface) {
- // printf("sdkStopTimer called object %08x\n", (void *)*timer_interface);
- if (*timer_interface) {
- (*timer_interface)->stop();
- }
- return true;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Resets the timer's counter.
- //! @param name name of the timer to reset.
- ////////////////////////////////////////////////////////////////////////////////
- inline bool sdkResetTimer(StopWatchInterface **timer_interface) {
- // printf("sdkResetTimer called object %08x\n", (void *)*timer_interface);
- if (*timer_interface) {
- (*timer_interface)->reset();
- }
- return true;
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Return the average time for timer execution as the total time
- //! for the timer dividied by the number of completed (stopped) runs the timer
- //! has made.
- //! Excludes the current running time if the timer is currently running.
- //! @param name name of the timer to return the time of
- ////////////////////////////////////////////////////////////////////////////////
- inline float sdkGetAverageTimerValue(StopWatchInterface **timer_interface) {
- // printf("sdkGetAverageTimerValue called object %08x\n", (void
- // *)*timer_interface);
- if (*timer_interface) {
- return (*timer_interface)->getAverageTime();
- } else {
- return 0.0f;
- }
- }
- ////////////////////////////////////////////////////////////////////////////////
- //! Total execution time for the timer over all runs since the last reset
- //! or timer creation.
- //! @param name name of the timer to obtain the value of.
- ////////////////////////////////////////////////////////////////////////////////
- inline float sdkGetTimerValue(StopWatchInterface **timer_interface) {
- // printf("sdkGetTimerValue called object %08x\n", (void *)*timer_interface);
- if (*timer_interface) {
- return (*timer_interface)->getTime();
- } else {
- return 0.0f;
- }
- }
- #endif // COMMON_HELPER_TIMER_H_
|