summaryrefslogtreecommitdiff
path: root/src/rollback.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/rollback.zig')
-rw-r--r--src/rollback.zig36
1 files changed, 5 insertions, 31 deletions
diff --git a/src/rollback.zig b/src/rollback.zig
index a7027da6..37fc481d 100644
--- a/src/rollback.zig
+++ b/src/rollback.zig
@@ -35,8 +35,8 @@ const Allocator = std.mem.Allocator;
const Alignment = std.mem.Alignment;
const Pardes = pardes.Pardes;
-/// Blobs this long or longer (`pinned`) are pinned, not copied. Checked
-/// unchanged in a safe build when the copy goes.
+/// Blobs (walk.blob: fields annotated `.blob`) this long or longer are
+/// pinned, not copied. Checked unchanged in a safe build when the copy goes.
const blob_min = 4096;
const checked = builtin.mode == .debug or builtin.mode == .safe;
@@ -198,8 +198,6 @@ pub const Copy = struct {
/// of the blobs: a file's text or an undo snapshot's.
where: []const u8 = "",
pinnable: bool = false,
- /// Whether it is a blob of rows that own allocations of their own.
- deep: bool = false,
const Region = struct { addr: usize, off: usize, len: usize };
const Pin = struct { addr: usize, len: usize, hash: u64, where: []const u8 };
@@ -344,8 +342,7 @@ pub const Copy = struct {
if (attr.@"comptime" or comptime (annotated(T, "authority", name) or ((annotated(T, "local", name) or annotated(T, "derived", name)) and unsaved(name)))) continue;
if (comptime opaqueTo(F)) continue;
c.where = @typeName(T) ++ "." ++ name;
- c.pinnable = comptime pinned(T, name);
- c.deep = comptime pinnedDeep(T, name);
+ c.pinnable = comptime walk.blob(T, name);
if (comptime walk.lengthOf(T, name) != null and @typeInfo(F) == .array) {
const len = comptime walk.lengthOf(T, name).?;
if (comptime heapIn(@typeInfo(F).array.child, 0)) for (@field(v, name)[0..walk.lengthIn(v, len)]) |*e| try c.visit(@typeInfo(F).array.child, e);
@@ -398,9 +395,8 @@ pub const Copy = struct {
if (s.len == 0) return;
const addr = @intFromPtr(s.ptr);
if (try c.reached([]const E, addr)) return;
- const flat = comptime !heapIn(E, 0);
- if ((if (flat) c.pinnable else c.deep) and s.len * @sizeOf(E) >= blob_min and c.epoch.?.owns(addr) != null) {
- // A blob of rows with allocations of their own pinned whole:
+ if (c.pinnable and s.len * @sizeOf(E) >= blob_min and c.epoch.?.owns(addr) != null) {
+ // A blob of rows with allocations of their own is pinned whole:
// they are as immutable as it, and kept alive with it.
const bytes = std.mem.sliceAsBytes(s);
try c.pins.append(c.meta, .{ .addr = addr, .len = bytes.len, .hash = if (checked) std.hash.Wyhash.hash(0, bytes) else 0, .where = c.where });
@@ -411,28 +407,6 @@ pub const Copy = struct {
}
};
-/// The blobs: what an edit puts in place of its predecessor, never writes
-/// (File.setContentSpan), and frees raw (memory.freeUnfilled, freeRaw).
-fn pinned(comptime T: type, comptime name: []const u8) bool {
- const File = pardes.panes.File;
- return (T == File.State and (std.mem.eql(u8, name, "content") or std.mem.eql(u8, name, "line_starts"))) or
- (T == File.Snapshot and std.mem.eql(u8, name, "content")) or
- // A register's values and joined text: a yank of a terminal's whole
- // grid is megabytes, which every speculation would otherwise copy.
- (T == pardes.Registers.Reg and (std.mem.eql(u8, name, "values") or std.mem.eql(u8, name, "joined")));
-}
-
-/// Blobs of rows that own allocations of their own (a location's path, its
-/// colours), the array and they replaced whole and never written, freed raw
-/// (locations.freeRows): a file's location rows (5 MB after a flood of
-/// search results), the ones an edit dropped, a query's saved.
-fn pinnedDeep(comptime T: type, comptime name: []const u8) bool {
- const File = pardes.panes.File;
- return (T == File.State and std.mem.eql(u8, name, "location_rows")) or
- (T == File.DroppedMarks and std.mem.eql(u8, name, "rows")) or
- (T == pardes.panes.Query.Saved and std.mem.eql(u8, name, "rows"));
-}
-
fn annotatedStruct(comptime T: type) bool {
return @typeInfo(T) == .@"struct" and @hasDecl(T, "replica");
}