tricu

io_v2_native.zig (4213B)

---

 //! Native v2 entry boundary. Never probes by executing or retries another driver.
 const std = @import("std");
 const Arena = @import("arena.zig").Arena;
 const P = @import("io_v2_protocol.zig");
 const Core = @import("io_v2_core.zig");
 const Host = @import("io_v2_file_host.zig").Host;
 const C = @import("codecs.zig");
 const Identities = struct {
     next: std.atomic.Value(u64) = .init(1),
     fn issue(self: *@This()) !u64 {
         var value = self.next.load(.monotonic);
         while (true) {
             if (value == std.math.maxInt(u64)) return error.RunIdentityExhausted;
             if (self.next.cmpxchgWeak(value, value + 1, .monotonic, .monotonic)) |changed| value = changed else return value;
         }
     }
 };
 var identities: Identities = .{};
 pub const Envelope = struct { version: u64, action: u32 };
 pub fn envelope(arena: *Arena, program: u32, fuel: u64) !Envelope {
     const base = arena.roots.items.len;
     defer arena.roots.shrinkRetainingCapacity(base);
     try arena.roots.append(arena.allocator, program);
     const r = P.Reader{ .arena = arena, .fuel = fuel };
     const outer = try r.pair(program) orelse return error.InvalidIOEnvelope;
     var rest = outer.first;
     for ("tricuIO") |ch| {
         const cell = try r.pair(rest) orelse return error.InvalidIOEnvelope;
         if (try r.nat(cell.first, 7) != @as(?u64, ch)) return error.InvalidIOEnvelope;
         rest = cell.second;
     }
     if (try r.node(rest) != .leaf) return error.InvalidIOEnvelope;
     const inner = try r.pair(outer.second) orelse return error.InvalidIOEnvelope;
     return .{ .version = try r.nat(inner.first, 16) orelse return error.InvalidIOEnvelope, .action = inner.second };
 }
 pub fn run(arena: *Arena, program: u32, fuel: u64) !u32 {
     const decoded = try envelope(arena, program, fuel);
     if (decoded.version != 2) return error.UnsupportedIOVersion;
     var host: Host = .{};
     const outcome = try Core.runWithHost(Host, &host, arena, decoded.action, try identities.issue(), fuel);
     return switch (outcome.kind) {
         .completed => outcome.value,
         .failed => error.IOV2Failed,
         .cancelled => error.IOV2Cancelled,
     };
 }
 test "native run identities never repeat or wrap" {
     var ids: Identities = .{};
     try std.testing.expectEqual(@as(u64, 1), try ids.issue());
     try std.testing.expectEqual(@as(u64, 2), try ids.issue());
     ids.next.store(std.math.maxInt(u64) - 1, .monotonic);
     _ = try ids.issue();
     try std.testing.expectError(error.RunIdentityExhausted, ids.issue());
     try std.testing.expectError(error.RunIdentityExhausted, ids.issue());
 }
 test "retired versions rejected without demanding action" {
     var a = Arena.init(std.testing.allocator);
     defer a.deinit();
     const bad = try a.allocApp(try a.alloc(.leaf), try a.alloc(.leaf));
     for ([_]u64{ 0, 1, 3, 65535 }) |version| {
         const program = try a.alloc(.{ .fork = .{ .left = try C.ofString(&a, "tricuIO"), .right = try a.alloc(.{ .fork = .{ .left = try C.ofNumber(&a, version), .right = bad } }) } });
         try std.testing.expectError(error.UnsupportedIOVersion, run(&a, program, 0));
     }
 }
 
 test "successive native runs produce distinct scope identities" {
     var arena = Arena.init(std.testing.allocator);
     defer arena.deinit();
     const leaf = try arena.alloc(.leaf);
     const action = try arena.alloc(.{ .fork = .{ .left = try C.ofNumber(&arena, 4), .right = leaf } });
     const program = try arena.alloc(.{ .fork = .{ .left = try C.ofString(&arena, "tricuIO"), .right = try arena.alloc(.{ .fork = .{ .left = try C.ofNumber(&arena, 2), .right = action } }) } });
     const first = try run(&arena, program, 10000);
     try arena.roots.append(arena.allocator, first);
     const second = try run(&arena, program, 10000);
     const reader = P.Reader{ .arena = &arena, .fuel = 10000 };
     const first_fields = (try reader.pair(first)).?;
     const second_fields = (try reader.pair(second)).?;
     const first_id = try reader.nat((try reader.pair(first_fields.second)).?.first, 64);
     const second_id = try reader.nat((try reader.pair(second_fields.second)).?.first, 64);
     try std.testing.expect(first_id != null and second_id != null and first_id != second_id);
 }