timing.hpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#ifndef timing_h
#define timing_h
 
#include <chrono>
#include <mutex>
#include <map>
 
namespace timing {
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    class measure_diagnostic {
    private:
        const std::string label;
        std::chrono::high_resolution_clock::time_point start;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        measure_diagnostic(const std::string message = "") :
        label(message), start(std::chrono::high_resolution_clock::now()) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        measure_diagnostic(const measure_diagnostic &md) :
        label(md.label), start(md.start) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void reset() {
            start = std::chrono::high_resolution_clock::now();
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void print() const {
            const auto end = std::chrono::high_resolution_clock::now();
            const auto total_time = end - start;
            const std::chrono::nanoseconds total_time_ns =
                      std::chrono::duration_cast<std::chrono::nanoseconds> (total_time);
 
            std::cout << std::endl << "  " << label << " : ";
 
            if (total_time_ns.count() < 1000) {
                std::cout << total_time_ns.count()                 << " ns"  << std::endl;
            } else if (total_time_ns.count() < 1000000) {
                std::cout << total_time_ns.count()/1000.0          << " μs"  << std::endl;
            } else if (total_time_ns.count() < 1000000000) {
                std::cout << total_time_ns.count()/1000000.0       << " ms"  << std::endl;
            } else if (total_time_ns.count() < 60000000000) {
                std::cout << total_time_ns.count()/1000000000.0    << " s"   << std::endl;
            } else if (total_time_ns.count() < 3600000000000) {
                std::cout << total_time_ns.count()/60000000000.0   << " min" << std::endl;
            } else {
                std::cout << total_time_ns.count()/3600000000000.0 << " h"   << std::endl;
            }
            std::cout << std::endl;
        }
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    class measure_diagnostic_threaded {
    private:
        const std::string label;
        std::map<size_t, std::chrono::high_resolution_clock::time_point> start;
        std::map<size_t, std::chrono::high_resolution_clock::time_point> end;
        std::mutex sync_start;
        std::mutex sync_end;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        measure_diagnostic_threaded(const std::string message = "") :
        label(message) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        measure_diagnostic_threaded(const measure_diagnostic_threaded &mdt) :
        label(mdt.label) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void start_time(const size_t thread_number) {
            sync_start.lock();
            start[thread_number] = std::chrono::high_resolution_clock::now();
            sync_start.unlock();
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void end_time(const size_t thread_number) {
            const auto temp = std::chrono::high_resolution_clock::now();
            sync_end.lock();
            end[thread_number] = temp;
            sync_end.unlock();
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void print() {
            std::chrono::nanoseconds total_time_ns = static_cast<std::chrono::nanoseconds> (0);
            for (size_t i = 0, ie = start.size(); i < ie; i++) {
                const auto duration = end[i] - start[i];
                total_time_ns += std::chrono::duration_cast<std::chrono::nanoseconds> (duration);
            }
 
            std::cout << "Average " << label << " time : " << total_time_ns.count()/start.size() << " ns"<< std::endl;
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void print_max() {
            std::chrono::nanoseconds total_time_ns = static_cast<std::chrono::nanoseconds> (0);
            for (size_t i = 0, ie = start.size(); i < ie; i++) {
                const auto duration = end[i] - start[i];
                total_time_ns = std::max(std::chrono::duration_cast<std::chrono::nanoseconds> (duration), total_time_ns);
            }
 
            std::cout << "Max " << label << " time : ";
            if (total_time_ns.count() < 1000) {
                std::cout << total_time_ns.count()                 << " ns"  << std::endl;
            } else if (total_time_ns.count() < 1000000) {
                std::cout << total_time_ns.count()/1000.0          << " μs"  << std::endl;
            } else if (total_time_ns.count() < 1000000000) {
                std::cout << total_time_ns.count()/1000000.0       << " ms"  << std::endl;
            } else if (total_time_ns.count() < 60000000000) {
                std::cout << total_time_ns.count()/1000000000.0    << " s"   << std::endl;
            } else if (total_time_ns.count() < 3600000000000) {
                std::cout << total_time_ns.count()/60000000000.0   << " min" << std::endl;
            } else {
                std::cout << total_time_ns.count()/3600000000000.0 << " h"   << std::endl;
            }
            std::cout << std::endl;
        }
    };
}
 
#endif /* timing_h */