diff options
Diffstat (limited to 'core/client.cpp')
| -rw-r--r-- | core/client.cpp | 686 |
1 files changed, 545 insertions, 141 deletions
diff --git a/core/client.cpp b/core/client.cpp index 1c63540..a5cf6d6 100644 --- a/core/client.cpp +++ b/core/client.cpp @@ -9,8 +9,8 @@ #include <threads.h> #include <algorithm> +#include <array> #include <map> -#include <string> #include <vector> #include "logger.c" @@ -20,10 +20,18 @@ // ---------------------------------------------------------------------------- #define COLOR_BLACK ImVec4(0.f, 0.f, 0.f, 1.f) #define FONT_SIZE 12.f +#define FONT_SOURCE "/usr/share/fonts/droid/DroidSansMono.ttf" #define GLSL_VERSION "#version 130" -#define PLOT_MAX_COLS 8 #define PLOT_MIN_COLS 1 -#define PLOT_SCROLL_OFFSET 28.f +#define PLOT_MAX_COLS 8 +#define PLOT_MIN_HEIGHT 100.f +#define PLOT_MAX_HEIGHT 800.f +#define PLOT_HEIGHT_INTERVAL 50.f +#define PLOT_SCROLL_MARGIN 28.f +#define HM_SCALE_POW_MIN -1.f +#define HM_SCALE_POW_MAX 64.f +#define HM_SCALE_POW_INTERVAL 1.f +#define HM_COLORSCALE_WIDTH 80.f #define IMGUI_WINDOW_FLAGS ( \ ImGuiWindowFlags_NoBackground | \ @@ -41,10 +49,10 @@ #define DEFVAL_X_LOW 0l #define DEFVAL_X_HIGH INT64_MAX #define DEFVAL_HM_LEFT 0l -#define DEFVAL_HM_PIXEL_COUNT 0x400l +#define DEFVAL_HM_PIXEL_COUNT 0x400l // must equal HM_PIXEL_COUNT in server.c // ---------------------------------------------------------------------------- -// Declarations +// State declaration // ---------------------------------------------------------------------------- enum Status { STATUS_STOPPED, @@ -52,37 +60,115 @@ enum Status { STATUS_STOPPING, }; -template <class T> struct Trace : public std::vector<T> { +// ---------------------------------------------------------------------------- +// Trace declarations +// ---------------------------------------------------------------------------- +template <class T> +class Trace { +public: Trace(); + virtual ~Trace(); + virtual size_t start_offset() const; + virtual void trim(); +#if !defined(NDEBUG) + virtual void validate() const; +#endif + + size_t size() const; + T &back(); + T &operator[](size_t n); T *start(); - void trim(); + T max() const; + T operator[](size_t n) const; + void clear(); + void push_back(T); + +protected: + void trim_spec(int mult = 1); + + std::vector<T> m_data; + size_t m_max_index; +}; + +template <class T> +class TraceNamed : public Trace<T> { +public: + TraceNamed(const char *name, const char *name_fmt); + + const char *m_name; + const char *m_name_fmt; +}; + +template <class T> +class TraceHeatmap : public TraceNamed<T> { +public: + TraceHeatmap(const char *name, const char *name_fmt); + size_t start_offset() const; + void trim(); #if !defined(NDEBUG) - T &operator[](size_t n); + void validate() const; #endif }; -template <class T> struct TraceNamed : public Trace<T> { - std::string m_name; - std::string m_name_fmt; - TraceNamed(std::string name, std::string name_fmt); -}; +// ---------------------------------------------------------------------------- +// Plot declarations +// ---------------------------------------------------------------------------- +typedef int (*AxisFormatter)(double value, char *buff, int size, void *data); -struct Plot { - std::string m_name; - std::string m_section; - std::vector<std::string> m_trace_keys; - Plot(std::string name, std::string section, std::vector<std::string> trace_keys); +class Plot { +public: + Plot(const char *name, const char *section); virtual ~Plot(); - virtual void render(); + void render(ImVec2 frame_size); + + const char *m_name; + const char *m_section; + +private: + static int hex_axis_formatter(double value, char *buff, int size, void *data); + virtual AxisFormatter x_axis_formatter(); + virtual AxisFormatter y_axis_formatter(); + virtual float frame_right_margin(); + virtual int plot_flags(); + virtual void render_internal() = 0; + virtual void render_post(ImVec2 frame_size); }; -struct PlotStacked : public Plot { +class PlotLines : public Plot { +public: + PlotLines(const char *name, const char *section, std::vector<const char *> trace_keys); + std::vector<const char *> m_trace_keys; + +private: + void render_internal(); +}; + +class PlotStacked : public Plot { +public: + PlotStacked(const char *name, const char *section, std::vector<const char *> trace_keys); + std::vector<ImS64> m_totals; std::vector<double> m_old_trace; std::vector<double> m_new_trace; - PlotStacked(std::string name, std::string section, std::vector<std::string> trace_keys); - void render(); + std::vector<const char *> m_trace_keys; + +private: + AxisFormatter y_axis_formatter(); + static int percent_axis_formatter(double value, char *buff, int size, void *data); + void render_internal(); +}; + +class PlotHeatmap : public Plot { +public: + PlotHeatmap(const char *name, const char *section, const char *trace_key); + const char *m_trace_key; + +private: + float frame_right_margin(); + int plot_flags(); + void render_internal(); + void render_post(ImVec2 frame_size); }; // ---------------------------------------------------------------------------- @@ -90,7 +176,7 @@ struct PlotStacked : public Plot { // ---------------------------------------------------------------------------- #include "arch_plots.cpp" -std::vector<TraceNamed<ImS64>> g_core_traces = { +std::array g_core_traces = std::to_array<TraceNamed<ImS64>>({ {"rowid", "rowid"}, {"step", "step"}, #define FOR_CORE(i) \ @@ -107,9 +193,18 @@ std::vector<TraceNamed<ImS64>> g_core_traces = { {"edea_" #i, "edea_" #i}, FOR_CORES #undef FOR_CORE -}; +}); -std::vector<Plot> g_core_plots = { +std::array g_core_traces_heatmaps = std::to_array<TraceHeatmap<ImS64>>({ +#define FOR_CORE(i) \ + {"aev_" #i, "aev_" #i}, \ + {"eev_" #i, "eev_" #i}, \ + {"bev_" #i, "bev_" #i}, + FOR_CORES +#undef FOR_CORE +}); + +std::array g_core_plots = std::to_array<PlotLines>({ {"cycl", "general", { #define FOR_CORE(i) "cycl_" #i, FOR_CORES @@ -140,7 +235,38 @@ std::vector<Plot> g_core_plots = { FOR_CORES #undef FOR_CORE }}, -}; +}); + +std::array g_core_plots_heatmaps = std::to_array<PlotHeatmap>({ +#define FOR_CORE(i) \ + {"aev_" #i, "heatmaps", "aev_" #i}, + FOR_CORES +#undef FOR_CORE +#define FOR_CORE(i) \ + {"eev_" #i, "heatmaps", "eev_" #i}, + FOR_CORES +#undef FOR_CORE +#define FOR_CORE(i) \ + {"bev_" #i, "heatmaps", "bev_" #i}, + FOR_CORES +#undef FOR_CORE +}); + +// ---------------------------------------------------------------------------- +// Heatmap colormap +// ---------------------------------------------------------------------------- +std::array g_hm_colormap_cols = std::to_array<ImVec4>({ + {0.000f, 0.000f, 0.016f, 1.f}, + {0.106f, 0.047f, 0.255f, 1.f}, + {0.290f, 0.047f, 0.420f, 1.f}, + {0.471f, 0.110f, 0.427f, 1.f}, + {0.647f, 0.173f, 0.376f, 1.f}, + {0.812f, 0.267f, 0.275f, 1.f}, + {0.929f, 0.412f, 0.145f, 1.f}, + {0.984f, 0.608f, 0.024f, 1.f}, + {0.969f, 0.820f, 0.239f, 1.f}, + {0.988f, 1.000f, 0.643f, 1.f}, +}); // ---------------------------------------------------------------------------- // Globals @@ -151,13 +277,13 @@ ImGuiStyle *g_imgui_style; ImPlotStyle *g_implot_style; // Data -std::vector<std::string> g_x_axes = { +std::array g_x_axes = std::to_array<const char *>({ "rowid", "step", #define FOR_CORE(i) "cycl_" #i, FOR_CORES #undef FOR_CORE -}; +}); int g_status; int g_x_axis = DEFVAL_X_AXIS; @@ -188,12 +314,22 @@ std::vector<float> g_plot_cells_top; std::vector<float> g_plot_cells_bottom; std::vector<bool> g_plots_covered; Plot *g_plot_selected; +Plot *g_plot_hovered; int g_plot_cols = 2; int g_plot_col_selected; int g_plot_row_selected; +float g_plot_height = 300.f; +float g_hm_scale_pow = HM_SCALE_POW_MIN; +ImPlotColormap g_hm_colormap; // Plots -std::map<std::string, TraceNamed<ImS64> *> g_trace_map; +struct CompStr { + bool operator()(const char *a, const char *b) const { + return strcmp(a, b) < 0; + } +}; + +std::map<const char *, TraceNamed<ImS64> *, CompStr> g_trace_map; std::vector<TraceNamed<ImS64> *> g_traces; std::vector<Plot *> g_plots; Trace<double> g_x_axis_normal; @@ -201,57 +337,205 @@ Trace<double> g_x_axis_normal; // ---------------------------------------------------------------------------- // Trace definitions // ---------------------------------------------------------------------------- -template <class T> Trace<T>::Trace() : std::vector<T>() {} +template <class T> +Trace<T>::Trace() : m_data({}), m_max_index(0) {} + +template <class T> +Trace<T>::~Trace() {} + +template <class T> +size_t Trace<T>::start_offset() const { + return g_trace_offset; +} + +template <class T> +void Trace<T>::trim() { + trim_spec(1); +} -template <class T> T *Trace<T>::start() { - return this->size() ? &this->operator[](g_trace_offset) : nullptr; +#if !defined(NDEBUG) +template <class T> +void Trace<T>::validate() const { + assert(size() == g_traces[0]->size()); } +#endif -template <class T> void Trace<T>::trim() { - assert((int64_t)this->size() >= g_entries * 2); - this->erase(this->begin(), this->end() - g_entries); +template <class T> +size_t Trace<T>::size() const { + return m_data.size(); } +template <class T> +T &Trace<T>::back() { + return m_data.back(); +} + +template <class T> +T &Trace<T>::operator[](size_t n) { #if !defined(NDEBUG) -template <class T> T &Trace<T>::operator[](size_t n) { - return this->at(n); + return m_data.at(n); +#else + return m_data[n]; +#endif +} + +template <class T> +T *Trace<T>::start() { + return size() ? &operator[](start_offset()) : nullptr; +} + +template <class T> +T Trace<T>::max() const { + return size() ? operator[](m_max_index) : 0; } + +template <class T> +T Trace<T>::operator[](size_t n) const { +#if !defined(NDEBUG) + return m_data.at(n); +#else + return m_data[n]; #endif +} + +template <class T> +void Trace<T>::clear() { + m_data.clear(); + m_max_index = 0; +} + +template <class T> +void Trace<T>::push_back(T value) { + m_data.push_back(value); + + if (value > operator[](m_max_index)) { + m_max_index = size() - 1; + } +} + +template <class T> +void Trace<T>::trim_spec(int mult) { + assert((int64_t)size() >= g_entries * mult * 2); + m_data.erase(m_data.begin(), m_data.end() - (g_entries * mult)); + + for (size_t i = 0; i < size(); i++) { + m_max_index = std::max(operator[](m_max_index), operator[](i)); + } +} // ---------------------------------------------------------------------------- // TraceNamed definitions // ---------------------------------------------------------------------------- -template <class T> TraceNamed<T>::TraceNamed(std::string name, std::string name_fmt) : m_name(name), m_name_fmt(name_fmt) {} +template <class T> +TraceNamed<T>::TraceNamed(const char *name, const char *name_fmt) : m_name(name), m_name_fmt(name_fmt) {} + +// ---------------------------------------------------------------------------- +// TraceHeatmap definitions +// ---------------------------------------------------------------------------- +template <class T> +TraceHeatmap<T>::TraceHeatmap(const char *name, const char *name_fmt) : TraceNamed<T>(name, name_fmt) {} + +template <class T> +size_t TraceHeatmap<T>::start_offset() const { + return g_trace_offset * g_hm_pixel_count; +} + +template <class T> +void TraceHeatmap<T>::trim() { + this->trim_spec(g_hm_pixel_count); +} + +#if !defined(NDEBUG) +template <class T> +void TraceHeatmap<T>::validate() const { + assert(this->size() == g_traces[0]->size() * g_hm_pixel_count); +} +#endif // ---------------------------------------------------------------------------- // Plot definitions // ---------------------------------------------------------------------------- -Plot::Plot(std::string name, std::string section, std::vector<std::string> trace_keys) : m_name(name), m_section(section), m_trace_keys(trace_keys) {} +Plot::Plot(const char *name, const char *section) : m_name(name), m_section(section) {} Plot::~Plot() {} -void Plot::render() { +void Plot::render(ImVec2 frame_size) { + if (ImPlot::BeginPlot(m_name, ImVec2(frame_size.x - frame_right_margin(), frame_size.y), plot_flags())) { + int axis_flags = ImPlotAxisFlags_Foreground | (g_status != STATUS_STOPPED ? ImPlotAxisFlags_AutoFit : 0); + ImPlot::SetupAxes(nullptr, nullptr, axis_flags, axis_flags); + ImPlot::SetupAxisFormat(ImAxis_X1, x_axis_formatter()); + ImPlot::SetupAxisFormat(ImAxis_Y1, y_axis_formatter()); + if (ImPlot::IsPlotHovered()) g_plot_hovered = this; + render_internal(); + ImPlot::EndPlot(); + } + + render_post(frame_size); +} + +int Plot::hex_axis_formatter(double value, char *buff, int size, void *data) { + (void)data; + snprintf(buff, size, "%s%#lx", value < 0. ? "-" : "", abs((int64_t)value)); + return 0; +} + +AxisFormatter Plot::x_axis_formatter() { + return Plot::hex_axis_formatter; +} + +AxisFormatter Plot::y_axis_formatter() { + return Plot::hex_axis_formatter; +} + +float Plot::frame_right_margin() { + return 0.f; +} + +int Plot::plot_flags() { + return 0; +} + +void Plot::render_post(ImVec2 frame_size) { + (void)frame_size; +} + +// ---------------------------------------------------------------------------- +// PlotLines definitions +// ---------------------------------------------------------------------------- +PlotLines::PlotLines(const char *name, const char *section, std::vector<const char *> trace_keys) : Plot(name, section), m_trace_keys(trace_keys) {} + +void PlotLines::render_internal() { ImS64 *x = g_trace_map[g_x_axes[g_x_axis]]->start(); for (auto &trace : m_trace_keys) { TraceNamed<ImS64> *trace_obj = g_trace_map[trace]; ImS64 *y = trace_obj->start(); - ImPlot::PlotLine(trace_obj->m_name_fmt.c_str(), x, y, g_trace_len); + ImPlot::PlotLine(trace_obj->m_name_fmt, x, y, g_trace_len); } } // ---------------------------------------------------------------------------- // PlotStacked definitions // ---------------------------------------------------------------------------- -PlotStacked::PlotStacked(std::string name, std::string section, std::vector<std::string> trace_keys) : Plot(name, section, trace_keys) {} +PlotStacked::PlotStacked(const char *name, const char *section, std::vector<const char *> trace_keys) : Plot(name, section), m_trace_keys(trace_keys) {} + +AxisFormatter PlotStacked::y_axis_formatter() { + return PlotStacked::percent_axis_formatter; +} + +int PlotStacked::percent_axis_formatter(double value, char *buff, int size, void *data) { + (void)data; + snprintf(buff, size, "%3.0f%%", value * 100.); + return 0; +} -void PlotStacked::render() { +void PlotStacked::render_internal() { m_totals.resize(g_trace_len); m_old_trace.resize(g_trace_len); m_new_trace.resize(g_trace_len); for (size_t i = 0; i < m_trace_keys.size(); i++) { - ImPlot::PlotDummy(g_trace_map[m_trace_keys[i]]->m_name_fmt.c_str()); + ImPlot::PlotDummy(g_trace_map[m_trace_keys[i]]->m_name_fmt); } for (int i = 0; i < (int)m_trace_keys.size(); i++) { @@ -264,15 +548,17 @@ void PlotStacked::render() { for (int i = 0; i < (int)m_trace_keys.size(); i++) { if (GImPlot->CurrentPlot->Items.GetLegendItem(i)->Show) { - ImPlotSpec spec = ImPlotSpec(ImPlotProp_FillAlpha, GImPlot->CurrentPlot->Items.GetLegendItem(i)->LegendHovered ? 0.9f : 0.7f); + ImPlotSpec spec = ImPlotSpec(ImPlotProp_FillAlpha, GImPlot->CurrentPlot->Items.GetLegendItem(i)->LegendHovered ? 1.f : 0.9f); + TraceNamed<ImS64> *trace = g_trace_map[m_trace_keys[i]]; + const char *trace_name = trace->m_name_fmt; for (int j = 0; j < g_trace_len; j++) { - m_new_trace[j] = m_totals[j] ? (m_old_trace[j] + (double)g_trace_map[m_trace_keys[i]]->start()[j] / (double)m_totals[j]) : 0.; + m_new_trace[j] = m_totals[j] ? (m_old_trace[j] + (double)trace->start()[j] / (double)m_totals[j]) : 0.; } - ImPlot::PlotShaded(g_trace_map[m_trace_keys[i]]->m_name_fmt.c_str(), g_x_axis_normal.start(), m_old_trace.data(), m_new_trace.data(), g_trace_len, spec); - ImPlot::PlotLine(g_trace_map[m_trace_keys[i]]->m_name_fmt.c_str(), g_x_axis_normal.start(), m_old_trace.data(), g_trace_len); - ImPlot::PlotLine(g_trace_map[m_trace_keys[i]]->m_name_fmt.c_str(), g_x_axis_normal.start(), m_new_trace.data(), g_trace_len); + ImPlot::PlotShaded(trace_name, g_x_axis_normal.start(), m_old_trace.data(), m_new_trace.data(), g_trace_len, spec); + ImPlot::PlotLine(trace_name, g_x_axis_normal.start(), m_old_trace.data(), g_trace_len); + ImPlot::PlotLine(trace_name, g_x_axis_normal.start(), m_new_trace.data(), g_trace_len); std::swap(m_old_trace, m_new_trace); } } @@ -283,6 +569,35 @@ void PlotStacked::render() { } // ---------------------------------------------------------------------------- +// PlotHeatmap definitions +// ---------------------------------------------------------------------------- +PlotHeatmap::PlotHeatmap(const char *name, const char *section, const char *trace_key) : Plot(name, section), m_trace_key(trace_key) {} + +float PlotHeatmap::frame_right_margin() { + return HM_COLORSCALE_WIDTH; +} + +int PlotHeatmap::plot_flags() { + return ImPlotFlags_NoLegend; +} + +void PlotHeatmap::render_internal() { + TraceNamed<ImS64> *trace = g_trace_map[m_trace_key]; + ImPlot::PushColormap(g_hm_colormap); + double scale_max = g_hm_scale_pow == HM_SCALE_POW_MIN ? 0. : pow(2., (double)g_hm_scale_pow); + ImPlot::PlotHeatmap(trace->m_name_fmt, trace->start(), g_trace_len, g_hm_pixel_count, 0., scale_max, nullptr, ImPlotPoint(0, g_x_current), ImPlotPoint(MVEC_SIZE, 0)); + ImPlot::PopColormap(); +} + +void PlotHeatmap::render_post(ImVec2 frame_size) { + ImGui::SameLine(); + ImPlot::PushColormap(g_hm_colormap); + double scale_max = g_hm_scale_pow == HM_SCALE_POW_MIN ? (double)g_trace_map[m_trace_key]->max() : pow(2., (double)g_hm_scale_pow); + ImPlot::ColormapScale("##hm-scale", 0., scale_max, ImVec2(HM_COLORSCALE_WIDTH, frame_size.y), "%.1e"); + ImPlot::PopColormap(); +} + +// ---------------------------------------------------------------------------- // Data functions // ---------------------------------------------------------------------------- int64_t data_max_hm_pixel_pow(void) { @@ -327,27 +642,21 @@ void data_reset_plot_cells(void) { std::fill(g_plot_cells_bottom.begin(), g_plot_cells_bottom.end(), 0.f); } -#if !defined(NDEBUG) -void data_validate_traces(void) { - for (auto &trace : g_traces) assert(trace->size() == g_traces[0]->size()); -} -#endif - void data_fetch(void) { json_object *request = json_object_new_object(); json_object_object_add(request, "request", json_object_new_string("data")); json_object_object_add(request, "entries", json_object_new_int64(g_entries)); json_object_object_add(request, "nth", json_object_new_int64(g_nth)); - json_object_object_add(request, "x-axis", json_object_new_string(g_x_axes[g_x_axis].c_str())); + json_object_object_add(request, "x-axis", json_object_new_string(g_x_axes[g_x_axis])); json_object_object_add(request, "x-low", json_object_new_int64(g_x_low)); json_object_object_add(request, "x-high", json_object_new_int64(g_x_high)); json_object_object_add(request, "hm-left", json_object_new_int64(g_hm_left)); json_object_object_add(request, "hm-pixel-count", json_object_new_int64(g_hm_pixel_count)); json_object_object_add(request, "hm-pixel-pow", json_object_new_int64(g_hm_pixel_pow)); json_object_object_add(request, "x-current", json_object_new_int64(g_x_current)); - std::string request_str = json_object_to_json_string(request); + const char *request_str = json_object_to_json_string(request); - log_info("Sending request to server: %s", request_str.c_str()); + log_info("Sending request to server: %s", request_str); int socket_fd = socket(AF_INET, SOCK_STREAM, 0); sockaddr_in socket_addr; memset(&socket_addr, 0, sizeof(sockaddr_in)); @@ -359,23 +668,25 @@ void data_fetch(void) { shutdown(socket_fd, SHUT_WR); json_object *response = json_object_from_fd(socket_fd); - std::string response_str = json_object_to_json_string(response); - log_info("Server responded with: %s", response_str.c_str()); mtx_lock(&g_fetching_mutex); json_object_object_foreach(response, key, value) { - if (g_trace_map.contains(key)) { - for (size_t i = 0; i < json_object_array_length(value); i++) { + size_t new_rows = json_object_array_length(value); + + if (!strcmp(key, g_x_axes[g_x_axis])) { + log_info("Received %lu rows of data from server", new_rows); + + for (size_t i = 0; i < new_rows; i++) { ImS64 point = json_object_get_int64(json_object_array_get_idx(value, i)); - g_trace_map[key]->push_back(point); + g_x_axis_normal.push_back((double)point); } } - if (std::string(key) == g_x_axes[g_x_axis]) { - for (size_t i = 0; i < json_object_array_length(value); i++) { + if (g_trace_map.contains(key)) { + for (size_t i = 0; i < new_rows; i++) { ImS64 point = json_object_get_int64(json_object_array_get_idx(value, i)); - g_x_axis_normal.push_back((double)point); + g_trace_map[key]->push_back(point); } } } @@ -385,7 +696,7 @@ void data_fetch(void) { json_object_put(response); #if !defined(NDEBUG) - data_validate_traces(); + for (auto &trace : g_traces) trace->validate(); #endif if ((int64_t)g_traces[0]->size() >= g_entries * 2) { @@ -394,7 +705,7 @@ void data_fetch(void) { } #if !defined(NDEBUG) - data_validate_traces(); + for (auto &trace : g_traces) trace->validate(); #endif int64_t current_size = g_traces[0]->size(); @@ -439,10 +750,10 @@ void data_stop_fetching(void) { // ---------------------------------------------------------------------------- // GUI functions // ---------------------------------------------------------------------------- -void gui_render_data_input(std::string label, int64_t *target) { +void gui_render_data_input(const char *label, int64_t *target) { assert(target); - if (ImGui::InputScalar(label.c_str(), ImGuiDataType_U64, target, nullptr, nullptr, "%#lx")) { + if (ImGui::InputScalar(label, ImGuiDataType_U64, target, nullptr, nullptr, "%#lx")) { data_on_field_change(); } } @@ -478,9 +789,9 @@ void gui_render_data_col(void) { gui_render_data_input("entries", &g_entries); gui_render_data_input("nth", &g_nth); - if (ImGui::BeginCombo("x-axis", g_x_axes[g_x_axis].c_str())) { + if (ImGui::BeginCombo("x-axis", g_x_axes[g_x_axis])) { for (int i = 0; i < CORES + 2; i++) { - if (ImGui::Selectable(g_x_axes[i].c_str(), g_x_axis == i)) { + if (ImGui::Selectable(g_x_axes[i], g_x_axis == i)) { data_reset_fields(); g_x_axis = i; } @@ -499,7 +810,7 @@ void gui_render_data_col(void) { case STATUS_STOPPING: ImGui::LabelText("entries", "%#lx", g_entries); ImGui::LabelText("nth", "%#lx", g_nth); - ImGui::LabelText("x-axis", "%s", g_x_axes[g_x_axis].c_str()); + ImGui::LabelText("x-axis", "%s", g_x_axes[g_x_axis]); ImGui::LabelText("x-low", "%#lx", g_x_low); ImGui::LabelText("x-high", "%#lx", g_x_high); ImGui::LabelText("hm-left", "%#lx", g_hm_left); @@ -531,40 +842,44 @@ void gui_render_data_col(void) { } ImGui::SeparatorText("Layout"); - ImGui::SliderInt("cols", &g_plot_cols, PLOT_MIN_COLS, PLOT_MAX_COLS); + ImGui::DragInt("cols", &g_plot_cols, 1, PLOT_MIN_COLS, PLOT_MAX_COLS); + ImGui::DragFloat("plot-height", &g_plot_height, PLOT_HEIGHT_INTERVAL, PLOT_MIN_HEIGHT, PLOT_MAX_HEIGHT, "%.0f"); + ImGui::DragFloat("hm-pow", &g_hm_scale_pow, HM_SCALE_POW_INTERVAL, HM_SCALE_POW_MIN, HM_SCALE_POW_MAX, "%.0f"); + ImGui::End(); } -int gui_plot_cell_index(int col, int row) { - int index = col * PLOT_MAX_COLS + row; +int gui_plot_cell_index(int row, int col) { + int index = row * PLOT_MAX_COLS + col; assert(index < (int)g_plot_cells.size()); assert(index < (int)g_plot_cells_top.size()); assert(index < (int)g_plot_cells_bottom.size()); return index; } -void gui_render_plot(Plot *plot, const ImVec2 &frame_size=ImVec2(-1.f, 0.f)) { - assert(plot); +int gui_plot_cell_row_up() { + for (int row = g_plot_row_selected - 1; row >= 0; row--) { + if (g_plot_cells[gui_plot_cell_index(row, g_plot_col_selected)]) { + return row; + } + } - int plot_flags = ImPlotFlags_NoMenus; - int axis_flags = ImPlotAxisFlags_NoMenus; + return g_plot_row_selected; +} - if (g_status != STATUS_STOPPED) { - ImPlot::SetNextAxesToFit(); - plot_flags |= ImPlotFlags_NoInputs | ImPlotFlags_NoMouseText; - axis_flags |= ImPlotAxisFlags_NoHighlight; +int gui_plot_cell_row_down() { + for (int row = g_plot_row_selected + 1; row < (int)g_plots.size(); row++) { + if (g_plot_cells[gui_plot_cell_index(row, g_plot_col_selected)]) { + return row; + } } - if (ImPlot::BeginPlot(plot->m_name.c_str(), frame_size, plot_flags)) { - ImPlot::SetupAxes(nullptr, nullptr, axis_flags, axis_flags); - plot->render(); - ImPlot::EndPlot(); - } + return g_plot_row_selected; } void gui_render_plots(void) { - std::string section_current = g_plots[0]->m_section; - std::string section_next; + const char *section_current = g_plots[0]->m_section; + const char *section_next = nullptr; g_plots_covered.clear(); g_plots_covered.resize(g_plots.size(), false); @@ -583,25 +898,27 @@ void gui_render_plots(void) { ImGui::SetNextWindowSize(win_size); ImGui::Begin("plots", nullptr, IMGUI_WINDOW_FLAGS); g_plot_scroll_current = ImGui::GetScrollY(); + g_plot_hovered = nullptr; - int col = 0; int row = 0; + int col = 0; mtx_lock(&g_fetching_mutex); - while (section_current.length()) { - ImGui::SeparatorText(section_current.c_str()); + while (section_current) { + ImGui::SeparatorText(section_current); ImGui::BeginTable("plots-table", g_plot_cols); for (size_t i = 0; i < g_plots.size(); i++) { - if (g_plots[i]->m_section != section_current) { - section_next = (!section_next.length() && !g_plots_covered[i]) ? g_plots[i]->m_section : section_next; + if (strcmp(g_plots[i]->m_section, section_current)) { + section_next = (!section_next && !g_plots_covered[i]) ? g_plots[i]->m_section : section_next; continue; } ImGui::TableNextColumn(); - g_plot_cells[gui_plot_cell_index(col, row)] = g_plots[i]; - g_plot_cells_top[gui_plot_cell_index(col, row)] = ImGui::GetCursorPosY(); + ImVec2 frame_size = ImVec2(ImGui::GetContentRegionAvail().x, g_plot_height); + g_plot_cells[gui_plot_cell_index(row, col)] = g_plots[i]; + g_plot_cells_top[gui_plot_cell_index(row, col)] = ImGui::GetCursorPosY(); if (g_plots[i] == g_plot_selected) { g_plot_col_selected = col; @@ -609,20 +926,21 @@ void gui_render_plots(void) { g_implot_style->Colors[ImPlotCol_FrameBg] = g_imgui_style->Colors[ImGuiCol_FrameBg]; } - gui_render_plot(g_plots[i]); + g_plots[i]->render(frame_size); if (g_plots[i] == g_plot_selected) { g_implot_style->Colors[ImPlotCol_FrameBg] = COLOR_BLACK; } - g_plot_cells_bottom[gui_plot_cell_index(col, row)] = ImGui::GetCursorPosY(); + g_plot_cells_bottom[gui_plot_cell_index(row, col)] = ImGui::GetCursorPosY(); col = (col + 1) % g_plot_cols; row += col ? 0 : 1; + g_plots_covered[i] = true; } section_current = section_next; - section_next = std::string(); + section_next = nullptr; ImGui::EndTable(); row += col ? 1 : 0; col = 0; @@ -639,25 +957,47 @@ void gui_render_plot_maximized(void) { ImGui::SetNextWindowSize(viewport->Size); ImGui::Begin("plot-fullscreen", nullptr, IMGUI_WINDOW_FLAGS); - gui_render_plot(g_plot_selected, viewport->Size); + ImVec2 frame_size = { + viewport->Size.x - g_imgui_style->WindowPadding.x * 2, + viewport->Size.y - g_imgui_style->WindowPadding.y * 2, + }; + + g_plot_selected->render(frame_size); ImGui::End(); } -void gui_plot_queue_scroll(int col_selected, int row_selected) { +void gui_plot_queue_scroll_to_position(bool increased_plot_height) { + int row = 0; + float selected_plot_top = 0.f; + + for (row = 0; row < (int)g_plots.size(); row++) { + for (int col = 0; col < PLOT_MAX_COLS; col++) { + if (g_plot_selected == g_plot_cells[gui_plot_cell_index(row, col)]) { + selected_plot_top = g_plot_cells_top[gui_plot_cell_index(row, col)]; + goto loop_exit; + } + } + } + + loop_exit: + g_plot_scroll_to = selected_plot_top + (PLOT_HEIGHT_INTERVAL * (float)row * (increased_plot_height ? 1.f : -1.f)) - PLOT_SCROLL_MARGIN; + g_plot_scroll = true; +} + +void gui_plot_queue_scroll_to_selected() { const ImGuiViewport *viewport = ImGui::GetMainViewport(); - float plot_top = g_plot_cells_top[gui_plot_cell_index(col_selected, row_selected)]; - float plot_bottom = g_plot_cells_bottom[gui_plot_cell_index(col_selected, row_selected)]; - float win_top = g_plot_scroll_current; - float win_bottom = win_top + viewport->Size.y; + float plot_top = g_plot_cells_top[gui_plot_cell_index(g_plot_row_selected, g_plot_col_selected)]; + float plot_bottom = g_plot_cells_bottom[gui_plot_cell_index(g_plot_row_selected, g_plot_col_selected)]; + float win_bottom = g_plot_scroll_current + viewport->Size.y; if (plot_bottom > win_bottom) { - g_plot_scroll_to = win_top + (plot_bottom - win_bottom); + g_plot_scroll_to = g_plot_scroll_current + (plot_bottom - win_bottom); g_plot_scroll = true; } - if (plot_top < win_top) { - g_plot_scroll_to = plot_top - PLOT_SCROLL_OFFSET; + if (plot_top < g_plot_scroll_current) { + g_plot_scroll_to = plot_top - PLOT_SCROLL_MARGIN; g_plot_scroll = true; } } @@ -691,23 +1031,62 @@ void app_error_callback(int error, const char* description) { log_warn("GLFW error %d: %s", error, description); } +void app_toggle_state() { + switch (g_status) { + case STATUS_STOPPED: + data_start_fetching(); + break; + case STATUS_RUNNING: + data_stop_fetching(); + break; + } +} + +void app_key_callback_plot_maximized(int key, int mods) { + switch (mods) { + case GLFW_MOD_CONTROL: + switch (key) { + case GLFW_KEY_C: + glfwSetWindowShouldClose(g_window, GLFW_TRUE); + break; + case GLFW_KEY_COMMA: + g_hm_scale_pow = std::max(g_hm_scale_pow - HM_SCALE_POW_INTERVAL, HM_SCALE_POW_MIN); + break; + case GLFW_KEY_PERIOD: + g_hm_scale_pow = std::min(g_hm_scale_pow + HM_SCALE_POW_INTERVAL, HM_SCALE_POW_MAX); + break; + } + + break; + + case 0: + switch (key) { + case GLFW_KEY_F: + g_plot_maximized = false; + break; + case GLFW_KEY_SPACE: + app_toggle_state(); + break; + } + + break; + } +} + void app_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) { (void)window; (void)scancode; - if (action != GLFW_PRESS || ImGui::IsAnyItemActive()) { + if (ImGui::IsAnyItemActive()) { return; } - if (g_plot_maximized) { - if (mods == GLFW_MOD_CONTROL && key == GLFW_KEY_C) { - glfwSetWindowShouldClose(g_window, GLFW_TRUE); - } - - if (mods == 0 && key == GLFW_KEY_F) { - g_plot_maximized = !g_plot_maximized; - } + if (action != GLFW_PRESS && action != GLFW_REPEAT) { + return; + } + if (g_plot_maximized) { + app_key_callback_plot_maximized(key, mods); return; } @@ -721,13 +1100,27 @@ void app_key_callback(GLFWwindow* window, int key, int scancode, int action, int g_data_col_visible = !g_data_col_visible; break; case GLFW_KEY_LEFT: - g_plot_cols -= g_plot_cols > 1 ? 1 : 0; + g_plot_cols = std::max(g_plot_cols - 1, PLOT_MIN_COLS); data_reset_plot_cells(); break; case GLFW_KEY_RIGHT: - g_plot_cols += g_plot_cols < PLOT_MAX_COLS ? 1 : 0; + g_plot_cols = std::min(g_plot_cols + 1, PLOT_MAX_COLS); data_reset_plot_cells(); break; + case GLFW_KEY_UP: + g_plot_height = std::min(g_plot_height + PLOT_HEIGHT_INTERVAL, PLOT_MAX_HEIGHT); + gui_plot_queue_scroll_to_position(true); + break; + case GLFW_KEY_DOWN: + g_plot_height = std::max(g_plot_height - PLOT_HEIGHT_INTERVAL, PLOT_MIN_HEIGHT); + gui_plot_queue_scroll_to_position(false); + break; + case GLFW_KEY_COMMA: + g_hm_scale_pow = std::max(g_hm_scale_pow - HM_SCALE_POW_INTERVAL, HM_SCALE_POW_MIN); + break; + case GLFW_KEY_PERIOD: + g_hm_scale_pow = std::min(g_hm_scale_pow + HM_SCALE_POW_INTERVAL, HM_SCALE_POW_MAX); + break; } break; @@ -735,36 +1128,28 @@ void app_key_callback(GLFWwindow* window, int key, int scancode, int action, int case 0: switch (key) { case GLFW_KEY_LEFT: - g_plot_col_selected -= g_plot_col_selected ? 1 : 0; - g_plot_selected = g_plot_cells[gui_plot_cell_index(g_plot_col_selected, g_plot_row_selected)]; + g_plot_col_selected = std::max(g_plot_col_selected - 1, 0); + g_plot_selected = g_plot_cells[gui_plot_cell_index(g_plot_row_selected, g_plot_col_selected)]; break; case GLFW_KEY_RIGHT: - g_plot_col_selected += (g_plot_col_selected < PLOT_MAX_COLS - 1 && g_plot_cells[gui_plot_cell_index(g_plot_col_selected + 1, g_plot_row_selected)]) ? 1 : 0; - g_plot_selected = g_plot_cells[gui_plot_cell_index(g_plot_col_selected, g_plot_row_selected)]; + g_plot_col_selected += (g_plot_col_selected < PLOT_MAX_COLS - 1 && g_plot_cells[gui_plot_cell_index(g_plot_row_selected, g_plot_col_selected + 1)]) ? 1 : 0; + g_plot_selected = g_plot_cells[gui_plot_cell_index(g_plot_row_selected, g_plot_col_selected)]; break; case GLFW_KEY_UP: - g_plot_row_selected -= (g_plot_row_selected && g_plot_cells[gui_plot_cell_index(g_plot_col_selected, g_plot_row_selected - 1)]) ? 1 : 0; - g_plot_selected = g_plot_cells[gui_plot_cell_index(g_plot_col_selected, g_plot_row_selected)]; - gui_plot_queue_scroll(g_plot_col_selected, g_plot_row_selected); + g_plot_row_selected = gui_plot_cell_row_up(); + g_plot_selected = g_plot_cells[gui_plot_cell_index(g_plot_row_selected, g_plot_col_selected)]; + gui_plot_queue_scroll_to_selected(); break; case GLFW_KEY_DOWN: - g_plot_row_selected += (g_plot_row_selected < (int)g_plots.size() - 1 && g_plot_cells[gui_plot_cell_index(g_plot_col_selected, g_plot_row_selected + 1)]) ? 1 : 0; - g_plot_selected = g_plot_cells[gui_plot_cell_index(g_plot_col_selected, g_plot_row_selected)]; - gui_plot_queue_scroll(g_plot_col_selected, g_plot_row_selected); + g_plot_row_selected = gui_plot_cell_row_down(); + g_plot_selected = g_plot_cells[gui_plot_cell_index(g_plot_row_selected, g_plot_col_selected)]; + gui_plot_queue_scroll_to_selected(); break; case GLFW_KEY_F: g_plot_maximized = !g_plot_maximized; break; case GLFW_KEY_SPACE: - switch (g_status) { - case STATUS_STOPPED: - data_start_fetching(); - break; - case STATUS_RUNNING: - data_stop_fetching(); - break; - } - + app_toggle_state(); break; } @@ -772,6 +1157,19 @@ void app_key_callback(GLFWwindow* window, int key, int scancode, int action, int } } +void app_mouse_button_callback(GLFWwindow* window, int button, int action, int mods) { + (void)window; + (void)mods; + + if (button != GLFW_MOUSE_BUTTON_LEFT) return; + + switch (action) { + case GLFW_PRESS: + g_plot_selected = g_plot_hovered ? g_plot_hovered : g_plot_selected; + break; + } +} + void init() { signal(SIGINT, app_sig_handler); signal(SIGTERM, app_sig_handler); @@ -787,6 +1185,7 @@ void init() { g_window = glfwCreateWindow((int)(800 * scale), (int)(600 * scale), "SALIS data client", nullptr, nullptr); assert(g_window); glfwSetKeyCallback(g_window, app_key_callback); + glfwSetMouseButtonCallback(g_window, app_mouse_button_callback); glfwMakeContextCurrent(g_window); glfwSwapInterval(1); // enable vsync @@ -796,7 +1195,7 @@ void init() { ImPlot::CreateContext(); g_imgui_io = &ImGui::GetIO(); - g_imgui_io->Fonts->AddFontDefaultVector(); + g_imgui_io->Fonts->AddFontFromFileTTF(FONT_SOURCE, FONT_SIZE); g_imgui_io->IniFilename = nullptr; g_imgui_style = &ImGui::GetStyle(); @@ -808,15 +1207,20 @@ void init() { g_implot_style = &ImPlot::GetStyle(); g_implot_style->Colors[ImPlotCol_FrameBg] = COLOR_BLACK; + g_hm_colormap = ImPlot::AddColormap("Inferno", g_hm_colormap_cols.data(), g_hm_colormap_cols.size(), false); ImGui_ImplGlfw_InitForOpenGL(g_window, true); ImGui_ImplOpenGL3_Init(GLSL_VERSION); for (auto &trace : g_core_traces) g_traces.push_back(&trace); for (auto &trace : g_arch_traces) g_traces.push_back(&trace); + for (auto &trace : g_core_traces_heatmaps) g_traces.push_back(&trace); + for (auto &trace : g_arch_traces_heatmaps) g_traces.push_back(&trace); for (auto &plot : g_core_plots) g_plots.push_back(&plot); for (auto &plot : g_arch_plots) g_plots.push_back(&plot); for (auto &plot : g_arch_plots_stacked) g_plots.push_back(&plot); + for (auto &plot : g_core_plots_heatmaps) g_plots.push_back(&plot); + for (auto &plot : g_arch_plots_heatmaps) g_plots.push_back(&plot); for (auto &i : g_traces) g_trace_map[i->m_name] = i; g_plot_cells = std::vector<Plot *>(g_plots.size() * PLOT_MAX_COLS); |