Zakero_Profiler.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2010-2019 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 <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_) \
        zakero::Profiler::init(output_, {});
 
#define ZAKERO_PROFILER_INIT_METADATA(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_UNIQUE(name_) ZAKERO_CONCAT(name_, __LINE__)
 
#define ZAKERO_PROFILER_DURATION(category_, name_)                                   \
        zakero::Profiler::Duration ZAKERO_PROFILER_UNIQUE(zakero_profiler_duration_) \
        ( category_                                                                  \
        , name_                                                                      \
        , std::experimental::source_location::current()                              \
        );                                                                           \
 
 
#define ZAKERO_PROFILER_INSTANT(category_, name_)                                  \
        {                                                                          \
        zakero::Profiler::Instant ZAKERO_PROFILER_UNIQUE(zakero_profiler_instant_) \
        ( category_                                                                \
        , name_                                                                    \
        , std::experimental::source_location::current()                            \
        );                                                                         \
        }                                                                          \
 
#else
 
#define ZAKERO_PROFILER_INIT(output_)
#define ZAKERO_PROFILER_INIT_METADATA(output_, meta_data_)
#define ZAKERO_PROFILER_ACTIVATE
#define ZAKERO_PROFILER_DEACTIVATE
#define ZAKERO_PROFILER_DURATION(category_, name_)
#define ZAKERO_PROFILER_INSTANT(category_, name_)
 
#endif
 
// }}}
 
namespace zakero
{
        // {{{ Declaration
 
        class Profiler
        {
                public:
                        using MetaData = std::map<std::string, std::string>;
 
                        struct Data
                        {
                                std::string                        category;
                                std::string                        name;
                                std::experimental::source_location location;
                                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&) noexcept;
                        };
 
                        struct Duration
                                : public zakero::Profiler::Data
                        {
                                bool was_active;
 
                                Duration(const std::string&, const std::string&, const std::experimental::source_location&) noexcept;
                                ~Duration() noexcept;
                        };
 
                        struct Instant
                                : public zakero::Profiler::Data
                        {
                                Instant(const std::string&, const std::string&, const std::experimental::source_location&) noexcept;
                        };
 
                        Profiler() noexcept;
                        ~Profiler() noexcept;
 
                        static void init(std::ostream&, zakero::Profiler::MetaData) noexcept;
                        static void init(std::string, 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
// {{{ 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
 
// }}}
 
#ifdef __linux__
#include <sys/types.h>
#include <unistd.h>
#define ZAKERO_PROFILER__PID getpid()
#else
#define ZAKERO_PROFILER__PID -1
#endif
 
// }}}
 
namespace zakero
{
// {{{ Anonymous Namespace
 
namespace
{
        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";
}
 
 
void zakero::Profiler::init(std::string file_name 
        , zakero::Profiler::MetaData    meta_data 
        ) noexcept
{
        if(zakero_profiler.stream != nullptr)
        {
                return;
        }
 
        zakero_profiler.file_output.open(file_name);
 
        init(zakero_profiler.file_output, meta_data);
}
 
 
void 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.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";
}
 
 
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
                <<  ",\"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() << "\""
                        << "}"
                << "}\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 
        ) noexcept
        : category(category)
        , name(name)
        , location(location)
        , time_stamp(ZAKERO_STEADY_TIME_NOW(microseconds))
        , thread_id(std::this_thread::get_id())
        , process_id(ZAKERO_PROFILER__PID)
        , phase(phase)
{
}
 
 
Profiler::Duration::Duration(const std::string&     category 
        , const std::string&                        name     
        , const std::experimental::source_location& location 
        ) noexcept
        : zakero::Profiler::Data('B', category, name, location)
        , 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 
        ) noexcept
        : zakero::Profiler::Data('I', category, name, location)
{
        if(zakero_profiler.is_active)
        {
                zakero::Profiler::report(*this);
        }
}
 
} // zakero
 
#endif // ZAKERO_PROFILER_IMPLEMENTATION
 
// }}}
 
#endif // zakero_Profiler_h