1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
//! Comptime reflection of a sketch's memory into `abi.Layout`.
//!
//! Structs are flattened into dotted leaf paths; everything else (arrays,
//! optionals, unions) is one leaf. Each leaf carries a structural hash of its
//! type, so a host can tell, across a reload, which bytes still mean the same
//! thing.
//!
//! State is saved to disk and snapshotted, so it may not hold pointers at all.
//! Session memory lives only in the host process and may point into memory
//! the host owns (its heap, mapped files), never into the sketch library.
const std = @import("std");
const abi = @import("abi.zig");
pub const Pointers = enum { forbidden, host_only };
pub fn of(comptime T: type, comptime pointers: Pointers) abi.Layout {
return comptime blk: {
@setEvalBranchQuota(1_000_000);
if (pointers == .forbidden) noPointers(T, @typeName(T));
const Leaves = struct {
const list = flatten(T, "", 0);
const fields: [list.len]abi.Field = list[0..list.len].*;
};
break :blk .{
.size = @sizeOf(T),
.alignment = @alignOf(T),
.hash = hash(T),
.fields = &Leaves.fields,
};
};
}
fn flatten(comptime T: type, comptime prefix: []const u8, comptime base: usize) []const abi.Field {
comptime {
if (@typeInfo(T) != .@"struct") return &.{leaf(T, if (prefix.len == 0) "value" else prefix, base)};
var leaves: []const abi.Field = &.{};
for (@typeInfo(T).@"struct".fields) |field| {
if (field.is_comptime or @sizeOf(field.type) == 0) continue;
const path = if (prefix.len == 0) field.name else prefix ++ "." ++ field.name;
const offset = base + @offsetOf(T, field.name);
leaves = leaves ++ if (@typeInfo(field.type) == .@"struct" and @typeInfo(field.type).@"struct".backing_integer == null)
flatten(field.type, path, offset)
else
&[_]abi.Field{leaf(field.type, path, offset)};
}
return leaves;
}
}
fn leaf(comptime T: type, comptime path: []const u8, comptime offset: usize) abi.Field {
comptime {
const kind: abi.Field.Kind = switch (@typeInfo(T)) {
.int => |i| if (i.signedness == .signed) .int else .uint,
.float => .float,
.bool => .bool,
.@"enum" => .@"enum",
.array => .array,
else => .bytes,
};
return .{
.path = std.fmt.comptimePrint("{s}", .{path}),
.offset = offset,
.size = @sizeOf(T),
.kind = kind,
.hash = hash(T),
.tags = if (kind == .@"enum") tags(T) else "",
};
}
}
fn noPointers(comptime T: type, comptime path: []const u8) void {
comptime switch (@typeInfo(T)) {
.pointer => @compileError("State cannot hold pointers (" ++ path ++ "): it is saved to disk and outlives every address. Store handles, indices or offsets, or keep it in Session."),
.array => |a| noPointers(a.child, path ++ "[]"),
.vector => |v| noPointers(v.child, path ++ "[]"),
.optional => |o| noPointers(o.child, path),
.@"struct" => |s| for (s.fields) |f| noPointers(f.type, path ++ "." ++ f.name),
.@"union" => |u| for (u.fields) |f| noPointers(f.type, path ++ "." ++ f.name),
else => {},
};
}
fn tags(comptime E: type) [:0]const u8 {
comptime {
var text: []const u8 = "";
for (@typeInfo(E).@"enum".fields, 0..) |field, i| {
text = text ++ (if (i == 0) "" else ",") ++ std.fmt.comptimePrint("{s}={d}", .{ field.name, field.value });
}
return std.fmt.comptimePrint("{s}", .{text});
}
}
/// Equal hashes mean the bytes can be copied and keep their meaning. Enum
/// leaves also carry their tags, so a host can remap them by name.
pub fn hash(comptime T: type) u64 {
return comptime blk: {
@setEvalBranchQuota(1_000_000);
break :blk std.hash.Wyhash.hash(0, signature(T));
};
}
pub fn signature(comptime T: type) []const u8 {
comptime {
return switch (@typeInfo(T)) {
.int => |i| std.fmt.comptimePrint("{c}{d}", .{ if (i.signedness == .signed) 'i' else 'u', i.bits }),
.float => |f| std.fmt.comptimePrint("f{d}", .{f.bits}),
.bool => "b",
.void => "v",
.@"enum" => |e| "e(" ++ signature(e.tag_type) ++ ":" ++ tags(T) ++ ")",
.array => |a| std.fmt.comptimePrint("[{d}]", .{a.len}) ++ signature(a.child),
.vector => |v| std.fmt.comptimePrint("@{d}", .{v.len}) ++ signature(v.child),
.optional => |o| "?" ++ signature(o.child),
.@"struct" => |s| blk: {
var text: []const u8 = std.fmt.comptimePrint("s{d}{{", .{@sizeOf(T)});
for (s.fields) |field| {
if (field.is_comptime) continue;
text = text ++ std.fmt.comptimePrint("{s}@{d}:", .{ field.name, @offsetOf(T, field.name) }) ++ signature(field.type) ++ ";";
}
break :blk text ++ "}";
},
.@"union" => |u| blk: {
var text: []const u8 = std.fmt.comptimePrint("u{d}{{", .{@sizeOf(T)});
if (u.tag_type) |tag| text = text ++ signature(tag) ++ "|";
for (u.fields) |field| text = text ++ field.name ++ ":" ++ signature(field.type) ++ ";";
break :blk text ++ "}";
},
.pointer => |p| std.fmt.comptimePrint("*{s}:{s}", .{ @tagName(p.size), @typeName(p.child) }),
.@"opaque" => "opaque",
.@"fn" => @typeName(T),
else => @compileError("unsupported type in sketch memory: " ++ @typeName(T)),
};
}
}
test "leaves flatten structs, keep arrays whole and reject nothing pointer-free" {
const Inner = extern struct { a: u8 = 0, b: enum(u8) { x, y = 5 } = .x };
const S = extern struct { inner: Inner = .{}, list: [4]f32 = @splat(0), flag: bool = false };
const l = of(S, .forbidden);
const fields = l.fields;
try std.testing.expectEqual(4, fields.len);
try std.testing.expectEqualStrings("inner.a", std.mem.span(fields[0].path));
try std.testing.expectEqualStrings("inner.b", std.mem.span(fields[1].path));
try std.testing.expectEqualStrings("x=0,y=5", std.mem.span(fields[1].tags));
try std.testing.expectEqual(abi.Field.Kind.array, fields[2].kind);
try std.testing.expectEqual(@as(u32, 4), fields[2].offset);
try std.testing.expect(hash([4]f32) != hash([5]f32));
try std.testing.expect(hash(enum(u8) { a }) != hash(enum(u8) { a, b }));
}
|