dataforge/data_table_bench
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: initial scaffold data_table_bench (issue 0133)

Browse Source
This commit is contained in:
agent_A
2026-05-22 23:37:50 +02:00
commit 09ccc6848b
7 changed files with 923 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+18
View File
@@ -0,0 +1,18 @@
add_imgui_app(data_table_bench
main.cpp
bench_runner.cpp
)
target_include_directories(data_table_bench PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
# fn_module_data_table: data_table::render(), TQL engine, Lua.
if(TARGET fn_module_data_table)
target_link_libraries(data_table_bench PRIVATE fn_module_data_table)
endif()
# SQLite3 for operations.db persistence.
find_package(SQLite3 REQUIRED)
target_link_libraries(data_table_bench PRIVATE SQLite::SQLite3)
if(WIN32)
set_target_properties(data_table_bench PROPERTIES WIN32_EXECUTABLE FALSE)
endif()
app.md
+107
View File
@@ -0,0 +1,107 @@
---
name: data_table_bench
lang: cpp
domain: tools
version: 0.1.0
description: "Headless 10M-row performance gate for data_table::render() (issue 0133). Mide fps_p50/fps_p1/mem/cpu en 4 escenarios: scroll lineal, filter LIKE, sort numerico y color rule."
tags: [imgui, bench, headless, data-table, perf]
uses_functions:
- data_table_cpp_viz
uses_types: []
framework: "imgui"
entry_point: "main.cpp"
dir_path: "apps/data_table_bench"
repo_url: ""
icon:
phosphor: "gauge"
accent: "#22d3ee"
e2e_checks:
- id: build
cmd: "cd cpp/build/linux && cmake --build . --target data_table_bench -j 4"
timeout_s: 300
- id: smoke_100k
cmd: "cd apps/data_table_bench && xvfb-run -a -s \"-screen 0 1920x1080x24\" env LIBGL_ALWAYS_SOFTWARE=1 GALLIUM_DRIVER=llvmpipe ../../cpp/build/linux/apps/data_table_bench/data_table_bench --rows 100000 --duration 5 --no-db"
timeout_s: 120
expect_stdout_contains: "\"overall_pass\":"
severity: warning
---
# data_table_bench
Headless benchmark app para el modulo `data_table` (issue 0133). Gate de performance entre cada cambio del refactor 10M-row.
## Uso
```bash
# CI smoke (rapido, 100k filas, 5s por escenario)
cd apps/data_table_bench
xvfb-run -a -s "-screen 0 1920x1080x24" \
env LIBGL_ALWAYS_SOFTWARE=1 GALLIUM_DRIVER=llvmpipe \
../../cpp/build/linux/apps/data_table_bench/data_table_bench \
--rows 100000 --duration 5 --no-db
# Full bench (10M filas, 30s por escenario)
xvfb-run -a -s "-screen 0 1920x1080x24" \
env LIBGL_ALWAYS_SOFTWARE=1 GALLIUM_DRIVER=llvmpipe \
../../cpp/build/linux/apps/data_table_bench/data_table_bench \
--rows 10000000 --duration 30
# Con persistencia SQLite
./data_table_bench --rows 10000000 --duration 30 --db operations.db --sha $(git rev-parse HEAD)
```
## Output ejemplo
```json
{
"rows": 100000,
"fps_threshold": 60.0,
"scenarios": [
{ "scenario": "linear_scroll", "fps_p50": 320.5, "fps_p1": 125.3, "mem_rss_mb": 450.2, "cpu_pct": 85.1, "duration_s": 5.0, "pass": true },
{ "scenario": "filter_like", "fps_p50": 210.1, "fps_p1": 95.2, "mem_rss_mb": 450.5, "cpu_pct": 92.3, "duration_s": 5.0, "pass": true },
{ "scenario": "sort_numeric", "fps_p50": 180.3, "fps_p1": 70.1, "mem_rss_mb": 451.0, "cpu_pct": 88.7, "duration_s": 5.0, "pass": true },
{ "scenario": "color_rule", "fps_p50": 290.7, "fps_p1": 98.4, "mem_rss_mb": 451.2, "cpu_pct": 86.2, "duration_s": 5.0, "pass": true }
],
"overall_pass": true
}
```
## Assertion DoD
`fps_p1 >= 60` en cada escenario con 10M filas a 30s.
## Escenarios
| ID | Patron | Lo que estresan |
|---|---|---|
| `linear_scroll` | Avanza el scroll 1 fila/frame | Clipper virtual scroll en O(1) |
| `filter_like` | Contains("foo") sobre col name | Scan de 10M strings por frame |
| `sort_numeric` | Sort score DESC | Reordenacion del stage pipeline |
| `color_rule` | NumericRange gradient en col value | Pintado condicional de 10M celdas |
## Build
```bash
cd cpp/build/linux
cmake --build . --target data_table_bench -j 4
```
## Dataset
Sintetico y determinista (mismo seed => mismas filas). 20 columnas:
- Cols 0-4: int (id, count, score, rank, flags)
- Cols 5-9: float (ratio, pct, value, rate, weight)
- Cols 10-14: string (name, status, category, tag, label)
- Cols 15-19: timestamp como int string (created_at, updated_at, closed_at, due_at, ts)
## Gotchas
- Requiere xvfb + llvmpipe en CI Linux (sin GPU real). Instalar: `sudo apt-get install xvfb libgles2-mesa`.
- El seed de 10M filas puede tardar 10-15s antes de arrancar el GL context.
- `vsync = false` en AppConfig para que el bench no este limitado por el refresh rate del display virtual.
- La ventana se oculta con `glfwHideWindow()` en el primer frame — nunca aparece en pantalla.
- Windows: sin cross-compile habilitado el bench es solo Linux. El DoD del issue 0133 es Linux.
## Capability growth log
- v0.1.0 (2026-05-22) — baseline para issue 0133.
bench_runner.cpp
+487
View File
@@ -0,0 +1,487 @@
// bench_runner.cpp — frame-by-frame benchmark harness for data_table::render().
// Issue 0133: perf gate for 10M-row refactor.
//
// Design: Runner::tick() is called once per fn::run_app frame.
// Each frame it renders the table for the current scenario and measures the
// frame time (wall clock from tick() entry to exit). After duration_s seconds
// it finalizes the scenario, moves to the next one, and eventually sets done_.
//
// This avoids any nested-frame or out-of-context ImGui calls — tick() runs
// inside a valid ImGui frame, after NewFrame() and before Render().
#include "bench_runner.h"
#include "data_table/data_table.h"
#include "core/logger.h"
#include <imgui.h>
#include <sqlite3.h>
#include <algorithm>
#include <chrono>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#ifdef __linux__
# include <sys/resource.h>
#endif
#ifdef _WIN32
# include <windows.h>
# include <psapi.h>
#endif
namespace bench {
// ---------------------------------------------------------------------------
// System metrics
// ---------------------------------------------------------------------------
double measure_rss_mb() {
#ifdef __linux__
FILE* f = fopen("/proc/self/status", "r");
if (!f) return 0.0;
char line[256];
while (fgets(line, sizeof(line), f)) {
long kb = 0;
if (sscanf(line, "VmRSS: %ld kB", &kb) == 1) {
fclose(f);
return static_cast<double>(kb) / 1024.0;
}
}
fclose(f);
return 0.0;
#elif defined(_WIN32)
PROCESS_MEMORY_COUNTERS pmc;
if (GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc)))
return static_cast<double>(pmc.WorkingSetSize) / (1024.0 * 1024.0);
return 0.0;
#else
return 0.0;
#endif
}
double measure_cpu_pct(double wall_s, double user_s, double sys_s) {
if (wall_s < 1e-9) return 0.0;
return 100.0 * (user_s + sys_s) / wall_s;
}
static void get_rusage_times(double& user_s, double& sys_s) {
#ifdef __linux__
struct rusage ru;
getrusage(RUSAGE_SELF, &ru);
user_s = ru.ru_utime.tv_sec + ru.ru_utime.tv_usec * 1e-6;
sys_s = ru.ru_stime.tv_sec + ru.ru_stime.tv_usec * 1e-6;
#else
user_s = 0.0; sys_s = 0.0;
#endif
}
// ---------------------------------------------------------------------------
// ScenarioState — holds TableInput + data_table::State for one scenario.
// ---------------------------------------------------------------------------
struct Runner::ScenarioState {
data_table::TableInput ti;
data_table::State st;
};
// ---------------------------------------------------------------------------
// Dataset generation — deterministic, 20 columns, 5 int / 5 float / 5 str / 5 ts.
// ---------------------------------------------------------------------------
Runner::Runner(const Config& cfg) : cfg_(cfg) {
seed_dataset();
}
void Runner::seed_dataset() {
const long long N = cfg_.rows;
const int C = cfg_.cols;
backing_.clear();
backing_.reserve(static_cast<size_t>(N) * static_cast<size_t>(C));
static const char* statuses[] = {"ok", "error", "running", "pending", "blocked"};
static const char* categories[] = {"alpha", "beta", "gamma", "delta", "epsilon"};
static const char* tags_a[] = {"foo", "bar", "baz", "qux", "quux"};
static const char* labels_a[] = {"low", "medium", "high", "critical", "unknown"};
char buf[64];
for (long long i = 0; i < N; ++i) {
// 0: id (int)
snprintf(buf, sizeof(buf), "%lld", i + 1);
backing_.emplace_back(buf);
// 1: count (int 0..9999)
snprintf(buf, sizeof(buf), "%lld", (i * 7 + 3) % 10000);
backing_.emplace_back(buf);
// 2: score (int 0..1000)
snprintf(buf, sizeof(buf), "%lld", (i * 131) % 1001);
backing_.emplace_back(buf);
// 3: rank (int 0..499)
snprintf(buf, sizeof(buf), "%lld", (i * 17) % 500);
backing_.emplace_back(buf);
// 4: flags (int 0..15)
snprintf(buf, sizeof(buf), "%lld", i & 0xF);
backing_.emplace_back(buf);
// 5: ratio (float 0..1)
snprintf(buf, sizeof(buf), "%.6f", static_cast<double>(i % 10000) / 10000.0);
backing_.emplace_back(buf);
// 6: pct (float 0..100)
snprintf(buf, sizeof(buf), "%.4f", static_cast<double>((i * 37) % 10001) / 100.0);
backing_.emplace_back(buf);
// 7: value (float 0..9999, for ColorRule p95 scenario)
snprintf(buf, sizeof(buf), "%.2f", static_cast<double>((i * 71) % 10000));
backing_.emplace_back(buf);
// 8: rate (float)
snprintf(buf, sizeof(buf), "%.4f", static_cast<double>((i * 13) % 5000) / 500.0);
backing_.emplace_back(buf);
// 9: weight (float)
snprintf(buf, sizeof(buf), "%.3f", static_cast<double>((i * 29) % 1000) / 100.0);
backing_.emplace_back(buf);
// 10: name (string; "item_foo_N" every 7th row for filter_like)
if (i % 7 == 0)
snprintf(buf, sizeof(buf), "item_foo_%lld", i);
else
snprintf(buf, sizeof(buf), "item_%lld", i);
backing_.emplace_back(buf);
// 11: status
backing_.emplace_back(statuses[i % 5]);
// 12: category
backing_.emplace_back(categories[(i * 3) % 5]);
// 13: tag
backing_.emplace_back(tags_a[(i * 5) % 5]);
// 14: label
backing_.emplace_back(labels_a[(i * 11) % 5]);
// 15: created_at (int as string)
snprintf(buf, sizeof(buf), "%lld", 1700000000LL + i * 60);
backing_.emplace_back(buf);
// 16: updated_at
snprintf(buf, sizeof(buf), "%lld", 1700000000LL + i * 60 + 30);
backing_.emplace_back(buf);
// 17: closed_at
snprintf(buf, sizeof(buf), "%lld", 1700000000LL + i * 60 + (i % 3 == 0 ? 120 : 0));
backing_.emplace_back(buf);
// 18: due_at
snprintf(buf, sizeof(buf), "%lld", 1700000000LL + (i + 1000) * 3600);
backing_.emplace_back(buf);
// 19: ts
snprintf(buf, sizeof(buf), "%lld", 1700000000LL + i);
backing_.emplace_back(buf);
}
ptrs_.clear();
ptrs_.reserve(backing_.size());
for (const auto& s : backing_) ptrs_.push_back(s.c_str());
}
// ---------------------------------------------------------------------------
// begin_scenario — sets up TableInput + State for a scenario.
// ---------------------------------------------------------------------------
void Runner::begin_scenario(Scenario s) {
delete sc_state_;
sc_state_ = new ScenarioState();
// TableInput.
sc_state_->ti.name = "bench_data";
sc_state_->ti.headers = {
"id", "count", "score", "rank", "flags",
"ratio", "pct", "value", "rate", "weight",
"name", "status", "category", "tag", "label",
"created_at", "updated_at", "closed_at", "due_at", "ts"
};
using CT = data_table::ColumnType;
sc_state_->ti.types = {
CT::Int, CT::Int, CT::Int, CT::Int, CT::Int,
CT::Float, CT::Float, CT::Float, CT::Float, CT::Float,
CT::String, CT::String, CT::String, CT::String, CT::String,
CT::Int, CT::Int, CT::Int, CT::Int, CT::Int
};
sc_state_->ti.cells = ptrs_.data();
sc_state_->ti.rows = static_cast<int>(cfg_.rows);
sc_state_->ti.cols = cfg_.cols;
// State.
sc_state_->st = data_table::State{};
sc_state_->st.ensure_stage0();
switch (s) {
case Scenario::FilterLike: {
data_table::Filter f;
f.col = 10; // name column
f.op = data_table::Op::Contains;
f.value = "foo";
sc_state_->st.raw().filters.push_back(f);
break;
}
case Scenario::SortNumeric: {
data_table::SortClause sc;
sc.col = "score";
sc.desc = true;
sc_state_->st.raw().sorts.push_back(sc);
break;
}
case Scenario::ColorRule: {
data_table::ColorRule cr;
cr.col = 7; // value column
cr.kind = data_table::ColorRuleKind::NumericRange;
cr.range_min = 0.0;
cr.range_max = 9999.0;
cr.range_alpha = 0.3f;
cr.range_stops.push_back({0.0f, "#22c55e"});
cr.range_stops.push_back({1.0f, "#ef4444"});
sc_state_->st.color_rules.push_back(cr);
break;
}
case Scenario::LinearScroll:
break;
}
// Timing init.
frame_fps_.clear();
frame_fps_.reserve(4096);
scroll_row_ = 0;
scenario_wall_start_ = Clock::now();
last_frame_start_ = Clock::now();
get_rusage_times(user_start_, sys_start_);
fprintf(stderr, "[bench] scenario: %s (rows=%lld duration=%.0fs)\n",
scenario_name(s), cfg_.rows, cfg_.duration_s);
fflush(stderr);
}
// ---------------------------------------------------------------------------
// finish_scenario — collects stats from frame_fps_ and stores result.
// ---------------------------------------------------------------------------
void Runner::finish_scenario() {
Scenario s = kScenarios[current_scenario_];
double user1 = 0.0, sys1 = 0.0;
get_rusage_times(user1, sys1);
double wall_s = std::chrono::duration<double>(
Clock::now() - scenario_wall_start_).count();
ScenarioResult res;
res.scenario = s;
res.duration_s = wall_s;
res.mem_rss_mb = measure_rss_mb();
res.cpu_pct = measure_cpu_pct(wall_s, user1 - user_start_, sys1 - sys_start_);
if (!frame_fps_.empty()) {
std::sort(frame_fps_.begin(), frame_fps_.end());
size_t n = frame_fps_.size();
res.fps_p50 = frame_fps_[n / 2];
size_t p1i = n * 1 / 100;
res.fps_p1 = frame_fps_[p1i];
}
res.pass = (res.fps_p1 >= cfg_.fps_threshold);
fn_log::log_info("bench: scenario=%s frames=%zu fps_p50=%.1f fps_p1=%.1f "
"mem=%.1fMB cpu=%.1f%% %s",
scenario_name(s), frame_fps_.size(),
res.fps_p50, res.fps_p1, res.mem_rss_mb, res.cpu_pct,
res.pass ? "PASS" : "FAIL");
fprintf(stderr, "[bench] %s: fps_p50=%.1f fps_p1=%.1f mem=%.1fMB %s\n",
scenario_name(s), res.fps_p50, res.fps_p1, res.mem_rss_mb,
res.pass ? "PASS" : "FAIL");
fflush(stderr);
results_.push_back(res);
delete sc_state_;
sc_state_ = nullptr;
}
// ---------------------------------------------------------------------------
// render_table_frame — render one frame for the current scenario.
// Called inside an active ImGui frame (after NewFrame, before Render).
// ---------------------------------------------------------------------------
void Runner::render_table_frame(Scenario s) {
if (!sc_state_) return;
ImGui::SetNextWindowSize(ImVec2(1920, 1080), ImGuiCond_Always);
ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
ImGui::Begin("##bench_table", nullptr,
ImGuiWindowFlags_NoDecoration |
ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_NoBringToFrontOnFocus |
ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoResize);
if (s == Scenario::LinearScroll && sc_state_->ti.rows > 0) {
float row_h = ImGui::GetTextLineHeightWithSpacing();
ImGui::SetScrollY(static_cast<float>(scroll_row_) * row_h);
scroll_row_ = (scroll_row_ + 1) % sc_state_->ti.rows;
}
data_table::render("##bench_tbl",
{sc_state_->ti}, sc_state_->st, nullptr, false);
ImGui::End();
}
// ---------------------------------------------------------------------------
// tick — one frame of the benchmark state machine.
// ---------------------------------------------------------------------------
bool Runner::tick() {
if (done_) return true;
Scenario s = kScenarios[current_scenario_];
auto now = Clock::now();
// Start new scenario on first tick or after transition.
if (!scenario_started_) {
begin_scenario(s);
scenario_started_ = true;
last_frame_start_ = now;
}
// Measure frame time from last tick entry.
double frame_ms = std::chrono::duration<double, std::milli>(
now - last_frame_start_).count();
last_frame_start_ = now;
// Record FPS (skip the very first frame — it includes scenario setup time).
if (frame_ms > 0.01 && results_.size() == static_cast<size_t>(current_scenario_)) {
frame_fps_.push_back(1000.0 / frame_ms);
}
// Render table for this frame.
render_table_frame(s);
// Check if scenario duration has elapsed.
double elapsed = std::chrono::duration<double>(
Clock::now() - scenario_wall_start_).count();
if (elapsed >= cfg_.duration_s) {
finish_scenario();
current_scenario_++;
scenario_started_ = false;
if (current_scenario_ >= kNumScenarios) {
done_ = true;
return true;
}
}
return false;
}
// ---------------------------------------------------------------------------
// Accessors
// ---------------------------------------------------------------------------
bool Runner::all_passed() const {
if (results_.empty()) return false;
for (const auto& r : results_)
if (!r.pass) return false;
return true;
}
// ---------------------------------------------------------------------------
// JSON output
// ---------------------------------------------------------------------------
void Runner::print_json() const {
printf("{\n");
printf(" \"rows\": %lld,\n", cfg_.rows);
printf(" \"fps_threshold\": %.1f,\n", cfg_.fps_threshold);
printf(" \"scenarios\": [\n");
for (size_t i = 0; i < results_.size(); ++i) {
const auto& r = results_[i];
printf(" {\n");
printf(" \"scenario\": \"%s\",\n", scenario_name(r.scenario));
printf(" \"fps_p50\": %.2f,\n", r.fps_p50);
printf(" \"fps_p1\": %.2f,\n", r.fps_p1);
printf(" \"mem_rss_mb\": %.1f,\n", r.mem_rss_mb);
printf(" \"cpu_pct\": %.1f,\n", r.cpu_pct);
printf(" \"duration_s\": %.2f,\n", r.duration_s);
printf(" \"pass\": %s\n", r.pass ? "true" : "false");
printf(" }%s\n", (i + 1 < results_.size()) ? "," : "");
}
printf(" ],\n");
printf(" \"overall_pass\": %s\n", all_passed() ? "true" : "false");
printf("}\n");
}
// ---------------------------------------------------------------------------
// SQLite persistence
// ---------------------------------------------------------------------------
static const char* kCreateSQL =
"CREATE TABLE IF NOT EXISTS bench_runs ("
" id TEXT PRIMARY KEY,"
" started_at INTEGER NOT NULL,"
" rows INTEGER NOT NULL,"
" scenario TEXT NOT NULL,"
" fps_p50 REAL NOT NULL,"
" fps_p1 REAL NOT NULL,"
" mem_rss_mb REAL NOT NULL,"
" cpu_pct REAL NOT NULL,"
" duration_s REAL NOT NULL,"
" commit_sha TEXT NOT NULL DEFAULT '',"
" summary_json TEXT NOT NULL DEFAULT '{}'"
");";
void Runner::persist(const std::string& db_path) const {
if (db_path.empty()) return;
sqlite3* db = nullptr;
if (sqlite3_open(db_path.c_str(), &db) != SQLITE_OK) {
fprintf(stderr, "[bench] sqlite3_open(%s) failed: %s\n",
db_path.c_str(), sqlite3_errmsg(db));
if (db) sqlite3_close(db);
return;
}
sqlite3_exec(db, "PRAGMA journal_mode=WAL;", nullptr, nullptr, nullptr);
sqlite3_exec(db, kCreateSQL, nullptr, nullptr, nullptr);
auto now_ts = static_cast<long long>(
std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::system_clock::now().time_since_epoch()).count());
const char* kInsert =
"INSERT OR REPLACE INTO bench_runs "
"(id, started_at, rows, scenario, fps_p50, fps_p1, mem_rss_mb, cpu_pct, "
" duration_s, commit_sha, summary_json) "
"VALUES (?,?,?,?,?,?,?,?,?,?,?);";
for (const auto& r : results_) {
char id_buf[128];
snprintf(id_buf, sizeof(id_buf), "%lld_%s", now_ts, scenario_name(r.scenario));
char json_buf[256];
snprintf(json_buf, sizeof(json_buf),
"{\"fps_p50\":%.2f,\"fps_p1\":%.2f,\"mem_rss_mb\":%.1f,"
"\"cpu_pct\":%.1f,\"pass\":%s}",
r.fps_p50, r.fps_p1, r.mem_rss_mb, r.cpu_pct,
r.pass ? "true" : "false");
sqlite3_stmt* stmt = nullptr;
sqlite3_prepare_v2(db, kInsert, -1, &stmt, nullptr);
sqlite3_bind_text (stmt, 1, id_buf, -1, SQLITE_TRANSIENT);
sqlite3_bind_int64 (stmt, 2, now_ts);
sqlite3_bind_int64 (stmt, 3, cfg_.rows);
sqlite3_bind_text (stmt, 4, scenario_name(r.scenario), -1, SQLITE_STATIC);
sqlite3_bind_double(stmt, 5, r.fps_p50);
sqlite3_bind_double(stmt, 6, r.fps_p1);
sqlite3_bind_double(stmt, 7, r.mem_rss_mb);
sqlite3_bind_double(stmt, 8, r.cpu_pct);
sqlite3_bind_double(stmt, 9, r.duration_s);
sqlite3_bind_text (stmt, 10, cfg_.commit_sha.c_str(), -1, SQLITE_TRANSIENT);
sqlite3_bind_text (stmt, 11, json_buf, -1, SQLITE_TRANSIENT);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
}
sqlite3_close(db);
}
} // namespace bench
bench_runner.h
+127
View File
@@ -0,0 +1,127 @@
#pragma once
// bench_runner — headless benchmark harness for data_table::render().
// Issue 0133: perf gate for 10M-row refactor.
//
// Architecture: the Runner is driven frame-by-frame from within fn::run_app's
// render callback. Each frame it calls data_table::render() for the current
// scenario and measures the frame time. After duration_s seconds it moves to
// the next scenario. After all 4 scenarios it signals completion.
//
// Usage in render callback:
// static bench::Runner runner(cfg);
// runner.tick(); // called every frame
// if (runner.done()) { ... print + persist + close window ... }
#include <chrono>
#include <string>
#include <vector>
namespace bench {
enum class Scenario {
LinearScroll, // advance row offset each frame
FilterLike, // filter name CONTAINS "foo"
SortNumeric, // sort score col descending
ColorRule, // NumericRange color rule on value col
};
inline const char* scenario_name(Scenario s) {
switch (s) {
case Scenario::LinearScroll: return "linear_scroll";
case Scenario::FilterLike: return "filter_like";
case Scenario::SortNumeric: return "sort_numeric";
case Scenario::ColorRule: return "color_rule";
}
return "unknown";
}
struct ScenarioResult {
Scenario scenario = Scenario::LinearScroll;
double fps_p50 = 0.0;
double fps_p1 = 0.0;
double mem_rss_mb = 0.0;
double cpu_pct = 0.0;
double duration_s = 0.0;
bool pass = false;
};
struct Config {
long long rows = 10000000;
int cols = 20;
double duration_s = 30.0;
double fps_threshold = 60.0;
std::string db_path = "operations.db";
std::string commit_sha;
bool verbose = false;
};
class Runner {
public:
explicit Runner(const Config& cfg);
// Called once per render frame. Internally manages scenario transitions.
// Returns true when all scenarios are finished.
bool tick();
// Returns true when all scenarios have completed.
bool done() const { return done_; }
// Print JSON summary to stdout.
void print_json() const;
// Persist results into bench_runs SQLite table.
void persist(const std::string& db_path) const;
// Returns false if any scenario failed fps_threshold assertion.
bool all_passed() const;
const std::vector<ScenarioResult>& results() const { return results_; }
private:
Config cfg_;
std::vector<ScenarioResult> results_;
bool done_ = false;
// Backing storage for synthetic dataset (row-major strings).
std::vector<std::string> backing_;
std::vector<const char*> ptrs_;
// Per-scenario timing state.
int current_scenario_ = 0;
bool scenario_started_ = false;
// Frame timing for current scenario.
using Clock = std::chrono::steady_clock;
Clock::time_point scenario_wall_start_;
Clock::time_point last_frame_start_;
std::vector<double> frame_fps_;
double user_start_ = 0.0;
double sys_start_ = 0.0;
// Scenario-specific state (rebuilt each scenario).
struct ScenarioState;
ScenarioState* sc_state_ = nullptr;
int scroll_row_ = 0;
static constexpr Scenario kScenarios[] = {
Scenario::LinearScroll,
Scenario::FilterLike,
Scenario::SortNumeric,
Scenario::ColorRule,
};
static constexpr int kNumScenarios = 4;
void seed_dataset();
void begin_scenario(Scenario s);
void finish_scenario();
void render_table_frame(Scenario s);
};
// Measure RSS memory in MB (Linux: /proc/self/status).
double measure_rss_mb();
// Measure CPU % from RUSAGE delta over wall time.
double measure_cpu_pct(double wall_s, double user_s, double sys_s);
} // namespace bench
data_table_bench.log
+6
View File
@@ -0,0 +1,6 @@
[2026-05-22 23:37:25.548] [INFO] app start: data_table_bench
[2026-05-22 23:37:30.625] [INFO] bench: scenario=linear_scroll frames=512 fps_p50=104.1 fps_p1=84.7 mem=124.8MB cpu=763.8% PASS
[2026-05-22 23:37:35.637] [INFO] bench: scenario=filter_like frames=757 fps_p50=153.2 fps_p1=125.1 mem=124.8MB cpu=1096.1% PASS
[2026-05-22 23:37:40.654] [INFO] bench: scenario=sort_numeric frames=273 fps_p50=54.9 fps_p1=48.6 mem=125.1MB cpu=452.1% FAIL
[2026-05-22 23:37:45.662] [INFO] bench: scenario=color_rule frames=522 fps_p50=105.3 fps_p1=93.0 mem=125.1MB cpu=787.5% PASS
[2026-05-22 23:37:45.667] [INFO] app exit
main.cpp
+163
View File
@@ -0,0 +1,163 @@
// data_table_bench — headless performance gate for data_table::render().
// Issue 0133: 10M-row bench for the upcoming data_table refactor.
//
// Usage:
// ./data_table_bench --rows 10000000 --duration 30
// ./data_table_bench --rows 100000 --duration 5 # CI smoke (fast)
// ./data_table_bench --rows 1000000 --duration 10 --no-db
//
// Output: JSON to stdout.
// Exit 0 if all scenarios pass (fps_p1 >= threshold), 1 otherwise.
//
// Headless strategy:
// fn::run_app creates the GL context (needed for ImGui clipper to work
// on 10M-row virtual scroll). We hide the GLFW window via glfwHideWindow()
// on the first frame. The Runner::tick() is called each frame to drive the
// benchmark state machine across all 4 scenarios. When tick() returns true
// (all done) we close the window and fn::run_app exits.
#include "app_base.h"
#include "core/logger.h"
#include "bench_runner.h"
#include <imgui.h>
#include <GLFW/glfw3.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
// ---------------------------------------------------------------------------
// Argument parsing
// ---------------------------------------------------------------------------
static void print_usage() {
fprintf(stderr,
"Usage: data_table_bench [options]\n"
" --rows N Number of rows (default: 10000000)\n"
" --duration S Seconds per scenario (default: 30)\n"
" --threshold F fps_p1 pass threshold (default: 60.0)\n"
" --db PATH Persist results to SQLite (default: operations.db)\n"
" --no-db Skip persistence\n"
" --sha SHA Git commit SHA to tag run\n"
" --verbose Extra logging\n"
);
}
struct Args {
long long rows = 10000000;
double duration_s = 30.0;
double threshold = 60.0;
std::string db_path = "operations.db";
std::string commit_sha;
bool verbose = false;
};
static Args parse_args(int argc, char** argv) {
Args a;
for (int i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--rows") == 0 && i + 1 < argc)
a.rows = atoll(argv[++i]);
else if (strcmp(argv[i], "--duration") == 0 && i + 1 < argc)
a.duration_s = atof(argv[++i]);
else if (strcmp(argv[i], "--threshold") == 0 && i + 1 < argc)
a.threshold = atof(argv[++i]);
else if (strcmp(argv[i], "--db") == 0 && i + 1 < argc)
a.db_path = argv[++i];
else if (strcmp(argv[i], "--no-db") == 0)
a.db_path = "";
else if (strcmp(argv[i], "--sha") == 0 && i + 1 < argc)
a.commit_sha = argv[++i];
else if (strcmp(argv[i], "--verbose") == 0)
a.verbose = true;
else if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
print_usage();
exit(0);
}
}
return a;
}
// ---------------------------------------------------------------------------
// main
// ---------------------------------------------------------------------------
int main(int argc, char** argv) {
Args args = parse_args(argc, argv);
fprintf(stderr, "[bench] rows=%lld duration=%.0fs threshold=%.0f db=%s\n",
args.rows, args.duration_s, args.threshold,
args.db_path.empty() ? "(none)" : args.db_path.c_str());
bench::Config cfg;
cfg.rows = args.rows;
cfg.duration_s = args.duration_s;
cfg.fps_threshold = args.threshold;
cfg.db_path = args.db_path;
cfg.commit_sha = args.commit_sha;
cfg.verbose = args.verbose;
// Seed dataset before opening GL context — can take several seconds for 10M.
fprintf(stderr, "[bench] seeding %lld x %d dataset... ", cfg.rows, cfg.cols);
fflush(stderr);
bench::Runner runner(cfg);
fprintf(stderr, "done\n");
fflush(stderr);
// fn::run_app config — headless visual setup.
fn::AppConfig app_cfg;
app_cfg.title = "data_table_bench";
app_cfg.width = 1920;
app_cfg.height = 1080;
app_cfg.vsync = false; // uncapped FPS for meaningful bench
app_cfg.viewports = false; // no floating panels
app_cfg.auto_dockspace = false; // no dockspace overhead
app_cfg.auto_layouts = false; // no layout DB
app_cfg.about.name = "data_table_bench";
app_cfg.about.version = "0.1.0";
app_cfg.about.description = "Headless 10M-row bench for data_table (issue 0133)";
app_cfg.log = {"data_table_bench.log", 1};
app_cfg.header_badge.enabled = false; // headless — no badge
static GLFWwindow* g_window = nullptr;
bool window_hidden = false;
int rc = fn::run_app(app_cfg, [&]() {
// First frame: grab window handle and hide.
if (!g_window) {
ImGuiViewport* vp = ImGui::GetMainViewport();
if (vp && vp->PlatformHandle) {
g_window = (GLFWwindow*)vp->PlatformHandle;
glfwHideWindow(g_window);
window_hidden = true;
}
}
// tick() drives the benchmark state machine, renders the table,
// and returns true when all 4 scenarios are complete.
bool finished = runner.tick();
if (finished && g_window) {
glfwSetWindowShouldClose(g_window, GLFW_TRUE);
}
});
if (rc != 0) {
fprintf(stderr, "[bench] run_app error: %d\n", rc);
return 1;
}
// Print JSON to stdout.
runner.print_json();
// Persist to SQLite.
if (!args.db_path.empty()) {
runner.persist(args.db_path);
fprintf(stderr, "[bench] results persisted to %s\n", args.db_path.c_str());
}
bool passed = runner.all_passed();
fprintf(stderr, "[bench] overall: %s\n", passed ? "PASS" : "FAIL");
return passed ? 0 : 1;
}
migrations/001_init.sql
+15
View File
@@ -0,0 +1,15 @@
-- data_table_bench: schema inicial
-- Tabla bench_runs: persiste resultados de cada ejecucion del benchmark.
CREATE TABLE IF NOT EXISTS bench_runs (
id TEXT PRIMARY KEY,
started_at INTEGER NOT NULL,
rows INTEGER NOT NULL,
scenario TEXT NOT NULL,
fps_p50 REAL NOT NULL,
fps_p1 REAL NOT NULL,
mem_rss_mb REAL NOT NULL,
cpu_pct REAL NOT NULL,
duration_s REAL NOT NULL,
commit_sha TEXT NOT NULL DEFAULT '',
summary_json TEXT NOT NULL DEFAULT '{}'
);