test(perf): rebuild gate in the §1.1 shape on both dialects, every column compared

- The rebuild gate adopts 400 sequences of 250 real photos (one fifth of the
  §1.1 library, same frames per sequence) and runs on SQLite and PostgreSQL.
- The rebuilt index is compared with the original in every column of every
  sequence and frame (only UpdatedAt, the rebuild time, is left out), and the
  first differing row is named.
- Synthetic frames are seeded by the sequence's position, so every run builds
  the same library; the Library open gate says it runs on a new connection pool
  with a warm OS cache instead of calling it cold.

Measured locally (PostgreSQL 16): Library open 259 ms SQLite / 181 ms PostgreSQL,
filters <= 6.4 ms; rebuild of 100,000 frames 1.8 s SQLite / 4.7 s PostgreSQL
(budget 120 s).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
Claude committed 2026-10-03 10:13:06 +00:00
1 parent 411425b83a
commit 54fa588ecc
3 files changed
+86 -51

No files matched your search

@@ -7,8 +7,10 @@ namespace Titano.Data.Tests.Perf;
/// <summary>
/// §1.1 / Phase 3 gate on the 500,000-photo library: the Library opens (archive totals, filter lists and the first
/// page, exactly what the Library screen asks at start) in under 1 s on a cold index, and every filter, search and
/// sort answers its first page plus the total in under 200 ms. Opt-in: <c>TITANO_PERF=1</c>.
/// page, exactly what the Library screen asks at start) in under 1 s on its first query through a new connection pool,
/// and every filter, search and sort answers its first page plus the total in under 200 ms. The index was just written
/// by the same machine, so the OS page cache (and PostgreSQL's shared buffers) are warm: the gate covers query plans
/// and indexes, not a disk read after a reboot. Opt-in: <c>TITANO_PERF=1</c>.
/// </summary>
[Category("perf")]
[RequiresEnvironment(PerfGate.Variable)]
@@ -25,14 +27,14 @@ public abstract class LibraryPerfTests(TestContext context) : RepositoryTest(con
var options = await NewOptionsAsync(multiConnection: true);
await using (var build = await TitanoDatabase.OpenAsync(options, Ct)) await SyntheticLibrary.BuildAsync(build, Context);
// A new connection pool and page cache, as at application start.
// A new connection pool and SQLite page cache, as at application start.
var db = Own(await TitanoDatabase.OpenAsync(options, Ct));
var cold = await PerfGate.TimeAsync(() => OpenLibraryAsync(db));
var warm = await PerfGate.MedianAsync(() => OpenLibraryAsync(db));
Context.Log($"perf: {Dialect} library open {cold:F0} ms cold, {warm:F0} ms warm (budget {OpenBudgetMs:F0} ms)");
var first = await PerfGate.TimeAsync(() => OpenLibraryAsync(db));
var again = await PerfGate.MedianAsync(() => OpenLibraryAsync(db));
Context.Log($"perf: {Dialect} library open {first:F0} ms first, {again:F0} ms again (budget {OpenBudgetMs:F0} ms)");
var failures = new List<string>();
if (cold > OpenBudgetMs) failures.Add($"open {cold:F0} ms");
if (first > OpenBudgetMs) failures.Add($"open {first:F0} ms");
var firstPage = await db.Sequences.ListAsync(new SequenceQuery { Limit = 200 }, Ct);
foreach (var (name, query) in Filters(firstPage.NextCursor))
{
@@ -1,85 +1,117 @@
using System.Diagnostics;
using System.Text;
using System.Globalization;
using System.Text.Json;
using Titano.Core.Archiving;
using Titano.Core.Model;
using Titano.Data.Archiving;
using Titano.Data.Tests.Archiving;
using Titano.Data.Tests.Infrastructure;
using Titano.Testing;
namespace Titano.Data.Tests.Perf;
/// <summary>
/// Phase 2 gate, §1.1 scaled: a 100,000-frame archive adopted from real files, then its index thrown away and rebuilt
/// from the sidecars alone. The rebuilt index must equal the original row for row, within a fifth of the 10-minute
/// budget §1.1 gives 500,000 photos. Opt-in: <c>TITANO_PERF=1</c>.
/// Phase 2 gate, §1.1 scaled to one fifth: 400 sequences of 250 real photos (100,000 frames; the §1.1 shape has 2,000
/// such sequences) adopted from files, then the index thrown away and rebuilt from the archive — once with the index
/// snapshot the scan left behind and once from the sidecars alone. The rebuilt index must equal the original in every
/// column of every sequence and frame (only <see cref="Sequence.UpdatedAt"/>, the time of the rebuild, may differ),
/// within a fifth of the 10 minutes §1.1 allows for 500,000 photos. Opt-in: <c>TITANO_PERF=1</c>.
/// </summary>
[Category("perf")]
[RequiresEnvironment(PerfGate.Variable)]
[Serial]
[Timeout(3_600_000)]
public sealed class RebuildPerfTests(TestContext context)
public abstract class RebuildPerfTests(TestContext context) : DatabaseTest(context)
{
public const int Sequences = 40;
public const int FramesPerSequence = 2_500;
public const double RebuildBudgetSeconds = 600.0 * Sequences * FramesPerSequence / 500_000;
public const int Scale = 5;
public const int Sequences = SyntheticLibrary.Sequences / Scale;
public const int FramesPerSequence = SyntheticLibrary.FramesPerSequence;
public const double RebuildBudgetSeconds = 600.0 / Scale;
private static readonly JsonSerializerOptions Json = new() { WriteIndented = false };
[Test]
public async Task AHundredThousandFrameArchiveRebuildsFromSidecarsAlone()
{
await using var fx = await ArchiveFixture.CreateAsync(context);
var root = Context.CreateTempDirectory("archive");
var watch = Stopwatch.StartNew();
Parallel.For(0, Sequences, new ParallelOptions { CancellationToken = fx.Ct }, s =>
Parallel.For(0, Sequences, new ParallelOptions { CancellationToken = Ct }, s =>
{
var start = ArchiveFixture.Start.AddDays(3 * s);
var folder = Path.Combine(fx.Paths.Root, start.Year.ToString(System.Globalization.CultureInfo.InvariantCulture), $"{start:yyyy-MM-dd} Roof {s:00}", "originals");
var folder = Path.Combine(root, start.Year.ToString(CultureInfo.InvariantCulture), $"{start:yyyy-MM-dd} Roof {s:000}", "originals");
Photos.WriteSeries(folder, start, FramesPerSequence, firstSeed: 1 + s * FramesPerSequence);
});
context.Log($"perf: wrote {Sequences * FramesPerSequence:N0} photos in {watch.Elapsed.TotalSeconds:F1} s");
Context.Log($"perf: wrote {Sequences * FramesPerSequence:N0} photos in {Sequences:N0} folders in {watch.Elapsed.TotalSeconds:F1} s");
var (db, service, archive) = await OpenIndexAsync(root, adopt: true);
watch.Restart();
var adopted = await fx.ScanAsync(ScanMode.Full);
context.Log($"perf: adopted {adopted.Adopted} folders in {watch.Elapsed.TotalSeconds:F1} s");
var adopted = await service.Indexer.ScanAsync(archive, ScanMode.Full, null, _ => ValueTask.CompletedTask, Ct);
Context.Log($"perf: {Dialect} adopted {adopted.Adopted} folders in {watch.Elapsed.TotalSeconds:F1} s");
Assert.Equal(Sequences, adopted.Adopted);
Assert.Empty(adopted.Failed);
var original = await DumpAsync(fx);
var original = await DumpAsync(db, archive.Id);
Assert.Equal(Sequences * (FramesPerSequence + 1), original.Count);
// With the index snapshot the full scan left behind, then from the sidecar files alone (snapshot lost).
foreach (var snapshot in new[] { true, false })
{
if (!snapshot) File.Delete(fx.Paths.SnapshotPath);
await fx.ReopenWithEmptyIndexAsync();
if (!snapshot) File.Delete(new ArchivePaths(root).SnapshotPath);
var (freshDb, fresh, reopened) = await OpenIndexAsync(root, adopt: false);
watch.Restart();
var rebuilt = await fx.ScanAsync(ScanMode.Rebuild);
var rebuilt = await fresh.Indexer.ScanAsync(reopened, ScanMode.Rebuild, null, _ => ValueTask.CompletedTask, Ct);
var seconds = watch.Elapsed.TotalSeconds;
context.Log($"perf: rebuilt {Sequences * FramesPerSequence:N0} frames {(snapshot ? "with" : "without")} the snapshot in {seconds:F1} s (budget {RebuildBudgetSeconds:F0} s)");
Context.Log($"perf: {Dialect} rebuilt {Sequences * FramesPerSequence:N0} frames {(snapshot ? "with" : "without")} the snapshot in {seconds:F1} s (budget {RebuildBudgetSeconds:F0} s)");
Assert.Equal((Sequences, 0), (rebuilt.Indexed, rebuilt.Adopted));
Assert.Equal(original, await DumpAsync(fx));
AssertSameIndex(original, await DumpAsync(freshDb, reopened.Id));
Assert.Less(seconds, RebuildBudgetSeconds, "rebuild from sidecars");
}
}
/// <summary>Every sequence row and every frame row (paged), in folder and index order.</summary>
private static async Task<string> DumpAsync(ArchiveFixture fx)
/// <summary>A new empty index of this test's dialect with the archive at <paramref name="root"/> adopted or opened in it.</summary>
private async Task<(TitanoDatabase Db, ArchiveService Service, Archive Archive)> OpenIndexAsync(string root, bool adopt)
{
var sb = new StringBuilder();
var frames = 0;
foreach (var location in await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id, fx.Ct))
var db = Own(await TitanoDatabase.OpenAsync(await NewOptionsAsync(multiConnection: true), Ct));
var service = new ArchiveService(db, new ArchiveServiceOptions { Owner = "perf", LeaseWait = TimeSpan.FromSeconds(20) });
var archive = adopt ? await service.AdoptAsync(root, "Main", Ct) : await service.OpenAsync(root, Ct);
return (db, service, archive);
}
/// <summary>Every sequence and frame row as JSON with all its columns, in folder and index order.</summary>
private async Task<List<string>> DumpAsync(TitanoDatabase db, Guid archiveId)
{
var rows = new List<string>();
foreach (var location in await db.Sequences.ListLocationsAsync(archiveId, Ct))
{
var s = (await fx.Db.Sequences.GetAsync(location.Id, fx.Ct))!;
sb.Append($"S {s.Id} {s.Folder} '{s.Title}' {s.CameraModel} {s.FirstCapture:O} {s.FrameCount} {s.TotalBytes} {s.Status} ")
.AppendLine($"{s.VerifiedAt:O} {string.Join('|', s.Tags)} {s.SettingsVersion}/{s.FramesVersion} {s.MedianInterval}");
var sequence = JsonSerializer.SerializeToNode((await db.Sequences.GetAsync(location.Id, Ct))!, Json)!.AsObject();
sequence.Remove(nameof(Sequence.UpdatedAt));
rows.Add("S " + sequence.ToJsonString(Json));
var after = -1;
while (true)
while (await db.Frames.ListBySequenceAsync(location.Id, after, 1000, Ct) is { Count: > 0 } page)
{
var page = await fx.Db.Frames.ListBySequenceAsync(s.Id, after, 1000, fx.Ct);
if (page.Count == 0) break;
foreach (var f in page)
{
sb.AppendLine($" F {f.Id} {f.Index} {f.RelativePath} {f.OriginalFileName} {f.Size} {f.Sha256} {f.CapturedAt:O} {f.Width}x{f.Height} {f.Format} {f.Flags}");
frames++;
}
rows.AddRange(page.Select(f => " F " + JsonSerializer.Serialize(f, Json)));
after = page[^1].Index;
}
}
Assert.Equal(Sequences * FramesPerSequence, frames);
return sb.ToString();
return rows;
}
/// <summary>Equal row for row; a difference names its first row instead of printing two 100,000-line dumps.</summary>
private static void AssertSameIndex(List<string> expected, List<string> actual)
{
for (var i = 0; i < System.Math.Min(expected.Count, actual.Count); i++)
{
if (expected[i] != actual[i]) Assert.Fail($"row {i} differs after the rebuild:\n before {expected[i]}\n after {actual[i]}");
}
Assert.Equal(expected.Count, actual.Count, "rows after the rebuild");
}
}
public sealed class SqliteRebuildPerfTests(TestContext context) : RebuildPerfTests(context)
{
protected override Backend Backend => Backend.SqliteFile;
}
[RequiresEnvironment(PgTestServer.Variable)]
public sealed class PostgresRebuildPerfTests(TestContext context) : RebuildPerfTests(context)
{
protected override Backend Backend => Backend.Postgres;
}
@@ -7,8 +7,8 @@ namespace Titano.Data.Tests.Perf;
/// <summary>
/// The §1.1 library: 2,000 sequences of 250 photos (500,000 frames) over twelve years, a dozen cameras, sixty tags and
/// mixed status flags, written straight into the index (no files). Titles, cameras, dates, tags and flags follow the
/// seed; ids and hashes are random.
/// mixed status flags, written straight into the index (no files). Everything but ids and hashes follows the seed, so
/// every run measures the same library.
/// </summary>
internal static class SyntheticLibrary
{
@@ -75,14 +75,15 @@ internal static class SyntheticLibrary
});
}
foreach (var s in sequences) await db.Sequences.UpsertAsync(s, context.Cancellation);
await db.Frames.BulkInsertAsync(sequences.SelectMany(s => Frames(s, seed)), context.Cancellation);
await db.Frames.BulkInsertAsync(sequences.SelectMany((s, i) => Frames(s, seed, i)), context.Cancellation);
context.Log($"perf: built {Sequences:N0} sequences / {Photos:N0} photos in {watch.Elapsed.TotalSeconds:F1} s");
return archive;
}
private static IEnumerable<Frame> Frames(Sequence sequence, int seed)
private static IEnumerable<Frame> Frames(Sequence sequence, int seed, int index)
{
var random = new Random(HashCode.Combine(seed, sequence.Id));
// Seeded by the sequence's position, not its random id, so every run builds the same frames.
var random = new Random(unchecked((seed * 100_003) + index));
var format = Formats[random.Next(Formats.Length)];
for (var i = 0; i < FramesPerSequence; i++)
{