VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
VK_ERROR_FRAGMENTATION_EXT = -1000161000,
VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
- VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000244000,
VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
+ VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = -1000244000,
VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
+ VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR,
VK_RESULT_MAX_ENUM = 0x7FFFFFFF,
};
VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = 1000241001,
VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = 1000241002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
- VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001,
VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000,
VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = 1000257000,
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = 1000244001,
+ VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = 1000257002,
+ VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = 1000257003,
+ VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = 1000257004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR,
VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF,
};
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
- VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000010,
+ VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000010,
+ VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR,
VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF,
};
typedef deUint32 VkBufferCreateFlags;
VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400,
- VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 0x00020000,
+ VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000,
+ VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR,
VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF,
};
typedef deUint32 VkBufferUsageFlags;
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
- VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
+ VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,
VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
+ VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF,
enum VkMemoryAllocateFlagBits
{
- VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
- VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
- VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF,
+ VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
+ VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = 0x00000002,
+ VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000004,
+ VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
+ VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF,
};
typedef deUint32 VkMemoryAllocateFlags;
#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1
#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
+#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1
#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9
#define VK_NV_GLSL_SHADER_SPEC_VERSION 1
virtual VkResult getSemaphoreCounterValueKHR (VkDevice device, VkSemaphore semaphore, deUint64* pValue) const;
virtual VkResult waitSemaphoresKHR (VkDevice device, const VkSemaphoreWaitInfoKHR* pWaitInfo, deUint64 timeout) const;
virtual VkResult signalSemaphoreKHR (VkDevice device, const VkSemaphoreSignalInfoKHR* pSignalInfo) const;
+virtual VkDeviceAddress getBufferDeviceAddressKHR (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo) const;
+virtual uint64_t getBufferOpaqueCaptureAddressKHR (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo) const;
+virtual uint64_t getDeviceMemoryOpaqueCaptureAddressKHR (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo) const;
virtual VkResult getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const;
virtual VkResult getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) const;
virtual VkResult getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const;
virtual VkResult queueSetPerformanceConfigurationINTEL (VkQueue queue, VkPerformanceConfigurationINTEL configuration) const;
virtual VkResult getPerformanceParameterINTEL (VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) const;
virtual void setLocalDimmingAMD (VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const;
-virtual VkDeviceAddress getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) const;
+virtual VkDeviceAddress getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo) const;
virtual void cmdSetLineStippleEXT (VkCommandBuffer commandBuffer, deUint32 lineStippleFactor, deUint16 lineStipplePattern) const;
virtual void resetQueryPoolEXT (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount) const;
virtual VkResult getAndroidHardwareBufferPropertiesANDROID (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) const;
return m_vk.signalSemaphoreKHR(device, pSignalInfo);
}
+VkDeviceAddress DeviceDriver::getBufferDeviceAddressKHR (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo) const
+{
+ return m_vk.getBufferDeviceAddressKHR(device, pInfo);
+}
+
+uint64_t DeviceDriver::getBufferOpaqueCaptureAddressKHR (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo) const
+{
+ return m_vk.getBufferOpaqueCaptureAddressKHR(device, pInfo);
+}
+
+uint64_t DeviceDriver::getDeviceMemoryOpaqueCaptureAddressKHR (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo) const
+{
+ return m_vk.getDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo);
+}
+
VkResult DeviceDriver::getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const
{
return m_vk.getPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
m_vk.setLocalDimmingAMD(device, swapChain, localDimmingEnable);
}
-VkDeviceAddress DeviceDriver::getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) const
+VkDeviceAddress DeviceDriver::getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo) const
{
return m_vk.getBufferDeviceAddressEXT(device, pInfo);
}
"VK_KHR_shader_subgroup_extended_types",
"VK_KHR_separate_depth_stencil_layouts",
"VK_KHR_performance_query",
+ "VK_KHR_buffer_device_address",
};
#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"
#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
+#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address"
#define DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME "not_existent_feature"
#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"
#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"
#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 50); }
-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, 49); }
-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, 48); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 47); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 51); }
+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, 50); }
+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, 49); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 48); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR, VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 47); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0, 46); }
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, 45); }
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, 44); }
{ createFeatureStructWrapper<VkPhysicalDevice8BitStorageFeaturesKHR>, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION },
+ { createFeatureStructWrapper<VkPhysicalDeviceBufferDeviceAddressFeaturesKHR>, VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceCoherentMemoryFeaturesAMD>, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0 },
{ createFeatureStructWrapper<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceConditionalRenderingFeaturesEXT>, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION },
const vk::VkPhysicalDevice16BitStorageFeatures& get16BitStorageFeatures (void) const;
const vk::VkPhysicalDevice8BitStorageFeaturesKHR& get8BitStorageFeatures (void) const;
const vk::VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& getBlendOperationAdvancedFeatures (void) const;
-const vk::VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& getBufferDeviceAddressFeatures (void) const;
+const vk::VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& getBufferDeviceAddressFeaturesEXT (void) const;
+const vk::VkPhysicalDeviceBufferDeviceAddressFeaturesKHR& getBufferDeviceAddressFeatures (void) const;
const vk::VkPhysicalDeviceCoherentMemoryFeaturesAMD& getCoherentMemoryFeaturesAMD (void) const;
const vk::VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& getComputeShaderDerivativesFeatures (void) const;
const vk::VkPhysicalDeviceConditionalRenderingFeaturesEXT& getConditionalRenderingFeatures (void) const;
const vk::VkPhysicalDevice16BitStorageFeatures& Context::get16BitStorageFeatures (void) const { return m_device->get16BitStorageFeatures(); }
const vk::VkPhysicalDevice8BitStorageFeaturesKHR& Context::get8BitStorageFeatures (void) const { return m_device->get8BitStorageFeatures(); }
const vk::VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& Context::getBlendOperationAdvancedFeatures (void) const { return m_device->getBlendOperationAdvancedFeatures(); }
-const vk::VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& Context::getBufferDeviceAddressFeatures (void) const { return m_device->getBufferDeviceAddressFeatures(); }
+const vk::VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& Context::getBufferDeviceAddressFeaturesEXT (void) const { return m_device->getBufferDeviceAddressFeaturesEXT(); }
+const vk::VkPhysicalDeviceBufferDeviceAddressFeaturesKHR& Context::getBufferDeviceAddressFeatures (void) const { return m_device->getBufferDeviceAddressFeatures(); }
const vk::VkPhysicalDeviceCoherentMemoryFeaturesAMD& Context::getCoherentMemoryFeaturesAMD (void) const { return m_device->getCoherentMemoryFeaturesAMD(); }
const vk::VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& Context::getComputeShaderDerivativesFeatures (void) const { return m_device->getComputeShaderDerivativesFeatures(); }
const vk::VkPhysicalDeviceConditionalRenderingFeaturesEXT& Context::getConditionalRenderingFeatures (void) const { return m_device->getConditionalRenderingFeatures(); }
const VkPhysicalDevice16BitStorageFeatures& get16BitStorageFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDevice16BitStorageFeatures>(); }
const VkPhysicalDevice8BitStorageFeaturesKHR& get8BitStorageFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDevice8BitStorageFeaturesKHR>(); }
const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& getBlendOperationAdvancedFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(); }
-const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& getBufferDeviceAddressFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(); }
+const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& getBufferDeviceAddressFeaturesEXT (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(); }
+const VkPhysicalDeviceBufferDeviceAddressFeaturesKHR& getBufferDeviceAddressFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceBufferDeviceAddressFeaturesKHR>(); }
const VkPhysicalDeviceCoherentMemoryFeaturesAMD& getCoherentMemoryFeaturesAMD (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(); }
const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& getComputeShaderDerivativesFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(); }
const VkPhysicalDeviceConditionalRenderingFeaturesEXT& getConditionalRenderingFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(); }
GetSemaphoreCounterValueKHRFunc getSemaphoreCounterValueKHR;
WaitSemaphoresKHRFunc waitSemaphoresKHR;
SignalSemaphoreKHRFunc signalSemaphoreKHR;
+GetBufferDeviceAddressKHRFunc getBufferDeviceAddressKHR;
+GetBufferOpaqueCaptureAddressKHRFunc getBufferOpaqueCaptureAddressKHR;
+GetDeviceMemoryOpaqueCaptureAddressKHRFunc getDeviceMemoryOpaqueCaptureAddressKHR;
GetPipelineExecutablePropertiesKHRFunc getPipelineExecutablePropertiesKHR;
GetPipelineExecutableStatisticsKHRFunc getPipelineExecutableStatisticsKHR;
GetPipelineExecutableInternalRepresentationsKHRFunc getPipelineExecutableInternalRepresentationsKHR;
functions.push_back("vkWaitSemaphoresKHR");
functions.push_back("vkSignalSemaphoreKHR");
}
+ else if (extName == "VK_KHR_buffer_device_address")
+ {
+ functions.push_back("vkGetBufferDeviceAddressKHR");
+ functions.push_back("vkGetBufferOpaqueCaptureAddressKHR");
+ functions.push_back("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
+ }
else if (extName == "VK_KHR_pipeline_executable_properties")
{
functions.push_back("vkGetPipelineExecutablePropertiesKHR");
"VK_KHR_maintenance3",
"VK_KHR_draw_indirect_count",
"VK_KHR_timeline_semaphore",
+ "VK_KHR_buffer_device_address",
"VK_KHR_pipeline_executable_properties",
"VK_EXT_debug_marker",
"VK_EXT_transform_feedback",
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetSemaphoreCounterValueKHRFunc) (VkDevice device, VkSemaphore semaphore, deUint64* pValue);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* WaitSemaphoresKHRFunc) (VkDevice device, const VkSemaphoreWaitInfoKHR* pWaitInfo, deUint64 timeout);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* SignalSemaphoreKHRFunc) (VkDevice device, const VkSemaphoreSignalInfoKHR* pSignalInfo);
+typedef VKAPI_ATTR VkDeviceAddress (VKAPI_CALL* GetBufferDeviceAddressKHRFunc) (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
+typedef VKAPI_ATTR uint64_t (VKAPI_CALL* GetBufferOpaqueCaptureAddressKHRFunc) (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
+typedef VKAPI_ATTR uint64_t (VKAPI_CALL* GetDeviceMemoryOpaqueCaptureAddressKHRFunc) (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPipelineExecutablePropertiesKHRFunc) (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPipelineExecutableStatisticsKHRFunc) (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPipelineExecutableInternalRepresentationsKHRFunc) (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* QueueSetPerformanceConfigurationINTELFunc) (VkQueue queue, VkPerformanceConfigurationINTEL configuration);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPerformanceParameterINTELFunc) (VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue);
typedef VKAPI_ATTR void (VKAPI_CALL* SetLocalDimmingAMDFunc) (VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable);
-typedef VKAPI_ATTR VkDeviceAddress (VKAPI_CALL* GetBufferDeviceAddressEXTFunc) (VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo);
+typedef VKAPI_ATTR VkDeviceAddress (VKAPI_CALL* GetBufferDeviceAddressEXTFunc) (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceCooperativeMatrixPropertiesNVFunc) (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNVFunc) (VkPhysicalDevice physicalDevice, deUint32* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateHeadlessSurfaceEXTFunc) (VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR;
}
+template<> VkStructureType getStructureType<VkPhysicalDeviceBufferDeviceAddressFeaturesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkBufferDeviceAddressInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkBufferOpaqueCaptureAddressCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkMemoryOpaqueCaptureAddressAllocateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkDeviceMemoryOpaqueCaptureAddressInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR;
+}
+
template<> VkStructureType getStructureType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR> (void)
{
return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
}
-template<> VkStructureType getStructureType<VkBufferDeviceAddressInfoEXT> (void)
-{
- return VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT;
-}
-
template<> VkStructureType getStructureType<VkBufferDeviceAddressCreateInfoEXT> (void)
{
return VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
m_vk.getSemaphoreCounterValueKHR = (GetSemaphoreCounterValueKHRFunc) GET_PROC_ADDR("vkGetSemaphoreCounterValueKHR");
m_vk.waitSemaphoresKHR = (WaitSemaphoresKHRFunc) GET_PROC_ADDR("vkWaitSemaphoresKHR");
m_vk.signalSemaphoreKHR = (SignalSemaphoreKHRFunc) GET_PROC_ADDR("vkSignalSemaphoreKHR");
+m_vk.getBufferDeviceAddressKHR = (GetBufferDeviceAddressKHRFunc) GET_PROC_ADDR("vkGetBufferDeviceAddressKHR");
+m_vk.getBufferOpaqueCaptureAddressKHR = (GetBufferOpaqueCaptureAddressKHRFunc) GET_PROC_ADDR("vkGetBufferOpaqueCaptureAddressKHR");
+m_vk.getDeviceMemoryOpaqueCaptureAddressKHR = (GetDeviceMemoryOpaqueCaptureAddressKHRFunc) GET_PROC_ADDR("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
m_vk.getPipelineExecutablePropertiesKHR = (GetPipelineExecutablePropertiesKHRFunc) GET_PROC_ADDR("vkGetPipelineExecutablePropertiesKHR");
m_vk.getPipelineExecutableStatisticsKHR = (GetPipelineExecutableStatisticsKHRFunc) GET_PROC_ADDR("vkGetPipelineExecutableStatisticsKHR");
m_vk.getPipelineExecutableInternalRepresentationsKHR = (GetPipelineExecutableInternalRepresentationsKHRFunc) GET_PROC_ADDR("vkGetPipelineExecutableInternalRepresentationsKHR");
const MemoryRequirement MemoryRequirement::Local = MemoryRequirement(MemoryRequirement::FLAG_LOCAL);
const MemoryRequirement MemoryRequirement::Cached = MemoryRequirement(MemoryRequirement::FLAG_CACHED);
const MemoryRequirement MemoryRequirement::NonLocal = MemoryRequirement(MemoryRequirement::FLAG_NON_LOCAL);
+const MemoryRequirement MemoryRequirement::DeviceAddress = MemoryRequirement(MemoryRequirement::FLAG_DEVICE_ADDRESS);
bool MemoryRequirement::matchesHeap (VkMemoryPropertyFlags heapFlags) const
{
MovePtr<Allocation> SimpleAllocator::allocate (const VkMemoryRequirements& memReqs, MemoryRequirement requirement)
{
const deUint32 memoryTypeNdx = selectMatchingMemoryType(m_memProps, memReqs.memoryTypeBits, requirement);
- const VkMemoryAllocateInfo allocInfo =
+ VkMemoryAllocateInfo allocInfo =
{
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
memoryTypeNdx, // deUint32 memoryTypeIndex;
};
+ VkMemoryAllocateFlagsInfo allocFlagsInfo =
+ {
+ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ 0, // VkMemoryAllocateFlags flags
+ 0, // uint32_t deviceMask
+ };
+
+ if (requirement & MemoryRequirement::DeviceAddress)
+ {
+ allocFlagsInfo.flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR;
+ allocInfo.pNext = &allocFlagsInfo;
+ }
+
Move<VkDeviceMemory> mem = allocateMemory(m_vk, m_device, &allocInfo);
MovePtr<HostPtr> hostPtr;
return MovePtr<Allocation>(new SimpleAllocation(mem, hostPtr));
}
-static MovePtr<Allocation> allocateDedicated (const InstanceInterface& vki,
- const DeviceInterface& vkd,
- const VkPhysicalDevice& physDevice,
- const VkDevice device,
- const VkMemoryRequirements& memReqs,
- const MemoryRequirement requirement,
- const void* pNext)
+MovePtr<Allocation> allocateExtended (const InstanceInterface& vki,
+ const DeviceInterface& vkd,
+ const VkPhysicalDevice& physDevice,
+ const VkDevice device,
+ const VkMemoryRequirements& memReqs,
+ const MemoryRequirement requirement,
+ const void* pNext)
{
const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vki, physDevice);
const deUint32 memoryTypeNdx = selectMatchingMemoryType(memoryProperties, memReqs.memoryTypeBits, requirement);
buffer // VkBuffer buffer
};
- return allocateDedicated(vki, vkd, physDevice, device, memoryRequirements, requirement, &dedicatedAllocationInfo);
+ return allocateExtended(vki, vkd, physDevice, device, memoryRequirements, requirement, &dedicatedAllocationInfo);
}
de::MovePtr<Allocation> allocateDedicated (const InstanceInterface& vki,
DE_NULL // VkBuffer buffer
};
- return allocateDedicated(vki, vkd, physDevice, device, memoryRequirements, requirement, &dedicatedAllocationInfo);
+ return allocateExtended(vki, vkd, physDevice, device, memoryRequirements, requirement, &dedicatedAllocationInfo);
}
void* mapMemory (const DeviceInterface& vkd, VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags)
static const MemoryRequirement Local;
static const MemoryRequirement Cached;
static const MemoryRequirement NonLocal;
+ static const MemoryRequirement DeviceAddress;
inline MemoryRequirement operator| (MemoryRequirement requirement) const
{
FLAG_LOCAL = 1u << 4u,
FLAG_CACHED = 1u << 5u,
FLAG_NON_LOCAL = 1u << 6u,
+ FLAG_DEVICE_ADDRESS = 1u << 7u,
};
};
const VkPhysicalDeviceMemoryProperties m_memProps;
};
+de::MovePtr<Allocation> allocateExtended (const InstanceInterface& vki, const DeviceInterface& vkd, const VkPhysicalDevice& physDevice, const VkDevice device, const VkMemoryRequirements& memReqs, const MemoryRequirement requirement, const void* pNext);
de::MovePtr<Allocation> allocateDedicated (const InstanceInterface& vki, const DeviceInterface& vkd, const VkPhysicalDevice& physDevice, const VkDevice device, const VkBuffer buffer, MemoryRequirement requirement);
de::MovePtr<Allocation> allocateDedicated (const InstanceInterface& vki, const DeviceInterface& vkd, const VkPhysicalDevice& physDevice, const VkDevice device, const VkImage image, MemoryRequirement requirement);
return VK_SUCCESS;
}
+VKAPI_ATTR VkDeviceAddress VKAPI_CALL getBufferDeviceAddressKHR (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo)
+{
+ DE_UNREF(device);
+ DE_UNREF(pInfo);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR uint64_t VKAPI_CALL getBufferOpaqueCaptureAddressKHR (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo)
+{
+ DE_UNREF(device);
+ DE_UNREF(pInfo);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR uint64_t VKAPI_CALL getDeviceMemoryOpaqueCaptureAddressKHR (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo)
+{
+ DE_UNREF(device);
+ DE_UNREF(pInfo);
+ return VK_SUCCESS;
+}
+
VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties)
{
DE_UNREF(device);
DE_UNREF(localDimmingEnable);
}
-VKAPI_ATTR VkDeviceAddress VKAPI_CALL getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo)
+VKAPI_ATTR VkDeviceAddress VKAPI_CALL getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo)
{
DE_UNREF(device);
DE_UNREF(pInfo);
VK_NULL_FUNC_ENTRY(vkGetSemaphoreCounterValueKHR, getSemaphoreCounterValueKHR),
VK_NULL_FUNC_ENTRY(vkWaitSemaphoresKHR, waitSemaphoresKHR),
VK_NULL_FUNC_ENTRY(vkSignalSemaphoreKHR, signalSemaphoreKHR),
+ VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddressKHR, getBufferDeviceAddressKHR),
+ VK_NULL_FUNC_ENTRY(vkGetBufferOpaqueCaptureAddressKHR, getBufferOpaqueCaptureAddressKHR),
+ VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryOpaqueCaptureAddressKHR, getDeviceMemoryOpaqueCaptureAddressKHR),
VK_NULL_FUNC_ENTRY(vkGetPipelineExecutablePropertiesKHR, getPipelineExecutablePropertiesKHR),
VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableStatisticsKHR, getPipelineExecutableStatisticsKHR),
VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableInternalRepresentationsKHR, getPipelineExecutableInternalRepresentationsKHR),
std::ostream& operator<< (std::ostream& s, const VkAttachmentReferenceStencilLayoutKHR& value);
std::ostream& operator<< (std::ostream& s, const VkAttachmentDescriptionStencilLayoutKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceBufferDeviceAddressFeaturesKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkBufferDeviceAddressInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkBufferOpaqueCaptureAddressCreateInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkMemoryOpaqueCaptureAddressAllocateInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineInfoKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPipelineExecutablePropertiesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkMemoryPriorityAllocateInfoEXT& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& value);
-std::ostream& operator<< (std::ostream& s, const VkBufferDeviceAddressInfoEXT& value);
std::ostream& operator<< (std::ostream& s, const VkBufferDeviceAddressCreateInfoEXT& value);
std::ostream& operator<< (std::ostream& s, const VkImageStencilUsageCreateInfoEXT& value);
std::ostream& operator<< (std::ostream& s, const VkValidationFeaturesEXT& value);
case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
case VK_ERROR_FRAGMENTATION_EXT: return "VK_ERROR_FRAGMENTATION_EXT";
case VK_ERROR_NOT_PERMITTED_EXT: return "VK_ERROR_NOT_PERMITTED_EXT";
- case VK_ERROR_INVALID_DEVICE_ADDRESS_EXT: return "VK_ERROR_INVALID_DEVICE_ADDRESS_EXT";
case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
+ case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR";
case VK_RESULT_MAX_ENUM: return "VK_RESULT_MAX_ENUM";
default: return DE_NULL;
}
case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR";
case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT";
- case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT: return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT";
case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT";
case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT";
case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: return "VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT";
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT";
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT";
case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR: return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR";
+ case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: return "VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT";
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT";
tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, "VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"),
tcu::Format::BitDesc(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, "VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"),
tcu::Format::BitDesc(VK_BUFFER_CREATE_PROTECTED_BIT, "VK_BUFFER_CREATE_PROTECTED_BIT"),
+ tcu::Format::BitDesc(VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR"),
tcu::Format::BitDesc(VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT, "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT"),
tcu::Format::BitDesc(VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM, "VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM"),
};
tcu::Format::BitDesc(VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"),
tcu::Format::BitDesc(VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT, "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"),
tcu::Format::BitDesc(VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, "VK_BUFFER_USAGE_RAY_TRACING_BIT_NV"),
+ tcu::Format::BitDesc(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR, "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR"),
tcu::Format::BitDesc(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT, "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT"),
tcu::Format::BitDesc(VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM, "VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM"),
};
tcu::Format::BitDesc(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"),
tcu::Format::BitDesc(VK_PIPELINE_CREATE_DERIVATIVE_BIT, "VK_PIPELINE_CREATE_DERIVATIVE_BIT"),
tcu::Format::BitDesc(VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE, "VK_PIPELINE_CREATE_DISPATCH_BASE"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, "VK_PIPELINE_CREATE_DISPATCH_BASE_BIT"),
tcu::Format::BitDesc(VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV"),
tcu::Format::BitDesc(VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR, "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR"),
tcu::Format::BitDesc(VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"),
+ tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE, "VK_PIPELINE_CREATE_DISPATCH_BASE"),
tcu::Format::BitDesc(VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR"),
tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE_KHR, "VK_PIPELINE_CREATE_DISPATCH_BASE_KHR"),
tcu::Format::BitDesc(VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM, "VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM"),
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"),
- tcu::Format::BitDesc(VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR, "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR"),
- tcu::Format::BitDesc(VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM, "VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM"),
+ tcu::Format::BitDesc(VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"),
+ tcu::Format::BitDesc(VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR, "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR"),
+ tcu::Format::BitDesc(VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR"),
+ tcu::Format::BitDesc(VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR, "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR"),
+ tcu::Format::BitDesc(VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM, "VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM"),
};
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceBufferDeviceAddressFeaturesKHR& value)
+{
+ s << "VkPhysicalDeviceBufferDeviceAddressFeaturesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tbufferDeviceAddress = " << value.bufferDeviceAddress << '\n';
+ s << "\tbufferDeviceAddressCaptureReplay = " << value.bufferDeviceAddressCaptureReplay << '\n';
+ s << "\tbufferDeviceAddressMultiDevice = " << value.bufferDeviceAddressMultiDevice << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkBufferDeviceAddressInfoKHR& value)
+{
+ s << "VkBufferDeviceAddressInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tbuffer = " << value.buffer << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkBufferOpaqueCaptureAddressCreateInfoKHR& value)
+{
+ s << "VkBufferOpaqueCaptureAddressCreateInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\topaqueCaptureAddress = " << value.opaqueCaptureAddress << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkMemoryOpaqueCaptureAddressAllocateInfoKHR& value)
+{
+ s << "VkMemoryOpaqueCaptureAddressAllocateInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\topaqueCaptureAddress = " << value.opaqueCaptureAddress << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR& value)
+{
+ s << "VkDeviceMemoryOpaqueCaptureAddressInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tmemory = " << value.memory << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value)
{
s << "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR = {\n";
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkBufferDeviceAddressInfoEXT& value)
-{
- s << "VkBufferDeviceAddressInfoEXT = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tbuffer = " << value.buffer << '\n';
- s << '}';
- return s;
-}
-
std::ostream& operator<< (std::ostream& s, const VkBufferDeviceAddressCreateInfoEXT& value)
{
s << "VkBufferDeviceAddressCreateInfoEXT = {\n";
VkBool32 uniformBufferStandardLayout;
};
+struct VkPhysicalDeviceBufferDeviceAddressFeaturesKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 bufferDeviceAddress;
+ VkBool32 bufferDeviceAddressCaptureReplay;
+ VkBool32 bufferDeviceAddressMultiDevice;
+};
+
+struct VkBufferDeviceAddressInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+};
+
+struct VkBufferOpaqueCaptureAddressCreateInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint64 opaqueCaptureAddress;
+};
+
+struct VkMemoryOpaqueCaptureAddressAllocateInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint64 opaqueCaptureAddress;
+};
+
+struct VkDeviceMemoryOpaqueCaptureAddressInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory memory;
+};
+
struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR
{
VkStructureType sType;
struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
{
VkStructureType sType;
- const void* pNext;
+ void* pNext;
VkBool32 textureCompressionASTC_HDR;
};
VkBool32 bufferDeviceAddressMultiDevice;
};
-struct VkBufferDeviceAddressInfoEXT
-{
- VkStructureType sType;
- const void* pNext;
- VkBuffer buffer;
-};
-
struct VkBufferDeviceAddressCreateInfoEXT
{
VkStructureType sType;
typedef VkPhysicalDeviceShaderFloat16Int8FeaturesKHR VkPhysicalDeviceFloat16Int8FeaturesKHR;
+typedef VkBufferDeviceAddressInfoKHR VkBufferDeviceAddressInfoEXT;
+
typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;
virtual VkResult getSemaphoreCounterValueKHR (VkDevice device, VkSemaphore semaphore, deUint64* pValue) const = 0;
virtual VkResult waitSemaphoresKHR (VkDevice device, const VkSemaphoreWaitInfoKHR* pWaitInfo, deUint64 timeout) const = 0;
virtual VkResult signalSemaphoreKHR (VkDevice device, const VkSemaphoreSignalInfoKHR* pSignalInfo) const = 0;
+virtual VkDeviceAddress getBufferDeviceAddressKHR (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo) const = 0;
+virtual uint64_t getBufferOpaqueCaptureAddressKHR (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo) const = 0;
+virtual uint64_t getDeviceMemoryOpaqueCaptureAddressKHR (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo) const = 0;
virtual VkResult getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, deUint32* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const = 0;
virtual VkResult getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) const = 0;
virtual VkResult getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, deUint32* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const = 0;
virtual VkResult queueSetPerformanceConfigurationINTEL (VkQueue queue, VkPerformanceConfigurationINTEL configuration) const = 0;
virtual VkResult getPerformanceParameterINTEL (VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) const = 0;
virtual void setLocalDimmingAMD (VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const = 0;
-virtual VkDeviceAddress getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo) const = 0;
+virtual VkDeviceAddress getBufferDeviceAddressEXT (VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo) const = 0;
virtual void cmdSetLineStippleEXT (VkCommandBuffer commandBuffer, deUint32 lineStippleFactor, deUint16 lineStipplePattern) const = 0;
virtual void resetQueryPoolEXT (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount) const = 0;
virtual VkResult getAndroidHardwareBufferPropertiesANDROID (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) const = 0;
#define VK_VERSION_MINOR(version) (((deUint32)(version) >> 12) & 0x3ff)
#define VK_VERSION_PATCH(version) ((deUint32)(version) & 0xfff)
// Version of this file
-#define VK_HEADER_VERSION 124
+#define VK_HEADER_VERSION 129
#define VK_NULL_HANDLE 0
VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
VK_ERROR_FRAGMENTATION_EXT = -1000161000,
VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
- VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000244000,
VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
+ VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = -1000244000,
VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
+ VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR,
VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
VK_RESULT_END_RANGE = VK_INCOMPLETE,
VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = 1000241001,
VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = 1000241002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
- VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001,
VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000,
VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = 1000257000,
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = 1000244001,
+ VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = 1000257002,
+ VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = 1000257003,
+ VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = 1000257004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR,
VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
- VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000010,
+ VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000010,
+ VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR,
VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferCreateFlagBits;
typedef VkFlags VkBufferCreateFlags;
VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400,
- VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 0x00020000,
+ VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000,
+ VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR,
VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferUsageFlagBits;
typedef VkFlags VkBufferUsageFlags;
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
- VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
+ VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,
VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
+ VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
typedef enum VkMemoryAllocateFlagBits {
VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
+ VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = 0x00000002,
+ VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000004,
VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkMemoryAllocateFlagBits;
int* pFd);
#endif
+
#define VK_KHR_performance_query 1
#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1
#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"
} VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
+
#define VK_KHR_spirv_1_4 1
#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1
#define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4"
+#define VK_KHR_buffer_device_address 1
+typedef deUint64 VkDeviceAddress;
+#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1
+#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address"
+typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 bufferDeviceAddress;
+ VkBool32 bufferDeviceAddressCaptureReplay;
+ VkBool32 bufferDeviceAddressMultiDevice;
+} VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;
+
+typedef struct VkBufferDeviceAddressInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+} VkBufferDeviceAddressInfoKHR;
+
+typedef struct VkBufferOpaqueCaptureAddressCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ deUint64 opaqueCaptureAddress;
+} VkBufferOpaqueCaptureAddressCreateInfoKHR;
+
+typedef struct VkMemoryOpaqueCaptureAddressAllocateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ deUint64 opaqueCaptureAddress;
+} VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
+
+typedef struct VkDeviceMemoryOpaqueCaptureAddressInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory memory;
+} VkDeviceMemoryOpaqueCaptureAddressInfoKHR;
+
+typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
+typedef deUint64 (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
+typedef deUint64 (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(
+ VkDevice device,
+ const VkBufferDeviceAddressInfoKHR* pInfo);
+
+VKAPI_ATTR deUint64 VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(
+ VkDevice device,
+ const VkBufferDeviceAddressInfoKHR* pInfo);
+
+VKAPI_ATTR deUint64 VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+ VkDevice device,
+ const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo);
+#endif
+
+
#define VK_KHR_pipeline_executable_properties 1
#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
VkStructureType sType;
- const void* pNext;
+ void* pNext;
VkBool32 textureCompressionASTC_HDR;
} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
#define VK_EXT_buffer_device_address 1
-typedef deUint64 VkDeviceAddress;
#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2
#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;
-typedef struct VkBufferDeviceAddressInfoEXT {
- VkStructureType sType;
- const void* pNext;
- VkBuffer buffer;
-} VkBufferDeviceAddressInfoEXT;
+typedef VkBufferDeviceAddressInfoKHR VkBufferDeviceAddressInfoEXT;
typedef struct VkBufferDeviceAddressCreateInfoEXT {
VkStructureType sType;
VkDeviceAddress deviceAddress;
} VkBufferDeviceAddressCreateInfoEXT;
-typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo);
+typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(
VkDevice device,
- const VkBufferDeviceAddressInfoEXT* pInfo);
+ const VkBufferDeviceAddressInfoKHR* pInfo);
#endif
using namespace vk;
using namespace std;
+typedef de::MovePtr<Unique<VkBuffer> > VkBufferSp;
+typedef de::MovePtr<Allocation> AllocationSp;
+
static const deUint32 DIM = 8;
typedef enum
void BufferAddressTestCase::checkSupport (Context& context) const
{
- if (!context.getBufferDeviceAddressFeatures().bufferDeviceAddress)
+ if (!context.isBufferDeviceAddressSupported())
TCU_THROW(NotSupportedError, "Physical storage buffer pointers not supported");
if (m_data.stage == STAGE_VERTEX && !context.getDeviceFeatures().vertexPipelineStoresAndAtomics)
if (m_data.convertUToPtr == VK_TRUE && !context.getDeviceFeatures().shaderInt64)
TCU_THROW(NotSupportedError, "64-bit integers in shader not supported");
- if (m_data.bufType == BT_REPLAY &&
- !context.getBufferDeviceAddressFeatures().bufferDeviceAddressCaptureReplay)
+ bool isBufferDeviceAddressWithCaptureReplaySupported =
+ (context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address") && context.getBufferDeviceAddressFeatures().bufferDeviceAddressCaptureReplay) ||
+ (context.isDeviceFunctionalitySupported("VK_EXT_buffer_device_address") && context.getBufferDeviceAddressFeaturesEXT().bufferDeviceAddressCaptureReplay);
+ if (m_data.bufType == BT_REPLAY && !isBufferDeviceAddressWithCaptureReplaySupported)
TCU_THROW(NotSupportedError, "Capture/replay of physical storage buffer pointers not supported");
if (m_data.layout == LAYOUT_SCALAR && !context.getScalarBlockLayoutFeatures().scalarBlockLayout)
TCU_THROW(NotSupportedError, "Ray tracing not supported");
}
#endif
+
+ if (m_data.convertUToPtr && !context.getDeviceFeatures().shaderInt64)
+ TCU_THROW(NotSupportedError, "Int64 not supported");
}
void BufferAddressTestCase::checkBuffer (std::stringstream& checks, deUint32 bufNum, deUint32 curDepth, const std::string &prefix) const
tcu::TestStatus BufferAddressTestInstance::iterate (void)
{
+ const InstanceInterface&vki = m_context.getInstanceInterface();
const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkPhysicalDevice& physDevice = m_context.getPhysicalDevice();
const VkDevice device = m_context.getDevice();
Allocator& allocator = m_context.getDefaultAllocator();
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
VkFlags allShaderStages = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
numBindings = numBindings*3+1;
}
- VkBufferDeviceAddressCreateInfoEXT addressCreateInfo =
+ VkBufferDeviceAddressCreateInfoEXT addressCreateInfoEXT =
{
VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, // VkStructureType sType;
DE_NULL, // const void* pNext;
- 0x000000000ULL, // VkDeviceSize deviceAddress
+ 0x000000000ULL, // VkDeviceSize deviceAddress
+ };
+
+ VkBufferOpaqueCaptureAddressCreateInfoKHR bufferOpaqueCaptureAddressCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR,// VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0x000000000ULL, // VkDeviceSize opaqueCaptureAddress
};
std::vector<deUint8 *> cpuAddrs(numBindings);
std::vector<VkDeviceAddress> gpuAddrs(numBindings);
+ std::vector<deUint64> opaqueBufferAddrs(numBindings);
+ std::vector<deUint64> opaqueMemoryAddrs(numBindings);
- VkBufferDeviceAddressInfoEXT info =
+ VkBufferDeviceAddressInfoKHR bufferDeviceAddressInfo =
{
- VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // VkBuffer buffer
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR,// VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkBuffer buffer
+ };
+
+ VkDeviceMemoryOpaqueCaptureAddressInfoKHR deviceMemoryOpaqueCaptureAddressInfo =
+ {
+ VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR,// VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkDeviceMemory memory;
};
bool multiBuffer = m_data.bufType != BT_SINGLE;
deUint32 numBuffers = multiBuffer ? numBindings : 1;
VkDeviceSize bufferSize = multiBuffer ? align : (align*numBindings);
- vector<de::SharedPtr<BufferWithMemory> > buffers(numBuffers);
- for (deUint32 i = 0; i < numBuffers; ++i)
- {
- buffers[i] = de::SharedPtr<BufferWithMemory>(new BufferWithMemory(
- vk, device, allocator, makeBufferCreateInfo(DE_NULL, bufferSize,
+ vector<VkBufferSp> buffers(numBuffers);
+ vector<AllocationSp> allocations(numBuffers);
+
+ VkBufferCreateInfo bufferCreateInfo = makeBufferCreateInfo(DE_NULL, bufferSize,
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
- VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT,
- m_data.bufType == BT_REPLAY ? VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT : 0),
- MemoryRequirement::HostVisible));
+ VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR,
+ m_data.bufType == BT_REPLAY ? VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR : 0);
+
+ // VkMemoryAllocateFlags to be filled out later
+ VkMemoryAllocateFlagsInfo allocFlagsInfo =
+ {
+ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ 0, // VkMemoryAllocateFlags flags
+ 0, // uint32_t deviceMask
+ };
+
+ VkMemoryOpaqueCaptureAddressAllocateInfoKHR memoryOpaqueCaptureAddressAllocateInfo =
+ {
+ VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR,// VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // uint64_t opaqueCaptureAddress;
+ };
+
+ if (useKHR)
+ allocFlagsInfo.flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR;
+
+ if (useKHR && m_data.bufType == BT_REPLAY)
+ {
+ allocFlagsInfo.flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR;
+ allocFlagsInfo.pNext = &memoryOpaqueCaptureAddressAllocateInfo;
+ }
+
+ for (deUint32 i = 0; i < numBuffers; ++i)
+ {
+ buffers[i] = VkBufferSp(new Unique<VkBuffer>(createBuffer(vk, device, &bufferCreateInfo)));
+
+ // query opaque capture address before binding memory
+ if (useKHR) {
+ bufferDeviceAddressInfo.buffer = **buffers[i];
+ opaqueBufferAddrs[i] = vk.getBufferOpaqueCaptureAddressKHR(device, &bufferDeviceAddressInfo);
+ }
+
+ allocations[i] = AllocationSp(allocateExtended(vki, vk, physDevice, device, getBufferMemoryRequirements(vk, device, **buffers[i]), MemoryRequirement::HostVisible, &allocFlagsInfo));
+
+ if (useKHR) {
+ deviceMemoryOpaqueCaptureAddressInfo.memory = allocations[i]->getMemory();
+ opaqueMemoryAddrs[i] = vk.getDeviceMemoryOpaqueCaptureAddressKHR(device, &deviceMemoryOpaqueCaptureAddressInfo);
+ }
+
+ VK_CHECK(vk.bindBufferMemory(device, **buffers[i], allocations[i]->getMemory(), 0));
}
if (m_data.bufType == BT_REPLAY)
{
for (deUint32 i = 0; i < numBuffers; ++i)
{
- info.buffer = **buffers[i];
- gpuAddrs[i] = vk.getBufferDeviceAddressEXT(device, &info);
+ bufferDeviceAddressInfo.buffer = **buffers[i];
+ if (useKHR)
+ gpuAddrs[i] = vk.getBufferDeviceAddressKHR(device, &bufferDeviceAddressInfo);
+ else
+ gpuAddrs[i] = vk.getBufferDeviceAddressEXT(device, &bufferDeviceAddressInfo);
}
buffers.clear();
buffers.resize(numBuffers);
+ allocations.clear();
+ allocations.resize(numBuffers);
+
+ bufferCreateInfo.pNext = useKHR ? (void *)&bufferOpaqueCaptureAddressCreateInfo : (void *)&addressCreateInfoEXT;
+
for (deInt32 i = numBuffers-1; i >= 0; --i)
{
- addressCreateInfo.deviceAddress = gpuAddrs[i];
- buffers[i] = de::SharedPtr<BufferWithMemory>(new BufferWithMemory(
- vk, device, allocator, makeBufferCreateInfo(&addressCreateInfo, bufferSize,
- VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
- VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
- VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT,
- m_data.bufType == BT_REPLAY ? VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT : 0),
- MemoryRequirement::HostVisible));
- info.buffer = **buffers[i];
- VkDeviceSize newAddr = vk.getBufferDeviceAddressEXT(device, &info);
+ addressCreateInfoEXT.deviceAddress = gpuAddrs[i];
+ bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress = opaqueBufferAddrs[i];
+ memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress = opaqueMemoryAddrs[i];
+
+ buffers[i] = VkBufferSp(new Unique<VkBuffer>(createBuffer(vk, device, &bufferCreateInfo)));
+ allocations[i] = AllocationSp(allocateExtended(vki, vk, physDevice, device, getBufferMemoryRequirements(vk, device, **buffers[i]), MemoryRequirement::HostVisible, &allocFlagsInfo));
+ VK_CHECK(vk.bindBufferMemory(device, **buffers[i], allocations[i]->getMemory(), 0));
+
+ bufferDeviceAddressInfo.buffer = **buffers[i];
+ VkDeviceSize newAddr;
+ if (useKHR)
+ newAddr = vk.getBufferDeviceAddressKHR(device, &bufferDeviceAddressInfo);
+ else
+ newAddr = vk.getBufferDeviceAddressEXT(device, &bufferDeviceAddressInfo);
if (newAddr != gpuAddrs[i])
return tcu::TestStatus(QP_TEST_RESULT_FAIL, "address mismatch");
}
// Create a buffer and compute the address for each "align" bytes.
for (deUint32 i = 0; i < numBindings; ++i)
{
- info.buffer = **buffers[multiBuffer ? i : 0];
+ bufferDeviceAddressInfo.buffer = **buffers[multiBuffer ? i : 0];
- gpuAddrs[i] = vk.getBufferDeviceAddressEXT(device, &info);
- cpuAddrs[i] = (deUint8 *)buffers[multiBuffer ? i : 0]->getAllocation().getHostPtr();
+ if (useKHR)
+ gpuAddrs[i] = vk.getBufferDeviceAddressKHR(device, &bufferDeviceAddressInfo);
+ else
+ gpuAddrs[i] = vk.getBufferDeviceAddressEXT(device, &bufferDeviceAddressInfo);
+ cpuAddrs[i] = (deUint8 *)allocations[multiBuffer ? i : 0]->getHostPtr();
if (!multiBuffer)
{
cpuAddrs[i] = cpuAddrs[i] + align*i;
fillBuffer(cpuAddrs, gpuAddrs, 0, 0);
for (deUint32 i = 0; i < numBuffers; ++i)
- flushAlloc(vk, device, buffers[i]->getAllocation());
+ flushAlloc(vk, device, *allocations[i]);
const VkQueue queue = m_context.getUniversalQueue();
Move<VkCommandPool> cmdPool = createCommandPool(vk, device, 0, m_context.getUniversalQueueFamilyIndex());
TCU_THROW(NotSupportedError, "variable pointers not supported");
}
- if (m_data.storageClass == SC_PHYSICAL_STORAGE_BUFFER &&
- !context.getBufferDeviceAddressFeatures().bufferDeviceAddress)
+ if (m_data.storageClass == SC_PHYSICAL_STORAGE_BUFFER && !context.isBufferDeviceAddressSupported())
{
TCU_THROW(NotSupportedError, "buffer device address not supported");
}
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice device = m_context.getDevice();
Allocator& allocator = m_context.getDefaultAllocator();
+ MemoryRequirement memoryDeviceAddress = m_data.storageClass == SC_PHYSICAL_STORAGE_BUFFER &&
+ m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address") ? MemoryRequirement::DeviceAddress : MemoryRequirement::Any;
qpTestResult finalres = QP_TEST_RESULT_PASS;
tcu::TestLog& log = m_context.getTestContext().getLog();
{
buffers[i] = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
vk, device, allocator, makeBufferCreateInfo(bufferSizes[i], VK_BUFFER_USAGE_STORAGE_BUFFER_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT|VK_BUFFER_USAGE_TRANSFER_SRC_BIT|VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT),
- MemoryRequirement::HostVisible | MemoryRequirement::Cached | MemoryRequirement::Coherent));
+ MemoryRequirement::HostVisible | MemoryRequirement::Cached | MemoryRequirement::Coherent | memoryDeviceAddress));
}
catch (const tcu::NotSupportedError&)
{
buffers[i] = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
vk, device, allocator, makeBufferCreateInfo(bufferSizes[i], VK_BUFFER_USAGE_STORAGE_BUFFER_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT|VK_BUFFER_USAGE_TRANSFER_SRC_BIT|VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT),
- MemoryRequirement::HostVisible));
+ MemoryRequirement::HostVisible | memoryDeviceAddress));
}
bufferDescriptors[i] = makeDescriptorBufferInfo(**buffers[i], 0, bufferSizes[i]);
vk::DescriptorSetUpdateBuilder setUpdateBuilder;
if (m_data.storageClass == SC_PHYSICAL_STORAGE_BUFFER)
{
- VkBufferDeviceAddressInfoEXT info =
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
+
+ VkBufferDeviceAddressInfoKHR info =
{
- VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, // VkStructureType sType;
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, // VkStructureType sType;
DE_NULL, // const void* pNext;
0, // VkBuffer buffer
};
for (deUint32 i = 0; i < 4; ++i)
{
info.buffer = **buffers[i];
- VkDeviceAddress addr = vk.getBufferDeviceAddressEXT(device, &info);
+ VkDeviceAddress addr;
+ if (useKHR)
+ addr = vk.getBufferDeviceAddressKHR(device, &info);
+ else
+ addr = vk.getBufferDeviceAddressEXT(device, &info);
addrsInMemory[i] = addr;
}
setUpdateBuilder.writeSingle(*descriptorSet, vk::DescriptorSetUpdateBuilder::Location::binding(4),
!context.getVulkanMemoryModelFeatures().vulkanMemoryModelAvailabilityVisibilityChains)
TCU_THROW(NotSupportedError, "vulkanMemoryModelAvailabilityVisibilityChains not supported");
- if ((m_data.payloadSC == SC_PHYSBUFFER || m_data.guardSC == SC_PHYSBUFFER) &&
- !context.getBufferDeviceAddressFeatures().bufferDeviceAddress)
+ if ((m_data.payloadSC == SC_PHYSBUFFER || m_data.guardSC == SC_PHYSBUFFER) && !context.isBufferDeviceAddressSupported())
TCU_THROW(NotSupportedError, "Physical storage buffer pointers not supported");
if (m_data.stage == STAGE_VERTEX)
vk::VkFlags usageFlags = vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+ bool memoryDeviceAddress = false;
+
bool local;
switch (i)
{
continue;
local = m_data.payloadMemLocal;
if (m_data.payloadSC == SC_PHYSBUFFER)
- usageFlags |= vk::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT;
+ {
+ usageFlags |= vk::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+ if (m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address"))
+ memoryDeviceAddress = true;
+ }
break;
case 1:
if (m_data.guardSC != SC_BUFFER && m_data.guardSC != SC_PHYSBUFFER)
continue;
local = m_data.guardMemLocal;
if (m_data.guardSC == SC_PHYSBUFFER)
- usageFlags |= vk::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT;
+ {
+ usageFlags |= vk::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+ if (m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address"))
+ memoryDeviceAddress = true;
+ }
break;
case 2: local = true; break;
}
{
buffers[i] = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
vk, device, allocator, makeBufferCreateInfo(bufferSizes[i], usageFlags),
- local ? MemoryRequirement::Local : MemoryRequirement::NonLocal));
+ (memoryDeviceAddress ? MemoryRequirement::DeviceAddress : MemoryRequirement::Any) |
+ (local ? MemoryRequirement::Local : MemoryRequirement::NonLocal)));
}
catch (const tcu::NotSupportedError&)
{
pipeline = createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo);
}
- const VkQueue queue = m_context.getUniversalQueue();
+ const VkQueue queue = m_context.getUniversalQueue();
Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, m_context.getUniversalQueueFamilyIndex());
Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- VkBufferDeviceAddressInfoEXT addrInfo =
+ VkBufferDeviceAddressInfoKHR addrInfo =
{
- VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // VkBuffer buffer
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR,// VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // VkBuffer buffer
};
VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
bufferSizes[2] // size
};
- deUint32 NUM_SUBMITS = 2;
+ deUint32 NUM_SUBMITS = 2;
for (deUint32 x = 0; x < NUM_SUBMITS; ++x)
{
if (m_data.payloadSC == SC_PHYSBUFFER)
{
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
addrInfo.buffer = **buffers[0];
- VkDeviceAddress addr = vk.getBufferDeviceAddressEXT(device, &addrInfo);
+ VkDeviceAddress addr;
+ if (useKHR)
+ addr = vk.getBufferDeviceAddressKHR(device, &addrInfo);
+ else
+ addr = vk.getBufferDeviceAddressEXT(device, &addrInfo);
vk.cmdPushConstants(*cmdBuffer, *pipelineLayout, allShaderStages,
0, sizeof(VkDeviceSize), &addr);
}
if (m_data.guardSC == SC_PHYSBUFFER)
{
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
addrInfo.buffer = **buffers[1];
- VkDeviceAddress addr = vk.getBufferDeviceAddressEXT(device, &addrInfo);
+ VkDeviceAddress addr;
+ if (useKHR)
+ addr = vk.getBufferDeviceAddressKHR(device, &addrInfo);
+ else
+ addr = vk.getBufferDeviceAddressEXT(device, &addrInfo);
vk.cmdPushConstants(*cmdBuffer, *pipelineLayout, allShaderStages,
8, sizeof(VkDeviceSize), &addr);
}
* The memory is created as host visible and passed back as a vk::Allocation
* instance via outMemory.
*//*--------------------------------------------------------------------*/
-Move<VkBuffer> createBufferAndBindMemory (const DeviceInterface& vkdi,
+Move<VkBuffer> createBufferAndBindMemory (vkt::Context& context,
+ const DeviceInterface& vkdi,
const VkDevice& device,
VkDescriptorType dtype,
Allocator& allocator,
VkBufferUsageFlags usageFlags = (VkBufferUsageFlags)0u;
if (physStorageBuffer)
- usageFlags |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT;
+ usageFlags |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
switch (dtype)
{
Move<VkBuffer> buffer (createBuffer(vkdi, device, &bufferCreateInfo));
const VkMemoryRequirements requirements = getBufferMemoryRequirements(vkdi, device, *buffer);
- AllocationMp bufferMemory = allocator.allocate(requirements, coherent ? MemoryRequirement::Coherent | MemoryRequirement::HostVisible : MemoryRequirement::HostVisible);
+ AllocationMp bufferMemory = allocator.allocate(requirements,
+ (coherent ? MemoryRequirement::Coherent : MemoryRequirement::Any) |
+ (context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address") && physStorageBuffer ? MemoryRequirement::DeviceAddress : MemoryRequirement::Any) |
+ MemoryRequirement::HostVisible);
VK_CHECK(vkdi.bindBufferMemory(device, *buffer, bufferMemory->getMemory(), bufferMemory->getOffset()));
*outMemory = bufferMemory;
if (!isFloatControlsFeaturesSupported(m_context, m_shaderSpec.requestedVulkanFeatures.floatControlsProperties))
TCU_THROW(NotSupportedError, "Requested Float Controls features not supported");
- if (m_shaderSpec.usesPhysStorageBuffer && !m_context.getBufferDeviceAddressFeatures().bufferDeviceAddress)
+ if (m_shaderSpec.usesPhysStorageBuffer && !m_context.isBufferDeviceAddressSupported())
TCU_THROW(NotSupportedError, "Request physical storage buffer feature not supported");
}
const size_t numBytes = inputBytes.size();
AllocationMp bufferAlloc;
- BufferHandleUp* buffer = new BufferHandleUp(createBufferAndBindMemory(vkdi, device, descType, allocator, numBytes, &bufferAlloc, m_shaderSpec.usesPhysStorageBuffer, m_shaderSpec.coherentMemory));
+ BufferHandleUp* buffer = new BufferHandleUp(createBufferAndBindMemory(m_context, vkdi, device, descType, allocator, numBytes, &bufferAlloc, m_shaderSpec.usesPhysStorageBuffer, m_shaderSpec.coherentMemory));
setMemory(vkdi, device, &*bufferAlloc, numBytes, &inputBytes.front(), m_shaderSpec.coherentMemory);
inputBuffers.push_back(BufferHandleSp(buffer));
const size_t numBytes = inputBytes.size();
AllocationMp bufferAlloc;
- BufferHandleUp* buffer = new BufferHandleUp(createBufferAndBindMemory(vkdi, device, descType, allocator, numBytes, &bufferAlloc, m_shaderSpec.usesPhysStorageBuffer));
+ BufferHandleUp* buffer = new BufferHandleUp(createBufferAndBindMemory(m_context, vkdi, device, descType, allocator, numBytes, &bufferAlloc, m_shaderSpec.usesPhysStorageBuffer));
AllocationMp imageAlloc;
ImageHandleUp* image = new ImageHandleUp(createImageAndBindMemory(vkdi, device, descType, allocator, queueFamilyIndex, &imageAlloc));
output->getBytes(outputBytes);
const size_t numBytes = outputBytes.size();
- BufferHandleUp* buffer = new BufferHandleUp(createBufferAndBindMemory(vkdi, device, descriptorTypes.back(), allocator, numBytes, &alloc, m_shaderSpec.usesPhysStorageBuffer, m_shaderSpec.coherentMemory));
+ BufferHandleUp* buffer = new BufferHandleUp(createBufferAndBindMemory(m_context, vkdi, device, descriptorTypes.back(), allocator, numBytes, &alloc, m_shaderSpec.usesPhysStorageBuffer, m_shaderSpec.coherentMemory));
fillMemoryWithValue(vkdi, device, &*alloc, numBytes, 0xff, m_shaderSpec.coherentMemory);
descriptorInfos.push_back(vk::makeDescriptorBufferInfo(**buffer, 0u, numBytes));
// all the descriptors with just a desciptor to this new buffer.
if (m_shaderSpec.usesPhysStorageBuffer)
{
- VkBufferDeviceAddressInfoEXT info =
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
+
+ VkBufferDeviceAddressInfoKHR info =
{
- VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, // VkStructureType sType;
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, // VkStructureType sType;
DE_NULL, // const void* pNext;
0, // VkBuffer buffer
};
for (deUint32 inputNdx = 0; inputNdx < m_shaderSpec.inputs.size(); ++inputNdx)
{
info.buffer = **inputBuffers[inputNdx];
- VkDeviceAddress addr = vkdi.getBufferDeviceAddressEXT(device, &info);
+ VkDeviceAddress addr;
+ if (useKHR)
+ addr = vkdi.getBufferDeviceAddressKHR(device, &info);
+ else
+ addr = vkdi.getBufferDeviceAddressEXT(device, &info);
gpuAddrs.push_back(addr);
}
for (deUint32 outputNdx = 0; outputNdx < m_shaderSpec.outputs.size(); ++outputNdx)
{
info.buffer = **outputBuffers[outputNdx];
- VkDeviceAddress addr = vkdi.getBufferDeviceAddressEXT(device, &info);
+ VkDeviceAddress addr;
+ if (useKHR)
+ addr = vkdi.getBufferDeviceAddressKHR(device, &info);
+ else
+ addr = vkdi.getBufferDeviceAddressEXT(device, &info);
gpuAddrs.push_back(addr);
}
const size_t numBytes = gpuAddrs.size() * sizeof(VkDeviceAddress);
AllocationMp bufferAlloc;
- BufferHandleUp* buffer = new BufferHandleUp(createBufferAndBindMemory(vkdi, device, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+ BufferHandleUp* buffer = new BufferHandleUp(createBufferAndBindMemory(m_context, vkdi, device, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
allocator, numBytes, &bufferAlloc, false, m_shaderSpec.coherentMemory));
setMemory(vkdi, device, &*bufferAlloc, numBytes, &gpuAddrs.front(), m_shaderSpec.coherentMemory);
incrAmuxBOutputFloats[i] = (inputSFloats[i] < 0) ? 1 + inputAFloats[i] : 1 + inputBFloats[i];
}
- const char *extensions = physPtrs ? "VK_EXT_buffer_device_address" : "VK_KHR_variable_pointers";
-
std::string stringTemplate =
"OpCapability Shader\n"
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputBFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputSFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
{ // Variable Pointer Reads (using OpFunctionCall)
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputBFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputSFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
{ // Variable Pointer Reads (using OpPhi)
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputBFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputSFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
{ // Variable Pointer Reads (using OpCopyObject)
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputBFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputSFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
{ // Test storing into Private variables.
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputBFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputSFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), description.c_str(), spec));
}
}
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputBFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputSFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
{ // Variable Pointer Writes
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputBFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputSFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedIncrOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
spec.inputs.push_back (Resource(BufferSp(new Float32Buffer(inputBFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back (Resource(BufferSp(new Float32Buffer(inputSFloats)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
}
"%inputC_b = OpAccessChain %outer_struct_ptr %inputC %c_i32_1\n"
);
- const char *extensions = physPtrs ? "VK_EXT_buffer_device_address" : "VK_KHR_variable_pointers";
-
std::string stringTemplate =
"OpCapability Shader\n"
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputB)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputC)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputB)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputC)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputB)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputC)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputB)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputC)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputB)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.inputs.push_back(Resource(BufferSp(new Float32Buffer(inputC)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput))));
- spec.extensions.push_back(extensions);
+ if (!physPtrs)
+ spec.extensions.push_back("VK_KHR_variable_pointers");
group->addChild(new SpvAsmComputeShaderCase(testCtx, name.c_str(), name.c_str(), spec));
}
}
vector<BlockDataPtr> mappedBlockPtrs;
vk::VkFlags usageFlags = vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+ bool memoryDeviceAddress = false;
if (m_usePhysStorageBuffer)
- usageFlags |= vk::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT;
+ {
+ usageFlags |= vk::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+ if (m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address"))
+ memoryDeviceAddress = true;
+ }
// Upload base buffers
const std::vector<int> bufferSizes = computeBufferSizes(m_interface, m_refLayout);
blockLocations[blockNdx] = BlockLocation(blockNdx, 0, bufferSize);
vk::Move<vk::VkBuffer> buffer = createBuffer(m_context, bufferSize, usageFlags);
- de::MovePtr<vk::Allocation> alloc = allocateAndBindMemory(m_context, *buffer, vk::MemoryRequirement::HostVisible);
+ de::MovePtr<vk::Allocation> alloc = allocateAndBindMemory(m_context, *buffer, vk::MemoryRequirement::HostVisible | (memoryDeviceAddress ? vk::MemoryRequirement::DeviceAddress : vk::MemoryRequirement::Any));
descriptors[blockNdx] = makeDescriptorBufferInfo(*buffer, 0ull, bufferSize);
const int totalBufferSize = curOffset;
vk::Move<vk::VkBuffer> buffer = createBuffer(m_context, totalBufferSize, usageFlags);
- de::MovePtr<vk::Allocation> alloc = allocateAndBindMemory(m_context, *buffer, vk::MemoryRequirement::HostVisible);
+ de::MovePtr<vk::Allocation> alloc = allocateAndBindMemory(m_context, *buffer, vk::MemoryRequirement::HostVisible | (memoryDeviceAddress ? vk::MemoryRequirement::DeviceAddress : vk::MemoryRequirement::Any));
mapPtrs.push_back(alloc->getHostPtr());
// Query the buffer device addresses and push them via push constants
if (m_usePhysStorageBuffer)
{
- vk::VkBufferDeviceAddressInfoEXT info =
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
+
+ vk::VkBufferDeviceAddressInfoKHR info =
{
- vk::VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, // VkStructureType sType;
+ vk::VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, // VkStructureType sType;
DE_NULL, // const void* pNext;
0, // VkBuffer buffer
};
for (deUint32 i = 0; i < descriptors.size(); ++i)
{
info.buffer = descriptors[i].buffer;
- vk::VkDeviceAddress addr = vk.getBufferDeviceAddressEXT(device, &info);
+ vk::VkDeviceAddress addr;
+ if (useKHR)
+ addr = vk.getBufferDeviceAddressKHR(device, &info);
+ else
+ addr = vk.getBufferDeviceAddressEXT(device, &info);
addr += descriptors[i].offset;
gpuAddrs.push_back(addr);
}
(vk::VkPipelineLayoutCreateFlags)0,
1u, // deUint32 descriptorSetCount;
&*descriptorSetLayout, // const VkDescriptorSetLayout* pSetLayouts;
- m_usePhysStorageBuffer ? 1u : 0u, // deUint32 pushConstantRangeCount;
+ m_usePhysStorageBuffer ? 1u : 0u, // deUint32 pushConstantRangeCount;
&pushConstRange, // const VkPushConstantRange* pPushConstantRanges;
};
vk::Move<vk::VkPipelineLayout> pipelineLayout(createPipelineLayout(vk, device, &pipelineLayoutParams));
TCU_THROW(NotSupportedError, "storageBuffer8BitAccess not supported");
if (!context.getScalarBlockLayoutFeatures().scalarBlockLayout && usesScalarLayout(m_interface))
TCU_THROW(NotSupportedError, "scalarBlockLayout not supported");
- if (!context.getBufferDeviceAddressFeatures().bufferDeviceAddress && m_usePhysStorageBuffer)
+ if (m_usePhysStorageBuffer && !context.isBufferDeviceAddressSupported())
TCU_THROW(NotSupportedError, "Physical storage buffer pointers not supported");
return new SSBOLayoutCaseInstance(context, m_bufferMode, m_interface, m_refLayout, m_initialData, m_writeData, m_usePhysStorageBuffer);
}
return (void*)m_platformInterface.getGetInstanceProcAddr();
}
+bool Context::isBufferDeviceAddressSupported(void) const
+{
+ return isDeviceFunctionalitySupported("VK_KHR_buffer_device_address") ||
+ isDeviceFunctionalitySupported("VK_EXT_buffer_device_address");
+}
+
// TestCase
void TestCase::initPrograms (SourceCollections&) const
bool resultSetOnValidation () const { return m_resultSetOnValidation; }
void resultSetOnValidation (bool value) { m_resultSetOnValidation = value; }
+ bool isBufferDeviceAddressSupported (void) const;
+
protected:
tcu::TestContext& m_testCtx;
const vk::PlatformInterface& m_platformInterface;
def genericDeviceFeaturesWriter(dfDefs, pattern, filename):
stream = []
- for _, _, extStruct, _, _, _ in dfDefs:
- nameSubStr = extStruct.replace("VkPhysicalDevice", "").replace("KHR", "").replace("EXT", "").replace("NV", "")
+ for sType, sSuffix, extStruct, _, _, _ in dfDefs:
+ # Special case to treat BufferDeviceAddressFeaturesEXT differently than BufferDeviceAddressFeaturesKHR
+ if sType == "BUFFER_DEVICE_ADDRESS" and sSuffix == "_EXT":
+ nameSubStr = extStruct.replace("VkPhysicalDevice", "")
+ else:
+ nameSubStr = extStruct.replace("VkPhysicalDevice", "").replace("EXT", "").replace("KHR", "").replace("NV", "")
stream.append(pattern.format(extStruct, nameSubStr))
writeInlFile(filename, INL_HEADER, indentLines(stream))
VK_KHR_spirv_1_4 DEVICE
VK_KHR_shader_subgroup_extended_types DEVICE
VK_KHR_separate_depth_stencil_layouts DEVICE
-VK_KHR_performance_query DEVICE
\ No newline at end of file
+VK_KHR_performance_query DEVICE
+VK_KHR_buffer_device_address DEVICE
\ No newline at end of file
#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
// Version of this file
-#define VK_HEADER_VERSION 124
+#define VK_HEADER_VERSION 129
#define VK_NULL_HANDLE 0
VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,
VK_ERROR_FRAGMENTATION_EXT = -1000161000,
VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
- VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = -1000244000,
VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,
+ VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = -1000244000,
VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
+ VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR,
VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
VK_RESULT_END_RANGE = VK_INCOMPLETE,
VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = 1000241001,
VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = 1000241002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
- VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001,
VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = 1000246000,
VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,
VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,
VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = 1000257000,
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = 1000244001,
+ VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = 1000257002,
+ VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = 1000257003,
+ VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = 1000257004,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
+ VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR,
VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
- VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000010,
+ VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000010,
+ VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR,
VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferCreateFlagBits;
typedef VkFlags VkBufferCreateFlags;
VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,
VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,
VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = 0x00000400,
- VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = 0x00020000,
+ VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000,
+ VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR,
VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkBufferUsageFlagBits;
typedef VkFlags VkBufferUsageFlags;
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
- VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
+ VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,
VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,
VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,
VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,
+ VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
typedef enum VkMemoryAllocateFlagBits {
VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
+ VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = 0x00000002,
+ VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000004,
VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
} VkMemoryAllocateFlagBits;
int* pFd);
#endif
+
#define VK_KHR_performance_query 1
#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1
#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"
} VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
+
#define VK_KHR_spirv_1_4 1
#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1
#define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4"
+#define VK_KHR_buffer_device_address 1
+typedef uint64_t VkDeviceAddress;
+#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1
+#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address"
+typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 bufferDeviceAddress;
+ VkBool32 bufferDeviceAddressCaptureReplay;
+ VkBool32 bufferDeviceAddressMultiDevice;
+} VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;
+
+typedef struct VkBufferDeviceAddressInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkBuffer buffer;
+} VkBufferDeviceAddressInfoKHR;
+
+typedef struct VkBufferOpaqueCaptureAddressCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint64_t opaqueCaptureAddress;
+} VkBufferOpaqueCaptureAddressCreateInfoKHR;
+
+typedef struct VkMemoryOpaqueCaptureAddressAllocateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint64_t opaqueCaptureAddress;
+} VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
+
+typedef struct VkDeviceMemoryOpaqueCaptureAddressInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkDeviceMemory memory;
+} VkDeviceMemoryOpaqueCaptureAddressInfoKHR;
+
+typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
+typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
+typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(
+ VkDevice device,
+ const VkBufferDeviceAddressInfoKHR* pInfo);
+
+VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(
+ VkDevice device,
+ const VkBufferDeviceAddressInfoKHR* pInfo);
+
+VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+ VkDevice device,
+ const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo);
+#endif
+
+
#define VK_KHR_pipeline_executable_properties 1
#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"
typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
VkStructureType sType;
- const void* pNext;
+ void* pNext;
VkBool32 textureCompressionASTC_HDR;
} VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
#define VK_EXT_buffer_device_address 1
-typedef uint64_t VkDeviceAddress;
#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2
#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"
typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;
-typedef struct VkBufferDeviceAddressInfoEXT {
- VkStructureType sType;
- const void* pNext;
- VkBuffer buffer;
-} VkBufferDeviceAddressInfoEXT;
+typedef VkBufferDeviceAddressInfoKHR VkBufferDeviceAddressInfoEXT;
typedef struct VkBufferDeviceAddressCreateInfoEXT {
VkStructureType sType;
VkDeviceAddress deviceAddress;
} VkBufferDeviceAddressCreateInfoEXT;
-typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo);
+typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfoKHR* pInfo);
#ifndef VK_NO_PROTOTYPES
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(
VkDevice device,
- const VkBufferDeviceAddressInfoEXT* pInfo);
+ const VkBufferDeviceAddressInfoKHR* pInfo);
#endif
projects / platform / upstream / VK-GL-CTS.git / commitdiff