jabber.developer2
b1d820462a
End-to-end performance and correctness harness for the flat-file +
SQLite database backends. Lives in tests/bench/, built only on
demand (`make bench`); not part of `make check`.
Components
gen_history (P1)
Deterministic corpus generator. Knobs: lines, contacts, years,
seed, stanza-id mode (uuid/libpurple/conversations/mixed), LMC
rate, MAM-OOO rate, resources/contact, length profile
(short/mixed/long/extreme). Emits the canonical
flatlog/<account>/<contact>/history.log layout used by
ff_verify_integrity. ~340 LOC.
bench_runner (P1, P2.5)
S1 cold tail-access via sparse index
S2 warm tail-access (page cache hot)
S3 deep pagination (1000 binary-search lookups)
S4 first-time index build (cold file -> ff_state_ensure_fresh)
S5 incremental extend (asserts no full rebuild path)
S6 real ff_verify_integrity over the contact tree
Reports total/err/warn/info issue counts in the CSV note.
bench_long_messages (P2)
L1-L14 long-message stress: 1KB up to 9.9MB bodies, plus
oversized line rejection (10MB+1 -> ff_readline returns ""),
embedded-newline / pipe / emoji body patterns, full parse on
100x1MB, 1000x100KB sustained append.
bench_failure_modes (P3)
F1-F15 failure-injection: truncated last line, mid-file CRLF,
mid-file BOM, LMC cycle, LMC depth>FF_MAX_LMC_DEPTH, manual
': ' in resource, RTL/ZWSP, Latin-1 byte, empty body,
mtime/inode flip, empty file. Each test asserts expected issue
levels and reports PASS/FAIL.
bench_export_import (P5)
Links real database_export.c + database_sqlite.c + database.c
and drives log_database_export_to_flatfile /
log_database_import_from_flatfile under load.
Subcommands: seed, export, import, roundtrip, verify.
S7a/b export, S8a/b import, S8e roundtrip with full byte-by-byte
content diff of every row in (from_jid, to_jid, message,
timestamp, type, stanza_id, archive_id, encryption, replace_id).
Make targets
bench-quick / bench / bench-full
bench-longmsg, bench-failure
bench-multicontact, bench-lmc, bench-ooo
bench-export, bench-import, bench-roundtrip
bench-pipeline, bench-pipeline-max (1M rows)
bench-compare, bench-update-baseline
Volume controls: BENCH_VOLUME (small/medium/max), BENCH_PIPE_ROWS,
BENCH_PIPE_ROWS_MAX, BENCH_DATA_DIR, BENCH_CSV.
Baseline + regression checking (P4)
tests/bench/baseline.csv 51 rows: S1-S6 x {small,lmc,ooo}
+ L1-L14 + F1-F15 (11 of 15) +
S7/S8 x {pipe100k, pipe1M}.
compare_baseline.py median over duplicate rows;
exits 1 on any (scenario, volume)
slowdown >= threshold (default 25%).
Verified at scale
bench-pipeline-max: 1,000,000 rows, full content diff
seed 17 s, export 304 s, import 31 s, idempotent re-import 10 s,
diff 2.7 s -- mismatches=0.
Findings surfaced by the harness
Export scales super-linearly: 4 s @ 100k -> 304 s @ 1M (76x for
10x rows). Cause: g_slist_sort on the merged list + per-row
ProfMessage/ff_parsed_line_t allocations. RSS peaks at 1.4 GB
on 1M. Worth a follow-up.
Export progress reporting only fires during the write phase --
the merge+sort phase (~95% of wall time at 1M) is silent.
/history export and /history import are blocking on the main
UI thread; profanity is frozen for the duration (~5 min @ 1M).
ff_readline sets *truncated=TRUE on partial-write tail but
ff_verify_integrity does not surface this -- partial writes
go unflagged (failure-injection F1).
Parser silently truncates body at first unescaped ': ' if a
resource was manually edited to contain it (F9).
In gen_history (caught by the bench's own real-verify pass):
g_strndup mid-codepoint truncation on UTF-8 bank strings -- fixed.
Linkage strategy
database_flatfile.c + parser + verify + common.c are linked
unconditionally. The export/import bench additionally links
database.c + database_sqlite.c + database_export.c. bench_stubs.c
provides minimal stubs for log_*, prefs_*, connection_get_jid,
jid_create, files_*, message_*, ui hooks. integrity_issue_free
is a weak symbol so it falls back to the real database.c
implementation when that file is linked.
133 lines
3.1 KiB
C
133 lines
3.1 KiB
C
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
//
|
|
// This file is part of CProof.
|
|
// See LICENSE for the full GPLv3 text and the special OpenSSL linking exception.
|
|
|
|
#include "bench_common.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/statvfs.h>
|
|
#include <sys/time.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
|
|
double
|
|
bench_now_ms(void)
|
|
{
|
|
struct timespec ts;
|
|
clock_gettime(CLOCK_MONOTONIC, &ts);
|
|
return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1.0e6;
|
|
}
|
|
|
|
char*
|
|
bench_fmt_bytes(uint64_t bytes)
|
|
{
|
|
static const char* units[] = { "B", "KB", "MB", "GB", "TB" };
|
|
int u = 0;
|
|
double v = (double)bytes;
|
|
while (v >= 1024.0 && u < 4) {
|
|
v /= 1024.0;
|
|
u++;
|
|
}
|
|
if (u == 0)
|
|
return g_strdup_printf("%" G_GUINT64_FORMAT " %s", bytes, units[u]);
|
|
return g_strdup_printf("%.2f %s", v, units[u]);
|
|
}
|
|
|
|
char*
|
|
bench_fmt_ms(double ms)
|
|
{
|
|
if (ms < 1.0)
|
|
return g_strdup_printf("%.0f us", ms * 1000.0);
|
|
if (ms < 1000.0)
|
|
return g_strdup_printf("%.1f ms", ms);
|
|
if (ms < 60000.0)
|
|
return g_strdup_printf("%.2f s", ms / 1000.0);
|
|
return g_strdup_printf("%.1f min", ms / 60000.0);
|
|
}
|
|
|
|
bench_volume_t
|
|
bench_volume_from_env(void)
|
|
{
|
|
const char* v = getenv("BENCH_VOLUME");
|
|
if (!v || !v[0])
|
|
return BENCH_VOLUME_MEDIUM;
|
|
if (g_ascii_strcasecmp(v, "small") == 0)
|
|
return BENCH_VOLUME_SMALL;
|
|
if (g_ascii_strcasecmp(v, "medium") == 0)
|
|
return BENCH_VOLUME_MEDIUM;
|
|
if (g_ascii_strcasecmp(v, "max") == 0)
|
|
return BENCH_VOLUME_MAX;
|
|
fprintf(stderr, "WARN: unknown BENCH_VOLUME='%s', defaulting to medium\n", v);
|
|
return BENCH_VOLUME_MEDIUM;
|
|
}
|
|
|
|
const char*
|
|
bench_volume_name(bench_volume_t v)
|
|
{
|
|
switch (v) {
|
|
case BENCH_VOLUME_SMALL: return "small";
|
|
case BENCH_VOLUME_MEDIUM: return "medium";
|
|
case BENCH_VOLUME_MAX: return "max";
|
|
}
|
|
return "?";
|
|
}
|
|
|
|
gboolean
|
|
bench_drop_page_cache(const char* path)
|
|
{
|
|
int fd = open(path, O_RDONLY);
|
|
if (fd < 0)
|
|
return FALSE;
|
|
#ifdef POSIX_FADV_DONTNEED
|
|
// Best-effort: kernel may ignore but typically honours.
|
|
posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
|
|
#endif
|
|
close(fd);
|
|
return TRUE;
|
|
}
|
|
|
|
int64_t
|
|
bench_fs_free_bytes(const char* path)
|
|
{
|
|
struct statvfs vfs;
|
|
if (statvfs(path, &vfs) != 0)
|
|
return -1;
|
|
return (int64_t)vfs.f_bavail * (int64_t)vfs.f_frsize;
|
|
}
|
|
|
|
long
|
|
bench_peak_rss_kb(void)
|
|
{
|
|
struct rusage ru;
|
|
if (getrusage(RUSAGE_SELF, &ru) != 0)
|
|
return -1;
|
|
return ru.ru_maxrss; // already KB on Linux
|
|
}
|
|
|
|
double
|
|
bench_run_best_of(int runs, bench_fn_t fn, void* arg, long* peak_rss_kb)
|
|
{
|
|
if (runs < 1)
|
|
runs = 1;
|
|
double best = 0.0;
|
|
long max_rss = 0;
|
|
for (int i = 0; i < runs; i++) {
|
|
double t0 = bench_now_ms();
|
|
fn(arg);
|
|
double dt = bench_now_ms() - t0;
|
|
if (i == 0 || dt < best)
|
|
best = dt;
|
|
long rss = bench_peak_rss_kb();
|
|
if (rss > max_rss)
|
|
max_rss = rss;
|
|
}
|
|
if (peak_rss_kb)
|
|
*peak_rss_kb = max_rss;
|
|
return best;
|
|
}
|