diff --git a/tests/Titano.Data.Tests/Perf/LibraryPerfTests.cs b/tests/Titano.Data.Tests/Perf/LibraryPerfTests.cs
index ffbcc0ed..d8b33241 100644
--- a/tests/Titano.Data.Tests/Perf/LibraryPerfTests.cs
+++ b/tests/Titano.Data.Tests/Perf/LibraryPerfTests.cs
@@ -7,8 +7,10 @@ namespace Titano.Data.Tests.Perf;
///
/// §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: TITANO_PERF=1.
+/// 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: TITANO_PERF=1.
///
[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();
- 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))
{
diff --git a/tests/Titano.Data.Tests/Perf/RebuildPerfTests.cs b/tests/Titano.Data.Tests/Perf/RebuildPerfTests.cs
index 328d9b64..757ed21c 100644
--- a/tests/Titano.Data.Tests/Perf/RebuildPerfTests.cs
+++ b/tests/Titano.Data.Tests/Perf/RebuildPerfTests.cs
@@ -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;
///
-/// 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: TITANO_PERF=1.
+/// 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 , the time of the rebuild, may differ),
+/// within a fifth of the 10 minutes §1.1 allows for 500,000 photos. Opt-in: TITANO_PERF=1.
///
[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");
}
}
- /// Every sequence row and every frame row (paged), in folder and index order.
- private static async Task DumpAsync(ArchiveFixture fx)
+ /// A new empty index of this test's dialect with the archive at adopted or opened in it.
+ 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);
+ }
+
+ /// Every sequence and frame row as JSON with all its columns, in folder and index order.
+ private async Task> DumpAsync(TitanoDatabase db, Guid archiveId)
+ {
+ var rows = new List();
+ 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;
+ }
+
+ /// Equal row for row; a difference names its first row instead of printing two 100,000-line dumps.
+ private static void AssertSameIndex(List expected, List 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;
+}
diff --git a/tests/Titano.Data.Tests/Perf/SyntheticLibrary.cs b/tests/Titano.Data.Tests/Perf/SyntheticLibrary.cs
index aa1c286f..8034de8b 100644
--- a/tests/Titano.Data.Tests/Perf/SyntheticLibrary.cs
+++ b/tests/Titano.Data.Tests/Perf/SyntheticLibrary.cs
@@ -7,8 +7,8 @@ namespace Titano.Data.Tests.Perf;
///
/// 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.
///
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 Frames(Sequence sequence, int seed)
+ private static IEnumerable 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++)
{