timer.h

Go to the documentation of this file.

#ifndef __timer_h__
#define __timer_h__
 
#include <errMsgQueue.h>
#include <set>
#include <chrono>
#include <atomic>
#include <string.h>
#include <mutex>
#include <iostream>
 
#if defined(__has_builtin) // we probably use CLANG
#if __has_builtin(__builtin_FUNCTION)
#define __useBuiltinFunction__
#endif
#else // we probably use GCC
#define __useBuiltinFunction__
#endif
 
namespace timer {
    typedef std::chrono::high_resolution_clock clock_type;
    class anchor {
        friend class instanceUnscoped;
        friend class pointerCompare;
        const char*subfunc;
        const char*function;
        const char*file;
        int line;
 
        class pointerCompare {
          public:
            bool operator () (const anchor* lhs,
                              const anchor* rhs) const {
                auto cmp = strcmp(lhs->file, rhs->file);
                if (cmp < 0) {
                    return true;
                }
                if (cmp > 0) {
                    return false;
                }
                return lhs->line < rhs->line;
            }
        };
 
        std::atomic<int> counter;
        std::atomic<std::uint64_t> timeSpent;
        std::atomic<std::int64_t> maxTimeSpent;
        static std::mutex listMutex;
        static std::set<anchor*, pointerCompare>& getList() {
            static std::set<anchor*, pointerCompare> list;
            return list;
        }
 
      public:
        #ifdef __useBuiltinFunction__
        anchor(const char *aSubFunc,
               const char *aFunc = __builtin_FUNCTION(),
               int aLine = __builtin_LINE(),
               const char *aFile = __builtin_FILE()):
        #else // no info available....
        anchor(const char * aSubFunc,
               const char *aFunc = "unknown",
               int aLine = 0,
               const char *aFile = "unknown"):
        #endif
            subfunc(aSubFunc),
            function(aFunc),
            file(aFile),
            line(aLine),
            counter(0) {
            std::unique_lock<decltype(listMutex)> lock(listMutex);
            getList().emplace(this);
        }
        const char* getFunc() const {
            return function;
        };
        const char* getFile() const {
            return file;
        };
        int getLine() const {
            return line;
        };
 
 
      static void print(std::ostream& out, const std::string& prefix);
        static void reset() {
          std::unique_lock<decltype(listMutex)> lock(listMutex);
            for (auto item : getList()) {
                item->timeSpent = 0;
                item->counter = 0;
                item->maxTimeSpent = 0;
            }
        }
    };
    class instanceUnscoped {
        anchor& lAnchor;
        clock_type::time_point start;
      public:
        instanceUnscoped(anchor& aAnchor): lAnchor(aAnchor) {
            start = clock_type::now();
        }
        static inline void updateMax(std::atomic<std::int64_t>& max, std::int64_t val) {
            auto oldMax = max.load();
            while (val > oldMax &&
                   !max.compare_exchange_weak(oldMax, val));
        }
        void stop() {
            lAnchor.counter++;
            auto timeSpent = clock_type::now() - start;
            auto timeSpentNs = std::chrono::duration_cast<std::chrono::nanoseconds>(timeSpent).count();
            lAnchor.timeSpent += timeSpentNs;
            updateMax(lAnchor.maxTimeSpent, timeSpentNs);
        }
        static inline const std::string& stringy(const std::string& s) {
            return s;
        }
        static inline const std::string stringy(const std::vector<char>& s) {
            return std::string(s.data());
        }
        
        template <class T> void stop(clock_type::duration timeout, const T& object) {
            lAnchor.counter++;
            auto timeSpent = clock_type::now() - start;
            auto timeSpentNs = std::chrono::duration_cast<std::chrono::nanoseconds>(timeSpent).count();
            lAnchor.timeSpent += timeSpentNs;
            updateMax(lAnchor.maxTimeSpent, timeSpentNs);
            if (timeSpent > timeout) {
                const std::string& oref(stringy(object));
                errMsg::emit(errMsg::level::debug, errMsg::location(lAnchor.function, lAnchor.line, lAnchor.file),
                             oref, lAnchor.subfunc, "tardy action took ", std::chrono::duration_cast<std::chrono::duration<double>>(timeSpent).count(), "s");
            }
        }
        void restart() {
            start = clock_type::now();
        }
    };
    class instance: private instanceUnscoped {
      public:
        instance(anchor& aAnchor): instanceUnscoped(aAnchor) {};
        ~instance() {
            stop();
        }
    };
    template <class T> class instanceWithTimeout: private instanceUnscoped {
        clock_type::duration timeout;
        const T& object;
    public:
        instanceWithTimeout(anchor& aAnchor, clock_type::duration aTimeout, const T& aObject): instanceUnscoped(aAnchor),
                            timeout(aTimeout),
                            object(aObject) {};
        ~instanceWithTimeout() {
            stop(timeout, object);
        }
    };
 
};
#define timerInst(subfunc) static timer::anchor aUniqueName##subfunc(#subfunc); timer::instance iUniqueName##subfunc(aUniqueName##subfunc)
#define timerInstTO(subfunc,timeout,object) static timer::anchor aUniqueName##subfunc(#subfunc); timer::instanceWithTimeout<decltype(object)> iUniqueName##subfunc(aUniqueName##subfunc, timeout, object)
 
 
#undef __useBuiltinFunction__
#endif