paoda
/
zgui
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
zgui/libs/imgui_test_engine/imgui_te_perftool.cpp

1950 lines
78 KiB
C++
Raw Normal View History

chore: update to 2a0400ade5535001bfc09e0e7531515e232be6e7
2024-07-04 00:55:17 +00:00
// dear imgui test engine
// (performance tool)
// Browse and visualize samples recorded by ctx->PerfCapture() calls.
// User access via 'Test Engine UI -> Tools -> Perf Tool'
/*
Index of this file:
// [SECTION] Header mess
// [SECTION] ImGuiPerflogEntry
// [SECTION] Types & everything else
// [SECTION] USER INTERFACE
// [SECTION] SETTINGS
// [SECTION] TESTS
*/
// Terminology:
// * Entry: information about execution of a single perf test. This corresponds to one line in CSV file.
// * Batch: a group of entries that were created together during a single execution. A new batch is created each time
// one or more perf tests are executed. All entries in a single batch will have a matching ImGuiPerflogEntry::Timestamp.
// * Build: A group of batches that have matching BuildType, OS, Cpu, Compiler, GitBranchName.
// * Baseline: A batch that we are comparing against. Baselines are identified by batch timestamp and build id.
//-------------------------------------------------------------------------
// [SECTION] Header mess
//-------------------------------------------------------------------------
#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS
#endif
#define IMGUI_DEFINE_MATH_OPERATORS
#include "imgui_te_perftool.h"
#include "imgui.h"
#include "imgui_internal.h"
#include "imgui_te_utils.h"
#include "thirdparty/Str/Str.h"
#include <time.h> // time(), localtime()
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
#include "implot.h"
#include "implot_internal.h"
#endif
// For tests
#include "imgui_te_engine.h"
#include "imgui_te_context.h"
#include "imgui_te_internal.h" // ImGuiTestEngine_GetPerfTool()
#include "imgui_capture_tool.h"
//-------------------------------------------------------------------------
// [SECTION] ImGuiPerflogEntry
//-------------------------------------------------------------------------
void ImGuiPerfToolEntry::Set(const ImGuiPerfToolEntry& other)
{
Timestamp = other.Timestamp;
Category = other.Category;
TestName = other.TestName;
DtDeltaMs = other.DtDeltaMs;
DtDeltaMsMin = other.DtDeltaMsMin;
DtDeltaMsMax = other.DtDeltaMsMax;
NumSamples = other.NumSamples;
PerfStressAmount = other.PerfStressAmount;
GitBranchName = other.GitBranchName;
BuildType = other.BuildType;
Cpu = other.Cpu;
OS = other.OS;
Compiler = other.Compiler;
Date = other.Date;
//DateMax = ...
VsBaseline = other.VsBaseline;
LabelIndex = other.LabelIndex;
}
//-------------------------------------------------------------------------
// [SECTION] Types & everything else
//-------------------------------------------------------------------------
typedef ImGuiID(*HashEntryFn)(ImGuiPerfToolEntry* entry);
typedef void(*FormatEntryLabelFn)(ImGuiPerfTool* perftool, Str* result, ImGuiPerfToolEntry* entry);
struct ImGuiPerfToolColumnInfo
{
const char* Title;
int Offset;
ImGuiDataType Type;
bool ShowAlways;
ImGuiTableFlags Flags;
template<typename T>
T GetValue(const ImGuiPerfToolEntry* entry) const { return *(T*)((const char*)entry + Offset); }
};
// Update _ShowEntriesTable() and SaveHtmlReport() when adding new entries.
static const ImGuiPerfToolColumnInfo PerfToolColumnInfo[] =
{
{ /* 00 */ "Date", offsetof(ImGuiPerfToolEntry, Timestamp), ImGuiDataType_U64, true, ImGuiTableColumnFlags_DefaultHide },
{ /* 01 */ "Test Name", offsetof(ImGuiPerfToolEntry, TestName), ImGuiDataType_COUNT, true, 0 },
{ /* 02 */ "Branch", offsetof(ImGuiPerfToolEntry, GitBranchName), ImGuiDataType_COUNT, true, 0 },
{ /* 03 */ "Compiler", offsetof(ImGuiPerfToolEntry, Compiler), ImGuiDataType_COUNT, true, 0 },
{ /* 04 */ "OS", offsetof(ImGuiPerfToolEntry, OS), ImGuiDataType_COUNT, true, 0 },
{ /* 05 */ "CPU", offsetof(ImGuiPerfToolEntry, Cpu), ImGuiDataType_COUNT, true, 0 },
{ /* 06 */ "Build", offsetof(ImGuiPerfToolEntry, BuildType), ImGuiDataType_COUNT, true, 0 },
{ /* 07 */ "Stress", offsetof(ImGuiPerfToolEntry, PerfStressAmount), ImGuiDataType_S32, true, 0 },
{ /* 08 */ "Avg ms", offsetof(ImGuiPerfToolEntry, DtDeltaMs), ImGuiDataType_Double, true, 0 },
{ /* 09 */ "Min ms", offsetof(ImGuiPerfToolEntry, DtDeltaMsMin), ImGuiDataType_Double, false, 0 },
{ /* 00 */ "Max ms", offsetof(ImGuiPerfToolEntry, DtDeltaMsMax), ImGuiDataType_Double, false, 0 },
{ /* 11 */ "Samples", offsetof(ImGuiPerfToolEntry, NumSamples), ImGuiDataType_S32, false, 0 },
{ /* 12 */ "VS Baseline", offsetof(ImGuiPerfToolEntry, VsBaseline), ImGuiDataType_Float, true, 0 },
};
static const char* PerfToolReportDefaultOutputPath = "./output/capture_perf_report.html";
// This is declared as a standalone function in order to run without a PerfTool instance
void ImGuiTestEngine_PerfToolAppendToCSV(ImGuiPerfTool* perf_log, ImGuiPerfToolEntry* entry, const char* filename)
{
if (filename == NULL)
filename = IMGUI_PERFLOG_DEFAULT_FILENAME;
if (!ImFileCreateDirectoryChain(filename, ImPathFindFilename(filename)))
{
fprintf(stderr, "Unable to create missing directory '%*s', perftool entry was not saved.\n", (int)(ImPathFindFilename(filename) - filename), filename);
return;
}
// Appends to .csv
FILE* f = fopen(filename, "a+b");
if (f == NULL)
{
fprintf(stderr, "Unable to open '%s', perftool entry was not saved.\n", filename);
return;
}
fprintf(f, "%llu,%s,%s,%.3f,x%d,%s,%s,%s,%s,%s,%s\n", entry->Timestamp, entry->Category, entry->TestName,
entry->DtDeltaMs, entry->PerfStressAmount, entry->GitBranchName, entry->BuildType, entry->Cpu, entry->OS,
entry->Compiler, entry->Date);
fflush(f);
fclose(f);
// Register to runtime perf tool if any
if (perf_log != NULL)
perf_log->AddEntry(entry);
}
// Tri-state button. Copied and modified ButtonEx().
static bool Button3(const char* label, int* value)
{
ImGuiWindow* window = ImGui::GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const ImVec2 label_size = ImGui::CalcTextSize(label, NULL, true);
float dot_radius2 = g.FontSize;
ImVec2 btn_size(dot_radius2 * 2, dot_radius2);
ImVec2 pos = window->DC.CursorPos;
ImVec2 size = ImGui::CalcItemSize(ImVec2(), btn_size.x + label_size.x + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x, label_size.y + style.FramePadding.y * 2.0f);
const ImRect bb(pos, pos + size);
ImGui::ItemSize(size, style.FramePadding.y);
if (!ImGui::ItemAdd(bb, id))
return false;
bool hovered, held;
bool pressed = ImGui::ButtonBehavior(ImRect(pos, pos + style.FramePadding + btn_size), id, &hovered, &held, 0);
// Render
const ImU32 col = ImGui::GetColorU32(ImGuiCol_FrameBg);
ImGui::RenderNavHighlight(bb, id);
ImGui::RenderFrame(bb.Min + style.FramePadding, bb.Min + style.FramePadding + btn_size, col, true, /*style.FrameRounding*/ 5.0f);
ImColor btn_col;
if (held)
btn_col = style.Colors[ImGuiCol_SliderGrabActive];
else if (hovered)
btn_col = style.Colors[ImGuiCol_ButtonHovered];
else
btn_col = style.Colors[ImGuiCol_SliderGrab];
ImVec2 center = bb.Min + ImVec2(dot_radius2 + (dot_radius2 * (float)*value), dot_radius2) * 0.5f + style.FramePadding;
window->DrawList->AddCircleFilled(center, dot_radius2 * 0.5f, btn_col);
ImRect text_bb;
text_bb.Min = bb.Min + style.FramePadding + ImVec2(btn_size.x + style.ItemInnerSpacing.x, 0);
text_bb.Max = text_bb.Min + label_size;
ImGui::RenderTextClipped(text_bb.Min, text_bb.Max, label, NULL, &label_size, style.ButtonTextAlign, &bb);
*value = (*value + pressed) % 3;
return pressed;
}
static ImGuiID GetBuildID(const ImGuiPerfToolEntry* entry)
{
IM_ASSERT(entry != NULL);
ImGuiID build_id = ImHashStr(entry->BuildType);
build_id = ImHashStr(entry->OS, 0, build_id);
build_id = ImHashStr(entry->Cpu, 0, build_id);
build_id = ImHashStr(entry->Compiler, 0, build_id);
build_id = ImHashStr(entry->GitBranchName, 0, build_id);
return build_id;
}
static ImGuiID GetBuildID(const ImGuiPerfToolBatch* batch)
{
IM_ASSERT(batch != NULL);
IM_ASSERT(!batch->Entries.empty());
return GetBuildID(&batch->Entries.Data[0]);
}
// Batch ID depends on display type. It is either a build ID (when combinding by build type) or batch timestamp otherwise.
static ImGuiID GetBatchID(const ImGuiPerfTool* perftool, const ImGuiPerfToolEntry* entry)
{
IM_ASSERT(perftool != NULL);
IM_ASSERT(entry != NULL);
if (perftool->_DisplayType == ImGuiPerfToolDisplayType_CombineByBuildInfo)
return GetBuildID(entry);
else
return (ImU32)entry->Timestamp;
}
static int PerfToolComparerStr(const void* a, const void* b)
{
return strcmp(*(const char**)b, *(const char**)a);
}
static int IMGUI_CDECL PerfToolComparerByEntryInfo(const void* lhs, const void* rhs)
{
const ImGuiPerfToolEntry* a = (const ImGuiPerfToolEntry*)lhs;
const ImGuiPerfToolEntry* b = (const ImGuiPerfToolEntry*)rhs;
// While build ID does include git branch it wont ensure branches are grouped together, therefore we do branch
// sorting manually.
int result = strcmp(a->GitBranchName, b->GitBranchName);
// Now that we have groups of branches - sort individual builds within those groups.
if (result == 0)
result = ImClamp<int>((int)((ImS64)GetBuildID(a) - (ImS64)GetBuildID(b)), -1, +1);
// Group individual runs together within build groups.
if (result == 0)
result = (int)ImClamp<ImS64>((ImS64)b->Timestamp - (ImS64)a->Timestamp, -1, +1);
// And finally sort individual runs by perf name so we can have a predictable order (used to optimize in _Rebuild()).
if (result == 0)
result = (int)strcmp(a->TestName, b->TestName);
return result;
}
static ImGuiPerfTool* PerfToolInstance = NULL;
static int IMGUI_CDECL CompareWithSortSpecs(const void* lhs, const void* rhs)
{
IM_ASSERT(PerfToolInstance != NULL);
ImGuiPerfTool* tool = PerfToolInstance;
const ImGuiTableSortSpecs* sort_specs = PerfToolInstance->_InfoTableSortSpecs;
int batch_index_a, entry_index_a, mono_index_a, batch_index_b, entry_index_b, mono_index_b;
tool->_UnpackSortedKey(*(ImU64*)lhs, &batch_index_a, &entry_index_a, &mono_index_a);
tool->_UnpackSortedKey(*(ImU64*)rhs, &batch_index_b, &entry_index_b, &mono_index_b);
for (int i = 0; i < sort_specs->SpecsCount; i++)
{
const ImGuiTableColumnSortSpecs* specs = &sort_specs->Specs[i];
const ImGuiPerfToolColumnInfo& col_info = PerfToolColumnInfo[specs->ColumnIndex];
const ImGuiPerfToolBatch* batch_a = &tool->_Batches[batch_index_a];
const ImGuiPerfToolBatch* batch_b = &tool->_Batches[batch_index_b];
ImGuiPerfToolEntry* a = &batch_a->Entries.Data[entry_index_a];
ImGuiPerfToolEntry* b = &batch_b->Entries.Data[entry_index_b];
if (specs->SortDirection == ImGuiSortDirection_Ascending)
ImSwap(a, b);
int result = 0;
switch (col_info.Type)
{
case ImGuiDataType_S32:
result = col_info.GetValue<int>(a) - col_info.GetValue<int>(b);
break;
case ImGuiDataType_U64:
result = (int)(col_info.GetValue<ImU64>(a) - col_info.GetValue<ImU64>(b));
break;
case ImGuiDataType_Float:
result = (int)((col_info.GetValue<float>(a) - col_info.GetValue<float>(b)) * 1000.0f);
break;
case ImGuiDataType_Double:
result = (int)((col_info.GetValue<double>(a) - col_info.GetValue<double>(b)) * 1000.0);
break;
case ImGuiDataType_COUNT:
result = strcmp(col_info.GetValue<const char*>(a), col_info.GetValue<const char*>(b));
break;
default:
IM_ASSERT(false);
}
if (result != 0)
return result;
}
return mono_index_a - mono_index_b;
}
// Dates are in format "YYYY-MM-DD"
static bool IsDateValid(const char* date)
{
if (date[4] != '-' || date[7] != '-')
return false;
for (int i = 0; i < 10; i++)
{
if (i == 4 || i == 7)
continue;
if (date[i] < '0' || date[i] > '9')
return false;
}
return true;
}
static float FormatVsBaseline(ImGuiPerfToolEntry* entry, ImGuiPerfToolEntry* baseline_entry, Str& out_label)
{
if (baseline_entry == NULL)
{
out_label.appendf("--");
return FLT_MAX;
}
if (entry == baseline_entry)
{
out_label.append("baseline");
return FLT_MAX;
}
double percent_vs_first = 100.0 / baseline_entry->DtDeltaMs * entry->DtDeltaMs;
double dt_change = -(100.0 - percent_vs_first);
if (dt_change == INFINITY)
out_label.appendf("--");
else if (ImAbs(dt_change) > 0.001f)
out_label.appendf("%+.2lf%% (%s)", dt_change, dt_change < 0.0f ? "faster" : "slower");
else
out_label.appendf("==");
return (float)dt_change;
}
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
static void PerfToolFormatBuildInfo(ImGuiPerfTool* perftool, Str* result, ImGuiPerfToolBatch* batch)
{
IM_ASSERT(perftool != NULL);
IM_ASSERT(result != NULL);
IM_ASSERT(batch != NULL);
IM_ASSERT(batch->Entries.Size > 0);
ImGuiPerfToolEntry* entry = &batch->Entries.Data[0];
Str64f legend_format("x%%-%dd %%-%ds %%-%ds %%-%ds %%-%ds %%-%ds %%s%%s%%s%%s(%%-%dd sample%%s)%%s",
perftool->_AlignStress, perftool->_AlignType, perftool->_AlignCpu, perftool->_AlignOs, perftool->_AlignCompiler,
perftool->_AlignBranch, perftool->_AlignSamples);
result->appendf(legend_format.c_str(), entry->PerfStressAmount, entry->BuildType, entry->Cpu, entry->OS,
entry->Compiler, entry->GitBranchName, entry->Date,
#if 0
// Show min-max dates.
perftool->_CombineByBuildInfo ? " - " : "",
entry->DateMax ? entry->DateMax : "",
#else
"", "",
#endif
*entry->Date ? " " : "",
batch->NumSamples,
batch->NumSamples > 1 ? "s" : "", // Singular/plural form of "sample(s)"
batch->NumSamples > 1 || perftool->_AlignSamples == 1 ? "" : " " // Space after legend entry to separate * marking baseline
);
}
#endif
static int PerfToolCountBuilds(ImGuiPerfTool* perftool, bool only_visible)
{
int num_builds = 0;
ImU64 build_id = 0;
for (ImGuiPerfToolEntry& entry : perftool->_SrcData)
{
if (build_id != GetBuildID(&entry))
{
if (!only_visible || perftool->_IsVisibleBuild(&entry))
num_builds++;
build_id = GetBuildID(&entry);
}
}
return num_builds;
}
static bool InputDate(const char* label, char* date, int date_len, bool valid)
{
ImGui::SetNextItemWidth(ImGui::CalcTextSize("YYYY-MM-DD").x + ImGui::GetStyle().FramePadding.x * 2.0f);
const bool date_valid = date[0] == 0 || (IsDateValid(date) && valid);
if (!date_valid)
{
ImGui::PushStyleColor(ImGuiCol_Border, IM_COL32(255, 0, 0, 255));
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1);
}
bool date_changed = ImGui::InputTextWithHint(label, "YYYY-MM-DD", date, date_len);
if (!date_valid)
{
ImGui::PopStyleVar();
ImGui::PopStyleColor();
}
return date_changed;
}
static void FormatDate(ImU64 microseconds, char* buf, size_t buf_size)
{
time_t timestamp = (time_t)(microseconds / 1000000);
tm* time = localtime(&timestamp);
ImFormatString(buf, buf_size, "%04d-%02d-%02d", time->tm_year + 1900, time->tm_mon + 1, time->tm_mday);
}
static void FormatDateAndTime(ImU64 microseconds, char* buf, size_t buf_size)
{
time_t timestamp = (time_t)(microseconds / 1000000);
tm* time = localtime(&timestamp);
ImFormatString(buf, buf_size, "%04d-%02d-%02d %02d:%02d:%02d", time->tm_year + 1900, time->tm_mon + 1, time->tm_mday, time->tm_hour, time->tm_min, time->tm_sec);
}
static void RenderFilterInput(ImGuiPerfTool* perf, const char* hint, float width = -FLT_MIN)
{
if (ImGui::IsWindowAppearing())
strcpy(perf->_Filter, "");
ImGui::SetNextItemWidth(width);
ImGui::InputTextWithHint("##filter", hint, perf->_Filter, IM_ARRAYSIZE(perf->_Filter));
if (ImGui::IsWindowAppearing())
ImGui::SetKeyboardFocusHere();
}
static bool RenderMultiSelectFilter(ImGuiPerfTool* perf, const char* filter_hint, ImVector<const char*>* labels)
{
ImGuiContext& g = *ImGui::GetCurrentContext();
ImGuiIO& io = ImGui::GetIO();
ImGuiStorage& visibility = perf->_Visibility;
bool modified = false;
RenderFilterInput(perf, filter_hint, -(ImGui::CalcTextSize("(?)").x + g.Style.ItemSpacing.x));
ImGui::SameLine();
ImGui::TextDisabled("(?)");
if (ImGui::IsItemHovered())
ImGui::SetTooltip("Hold CTRL to invert other items.\nHold SHIFT to close popup instantly.");
// Keep popup open for multiple actions if SHIFT is pressed.
if (!io.KeyShift)
ImGui::PushItemFlag(ImGuiItemFlags_SelectableDontClosePopup, true);
if (ImGui::MenuItem("Show All"))
{
for (const char* label : *labels)
if (strstr(label, perf->_Filter) != NULL)
visibility.SetBool(ImHashStr(label), true);
modified = true;
}
if (ImGui::MenuItem("Hide All"))
{
for (const char* label : *labels)
if (strstr(label, perf->_Filter) != NULL)
visibility.SetBool(ImHashStr(label), false);
modified = true;
}
// Render perf labels in reversed order. Labels are sorted, but stored in reversed order to render them on the plot
// from top down (ImPlot renders stuff from bottom up).
int filtered_entries = 0;
for (int i = labels->Size - 1; i >= 0; i--)
{
const char* label = (*labels)[i];
if (strstr(label, perf->_Filter) == NULL) // Filter out entries not matching a filter query
continue;
if (filtered_entries == 0)
ImGui::Separator();
ImGuiID build_id = ImHashStr(label);
bool visible = visibility.GetBool(build_id, true);
if (ImGui::MenuItem(label, NULL, &visible))
{
modified = true;
if (io.KeyCtrl)
{
for (const char* label2 : *labels)
{
ImGuiID build_id2 = ImHashStr(label2);
visibility.SetBool(build_id2, !visibility.GetBool(build_id2, true));
}
}
else
{
visibility.SetBool(build_id, !visibility.GetBool(build_id, true));
}
}
filtered_entries++;
}
if (!io.KeyShift)
ImGui::PopItemFlag();
return modified;
}
// Based on ImPlot::SetupFinish().
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
static ImRect ImPlotGetYTickRect(int t, int y = 0)
{
ImPlotContext& gp = *GImPlot;
ImPlotPlot& plot = *gp.CurrentPlot;
ImPlotAxis& ax = plot.YAxis(y);
const ImPlotTicker& tkc = ax.Ticker;
const bool opp = ax.IsOpposite();
ImRect result(1.0f, 1.0f, -1.0f, -1.0f);
if (ax.HasTickLabels())
{
const ImPlotTick& tk = tkc.Ticks[t];
const float datum = ax.Datum1 + (opp ? gp.Style.LabelPadding.x : (-gp.Style.LabelPadding.x - tk.LabelSize.x));
if (tk.ShowLabel && tk.PixelPos >= plot.PlotRect.Min.y - 1 && tk.PixelPos <= plot.PlotRect.Max.y + 1)
{
ImVec2 start(datum, tk.PixelPos - 0.5f * tk.LabelSize.y);
result.Min = start;
result.Max = start + tk.LabelSize;
}
}
return result;
}
#endif // #if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
ImGuiPerfTool::ImGuiPerfTool()
{
_CsvParser = IM_NEW(ImGuiCsvParser)();
Clear();
}
ImGuiPerfTool::~ImGuiPerfTool()
{
_SrcData.clear_destruct();
_Batches.clear_destruct();
IM_DELETE(_CsvParser);
}
void ImGuiPerfTool::AddEntry(ImGuiPerfToolEntry* entry)
{
if (strcmp(_FilterDateFrom, entry->Date) > 0)
ImStrncpy(_FilterDateFrom, entry->Date, IM_ARRAYSIZE(_FilterDateFrom));
if (strcmp(_FilterDateTo, entry->Date) < 0)
ImStrncpy(_FilterDateTo, entry->Date, IM_ARRAYSIZE(_FilterDateTo));
_SrcData.push_back(*entry);
_Batches.clear_destruct();
}
void ImGuiPerfTool::_Rebuild()
{
if (_SrcData.empty())
return;
ImGuiStorage& temp_set = _TempSet;
_Labels.resize(0);
_LabelsVisible.resize(0);
_InfoTableSort.resize(0);
_Batches.clear_destruct();
_InfoTableSortDirty = true;
// Gather all visible labels. Legend batches will store data in this order.
temp_set.Data.resize(0); // name_id:IsLabelSeen
for (ImGuiPerfToolEntry& entry : _SrcData)
{
ImGuiID name_id = ImHashStr(entry.TestName);
if (!temp_set.GetBool(name_id))
{
temp_set.SetBool(name_id, true);
_Labels.push_back(entry.TestName);
if (_IsVisibleTest(entry.TestName))
_LabelsVisible.push_front(entry.TestName);
}
}
int num_visible_labels = _LabelsVisible.Size;
// Labels are sorted in reverse order so they appear to be oredered from top down.
ImQsort(_Labels.Data, _Labels.Size, sizeof(const char*), &PerfToolComparerStr);
ImQsort(_LabelsVisible.Data, num_visible_labels, sizeof(const char*), &PerfToolComparerStr);
// _SrcData vector stores sorted raw entries of imgui_perflog.csv. Sorting is very important,
// algorithm depends on data being correctly sorted. Sorting _SrcData is OK, because it is only
// ever appended to and never written out to disk. Entries are sorted by multiple criteria,
// in specified order:
// 1. By branch name
// 2. By build ID
// 3. By run timestamp
// 4. By test name
// This results in a neatly partitioned dataset where similar data is grouped together and where perf test order
// is consistent in all batches. Sorting by build ID _before_ timestamp is also important as we will be aggregating
// entries by build ID instead of timestamp, when appropriate display mode is enabled.
ImQsort(_SrcData.Data, _SrcData.Size, sizeof(ImGuiPerfToolEntry), &PerfToolComparerByEntryInfo);
// Sort groups of entries into batches.
const bool combine_by_build_info = _DisplayType == ImGuiPerfToolDisplayType_CombineByBuildInfo;
_LabelBarCounts.Data.resize(0);
// Process all batches. `entry` is always a first batch element (guaranteed by _SrcData being sorted by timestamp).
// At the end of this loop we fast-forward until next batch (first entry having different batch id (which is a
// timestamp or build info)).
for (ImGuiPerfToolEntry* entry = _SrcData.begin(); entry < _SrcData.end();)
{
// Filtered out entries can be safely ignored. Note that entry++ does not follow logic of fast-forwarding to the
// next batch, as found at the end of this loop. This is OK, because all entries belonging to a same batch will
// also have same date.
if ((_FilterDateFrom[0] && strcmp(entry->Date, _FilterDateFrom) < 0) || (_FilterDateTo[0] && strcmp(entry->Date, _FilterDateTo) > 0))
{
entry++;
continue;
}
_Batches.push_back(ImGuiPerfToolBatch());
ImGuiPerfToolBatch& batch = _Batches.back();
batch.BatchID = GetBatchID(this, entry);
batch.Entries.resize(num_visible_labels);
// Fill in defaults. Done once before data aggregation loop, because same entry may be touched multiple times in
// the following loop when entries are being combined by build info.
for (int i = 0; i < num_visible_labels; i++)
{
ImGuiPerfToolEntry* e = &batch.Entries.Data[i];
*e = *entry;
e->DtDeltaMs = 0;
e->NumSamples = 0;
e->LabelIndex = i;
e->TestName = _LabelsVisible.Data[i];
}
// Find perf test runs for this particular batch and accumulate them.
for (int i = 0; i < num_visible_labels; i++)
{
// This inner loop walks all entries that belong to current batch. Due to sorting we are sure that batch
// always starts with `entry`, and all entries that belong to a batch (whether we combine by build info or not)
// will be grouped in _SrcData.
ImGuiPerfToolEntry* aggregate = &batch.Entries.Data[i];
for (ImGuiPerfToolEntry* e = entry; e < _SrcData.end() && GetBatchID(this, e) == batch.BatchID; e++)
{
if (strcmp(e->TestName, aggregate->TestName) != 0)
continue;
aggregate->DtDeltaMs += e->DtDeltaMs;
aggregate->NumSamples++;
aggregate->DtDeltaMsMin = ImMin(aggregate->DtDeltaMsMin, e->DtDeltaMs);
aggregate->DtDeltaMsMax = ImMax(aggregate->DtDeltaMsMax, e->DtDeltaMs);
}
}
// In case data is combined by build info, DtDeltaMs will be a sum of all combined entries. Average it out.
if (combine_by_build_info)
for (int i = 0; i < num_visible_labels; i++)
{
ImGuiPerfToolEntry* aggregate = &batch.Entries.Data[i];
if (aggregate->NumSamples > 0)
aggregate->DtDeltaMs /= aggregate->NumSamples;
}
// Advance to the next batch.
batch.NumSamples = 1;
if (combine_by_build_info)
{
ImU64 last_timestamp = entry->Timestamp;
for (ImGuiID build_id = GetBuildID(entry); entry < _SrcData.end() && build_id == GetBuildID(entry);)
{
// Also count how many unique batches participate in this aggregated batch.
if (entry->Timestamp != last_timestamp)
{
batch.NumSamples++;
last_timestamp = entry->Timestamp;
}
entry++;
}
}
else
{
for (ImU64 timestamp = entry->Timestamp; entry < _SrcData.end() && timestamp == entry->Timestamp;)
entry++;
}
}
// Create man entries for every batch.
// Pushed after sorting so they are always at the start of the chart.
const char* mean_labels[] = { "harmonic mean", "arithmetic mean", "geometric mean" };
int num_visible_mean_labels = 0;
for (const char* label : mean_labels)
{
_Labels.push_back(label);
if (_IsVisibleTest(label))
{
_LabelsVisible.push_back(label);
num_visible_mean_labels++;
}
}
for (ImGuiPerfToolBatch& batch : _Batches)
{
double delta_sum = 0.0;
double delta_prd = 1.0;
double delta_rec = 0.0;
for (int i = 0; i < batch.Entries.Size; i++)
{
ImGuiPerfToolEntry* entry = &batch.Entries.Data[i];
delta_sum += entry->DtDeltaMs;
delta_prd *= entry->DtDeltaMs;
delta_rec += 1 / entry->DtDeltaMs;
}
int visible_label_i = 0;
for (int i = 0; i < IM_ARRAYSIZE(mean_labels); i++)
{
if (!_IsVisibleTest(mean_labels[i]))
continue;
batch.Entries.push_back(ImGuiPerfToolEntry());
ImGuiPerfToolEntry* mean_entry = &batch.Entries.back();
*mean_entry = batch.Entries.Data[0];
mean_entry->LabelIndex = _LabelsVisible.Size - num_visible_mean_labels + visible_label_i;
mean_entry->TestName = _LabelsVisible.Data[mean_entry->LabelIndex];
mean_entry->GitBranchName = "";
mean_entry->BuildType = "";
mean_entry->Compiler = "";
mean_entry->OS = "";
mean_entry->Cpu = "";
mean_entry->Date = "";
visible_label_i++;
if (i == 0)
mean_entry->DtDeltaMs = num_visible_labels / delta_rec;
else if (i == 1)
mean_entry->DtDeltaMs = delta_sum / num_visible_labels;
else if (i == 2)
mean_entry->DtDeltaMs = pow(delta_prd, 1.0 / num_visible_labels);
else
IM_ASSERT(0);
}
IM_ASSERT(batch.Entries.Size == _LabelsVisible.Size);
}
// Find number of bars (batches) each label will render.
for (ImGuiPerfToolBatch& batch : _Batches)
{
if (!_IsVisibleBuild(&batch))
continue;
for (ImGuiPerfToolEntry& entry : batch.Entries)
{
ImGuiID label_id = ImHashStr(entry.TestName);
int num_bars = _LabelBarCounts.GetInt(label_id) + 1;
_LabelBarCounts.SetInt(label_id, num_bars);
}
}
// Index branches, used for per-branch colors.
temp_set.Data.resize(0); // ImHashStr(branch_name):linear_index
int branch_index_last = 0;
_BaselineBatchIndex = -1;
for (ImGuiPerfToolBatch& batch : _Batches)
{
if (batch.Entries.empty())
continue;
ImGuiPerfToolEntry* entry = &batch.Entries.Data[0];
ImGuiID branch_hash = ImHashStr(entry->GitBranchName);
batch.BranchIndex = temp_set.GetInt(branch_hash, -1);
if (batch.BranchIndex < 0)
{
batch.BranchIndex = branch_index_last++;
temp_set.SetInt(branch_hash, batch.BranchIndex);
}
if (_BaselineBatchIndex < 0)
if ((combine_by_build_info && GetBuildID(entry) == _BaselineBuildId) || _BaselineTimestamp == entry->Timestamp)
_BaselineBatchIndex = _Batches.index_from_ptr(&batch);
}
// When per-branch colors are enabled we aggregate sample counts and set them to all batches with identical build info.
temp_set.Data.resize(0); // build_id:TotalSamples
if (_DisplayType == ImGuiPerfToolDisplayType_PerBranchColors)
{
// Aggregate totals to temp_set.
for (ImGuiPerfToolBatch& batch : _Batches)
{
ImGuiID build_id = GetBuildID(&batch);
temp_set.SetInt(build_id, temp_set.GetInt(build_id, 0) + batch.NumSamples);
}
// Fill in batch sample counts.
for (ImGuiPerfToolBatch& batch : _Batches)
{
ImGuiID build_id = GetBuildID(&batch);
batch.NumSamples = temp_set.GetInt(build_id, 1);
}
}
_NumVisibleBuilds = PerfToolCountBuilds(this, true);
_NumUniqueBuilds = PerfToolCountBuilds(this, false);
_CalculateLegendAlignment();
temp_set.Data.resize(0);
}
void ImGuiPerfTool::Clear()
{
_Labels.clear();
_LabelsVisible.clear();
_Batches.clear_destruct();
_Visibility.Clear();
_SrcData.clear_destruct();
_CsvParser->Clear();
ImStrncpy(_FilterDateFrom, "9999-99-99", IM_ARRAYSIZE(_FilterDateFrom));
ImStrncpy(_FilterDateTo, "0000-00-00", IM_ARRAYSIZE(_FilterDateFrom));
}
bool ImGuiPerfTool::LoadCSV(const char* filename)
{
if (filename == NULL)
filename = IMGUI_PERFLOG_DEFAULT_FILENAME;
Clear();
ImGuiCsvParser* parser = _CsvParser;
parser->Columns = 11;
if (!parser->Load(filename))
return false;
// Read perf test entries from CSV
for (int row = 0; row < parser->Rows; row++)
{
ImGuiPerfToolEntry entry;
int col = 0;
sscanf(parser->GetCell(row, col++), "%llu", &entry.Timestamp);
entry.Category = parser->GetCell(row, col++);
entry.TestName = parser->GetCell(row, col++);
sscanf(parser->GetCell(row, col++), "%lf", &entry.DtDeltaMs);
sscanf(parser->GetCell(row, col++), "x%d", &entry.PerfStressAmount);
entry.GitBranchName = parser->GetCell(row, col++);
entry.BuildType = parser->GetCell(row, col++);
entry.Cpu = parser->GetCell(row, col++);
entry.OS = parser->GetCell(row, col++);
entry.Compiler = parser->GetCell(row, col++);
entry.Date = parser->GetCell(row, col++);
AddEntry(&entry);
}
return true;
}
void ImGuiPerfTool::ViewOnly(const char** perf_names)
{
// Data would not be built if we tried to view perftool of a particular test without first opening perftool via button. We need data to be built to hide perf tests.
if (_Batches.empty())
_Rebuild();
// Hide other perf tests.
for (const char* label : _Labels)
{
bool visible = false;
for (const char** p_name = perf_names; !visible && *p_name; p_name++)
visible |= strcmp(label, *p_name) == 0;
_Visibility.SetBool(ImHashStr(label), visible);
}
}
void ImGuiPerfTool::ViewOnly(const char* perf_name)
{
const char* names[] = { perf_name, NULL };
ViewOnly(names);
}
ImGuiPerfToolEntry* ImGuiPerfTool::GetEntryByBatchIdx(int idx, const char* perf_name)
{
if (idx < 0)
return NULL;
IM_ASSERT(idx < _Batches.Size);
ImGuiPerfToolBatch& batch = _Batches.Data[idx];
for (int i = 0; i < batch.Entries.Size; i++)
if (ImGuiPerfToolEntry* entry = &batch.Entries.Data[i])
if (strcmp(entry->TestName, perf_name) == 0)
return entry;
return NULL;
}
bool ImGuiPerfTool::_IsVisibleBuild(ImGuiPerfToolBatch* batch)
{
IM_ASSERT(batch != NULL);
if (batch->Entries.empty())
return false; // All entries are hidden.
return _IsVisibleBuild(&batch->Entries.Data[0]);
}
bool ImGuiPerfTool::_IsVisibleBuild(ImGuiPerfToolEntry* entry)
{
return _Visibility.GetBool(ImHashStr(entry->GitBranchName), true) &&
_Visibility.GetBool(ImHashStr(entry->Compiler), true) &&
_Visibility.GetBool(ImHashStr(entry->Cpu), true) &&
_Visibility.GetBool(ImHashStr(entry->OS), true) &&
_Visibility.GetBool(ImHashStr(entry->BuildType), true);
}
bool ImGuiPerfTool::_IsVisibleTest(const char* test_name)
{
return _Visibility.GetBool(ImHashStr(test_name), true);
}
void ImGuiPerfTool::_CalculateLegendAlignment()
{
// Estimate paddings for legend format so it looks nice and aligned
// FIXME: Rely on font being monospace. May need to recalculate every frame on a per-need basis based on font?
_AlignStress = _AlignType = _AlignCpu = _AlignOs = _AlignCompiler = _AlignBranch = _AlignSamples = 0;
for (ImGuiPerfToolBatch& batch : _Batches)
{
if (batch.Entries.empty())
continue;
ImGuiPerfToolEntry* entry = &batch.Entries.Data[0];
if (!_IsVisibleBuild(entry))
continue;
_AlignStress = ImMax(_AlignStress, (int)ceil(log10(entry->PerfStressAmount)));
_AlignType = ImMax(_AlignType, (int)strlen(entry->BuildType));
_AlignCpu = ImMax(_AlignCpu, (int)strlen(entry->Cpu));
_AlignOs = ImMax(_AlignOs, (int)strlen(entry->OS));
_AlignCompiler = ImMax(_AlignCompiler, (int)strlen(entry->Compiler));
_AlignBranch = ImMax(_AlignBranch, (int)strlen(entry->GitBranchName));
_AlignSamples = ImMax(_AlignSamples, (int)Str16f("%d", entry->NumSamples).length());
}
}
bool ImGuiPerfTool::SaveHtmlReport(const char* file_name, const char* image_file)
{
if (!ImFileCreateDirectoryChain(file_name, ImPathFindFilename(file_name)))
return false;
FILE* fp = fopen(file_name, "w+");
if (fp == NULL)
return false;
fprintf(fp, "<!doctype html>\n"
"<html>\n"
"<head>\n"
" <meta charset=\"utf-8\"/>\n"
" <title>Dear ImGui perf report</title>\n"
"</head>\n"
"<body>\n"
" <pre id=\"content\">\n");
// Embed performance chart.
fprintf(fp, "## Dear ImGui perf report\n\n");
if (image_file != NULL)
{
FILE* fp_img = fopen(image_file, "rb");
if (fp_img != NULL)
{
ImVector<char> image_buffer;
ImVector<char> base64_buffer;
fseek(fp_img, 0, SEEK_END);
image_buffer.resize((int)ftell(fp_img));
base64_buffer.resize(((image_buffer.Size / 3) + 1) * 4 + 1);
rewind(fp_img);
fread(image_buffer.Data, 1, image_buffer.Size, fp_img);
fclose(fp_img);
int len = ImStrBase64Encode((unsigned char*)image_buffer.Data, base64_buffer.Data, image_buffer.Size);
base64_buffer.Data[len] = 0;
fprintf(fp, "![](data:image/png;base64,%s)\n\n", base64_buffer.Data);
}
}
// Print info table.
const bool combine_by_build_info = _DisplayType == ImGuiPerfToolDisplayType_CombineByBuildInfo;
for (const auto& column_info : PerfToolColumnInfo)
if (column_info.ShowAlways || combine_by_build_info)
fprintf(fp, "| %s ", column_info.Title);
fprintf(fp, "|\n");
for (const auto& column_info : PerfToolColumnInfo)
if (column_info.ShowAlways || combine_by_build_info)
fprintf(fp, "| -- ");
fprintf(fp, "|\n");
for (int row_index = _InfoTableSort.Size - 1; row_index >= 0; row_index--)
{
int batch_index_sorted, entry_index_sorted;
_UnpackSortedKey(_InfoTableSort[row_index], &batch_index_sorted, &entry_index_sorted);
ImGuiPerfToolBatch* batch = &_Batches[batch_index_sorted];
ImGuiPerfToolEntry* entry = &batch->Entries[entry_index_sorted];
const char* test_name = entry->TestName;
if (!_IsVisibleBuild(entry) || entry->NumSamples == 0)
continue;
ImGuiPerfToolEntry* baseline_entry = GetEntryByBatchIdx(_BaselineBatchIndex, test_name);
for (int i = 0; i < IM_ARRAYSIZE(PerfToolColumnInfo); i++)
{
Str30f label("");
const ImGuiPerfToolColumnInfo& column_info = PerfToolColumnInfo[i];
if (column_info.ShowAlways || combine_by_build_info)
{
switch (i)
{
case 0:
{
char date[64];
FormatDateAndTime(entry->Timestamp, date, IM_ARRAYSIZE(date));
fprintf(fp, "| %s ", date);
break;
}
case 1: fprintf(fp, "| %s ", entry->TestName); break;
case 2: fprintf(fp, "| %s ", entry->GitBranchName); break;
case 3: fprintf(fp, "| %s ", entry->Compiler); break;
case 4: fprintf(fp, "| %s ", entry->OS); break;
case 5: fprintf(fp, "| %s ", entry->Cpu); break;
case 6: fprintf(fp, "| %s ", entry->BuildType); break;
case 7: fprintf(fp, "| x%d ", entry->PerfStressAmount); break;
case 8: fprintf(fp, "| %.2f ", entry->DtDeltaMs); break;
case 9: fprintf(fp, "| %.2f ", entry->DtDeltaMsMin); break;
case 10: fprintf(fp, "| %.2f ", entry->DtDeltaMsMax); break;
case 11: fprintf(fp, "| %d ", entry->NumSamples); break;
case 12: FormatVsBaseline(entry, baseline_entry, label); fprintf(fp, "| %s ", label.c_str()); break;
default: IM_ASSERT(0); break;
}
}
}
fprintf(fp, "|\n");
}
fprintf(fp, "</pre>\n"
" <script src=\"https://cdn.jsdelivr.net/npm/marked@4.0.0/marked.min.js\"></script>\n"
" <script>\n"
" var content = document.getElementById('content');\n"
" content.innerHTML = marked.parse(content.innerText);\n"
" </script>\n"
"</body>\n"
"</html>\n");
fclose(fp);
return true;
}
void ImGuiPerfTool::_SetBaseline(int batch_index)
{
IM_ASSERT(batch_index < _Batches.Size);
_BaselineBatchIndex = batch_index;
if (batch_index >= 0)
{
_BaselineTimestamp = _Batches.Data[batch_index].Entries.Data[0].Timestamp;
_BaselineBuildId = GetBuildID(&_Batches.Data[batch_index]);
}
}
//-------------------------------------------------------------------------
// [SECTION] USER INTERFACE
//-------------------------------------------------------------------------
void ImGuiPerfTool::ShowPerfToolWindow(ImGuiTestEngine* engine, bool* p_open)
{
if (!ImGui::Begin("Dear ImGui Perf Tool", p_open))
{
ImGui::End();
return;
}
if (ImGui::IsWindowAppearing() && Empty())
LoadCSV();
ImGuiStyle& style = ImGui::GetStyle();
// -----------------------------------------------------------------------------------------------------------------
// Render utility buttons
// -----------------------------------------------------------------------------------------------------------------
// Date filter
ImGui::AlignTextToFramePadding();
ImGui::TextUnformatted("Date Range:");
ImGui::SameLine();
bool dirty = _Batches.empty();
bool date_changed = InputDate("##date-from", _FilterDateFrom, IM_ARRAYSIZE(_FilterDateFrom),
(strcmp(_FilterDateFrom, _FilterDateTo) <= 0 || !*_FilterDateTo));
if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Right))
ImGui::OpenPopup("InputDate From Menu");
ImGui::SameLine(0, 0.0f);
ImGui::TextUnformatted("..");
ImGui::SameLine(0, 0.0f);
date_changed |= InputDate("##date-to", _FilterDateTo, IM_ARRAYSIZE(_FilterDateTo),
(strcmp(_FilterDateFrom, _FilterDateTo) <= 0 || !*_FilterDateFrom));
if (date_changed)
{
dirty = (!_FilterDateFrom[0] || IsDateValid(_FilterDateFrom)) && (!_FilterDateTo[0] || IsDateValid(_FilterDateTo));
if (_FilterDateFrom[0] && _FilterDateTo[0])
dirty &= strcmp(_FilterDateFrom, _FilterDateTo) <= 0;
}
if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Right))
ImGui::OpenPopup("InputDate To Menu");
ImGui::SameLine();
for (int i = 0; i < 2; i++)
{
if (ImGui::BeginPopup(i == 0 ? "InputDate From Menu" : "InputDate To Menu"))
{
char* date = i == 0 ? _FilterDateFrom : _FilterDateTo;
int date_size = i == 0 ? IM_ARRAYSIZE(_FilterDateFrom) : IM_ARRAYSIZE(_FilterDateTo);
if (i == 0 && ImGui::MenuItem("Set Min"))
{
for (ImGuiPerfToolEntry& entry : _SrcData)
if (strcmp(date, entry.Date) > 0)
{
ImStrncpy(date, entry.Date, date_size);
dirty = true;
}
}
if (ImGui::MenuItem("Set Max"))
{
for (ImGuiPerfToolEntry& entry : _SrcData)
if (strcmp(date, entry.Date) < 0)
{
ImStrncpy(date, entry.Date, date_size);
dirty = true;
}
}
if (ImGui::MenuItem("Set Today"))
{
time_t now = time(NULL);
FormatDate((ImU64)now * 1000000, date, date_size);
dirty = true;
}
ImGui::EndPopup();
}
}
if (ImGui::Button(Str64f("Filter builds (%d/%d)###Filter builds", _NumVisibleBuilds, _NumUniqueBuilds).c_str()))
ImGui::OpenPopup("Filter builds");
if (ImGui::IsItemHovered())
ImGui::SetTooltip("Hide or show individual builds.");
ImGui::SameLine();
if (ImGui::Button(Str64f("Filter tests (%d/%d)###Filter tests", _LabelsVisible.Size, _Labels.Size).c_str()))
ImGui::OpenPopup("Filter perfs");
if (ImGui::IsItemHovered())
ImGui::SetTooltip("Hide or show individual tests.");
ImGui::SameLine();
dirty |= Button3("Combine", (int*)&_DisplayType);
if (ImGui::IsItemHovered())
{
ImGui::BeginTooltip();
ImGui::RadioButton("Display each run separately", _DisplayType == ImGuiPerfToolDisplayType_Simple);
ImGui::RadioButton("Use one color per branch. Disables baseline comparisons!", _DisplayType == ImGuiPerfToolDisplayType_PerBranchColors);
ImGui::RadioButton("Combine multiple runs with same build info into one averaged build entry.", _DisplayType == ImGuiPerfToolDisplayType_CombineByBuildInfo);
ImGui::EndTooltip();
}
ImGui::SameLine();
if (_ReportGenerating && ImGuiTestEngine_IsTestQueueEmpty(engine))
{
_ReportGenerating = false;
ImOsOpenInShell(PerfToolReportDefaultOutputPath);
}
if (_Batches.empty())
ImGui::BeginDisabled();
if (ImGui::Button("Html Export"))
{
// In order to capture a screenshot Report is saved by executing a "capture_perf_report" test.
_ReportGenerating = true;
ImGuiTestEngine_QueueTests(engine, ImGuiTestGroup_Tests, "capture_perf_report");
}
if (_Batches.empty())
ImGui::EndDisabled();
ImGui::SameLine();
if (ImGui::IsItemHovered())
ImGui::SetTooltip("Generate a report and open it in the browser.");
// Align help button to the right.
float help_pos = ImGui::GetWindowContentRegionMax().x - style.FramePadding.x * 2 - ImGui::CalcTextSize("(?)").x;
if (help_pos > ImGui::GetCursorPosX())
ImGui::SetCursorPosX(help_pos);
ImGui::TextDisabled("(?)");
if (ImGui::IsItemHovered())
{
ImGui::BeginTooltip();
ImGui::BulletText("To change baseline build, double-click desired build in the legend.");
ImGui::BulletText("Extra information is displayed when hovering bars of a particular perf test and holding SHIFT.");
ImGui::BulletText("Double-click plot to fit plot into available area.");
ImGui::EndTooltip();
}
if (ImGui::BeginPopup("Filter builds"))
{
ImGuiStorage& temp_set = _TempSet;
temp_set.Data.resize(0); // ImHashStr(BuildProperty):seen
static const char* columns[] = { "Branch", "Build", "CPU", "OS", "Compiler" };
bool show_all = ImGui::Button("Show All");
ImGui::SameLine();
bool hide_all = ImGui::Button("Hide All");
if (ImGui::BeginTable("Builds", IM_ARRAYSIZE(columns), ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit))
{
for (int i = 0; i < IM_ARRAYSIZE(columns); i++)
ImGui::TableSetupColumn(columns[i]);
ImGui::TableHeadersRow();
// Find columns with nothing checked.
bool checked_any[] = { false, false, false, false, false };
for (ImGuiPerfToolEntry& entry : _SrcData)
{
const char* properties[] = { entry.GitBranchName, entry.BuildType, entry.Cpu, entry.OS, entry.Compiler };
for (int i = 0; i < IM_ARRAYSIZE(properties); i++)
{
ImGuiID hash = ImHashStr(properties[i]);
checked_any[i] |= _Visibility.GetBool(hash, true);
}
}
int property_offsets[] =
{
offsetof(ImGuiPerfToolEntry, GitBranchName),
offsetof(ImGuiPerfToolEntry, BuildType),
offsetof(ImGuiPerfToolEntry, Cpu),
offsetof(ImGuiPerfToolEntry, OS),
offsetof(ImGuiPerfToolEntry, Compiler),
};
ImGui::TableNextRow();
for (int i = 0; i < IM_ARRAYSIZE(property_offsets); i++)
{
ImGui::TableSetColumnIndex(i);
for (ImGuiPerfToolEntry& entry : _SrcData)
{
const char* property = *(const char**)((const char*)&entry + property_offsets[i]);
ImGuiID hash = ImHashStr(property);
if (temp_set.GetBool(hash))
continue;
temp_set.SetBool(hash, true);
bool visible = _Visibility.GetBool(hash, true) || show_all;
if (hide_all)
visible = false;
bool modified = ImGui::Checkbox(property, &visible) || show_all || hide_all;
_Visibility.SetBool(hash, visible);
if (modified)
{
_CalculateLegendAlignment();
_NumVisibleBuilds = PerfToolCountBuilds(this, true);
dirty = true;
}
if (!checked_any[i])
{
ImGui::TableSetBgColor(ImGuiTableBgTarget_CellBg, ImColor(1.0f, 0.0f, 0.0f, 0.2f));
if (ImGui::TableGetColumnFlags() & ImGuiTableColumnFlags_IsHovered)
ImGui::SetTooltip("Check at least one item in each column to see any data.");
}
}
}
ImGui::EndTable();
}
ImGui::EndPopup();
}
if (ImGui::BeginPopup("Filter perfs"))
{
dirty |= RenderMultiSelectFilter(this, "Filter by perf test", &_Labels);
if (ImGui::IsKeyPressed(ImGuiKey_Escape))
ImGui::CloseCurrentPopup();
ImGui::EndPopup();
}
if (dirty)
_Rebuild();
// Rendering a plot of empty dataset is not possible.
if (_Batches.empty() || _LabelsVisible.Size == 0 || _NumVisibleBuilds == 0)
{
ImGui::TextUnformatted("No data is available. Run some perf tests or adjust filter settings.");
}
else
{
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
// Splitter between two following child windows is rendered first.
float plot_height = 0.0f;
float& table_height = _InfoTableHeight;
ImGui::Splitter("splitter", &plot_height, &table_height, ImGuiAxis_Y, +1);
// Double-click to move splitter to bottom
if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
{
table_height = 0;
plot_height = ImGui::GetContentRegionAvail().y - style.ItemSpacing.y;
ImGui::ClearActiveID();
}
// Render entries plot
if (ImGui::BeginChild(ImGui::GetID("plot"), ImVec2(0, plot_height)))
_ShowEntriesPlot();
ImGui::EndChild();
// Render entries tables
if (table_height > 0.0f)
{
if (ImGui::BeginChild(ImGui::GetID("info-table"), ImVec2(0, table_height)))
_ShowEntriesTable();
ImGui::EndChild();
}
#else
_ShowEntriesTable();
#endif
}
ImGui::End();
}
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
static double GetLabelVerticalOffset(double occupy_h, int max_visible_builds, int now_visible_builds)
{
const double h = occupy_h / (float)max_visible_builds;
double offset = -h * ((max_visible_builds - 1) * 0.5);
return (double)now_visible_builds * h + offset;
}
#endif
void ImGuiPerfTool::_ShowEntriesPlot()
{
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
ImGuiIO& io = ImGui::GetIO();
ImGuiStyle& style = ImGui::GetStyle();
Str256 label;
Str256 display_label;
ImPlot::PushStyleColor(ImPlotCol_AxisBgHovered, IM_COL32(0, 0, 0, 0));
ImPlot::PushStyleColor(ImPlotCol_AxisBgActive, IM_COL32(0, 0, 0, 0));
if (!ImPlot::BeginPlot("PerfTool", ImVec2(-1, -1), ImPlotFlags_NoTitle))
return;
ImPlot::SetupAxis(ImAxis_X1, NULL, ImPlotAxisFlags_NoTickLabels);
if (_LabelsVisible.Size > 1)
{
ImPlot::SetupAxisTicks(ImAxis_Y1, 0, _LabelsVisible.Size, _LabelsVisible.Size, _LabelsVisible.Data);
}
else if (_LabelsVisible.Size == 1)
{
const char* labels[] = { _LabelsVisible[0], "" };
ImPlot::SetupAxisTicks(ImAxis_Y1, 0, _LabelsVisible.Size, 2, labels);
}
ImPlot::SetupLegend(ImPlotLocation_NorthEast);
// Amount of vertical space bars of one label will occupy. 1.0 would leave no space between bars of adjacent labels.
const float occupy_h = 0.8f;
// Plot bars
bool legend_hovered = false;
ImGuiStorage& temp_set = _TempSet;
temp_set.Data.resize(0); // ImHashStr(TestName):now_visible_builds_i
int current_baseline_batch_index = _BaselineBatchIndex; // Cache this value before loop, so toggling it does not create flicker.
for (int batch_index = 0; batch_index < _Batches.Size; batch_index++)
{
ImGuiPerfToolBatch& batch = _Batches[batch_index];
if (!_IsVisibleBuild(&batch.Entries.Data[0]))
continue;
// Plot bars.
label.clear();
display_label.clear();
PerfToolFormatBuildInfo(this, &label, &batch);
display_label.append(label.c_str());
ImGuiID batch_label_id;
bool baseline_match = false;
if (_DisplayType == ImGuiPerfToolDisplayType_PerBranchColors)
{
// No "vs baseline" comparison for per-branch colors, because runs are combined in the legend, but not in the info table.
batch_label_id = GetBuildID(&batch);
}
else
{
batch_label_id = ImHashData(&batch.BatchID, sizeof(batch.BatchID));
baseline_match = current_baseline_batch_index == batch_index;
}
display_label.appendf("%s###%08X", baseline_match ? " *" : "", batch_label_id);
// Plot all bars one by one, so batches with varying number of bars would not contain empty holes.
for (ImGuiPerfToolEntry& entry : batch.Entries)
{
if (entry.NumSamples == 0)
continue; // Dummy entry, perf did not run for this test in this batch.
ImGuiID label_id = ImHashStr(entry.TestName);
const int max_visible_builds = _LabelBarCounts.GetInt(label_id);
const int now_visible_builds = temp_set.GetInt(label_id);
temp_set.SetInt(label_id, now_visible_builds + 1);
double y_pos = (double)entry.LabelIndex + GetLabelVerticalOffset(occupy_h, max_visible_builds, now_visible_builds);
ImPlot::SetNextFillStyle(ImPlot::GetColormapColor(_DisplayType == ImGuiPerfToolDisplayType_PerBranchColors ? batch.BranchIndex : batch_index));
ImPlot::PlotBars<double>(display_label.c_str(), &entry.DtDeltaMs, &y_pos, 1, occupy_h / (double)max_visible_builds, ImPlotBarsFlags_Horizontal);
}
legend_hovered |= ImPlot::IsLegendEntryHovered(display_label.c_str());
// Set baseline.
if (ImPlot::IsLegendEntryHovered(display_label.c_str()))
{
if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
_SetBaseline(batch_index);
}
}
// Plot highlights.
ImPlotContext& gp = *GImPlot;
ImPlotPlot& plot = *gp.CurrentPlot;
_PlotHoverTest = -1;
_PlotHoverBatch = -1;
_PlotHoverTestLabel = false;
bool can_highlight = !legend_hovered && (ImPlot::IsPlotHovered() || ImPlot::IsAxisHovered(ImAxis_Y1));
ImDrawList* plot_draw_list = ImPlot::GetPlotDrawList();
// Highlight bars when hovering a label.
int hovered_label_index = -1;
for (int i = 0; i < _LabelsVisible.Size && can_highlight; i++)
{
ImRect label_rect_loose = ImPlotGetYTickRect(i); // Rect around test label
ImRect label_rect_tight; // Rect around test label, covering bar height and label area width
label_rect_tight.Min.y = ImPlot::PlotToPixels(0, (float)i + 0.5f).y;
label_rect_tight.Max.y = ImPlot::PlotToPixels(0, (float)i - 0.5f).y;
label_rect_tight.Min.x = plot.CanvasRect.Min.x;
label_rect_tight.Max.x = plot.PlotRect.Min.x;
ImRect rect_bars; // Rect around bars only
rect_bars.Min.x = plot.PlotRect.Min.x;
rect_bars.Max.x = plot.PlotRect.Max.x;
rect_bars.Min.y = ImPlot::PlotToPixels(0, (float)i + 0.5f).y;
rect_bars.Max.y = ImPlot::PlotToPixels(0, (float)i - 0.5f).y;
// Render underline signaling it is clickable. Clicks are handled when rendering info table.
if (label_rect_loose.Contains(io.MousePos))
{
ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
plot_draw_list->AddLine(ImFloor(label_rect_loose.GetBL()), ImFloor(label_rect_loose.GetBR()),
ImColor(style.Colors[ImGuiCol_Text]));
}
// Highlight bars belonging to hovered label.
if (label_rect_tight.Contains(io.MousePos))
{
plot_draw_list->AddRectFilled(rect_bars.Min, rect_bars.Max, ImColor(style.Colors[ImGuiCol_TextSelectedBg]));
_PlotHoverTestLabel = true;
_PlotHoverTest = i;
}
if (rect_bars.Contains(io.MousePos))
hovered_label_index = i;
}
// Highlight individual bars when hovering them on the plot or info table.
temp_set.Data.resize(0); // ImHashStr(hovered_label):now_visible_builds_i
if (hovered_label_index < 0)
hovered_label_index = _TableHoveredTest;
if (hovered_label_index >= 0)
{
const char* hovered_label = _LabelsVisible.Data[hovered_label_index];
ImGuiID label_id = ImHashStr(hovered_label);
for (ImGuiPerfToolBatch& batch : _Batches)
{
int batch_index = _Batches.index_from_ptr(&batch);
if (!_IsVisibleBuild(&batch))
continue;
ImGuiPerfToolEntry* entry = &batch.Entries.Data[hovered_label_index];
if (entry->NumSamples == 0)
continue; // Dummy entry, perf did not run for this test in this batch.
int max_visible_builds = _LabelBarCounts.GetInt(label_id);
const int now_visible_builds = temp_set.GetInt(label_id);
temp_set.SetInt(label_id, now_visible_builds + 1);
float h = occupy_h / (float)max_visible_builds;
float y_pos = (float)entry->LabelIndex;
y_pos += (float)GetLabelVerticalOffset(occupy_h, max_visible_builds, now_visible_builds);
ImRect rect_bar; // Rect around hovered bar only
rect_bar.Min.x = plot.PlotRect.Min.x;
rect_bar.Max.x = plot.PlotRect.Max.x;
rect_bar.Min.y = ImPlot::PlotToPixels(0, y_pos - h * 0.5f + h).y; // ImPlot y_pos is for bar center, therefore we adjust positions by half-height to get a bounding box.
rect_bar.Max.y = ImPlot::PlotToPixels(0, y_pos - h * 0.5f).y;
// Mouse is hovering label or bars of a perf test - highlight them in info table.
if (_PlotHoverTest < 0 && rect_bar.Min.y <= io.MousePos.y && io.MousePos.y < rect_bar.Max.y && io.MousePos.x > plot.PlotRect.Min.x)
{
// _LabelsVisible is inverted to make perf test order match info table order. Revert it back.
_PlotHoverTest = hovered_label_index;
_PlotHoverBatch = batch_index;
plot_draw_list->AddRectFilled(rect_bar.Min, rect_bar.Max, ImColor(style.Colors[ImGuiCol_TextSelectedBg]));
}
// Mouse is hovering a row in info table - highlight relevant bars on the plot.
if (_TableHoveredBatch == batch_index && _TableHoveredTest == hovered_label_index)
plot_draw_list->AddRectFilled(rect_bar.Min, rect_bar.Max, ImColor(style.Colors[ImGuiCol_TextSelectedBg]));
}
}
if (io.KeyShift && _PlotHoverTest >= 0)
{
// Info tooltip with delta times of each batch for a hovered test.
const char* test_name = _LabelsVisible.Data[_PlotHoverTest];
ImGui::BeginTooltip();
float w = ImGui::CalcTextSize(test_name).x;
float total_w = ImGui::GetContentRegionAvail().x;
if (total_w > w)
ImGui::SetCursorPosX(ImGui::GetCursorPosX() + (total_w - w) * 0.5f);
ImGui::TextUnformatted(test_name);
for (int i = 0; i < _Batches.Size; i++)
{
if (ImGuiPerfToolEntry* hovered_entry = GetEntryByBatchIdx(i, test_name))
ImGui::Text("%s %.3fms", label.c_str(), hovered_entry->DtDeltaMs);
else
ImGui::Text("%s --", label.c_str());
}
ImGui::EndTooltip();
}
ImPlot::EndPlot();
ImPlot::PopStyleColor(2);
#else
ImGui::TextUnformatted("Not enabled because ImPlot is not available (IMGUI_TEST_ENGINE_ENABLE_IMPLOT=0).");
#endif
}
void ImGuiPerfTool::_ShowEntriesTable()
{
ImGuiTableFlags table_flags = ImGuiTableFlags_Hideable | ImGuiTableFlags_Borders | ImGuiTableFlags_Sortable |
ImGuiTableFlags_SortMulti | ImGuiTableFlags_SortTristate | ImGuiTableFlags_Resizable |
ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_ScrollY;
if (!ImGui::BeginTable("PerfInfo", IM_ARRAYSIZE(PerfToolColumnInfo), table_flags))
return;
ImGuiStyle& style = ImGui::GetStyle();
int num_visible_labels = _LabelsVisible.Size;
// Test name column is not sorted because we do sorting only within perf runs of a particular tests,
// so as far as sorting function is concerned all items in first column are identical.
for (int i = 0; i < IM_ARRAYSIZE(PerfToolColumnInfo); i++)
{
const ImGuiPerfToolColumnInfo& info = PerfToolColumnInfo[i];
ImGuiTableColumnFlags column_flags = info.Flags;
if (i == 0 && _DisplayType != ImGuiPerfToolDisplayType_Simple)
column_flags |= ImGuiTableColumnFlags_Disabled; // Date only visible in non-combining mode.
if (!info.ShowAlways && _DisplayType != ImGuiPerfToolDisplayType_CombineByBuildInfo)
column_flags |= ImGuiTableColumnFlags_Disabled;
ImGui::TableSetupColumn(info.Title, column_flags);
}
ImGui::TableSetupScrollFreeze(0, 1);
if (ImGuiTableSortSpecs* sorts_specs = ImGui::TableGetSortSpecs())
if (sorts_specs->SpecsDirty || _InfoTableSortDirty)
{
// Fill sort table with unsorted indices.
sorts_specs->SpecsDirty = _InfoTableSortDirty = false;
// Reinitialize sorting table to unsorted state.
_InfoTableSort.resize(num_visible_labels * _Batches.Size);
for (int entry_index = 0, i = 0; entry_index < num_visible_labels; entry_index++)
for (int batch_index = 0; batch_index < _Batches.Size; batch_index++, i++)
_InfoTableSort.Data[i] = (((ImU64)batch_index * num_visible_labels + entry_index) << 24) | i;
// Sort batches of each label.
if (sorts_specs->SpecsCount > 0)
{
_InfoTableSortSpecs = sorts_specs;
PerfToolInstance = this;
ImQsort(_InfoTableSort.Data, (size_t)_InfoTableSort.Size, sizeof(_InfoTableSort.Data[0]), CompareWithSortSpecs);
_InfoTableSortSpecs = NULL;
PerfToolInstance = NULL;
}
}
ImGui::TableHeadersRow();
// ImPlot renders bars from bottom to the top. We want bars to render from top to the bottom, therefore we loop
// labels and batches in reverse order.
_TableHoveredTest = -1;
_TableHoveredBatch = -1;
const bool scroll_into_view = _PlotHoverTestLabel && ImGui::IsMouseClicked(ImGuiMouseButton_Left);
const float header_row_height = ImGui::TableGetCellBgRect(ImGui::GetCurrentTable(), 0).GetHeight();
ImRect scroll_into_view_rect(FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX);
for (int row_index = _InfoTableSort.Size - 1; row_index >= 0; row_index--)
{
int batch_index_sorted, entry_index_sorted;
_UnpackSortedKey(_InfoTableSort[row_index], &batch_index_sorted, &entry_index_sorted);
ImGuiPerfToolBatch* batch = &_Batches[batch_index_sorted];
ImGuiPerfToolEntry* entry = &batch->Entries[entry_index_sorted];
const char* test_name = entry->TestName;
if (!_IsVisibleBuild(entry) || !_IsVisibleTest(entry->TestName) || entry->NumSamples == 0)
continue;
ImGui::PushID(entry);
ImGui::TableNextRow();
if (row_index & 1)
ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, ImGui::GetColorU32(ImGuiCol_TableRowBgAlt, 0.5f));
else
ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, ImGui::GetColorU32(ImGuiCol_TableRowBg, 0.5f));
if (_PlotHoverTest == entry_index_sorted)
{
// Highlight a row that corresponds to hovered bar, or all rows that correspond to hovered perf test label.
if (_PlotHoverBatch == batch_index_sorted || _PlotHoverTestLabel)
ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, ImColor(style.Colors[ImGuiCol_TextSelectedBg]));
}
ImGuiPerfToolEntry* baseline_entry = GetEntryByBatchIdx(_BaselineBatchIndex, test_name);
// Date
if (ImGui::TableNextColumn())
{
char date[64];
FormatDateAndTime(entry->Timestamp, date, IM_ARRAYSIZE(date));
ImGui::TextUnformatted(date);
}
// Build info
if (ImGui::TableNextColumn())
{
// ImGuiSelectableFlags_Disabled + changing ImGuiCol_TextDisabled color prevents selectable from overriding table highlight behavior.
ImGui::PushStyleColor(ImGuiCol_Header, style.Colors[ImGuiCol_Text]);
ImGui::PushStyleColor(ImGuiCol_HeaderHovered, style.Colors[ImGuiCol_TextSelectedBg]);
ImGui::PushStyleColor(ImGuiCol_HeaderActive, style.Colors[ImGuiCol_TextSelectedBg]);
ImGui::Selectable(entry->TestName, false, ImGuiSelectableFlags_SpanAllColumns);
ImGui::PopStyleColor(3);
if (ImGui::IsItemHovered())
{
_TableHoveredTest = entry_index_sorted;
_TableHoveredBatch = batch_index_sorted;
}
if (ImGui::BeginPopupContextItem())
{
if (entry == baseline_entry)
ImGui::BeginDisabled();
if (ImGui::MenuItem("Set as baseline"))
_SetBaseline(batch_index_sorted);
if (entry == baseline_entry)
ImGui::EndDisabled();
ImGui::EndPopup();
}
}
if (ImGui::TableNextColumn())
ImGui::TextUnformatted(entry->GitBranchName);
if (ImGui::TableNextColumn())
ImGui::TextUnformatted(entry->Compiler);
if (ImGui::TableNextColumn())
ImGui::TextUnformatted(entry->OS);
if (ImGui::TableNextColumn())
ImGui::TextUnformatted(entry->Cpu);
if (ImGui::TableNextColumn())
ImGui::TextUnformatted(entry->BuildType);
if (ImGui::TableNextColumn())
ImGui::Text("x%d", entry->PerfStressAmount);
// Avg ms
if (ImGui::TableNextColumn())
ImGui::Text("%.3lf", entry->DtDeltaMs);
// Min ms
if (ImGui::TableNextColumn())
ImGui::Text("%.3lf", entry->DtDeltaMsMin);
// Max ms
if (ImGui::TableNextColumn())
ImGui::Text("%.3lf", entry->DtDeltaMsMax);
// Num samples
if (ImGui::TableNextColumn())
ImGui::Text("%d", entry->NumSamples);
// VS Baseline
if (ImGui::TableNextColumn())
{
float dt_change = (float)entry->VsBaseline;
if (_DisplayType == ImGuiPerfToolDisplayType_PerBranchColors)
{
ImGui::TextUnformatted("--");
}
else
{
Str30 label;
dt_change = FormatVsBaseline(entry, baseline_entry, label);
ImGui::TextUnformatted(label.c_str());
if (dt_change != entry->VsBaseline)
{
entry->VsBaseline = dt_change;
_InfoTableSortDirty = true; // Force re-sorting.
}
}
}
if (_PlotHoverTest == entry_index_sorted && scroll_into_view)
{
ImGuiTable* table = ImGui::GetCurrentTable();
scroll_into_view_rect.Add(ImGui::TableGetCellBgRect(table, 0));
}
ImGui::PopID();
}
if (scroll_into_view)
{
scroll_into_view_rect.Min.y -= header_row_height; // FIXME-TABLE: Compensate for frozen header row covering a first content row scrolled into view.
ImGui::ScrollToRect(ImGui::GetCurrentWindow(), scroll_into_view_rect, ImGuiScrollFlags_NoScrollParent);
}
ImGui::EndTable();
}
//-------------------------------------------------------------------------
// [SECTION] SETTINGS
//-------------------------------------------------------------------------
static void PerflogSettingsHandler_ClearAll(ImGuiContext*, ImGuiSettingsHandler* ini_handler)
{
ImGuiPerfTool* perftool = (ImGuiPerfTool*)ini_handler->UserData;
perftool->_Visibility.Clear();
}
static void* PerflogSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, const char*)
{
return (void*)1;
}
static void PerflogSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHandler* ini_handler, void*, const char* line)
{
ImGuiPerfTool* perftool = (ImGuiPerfTool*)ini_handler->UserData;
char buf[128];
int visible = -1, display_type = -1;
/**/ if (sscanf(line, "DateFrom=%10s", perftool->_FilterDateFrom)) {}
else if (sscanf(line, "DateTo=%10s", perftool->_FilterDateTo)) {}
else if (sscanf(line, "DisplayType=%d", &display_type)) { perftool->_DisplayType = (ImGuiPerfToolDisplayType)display_type; }
else if (sscanf(line, "BaselineBuildId=%llu", &perftool->_BaselineBuildId)) {}
else if (sscanf(line, "BaselineTimestamp=%llu", &perftool->_BaselineTimestamp)) {}
else if (sscanf(line, "TestVisibility=%[^,],%d", buf, &visible) == 2) { perftool->_Visibility.SetBool(ImHashStr(buf), !!visible); }
else if (sscanf(line, "BuildVisibility=%[^,],%d", buf, &visible) == 2) { perftool->_Visibility.SetBool(ImHashStr(buf), !!visible); }
}
static void PerflogSettingsHandler_ApplyAll(ImGuiContext*, ImGuiSettingsHandler* ini_handler)
{
ImGuiPerfTool* perftool = (ImGuiPerfTool*)ini_handler->UserData;
perftool->_Batches.clear_destruct();
perftool->_SetBaseline(-1);
}
static void PerflogSettingsHandler_WriteAll(ImGuiContext*, ImGuiSettingsHandler* ini_handler, ImGuiTextBuffer* buf)
{
ImGuiPerfTool* perftool = (ImGuiPerfTool*)ini_handler->UserData;
if (perftool->_Batches.empty())
return;
buf->appendf("[%s][Data]\n", ini_handler->TypeName);
buf->appendf("DateFrom=%s\n", perftool->_FilterDateFrom);
buf->appendf("DateTo=%s\n", perftool->_FilterDateTo);
buf->appendf("DisplayType=%d\n", perftool->_DisplayType);
buf->appendf("BaselineBuildId=%llu\n", perftool->_BaselineBuildId);
buf->appendf("BaselineTimestamp=%llu\n", perftool->_BaselineTimestamp);
for (const char* label : perftool->_Labels)
buf->appendf("TestVisibility=%s,%d\n", label, perftool->_Visibility.GetBool(ImHashStr(label), true));
ImGuiStorage& temp_set = perftool->_TempSet;
temp_set.Data.clear();
for (ImGuiPerfToolEntry& entry : perftool->_SrcData)
{
const char* properties[] = { entry.GitBranchName, entry.BuildType, entry.Cpu, entry.OS, entry.Compiler };
for (int i = 0; i < IM_ARRAYSIZE(properties); i++)
{
ImGuiID hash = ImHashStr(properties[i]);
if (!temp_set.GetBool(hash))
{
temp_set.SetBool(hash, true);
buf->appendf("BuildVisibility=%s,%d\n", properties[i], perftool->_Visibility.GetBool(hash, true));
}
}
}
buf->append("\n");
}
void ImGuiPerfTool::_AddSettingsHandler()
{
ImGuiSettingsHandler ini_handler;
ini_handler.TypeName = "TestEnginePerfTool";
ini_handler.TypeHash = ImHashStr("TestEnginePerfTool");
ini_handler.ClearAllFn = PerflogSettingsHandler_ClearAll;
ini_handler.ReadOpenFn = PerflogSettingsHandler_ReadOpen;
ini_handler.ReadLineFn = PerflogSettingsHandler_ReadLine;
ini_handler.ApplyAllFn = PerflogSettingsHandler_ApplyAll;
ini_handler.WriteAllFn = PerflogSettingsHandler_WriteAll;
ini_handler.UserData = this;
ImGui::AddSettingsHandler(&ini_handler);
}
void ImGuiPerfTool::_UnpackSortedKey(ImU64 key, int* batch_index, int* entry_index, int* monotonic_index)
{
IM_ASSERT(batch_index != NULL);
IM_ASSERT(entry_index != NULL);
const int num_visible_labels = _LabelsVisible.Size;
*batch_index = (int)((key >> 24) / num_visible_labels);
*entry_index = (int)((key >> 24) % num_visible_labels);
if (monotonic_index)
*monotonic_index = (int)(key & 0xFFFFFF);
}
//-------------------------------------------------------------------------
// [SECTION] TESTS
//-------------------------------------------------------------------------
static bool SetPerfToolWindowOpen(ImGuiTestContext* ctx, bool is_open)
{
ctx->MenuClick("//Dear ImGui Test Engine/Tools");
bool was_open = ctx->ItemIsChecked("//##Menu_00/Perf Tool");
ctx->MenuAction(is_open ? ImGuiTestAction_Check : ImGuiTestAction_Uncheck, "//Dear ImGui Test Engine/Tools/Perf Tool");
return was_open;
}
void RegisterTests_TestEnginePerfTool(ImGuiTestEngine* e)
{
ImGuiTest* t = NULL;
// ## Flex perf tool code.
t = IM_REGISTER_TEST(e, "testengine", "testengine_cov_perftool");
t->GuiFunc = [](ImGuiTestContext* ctx)
{
IM_UNUSED(ctx);
ImGui::Begin("Test Func", NULL, ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_AlwaysAutoResize);
int loop_count = 1000;
bool v1 = false, v2 = true;
for (int n = 0; n < loop_count / 2; n++)
{
ImGui::PushID(n);
ImGui::Checkbox("Hello, world", &v1);
ImGui::Checkbox("Hello, world", &v2);
ImGui::PopID();
}
ImGui::End();
};
t->TestFunc = [](ImGuiTestContext* ctx)
{
ImGuiPerfTool* perftool = ImGuiTestEngine_GetPerfTool(ctx->Engine);
const char* temp_perf_csv = "output/misc_cov_perf_tool.csv";
Str16f min_date_bkp = perftool->_FilterDateFrom;
Str16f max_date_bkp = perftool->_FilterDateTo;
// Execute few perf tests, serialize them to temporary csv file.
ctx->PerfIterations = 50; // Make faster
ctx->PerfCapture("perf", "misc_cov_perf_tool_1", temp_perf_csv);
ctx->PerfCapture("perf", "misc_cov_perf_tool_2", temp_perf_csv);
// Load perf data from csv file and open perf tool.
perftool->Clear();
perftool->LoadCSV(temp_perf_csv);
bool perf_was_open = SetPerfToolWindowOpen(ctx, true);
ctx->Yield();
ImGuiWindow* window = ctx->GetWindowByRef("Dear ImGui Perf Tool");
IM_CHECK(window != NULL);
ImVec2 pos_bkp = window->Pos;
ImVec2 size_bkp = window->Size;
ctx->SetRef(window);
ctx->WindowMove("", ImVec2(50, 50));
ctx->WindowResize("", ImVec2(1400, 900));
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
ImGuiWindow* plot_child = ctx->WindowInfo("plot")->Window; // "plot/PerfTool" prior to implot 2023/08/21
IM_CHECK(plot_child != NULL);
// Move legend to right side.
ctx->MouseMoveToPos(plot_child->Rect().GetCenter());
ctx->MouseDoubleClick(ImGuiMouseButton_Left); // Auto-size plots while at it
ctx->MouseClick(ImGuiMouseButton_Right);
ctx->MenuClick("//$FOCUSED/Legend/NE");
// Click some stuff for more coverage.
ctx->MouseMoveToPos(plot_child->Rect().GetCenter());
ctx->KeyPress(ImGuiMod_Shift);
#endif
ctx->ItemClick("##date-from", ImGuiMouseButton_Right);
ctx->ItemClick(ctx->GetID("//$FOCUSED/Set Min"));
ctx->ItemClick("##date-to", ImGuiMouseButton_Right);
ctx->ItemClick(ctx->GetID("//$FOCUSED/Set Max"));
ctx->ItemClick("###Filter builds");
ctx->ItemClick("###Filter tests");
ctx->ItemClick("Combine", 0, ImGuiTestOpFlags_MoveToEdgeL); // Toggle thrice to leave state unchanged
ctx->ItemClick("Combine", 0, ImGuiTestOpFlags_MoveToEdgeL);
ctx->ItemClick("Combine", 0, ImGuiTestOpFlags_MoveToEdgeL);
// Restore original state.
perftool->Clear(); // Clear test data and load original data
ImFileDelete(temp_perf_csv);
perftool->LoadCSV();
ctx->Yield();
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
ctx->MouseMoveToPos(plot_child->Rect().GetCenter());
ctx->MouseDoubleClick(ImGuiMouseButton_Left); // Fit plot to original data
#endif
ImStrncpy(perftool->_FilterDateFrom, min_date_bkp.c_str(), IM_ARRAYSIZE(perftool->_FilterDateFrom));
ImStrncpy(perftool->_FilterDateTo, max_date_bkp.c_str(), IM_ARRAYSIZE(perftool->_FilterDateTo));
ImGui::SetWindowPos(window, pos_bkp);
ImGui::SetWindowSize(window, size_bkp);
SetPerfToolWindowOpen(ctx, perf_was_open); // Restore window visibility
};
// ## Capture perf tool graph.
t = IM_REGISTER_TEST(e, "capture", "capture_perf_report");
t->TestFunc = [](ImGuiTestContext* ctx)
{
ImGuiPerfTool* perftool = ImGuiTestEngine_GetPerfTool(ctx->Engine);
const char* perf_report_image = NULL;
if (!ImFileExist(IMGUI_PERFLOG_DEFAULT_FILENAME))
{
ctx->LogWarning("Perf tool has no data. Perf report generation was aborted.");
return;
}
char min_date_bkp[sizeof(perftool->_FilterDateFrom)], max_date_bkp[sizeof(perftool->_FilterDateTo)];
ImStrncpy(min_date_bkp, perftool->_FilterDateFrom, IM_ARRAYSIZE(min_date_bkp));
ImStrncpy(max_date_bkp, perftool->_FilterDateTo, IM_ARRAYSIZE(max_date_bkp));
bool perf_was_open = SetPerfToolWindowOpen(ctx, true);
ctx->Yield();
ImGuiWindow* window = ctx->GetWindowByRef("Dear ImGui Perf Tool");
IM_CHECK_SILENT(window != NULL);
ImVec2 pos_bkp = window->Pos;
ImVec2 size_bkp = window->Size;
ctx->SetRef(window);
ctx->WindowMove("", ImVec2(50, 50));
ctx->WindowResize("", ImVec2(1400, 900));
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
ctx->ItemDoubleClick("splitter"); // Hide info table
ImGuiWindow* plot_child = ctx->WindowInfo("plot")->Window; // "plot/PerfTool" prior to implot 2023/08/21
IM_CHECK(plot_child != NULL);
// Move legend to right side.
ctx->MouseMoveToPos(plot_child->Rect().GetCenter());
ctx->MouseDoubleClick(ImGuiMouseButton_Left); // Auto-size plots while at it
ctx->MouseClick(ImGuiMouseButton_Right);
ctx->MenuClick("//$FOCUSED/Legend/NE");
#endif
// Click some stuff for more coverage.
ctx->ItemClick("##date-from", ImGuiMouseButton_Right);
ctx->ItemClick(ctx->GetID("//$FOCUSED/Set Min"));
ctx->ItemClick("##date-to", ImGuiMouseButton_Right);
ctx->ItemClick(ctx->GetID("//$FOCUSED/Set Max"));
#if IMGUI_TEST_ENGINE_ENABLE_IMPLOT
// Take a screenshot.
ImGuiCaptureArgs* args = ctx->CaptureArgs;
args->InCaptureRect = plot_child->Rect();
ctx->CaptureAddWindow(window->Name);
ctx->CaptureScreenshot(ImGuiCaptureFlags_HideMouseCursor);
ctx->ItemDragWithDelta("splitter", ImVec2(0, -180)); // Show info table
perf_report_image = args->InOutputFile;
#endif
ImStrncpy(perftool->_FilterDateFrom, min_date_bkp, IM_ARRAYSIZE(min_date_bkp));
ImStrncpy(perftool->_FilterDateTo, max_date_bkp, IM_ARRAYSIZE(max_date_bkp));
ImGui::SetWindowPos(window, pos_bkp);
ImGui::SetWindowSize(window, size_bkp);
SetPerfToolWindowOpen(ctx, perf_was_open); // Restore window visibility
const char* perf_report_output = getenv("CAPTURE_PERF_REPORT_OUTPUT");
if (perf_report_output == NULL)
perf_report_output = PerfToolReportDefaultOutputPath;
perftool->SaveHtmlReport(perf_report_output, perf_report_image);
};
}
//-------------------------------------------------------------------------