Profiler.hpp

Go to the documentation of this file.

//==============================================================================
//
//                       Seismo Virtual Laboratory
//             Module for Serial and Parallel Analysis of seismic 
//         wave propagation and soil-structure interaction simulation
//         Copyright (C) 2018-2021, The California Institute of Technology
//                         All Rights Reserved.
//
// Commercial use of this program without express permission of the California
// Institute of Technology, is strictly  prohibited. See  file "COPYRIGHT"  in
// main  directory  for  information on  usage  and  redistribution, and for a
// DISCLAIMER OF ALL WARRANTIES.
//
//==============================================================================
//
// Written by:
//   Danilo S. Kusanovic (dkusanov@caltech.edu)
//   Elnaz E. Seylabi    (elnaze@unr.edu)
//
// Supervised by:
//   Domniki M. Asimaki  (domniki@caltech.edu)
//
// References : 
//   [1] https://gist.github.com/TheCherno/Instrumentor.h
//
// Description:
// This file contains the "Profiler object" declarations to compute how long it 
// takes for a program to be executed, and sequentially measures the time of 
// Execution of each function.
//------------------------------------------------------------------------------

#ifndef _PROFILER_HHP_
#define _PROFILER_HHP_

#include <omp.h>
#include <string>
#include <thread>
#include <chrono>
#include <algorithm>
#include <fstream>
#include <sstream>

#include "Definitions.hpp"

struct ProfileResult{
    std::string Name;

    long long Start;

    long long End;

    int ThreadID;
};

struct InstrumentationSession{
    std::string Name;
};


class Profiler{

    public:
        Profiler() : m_CurrentSession(nullptr), m_ProfileCount(0){
        }

        void BeginSession(const std::string& name){
            std::stringstream filename;
            filename << filePath << "/Profiler." << rank << ".json";
            m_OutputStream.open(filename.str().c_str());
            WriteHeader();
            m_CurrentSession = new InstrumentationSession{ name };
        }

        void EndSession(){
            WriteFooter();
            m_OutputStream.close();
            delete m_CurrentSession;
            m_CurrentSession = nullptr;
            m_ProfileCount = 0;
        }

        void WriteProfile(const ProfileResult& result){
            if (m_ProfileCount++ > 0)
                m_OutputStream << ",";

            std::string name = result.Name;
            std::replace(name.begin(), name.end(), '"', '\'');

            //The JSON file format to be opened with Google-Chrome 
            m_OutputStream << "{";
            m_OutputStream << "\"cat\":\"function\",";
            m_OutputStream << "\"dur\":" << (result.End - result.Start) << ',';
            m_OutputStream << "\"name\":\"" << name << "\",";
            m_OutputStream << "\"ph\":\"X\",";
            m_OutputStream << "\"pid\":\"" << result.ThreadID << "\",";
            m_OutputStream << "\"tid\":"   << rank << ",";
            m_OutputStream << "\"ts\":"    << result.Start;
            m_OutputStream << "}";

            //Flush in case the program abruptly stops.
            m_OutputStream.flush();
        }

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

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

        static Profiler& Get(){
            static Profiler instance;
            return instance;
        }

    private:
        InstrumentationSession* m_CurrentSession;

        std::ofstream m_OutputStream;

        int m_ProfileCount;
};

class Timer{

    public:
        Timer(const char* name) : m_Name(name), m_Stopped(false){
            std::this_thread::sleep_for (std::chrono::microseconds(3));
            m_StartTimepoint = std::chrono::high_resolution_clock::now();
        }

        ~Timer(){
            if (!m_Stopped)
                Stop();
        }

        void Stop(){
            auto endTimepoint = std::chrono::high_resolution_clock::now();

            long long start = std::chrono::time_point_cast<std::chrono::microseconds>(m_StartTimepoint).time_since_epoch().count();
            long long end = std::chrono::time_point_cast<std::chrono::microseconds>(endTimepoint).time_since_epoch().count();
            int threadID = omp_get_num_threads();
            Profiler::Get().WriteProfile({ m_Name, start, end, threadID });

            m_Stopped = true;
        }

    private:
        const char* m_Name;

        std::chrono::time_point<std::chrono::high_resolution_clock> m_StartTimepoint;

        bool m_Stopped;
};

#if PROFILING
#define PROFILE_SCOPE(name) Timer timer(name)
#define PROFILE_FUNCTION() PROFILE_SCOPE( __PRETTY_FUNCTION__ )
#else
#define PROFILE_FUNCTION()
#endif

#endif