tiny.accy.tensor.wire

1/// A caller uses this function to rebuild a tensor program from wire bytes, the versioned byte2/// encoding of a tensor program, sent by another process. The function reads version 1 bytes and3/// replays each operation through `Builder.operation` on the program builder, the object that4/// builds a program one checked operation at a time, which works out every result type again and5/// checks it, so the bytes never supply a result type the builder did not derive. Bytes that end6/// early or carry anything after the program return `error.InvalidArtifact`. A wrong magic number7/// returns `error.BadMagic` and another version returns `error.UnsupportedVersion`. The caller owns8/// the returned program and frees it with `Program.deinit`. The builder copies names and payloads9/// into the program's own memory, so the caller may free `bytes` as soon as the call returns.10pub fn decode(allocator: std.mem.Allocator, bytes: []const u8) !Program {11    var decoder = Decoder{ .allocator = allocator, .reader = .{ .bytes = bytes } };12    defer decoder.deinit();13    if (try decoder.reader.readU32() != format.magic) return error.BadMagic;14    if (try decoder.reader.readU32() != format.version) return error.UnsupportedVersion;15    const name = try decoder.reader.readLengthPrefixedBytes();16    try decoder.open(name, .{});17    for (0..bytes.len) |_| {18        const frame = &decoder.frames[decoder.count - 1];19        if (frame.remaining != 0) {20            frame.remaining -= 1;21            try decoder.operation(frame);22        } else if (decoder.count == 1) {23            return decoder.finish(frame);24        } else {25            try decoder.close();26        }27    }28    unreachable;29}

1/// A caller uses this to send a tensor program to another process, so the function writes `program`2/// as version 1 bytes, which the caller owns. The call returns `error.InvalidProgram` unless the3/// operation ids run densely from zero and the parameter operations appear in parameter order, and4/// every program made by the program builder meets both. The program builder is the tracer that5/// appends one operation at a time and checks each result type as it goes. The call returns6/// `error.ScanTooDeep` when scans nest deeper than eight levels and `error.InvalidArtifact` when a7/// list or string is longer than a 32-bit count can hold.8pub fn encode(allocator: std.mem.Allocator, program: *const Program) ![]u8 {9    var sink = Sink{ .allocator = allocator };10    errdefer sink.writer.deinit(allocator);11    try sink.word(format.magic);12    try sink.word(format.version);13    try sink.bytes(program.name);1415    var frames: [format.max_scan_depth + 1]Frame = undefined;16    frames[0] = .{ .graph = .{17        .values = program.values,18        .operations = program.operations,19        .parameters = program.parameters,20        .outputs = program.outputs,21    } };22    var count: usize = 1;23    try sink.graph(frames[0].graph);24    while (count != 0) {25        const frame = &frames[count - 1];26        std.debug.assert(frame.next <= frame.graph.operations.len);27        if (frame.next == frame.graph.operations.len) {28            try sink.idList(frame.graph.outputs);29            count -= 1;30            continue;31        }32        const op = frame.graph.operations[frame.next];33        frame.next += 1;34        try sink.operation(op);35        if (op.kind != .scan) continue;36        if (count > format.max_scan_depth) return error.ScanTooDeep;37        frames[count] = .{ .graph = op.kind.scan.body.* };38        count += 1;39        std.debug.assert(count <= frames.len);40        try sink.graph(op.kind.scan.body.*);41    }42    return sink.writer.toOwnedSlice(allocator);43}

1pub const wire = @import("wire/root.zig");

1//! A way to write a tensor program as bytes and read it back, for hosts outside this process. A2//! host has to hand over a program, and this side has to accept only programs that are well typed.3//! Any host can send any bytes, and a layout that changes without notice breaks senders built4//! against the old one.5//!6//! Programs travel as versioned bytes (*wire bytes*) that begin with the four bytes "ACTP" and7//! version 1. The reader replays every operation through the same checked step that builds a8//! program one operation at a time, so the bytes cannot introduce a type that step did not derive.9//! The parts are the byte layout (`format`), the encoder (`encode`) and the decoder (`decode`).10pub const format = @import("format.zig");1112pub const magic = format.magic;13pub const version = format.version;14pub const max_scan_depth = format.max_scan_depth;15pub const Error = format.Error;16pub const encode = @import("encode.zig").encode;17pub const decode = @import("decode.zig").decode;