performance_monitor.h

#pragma once
 
#include <deque>
#include <vector>
#include <cgv/utils/stopwatch.h>
#include <cgv/media/axis_aligned_box.h>
#include <cgv/media/color.h>
 
#include "lib_begin.h"
 
namespace cgv {
        namespace render {
 
enum PerformanceMonitoringBar {
        PMB_MIN,
        PMB_MAX,
        PMB_CUR,
        PMB_AVG
};
 
struct CGV_API performance_measurement
{
        double time;
        int task_id;
        bool start;
        performance_measurement(double _time, int _task_id, bool _start) : time(_time), task_id(_task_id), start(_start) {}
};
 
struct CGV_API performance_task
{
        std::string name;
        cgv::media::color<float> col;
        performance_task(std::string _name, cgv::media::color<float> _col) : name(_name), col(_col) {}
};
 
class CGV_API performance_monitor
{
public:
        typedef cgv::math::fvec<int,2> Pos;
        typedef cgv::media::axis_aligned_box<int,2> Rec;
        typedef cgv::media::color<float> Col;
        typedef std::vector<performance_measurement> frame_data;
private:
        bool frame_finished;
        unsigned frame_id;
protected:
        bool enabled;
        double fps_alpha;
        double fps;
        Rec placement;
        int nr_display_cycles;
        int bar_line_width;
        Col plot_color;
        std::string file_name;
        std::vector<performance_task> tasks;
        std::deque<frame_data> data;
        std::vector<PerformanceMonitoringBar> bar_config;
 
        cgv::utils::stopwatch watch;
        float time_scale;
        std::vector<Pos> positions;
        std::vector<Col> colors;
 
        void compute_colors(const frame_data& fdata);
        void compute_positions(int x, int y, int dx, int dy, const frame_data& fdata);
        frame_data& current_frame();
        void add_measurement(const performance_measurement& pm);
 
public:
        performance_monitor();
        void set_file_name(const std::string& _file_name);
        const std::string& get_file_name() const { return file_name; }
        void enable();
        void disable();
        bool is_enabled() const { return enabled; }
 
        void init_tasks();
        int add_task(const std::string& name, const Col& col);
        unsigned get_buffer_size() const { return placement.get_extent()(0); }
        void start_frame();
        unsigned get_frame_id() const { return frame_id; }
        void start_task(int task_id);
        void finish_task(int task_id);
        void finish_frame();
 
        void clear_bar();
        void add_bar_item(PerformanceMonitoringBar item);
        void set_placement(const Rec& rectangle);
        Rec get_placement() const { return placement; }
        void set_nr_display_cycles(unsigned _nr_cycles);
        unsigned get_nr_display_cycles() const { return nr_display_cycles; }
};
 
        }
}
 
#include <cgv/config/lib_end.h>