From 0fb1494a85992073d3a4978dcb089c2f16019b33 Mon Sep 17 00:00:00 2001 From: Ben Ashbaugh Date: Fri, 17 Jan 2025 18:17:21 -0800 Subject: [PATCH 1/5] tests for cl_khr_spirv_queries --- .github/workflows/presubmit.yml | 5 + CMakeLists.txt | 7 + README.md | 4 + test_conformance/api/CMakeLists.txt | 1 + .../api/generate_spirv_capability_deps.py | 95 +++ .../api/spirv_capability_deps.def | 312 +++++++ test_conformance/api/test_spirv_queries.cpp | 766 ++++++++++++++++++ 7 files changed, 1190 insertions(+) create mode 100644 test_conformance/api/generate_spirv_capability_deps.py create mode 100644 test_conformance/api/spirv_capability_deps.def create mode 100644 test_conformance/api/test_spirv_queries.cpp diff --git a/.github/workflows/presubmit.yml b/.github/workflows/presubmit.yml index 66b03df29c..f9c589e155 100644 --- a/.github/workflows/presubmit.yml +++ b/.github/workflows/presubmit.yml @@ -61,6 +61,10 @@ jobs: cd OpenCL-Headers ln -s CL OpenCL # For OSX builds cd .. + - name: Fetch SPIR-V Headers + shell: bash + run: | + git clone https://github.com/KhronosGroup/SPIRV-Headers.git - name: Install Vulkan SDK uses: humbletim/install-vulkan-sdk@main with: @@ -159,6 +163,7 @@ jobs: -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \ -DCMAKE_CACHE_OPTIONS="-DCMAKE_C_COMPILER_LAUNCHER=sccache -DCMAKE_CXX_COMPILER_LAUNCHER=sccache" \ -DCL_INCLUDE_DIR='${{ github.workspace }}'/OpenCL-Headers \ + -DSPIRV_INCLUDE_DIR='${{ github.workspace }}'/SPIRV-Headers \ -DCL_LIB_DIR='${{ github.workspace }}'/OpenCL-ICD-Loader/build \ -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE} \ -DCMAKE_RUNTIME_OUTPUT_DIRECTORY=./bin \ diff --git a/CMakeLists.txt b/CMakeLists.txt index 7ba12adfec..0ff1e1d845 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -59,6 +59,12 @@ else(CL_INCLUDE_DIR AND CL_LIB_DIR) message(FATAL_ERROR "Either install OpenCL or pass -DCL_INCLUDE_DIR and -DCL_LIB_DIR") endif(CL_INCLUDE_DIR AND CL_LIB_DIR) +# SPIRV_INCLUDE_DIR - path to dir with SPIR-V headers +if(NOT SPIRV_INCLUDE_DIR) + message(STATUS "SPIR-V headers haven't been found!") + message(FATAL_ERROR "Pass -DSPIRV_INCLUDE_DIR") +endif(NOT SPIRV_INCLUDE_DIR) + # CLConform_GL_LIBRARIES_DIR - path to OpenGL libraries if(GL_IS_SUPPORTED AND CLConform_GL_LIBRARIES_DIR) link_directories(${CLConform_GL_LIBRARIES_DIR}) @@ -191,6 +197,7 @@ if(APPLE) endif(APPLE) include_directories(SYSTEM ${CL_INCLUDE_DIR}) +include_directories(SYSTEM ${SPIRV_INCLUDE_DIR}/include) include_directories(${CLConform_SOURCE_DIR}/test_common/harness ${CLConform_SOURCE_DIR}/test_common/gles ${CLConform_SOURCE_DIR}/test_common/gl diff --git a/README.md b/README.md index 0cc09b1b21..77e4d9a9bd 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,8 @@ Compiling the CTS requires the following CMake configuration options to be set: * `CL_INCLUDE_DIR` Points to the unified [OpenCL-Headers](https://github.com/KhronosGroup/OpenCL-Headers). +* `SPIRV_INCLUDE_DIR` Points to the unified + [SPIRV-Headers](https://github.com/KhronosGroup/SPIRV-Headers). * `CL_LIB_DIR` Directory containing the OpenCL library to build against. * `SPIRV_TOOLS_DIR` Directory containing the `spirv-as` and `spirv-val` binaries to be used in the CTS build process. Alternatively, the location to these binaries @@ -31,6 +33,7 @@ a build, and compile. ```sh git clone https://github.com/KhronosGroup/OpenCL-CTS.git git clone https://github.com/KhronosGroup/OpenCL-Headers.git +git clone https://github.com/KhronosGroup/SPIRV-Headers.git git clone https://github.com/KhronosGroup/OpenCL-ICD-Loader.git git clone https://github.com/KhronosGroup/SPIRV-Tools.git git clone https://github.com/KhronosGroup/SPIRV-Headers.git SPIRV-Tools/external/spirv-headers @@ -50,6 +53,7 @@ cmake --build SPIRV-Tools/build --config Release mkdir OpenCL-CTS/build cmake -S OpenCL-CTS -B OpenCL-CTS/build \ -DCL_INCLUDE_DIR=$PWD/OpenCL-Headers \ + -DSPIRV_INCLUDE_DIR=$PWD/SPIRV-Headers \ -DCL_LIB_DIR=$PWD/OpenCL-ICD-Loader/build \ -DSPIRV_TOOLS_DIR=$PWD/SPIRV-Tools/build/tools/ \ -DOPENCL_LIBRARIES=OpenCL diff --git a/test_conformance/api/CMakeLists.txt b/test_conformance/api/CMakeLists.txt index 3df9a81f73..833c1e6145 100644 --- a/test_conformance/api/CMakeLists.txt +++ b/test_conformance/api/CMakeLists.txt @@ -39,6 +39,7 @@ set(${MODULE_NAME}_SOURCES test_pipe_properties_queries.cpp test_wg_suggested_local_work_size.cpp test_device_command_queue.cpp + test_spirv_queries.cpp ) include(../CMakeCommon.txt) diff --git a/test_conformance/api/generate_spirv_capability_deps.py b/test_conformance/api/generate_spirv_capability_deps.py new file mode 100644 index 0000000000..111c9bdde1 --- /dev/null +++ b/test_conformance/api/generate_spirv_capability_deps.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python3 + +##################################################################### +# Copyright (c) 2025 The Khronos Group Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +##################################################################### + +""" +Generates a file describing the SPIR-V extension dependencies or SPIR-V version +dependencies for a SPIR-V capability. This can be used to ensure that if support +for a SPIR-V capability is reported, the necessary SPIR-V extensions or SPIR-V +version is also supported. +""" + +import argparse +import json + +header_text = """\ +// +// Copyright (c) 2025 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +// This file is generated from the SPIR-V JSON grammar file. +// Please do not edit it directly! +""" + +def main(): + parser = argparse.ArgumentParser(description='Generate SPIR-V extension and version dependencies for SPIR-V capabilities') + + parser.add_argument('--grammar', metavar='', + type=str, required=True, + help='input JSON grammar file') + args = parser.parse_args() + + dependencies = {} + capabilities = [] + with open(args.grammar) as json_file: + grammar_json = json.loads(json_file.read()) + for operand_kind in grammar_json['operand_kinds']: + if operand_kind['kind'] == 'Capability': + for cap in operand_kind['enumerants']: + capname = cap['enumerant'] + capabilities.append(capname) + dependencies[capname] = {} + dependencies[capname]['extensions'] = cap['extensions'] if 'extensions' in cap else [] + dependencies[capname]['version'] = ("SPIR-V_" + cap['version']) if 'version' in cap and cap['version'] != 'None' else "" + + capabilities.sort() + + print(header_text) + print("// clang-format off") + if False: + for cap in capabilities: + deps = dependencies[cap] + extensions_str = ', '.join(f'"{ext}"' for ext in deps['extensions']) + + print('SPIRV_CAPABILITY_DEPENDENCIES( ', end = "") + print('{}, '.format(cap), end = "") + print('{{{}}}, '.format(extensions_str), end = "") + print('"{}"'.format(deps['version']), end = "") + print(' )') + else: + for cap in capabilities: + deps = dependencies[cap] + if deps['version'] != "": + print('SPIRV_CAPABILITY_VERSION_DEPENDENCY( {}, "{}" )'.format(cap, deps['version'])) + for ext in deps['extensions']: + print('SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( {}, "{}" )'.format(cap, ext)) + print("// clang-format on") + +if __name__ == '__main__': + main() diff --git a/test_conformance/api/spirv_capability_deps.def b/test_conformance/api/spirv_capability_deps.def new file mode 100644 index 0000000000..abc726f8a4 --- /dev/null +++ b/test_conformance/api/spirv_capability_deps.def @@ -0,0 +1,312 @@ +// +// Copyright (c) 2025 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +// This file is generated from the SPIR-V JSON grammar file. +// Please do not edit it directly! + +// clang-format off +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Addresses, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ArbitraryPrecisionFixedPointINTEL, "SPV_INTEL_arbitrary_precision_fixed_point" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ArbitraryPrecisionFloatingPointINTEL, "SPV_INTEL_arbitrary_precision_floating_point" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ArbitraryPrecisionIntegersINTEL, "SPV_INTEL_arbitrary_precision_integers" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ArithmeticFenceEXT, "SPV_EXT_arithmetic_fence" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( AsmINTEL, "SPV_INTEL_inline_assembly" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( AtomicFloat16AddEXT, "SPV_EXT_shader_atomic_float16_add" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( AtomicFloat16MinMaxEXT, "SPV_EXT_shader_atomic_float_min_max" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( AtomicFloat16VectorNV, "SPV_NV_shader_atomic_fp16_vector" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( AtomicFloat32AddEXT, "SPV_EXT_shader_atomic_float_add" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( AtomicFloat32MinMaxEXT, "SPV_EXT_shader_atomic_float_min_max" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( AtomicFloat64AddEXT, "SPV_EXT_shader_atomic_float_add" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( AtomicFloat64MinMaxEXT, "SPV_EXT_shader_atomic_float_min_max" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( AtomicStorage, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( AtomicStorageOps, "SPV_KHR_shader_atomic_counter_ops" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( BFloat16ConversionINTEL, "SPV_INTEL_bfloat16_conversion" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( BindlessTextureNV, "SPV_NV_bindless_texture" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( BitInstructions, "SPV_KHR_bit_instructions" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( BlockingPipesINTEL, "SPV_INTEL_blocking_pipes" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CacheControlsINTEL, "SPV_INTEL_cache_controls" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ClipDistance, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ComputeDerivativeGroupLinearKHR, "SPV_NV_compute_shader_derivatives" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ComputeDerivativeGroupLinearKHR, "SPV_KHR_compute_shader_derivatives" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ComputeDerivativeGroupQuadsKHR, "SPV_NV_compute_shader_derivatives" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ComputeDerivativeGroupQuadsKHR, "SPV_KHR_compute_shader_derivatives" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CooperativeMatrixBlockLoadsNV, "SPV_NV_cooperative_matrix2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CooperativeMatrixConversionsNV, "SPV_NV_cooperative_matrix2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CooperativeMatrixKHR, "SPV_KHR_cooperative_matrix" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CooperativeMatrixLayoutsARM, "SPV_ARM_cooperative_matrix_layouts" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CooperativeMatrixNV, "SPV_NV_cooperative_matrix" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CooperativeMatrixPerElementOperationsNV, "SPV_NV_cooperative_matrix2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CooperativeMatrixReductionsNV, "SPV_NV_cooperative_matrix2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CooperativeMatrixTensorAddressingNV, "SPV_NV_cooperative_matrix2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( CoreBuiltinsARM, "SPV_ARM_core_builtins" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( CullDistance, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DebugInfoModuleINTEL, "SPV_INTEL_debug_module" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DemoteToHelperInvocation, "SPIR-V_1.6" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DemoteToHelperInvocation, "SPV_EXT_demote_to_helper_invocation" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DenormFlushToZero, "SPIR-V_1.4" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DenormFlushToZero, "SPV_KHR_float_controls" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DenormPreserve, "SPIR-V_1.4" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DenormPreserve, "SPV_KHR_float_controls" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DerivativeControl, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DeviceEnqueue, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DeviceGroup, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DeviceGroup, "SPV_KHR_device_group" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DisplacementMicromapNV, "SPV_NV_displacement_micromap" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DotProduct, "SPIR-V_1.6" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DotProduct, "SPV_KHR_integer_dot_product" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DotProductInput4x8Bit, "SPIR-V_1.6" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DotProductInput4x8Bit, "SPV_KHR_integer_dot_product" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DotProductInput4x8BitPacked, "SPIR-V_1.6" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DotProductInput4x8BitPacked, "SPV_KHR_integer_dot_product" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DotProductInputAll, "SPIR-V_1.6" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DotProductInputAll, "SPV_KHR_integer_dot_product" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( DrawParameters, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( DrawParameters, "SPV_KHR_shader_draw_parameters" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ExpectAssumeKHR, "SPV_KHR_expect_assume" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPFastMathModeINTEL, "SPV_INTEL_fp_fast_math_mode" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGAArgumentInterfacesINTEL, "SPV_INTEL_fpga_argument_interfaces" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGABufferLocationINTEL, "SPV_INTEL_fpga_buffer_location" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGAClusterAttributesINTEL, "SPV_INTEL_fpga_cluster_attributes" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGAClusterAttributesV2INTEL, "SPV_INTEL_fpga_cluster_attributes" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGADSPControlINTEL, "SPV_INTEL_fpga_dsp_control" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGAInvocationPipeliningAttributesINTEL, "SPV_INTEL_fpga_invocation_pipelining_attributes" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGAKernelAttributesINTEL, "SPV_INTEL_kernel_attributes" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGAKernelAttributesv2INTEL, "SPV_INTEL_kernel_attributes" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGALatencyControlINTEL, "SPV_INTEL_fpga_latency_control" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGALoopControlsINTEL, "SPV_INTEL_fpga_loop_controls" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGAMemoryAccessesINTEL, "SPV_INTEL_fpga_memory_accesses" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGAMemoryAttributesINTEL, "SPV_INTEL_fpga_memory_attributes" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPGARegINTEL, "SPV_INTEL_fpga_reg" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FPMaxErrorINTEL, "SPV_INTEL_fp_max_error" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Float16, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Float16Buffer, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( Float16ImageAMD, "SPV_AMD_gpu_shader_half_float_fetch" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Float64, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FloatControls2, "SPV_KHR_float_controls2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FloatingPointModeINTEL, "SPV_INTEL_float_controls2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentBarycentricKHR, "SPV_NV_fragment_shader_barycentric" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentBarycentricKHR, "SPV_KHR_fragment_shader_barycentric" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentDensityEXT, "SPV_EXT_fragment_invocation_density" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentDensityEXT, "SPV_NV_shading_rate" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentFullyCoveredEXT, "SPV_EXT_fragment_fully_covered" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentMaskAMD, "SPV_AMD_shader_fragment_mask" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentShaderPixelInterlockEXT, "SPV_EXT_fragment_shader_interlock" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentShaderSampleInterlockEXT, "SPV_EXT_fragment_shader_interlock" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentShaderShadingRateInterlockEXT, "SPV_EXT_fragment_shader_interlock" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FragmentShadingRateKHR, "SPV_KHR_fragment_shading_rate" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FunctionFloatControlINTEL, "SPV_INTEL_float_controls2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( FunctionPointersINTEL, "SPV_INTEL_function_pointers" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GenericPointer, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Geometry, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GeometryPointSize, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( GeometryShaderPassthroughNV, "SPV_NV_geometry_shader_passthrough" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GeometryStreams, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( GlobalVariableFPGADecorationsINTEL, "SPV_INTEL_global_variable_fpga_decorations" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( GlobalVariableHostAccessINTEL, "SPV_INTEL_global_variable_host_access" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GroupNonUniform, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GroupNonUniformArithmetic, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GroupNonUniformBallot, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GroupNonUniformClustered, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( GroupNonUniformPartitionedNV, "SPV_NV_shader_subgroup_partitioned" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GroupNonUniformQuad, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( GroupNonUniformRotateKHR, "SPV_KHR_subgroup_rotate" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GroupNonUniformShuffle, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GroupNonUniformShuffleRelative, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( GroupNonUniformVote, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( GroupUniformArithmeticKHR, "SPV_KHR_uniform_group_instructions" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Groups, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( Groups, "SPV_AMD_shader_ballot" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( IOPipesINTEL, "SPV_INTEL_io_pipes" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Image1D, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ImageBasic, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ImageBuffer, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ImageCubeArray, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ImageFootprintNV, "SPV_NV_shader_image_footprint" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ImageGatherBiasLodAMD, "SPV_AMD_texture_gather_bias_lod" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ImageGatherExtended, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ImageMSArray, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ImageMipmap, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ImageQuery, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ImageReadWrite, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ImageReadWriteLodAMD, "SPV_AMD_shader_image_load_store_lod" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ImageRect, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( IndirectReferencesINTEL, "SPV_INTEL_function_pointers" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( InputAttachment, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( InputAttachmentArrayDynamicIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( InputAttachmentArrayDynamicIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( InputAttachmentArrayNonUniformIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( InputAttachmentArrayNonUniformIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Int16, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Int64, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Int64Atomics, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( Int64ImageEXT, "SPV_EXT_shader_image_int64" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Int8, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( IntegerFunctions2INTEL, "SPV_INTEL_shader_integer_functions2" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( InterpolationFunction, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Kernel, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( KernelAttributesINTEL, "SPV_INTEL_kernel_attributes" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Linkage, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( LiteralSampler, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( LongCompositesINTEL, "SPV_INTEL_long_composites" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( LoopFuseINTEL, "SPV_INTEL_loop_fuse" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( MaskedGatherScatterINTEL, "SPV_INTEL_masked_gather_scatter" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Matrix, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( MemoryAccessAliasingINTEL, "SPV_INTEL_memory_access_aliasing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( MeshShadingEXT, "SPV_EXT_mesh_shader" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( MeshShadingNV, "SPV_NV_mesh_shader" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( MinLod, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( MultiView, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( MultiView, "SPV_KHR_multiview" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( MultiViewport, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( NamedBarrier, "SPIR-V_1.1" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( OptNoneEXT, "SPV_EXT_optnone" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( OptNoneEXT, "SPV_INTEL_optnone" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( PerViewAttributesNV, "SPV_NVX_multiview_per_view_attributes" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( PhysicalStorageBufferAddresses, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( PhysicalStorageBufferAddresses, "SPV_EXT_physical_storage_buffer" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( PhysicalStorageBufferAddresses, "SPV_KHR_physical_storage_buffer" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( PipeStorage, "SPIR-V_1.1" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Pipes, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( QuadControlKHR, "SPV_KHR_quad_control" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RawAccessChainsNV, "SPV_NV_raw_access_chains" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayCullMaskKHR, "SPV_KHR_ray_cull_mask" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayQueryKHR, "SPV_KHR_ray_query" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayQueryPositionFetchKHR, "SPV_KHR_ray_tracing_position_fetch" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayQueryProvisionalKHR, "SPV_KHR_ray_query" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayTracingDisplacementMicromapNV, "SPV_NV_displacement_micromap" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayTracingKHR, "SPV_KHR_ray_tracing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayTracingMotionBlurNV, "SPV_NV_ray_tracing_motion_blur" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayTracingNV, "SPV_NV_ray_tracing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayTracingOpacityMicromapEXT, "SPV_EXT_opacity_micromap" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayTracingPositionFetchKHR, "SPV_KHR_ray_tracing_position_fetch" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayTracingProvisionalKHR, "SPV_KHR_ray_tracing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayTraversalPrimitiveCullingKHR, "SPV_KHR_ray_query" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RayTraversalPrimitiveCullingKHR, "SPV_KHR_ray_tracing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RegisterLimitsINTEL, "SPV_INTEL_maximum_registers" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ReplicatedCompositesEXT, "SPV_EXT_replicated_composites" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RoundToInfinityINTEL, "SPV_INTEL_float_controls2" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( RoundingModeRTE, "SPIR-V_1.4" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RoundingModeRTE, "SPV_KHR_float_controls" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( RoundingModeRTZ, "SPIR-V_1.4" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RoundingModeRTZ, "SPV_KHR_float_controls" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RuntimeAlignedAttributeINTEL, "SPV_INTEL_runtime_aligned" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( RuntimeDescriptorArray, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( RuntimeDescriptorArray, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SampleMaskOverrideCoverageNV, "SPV_NV_sample_mask_override_coverage" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SampleMaskPostDepthCoverage, "SPV_KHR_post_depth_coverage" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( SampleRateShading, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Sampled1D, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( SampledBuffer, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( SampledCubeArray, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( SampledImageArrayDynamicIndexing, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( SampledImageArrayNonUniformIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SampledImageArrayNonUniformIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( SampledRect, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Shader, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ShaderClockKHR, "SPV_KHR_shader_clock" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ShaderEnqueueAMDX, "SPV_AMDX_shader_enqueue" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ShaderInvocationReorderNV, "SPV_NV_shader_invocation_reorder" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ShaderLayer, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ShaderNonUniform, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ShaderNonUniform, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ShaderSMBuiltinsNV, "SPV_NV_shader_sm_builtins" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ShaderStereoViewNV, "SPV_NV_stereo_view_rendering" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( ShaderViewportIndex, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ShaderViewportIndexLayerEXT, "SPV_EXT_shader_viewport_index_layer" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ShaderViewportIndexLayerEXT, "SPV_NV_viewport_array2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( ShaderViewportMaskNV, "SPV_NV_viewport_array2" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( SignedZeroInfNanPreserve, "SPIR-V_1.4" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SignedZeroInfNanPreserve, "SPV_KHR_float_controls" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( SparseResidency, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SplitBarrierINTEL, "SPV_INTEL_split_barrier" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StencilExportEXT, "SPV_EXT_shader_stencil_export" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageBuffer16BitAccess, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StorageBuffer16BitAccess, "SPV_KHR_16bit_storage" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageBuffer8BitAccess, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StorageBuffer8BitAccess, "SPV_KHR_8bit_storage" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageBufferArrayDynamicIndexing, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageBufferArrayNonUniformIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StorageBufferArrayNonUniformIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageImageArrayDynamicIndexing, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageImageArrayNonUniformIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StorageImageArrayNonUniformIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageImageExtendedFormats, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageImageMultisample, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageImageReadWithoutFormat, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageImageWriteWithoutFormat, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageInputOutput16, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StorageInputOutput16, "SPV_KHR_16bit_storage" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StoragePushConstant16, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StoragePushConstant16, "SPV_KHR_16bit_storage" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StoragePushConstant8, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StoragePushConstant8, "SPV_KHR_8bit_storage" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageTexelBufferArrayDynamicIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StorageTexelBufferArrayDynamicIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( StorageTexelBufferArrayNonUniformIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( StorageTexelBufferArrayNonUniformIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupAvcMotionEstimationChromaINTEL, "SPV_INTEL_device_side_avc_motion_estimation" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupAvcMotionEstimationINTEL, "SPV_INTEL_device_side_avc_motion_estimation" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupAvcMotionEstimationIntraINTEL, "SPV_INTEL_device_side_avc_motion_estimation" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupBallotKHR, "SPV_KHR_shader_ballot" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupBufferBlockIOINTEL, "SPV_INTEL_subgroups" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupBufferPrefetchINTEL, "SPV_INTEL_subgroup_buffer_prefetch" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( SubgroupDispatch, "SPIR-V_1.1" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupImageBlockIOINTEL, "SPV_INTEL_subgroups" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupImageMediaBlockIOINTEL, "SPV_INTEL_media_block_io" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupShuffleINTEL, "SPV_INTEL_subgroups" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( SubgroupVoteKHR, "SPV_KHR_subgroup_vote" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( TensorAddressingNV, "SPV_NV_tensor_addressing" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Tessellation, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( TessellationPointSize, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( TextureBlockMatch2QCOM, "SPV_QCOM_image_processing2" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( TextureBlockMatchQCOM, "SPV_QCOM_image_processing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( TextureBoxFilterQCOM, "SPV_QCOM_image_processing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( TextureSampleWeightedQCOM, "SPV_QCOM_image_processing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( TileImageColorReadAccessEXT, "SPV_EXT_shader_tile_image" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( TileImageDepthReadAccessEXT, "SPV_EXT_shader_tile_image" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( TileImageStencilReadAccessEXT, "SPV_EXT_shader_tile_image" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( TransformFeedback, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( USMStorageClassesINTEL, "SPV_INTEL_usm_storage_classes" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( UniformAndStorageBuffer16BitAccess, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( UniformAndStorageBuffer16BitAccess, "SPV_KHR_16bit_storage" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( UniformAndStorageBuffer8BitAccess, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( UniformAndStorageBuffer8BitAccess, "SPV_KHR_8bit_storage" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( UniformBufferArrayDynamicIndexing, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( UniformBufferArrayNonUniformIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( UniformBufferArrayNonUniformIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( UniformDecoration, "SPIR-V_1.6" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( UniformTexelBufferArrayDynamicIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( UniformTexelBufferArrayDynamicIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( UniformTexelBufferArrayNonUniformIndexing, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( UniformTexelBufferArrayNonUniformIndexing, "SPV_EXT_descriptor_indexing" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( UnstructuredLoopControlsINTEL, "SPV_INTEL_unstructured_loop_controls" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( UntypedPointersKHR, "SPV_KHR_untyped_pointers" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( VariableLengthArrayINTEL, "SPV_INTEL_variable_length_array" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( VariablePointers, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( VariablePointers, "SPV_KHR_variable_pointers" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( VariablePointersStorageBuffer, "SPIR-V_1.3" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( VariablePointersStorageBuffer, "SPV_KHR_variable_pointers" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( Vector16, "SPIR-V_1.0" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( VectorAnyINTEL, "SPV_INTEL_vector_compute" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( VectorComputeINTEL, "SPV_INTEL_vector_compute" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( VulkanMemoryModel, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( VulkanMemoryModel, "SPV_KHR_vulkan_memory_model" ) +SPIRV_CAPABILITY_VERSION_DEPENDENCY( VulkanMemoryModelDeviceScope, "SPIR-V_1.5" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( VulkanMemoryModelDeviceScope, "SPV_KHR_vulkan_memory_model" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( WorkgroupMemoryExplicitLayout16BitAccessKHR, "SPV_KHR_workgroup_memory_explicit_layout" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( WorkgroupMemoryExplicitLayout8BitAccessKHR, "SPV_KHR_workgroup_memory_explicit_layout" ) +SPIRV_CAPABILITY_EXTENSION_DEPENDENCY( WorkgroupMemoryExplicitLayoutKHR, "SPV_KHR_workgroup_memory_explicit_layout" ) +// clang-format on diff --git a/test_conformance/api/test_spirv_queries.cpp b/test_conformance/api/test_spirv_queries.cpp new file mode 100644 index 0000000000..17f778a7f1 --- /dev/null +++ b/test_conformance/api/test_spirv_queries.cpp @@ -0,0 +1,766 @@ +// +// Copyright (c) 2025 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#include "testBase.h" +#include +#include +#include + +#define SPV_ENABLE_UTILITY_CODE +#include + +#ifndef cl_khr_spirv_queries +#define cl_khr_spirv_queries 1 +#define CL_KHR_SPIRV_QUERIES_EXTENSION_NAME "cl_khr_spirv_queries" +#define CL_DEVICE_SPIRV_EXTENDED_INSTRUCTION_SETS_KHR 0x12B9 +#define CL_DEVICE_SPIRV_EXTENSIONS_KHR 0x12BA +#define CL_DEVICE_SPIRV_CAPABILITIES_KHR 0x12BB +#endif + +static bool is_spirv_version_supported(cl_device_id deviceID, + const std::string& version) +{ + std::string ilVersions = get_device_il_version_string(deviceID); + return ilVersions.find(version) != std::string::npos; +} + +static int doQueries(cl_device_id device, + std::vector& extendedInstructionSets, + std::vector& extensions, + std::vector& capabilities) +{ + cl_int error = CL_SUCCESS; + + size_t size = 0; + error = + clGetDeviceInfo(device, CL_DEVICE_SPIRV_EXTENDED_INSTRUCTION_SETS_KHR, + 0, nullptr, &size); + test_error(error, + "clGetDeviceInfo failed for " + "CL_DEVICE_SPIRV_EXTENDED_INSTRUCTION_SETS_KHR size\n"); + + extendedInstructionSets.resize(size / sizeof(const char*)); + error = + clGetDeviceInfo(device, CL_DEVICE_SPIRV_EXTENDED_INSTRUCTION_SETS_KHR, + size, extendedInstructionSets.data(), nullptr); + test_error(error, + "clGetDeviceInfo failed for " + "CL_DEVICE_SPIRV_EXTENDED_INSTRUCTION_SETS_KHR\n"); + + error = clGetDeviceInfo(device, CL_DEVICE_SPIRV_EXTENSIONS_KHR, 0, nullptr, + &size); + test_error( + error, + "clGetDeviceInfo failed for CL_DEVICE_SPIRV_EXTENSIONS_KHR size\n"); + + extensions.resize(size / sizeof(const char*)); + error = clGetDeviceInfo(device, CL_DEVICE_SPIRV_EXTENSIONS_KHR, size, + extensions.data(), nullptr); + test_error(error, + "clGetDeviceInfo failed for CL_DEVICE_SPIRV_EXTENSIONS_KHR\n"); + + error = clGetDeviceInfo(device, CL_DEVICE_SPIRV_CAPABILITIES_KHR, 0, + nullptr, &size); + test_error( + error, + "clGetDeviceInfo failed for CL_DEVICE_SPIRV_CAPABILITIES_KHR size\n"); + + capabilities.resize(size / sizeof(cl_uint)); + error = clGetDeviceInfo(device, CL_DEVICE_SPIRV_CAPABILITIES_KHR, size, + capabilities.data(), nullptr); + test_error(error, + "clGetDeviceInfo failed for CL_DEVICE_SPIRV_CAPABILITIES_KHR\n"); + + return CL_SUCCESS; +} + +static int findRequirements(cl_device_id device, + std::vector& extendedInstructionSets, + std::vector& extensions, + std::vector& capabilities) +{ + cl_int error = CL_SUCCESS; + + auto version = get_device_cl_version(device); + auto ilVersions = get_device_il_version_string(device); + + // If no SPIR-V versions are supported, there are no requirements. + if (ilVersions.find("SPIR-V") == std::string::npos) + { + return CL_SUCCESS; + } + + cl_bool deviceImageSupport = CL_FALSE; + cl_bool deviceReadWriteImageSupport = CL_FALSE; + cl_bool deviceSubGroupsSupport = CL_FALSE; + cl_bool deviceGenericAddressSpaceSupport = CL_FALSE; + cl_bool deviceWorkGroupCollectiveFunctionsSupport = CL_FALSE; + cl_bool devicePipeSupport = CL_FALSE; + cl_bool deviceDeviceEnqueueSupport = CL_FALSE; + cl_device_integer_dot_product_capabilities_khr + deviceIntegerDotProductCapabilities = 0; + cl_device_fp_atomic_capabilities_ext deviceFp32AtomicCapabilities = 0; + cl_device_fp_atomic_capabilities_ext deviceFp16AtomicCapabilities = 0; + cl_device_fp_atomic_capabilities_ext deviceFp64AtomicCapabilities = 0; + + error = clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, + sizeof(deviceImageSupport), &deviceImageSupport, + nullptr); + test_error(error, "clGetDeviceInfo failed for CL_DEVICE_IMAGE_SUPPORT\n"); + + if (version >= Version(2, 0)) + { + cl_uint deviceMaxReadWriteImageArgs = 0; + error = clGetDeviceInfo(device, CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, + sizeof(deviceMaxReadWriteImageArgs), + &deviceMaxReadWriteImageArgs, nullptr); + test_error( + error, + "clGetDeviceInfo failed for CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS\n"); + + deviceReadWriteImageSupport = + deviceMaxReadWriteImageArgs != 0 ? CL_TRUE : CL_FALSE; + } + + if (version >= Version(2, 1)) + { + cl_uint deviceMaxNumSubGroups = 0; + error = clGetDeviceInfo(device, CL_DEVICE_MAX_NUM_SUB_GROUPS, + sizeof(deviceMaxNumSubGroups), + &deviceMaxNumSubGroups, nullptr); + test_error(error, + "clGetDeviceInfo failed for CL_DEVICE_MAX_NUM_SUB_GROUPS\n"); + + deviceSubGroupsSupport = + deviceMaxNumSubGroups != 0 ? CL_TRUE : CL_FALSE; + } + else if (is_extension_available(device, "cl_khr_subgroups")) + { + deviceSubGroupsSupport = CL_TRUE; + } + + if (version >= Version(3, 0)) + { + error = clGetDeviceInfo(device, CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT, + sizeof(deviceGenericAddressSpaceSupport), + &deviceGenericAddressSpaceSupport, nullptr); + test_error(error, + "clGetDeviceInfo failed for " + "CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT\n"); + + error = clGetDeviceInfo( + device, CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT, + sizeof(deviceWorkGroupCollectiveFunctionsSupport), + &deviceWorkGroupCollectiveFunctionsSupport, nullptr); + test_error(error, + "clGetDeviceInfo failed for " + "CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT\n"); + + error = clGetDeviceInfo(device, CL_DEVICE_PIPE_SUPPORT, + sizeof(devicePipeSupport), &devicePipeSupport, + nullptr); + test_error(error, + "clGetDeviceInfo failed for CL_DEVICE_PIPE_SUPPORT\n"); + + cl_device_device_enqueue_capabilities deviceDeviceEnqueueCapabilities = + 0; + error = clGetDeviceInfo(device, CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES, + sizeof(deviceDeviceEnqueueCapabilities), + &deviceDeviceEnqueueCapabilities, nullptr); + test_error(error, + "clGetDeviceInfo failed for " + "CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES\n"); + + deviceDeviceEnqueueSupport = + deviceDeviceEnqueueCapabilities != 0 ? CL_TRUE : CL_FALSE; + } + else if (version >= Version(2, 0)) + { + deviceGenericAddressSpaceSupport = CL_TRUE; + deviceWorkGroupCollectiveFunctionsSupport = CL_TRUE; + devicePipeSupport = CL_TRUE; + deviceDeviceEnqueueSupport = CL_TRUE; + } + + if (is_extension_available(device, "cl_khr_integer_dot_product")) + { + error = clGetDeviceInfo(device, + CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR, + sizeof(deviceIntegerDotProductCapabilities), + &deviceIntegerDotProductCapabilities, nullptr); + test_error(error, + "clGetDeviceInfo failed for " + "CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR\n"); + } + + if (is_extension_available(device, "cl_ext_float_atomics")) + { + error = + clGetDeviceInfo(device, CL_DEVICE_SINGLE_FP_ATOMIC_CAPABILITIES_EXT, + sizeof(deviceFp32AtomicCapabilities), + &deviceFp32AtomicCapabilities, nullptr); + test_error(error, + "clGetDeviceInfo failed for " + "CL_DEVICE_SINGLE_FP_ATOMIC_CAPABILITIES_EXT\n"); + + error = + clGetDeviceInfo(device, CL_DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT, + sizeof(deviceFp16AtomicCapabilities), + &deviceFp16AtomicCapabilities, nullptr); + test_error(error, + "clGetDeviceInfo failed for " + "CL_DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT\n"); + + error = + clGetDeviceInfo(device, CL_DEVICE_DOUBLE_FP_ATOMIC_CAPABILITIES_EXT, + sizeof(deviceFp64AtomicCapabilities), + &deviceFp64AtomicCapabilities, nullptr); + test_error(error, + "clGetDeviceInfo failed for " + "CL_DEVICE_DOUBLE_FP_ATOMIC_CAPABILITIES_EXT\n"); + } + + // Required. + extendedInstructionSets.push_back("OpenCL.std"); + + capabilities.push_back(spv::CapabilityAddresses); + capabilities.push_back(spv::CapabilityFloat16Buffer); + capabilities.push_back(spv::CapabilityInt16); + capabilities.push_back(spv::CapabilityInt8); + capabilities.push_back(spv::CapabilityKernel); + capabilities.push_back(spv::CapabilityLinkage); + capabilities.push_back(spv::CapabilityVector16); + + // Required for FULL_PROFILE devices, or devices supporting + // cles_khr_int64. + if (gHasLong) + { + capabilities.push_back(spv::CapabilityInt64); + } + + // Required for devices supporting images. + if (deviceImageSupport == CL_TRUE) + { + capabilities.push_back(spv::CapabilityImage1D); + capabilities.push_back(spv::CapabilityImageBasic); + capabilities.push_back(spv::CapabilityImageBuffer); + capabilities.push_back(spv::CapabilityLiteralSampler); + capabilities.push_back(spv::CapabilitySampled1D); + capabilities.push_back(spv::CapabilitySampledBuffer); + } + + // Required for devices supporting SPIR-V 1.6. + if (ilVersions.find("SPIR-V_1.6") != std::string::npos) + { + capabilities.push_back(spv::CapabilityUniformDecoration); + } + + // Required for devices supporting read-write images. + if (deviceReadWriteImageSupport == CL_TRUE) + { + capabilities.push_back(spv::CapabilityImageReadWrite); + } + + // Required for devices supporting the generic address space. + if (deviceGenericAddressSpaceSupport == CL_TRUE) + { + capabilities.push_back(spv::CapabilityGenericPointer); + } + + // Required for devices supporting sub-groups or work-group collective + // functions. + if (deviceSubGroupsSupport == CL_TRUE + || deviceWorkGroupCollectiveFunctionsSupport == CL_TRUE) + { + capabilities.push_back(spv::CapabilityGroups); + } + + // Required for devices supporting pipes. + if (devicePipeSupport == CL_TRUE) + { + capabilities.push_back(spv::CapabilityPipes); + } + + // Required for devices supporting device-side enqueue. + if (deviceDeviceEnqueueSupport == CL_TRUE) + { + capabilities.push_back(spv::CapabilityDeviceEnqueue); + } + + // Required for OpenCL 2.2 devices. + if (version == Version(2, 2)) + { + capabilities.push_back(spv::CapabilityPipeStorage); + } + + // Required for OpenCL 2.2, or OpenCL 3.0 devices supporting sub-groups. + if (version == Version(2, 2) + || (version >= Version(3, 0) && deviceSubGroupsSupport == CL_TRUE)) + { + capabilities.push_back(spv::CapabilitySubgroupDispatch); + } + + // Required for devices supporting cl_khr_expect_assume. + if (is_extension_available(device, "cl_khr_expect_assume")) + { + extensions.push_back("SPV_KHR_expect_assume"); + capabilities.push_back(spv::CapabilityExpectAssumeKHR); + } + + // Required for devices supporting cl_khr_extended_bit_ops. + if (is_extension_available(device, "cl_khr_extended_bit_ops")) + { + extensions.push_back("SPV_KHR_bit_instructions"); + capabilities.push_back(spv::CapabilityBitInstructions); + } + + // Required for devices supporting half-precision floating-point + // (cl_khr_fp16). + if (is_extension_available(device, "cl_khr_fp16")) + { + capabilities.push_back(spv::CapabilityFloat16); + } + + // Required for devices supporting double-precision floating-point + // (cl_khr_fp64). + if (is_extension_available(device, "cl_khr_fp64")) + { + capabilities.push_back(spv::CapabilityFloat64); + } + + // Required for devices supporting 64-bit atomics + // (cl_khr_int64_base_atomics or cl_khr_int64_extended_atomics). + if (is_extension_available(device, "cl_khr_int64_base_atomics") + || is_extension_available(device, "cl_khr_int64_extended_atomics")) + { + capabilities.push_back(spv::CapabilityInt64Atomics); + } + + // Required for devices supporting cl_khr_integer_dot_product. + if (is_extension_available(device, "cl_khr_integer_dot_product")) + { + extensions.push_back("SPV_KHR_integer_dot_product"); + capabilities.push_back(spv::CapabilityDotProduct); + capabilities.push_back(spv::CapabilityDotProductInput4x8BitPacked); + } + + // Required for devices supporting cl_khr_integer_dot_product and + // CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_KHR. + if (is_extension_available(device, "cl_khr_integer_dot_product") + && (deviceIntegerDotProductCapabilities + & CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_KHR)) + { + capabilities.push_back(spv::CapabilityDotProductInput4x8Bit); + } + + // Required for devices supporting cl_khr_kernel_clock. + if (is_extension_available(device, "cl_khr_kernel_clock")) + { + extensions.push_back("SPV_KHR_shader_clock"); + capabilities.push_back(spv::CapabilityShaderClockKHR); + } + + // Required for devices supporting both cl_khr_mipmap_image and + // cl_khr_mipmap_image_writes. + if (is_extension_available(device, "cl_khr_mipmap_image") + && is_extension_available(device, "cl_khr_mipmap_image_writes")) + { + capabilities.push_back(spv::CapabilityImageMipmap); + } + + // Required for devices supporting cl_khr_spirv_linkonce_odr. + if (is_extension_available(device, "cl_khr_spirv_linkonce_odr")) + { + extensions.push_back("SPV_KHR_linkonce_odr"); + } + + // Required for devices supporting + // cl_khr_spirv_no_integer_wrap_decoration. + if (is_extension_available(device, + "cl_khr_spirv_no_integer_wrap_decoration")) + { + extensions.push_back("SPV_KHR_no_integer_wrap_decoration"); + } + + // Required for devices supporting cl_khr_subgroup_ballot. + if (is_extension_available(device, "cl_khr_subgroup_ballot")) + { + capabilities.push_back(spv::CapabilityGroupNonUniformBallot); + } + + // Required for devices supporting cl_khr_subgroup_clustered_reduce. + if (is_extension_available(device, "cl_khr_subgroup_clustered_reduce")) + { + capabilities.push_back(spv::CapabilityGroupNonUniformClustered); + } + + // Required for devices supporting cl_khr_subgroup_named_barrier. + if (is_extension_available(device, "cl_khr_subgroup_named_barrier")) + { + capabilities.push_back(spv::CapabilityNamedBarrier); + } + + // Required for devices supporting + // cl_khr_subgroup_non_uniform_arithmetic. + if (is_extension_available(device, + "cl_khr_subgroup_non_uniform_arithmetic")) + { + capabilities.push_back(spv::CapabilityGroupNonUniformArithmetic); + } + + // Required for devices supporting cl_khr_subgroup_non_uniform_vote. + if (is_extension_available(device, "cl_khr_subgroup_non_uniform_vote")) + { + capabilities.push_back(spv::CapabilityGroupNonUniform); + capabilities.push_back(spv::CapabilityGroupNonUniformVote); + } + + // Required for devices supporting cl_khr_subgroup_rotate. + if (is_extension_available(device, "cl_khr_subgroup_rotate")) + { + extensions.push_back("SPV_KHR_subgroup_rotate"); + capabilities.push_back(spv::CapabilityGroupNonUniformRotateKHR); + } + + // Required for devices supporting cl_khr_subgroup_shuffle. + if (is_extension_available(device, "cl_khr_subgroup_shuffle")) + { + capabilities.push_back(spv::CapabilityGroupNonUniformShuffle); + } + + // Required for devices supporting cl_khr_subgroup_shuffle_relative. + if (is_extension_available(device, "cl_khr_subgroup_shuffle_relative")) + { + capabilities.push_back(spv::CapabilityGroupNonUniformShuffleRelative); + } + + // Required for devices supporting cl_khr_work_group_uniform_arithmetic. + if (is_extension_available(device, "cl_khr_work_group_uniform_arithmetic")) + { + extensions.push_back("SPV_KHR_uniform_group_instructions"); + capabilities.push_back(spv::CapabilityGroupUniformArithmeticKHR); + } + + // Required for devices supporting cl_ext_float_atomics and fp32 atomic + // adds. + if (is_extension_available(device, "cl_ext_float_atomics") + && (deviceFp32AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_ADD_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_ADD_EXT))) + { + capabilities.push_back(spv::CapabilityAtomicFloat32AddEXT); + } + + // Required for devices supporting cl_ext_float_atomics and fp32 atomic + // min and max. + if (is_extension_available(device, "cl_ext_float_atomics") + && (deviceFp32AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT))) + { + capabilities.push_back(spv::CapabilityAtomicFloat32MinMaxEXT); + } + + // Required for devices supporting cl_ext_float_atomics and fp16 atomic + // adds. + if (is_extension_available(device, "cl_ext_float_atomics") + && (deviceFp16AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_ADD_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_ADD_EXT))) + { + extensions.push_back("SPV_EXT_shader_atomic_float16_add"); + capabilities.push_back(spv::CapabilityAtomicFloat16AddEXT); + } + + // Required for devices supporting cl_ext_float_atomics and fp16 atomic + // min and max. + if (is_extension_available(device, "cl_ext_float_atomics") + && (deviceFp16AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT))) + { + capabilities.push_back(spv::CapabilityAtomicFloat16MinMaxEXT); + } + + // Required for devices supporting cl_ext_float_atomics and fp64 atomic + // adds. + if (is_extension_available(device, "cl_ext_float_atomics") + && (deviceFp64AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_ADD_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_ADD_EXT))) + { + capabilities.push_back(spv::CapabilityAtomicFloat64AddEXT); + } + + // Required for devices supporting cl_ext_float_atomics and fp64 atomic + // min and max. + if (is_extension_available(device, "cl_ext_float_atomics") + && (deviceFp64AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT))) + { + capabilities.push_back(spv::CapabilityAtomicFloat64MinMaxEXT); + } + + // Required for devices supporting cl_ext_float_atomics and fp16, fp32, + // or fp64 atomic min or max. + if (is_extension_available(device, "cl_ext_float_atomics") + && ((deviceFp32AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT)) + || (deviceFp16AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT)) + || (deviceFp64AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT)))) + { + extensions.push_back("SPV_EXT_shader_atomic_float_min_max"); + } + + // Required for devices supporting cl_ext_float_atomics and fp32 or fp64 + // atomic adds. + if (is_extension_available(device, "cl_ext_float_atomics") + && ((deviceFp32AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_ADD_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_ADD_EXT)) + || (deviceFp64AtomicCapabilities + & (CL_DEVICE_GLOBAL_FP_ATOMIC_ADD_EXT + | CL_DEVICE_LOCAL_FP_ATOMIC_ADD_EXT)))) + { + extensions.push_back("SPV_EXT_shader_atomic_float_add"); + } + + // Required for devices supporting cl_intel_bfloat16_conversions. + if (is_extension_available(device, "cl_intel_bfloat16_conversions")) + { + extensions.push_back("SPV_INTEL_bfloat16_conversion"); + capabilities.push_back(spv::CapabilityBFloat16ConversionINTEL); + } + + // Required for devices supporting + // cl_intel_spirv_device_side_avc_motion_estimation. + if (is_extension_available( + device, "cl_intel_spirv_device_side_avc_motion_estimation")) + { + extensions.push_back("SPV_INTEL_device_side_avc_motion_estimation"); + capabilities.push_back( + spv::CapabilitySubgroupAvcMotionEstimationChromaINTEL); + capabilities.push_back(spv::CapabilitySubgroupAvcMotionEstimationINTEL); + capabilities.push_back( + spv::CapabilitySubgroupAvcMotionEstimationIntraINTEL); + } + + // Required for devices supporting cl_intel_spirv_media_block_io. + if (is_extension_available(device, "cl_intel_spirv_media_block_io")) + { + extensions.push_back("SPV_INTEL_media_block_io"); + capabilities.push_back(spv::CapabilitySubgroupImageMediaBlockIOINTEL); + } + + // Required for devices supporting cl_intel_spirv_subgroups. + if (is_extension_available(device, "cl_intel_spirv_subgroups")) + { + extensions.push_back("SPV_INTEL_subgroups"); + capabilities.push_back(spv::CapabilitySubgroupBufferBlockIOINTEL); + capabilities.push_back(spv::CapabilitySubgroupImageBlockIOINTEL); + capabilities.push_back(spv::CapabilitySubgroupShuffleINTEL); + } + + // Required for devices supporting cl_intel_split_work_group_barrier. + if (is_extension_available(device, "cl_intel_split_work_group_barrier")) + { + extensions.push_back("SPV_INTEL_split_barrier"); + capabilities.push_back(spv::CapabilitySplitBarrierINTEL); + } + + // Required for devices supporting cl_intel_subgroup_buffer_prefetch. + if (is_extension_available(device, "cl_intel_subgroup_buffer_prefetch")) + { + extensions.push_back("SPV_INTEL_subgroup_buffer_prefetch"); + capabilities.push_back(spv::CapabilitySubgroupBufferPrefetchINTEL); + } + + return CL_SUCCESS; +} + +REGISTER_TEST(spirv_query_requirements) +{ + if (!is_extension_available(device, "cl_khr_spirv_queries")) + { + log_info("cl_khr_spirv_queries is not supported; skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + cl_int error; + + std::vector queriedExtendedInstructionSets; + std::vector queriedExtensions; + std::vector queriedCapabilities; + + error = doQueries(device, queriedExtendedInstructionSets, queriedExtensions, + queriedCapabilities); + test_error_fail(error, "Unable to perform SPIR-V queries"); + + std::vector requiredExtendedInstructionSets; + std::vector requiredExtensions; + std::vector requiredCapabilities; + error = findRequirements(device, requiredExtendedInstructionSets, + requiredExtensions, requiredCapabilities); + test_error_fail(error, "Unable to find SPIR-V requirements"); + + for (auto check : requiredExtendedInstructionSets) + { + auto cmp = [=](const char* queried) { + return strcmp(check, queried) == 0; + }; + auto it = std::find_if(queriedExtendedInstructionSets.begin(), + queriedExtendedInstructionSets.end(), cmp); + if (it == queriedExtendedInstructionSets.end()) + { + test_fail("Missing required extended instruction set: %s\n", check); + } + } + + for (auto check : requiredExtensions) + { + auto cmp = [=](const char* queried) { + return strcmp(check, queried) == 0; + }; + auto it = std::find_if(queriedExtensions.begin(), + queriedExtensions.end(), cmp); + if (it == queriedExtensions.end()) + { + test_fail("Missing required extension: %s\n", check); + } + } + + for (auto check : requiredCapabilities) + { + if (std::find(queriedCapabilities.begin(), queriedCapabilities.end(), + check) + == queriedCapabilities.end()) + { + test_fail( + "Missing required capability: %s\n", + spv::CapabilityToString(static_cast(check))); + } + } + + // Find any extraneous capabilities (informational): + for (auto check : queriedCapabilities) + { + if (std::find(requiredCapabilities.begin(), requiredCapabilities.end(), + check) + == requiredCapabilities.end()) + { + log_info( + "Found non-required capability: %s\n", + spv::CapabilityToString(static_cast(check))); + } + } + + return TEST_PASS; +} + +REGISTER_TEST(spirv_query_dependencies) +{ + if (!is_extension_available(device, "cl_khr_spirv_queries")) + { + log_info("cl_khr_spirv_queries is not supported; skipping test.\n"); + return TEST_SKIPPED_ITSELF; + } + + cl_int error; + + std::vector queriedExtendedInstructionSets; + std::vector queriedExtensions; + std::vector queriedCapabilities; + + error = doQueries(device, queriedExtendedInstructionSets, queriedExtensions, + queriedCapabilities); + test_error_fail(error, "Unable to perform SPIR-V queries"); + + struct CapabilityDependencies + { + std::vector extensions; + std::string version; + }; + + std::map dependencies; + +#define SPIRV_CAPABILITY_VERSION_DEPENDENCY(_cap, _ver) \ + dependencies[spv::Capability##_cap].version = _ver; +#define SPIRV_CAPABILITY_EXTENSION_DEPENDENCY(_cap, _ext) \ + dependencies[spv::Capability##_cap].extensions.push_back(_ext); +#include "spirv_capability_deps.def" + + // For each queried SPIR-V capability, ensure that either that any SPIR-V + // version dependencies or SPIR-V extension dependencies are satisfied. + + for (auto check : queriedCapabilities) + { + // Log and skip any unknown capabilities + auto it = dependencies.find(static_cast(check)); + if (it == dependencies.end()) + { + log_info( + "No known dependencies for queried capability %s!\n", + spv::CapabilityToString(static_cast(check))); + continue; + } + + // Check if a SPIR-V version dependency is satisfied + const auto& version_dep = it->second.version; + if (!version_dep.empty() + && is_spirv_version_supported(device, version_dep)) + { + continue; + } + + // Check if a SPIR-V extension dependency is satisfied + bool found = false; + for (const auto& extension_dep : it->second.extensions) + { + if (std::find(queriedExtensions.begin(), queriedExtensions.end(), + extension_dep) + != queriedExtensions.end()) + { + found = true; + break; + } + } + if (found) + { + continue; + } + + // If we get here then the capability has an unsatisfied dependency. + log_error("Couldn't find a dependency for queried capability %s!\n", + spv::CapabilityToString(static_cast(check))); + if (!version_dep.empty()) + { + log_error("Checked for SPIR-V version %s.\n", version_dep.c_str()); + } + for (const auto& extension_dep : it->second.extensions) + { + log_error("Checked for SPIR-V extension %s.n", + extension_dep.c_str()); + } + return TEST_FAIL; + } + + return TEST_PASS; +} From 3b16ff62686d311a2ac43e3e253721124bb86712 Mon Sep 17 00:00:00 2001 From: Ben Ashbaugh Date: Tue, 10 Jun 2025 11:12:19 -0700 Subject: [PATCH 2/5] use defines from headers Since cl_khr_spirv_queries support is now in the upstream headers, we can use the defines from the headers vs. duplicating them in the tests. --- test_conformance/api/test_spirv_queries.cpp | 8 -------- 1 file changed, 8 deletions(-) diff --git a/test_conformance/api/test_spirv_queries.cpp b/test_conformance/api/test_spirv_queries.cpp index 17f778a7f1..3bbdc5efc8 100644 --- a/test_conformance/api/test_spirv_queries.cpp +++ b/test_conformance/api/test_spirv_queries.cpp @@ -21,14 +21,6 @@ #define SPV_ENABLE_UTILITY_CODE #include -#ifndef cl_khr_spirv_queries -#define cl_khr_spirv_queries 1 -#define CL_KHR_SPIRV_QUERIES_EXTENSION_NAME "cl_khr_spirv_queries" -#define CL_DEVICE_SPIRV_EXTENDED_INSTRUCTION_SETS_KHR 0x12B9 -#define CL_DEVICE_SPIRV_EXTENSIONS_KHR 0x12BA -#define CL_DEVICE_SPIRV_CAPABILITIES_KHR 0x12BB -#endif - static bool is_spirv_version_supported(cl_device_id deviceID, const std::string& version) { From caaa0e361517d42e31b14814dda674e98dee8b68 Mon Sep 17 00:00:00 2001 From: Ben Ashbaugh Date: Tue, 10 Jun 2025 14:53:36 -0700 Subject: [PATCH 3/5] add checking for cl_khr_spirv_extended_debug_info --- test_conformance/api/test_spirv_queries.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/test_conformance/api/test_spirv_queries.cpp b/test_conformance/api/test_spirv_queries.cpp index 3bbdc5efc8..3c5d32b895 100644 --- a/test_conformance/api/test_spirv_queries.cpp +++ b/test_conformance/api/test_spirv_queries.cpp @@ -372,6 +372,12 @@ static int findRequirements(cl_device_id device, capabilities.push_back(spv::CapabilityImageMipmap); } + // Required for devices supporting cl_khr_spirv_extended_debug_info. + if (is_extension_available(device, "cl_khr_spirv_extended_debug_info")) + { + extendedInstructionSets.push_back("OpenCL.DebugInfo.100"); + } + // Required for devices supporting cl_khr_spirv_linkonce_odr. if (is_extension_available(device, "cl_khr_spirv_linkonce_odr")) { From dff1fccde60dfad346dd95e1697623be81f9e866 Mon Sep 17 00:00:00 2001 From: Ben Ashbaugh Date: Wed, 11 Jun 2025 10:48:11 -0700 Subject: [PATCH 4/5] add missing checks for SPIR-V 1.1 support for some capabilities --- test_conformance/api/test_spirv_queries.cpp | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/test_conformance/api/test_spirv_queries.cpp b/test_conformance/api/test_spirv_queries.cpp index 3c5d32b895..720f73b184 100644 --- a/test_conformance/api/test_spirv_queries.cpp +++ b/test_conformance/api/test_spirv_queries.cpp @@ -291,15 +291,18 @@ static int findRequirements(cl_device_id device, capabilities.push_back(spv::CapabilityDeviceEnqueue); } - // Required for OpenCL 2.2 devices. - if (version == Version(2, 2)) + // Required for devices supporting SPIR-V 1.1 and OpenCL 2.2. + if (ilVersions.find("SPIR-V_1.1") != std::string::npos + && version == Version(2, 2)) { capabilities.push_back(spv::CapabilityPipeStorage); } - // Required for OpenCL 2.2, or OpenCL 3.0 devices supporting sub-groups. - if (version == Version(2, 2) - || (version >= Version(3, 0) && deviceSubGroupsSupport == CL_TRUE)) + // Required for devices supporting SPIR-V 1.1 and either OpenCL 2.2 or + // OpenCL 3.0 devices supporting sub-groups. + if (ilVersions.find("SPIR-V_1.1") != std::string::npos + && (version == Version(2, 2) + || (version >= Version(3, 0) && deviceSubGroupsSupport == CL_TRUE))) { capabilities.push_back(spv::CapabilitySubgroupDispatch); } From 72b852157a8fe04f51b61cefa917a5d65cb6938f Mon Sep 17 00:00:00 2001 From: Ben Ashbaugh Date: Thu, 12 Jun 2025 09:19:11 -0700 Subject: [PATCH 5/5] add extension to compiler_defines_for_extensions --- .../compiler/test_compiler_defines_for_extensions.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test_conformance/compiler/test_compiler_defines_for_extensions.cpp b/test_conformance/compiler/test_compiler_defines_for_extensions.cpp index baede60899..61c50b989b 100644 --- a/test_conformance/compiler/test_compiler_defines_for_extensions.cpp +++ b/test_conformance/compiler/test_compiler_defines_for_extensions.cpp @@ -95,7 +95,8 @@ const char *known_extensions[] = { "cl_khr_command_buffer", "cl_khr_command_buffer_mutable_dispatch", "cl_khr_command_buffer_multi_device", - "cl_khr_external_memory_android_hardware_buffer" + "cl_khr_external_memory_android_hardware_buffer", + "cl_khr_spirv_queries" }; // clang-format on