tiny.gpu.BackendCapabilities

1pub const BackendCapabilities = struct {2    identity: DeviceIdentity,3    memory: MemoryLimits = .{},4    subgroup: SubgroupFacts = .{},5    float_controls: FloatControlFacts = .{},6    threadgroup: ThreadgroupFacts = .{},7    dtypes: DTypeSet = .{},8    layouts: LayoutFeatures = .{},9    runtime: RuntimeRequirements = .{},10    features: choir_abi.Features = .{},11    artifact_formats: ArtifactFormatSet = .{},12    textures: TextureCapabilities = .{},13    surfaces: SurfaceCapabilities = .{},14    raster: RasterCapabilities = .{},1516    pub fn supportsDType(self: BackendCapabilities, value: DType) bool {17        return self.dtypes.contains(value);18    }1920    pub fn supportsArtifactFormat(self: BackendCapabilities, format: ArtifactFormat) bool {21        return self.artifact_formats.contains(format);22    }2324    pub fn supportsTextureFormat(self: BackendCapabilities, format: TextureFormat) bool {25        return self.textures.supportsFormat(format);26    }2728    pub fn supportsSurfaceFormat(self: BackendCapabilities, format: TextureFormat) bool {29        return self.surfaces.supportsFormat(format);30    }3132    pub fn supportsRenderArtifactFormat(self: BackendCapabilities, format: RenderArtifactFormat) bool {33        return self.raster.supportsArtifactFormat(format);34    }3536    pub fn supportsFeatures(self: BackendCapabilities, required: choir_abi.Features) bool {37        return self.features.containsAll(required);38    }3940    pub fn supportsSubgroup(self: BackendCapabilities, required: choir_abi.SubgroupRequirements) bool {41        return self.subgroup.satisfies(required);42    }4344    pub fn supportsRuntime(self: BackendCapabilities, required: RuntimeRequirements) bool {45        return self.runtime.containsAll(required);46    }4748    pub fn validateCompileRequest(self: BackendCapabilities, request: CompileRequest) BackendError!void {49        if (!self.supportsArtifactFormat(request.requested_format)) return error.UnsupportedArtifactFormat;50        if (!self.dtypes.containsAll(request.required_dtypes)) return error.CapabilityMismatch;51        if (!self.supportsFeatures(request.required_features)) return error.CapabilityMismatch;52        if (!self.supportsSubgroup(request.required_subgroup)) return error.CapabilityMismatch;53    }5455    pub fn validateRuntimeRequirements(self: BackendCapabilities, required: RuntimeRequirements) BackendError!void {56        if (!self.supportsRuntime(required)) return error.CapabilityMismatch;57    }5859    pub fn validateBufferAllocation(self: BackendCapabilities, request: BufferAllocation) BackendError!void {60        if (request.byte_size == 0) return error.InvalidBuffer;61        if (request.alignment == 0) return error.InvalidBuffer;62        if ((request.alignment & (request.alignment - 1)) != 0) return error.InvalidBuffer;63        if (request.alignment < self.memory.min_buffer_alignment) return error.CapabilityMismatch;6465        const byte_size = std.math.cast(u64, request.byte_size) orelse return error.CapabilityMismatch;66        if (self.memory.max_allocation_bytes) |limit| {67            if (byte_size > limit) return error.CapabilityMismatch;68        }69        if (self.memory.global_bytes) |limit| {70            if (byte_size > limit) return error.CapabilityMismatch;71        }72        if (request.dtype) |dtype| {73            if (!self.supportsDType(dtype)) return error.CapabilityMismatch;74            if (request.element_count) |count| {75                const required_bytes = std.math.mul(u64, count, dtype.sizeOf()) catch return error.CapabilityMismatch;76                if (required_bytes > byte_size) return error.InvalidBuffer;77            }78        }79    }8081    pub fn validateTextureAllocation(self: BackendCapabilities, request: TextureAllocation) BackendError!void {82        if (!request.extent.valid()) return error.InvalidTexture;83        if (!request.usage.any()) return error.InvalidTexture;84        if (request.sample_count == 0) return error.InvalidTexture;85        if (!self.textures.supported) return error.CapabilityMismatch;86        if (!self.textures.supportsFormat(request.format)) return error.CapabilityMismatch;87        if (!self.textures.supportsUsage(request.usage)) return error.CapabilityMismatch;88        if (!self.textures.supportsExtent(request.extent)) return error.CapabilityMismatch;89        if (request.sample_count > self.textures.max_sample_count) return error.CapabilityMismatch;90    }9192    pub fn validateSurfaceCreation(self: BackendCapabilities, request: SurfaceCreationRequest) BackendError!void {93        if (!request.extent.valid()) return error.InvalidSurface;94        if (!request.usage.any() or !request.usage.present) return error.InvalidSurface;95        if (request.max_frames_in_flight == 0) return error.InvalidSurface;96        if (!self.surfaces.supported) return error.CapabilityMismatch;97        if (!self.surfaces.supportsPlatform(request.platform)) return error.CapabilityMismatch;98        if (!self.surfaces.supportsFormat(request.format)) return error.CapabilityMismatch;99        if (!self.surfaces.supportsColorSpace(request.color_space)) return error.CapabilityMismatch;100        if (!self.surfaces.supportsPresentMode(request.present_mode)) return error.CapabilityMismatch;101        if (!self.surfaces.supportsUsage(request.usage)) return error.CapabilityMismatch;102        if (!self.surfaces.supportsExtent(request.extent)) return error.CapabilityMismatch;103        if (request.max_frames_in_flight > self.surfaces.max_frames_in_flight) return error.CapabilityMismatch;104    }105106    pub fn validateRenderPipelineDesc(self: BackendCapabilities, desc: RenderPipelineDesc) BackendError!void {107        if (desc.vertex_entry_name.len == 0 or desc.fragment_entry_name.len == 0) return error.InvalidRenderArtifact;108        if (!self.raster.supported) return error.CapabilityMismatch;109        if (!self.raster.supportsArtifactFormat(desc.format)) return error.CapabilityMismatch;110        if (desc.target_format.isDepth()) return error.InvalidRenderArtifact;111        if (!self.raster.supportsTargetFormat(desc.target_format)) return error.CapabilityMismatch;112        if (desc.depth) |depth| {113            if (!depth.format.isDepth()) return error.InvalidRenderArtifact;114            if (!self.raster.supportsDepthFormat(depth.format)) return error.CapabilityMismatch;115            if (!depth.bias.valid()) return error.InvalidRenderArtifact;116            if (depth.bias.enabled() and !self.raster.depth_bias) return error.CapabilityMismatch;117            if (depth.bias.clamp != 0 and !self.raster.depth_bias_clamp) return error.CapabilityMismatch;118        }119        if (desc.push_constant_bytes % 4 != 0) return error.InvalidRenderArtifact;120        if (desc.push_constant_bytes > self.raster.max_push_constant_bytes) return error.CapabilityMismatch;121        if (desc.push_extent > desc.push_constant_bytes) return error.PushConstantRangeExceeded;122        if (!self.raster.supportsBlendMode(desc.blend_mode)) return error.CapabilityMismatch;123        if (!self.raster.supportsTopology(desc.topology)) return error.CapabilityMismatch;124        if (desc.vertex_layouts.len > self.raster.max_vertex_buffers) return error.CapabilityMismatch;125        if (desc.vertex_attributes.len > self.raster.max_vertex_attributes) return error.CapabilityMismatch;126        if (desc.bindings.len > self.raster.max_bindings) return error.CapabilityMismatch;127128        for (desc.vertex_layouts) |layout| {129            if (layout.stride == 0) return error.InvalidRenderArtifact;130            if (layout.step_mode == .instance and !self.raster.instancing) return error.CapabilityMismatch;131            const start: usize = @intCast(layout.attribute_start);132            const count: usize = @intCast(layout.attribute_count);133            if (count == 0) return error.InvalidRenderArtifact;134            if (start > desc.vertex_attributes.len or count > desc.vertex_attributes.len - start) return error.InvalidRenderArtifact;135            for (desc.vertex_attributes[start..][0..count]) |attribute| {136                if (!self.raster.supportsVertexFormat(attribute.format)) return error.CapabilityMismatch;137                const size = renderVertexFormatByteSize(attribute.format);138                if (attribute.offset > layout.stride or size > layout.stride - attribute.offset) return error.InvalidRenderArtifact;139            }140        }141142        for (desc.bindings) |binding| {143            if (!self.raster.supportsBindingKind(binding.kind)) return error.CapabilityMismatch;144        }145    }146147    /// Checks a pass against these capabilities and against the facts each draw's pipeline148    /// reported. A draw's pipeline declares a depth state exactly when the pass has a depth149    /// attachment, because a pipeline is built for the attachments it draws into.150    pub fn validateRenderPass(self: BackendCapabilities, pass: RenderPass) BackendError!void {151        if (!self.raster.supported) return error.CapabilityMismatch;152        if (!pass.viewport.valid()) return error.RenderArgumentMismatch;153        if (!pass.scissor.valid()) return error.RenderArgumentMismatch;154        const color = pass.color.view;155        if (color.texture.format != color.format) return error.InvalidTexture;156        if (!color.texture.usage.color_attachment) return error.InvalidTexture;157        if (!self.raster.supportsTargetFormat(color.format)) return error.CapabilityMismatch;158        switch (pass.color.load) {159            .load => {},160            .clear => |clear| if (!clear.valid()) return error.RenderArgumentMismatch,161        }162        const extent = color.texture.extent;163        if (!scissorWithin(pass.scissor, extent)) return error.RenderArgumentMismatch;164        if (pass.depth) |depth| {165            if (depth.view.texture.format != depth.view.format) return error.InvalidTexture;166            if (!depth.view.texture.usage.depth_attachment) return error.InvalidTexture;167            if (!self.raster.supportsDepthFormat(depth.view.format)) return error.CapabilityMismatch;168            if (!sameTextureExtent(depth.view.texture.extent, extent)) return error.RenderArgumentMismatch;169            switch (depth.load) {170                .load => {},171                .clear => |clear| if (!(clear >= 0 and clear <= 1)) return error.RenderArgumentMismatch,172            }173        }174        for (pass.draws) |draw| try self.validateRenderDraw(pass, draw);175    }176177    fn validateRenderDraw(self: BackendCapabilities, pass: RenderPass, draw: RenderDraw) BackendError!void {178        const pipeline = draw.pipeline;179        if (!draw.range.valid()) return error.RenderArgumentMismatch;180        if (pipeline.target_format != pass.color.view.format) return error.RenderArgumentMismatch;181        if ((pipeline.depth == null) != (pass.depth == null)) return error.RenderArgumentMismatch;182        if (pipeline.depth) |depth| {183            if (depth.format != pass.depth.?.view.format) return error.RenderArgumentMismatch;184        }185        if (draw.vertex_buffers.len != pipeline.vertex_buffer_count) return error.RenderArgumentMismatch;186        if ((pipeline.binding_count == 0) != (draw.bindings == null)) return error.RenderArgumentMismatch;187        if (draw.bindings) |bindings| {188            if (bindings.pipeline != pipeline.id) return error.RenderArgumentMismatch;189        }190        const range = draw.range;191        if (range.instance_count > 1 and !self.raster.instancing) return error.CapabilityMismatch;192        if (range.index_format != .none and !self.raster.supportsIndexFormat(range.index_format)) {193            return error.CapabilityMismatch;194        }195        if ((range.index_count != 0) != (draw.index_buffer != null)) return error.RenderArgumentMismatch;196        if (draw.push_constants.len != pipeline.push_constant_bytes) return error.RenderArgumentMismatch;197    }198199    /// Checks that `request` names one resource of the right kind for each pipeline binding.200    pub fn validateRenderBindings(self: BackendCapabilities, request: RenderBindingsRequest) BackendError!void {201        if (!self.raster.supported) return error.CapabilityMismatch;202        const bindings = request.artifact.bindings;203        if (request.pipeline.binding_count != bindings.len) return error.RenderArgumentMismatch;204        if (request.resources.len != bindings.len) return error.RenderArgumentMismatch;205        for (bindings, request.resources) |binding, resource| {206            if (std.meta.activeTag(resource) != binding.kind) return error.RenderArgumentMismatch;207            if (!self.raster.supportsBindingKind(binding.kind)) return error.CapabilityMismatch;208            switch (resource) {209                .uniform_buffer, .storage_buffer => {},210                .sampled_texture => |sampled| if (!sampled.texture.usage.sampled) return error.InvalidTexture,211                .storage_texture => |texture| if (!texture.usage.storage) return error.InvalidTexture,212            }213        }214    }215216    /// Checks that `byte_count` covers every texel of `texture` exactly once.217    pub fn validateTextureTransfer(texture: TextureHandle, byte_count: usize, usage: TextureUsage) BackendError!void {218        if (!texture.usage.containsAll(usage)) return error.InvalidTexture;219        if (byte_count != try textureByteSize(texture)) return error.InvalidTexture;220    }221222    pub fn validateLaunchRuntime(self: BackendCapabilities, request: LaunchRequest) BackendError!void {223        if (request.stream != null) try self.validateRuntimeRequirements(.{ .streams = true });224        if (request.wait_events.len != 0 or request.signal_event != null) try self.validateRuntimeRequirements(.{ .events = true });225    }226227    pub fn validateSubmitRuntime(228        self: BackendCapabilities,229        stream: ?StreamHandle,230        wait_events: []const EventHandle,231        signal_event: ?EventHandle,232    ) BackendError!void {233        if (stream != null) try self.validateRuntimeRequirements(.{ .streams = true });234        if (wait_events.len != 0 or signal_event != null) try self.validateRuntimeRequirements(.{ .events = true });235    }236237    pub fn validateSyncRuntime(self: BackendCapabilities, request: SyncRequest) BackendError!void {238        switch (request.scope) {239            .default_stream, .device => {},240            .stream => try self.validateRuntimeRequirements(.{ .streams = true }),241            .event => try self.validateRuntimeRequirements(.{ .events = true }),242        }243    }244245    pub fn validateLaunchGeometry(self: BackendCapabilities, geometry: choir_abi.LaunchGeometry) BackendError!void {246        if (geometry.grid[0] == 0 or geometry.grid[1] == 0 or geometry.grid[2] == 0) {247            return error.LaunchArgumentMismatch;248        }249        if (geometry.threadgroup[0] == 0 or geometry.threadgroup[1] == 0 or geometry.threadgroup[2] == 0) {250            return error.LaunchArgumentMismatch;251        }252253        const total_threads =254            @as(u64, geometry.threadgroup[0]) *255            @as(u64, geometry.threadgroup[1]) *256            @as(u64, geometry.threadgroup[2]);257        if (total_threads > self.threadgroup.max_threads) return error.CapabilityMismatch;258259        for (geometry.threadgroup, self.threadgroup.max_threads_per_dim) |requested, limit| {260            if (requested > limit) return error.CapabilityMismatch;261        }262        for (geometry.grid, self.threadgroup.max_blocks) |requested, limit| {263            if (requested > limit) return error.CapabilityMismatch;264        }265        for (geometry.grid, self.threadgroup.max_grid_per_dim) |requested, limit| {266            if (requested > limit) return error.CapabilityMismatch;267        }268        if (geometry.dynamic_shared_memory_bytes != 0 and !self.features.dynamic_shared_memory) {269            return error.CapabilityMismatch;270        }271        if (geometry.dynamic_shared_memory_bytes > self.threadgroup.shared_memory_bytes) {272            return error.CapabilityMismatch;273        }274    }275};

1pub const BackendCapabilities = contract.BackendCapabilities;