tiny.choir.dialects.gpu.stage

1pub const stage = @import("stage.zig");

1//! The vertex and fragment vocabulary of the gpu dialect.2//!3//! A function runs as a stage when it holds a `stage` attribute where a4//! compute function holds `kernel`. Stage values stay scalar like every other5//! gpu value: an interface slot of up to four components reads as that many6//! results and writes as that many operands, and each emitter builds or splits7//! the vector at the interface.8//!9//! A texture and its sampler are one binding, because the render contract10//! binds a `sampled_texture` and names no separate sampler.11//!12//! A push constant or a uniform read names one block member by its byte13//! offset and reads it as up to four components of one 4-byte scalar type.14//! The op carries the layout; no emitter infers one. `Member` holds the rules15//! a member must meet, and an emitter refuses a member its target cannot place.1617const std = @import("std");18const choir = @import("../../root.zig");19const tags = @import("tags.zig");2021const ir = choir.ir;22const effects = ir.interfaces.effects;23const arith = choir.dialects.arith;2425const Stage = tags.Stage;2627/// The components one interface slot holds.28pub const max_components = 4;29/// Interface slots per direction. Vulkan guarantees 16 vertex inputs and 6430/// vertex output components, which are 16 slots of four.31pub const max_locations = 16;32/// The function attribute that holds a stage.33pub const stage_attr_key = "stage";34/// Bytes a push-constant block holds at most: Vulkan's guaranteed35/// `maxPushConstantsSize`.36pub const max_push_constant_bytes = 128;37/// Bytes a uniform block holds at most: Vulkan's guaranteed38/// `maxUniformBufferRange`.39pub const max_uniform_bytes = 16384;4041/// Where a block member of `width` 4-byte components sits. Blocks follow42/// std140 for the scalars and vectors a stage reads, where std430 and WGSL's43/// host-shareable rules agree: a scalar has size 4 and alignment 4, a44/// two-component vector 8 and 8, a three-component vector 12 and 16, and a45/// four-component vector 16 and 16. A member so aligned never crosses a46/// 16-byte row, which lets an emitter read a uniform one row at a time.47pub const Member = struct {48    offset: u32,49    width: u32,5051    pub fn size(self: Member) u32 {52        return 4 * self.width;53    }5455    pub fn alignment(self: Member) u32 {56        return switch (self.width) {57            1 => 4,58            2 => 8,59            else => 16,60        };61    }6263    pub fn end(self: Member) u32 {64        return self.offset + self.size();65    }6667    /// Whether the member has a width a read may take, sits at an offset its68    /// alignment divides, and ends inside a block of `capacity` bytes.69    pub fn placed(self: Member, capacity: u32) bool {70        if (self.width < 1 or self.width > max_components) return false;71        if (self.offset % self.alignment() != 0) return false;72        return self.offset <= capacity and self.size() <= capacity - self.offset;73    }74};7576const names = struct {77    pub const name = "gpu";78};79const op_specs = ir.dialects.opSpec.dialect(names);8081fn loadSpec(ctx: *ir.Context) !void {82    try ir.dialects.loadDialectSpec(ctx, @import("dialect.zig").GpuDialect.spec);83}8485pub fn getStageAttr(ctx: *ir.Context, stage: Stage) !ir.Attribute {86    return ctx.getDialectAttr(tags.attr_names.stage, stage.toString());87}8889/// Marks `func_op` as `stage`. A function is a kernel or a stage, never both.90pub fn setStage(func_op: *ir.Operation, ctx: *ir.Context, stage: Stage) !void {91    std.debug.assert(func_op.getAttr("kernel") == null);92    try func_op.setAttr(stage_attr_key, try getStageAttr(ctx, stage));93}9495/// The stage `func_op` runs as, or null for a kernel or a plain function.96pub fn stageOf(func_op: *const ir.Operation) ?Stage {97    const attr = func_op.getAttrAs(ir.Attribute.DialectAttr, stage_attr_key) orelse return null;98    return Stage.fromString(attr.payload);99}100101pub fn getSampledTextureType(ctx: *ir.Context) !ir.Type {102    try loadSpec(ctx);103    return ctx.getDialectTypeFromName(tags.type_names.sampled_texture);104}105106const StageSet = packed struct {107    vertex: bool = false,108    fragment: bool = false,109110    fn has(self: StageSet, stage: Stage) bool {111        return switch (stage) {112            .vertex => self.vertex,113            .fragment => self.fragment,114        };115    }116};117118const both: StageSet = .{ .vertex = true, .fragment = true };119const vertex_only: StageSet = .{ .vertex = true };120const fragment_only: StageSet = .{ .fragment = true };121122fn stagesFor(op_name: []const u8) ?StageSet {123    const table = .{124        .{ StageInputOp, both },125        .{ StageOutputOp, both },126        .{ SampledTextureOp, both },127        .{ SampleLodOp, both },128        .{ PushConstantOp, both },129        .{ UniformOp, both },130        .{ PositionOp, vertex_only },131        .{ VertexIndexOp, vertex_only },132        .{ InstanceIndexOp, vertex_only },133        .{ FragCoordOp, fragment_only },134        .{ FrontFacingOp, fragment_only },135        .{ SampleOp, fragment_only },136        .{ DpdxOp, fragment_only },137        .{ DpdyOp, fragment_only },138        .{ FwidthOp, fragment_only },139    };140    inline for (table) |entry| {141        if (std.mem.eql(u8, op_name, entry[0].operation_name)) return entry[1];142    }143    return null;144}145146/// Whether a function of `stage` may hold an op named `op_name`, where a null147/// stage is a kernel. Stage ops run only in their stages, and every other gpu148/// op is compute vocabulary. Ops outside the gpu dialect are admitted here and149/// left to each target.150pub fn admits(stage: ?Stage, op_name: []const u8) bool {151    if (stagesFor(op_name)) |stages| {152        const current = stage orelse return false;153        return stages.has(current);154    }155    if (stage == null) return true;156    return !std.mem.startsWith(u8, op_name, names.name ++ ".");157}158159/// The refusal every stage backend names when `admitsMemory` fails.160pub const MemoryError = error{UnsupportedStageMemory};161162/// Whether a stage function, or a helper a stage calls, may hold `op`. A stage163/// touches only its own arrays: a `memref.alloca` in the local address space164/// with a size known when the module is built, from 1 to 2^32 - 1 elements, and165/// the loads and stores on local memrefs. Every other memref op is refused,166/// since no stage emitter expresses it and a fragment's helper lanes would repeat167/// its effect. An op outside the memref dialect is left to `admits`.168pub fn admitsMemory(op: *ir.Operation) bool {169    const memref = choir.dialects.memref;170    const Memref = memref.MemrefDialect;171    const name = op.name.name;172    if (!std.mem.startsWith(u8, name, Memref.name ++ ".")) return true;173    const target = if (std.mem.eql(u8, name, Memref.AllocaOp.operation_name)) {174        const alloca = Memref.AllocaOp{ .op = op };175        if (alloca.getDynamicSize() != null) return false;176        const params = memref.paramsOf(alloca.getResult().type) orelse return false;177        const size = params.size orelse return false;178        return params.addr_space == .local and size >= 1 and size <= std.math.maxInt(u32);179    } else if (std.mem.eql(u8, name, Memref.LoadOp.operation_name))180        (Memref.LoadOp{ .op = op }).getMemref()181    else if (std.mem.eql(u8, name, Memref.StoreOp.operation_name))182        (Memref.StoreOp{ .op = op }).getMemref()183    else184        return false;185    const params = memref.paramsOf(target.type) orelse return false;186    return params.addr_space == .local;187}188189/// The bytes of the push-constant block `module`'s stages read: the end of the190/// farthest member a push-constant read names, or 0 when none reads. A pipeline191/// that draws the module must declare at least this many. Null when a read192/// names no member.193pub fn pushExtent(module: *ir.Operation) ?u32 {194    var extent: u32 = 0;195    if (std.mem.eql(u8, module.name.name, PushConstantOp.operation_name)) {196        const member = (PushConstantOp{ .op = module }).member() orelse return null;197        extent = member.end();198    }199    for (0..module.getNumRegions()) |index| {200        const region = module.getRegion(index) orelse continue;201        var blocks = region.getBlocks();202        while (blocks.next()) |block| {203            var ops = block.getOperations();204            while (ops.next()) |op| extent = @max(extent, pushExtent(op) orelse return null);205        }206    }207    return extent;208}209210fn stageEffects(comptime kind: effects.EventKind) ir.interfaces.InterfaceEntry {211    const Declaration = struct {212        fn enumerate(op: *const ir.Operation, collector: *effects.Collector) void {213            collector.append(.{ .event = .{214                .kind = kind,215                .resource = .{ .state_key = "gpu.stage" },216                .ordered = true,217            } });218            collector.append(.{ .requirement = .{219                .kind = .execution_context,220                .subject = .operation,221            } });222            if (kind == .synchronize) collector.append(.{ .event = .{ .kind = .diverge } });223            for (0..op.getNumResults()) |index| {224                collector.append(.{ .result = .{ .index = index } });225            }226        }227    };228    return effects.EffectOpInterface.entryFor(.{229        .capacity = .{ .entries = 3, .per_result = 1 },230        .enumerate = Declaration.enumerate,231    });232}233234fn setIndexAttr(op: *ir.Operation, ctx: *ir.Context, key: []const u8, value: u32) !void {235    try op.setAttr(key, try ctx.getI64Attr(@intCast(value)));236}237238fn getIndexAttr(op: *const ir.Operation, key: []const u8) ?u32 {239    const int_attr = op.getAttrAs(ir.Attribute.IntegerAttr, key) orelse return null;240    const raw = int_attr.getUnsignedValue();241    if (raw > std.math.maxInt(u32)) return null;242    return @intCast(raw);243}244245fn createLeaf(246    ctx: *ir.Context,247    loc: ir.Location,248    comptime name: []const u8,249    operands: []const *ir.Value,250    result_types: []const ir.Type,251) !*ir.Operation {252    try loadSpec(ctx);253    var builder = ir.OperationBuilder.init(ctx);254    var state = ir.Operation.State.init(name, loc);255    state.addOperands(operands);256    state.addTypes(result_types);257    return builder.create(state);258}259260/// Reads interface slot `location` as `width` components of one scalar type.261pub const StageInputOp = struct {262    op: *ir.Operation,263264    pub const operation_spec = op_specs.leaf(.{265        .mnemonic = "stage_input",266        .interfaces = &.{stageEffects(.state_observe)},267        .operands = 0,268        .results = ir.dialects.shape.between(1, max_components),269        .required_attrs = &.{"location"},270    });271    pub const operation_name = operation_spec.name;272273    pub fn create(274        ctx: *ir.Context,275        loc: ir.Location,276        location: u32,277        element_type: ir.Type,278        width: u32,279    ) !StageInputOp {280        std.debug.assert(location < max_locations);281        std.debug.assert(width >= 1);282        std.debug.assert(width <= max_components);283        var types: [max_components]ir.Type = undefined;284        @memset(types[0..width], element_type);285        const op = try createLeaf(ctx, loc, operation_name, &.{}, types[0..width]);286        errdefer op.erase();287        try setIndexAttr(op, ctx, "location", location);288        return .{ .op = op };289    }290291    pub fn getLocation(self: StageInputOp) ?u32 {292        return getIndexAttr(self.op, "location");293    }294};295296/// Writes `width` components of one scalar type to interface slot `location`.297pub const StageOutputOp = struct {298    op: *ir.Operation,299300    pub const operation_spec = op_specs.leaf(.{301        .mnemonic = "stage_output",302        .interfaces = &.{stageEffects(.state_update)},303        .operands = ir.dialects.shape.between(1, max_components),304        .results = 0,305        .required_attrs = &.{"location"},306    });307    pub const operation_name = operation_spec.name;308309    pub fn create(310        ctx: *ir.Context,311        loc: ir.Location,312        location: u32,313        values: []const *ir.Value,314    ) !StageOutputOp {315        std.debug.assert(location < max_locations);316        std.debug.assert(values.len >= 1);317        std.debug.assert(values.len <= max_components);318        const op = try createLeaf(ctx, loc, operation_name, values, &.{});319        errdefer op.erase();320        try setIndexAttr(op, ctx, "location", location);321        return .{ .op = op };322    }323324    pub fn getLocation(self: StageOutputOp) ?u32 {325        return getIndexAttr(self.op, "location");326    }327};328329/// Writes the vertex's clip-space position from four f32 components.330pub const PositionOp = struct {331    op: *ir.Operation,332333    pub const operation_spec = op_specs.leaf(.{334        .mnemonic = "position",335        .interfaces = &.{stageEffects(.state_update)},336        .operands = .{ "x", "y", "z", "w" },337        .results = 0,338    });339    pub const operation_name = operation_spec.name;340341    pub fn create(ctx: *ir.Context, loc: ir.Location, xyzw: [4]*ir.Value) !PositionOp {342        const op = try createLeaf(ctx, loc, operation_name, &xyzw, &.{});343        return .{ .op = op };344    }345};346347/// Reads the fragment's window position, depth and reciprocal clip w as four348/// f32 results.349pub const FragCoordOp = struct {350    op: *ir.Operation,351352    pub const operation_spec = op_specs.leaf(.{353        .mnemonic = "frag_coord",354        .interfaces = &.{stageEffects(.state_observe)},355        .operands = 0,356        .results = .{ "x", "y", "z", "w" },357    });358    pub const operation_name = operation_spec.name;359360    pub fn create(ctx: *ir.Context, loc: ir.Location) !FragCoordOp {361        const f32_type = try arith.ArithDialect.getScalarType(ctx, .f32);362        const types = [_]ir.Type{ f32_type, f32_type, f32_type, f32_type };363        const op = try createLeaf(ctx, loc, operation_name, &.{}, &types);364        return .{ .op = op };365    }366};367368fn builtinOp(comptime mnemonic: []const u8, comptime kind: arith.ScalarKind) type {369    return struct {370        op: *ir.Operation,371372        pub const operation_spec = op_specs.leaf(.{373            .mnemonic = mnemonic,374            .interfaces = &.{stageEffects(.state_observe)},375            .operands = 0,376            .results = .{"result"},377        });378        pub const operation_name = operation_spec.name;379380        pub fn create(ctx: *ir.Context, loc: ir.Location) !@This() {381            const result_type = try arith.ArithDialect.getScalarType(ctx, kind);382            const op = try createLeaf(ctx, loc, operation_name, &.{}, &.{result_type});383            return .{ .op = op };384        }385386        pub fn getResult(self: @This()) *ir.Value {387            return self.op.getResult(0).?;388        }389    };390}391392/// The vertex's index in the draw, counting from the draw's first vertex.393pub const VertexIndexOp = builtinOp("vertex_index", .u32);394/// The instance's index in the draw, counting from the draw's first instance.395pub const InstanceIndexOp = builtinOp("instance_index", .u32);396/// Whether the fragment's primitive faces the viewer.397pub const FrontFacingOp = builtinOp("front_facing", .bool);398399/// Names the sampled texture at `group` and `binding`.400pub const SampledTextureOp = struct {401    op: *ir.Operation,402403    pub const operation_spec = op_specs.leaf(.{404        .mnemonic = "sampled_texture",405        .interfaces = &.{stageEffects(.state_observe)},406        .operands = 0,407        .results = .{"texture"},408        .required_attrs = &.{ "group", "binding" },409    });410    pub const operation_name = operation_spec.name;411412    pub fn create(ctx: *ir.Context, loc: ir.Location, group: u32, binding: u32) !SampledTextureOp {413        const texture_type = try getSampledTextureType(ctx);414        const op = try createLeaf(ctx, loc, operation_name, &.{}, &.{texture_type});415        errdefer op.erase();416        try setIndexAttr(op, ctx, "group", group);417        try setIndexAttr(op, ctx, "binding", binding);418        return .{ .op = op };419    }420421    pub fn getGroup(self: SampledTextureOp) ?u32 {422        return getIndexAttr(self.op, "group");423    }424425    pub fn getBinding(self: SampledTextureOp) ?u32 {426        return getIndexAttr(self.op, "binding");427    }428429    pub fn getResult(self: SampledTextureOp) *ir.Value {430        return self.op.getResult(0).?;431    }432};433434fn sampleOp(435    comptime mnemonic: []const u8,436    comptime kind: effects.EventKind,437    comptime operands: anytype,438) type {439    return struct {440        op: *ir.Operation,441442        pub const operation_spec = op_specs.leaf(.{443            .mnemonic = mnemonic,444            .interfaces = &.{stageEffects(kind)},445            .operands = operands,446            .results = .{ "r", "g", "b", "a" },447        });448        pub const operation_name = operation_spec.name;449450        /// `inputs` is the texture, then u and v, then the level when the op451        /// takes one.452        pub fn create(453            ctx: *ir.Context,454            loc: ir.Location,455            inputs: [operands.len]*ir.Value,456        ) !@This() {457            const f32_type = try arith.ArithDialect.getScalarType(ctx, .f32);458            const types = [_]ir.Type{ f32_type, f32_type, f32_type, f32_type };459            const op = try createLeaf(ctx, loc, operation_name, &inputs, &types);460            return .{ .op = op };461        }462463        pub fn getTexture(self: @This()) *ir.Value {464            return self.op.operands.items[0].value;465        }466    };467}468469/// Samples a texture at (u, v) with the level its derivatives select.470pub const SampleOp = sampleOp("sample", .synchronize, .{ "texture", "u", "v" });471/// Samples a texture at (u, v) at an explicit level of detail.472pub const SampleLodOp = sampleOp("sample_lod", .state_observe, .{ "texture", "u", "v", "lod" });473474fn derivativeOp(comptime mnemonic: []const u8) type {475    return struct {476        op: *ir.Operation,477478        pub const VerifyError = error{DerivativeOutsideFragmentStage};479480        pub const operation_spec = op_specs.leaf(.{481            .mnemonic = mnemonic,482            .interfaces = &.{stageEffects(.synchronize)},483            .operands = .{"value"},484            .results = .{"result"},485        });486        pub const operation_name = operation_spec.name;487488        pub fn verify(op_ptr: *const anyopaque) anyerror!void {489            const op: *const ir.Operation = @ptrCast(@alignCast(op_ptr));490            var parent = op.getParentOp();491            while (parent) |ancestor| : (parent = ancestor.getParentOp()) {492                if (!std.mem.eql(u8, ancestor.name.name, choir.dialects.FuncDialect.FuncOp.operation_name)) continue;493                if (stageOf(ancestor) != .fragment) return VerifyError.DerivativeOutsideFragmentStage;494                return;495            }496            return VerifyError.DerivativeOutsideFragmentStage;497        }498499        pub fn create(ctx: *ir.Context, loc: ir.Location, value: *ir.Value) !@This() {500            const op = try createLeaf(ctx, loc, operation_name, &.{value}, &.{value.type});501            return .{ .op = op };502        }503504        pub fn getResult(self: @This()) *ir.Value {505            return self.op.getResult(0).?;506        }507    };508}509510fn blockReadResults(ctx: *ir.Context, loc: ir.Location, comptime name: []const u8, element_type: ir.Type, width: u32) !*ir.Operation {511    std.debug.assert(width >= 1);512    std.debug.assert(width <= max_components);513    var types: [max_components]ir.Type = undefined;514    @memset(types[0..width], element_type);515    return createLeaf(ctx, loc, name, &.{}, types[0..width]);516}517518/// Reads the push-constant member at byte `offset` as `width` components of519/// one scalar type. Every stage of a pipeline reads the one block.520pub const PushConstantOp = struct {521    op: *ir.Operation,522523    pub const operation_spec = op_specs.leaf(.{524        .mnemonic = "push_constant",525        .interfaces = &.{stageEffects(.state_observe)},526        .operands = 0,527        .results = ir.dialects.shape.between(1, max_components),528        .required_attrs = &.{"offset"},529    });530    pub const operation_name = operation_spec.name;531532    pub fn create(ctx: *ir.Context, loc: ir.Location, offset: u32, element_type: ir.Type, width: u32) !PushConstantOp {533        const op = try blockReadResults(ctx, loc, operation_name, element_type, width);534        errdefer op.erase();535        try setIndexAttr(op, ctx, "offset", offset);536        return .{ .op = op };537    }538539    pub fn member(self: PushConstantOp) ?Member {540        const offset = getIndexAttr(self.op, "offset") orelse return null;541        return .{ .offset = offset, .width = @intCast(self.op.getNumResults()) };542    }543};544545/// Reads the member at byte `offset` of the uniform buffer at `group` and546/// `binding` as `width` components of one scalar type.547pub const UniformOp = struct {548    op: *ir.Operation,549550    pub const operation_spec = op_specs.leaf(.{551        .mnemonic = "uniform",552        .interfaces = &.{stageEffects(.state_observe)},553        .operands = 0,554        .results = ir.dialects.shape.between(1, max_components),555        .required_attrs = &.{ "group", "binding", "offset" },556    });557    pub const operation_name = operation_spec.name;558559    pub fn create(560        ctx: *ir.Context,561        loc: ir.Location,562        group: u32,563        binding: u32,564        offset: u32,565        element_type: ir.Type,566        width: u32,567    ) !UniformOp {568        const op = try blockReadResults(ctx, loc, operation_name, element_type, width);569        errdefer op.erase();570        try setIndexAttr(op, ctx, "group", group);571        try setIndexAttr(op, ctx, "binding", binding);572        try setIndexAttr(op, ctx, "offset", offset);573        return .{ .op = op };574    }575576    pub fn getGroup(self: UniformOp) ?u32 {577        return getIndexAttr(self.op, "group");578    }579580    pub fn getBinding(self: UniformOp) ?u32 {581        return getIndexAttr(self.op, "binding");582    }583584    pub fn member(self: UniformOp) ?Member {585        const offset = getIndexAttr(self.op, "offset") orelse return null;586        return .{ .offset = offset, .width = @intCast(self.op.getNumResults()) };587    }588};589590/// The fine rate `value` changes along window x: within the fragment's 2x2 quad, `value` at the591/// odd-x fragment of the fragment's own row minus `value` at the even-x fragment. Every backend592/// computes this flavour. SPIR-V emits OpDPdxFine. MSL's `dfdx` names no flavour, and the M4 Max593/// measured fine. The CPU twin recomputes `value` at the partner lane and subtracts in the same594/// order. The quad's four fragments must reach the op together; a derivative under control flow595/// that diverges within a quad is unproven on devices and refused by the CPU twin.596pub const DpdxOp = derivativeOp("dpdx");597/// The fine rate `value` changes along window y: `value` at the odd-y fragment of the fragment's598/// own column minus `value` at the even-y fragment, under the same terms as `DpdxOp`.599pub const DpdyOp = derivativeOp("dpdy");600/// The fine `|dpdx| + |dpdy|`, under the same terms as `DpdxOp`.601pub const FwidthOp = derivativeOp("fwidth");602603test "stage admission keeps stage ops in their stages and compute ops in kernels" {604    try std.testing.expect(admits(.vertex, PositionOp.operation_name));605    try std.testing.expect(!admits(.fragment, PositionOp.operation_name));606    try std.testing.expect(!admits(null, PositionOp.operation_name));607    try std.testing.expect(admits(.fragment, SampleOp.operation_name));608    try std.testing.expect(!admits(.vertex, SampleOp.operation_name));609    try std.testing.expect(admits(.vertex, SampleLodOp.operation_name));610    try std.testing.expect(admits(.fragment, StageInputOp.operation_name));611    try std.testing.expect(!admits(.vertex, "gpu.thread_idx"));612    try std.testing.expect(admits(null, "gpu.thread_idx"));613    try std.testing.expect(admits(.fragment, "arith.add"));614}615616test "block members follow the std140 rules for scalars and vectors" {617    try std.testing.expect((Member{ .offset = 12, .width = 1 }).placed(16));618    try std.testing.expect((Member{ .offset = 8, .width = 2 }).placed(16));619    try std.testing.expect(!(Member{ .offset = 4, .width = 2 }).placed(16));620    try std.testing.expect((Member{ .offset = 16, .width = 3 }).placed(28));621    try std.testing.expect(!(Member{ .offset = 4, .width = 3 }).placed(64));622    try std.testing.expect(!(Member{ .offset = 16, .width = 4 }).placed(28));623    try std.testing.expect(!(Member{ .offset = 0, .width = 5 }).placed(64));624    try std.testing.expectEqual(@as(u32, 28), (Member{ .offset = 16, .width = 3 }).end());625    try std.testing.expect(admits(.vertex, PushConstantOp.operation_name));626    try std.testing.expect(admits(.fragment, UniformOp.operation_name));627    try std.testing.expect(!admits(null, UniformOp.operation_name));628}629630test "stage ops build with their shapes and attributes" {631    var ctx = try ir.Context.init(std.testing.allocator, ir.Context.Limits.testing);632    defer ctx.deinit(std.testing.allocator);633    const f32_type = try arith.ArithDialect.getScalarType(&ctx, .f32);634    const input = try StageInputOp.create(&ctx, .unknown, 3, f32_type, 2);635    defer input.op.erase();636    try std.testing.expectEqual(@as(?u32, 3), input.getLocation());637    try std.testing.expectEqual(@as(usize, 2), input.op.getNumResults());638    const texture = try SampledTextureOp.create(&ctx, .unknown, 1, 4);639    defer texture.op.erase();640    try std.testing.expectEqual(@as(?u32, 1), texture.getGroup());641    try std.testing.expectEqual(@as(?u32, 4), texture.getBinding());642    const coord = try FragCoordOp.create(&ctx, .unknown);643    defer coord.op.erase();644    const u = coord.op.getResult(0).?;645    const sample = try SampleLodOp.create(&ctx, .unknown, .{ texture.getResult(), u, u, u });646    defer sample.op.erase();647    try std.testing.expectEqual(@as(usize, 4), sample.op.getNumResults());648    try ir.verifyOperation(sample.op, .{ .recursive = false });649}