tiny.accy.kernel.program.graph

1pub const Limits = struct {2    context: choir.ir.Context.Limits,3    parameters: usize,4    kernel_name_bytes: usize,5    temporary_values: usize,6    temporary_types: usize,7    schedule: schedule.Schedule.Limits,8    snapshot: schedule.Snapshot.Limits,910    pub const standard: Limits = fromRaw(11        RawLimits.standard,12        schedule.Schedule.Limits.standard,13        schedule.Snapshot.Limits.standard,14    );1516    pub const testing: Limits = fromRaw(17        RawLimits.testing,18        schedule.Schedule.Limits.testing,19        schedule.Snapshot.Limits.testing,20    );2122    pub const borrowed_standard: Limits = fromRaw(23        RawLimits.borrowed_standard,24        schedule.Schedule.Limits.standard,25        schedule.Snapshot.Limits.standard,26    );2728    pub const borrowed_testing: Limits = fromRaw(29        RawLimits.borrowed_testing,30        schedule.Schedule.Limits.testing,31        schedule.Snapshot.Limits.testing,32    );3334    pub fn raw(self: Limits) RawLimits {35        return .{36            .context = self.context,37            .parameters = self.parameters,38            .kernel_name_bytes = self.kernel_name_bytes,39            .temporary_values = self.temporary_values,40            .temporary_types = self.temporary_types,41        };42    }4344    fn fromRaw(45        raw_limits: RawLimits,46        schedule_limits: schedule.Schedule.Limits,47        snapshot_limits: schedule.Snapshot.Limits,48    ) Limits {49        return .{50            .context = raw_limits.context,51            .parameters = raw_limits.parameters,52            .kernel_name_bytes = raw_limits.kernel_name_bytes,53            .temporary_values = raw_limits.temporary_values,54            .temporary_types = raw_limits.temporary_types,55            .schedule = schedule_limits,56            .snapshot = snapshot_limits,57        };58    }59};

1pub const Capacity = struct {2    context_ownership: ContextOwnership,3    body: builder.Builder.Capacity,4    schedule: schedule_mod.Schedule.Capacity,5    snapshot: schedule_mod.Snapshot.Capacity,6    construction_bytes: usize,7    maximum_overlap_bytes: usize,89    pub const ContextOwnership = enum { owned, borrowed };1011    pub fn derive(limits: Limits) error{CapacityOverflow}!Capacity {12        return deriveWithContextOwnership(limits, .owned);13    }1415    pub fn deriveBorrowing(limits: Limits) error{CapacityOverflow}!Capacity {16        return deriveWithContextOwnership(limits, .borrowed);17    }1819    fn deriveWithContextOwnership(20        limits: Limits,21        context_ownership: ContextOwnership,22    ) error{CapacityOverflow}!Capacity {23        const body = try builder.Builder.Capacity.derive(limits.raw());24        const schedule = try schedule_mod.Schedule.Capacity.derive(limits.schedule);25        const snapshot = try schedule_mod.Snapshot.Capacity.derive(limits.snapshot);26        const body_acquired_bytes = switch (context_ownership) {27            .owned => body.owned_acquired_bytes,28            .borrowed => body.borrowed_acquired_bytes,29        };30        const construction_bytes = std.math.add(31            usize,32            body_acquired_bytes,33            schedule.storage_bytes,34        ) catch return error.CapacityOverflow;35        var maximum_overlap_bytes = std.math.add(36            usize,37            construction_bytes,38            snapshot.storage_bytes,39        ) catch return error.CapacityOverflow;40        maximum_overlap_bytes = std.math.add(41            usize,42            maximum_overlap_bytes,43            schedule.storage_bytes,44        ) catch return error.CapacityOverflow;45        return .{46            .context_ownership = context_ownership,47            .body = body,48            .schedule = schedule,49            .snapshot = snapshot,50            .construction_bytes = construction_bytes,51            .maximum_overlap_bytes = maximum_overlap_bytes,52        };53    }54};

1pub const Program = struct {2    capacity: Capacity,3    storage: Storage,45    const Self = @This();67    pub fn deinit(self: *Self) void {8        self.storage.schedule.deinit(self.storage.kernel.allocator);9        self.storage.kernel.deinit();10        self.* = undefined;11    }1213    pub fn verify(self: *Self) !void {14        try self.storage.kernel.verify();15    }1617    pub fn verifyWithDiagnostic(self: *Self, diagnostic: *builder.VerificationDiagnostic) !void {18        try self.storage.kernel.verifyWithDiagnostic(diagnostic);19    }2021    pub fn launch(self: *const Self) schedule_mod.ScheduleError!schedule_mod.Launch {22        return self.storage.schedule.launch();23    }2425    pub fn scheduleSnapshot(self: *const Self, allocator: std.mem.Allocator) schedule_mod.ScheduleError!schedule_mod.Snapshot {26        return schedule_mod.createSnapshot(27            allocator,28            self.capacity.snapshot.asLimits(),29            &self.storage.schedule,30        );31    }3233    pub fn createPlan(self: *Self, allocator: std.mem.Allocator, options: plan.Options) plan.Error!plan.Plan {34        return plan.create(35            allocator,36            &self.storage.kernel,37            &self.storage.schedule,38            self.capacity.snapshot.asLimits(),39            options,40        );41    }4243    pub fn kernelModule(self: *const Self) *ir.Operation {44        return self.storage.kernel.module();45    }4647    pub fn params(self: *const Self) []const builder.Param {48        return self.storage.kernel.params();49    }5051    pub fn createCheckedPlan(self: *Self, allocator: std.mem.Allocator, options: plan.Options) !plan.Plan {52        var out = try self.createPlan(allocator, options);53        errdefer out.deinit();54        try self.checkPlan(allocator, &out);55        return out;56    }5758    pub fn checkPlan(self: *Self, allocator: std.mem.Allocator, out: *const plan.Plan) !void {59        if (out.version != plan.plan_version) return error.PlanVersionMismatch;60        if (out.schedule_version != schedule_mod.snapshot_version) return error.ScheduleVersionMismatch;61        if (out.body_fingerprint != try self.bodyFingerprint(allocator)) return error.BodyFingerprintMismatch;62        if (out.schedule_fingerprint != self.scheduleFingerprint()) return error.ScheduleFingerprintMismatch;63        if (out.schedule.fingerprint() != out.schedule_fingerprint) return error.ScheduleFingerprintMismatch;64        if (!builder.paramsEql(out.params, self.storage.kernel.params())) return error.ParameterSchemaMismatch;65        const argument_count = std.math.cast(u32, self.storage.kernel.params().len) orelse return error.ArgumentCountOverflow;66        if (out.argument_count != argument_count) return error.ParameterSchemaMismatch;67        const entry_name = self.storage.kernel.func().getName() orelse return error.MissingKernelName;68        if (!std.mem.eql(u8, out.entry_name, entry_name)) return error.EntryNameMismatch;6970        var replayed = try schedule_mod.replaySnapshot(71            allocator,72            self.capacity.schedule.asLimits(),73            &out.schedule,74        );75        defer replayed.deinit(allocator);76        if (replayed.fingerprint() != out.schedule_fingerprint) return error.ScheduleReplayMismatch;7778        const launch_value = try self.launch();79        if (!launchEqual(out.launch, launch_value)) return error.LaunchMismatch;80        if (!launchEqual(try out.schedule.launch(), launch_value)) return error.LaunchMismatch;81    }8283    pub fn bodyFingerprint(self: *const Self, allocator: std.mem.Allocator) !u64 {84        return self.storage.kernel.fingerprint(allocator);85    }8687    pub fn scheduleFingerprint(self: *const Self) u64 {88        return self.storage.schedule.fingerprint();89    }9091    pub fn fingerprint(self: *const Self, allocator: std.mem.Allocator) !choir.product.incremental.Fingerprint {92        const entry_name = self.storage.kernel.func().getName() orelse return error.MissingKernelName;93        var fingerprint_builder = choir.product.incremental.FingerprintBuilder{};94        fingerprint_builder.updateBytes(product_name);95        fingerprint_builder.updateU32(plan.plan_version);96        fingerprint_builder.updateU32(schedule_mod.snapshot_version);97        fingerprint_builder.updateU64(try self.bodyFingerprint(allocator));98        fingerprint_builder.updateU64(self.scheduleFingerprint());99        fingerprint_builder.updateBytes(entry_name);100        updateParamsFingerprint(&fingerprint_builder, self.storage.kernel.params());101        return fingerprint_builder.finish();102    }103104    pub fn productStamp(self: *const Self, allocator: std.mem.Allocator) !choir.product.incremental.ProductStamp {105        return choir.product.incremental.productStamp(product_name, try self.fingerprint(allocator));106    }107108    pub fn init(109        kernel: builder.Kernel,110        schedule: schedule_mod.Schedule,111        capacity: Capacity,112    ) Self {113        return .{114            .capacity = capacity,115            .storage = .{116                .kernel = kernel,117                .schedule = schedule,118            },119        };120    }121};

1pub const product_name = "accy.kernel_program";

1const model = @import("model.zig");23pub const product_name = model.product_name;4pub const Limits = model.Limits;5pub const Capacity = model.Capacity;6pub const Program = model.Program;

1pub const graph = model.graph;