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++) {