profiler.hpp

//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2004-2015 SuperTuxKart-Team
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 3
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef PROFILER_HPP
#define PROFILER_HPP
 
#include "utils/synchronised.hpp"
 
#include <assert.h>
#include <atomic>
#include <iostream>
#include <list>
#include <map>
#include <ostream>
#include <stack>
#include <streambuf>
#include <string>
#include <vector>
 
#include <vector2d.h>
#include <SColor.h>
using namespace irr;
 
enum QueryPerf
{
    Q_SHADOWS_CASCADE0,
    Q_SHADOWS_CASCADE1,
    Q_SHADOWS_CASCADE2,
    Q_SHADOWS_CASCADE3,
    Q_SOLID_PASS,
    Q_ENVMAP,
    Q_SUN,
    Q_POINTLIGHTS,
    Q_SSAO,
    Q_LIGHTSCATTER,
    Q_GLOW,
    Q_COMBINE_DIFFUSE_COLOR,
    Q_SKYBOX,
    Q_TRANSPARENT,
    Q_PARTICLES,
    Q_DOF,
    Q_GODRAYS,
    Q_BLOOM,
    Q_TONEMAP,
    Q_MOTIONBLUR,
    Q_LIGHTNING,
    Q_MLAA,
    Q_GUI,
    Q_LAST
};
 
class Profiler;
extern Profiler profiler;
 
double getTimeMilliseconds();
 
#define MAX_ANALYZED_FPS  1000
#define ENABLE_PROFILER
 
#ifdef ENABLE_PROFILER
    #define PROFILER_PUSH_CPU_MARKER(name, r, g, b) \
        profiler.pushCPUMarker(name, video::SColor(0xFF, r, g, b))
 
    #define PROFILER_POP_CPU_MARKER()  \
        profiler.popCPUMarker()
 
    #define PROFILER_SYNC_FRAME()   \
        profiler.synchronizeFrame()
 
    #define PROFILER_DRAW() \
        profiler.draw()
#else
    #define PROFILER_PUSH_CPU_MARKER(name, r, g, b)
    #define PROFILER_POP_CPU_MARKER()
    #define PROFILER_SYNC_FRAME()
    #define PROFILER_DRAW()
#endif
 
using namespace irr;
 
// ============================================================================
class Profiler
{
private:
    // ------------------------------------------------------------------------
    class Marker
    {
    private:
        double  m_start;
 
        double  m_duration;
        size_t  m_layer;
    public:
        // --------------------------------------------------------------------
        Marker() { m_start = 0; m_duration = 0; m_layer = 0; }
 
        // --------------------------------------------------------------------
        Marker(double start, size_t layer=0)
           : m_start(start), m_duration(0), m_layer(layer)
        {
        }
        // --------------------------------------------------------------------
        Marker(const Marker& ref)
            : m_start(ref.m_start), m_duration(ref.m_duration), 
              m_layer(ref.m_layer)
        {
        }
        // --------------------------------------------------------------------
        double getStart() const { return m_start;  }
        // --------------------------------------------------------------------
        double getEnd() const { return m_start+m_duration; }
        // --------------------------------------------------------------------
        double getDuration() const { return m_duration;  }
        // --------------------------------------------------------------------
        size_t getLayer() const { return m_layer;  }
        // --------------------------------------------------------------------
        void clear() { m_duration = 0; }
        // --------------------------------------------------------------------
        void setStart(double start, size_t layer = 0)
        {
            m_start = start; m_layer = layer;
        }   // setStart
        // --------------------------------------------------------------------
        void setEnd(double end)
        {
            m_duration += (end - m_start);
        }   // setEnd
 
    };   // class Marker
 
    // ========================================================================
    class EventData
    {
    private:
        video::SColor m_colour;
 
        std::vector<Marker> m_all_markers;
 
    public:
        EventData() {}
        EventData(video::SColor colour, int max_size)
        {
            m_all_markers.resize(max_size);
            m_colour = colour;
        }   // EventData
        // --------------------------------------------------------------------
        void setStart(size_t frame, double start, int layer)
        {
            assert(frame < m_all_markers.capacity());
            m_all_markers[frame].setStart(start, layer);
        }   // setStart
        // --------------------------------------------------------------------
        void setEnd(size_t frame, double end)
        {
            assert(frame < m_all_markers.capacity());
            m_all_markers[frame].setEnd(end);
        }   // setEnd
        // --------------------------------------------------------------------
        const Marker& getMarker(int n) const { return m_all_markers[n]; }
        Marker& getMarker(int n) { return m_all_markers[n]; }
        // --------------------------------------------------------------------
        video::SColor getColour() const { return m_colour;  }
        // --------------------------------------------------------------------
    };   // EventData
 
    // ========================================================================
    typedef std::map<std::string, EventData> AllEventData;
    // ========================================================================
    struct ThreadData
    {
        std::vector< std::string > m_event_stack;
 
        std::vector<std::string> m_ordered_headings;
 
        AllEventData m_all_event_data;
    };   // class ThreadData
 
    // ========================================================================
 
    std::vector< ThreadData> m_all_threads_data;
 
    std::vector<int> m_gpu_times;
 
    std::atomic<int> m_threads_used;
 
    int m_current_frame;
 
    Synchronised<bool> m_lock;
 
    std::vector<int> m_frame_times;
 
    int m_total_frametime;
 
    int m_total_frames;
 
    int m_slow_frames[MAX_ANALYZED_FPS];
 
    int m_time_spent_in_slow_frames[MAX_ANALYZED_FPS];
 
    int m_time_waited_in_slow_frames[MAX_ANALYZED_FPS];
 
    int m_fps_metrics_high;
 
    int m_fps_metrics_mid;
 
    int m_fps_metrics_low;
 
    bool m_has_wrapped_around;
 
    bool m_drawing;
 
    int m_max_frames;
 
    double m_time_last_sync;
 
    double m_time_between_sync;
 
    std::vector<std::string> m_all_event_names;
 
    // Handling freeze/unfreeze by clicking on the display
    enum FreezeState
    {
        UNFROZEN,
        WAITING_FOR_FREEZE,
        FROZEN,
        WAITING_FOR_UNFREEZE,
    };
 
    FreezeState     m_freeze_state;
 
private:
    int  getThreadID();
    void drawBackground();
 
public:
             Profiler();
    virtual ~Profiler();
    void     init();
    void     reset();
    void     pushCPUMarker(const char* name="N/A",
                           const video::SColor& color=video::SColor());
    void     popCPUMarker();
    void     activate();
    void     desactivate();
    void     synchronizeFrame();
    void     draw();
    void     onClick(const core::vector2di& mouse_pos);
    void     computeStableFPS();
    void     startBenchmark();
    void     writeToFile();
 
    // ------------------------------------------------------------------------
    bool isFrozen() const { return m_freeze_state == FROZEN; }
    // ------------------------------------------------------------------------
    void setDrawing(bool drawing) { m_drawing = drawing; }
 
    int getTotalFrametime() { return m_total_frametime;  }
    int getTotalFrames()    { return m_total_frames;     }
    int getFPSMetricsHigh() { return m_fps_metrics_high; }
    int getFPSMetricsMid()  { return m_fps_metrics_mid;  }
    int getFPSMetricsLow()  { return m_fps_metrics_low;  }
};
#endif // PROFILER_HPP