Vesper::Instrumentor Class Reference

#include <Instrumentor.h>

Public Member Functions
	Instrumentor ()
void	BeginSession (const std::string &name, const std::string &filepath="results.json")
void	EndSession ()
void	WriteProfile (const ProfileResult &result)
void	WriteHeader ()
void	WriteFooter ()
void	InternalEndSession ()

Static Public Member Functions
static Instrumentor &	Get ()

Private Attributes
InstrumentationSession *	m_CurrentSession
std::ofstream	m_OutputStream
std::mutex	m_Mutex

Constructor & Destructor Documentation

Instrumentor()

Vesper::Instrumentor::Instrumentor ( )

inline

            : m_CurrentSession(nullptr)
        {
        }

Member Function Documentation

BeginSession()

void Vesper::Instrumentor::BeginSession ( const std::string & name, const std::string & filepath = "results.json" )

inline

        {
            std::lock_guard lock(m_Mutex);
            if (m_CurrentSession) {
                // If there is already a current session, end it and start new one
                if (Log::GetCoreLogger()) 
                {
                    VZ_CORE_ERROR("Instrumentor::BeginSession('{0}') when session '{1}' already open.", name, m_CurrentSession->Name);
                }
                InternalEndSession();
            }
            m_OutputStream.open(filepath);
            if (m_OutputStream.is_open()) {
                m_CurrentSession = new InstrumentationSession{ name };
                WriteHeader();
            }
            else {
                if (Log::GetCoreLogger()) 
                {
                    VZ_CORE_ERROR("Instrumentor could not open results file '{0}'.", filepath);
                }
            }
            WriteHeader();
            m_CurrentSession = new InstrumentationSession{ name };
        }

EndSession()

void Vesper::Instrumentor::EndSession ( )

inline

        {
            std::lock_guard lock(m_Mutex);
            InternalEndSession();
        }

Get()

Instrumentor & Vesper::Instrumentor::Get ( )

inlinestatic

        {
            static Instrumentor instance;
            return instance;
        }

InternalEndSession()

void Vesper::Instrumentor::InternalEndSession ( )

inline

        {
            if (m_CurrentSession)
            {
                WriteFooter();
                m_OutputStream.close();
                delete m_CurrentSession;
                m_CurrentSession = nullptr;
            }
        }

WriteFooter()

void Vesper::Instrumentor::WriteFooter ( )

inline

        {
            m_OutputStream << "]}";
            m_OutputStream.flush();
        }

WriteHeader()

void Vesper::Instrumentor::WriteHeader ( )

inline

        {
            m_OutputStream << "{\"otherData\": {},\"traceEvents\":[";
            m_OutputStream.flush();
        }

WriteProfile()

void Vesper::Instrumentor::WriteProfile ( const ProfileResult & result )

inline

        {
            m_OutputStream << ",";
 
            std::string name = result.Name;
            std::replace(name.begin(), name.end(), '"', '\'');
 
            m_OutputStream << "{";
            m_OutputStream << "\"cat\":\"function\",";
            m_OutputStream << "\"dur\":" << (result.End - result.Start) << ',';
            m_OutputStream << "\"name\":\"" << name << "\",";
            m_OutputStream << "\"ph\":\"X\",";
            m_OutputStream << "\"pid\":0,";
            m_OutputStream << "\"tid\":" << result.ThreadID << ",";
            m_OutputStream << "\"ts\":" << result.Start;
            m_OutputStream << "}";
 
            std::lock_guard lock(m_Mutex);
            if (m_CurrentSession)
            {
                //m_OutputStream << json.str();
                m_OutputStream.flush();
            }
        }

Member Data Documentation

m_CurrentSession

InstrumentationSession* Vesper::Instrumentor::m_CurrentSession

private

m_Mutex

std::mutex Vesper::Instrumentor::m_Mutex

private

m_OutputStream

std::ofstream Vesper::Instrumentor::m_OutputStream

private

---

The documentation for this class was generated from the following file:

• Vesper/src/Vesper/Debug/Instrumentor.h