Zakero_Profiler.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 Andrew Moore
 * 
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
#ifndef zakero_Profiler_h
#define zakero_Profiler_h
 
/******************************************************************************
 * Includes
 */
 
#include <ctime>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <map>
#include <mutex>
#include <thread>
 
// C++20
#include <experimental/source_location>
 
// Zakero
#include "Zakero_Base.h"
 
 
/******************************************************************************
 * Macros
 */
 
// {{{ Macros
 
#ifdef ZAKERO_PROFILER_ENABLE
 
#define ZAKERO_PROFILER_INIT(output_, meta_data_...) \
        zakero::Profiler::init(output_, ##meta_data_);
 
#define ZAKERO_PROFILER_ACTIVATE \
        zakero::Profiler::activate();
 
#define ZAKERO_PROFILER_DEACTIVATE \
        zakero::Profiler::deactivate();
 
#define ZAKERO_PROFILER_COMPLETE(category_, name_, meta_data_...)            \
        zakero::Profiler::Complete ZAKERO_CONCAT(zakero_profiler_, __LINE__) \
        ( category_                                                          \
        , name_                                                              \
        , std::experimental::source_location::current()                      \
        , ##meta_data_                                                       \
        );                                                                   \
 
 
#define ZAKERO_PROFILER_DURATION(category_, name_, meta_data_...)            \
        zakero::Profiler::Duration ZAKERO_CONCAT(zakero_profiler_, __LINE__) \
        ( category_                                                          \
        , name_                                                              \
        , std::experimental::source_location::current()                      \
        , ##meta_data_                                                       \
        );                                                                   \
 
#define ZAKERO_PROFILER_INSTANT(category_, name_, meta_data_...)            \
{                                                                           \
        zakero::Profiler::Instant ZAKERO_CONCAT(zakero_profiler_, __LINE__) \
        ( category_                                                         \
        , name_                                                             \
        , std::experimental::source_location::current()                     \
        , ##meta_data_                                                      \
        );                                                                  \
}                                                                           \
 
#else
 
#define ZAKERO_PROFILER_INIT(output_, meta_data_...)
#define ZAKERO_PROFILER_ACTIVATE
#define ZAKERO_PROFILER_DEACTIVATE
#define ZAKERO_PROFILER_COMPLETE(category_, name_, meta_data_...)
#define ZAKERO_PROFILER_DURATION(category_, name_, meta_data_...)
#define ZAKERO_PROFILER_INSTANT(category_, name_, meta_data_...)
 
#endif
 
// }}}
 
namespace zakero
{
        // {{{ Declaration
 
        class Profiler
        {
                public:
                        using MetaData = std::map<std::string, std::string>;
 
                        struct Data
                        {
                                MetaData                           meta_data;
                                std::string                        category;
                                std::string                        name;
                                std::experimental::source_location location;
                                std::chrono::microseconds::rep     duration;
                                std::chrono::microseconds::rep     time_stamp;
                                std::thread::id                    thread_id;
                                pid_t                              process_id;
                                char                               phase;
 
                                Data(const char, const std::string&, const std::string&, const std::experimental::source_location&, zakero::Profiler::MetaData = {}) noexcept;
                        };
 
                        struct Complete
                                : public zakero::Profiler::Data
                        {
                                bool was_active;
 
                                Complete(const std::string&, const std::string&, const std::experimental::source_location&, zakero::Profiler::MetaData = {}) noexcept;
                                ~Complete() noexcept;
                        };
 
                        struct Duration
                                : public zakero::Profiler::Data
                        {
                                bool was_active;
 
                                Duration(const std::string&, const std::string&, const std::experimental::source_location&, zakero::Profiler::MetaData = {}) noexcept;
                                ~Duration() noexcept;
                        };
 
                        struct Instant
                                : public zakero::Profiler::Data
                        {
                                Instant(const std::string&, const std::string&, const std::experimental::source_location&, zakero::Profiler::MetaData = {}) noexcept;
                        };
 
                        Profiler() noexcept;
                        ~Profiler() noexcept;
 
                        static std::error_code init(std::ostream&, zakero::Profiler::MetaData = {}) noexcept;
                        static std::error_code init(const std::filesystem::path, zakero::Profiler::MetaData = {}) noexcept;
 
                        static void activate() noexcept;
                        static void deactivate() noexcept;
 
                        static void report(const zakero::Profiler::Data&) noexcept;
 
                private:
                        std::mutex    mutex;
                        std::ostream* stream;
                        std::ofstream file_output;
                        bool          is_active;
        };
 
        // }}}
}
 
// {{{ Implementation
 
#ifdef ZAKERO_PROFILER_IMPLEMENTATION
 
// {{{ Macros
 
#define ZAKERO_PROFILER__ERROR_DATA \
        X(Error_None                , 0 , "No Error"                                       ) \
        X(Error_Stream_Already_Open , 1 , "The profiler is already using an output stream" ) \
        X(Error_No_Filename         , 2 , "No filename was provided"                       ) \
        X(Error_Cant_Open_Stream    , 3 , "Unable to open the output stream"               ) \
        X(Error_Bad_Stream          , 4 , "The stream is not in a good state"              ) \
 
#define ZAKERO_PROFILER__ERROR(err_) std::error_code(err_, ProfilerErrorCategory)
 
// {{{ Macros : Doxygen
 
#ifdef ZAKERO__DOXYGEN_DEFINE_DOCS
 
// Only used for generating Doxygen documentation
 
#define ZAKERO_PROFILER_IMPLEMENTATION
 
#define ZAKERO_PROFILER_ENABLE
 
#endif // ZAKERO__DOXYGEN_DEFINE_DOCS
 
// }}}
// }}}
 
namespace zakero
{
// {{{ Anonymous Namespace
 
namespace
{
        class ProfilerErrorCategory_
                : public std::error_category
        {
                public:
                        constexpr ProfilerErrorCategory_() noexcept
                        {
                        }
 
                        const char* name() const noexcept override
                        {
                                return "zakero.Profiler";
                        }
 
                        std::string message(int condition) const override
                        {
                                switch(condition)
                                {
#define X(name_, val_, mesg_) \
                                        case val_: return mesg_;
                                        ZAKERO_PROFILER__ERROR_DATA
#undef X
                                }
 
                                return "Unknown error condition";
                        }
        } ProfilerErrorCategory;
 
#define X(name_, val_, mesg_) \
        static constexpr int name_ = val_;
        ZAKERO_PROFILER__ERROR_DATA
#undef X
 
        zakero::Profiler zakero_profiler;
 
        // std::format performance testing
        //uint64_t count = 0;
        //uint64_t total = 0;
}
 
// }}}
// {{{ Documentation
 
// }}}
 
Profiler::Profiler() noexcept
        : mutex()
        , stream(nullptr)
        , file_output()
        , is_active(false)
{
}
 
 
Profiler::~Profiler() noexcept
{
        std::lock_guard<std::mutex> lock(zakero_profiler.mutex);
 
        if(stream != nullptr)
        {
                (*stream) << "]}" << std::endl;
 
                if(file_output.is_open())
                {
                        file_output.close();
                }
        }
 
        // std::format performance testing
        //std::cout << "Avg: " << (total / count) << "\n";
}
 
 
std::error_code zakero::Profiler::init(const std::filesystem::path path      
        , zakero::Profiler::MetaData                               meta_data 
        ) noexcept
{
        if(zakero_profiler.stream != nullptr)
        {
                return ZAKERO_PROFILER__ERROR(Error_Stream_Already_Open);
        }
 
        if(path.has_filename() == false)
        {
                return ZAKERO_PROFILER__ERROR(Error_No_Filename);
        }
 
        zakero_profiler.file_output.open(path);
 
        if(zakero_profiler.file_output.is_open() == false)
        {
                return ZAKERO_PROFILER__ERROR(Error_Cant_Open_Stream);
        }
 
        std::error_code error;
 
        error = init(zakero_profiler.file_output, meta_data);
 
        return error;
}
 
 
std::error_code zakero::Profiler::init(std::ostream& output_stream 
        , zakero::Profiler::MetaData                 meta_data     
        ) noexcept
{
        std::lock_guard<std::mutex> lock(zakero_profiler.mutex);
 
        if(zakero_profiler.stream != nullptr)
        {
                return ZAKERO_PROFILER__ERROR(Error_Stream_Already_Open);
        }
 
        if(output_stream.good() == false)
        {
                return ZAKERO_PROFILER__ERROR(Error_Bad_Stream);
        }
 
        zakero_profiler.stream = &output_stream;
        activate();
 
        if(meta_data.contains("date") == false)
        {
                std::time_t time = std::chrono::system_clock::to_time_t(
                        std::chrono::system_clock::now()
                        );
 
                char buf[128];
                std::strftime(buf, sizeof(buf), "%F %T", std::localtime(&time));
 
                meta_data["date"] = buf;
        }
 
        if(meta_data.contains("traceEvents"))
        {
                meta_data.erase("traceEvents");
        }
 
        meta_data["displayTimeUnit"] = "ms";
 
        (*zakero_profiler.stream) << "{";
 
        for(const auto& iter : meta_data)
        {
                (*zakero_profiler.stream) << "\"" << iter.first << "\":\"" << iter.second << "\",";
        }
 
        (*zakero_profiler.stream) << "\"traceEvents\":[{}\n";
 
        return ZAKERO_PROFILER__ERROR(Error_None);
}
 
 
void zakero::Profiler::activate() noexcept
{
        zakero_profiler.is_active = true;
}
 
 
void zakero::Profiler::deactivate() noexcept
{
        zakero_profiler.is_active = false;
}
 
 
void Profiler::report(const zakero::Profiler::Data& data 
        ) noexcept
{
        std::lock_guard<std::mutex> lock(zakero_profiler.mutex);
 
        // std::format performance testing
        //const auto t1  = std::chrono::steady_clock::now();
 
        (*zakero_profiler.stream)
                << ",{\"ph\":\""   << data.phase << "\""
                <<  ",\"ts\":"     << data.time_stamp
                <<  ",\"dur\":"    << data.duration
                <<  ",\"pid\":"    << data.process_id
                <<  ",\"tid\":"    << data.thread_id
                <<  ",\"cat\":\""  << data.category << "\""
                <<  ",\"name\":\"" << data.name << "\""
                <<  ",\"args\":"
                        << "{\"file_name\":\""     << data.location.file_name() << "\""
                        << ",\"function_name\":\"" << data.location.function_name() << "\""
                ;
        for(const auto& iter : data.meta_data)
        {
                (*zakero_profiler.stream)
                        << ",\"" << iter.first << "\":\"" << iter.second << "\""
                        ;
        }
 
        (*zakero_profiler.stream) << "}}\n";
 
        /* C++20 std::format ready
        (*zakero_profiler.stream) << std::format(
                ",{{\"ph\":\"{}\""
                ",\"ts\":{}"
                ",\"cat\":\"{}\""
                ",\"name\":\"{}\""
                ",\"pid\":{}"
                ",\"tid\":{}"
                ",\"args\": {{\"file_name\":\"{}\",\"function_name\":\"{}\"}}"
                "}}\n"
                , data.phase
                , nano
                , data.category
                , data.name
                , data.process_id
                , data.thread_id
                , data.location.file_name()
                , data.location.function_name()
                );
 
        // std::format performance testing
        const auto t2  = std::chrono::steady_clock::now();
        const auto delta  = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
        std::cout << (uint64_t)delta << "\n";
        total += delta;
        count++;
        */
}
 
 
Profiler::Data::Data(const char                     phase     
        , const std::string&                        category  
        , const std::string&                        name      
        , const std::experimental::source_location& location  
        , zakero::Profiler::MetaData                meta_data 
        ) noexcept
        : meta_data(meta_data)
        , category(category)
        , name(name)
        , location(location)
        , duration(0)
        , time_stamp(ZAKERO_STEADY_TIME_NOW(microseconds))
        , thread_id(std::this_thread::get_id())
        , process_id(ZAKERO_PID)
        , phase(phase)
{
}
 
 
Profiler::Complete::Complete(const std::string&     category  
        , const std::string&                        name      
        , const std::experimental::source_location& location  
        , zakero::Profiler::MetaData                meta_data 
        ) noexcept
        : zakero::Profiler::Data('X', category, name, location, meta_data)
        , was_active(zakero_profiler.is_active)
{
}
 
 
Profiler::Complete::~Complete() noexcept
{
        if(was_active || zakero_profiler.is_active)
        {
                duration = ZAKERO_STEADY_TIME_NOW(microseconds) - time_stamp;
                zakero::Profiler::report(*this);
        }
}
 
 
Profiler::Duration::Duration(const std::string&     category  
        , const std::string&                        name      
        , const std::experimental::source_location& location  
        , zakero::Profiler::MetaData                meta_data 
        ) noexcept
        : zakero::Profiler::Data('B', category, name, location, meta_data)
        , was_active(zakero_profiler.is_active)
{
}
 
 
Profiler::Duration::~Duration() noexcept
{
        if(was_active || zakero_profiler.is_active)
        {
                zakero::Profiler::report(*this);
 
                phase = 'E';
                time_stamp = ZAKERO_STEADY_TIME_NOW(microseconds);
                zakero::Profiler::report(*this);
        }
}
 
 
Profiler::Instant::Instant(const std::string&       category  
        , const std::string&                        name      
        , const std::experimental::source_location& location  
        , zakero::Profiler::MetaData                meta_data 
        ) noexcept
        : zakero::Profiler::Data('i', category, name, location, meta_data)
{
        if(zakero_profiler.is_active)
        {
                zakero::Profiler::report(*this);
        }
}
 
} // zakero
 
#endif // ZAKERO_PROFILER_IMPLEMENTATION
 
// }}}
 
#endif // zakero_Profiler_h