external/vulkancts/modules/vulkan/shaderexecutor/vktOpaqueTypeIndexingTests.cpp \
external/vulkancts/modules/vulkan/shaderexecutor/vktShaderBuiltinPrecisionTests.cpp \
external/vulkancts/modules/vulkan/shaderexecutor/vktShaderBuiltinTests.cpp \
+ external/vulkancts/modules/vulkan/shaderexecutor/vktShaderClockTests.cpp \
external/vulkancts/modules/vulkan/shaderexecutor/vktShaderCommonFunctionTests.cpp \
external/vulkancts/modules/vulkan/shaderexecutor/vktShaderExecutor.cpp \
external/vulkancts/modules/vulkan/shaderexecutor/vktShaderIntegerFunctionTests.cpp \
dEQP-VK.glsl.atomic_operations.xor_unsigned64bit_tess_ctrl
dEQP-VK.glsl.atomic_operations.xor_unsigned64bit_tess_eval
dEQP-VK.glsl.atomic_operations.xor_unsigned64bit_compute
+dEQP-VK.glsl.shader_clock.vertex.clockARB
+dEQP-VK.glsl.shader_clock.vertex.clock2x32ARB
+dEQP-VK.glsl.shader_clock.vertex.clockRealtimeEXT
+dEQP-VK.glsl.shader_clock.vertex.clockRealtime2x32EXT
+dEQP-VK.glsl.shader_clock.fragment.clockARB
+dEQP-VK.glsl.shader_clock.fragment.clock2x32ARB
+dEQP-VK.glsl.shader_clock.fragment.clockRealtimeEXT
+dEQP-VK.glsl.shader_clock.fragment.clockRealtime2x32EXT
+dEQP-VK.glsl.shader_clock.compute.clockARB
+dEQP-VK.glsl.shader_clock.compute.clock2x32ARB
+dEQP-VK.glsl.shader_clock.compute.clockRealtimeEXT
+dEQP-VK.glsl.shader_clock.compute.clockRealtime2x32EXT
dEQP-VK.renderpass.suballocation.simple.color
dEQP-VK.renderpass.suballocation.simple.depth
dEQP-VK.renderpass.suballocation.simple.stencil
GitRepo(
"https://github.com/KhronosGroup/glslang.git",
None,
- "6a50a7850d9fe6fea5eb911dfd19f7efe9057481",
+ "7bc047326e06961c59b785f827026947d81c7f02",
"glslang",
removeTags = ["master-tot"]),
GitRepo(
"https://github.com/KhronosGroup/SPIRV-Headers.git",
None,
- "123dc278f204f8e833e1a88d31c46d0edf81d4b2",
+ "842ec90674627ed2ffef609e3cd79d1562eded01",
"spirv-headers"),
GitRepo(
"https://github.com/google/amber.git",
VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000,
+ VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
+#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1
#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1
#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"
+#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"
#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"
#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader"
#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 41); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDrawParametersFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION, 40); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION, 39); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 38); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 37); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFloat16Int8FeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION, 36); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 35); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 34); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 33); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 32); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 31); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShadingRateImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME, VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION, 30); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 29); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 28); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION, 27); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 42); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDrawParametersFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION, 41); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION, 40); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 39); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 38); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFloat16Int8FeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION, 37); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 36); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 35); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 34); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 33); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 32); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShadingRateImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME, VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION, 31); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 30); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 29); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION, 28); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderClockFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, VK_KHR_SHADER_CLOCK_EXTENSION_NAME, VK_KHR_SHADER_CLOCK_SPEC_VERSION, 27); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION, 26); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION, 25); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 24); }
{ createFeatureStructWrapper<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDevice8BitStorageFeaturesKHR>, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION },
+ { createFeatureStructWrapper<VkPhysicalDeviceShaderClockFeaturesKHR>, VK_KHR_SHADER_CLOCK_EXTENSION_NAME, VK_KHR_SHADER_CLOCK_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceMeshShaderFeaturesNV>, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION },
const vk::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& getRepresentativeFragmentTestFeatures (void) const;
const vk::VkPhysicalDevice8BitStorageFeaturesKHR& get8BitStorageFeatures (void) const;
const vk::VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& getShaderAtomicInt64Features (void) const;
+const vk::VkPhysicalDeviceShaderClockFeaturesKHR& getShaderClockFeatures (void) const;
const vk::VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& getVertexAttributeDivisorFeatures (void) const;
const vk::VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& getComputeShaderDerivativesFeatures (void) const;
const vk::VkPhysicalDeviceMeshShaderFeaturesNV& getMeshShaderFeatures (void) const;
const vk::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& Context::getRepresentativeFragmentTestFeatures (void) const { return m_device->getRepresentativeFragmentTestFeatures(); }
const vk::VkPhysicalDevice8BitStorageFeaturesKHR& Context::get8BitStorageFeatures (void) const { return m_device->get8BitStorageFeatures(); }
const vk::VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& Context::getShaderAtomicInt64Features (void) const { return m_device->getShaderAtomicInt64Features(); }
+const vk::VkPhysicalDeviceShaderClockFeaturesKHR& Context::getShaderClockFeatures (void) const { return m_device->getShaderClockFeatures(); }
const vk::VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& Context::getVertexAttributeDivisorFeatures (void) const { return m_device->getVertexAttributeDivisorFeatures(); }
const vk::VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& Context::getComputeShaderDerivativesFeatures (void) const { return m_device->getComputeShaderDerivativesFeatures(); }
const vk::VkPhysicalDeviceMeshShaderFeaturesNV& Context::getMeshShaderFeatures (void) const { return m_device->getMeshShaderFeatures(); }
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& getRepresentativeFragmentTestFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(); }
const VkPhysicalDevice8BitStorageFeaturesKHR& get8BitStorageFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDevice8BitStorageFeaturesKHR>(); }
const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& getShaderAtomicInt64Features (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>(); }
+const VkPhysicalDeviceShaderClockFeaturesKHR& getShaderClockFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderClockFeaturesKHR>(); }
const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& getVertexAttributeDivisorFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>(); }
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& getComputeShaderDerivativesFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(); }
const VkPhysicalDeviceMeshShaderFeaturesNV& getMeshShaderFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceMeshShaderFeaturesNV>(); }
return VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
}
+template<> VkStructureType getStructureType<VkPhysicalDeviceShaderClockFeaturesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
+}
+
template<> VkStructureType getStructureType<VkDrmFormatModifierPropertiesListEXT> (void)
{
return VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT;
std::ostream& operator<< (std::ostream& s, const VkPipelineColorBlendAdvancedStateCreateInfoEXT& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineCoverageToColorStateCreateInfoNV& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineCoverageModulationStateCreateInfoNV& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceShaderClockFeaturesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkDrmFormatModifierPropertiesEXT& value);
std::ostream& operator<< (std::ostream& s, const VkDrmFormatModifierPropertiesListEXT& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceImageDrmFormatModifierInfoEXT& value);
case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: return "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR";
case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD";
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD";
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceShaderClockFeaturesKHR& value)
+{
+ s << "VkPhysicalDeviceShaderClockFeaturesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tshaderSubgroupClock = " << value.shaderSubgroupClock << '\n';
+ s << "\tshaderDeviceClock = " << value.shaderDeviceClock << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkDrmFormatModifierPropertiesEXT& value)
{
s << "VkDrmFormatModifierPropertiesEXT = {\n";
const float* pCoverageModulationTable;
};
+struct VkPhysicalDeviceShaderClockFeaturesKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 shaderSubgroupClock;
+ VkBool32 shaderDeviceClock;
+};
+
struct VkDrmFormatModifierPropertiesEXT
{
deUint64 drmFormatModifier;
VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000,
+ VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
const float* pCoverageModulationTable;
} VkPipelineCoverageModulationStateCreateInfoNV;
-
-
#define VK_NV_fill_rectangle 1
#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
+#define VK_KHR_shader_clock 1
+#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1
+#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
+
+typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 shaderSubgroupClock;
+ VkBool32 shaderDeviceClock;
+} VkPhysicalDeviceShaderClockFeaturesKHR;
#define VK_EXT_image_drm_format_modifier 1
#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1
vktOpaqueTypeIndexingTests.hpp
vktAtomicOperationTests.cpp
vktAtomicOperationTests.hpp
+ vktShaderClockTests.cpp
+ vktShaderClockTests.hpp
)
set(DEQP_VK_SHADEREXECUTOR_LIBS
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2015 The Khronos Group Inc.
+ * Copyright (c) 2018 Advanced Micro Devices, 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.
+ *
+ *//*!
+ * \file
+ * \brief Test cases for VK_KHR_shader_clock. Ensure that values are
+ being read from the OpReadClockKHR OpCode.
+ *//*--------------------------------------------------------------------*/
+
+#include "vktShaderClockTests.hpp"
+#include "vktTestCaseUtil.hpp"
+#include "vktTestGroupUtil.hpp"
+#include "vktShaderExecutor.hpp"
+
+#include "vkQueryUtil.hpp"
+
+#include "tcuStringTemplate.hpp"
+
+#include "vktAtomicOperationTests.hpp"
+#include "vktShaderExecutor.hpp"
+
+#include "vkRefUtil.hpp"
+#include "vkMemUtil.hpp"
+#include "vkQueryUtil.hpp"
+#include "vktTestGroupUtil.hpp"
+
+#include "tcuTestLog.hpp"
+#include "tcuStringTemplate.hpp"
+#include "tcuResultCollector.hpp"
+
+#include "deStringUtil.hpp"
+#include "deSharedPtr.hpp"
+#include "deRandom.hpp"
+#include "deArrayUtil.hpp"
+
+#include <cassert>
+#include <string>
+
+namespace vkt
+{
+namespace shaderexecutor
+{
+
+namespace
+{
+
+enum
+{
+ NUM_ELEMENTS = 32
+};
+
+enum clockType
+{
+ SUBGROUP = 0,
+ DEVICE
+};
+
+enum bitType
+{
+ BIT_32 = 0,
+ BIT_64
+};
+
+struct testType
+{
+ clockType testClockType;
+ bitType testBitType;
+ const char* testName;
+};
+
+static inline void* getPtrOfVar(deUint64& var)
+{
+ return &var;
+}
+
+using namespace vk;
+
+class ShaderClockTestInstance : public TestInstance
+{
+public:
+ ShaderClockTestInstance(Context& context, bool realtimeTest, const ShaderSpec& shaderSpec, glu::ShaderType shaderType)
+ : TestInstance(context)
+ , m_realtime_test(realtimeTest)
+ , m_executor(createExecutor(m_context, shaderType, shaderSpec))
+ {
+ checkSupported();
+ }
+
+ virtual tcu::TestStatus iterate(void)
+ {
+ const deUint64 initValue = 0xcdcdcdcd;
+
+ std::vector<deUint64> outputs (NUM_ELEMENTS, initValue);
+ std::vector<void*> outputPtr (NUM_ELEMENTS, nullptr);
+
+ std::transform(std::begin(outputs), std::end(outputs), std::begin(outputPtr), getPtrOfVar);
+
+ m_executor->execute(NUM_ELEMENTS, nullptr, outputPtr.data());
+
+ if (validateOutput(outputs))
+ return tcu::TestStatus::pass("Pass");
+ else
+ return tcu::TestStatus::fail("Result comparison failed");
+ }
+
+private:
+ void checkSupported(void)
+ {
+ m_context.requireDeviceExtension("VK_KHR_shader_clock");
+
+ VkPhysicalDeviceShaderClockFeaturesKHR shaderClockFeatures = {};
+ shaderClockFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
+ shaderClockFeatures.pNext = DE_NULL;
+
+ VkPhysicalDeviceFeatures2 features = {};
+ features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+ features.pNext = &shaderClockFeatures;
+
+ m_context.getInstanceInterface().getPhysicalDeviceFeatures2(m_context.getPhysicalDevice(), &features);
+
+ if (m_realtime_test && !shaderClockFeatures.shaderDeviceClock)
+ TCU_THROW(NotSupportedError, "Shader device clock is not supported");
+
+ if (!m_realtime_test && !shaderClockFeatures.shaderSubgroupClock)
+ TCU_THROW(NotSupportedError, "Shader subgroup clock is not supported");
+ }
+
+ bool validateOutput(std::vector<deUint64>& outputs)
+ {
+ // The shader will write a 1 in the output if the clock did not increase
+ return (outputs.size() == deUint64(std::count(std::begin(outputs), std::end(outputs), 0)));
+ }
+
+ const bool m_realtime_test;
+ de::UniquePtr<ShaderExecutor> m_executor;
+};
+
+class ShaderClockCase : public TestCase
+{
+public:
+ ShaderClockCase(tcu::TestContext& testCtx, testType operation, glu::ShaderType shaderType)
+ : TestCase(testCtx, operation.testName, operation.testName)
+ , m_operation(operation)
+ , m_shaderSpec()
+ , m_shaderType(shaderType)
+ {
+ initShaderSpec();
+ }
+
+ TestInstance* createInstance(Context& ctx) const
+ {
+ return new ShaderClockTestInstance(ctx, (m_operation.testClockType == DEVICE), m_shaderSpec, m_shaderType);
+ }
+
+ void initPrograms(vk::SourceCollections& programCollection) const
+ {
+ generateSources(m_shaderType, m_shaderSpec, programCollection);
+ }
+
+private:
+ void initShaderSpec()
+ {
+ std::stringstream extensions;
+ std::stringstream source;
+
+ if (m_operation.testBitType == BIT_64)
+ {
+ extensions << "#extension GL_ARB_gpu_shader_int64 : require \n";
+
+ source << "uint64_t time1 = " << m_operation.testName << "(); \n";
+ source << "uint64_t time2 = " << m_operation.testName << "(); \n";
+ source << "out0 = uvec2(0, 0); \n";
+ source << "if (time1 > time2) { \n";
+ source << " out0.x = 1; \n";
+ source << "} \n";
+ }
+ else
+ {
+ source << "uvec2 time1 = " << m_operation.testName << "(); \n";
+ source << "uvec2 time2 = " << m_operation.testName << "(); \n";
+ source << "out0 = uvec2(0, 0); \n";
+ source << "if (time1.y > time2.y || (time1.y == time2.y && time1.x > time2.x)){ \n";
+ source << " out0.x = 1; \n";
+ source << "} \n";
+ }
+
+ if (m_operation.testClockType == DEVICE)
+ {
+ extensions << "#extension GL_EXT_shader_realtime_clock : require \n";
+ }
+ else
+ {
+ extensions << "#extension GL_ARB_shader_clock : enable \n";
+ }
+
+ std::map<std::string, std::string> specializations = {
+ { "EXTENSIONS", extensions.str() },
+ { "SOURCE", source.str() }
+ };
+
+ m_shaderSpec.globalDeclarations = tcu::StringTemplate("${EXTENSIONS}").specialize(specializations);
+ m_shaderSpec.source = tcu::StringTemplate("${SOURCE} ").specialize(specializations);
+
+ m_shaderSpec.outputs.push_back(Symbol("out0", glu::VarType(glu::TYPE_UINT_VEC2, glu::PRECISION_HIGHP)));
+ }
+
+private:
+ ShaderClockCase (const ShaderClockCase&);
+ ShaderClockCase& operator= (const ShaderClockCase&);
+
+ testType m_operation;
+ ShaderSpec m_shaderSpec;
+ glu::ShaderType m_shaderType;
+};
+
+void addShaderClockTests (tcu::TestCaseGroup* testGroup)
+{
+ static glu::ShaderType stages[] =
+ {
+ glu::SHADERTYPE_VERTEX,
+ glu::SHADERTYPE_FRAGMENT,
+ glu::SHADERTYPE_COMPUTE
+ };
+
+ static testType operations[] =
+ {
+ {SUBGROUP, BIT_64, "clockARB"},
+ {SUBGROUP, BIT_32, "clock2x32ARB" },
+ {DEVICE, BIT_64, "clockRealtimeEXT"},
+ {DEVICE, BIT_32, "clockRealtime2x32EXT"}
+ };
+
+ tcu::TestContext& testCtx = testGroup->getTestContext();
+
+ for (size_t i = 0; i != DE_LENGTH_OF_ARRAY(stages); ++i)
+ {
+ const char* stageName = (stages[i] == glu::SHADERTYPE_VERTEX) ? ("vertex")
+ : (stages[i] == glu::SHADERTYPE_FRAGMENT) ? ("fragment")
+ : (stages[i] == glu::SHADERTYPE_COMPUTE) ? ("compute")
+ : (DE_NULL);
+
+ const std::string setName = std::string() + stageName;
+ de::MovePtr<tcu::TestCaseGroup> stageGroupTest(new tcu::TestCaseGroup(testCtx, setName.c_str(), "Shader Clock Tests"));
+
+ for (size_t j = 0; j != DE_LENGTH_OF_ARRAY(operations); ++j)
+ {
+ stageGroupTest->addChild(new ShaderClockCase(testCtx, operations[j], stages[i]));
+ }
+
+ testGroup->addChild(stageGroupTest.release());
+ }
+}
+
+} // anonymous
+
+tcu::TestCaseGroup* createShaderClockTests(tcu::TestContext& testCtx)
+{
+ return createTestGroup(testCtx, "shader_clock", "Shader Clock Tests", addShaderClockTests);
+}
+
+} // shaderexecutor
+} // vkt
--- /dev/null
+#ifndef _VKTSHADERCLOCKTESTS_HPP
+#define _VKTSHADERCLOCKTESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2015 The Khronos Group Inc.
+ * Copyright (c) 2018 Advanced Micro Devices, 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.
+ *
+ *//*!
+ * \file
+ * \brief Shader clock function tests.
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestCase.hpp"
+
+namespace vkt
+{
+namespace shaderexecutor
+{
+
+tcu::TestCaseGroup* createShaderClockTests(tcu::TestContext& testCtx);
+
+} // shaderexecutor
+} // vkt
+
+#endif // _VKTSHADERCLOCKTESTS_HPP
#include "vktDescriptorIndexingTests.hpp"
#include "vktImagelessFramebufferTests.hpp"
#include "vktFragmentShaderInterlockTests.hpp"
+#include "vktShaderClockTests.hpp"
#include <vector>
#include <sstream>
glslTests->addChild(shaderexecutor::createBuiltinTests (testCtx));
glslTests->addChild(shaderexecutor::createOpaqueTypeIndexingTests (testCtx));
glslTests->addChild(shaderexecutor::createAtomicOperationTests (testCtx));
+ glslTests->addChild(shaderexecutor::createShaderClockTests (testCtx));
}
// TestPackage
dEQP-VK.glsl.atomic_operations.xor_unsigned64bit_tess_ctrl
dEQP-VK.glsl.atomic_operations.xor_unsigned64bit_tess_eval
dEQP-VK.glsl.atomic_operations.xor_unsigned64bit_compute
+dEQP-VK.glsl.shader_clock.vertex.clockARB
+dEQP-VK.glsl.shader_clock.vertex.clock2x32ARB
+dEQP-VK.glsl.shader_clock.vertex.clockRealtimeEXT
+dEQP-VK.glsl.shader_clock.vertex.clockRealtime2x32EXT
+dEQP-VK.glsl.shader_clock.fragment.clockARB
+dEQP-VK.glsl.shader_clock.fragment.clock2x32ARB
+dEQP-VK.glsl.shader_clock.fragment.clockRealtimeEXT
+dEQP-VK.glsl.shader_clock.fragment.clockRealtime2x32EXT
+dEQP-VK.glsl.shader_clock.compute.clockARB
+dEQP-VK.glsl.shader_clock.compute.clock2x32ARB
+dEQP-VK.glsl.shader_clock.compute.clockRealtimeEXT
+dEQP-VK.glsl.shader_clock.compute.clockRealtime2x32EXT
dEQP-VK.renderpass.suballocation.simple.color
dEQP-VK.renderpass.suballocation.simple.depth
dEQP-VK.renderpass.suballocation.simple.stencil
dEQP-VK.glsl.atomic_operations.xor_unsigned64bit_tess_ctrl
dEQP-VK.glsl.atomic_operations.xor_unsigned64bit_tess_eval
dEQP-VK.glsl.atomic_operations.xor_unsigned64bit_compute
+dEQP-VK.glsl.shader_clock.vertex.clockARB
+dEQP-VK.glsl.shader_clock.vertex.clock2x32ARB
+dEQP-VK.glsl.shader_clock.vertex.clockRealtimeEXT
+dEQP-VK.glsl.shader_clock.vertex.clockRealtime2x32EXT
+dEQP-VK.glsl.shader_clock.fragment.clockARB
+dEQP-VK.glsl.shader_clock.fragment.clock2x32ARB
+dEQP-VK.glsl.shader_clock.fragment.clockRealtimeEXT
+dEQP-VK.glsl.shader_clock.fragment.clockRealtime2x32EXT
+dEQP-VK.glsl.shader_clock.compute.clockARB
+dEQP-VK.glsl.shader_clock.compute.clock2x32ARB
+dEQP-VK.glsl.shader_clock.compute.clockRealtimeEXT
+dEQP-VK.glsl.shader_clock.compute.clockRealtime2x32EXT
dEQP-VK.renderpass.suballocation.simple.color
dEQP-VK.renderpass.suballocation.simple.depth
dEQP-VK.renderpass.suballocation.simple.stencil
VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = 1000180000,
+ VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,
VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,
const float* pCoverageModulationTable;
} VkPipelineCoverageModulationStateCreateInfoNV;
-
-
#define VK_NV_fill_rectangle 1
#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
+#define VK_KHR_shader_clock 1
+#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1
+#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
+
+typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 shaderSubgroupClock;
+ VkBool32 shaderDeviceClock;
+} VkPhysicalDeviceShaderClockFeaturesKHR;
#define VK_EXT_image_drm_format_modifier 1
#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1
projects / platform / upstream / VK-GL-CTS.git / commitdiff