profile.hh

#ifndef VTESTBED_PROFILE_PROFILE_HH
#define VTESTBED_PROFILE_PROFILE_HH

#include <vtestbed/config/profile.hh>

#if defined(VTB_WITH_PROFILE)

#include <chrono>
#include <fstream>
#include <iosfwd>
#include <mutex>
#include <ostream>
#include <tuple>

namespace vtb {

    namespace profile {

        extern thread_local int profile_level;
        extern std::ofstream stream;
        extern const char* filename;
        extern std::mutex mtx;

        template <class Tuple, std::size_t N>
        struct tuple_traits {
            static void print(std::ostream& out, const Tuple& t) {
                tuple_traits<Tuple,N-1>::print(t);
                out << ' ' << std::get<N-1>(t);
            }
        };

        template <class Tuple>
        struct tuple_traits<Tuple,1> {
            static void print(std::ostream& out, const Tuple& t) { out << std::get<0>(t); }
        };


        class Profile {

        private:
            using clock = std::chrono::high_resolution_clock;
            using time_point = clock::time_point;
            using duration = clock::duration;

        private:
            const char* _tag = "";
            time_point _t0{duration::zero()};
            time_point _t1{duration::zero()};
            int _level{0};

        public:

            Profile() = default;

            inline explicit
            Profile(const char* tag):
            _tag{tag},
            _t0{clock::now()},
            _t1{duration::zero()},
            _level{++profile_level}
            {}

            ~Profile();

            void
            print();

        };

        template <class ... Args>
        class Benchmark {

        private:
            using clock = std::chrono::high_resolution_clock;
            using time_point = clock::time_point;
            using duration = clock::duration;
            using tuple_type = std::tuple<Args...>;
            using traits_type = tuple_traits<tuple_type,std::tuple_size<tuple_type>::value>;

        private:
            const char* _tag = "";
            time_point _t0{duration::zero()};
            time_point _t1{duration::zero()};
            tuple_type _params;

        public:

            Benchmark() = default;

            inline explicit Benchmark(const char* tag, Args... params):
            _tag{tag}, _t0{clock::now()}, _t1{duration::zero()}, _params{params...} {}

            inline ~Benchmark() {
                using namespace std::chrono;
                this->_t1 = clock::now();
                auto dt = duration_cast<microseconds>(this->_t1 - this->_t0);
                if (filename) {
                    mtx.lock();
                    if (!stream.is_open()) { stream.open(filename); }
                    stream << this->_tag << ' ';
                    traits_type::print(stream,this->_params);
                    stream << ' ' << dt.count() << std::endl;
                    mtx.unlock();
                }
            }

        };

        template <class ... Args>
        inline Benchmark<Args...>
        make_benchmark(const char* tag, Args... args) {
            return Benchmark<Args...>(tag, args...);
        }

    }

}

#define VTB_PROFILE_BLOCK(tag) \
    ::vtb::profile::Profile __profile_ ## __LINE__{tag}

#define VTB_BENCHMARK_BLOCK(tag, ...) \
    auto __benchmark_ ## __LINE__ = ::vtb::profile::make_benchmark(tag,__VA_ARGS__)

#else

#define VTB_PROFILE_BLOCK(tag)
#define VTB_BENCHMARK_BLOCK(tag, ...)

#endif

#endif // vim:filetype=cpp