From 470b8098a53ad3b3b0a2ef90f0d43416ea50a9b0 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Fri, 30 Oct 2026 15:38:35 -0300 Subject: Places: the lowered copy a smart-case search reads is zeroed where it is made: its pieces not lowered yet were whatever the heap held, in every digest and a join's dump, so two processes' places differed (H5's and H17's `places.hits|hay`) freshHay took `memory.unfilled` and lowered a piece at a time as the search reached it; the digest and the dump take the whole slice. Zeroing it costs 20 us for 1 MB, 0.4 ms for 10 MB and 10 ms for 100 MB in one frame (ReleaseFast, page faults included; lowering the same text is four times that, spread over frames), the order of the copy an edit of that text already makes. Test (failing before): two sessions searching one text, each heap handing out other bytes (rollback.Epoch.fill), digest the same places. Co-Authored-By: Claude Opus 5.5 --- src/Places.zig | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) (limited to 'src/Places.zig') diff --git a/src/Places.zig b/src/Places.zig index 3dca3adf..818ca1d7 100644 --- a/src/Places.zig +++ b/src/Places.zig @@ -264,6 +264,14 @@ fn freshHay(set: *Places, gpa: std.mem.Allocator, f: *File.State) bool { if (set.hay.len > 0) gpa.rawFree(set.hay, .of(u8), @returnAddress()); set.hay = &.{}; set.hay = memory.unfilled(gpa, f.content.len) catch return false; + // What is not lowered yet is in the digest and a dump as well: zeros, + // the same in every process, not whatever its heap held (a replica's + // diverged). A pass over the text, as the edit that made it was. + // ponytail: 0.4 ms for 10 MB, 10 ms for 100 MB in one frame (ReleaseFast, + // page faults and all; lowering it is four times that, over frames). A + // digest and a dump of the lowered pieces alone if a huge text's first + // search ever shows. + @memset(set.hay, 0); set.low.resize(gpa, (f.content.len + chunk_bytes - 1) / chunk_bytes, false) catch return false; set.low.unsetAll(); set.hay_revision = f.revision; @@ -880,3 +888,27 @@ test "zz stress analysis cost" { std.testing.allocator.free(a.colors); std.debug.print("decls {d} us ({d}), analysis with colours {d} us\n", .{ (t1 - t0) / 1000, d.len, (t2 - t1) / 1000 }); } + +test "a lowered copy's pieces not searched yet are the same in every process: a digest and a dump take them" { + // Two sessions searching one text, each heap handing out other bytes in + // what is not written yet (rollback.Epoch.fill): their places agree. + const rollback = @import("rollback.zig"); + var text: std.ArrayList(u8) = .empty; + defer text.deinit(std.testing.allocator); + for (0..2000) |i| try text.print(std.testing.allocator, "line {d} of a text in four pieces\n", .{i}); + var digests: [2]u64 = undefined; + for (&digests, [_]u8{ 0x11, 0x5a }) |*d, b| { + var e: rollback.Epoch = .{ .child = std.testing.allocator }; + defer e.deinit(); + rollback.Epoch.fill = b; + defer rollback.Epoch.fill = null; + const p = try Pardes.init(e.allocator(), .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + const pane = try p.setTestFile(text.items); + // The view's piece found now, the rest a frame at a time after. + pane.places.search(p, pane, .typed, 0, "piece", false, null, false); + try std.testing.expect(!pane.places.complete() and pane.places.fold); + d.* = pardes.walk.digest(Places, &pane.places); + } + try std.testing.expectEqual(digests[0], digests[1]); +} -- cgit v1.3