Low fps when using multiple real time plots

[t0mke]

How can I achieve at least 60 fps when using a large number of real time plots (around 30)

I understand it has to do with the buffer but what's the work around?

EDIT: I was running my project in debug mode with VS instead of release, I get the full 144fps now

[epezent]

Sorry, but without knowing the specifics of your application (e.g. 30 plots, but how many points per plot?), your system specs, build tools, etc. I can't really offer you any help. I suggest you try profiling the application and letting us know which lines of code are bottlenecking your application.

FYI, 30 line plots with around 1000 pts each should be perfectly doable. If your data has significantly more points, then you'll inevitably need to implement a downsampling algorithm. I simple but not great solution is to just plot every nth point using the stride features of ImPlot.

[t0mke]

yeah that's true

this is weird, I've only been touching up on some code with functions that aren't in use and suddenly i'm getting low performance again (from 72fps locked to 48fps) . I've even reduced the number of points from 3500 to 1000 and deleted the shaded plot (so only the line plot is drawn). It's a shame I didn't save the code when it was working.

[t0mke]

i've tested it out on a clean example_glfw_opengl3 that ImGui provides and I get around 70fps (doesn't lock) with 1000 points, here's the code. edit: on full screen i'll get an average of 54fps, which is not good enough for systems that will run with weaker gpus

if (show_another_window)
        {
            ImGui::SetNextWindowPos(ImVec2(240, 250), ImGuiCond_FirstUseEver);
            ImGui::SetNextWindowSize(ImVec2(1500, 500));
            ImGui::Begin("Graph Window", NULL, ImGuiWindowFlags_NoCollapse);
            static ScrollingBuffer sdata[32];
            static float t = 0;
            t += ImGui::GetIO().DeltaTime;
            static float history = 50;
            ImGui::SliderFloat("History", &history, 1, 50, "%.1f s");
            static ImPlotAxisFlags flags = ImPlotAxisFlags_NoTickLabels;
            int i = 0;
            ImGui::Text("");
            if (ImGui::BeginTable("table_graph", 8))
            {
                for (int row = 0; row < 4; row++)
                {
                    ImGui::TableNextRow();
                    for (int column = 0; column < 8; column++)
                    {
                        ImGui::TableSetColumnIndex(column);
                            sdata[i].AddPoint(t, 0);
                            snprintf(buffer, 99, "##Scrolling %d", i);
                            ImPlot::SetNextPlotLimitsX(t - history, t, ImGuiCond_Always);
                            ImPlot::SetNextPlotLimitsY(0, 500);
                            if (ImPlot::BeginPlot(buffer, NULL, NULL, ImVec2(100, 100), 0, flags, flags)) {
                                ImPlot::SetNextFillStyle(ImVec4(1 , 0.5, 0.5, 1), 0.5f);
                          //     ImPlot::PlotShaded("", &sdata[i].Data[0].x, &sdata[i].Data[0].y, sdata[i].Data.size(), -INFINITY, sdata[i].Offset, 2 * sizeof(float));
                                ImPlot::PlotLine("", &sdata[i].Data[0].x, &sdata[i].Data[0].y, sdata[i].Data.size(), sdata[i].Offset, 2 * sizeof(float));
                                ImPlot::EndPlot();
                            }
                        
                        i++;

                    }


                }
                ImGui::EndTable();
            }

GPU utilization only at 4%

[t0mke]

hold on, I think I see what's wrong

I was running it as debug not release, i'm getting 144fps now with 1000 points

[t0mke]

ALSO
just came back to this and i've realized i've been adding data to the vector at each frame instead of each second where my data update happens. Finally I can add a significantly more buffer size

[0lru]

From an architectural viewpoint, this also has to do with "immediate mode".
As an example, chrome and other frameworks may render to 30 FBO's and
then only use partial updates.
I'm trying to address this and other things here: https://github.com/0lru/gpuhud.

(That'd be also more "green", because of the reduced power consumption)