external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemWsiSwapchainTests.cpp \
external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemYCbCrConversionTests.cpp \
external/vulkancts/modules/vulkan/query_pool/vktQueryPoolOcclusionTests.cpp \
+ external/vulkancts/modules/vulkan/query_pool/vktQueryPoolPerformanceTests.cpp \
external/vulkancts/modules/vulkan/query_pool/vktQueryPoolStatisticsTests.cpp \
external/vulkancts/modules/vulkan/query_pool/vktQueryPoolTests.cpp \
external/vulkancts/modules/vulkan/rasterization/vktRasterizationTests.cpp \
dEQP-VK.query_pool.statistics_query.reset_before_copy.tes_evaluation_shader_invocations.64bits_tes_evaluation_shader_invocations
dEQP-VK.query_pool.statistics_query.reset_before_copy.tes_evaluation_shader_invocations.64bits_tes_evaluation_shader_invocations_secondary
dEQP-VK.query_pool.statistics_query.reset_before_copy.tes_evaluation_shader_invocations.64bits_tes_evaluation_shader_invocations_secondary_inherited
+dEQP-VK.query_pool.performance_query.enumerate_and_validate_graphic
+dEQP-VK.query_pool.performance_query.enumerate_and_validate_compute
+dEQP-VK.query_pool.performance_query.query_graphic
+dEQP-VK.query_pool.performance_query.query_compute
+dEQP-VK.query_pool.performance_query.multiple_pools_graphic
+dEQP-VK.query_pool.performance_query.multiple_pools_compute
dEQP-VK.draw.concurrent.compute_and_triangle_list
dEQP-VK.draw.simple_draw.simple_draw_triangle_list
dEQP-VK.draw.simple_draw.simple_draw_triangle_strip
VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,
+ VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,
+ VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,
+ VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,
+ VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005,
+ VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
VK_QUERY_TYPE_TIMESTAMP = 2,
VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
+ VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF,
VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF,
};
+enum VkPerformanceCounterUnitKHR
+{
+ VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
+ VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
+ VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
+ VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
+ VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
+ VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
+ VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
+ VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
+ VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
+ VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
+ VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
+ VK_PERFORMANCE_COUNTER_UNIT_KHR_LAST,
+ VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF,
+};
+
+enum VkPerformanceCounterScopeKHR
+{
+ VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = 0,
+ VK_QUERY_SCOPE_RENDER_PASS_KHR = 1,
+ VK_QUERY_SCOPE_COMMAND_KHR = 2,
+ VK_PERFORMANCE_COUNTER_SCOPE_KHR_LAST,
+ VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF,
+};
+
+enum VkPerformanceCounterStorageKHR
+{
+ VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
+ VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
+ VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
+ VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
+ VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
+ VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
+ VK_PERFORMANCE_COUNTER_STORAGE_KHR_LAST,
+ VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF,
+};
+
enum VkDriverIdKHR
{
VK_DRIVER_ID_AMD_PROPRIETARY_KHR = 1,
};
typedef deUint32 VkDisplayPlaneAlphaFlagsKHR;
+enum VkPerformanceCounterDescriptionFlagBitsKHR
+{
+ VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 0x00000001,
+ VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 0x00000002,
+ VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF,
+};
+typedef deUint32 VkPerformanceCounterDescriptionFlagsKHR;
+
+enum VkAcquireProfilingLockFlagBitsKHR
+{
+ VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF,
+};
+typedef deUint32 VkAcquireProfilingLockFlagsKHR;
+
enum VkResolveModeFlagBitsKHR
{
VK_RESOLVE_MODE_NONE_KHR = 0,
#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
+#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1
#define VK_KHR_MAINTENANCE2_SPEC_VERSION 1
#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
virtual VkResult getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const;
virtual VkResult importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const;
virtual VkResult getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const;
+virtual VkResult acquireProfilingLockKHR (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) const;
+virtual void releaseProfilingLockKHR (VkDevice device) const;
virtual void cmdDrawIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const;
virtual void cmdDrawIndexedIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const;
virtual VkResult getSemaphoreCounterValueKHR (VkDevice device, VkSemaphore semaphore, deUint64* pValue) const;
virtual VkResult createDisplayModeKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) const;
virtual VkResult getDisplayPlaneCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, deUint32 planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) const;
virtual VkResult createDisplayPlaneSurfaceKHR (VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const;
+virtual void enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, deUint32* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) const;
+virtual void getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR (VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, deUint32* pNumPasses) const;
virtual VkResult getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const;
virtual VkResult getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const;
virtual VkResult getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties) const;
return m_vk.getFenceFdKHR(device, pGetFdInfo, pFd);
}
+VkResult DeviceDriver::acquireProfilingLockKHR (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) const
+{
+ return m_vk.acquireProfilingLockKHR(device, pInfo);
+}
+
+void DeviceDriver::releaseProfilingLockKHR (VkDevice device) const
+{
+ m_vk.releaseProfilingLockKHR(device);
+}
+
void DeviceDriver::cmdDrawIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const
{
m_vk.cmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
"VK_KHR_spirv_1_4",
"VK_KHR_shader_subgroup_extended_types",
"VK_KHR_separate_depth_stencil_layouts",
+ "VK_KHR_performance_query",
};
#define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority"
#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader"
#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview"
+#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"
#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"
#define DECL_PROTECTED_MEMORY_EXTENSION_NAME "not_existent_feature"
#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
#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, 49); }
-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, 48); }
-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, 47); }
-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, 46); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0, 45); }
-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, 44); }
-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, 43); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 42); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 41); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 40); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 39); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 38); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 37); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 36); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 35); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 34); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 33); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 32); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 31); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 30); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 29); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 28); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 27); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 26); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 25); }
+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<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); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 43); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 42); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 41); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 40); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 39); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 38); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 37); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 36); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 35); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 34); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 33); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 32); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 31); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 30); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 29); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 28); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 27); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 26); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePerformanceQueryFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME, VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION, 25); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION, 24); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 23); }
template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 22); }
{ createFeatureStructWrapper<VkPhysicalDeviceMemoryPriorityFeaturesEXT>, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceMeshShaderFeaturesNV>, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceMultiviewFeatures>, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION },
+ { createFeatureStructWrapper<VkPhysicalDevicePerformanceQueryFeaturesKHR>, VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME, VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceProtectedMemoryFeatures>, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0 },
{ createFeatureStructWrapper<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION },
const vk::VkPhysicalDeviceMemoryPriorityFeaturesEXT& getMemoryPriorityFeatures (void) const;
const vk::VkPhysicalDeviceMeshShaderFeaturesNV& getMeshShaderFeatures (void) const;
const vk::VkPhysicalDeviceMultiviewFeatures& getMultiviewFeatures (void) const;
+const vk::VkPhysicalDevicePerformanceQueryFeaturesKHR& getPerformanceQueryFeatures (void) const;
const vk::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& getPipelineExecutablePropertiesFeatures (void) const;
const vk::VkPhysicalDeviceProtectedMemoryFeatures& getProtectedMemoryFeatures (void) const;
const vk::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& getRepresentativeFragmentTestFeatures (void) const;
const vk::VkPhysicalDeviceMemoryPriorityFeaturesEXT& Context::getMemoryPriorityFeatures (void) const { return m_device->getMemoryPriorityFeatures(); }
const vk::VkPhysicalDeviceMeshShaderFeaturesNV& Context::getMeshShaderFeatures (void) const { return m_device->getMeshShaderFeatures(); }
const vk::VkPhysicalDeviceMultiviewFeatures& Context::getMultiviewFeatures (void) const { return m_device->getMultiviewFeatures(); }
+const vk::VkPhysicalDevicePerformanceQueryFeaturesKHR& Context::getPerformanceQueryFeatures (void) const { return m_device->getPerformanceQueryFeatures(); }
const vk::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& Context::getPipelineExecutablePropertiesFeatures (void) const { return m_device->getPipelineExecutablePropertiesFeatures(); }
const vk::VkPhysicalDeviceProtectedMemoryFeatures& Context::getProtectedMemoryFeatures (void) const { return m_device->getProtectedMemoryFeatures(); }
const vk::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& Context::getRepresentativeFragmentTestFeatures (void) const { return m_device->getRepresentativeFragmentTestFeatures(); }
const VkPhysicalDeviceMemoryPriorityFeaturesEXT& getMemoryPriorityFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(); }
const VkPhysicalDeviceMeshShaderFeaturesNV& getMeshShaderFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceMeshShaderFeaturesNV>(); }
const VkPhysicalDeviceMultiviewFeatures& getMultiviewFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceMultiviewFeatures>(); }
+const VkPhysicalDevicePerformanceQueryFeaturesKHR& getPerformanceQueryFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDevicePerformanceQueryFeaturesKHR>(); }
const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& getPipelineExecutablePropertiesFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(); }
const VkPhysicalDeviceProtectedMemoryFeatures& getProtectedMemoryFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceProtectedMemoryFeatures>(); }
const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& getRepresentativeFragmentTestFeatures (void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(); }
GetSwapchainStatusKHRFunc getSwapchainStatusKHR;
ImportFenceFdKHRFunc importFenceFdKHR;
GetFenceFdKHRFunc getFenceFdKHR;
+AcquireProfilingLockKHRFunc acquireProfilingLockKHR;
+ReleaseProfilingLockKHRFunc releaseProfilingLockKHR;
CmdDrawIndirectCountKHRFunc cmdDrawIndirectCountKHR;
CmdDrawIndexedIndirectCountKHRFunc cmdDrawIndexedIndirectCountKHR;
GetSemaphoreCounterValueKHRFunc getSemaphoreCounterValueKHR;
{
functions.push_back("vkGetPhysicalDeviceExternalFencePropertiesKHR");
}
+ else if (extName == "VK_KHR_performance_query")
+ {
+ functions.push_back("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
+ functions.push_back("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
+ }
else if (extName == "VK_KHR_get_surface_capabilities2")
{
functions.push_back("vkGetPhysicalDeviceSurfaceCapabilities2KHR");
functions.push_back("vkImportFenceFdKHR");
functions.push_back("vkGetFenceFdKHR");
}
+ else if (extName == "VK_KHR_performance_query")
+ {
+ functions.push_back("vkAcquireProfilingLockKHR");
+ functions.push_back("vkReleaseProfilingLockKHR");
+ }
else if (extName == "VK_KHR_get_memory_requirements2")
{
functions.push_back("vkGetImageMemoryRequirements2KHR");
"VK_KHR_external_memory_capabilities",
"VK_KHR_external_semaphore_capabilities",
"VK_KHR_external_fence_capabilities",
+ "VK_KHR_performance_query",
"VK_KHR_get_surface_capabilities2",
"VK_KHR_get_display_properties2",
"VK_EXT_debug_report",
typedef VKAPI_ATTR void (VKAPI_CALL* GetPhysicalDeviceExternalFencePropertiesKHRFunc) (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* ImportFenceFdKHRFunc) (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetFenceFdKHRFunc) (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
+typedef VKAPI_ATTR void (VKAPI_CALL* EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHRFunc) (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, deUint32* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
+typedef VKAPI_ATTR void (VKAPI_CALL* GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHRFunc) (VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, deUint32* pNumPasses);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* AcquireProfilingLockKHRFunc) (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);
+typedef VKAPI_ATTR void (VKAPI_CALL* ReleaseProfilingLockKHRFunc) (VkDevice device);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceSurfaceCapabilities2KHRFunc) (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceSurfaceFormats2KHRFunc) (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetPhysicalDeviceDisplayProperties2KHRFunc) (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties);
return VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR;
}
+template<> VkStructureType getStructureType<VkPhysicalDevicePerformanceQueryFeaturesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPhysicalDevicePerformanceQueryPropertiesKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPerformanceCounterKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPerformanceCounterDescriptionKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR;
+}
+
+template<> VkStructureType getStructureType<VkQueryPoolPerformanceCreateInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkAcquireProfilingLockInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR;
+}
+
+template<> VkStructureType getStructureType<VkPerformanceQuerySubmitInfoKHR> (void)
+{
+ return VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
+}
+
template<> VkStructureType getStructureType<VkPhysicalDeviceSurfaceInfo2KHR> (void)
{
return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
m_vk.getSwapchainStatusKHR = (GetSwapchainStatusKHRFunc) GET_PROC_ADDR("vkGetSwapchainStatusKHR");
m_vk.importFenceFdKHR = (ImportFenceFdKHRFunc) GET_PROC_ADDR("vkImportFenceFdKHR");
m_vk.getFenceFdKHR = (GetFenceFdKHRFunc) GET_PROC_ADDR("vkGetFenceFdKHR");
+m_vk.acquireProfilingLockKHR = (AcquireProfilingLockKHRFunc) GET_PROC_ADDR("vkAcquireProfilingLockKHR");
+m_vk.releaseProfilingLockKHR = (ReleaseProfilingLockKHRFunc) GET_PROC_ADDR("vkReleaseProfilingLockKHR");
m_vk.cmdDrawIndirectCountKHR = (CmdDrawIndirectCountKHRFunc) GET_PROC_ADDR("vkCmdDrawIndirectCountKHR");
m_vk.cmdDrawIndexedIndirectCountKHR = (CmdDrawIndexedIndirectCountKHRFunc) GET_PROC_ADDR("vkCmdDrawIndexedIndirectCountKHR");
m_vk.getSemaphoreCounterValueKHR = (GetSemaphoreCounterValueKHRFunc) GET_PROC_ADDR("vkGetSemaphoreCounterValueKHR");
m_vk.getPhysicalDeviceExternalBufferPropertiesKHR = (GetPhysicalDeviceExternalBufferPropertiesKHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExternalBufferPropertiesKHR");
m_vk.getPhysicalDeviceExternalSemaphorePropertiesKHR = (GetPhysicalDeviceExternalSemaphorePropertiesKHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
m_vk.getPhysicalDeviceExternalFencePropertiesKHR = (GetPhysicalDeviceExternalFencePropertiesKHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceExternalFencePropertiesKHR");
+m_vk.enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = (EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHRFunc) GET_PROC_ADDR("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
+m_vk.getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = (GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
m_vk.getPhysicalDeviceSurfaceCapabilities2KHR = (GetPhysicalDeviceSurfaceCapabilities2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceSurfaceCapabilities2KHR");
m_vk.getPhysicalDeviceSurfaceFormats2KHR = (GetPhysicalDeviceSurfaceFormats2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceSurfaceFormats2KHR");
m_vk.getPhysicalDeviceDisplayProperties2KHR = (GetPhysicalDeviceDisplayProperties2KHRFunc) GET_PROC_ADDR("vkGetPhysicalDeviceDisplayProperties2KHR");
return m_vk.createDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
}
+void InstanceDriver::enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, deUint32* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) const
+{
+ m_vk.enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
+}
+
+void InstanceDriver::getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR (VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, deUint32* pNumPasses) const
+{
+ m_vk.getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
+}
+
VkResult InstanceDriver::getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const
{
return m_vk.getPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
GetPhysicalDeviceExternalBufferPropertiesKHRFunc getPhysicalDeviceExternalBufferPropertiesKHR;
GetPhysicalDeviceExternalSemaphorePropertiesKHRFunc getPhysicalDeviceExternalSemaphorePropertiesKHR;
GetPhysicalDeviceExternalFencePropertiesKHRFunc getPhysicalDeviceExternalFencePropertiesKHR;
+EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHRFunc enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
+GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHRFunc getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
GetPhysicalDeviceSurfaceCapabilities2KHRFunc getPhysicalDeviceSurfaceCapabilities2KHR;
GetPhysicalDeviceSurfaceFormats2KHRFunc getPhysicalDeviceSurfaceFormats2KHR;
GetPhysicalDeviceDisplayProperties2KHRFunc getPhysicalDeviceDisplayProperties2KHR;
return VK_SUCCESS;
}
+VKAPI_ATTR void VKAPI_CALL enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, deUint32* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions)
+{
+ DE_UNREF(physicalDevice);
+ DE_UNREF(queueFamilyIndex);
+ DE_UNREF(pCounterCount);
+ DE_UNREF(pCounters);
+ DE_UNREF(pCounterDescriptions);
+}
+
+VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR (VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, deUint32* pNumPasses)
+{
+ DE_UNREF(physicalDevice);
+ DE_UNREF(pPerformanceQueryCreateInfo);
+ DE_UNREF(pNumPasses);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL acquireProfilingLockKHR (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo)
+{
+ DE_UNREF(device);
+ DE_UNREF(pInfo);
+ return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL releaseProfilingLockKHR (VkDevice device)
+{
+ DE_UNREF(device);
+}
+
VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
{
DE_UNREF(physicalDevice);
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferPropertiesKHR, getPhysicalDeviceExternalBufferProperties),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, getPhysicalDeviceExternalSemaphoreProperties),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFencePropertiesKHR, getPhysicalDeviceExternalFenceProperties),
+ VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR),
+ VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2KHR, getPhysicalDeviceSurfaceCapabilities2KHR),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormats2KHR, getPhysicalDeviceSurfaceFormats2KHR),
VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayProperties2KHR, getPhysicalDeviceDisplayProperties2KHR),
VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR, getSwapchainStatusKHR),
VK_NULL_FUNC_ENTRY(vkImportFenceFdKHR, importFenceFdKHR),
VK_NULL_FUNC_ENTRY(vkGetFenceFdKHR, getFenceFdKHR),
+ VK_NULL_FUNC_ENTRY(vkAcquireProfilingLockKHR, acquireProfilingLockKHR),
+ VK_NULL_FUNC_ENTRY(vkReleaseProfilingLockKHR, releaseProfilingLockKHR),
VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2KHR, getImageMemoryRequirements2),
VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2KHR, getBufferMemoryRequirements2),
VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2KHR, getImageSparseMemoryRequirements2),
const char* getDescriptorUpdateTemplateTypeName (VkDescriptorUpdateTemplateType value);
const char* getColorSpaceKHRName (VkColorSpaceKHR value);
const char* getPresentModeKHRName (VkPresentModeKHR value);
+const char* getPerformanceCounterUnitKHRName (VkPerformanceCounterUnitKHR value);
+const char* getPerformanceCounterScopeKHRName (VkPerformanceCounterScopeKHR value);
+const char* getPerformanceCounterStorageKHRName (VkPerformanceCounterStorageKHR value);
const char* getDriverIdKHRName (VkDriverIdKHR value);
const char* getShaderFloatControlsIndependenceKHRName (VkShaderFloatControlsIndependenceKHR value);
const char* getSemaphoreTypeKHRName (VkSemaphoreTypeKHR value);
inline tcu::Format::Enum<VkDescriptorUpdateTemplateType> getDescriptorUpdateTemplateTypeStr (VkDescriptorUpdateTemplateType value) { return tcu::Format::Enum<VkDescriptorUpdateTemplateType>(getDescriptorUpdateTemplateTypeName, value); }
inline tcu::Format::Enum<VkColorSpaceKHR> getColorSpaceKHRStr (VkColorSpaceKHR value) { return tcu::Format::Enum<VkColorSpaceKHR>(getColorSpaceKHRName, value); }
inline tcu::Format::Enum<VkPresentModeKHR> getPresentModeKHRStr (VkPresentModeKHR value) { return tcu::Format::Enum<VkPresentModeKHR>(getPresentModeKHRName, value); }
+inline tcu::Format::Enum<VkPerformanceCounterUnitKHR> getPerformanceCounterUnitKHRStr (VkPerformanceCounterUnitKHR value) { return tcu::Format::Enum<VkPerformanceCounterUnitKHR>(getPerformanceCounterUnitKHRName, value); }
+inline tcu::Format::Enum<VkPerformanceCounterScopeKHR> getPerformanceCounterScopeKHRStr (VkPerformanceCounterScopeKHR value) { return tcu::Format::Enum<VkPerformanceCounterScopeKHR>(getPerformanceCounterScopeKHRName, value); }
+inline tcu::Format::Enum<VkPerformanceCounterStorageKHR> getPerformanceCounterStorageKHRStr (VkPerformanceCounterStorageKHR value) { return tcu::Format::Enum<VkPerformanceCounterStorageKHR>(getPerformanceCounterStorageKHRName, value); }
inline tcu::Format::Enum<VkDriverIdKHR> getDriverIdKHRStr (VkDriverIdKHR value) { return tcu::Format::Enum<VkDriverIdKHR>(getDriverIdKHRName, value); }
inline tcu::Format::Enum<VkShaderFloatControlsIndependenceKHR> getShaderFloatControlsIndependenceKHRStr (VkShaderFloatControlsIndependenceKHR value) { return tcu::Format::Enum<VkShaderFloatControlsIndependenceKHR>(getShaderFloatControlsIndependenceKHRName, value); }
inline tcu::Format::Enum<VkSemaphoreTypeKHR> getSemaphoreTypeKHRStr (VkSemaphoreTypeKHR value) { return tcu::Format::Enum<VkSemaphoreTypeKHR>(getSemaphoreTypeKHRName, value); }
inline std::ostream& operator<< (std::ostream& s, VkDescriptorUpdateTemplateType value) { return s << getDescriptorUpdateTemplateTypeStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkColorSpaceKHR value) { return s << getColorSpaceKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkPresentModeKHR value) { return s << getPresentModeKHRStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPerformanceCounterUnitKHR value) { return s << getPerformanceCounterUnitKHRStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPerformanceCounterScopeKHR value) { return s << getPerformanceCounterScopeKHRStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPerformanceCounterStorageKHR value) { return s << getPerformanceCounterStorageKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkDriverIdKHR value) { return s << getDriverIdKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkShaderFloatControlsIndependenceKHR value) { return s << getShaderFloatControlsIndependenceKHRStr(value); }
inline std::ostream& operator<< (std::ostream& s, VkSemaphoreTypeKHR value) { return s << getSemaphoreTypeKHRStr(value); }
tcu::Format::Bitfield<32> getSwapchainCreateFlagsKHRStr (VkSwapchainCreateFlagsKHR value);
tcu::Format::Bitfield<32> getDeviceGroupPresentModeFlagsKHRStr (VkDeviceGroupPresentModeFlagsKHR value);
tcu::Format::Bitfield<32> getDisplayPlaneAlphaFlagsKHRStr (VkDisplayPlaneAlphaFlagsKHR value);
+tcu::Format::Bitfield<32> getPerformanceCounterDescriptionFlagsKHRStr (VkPerformanceCounterDescriptionFlagsKHR value);
+tcu::Format::Bitfield<32> getAcquireProfilingLockFlagsKHRStr (VkAcquireProfilingLockFlagsKHR value);
tcu::Format::Bitfield<32> getResolveModeFlagsKHRStr (VkResolveModeFlagsKHR value);
tcu::Format::Bitfield<32> getSemaphoreWaitFlagsKHRStr (VkSemaphoreWaitFlagsKHR value);
tcu::Format::Bitfield<32> getDebugReportFlagsEXTStr (VkDebugReportFlagsEXT value);
std::ostream& operator<< (std::ostream& s, const VkSharedPresentSurfaceCapabilitiesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkImportFenceFdInfoKHR& value);
std::ostream& operator<< (std::ostream& s, const VkFenceGetFdInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePerformanceQueryFeaturesKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePerformanceQueryPropertiesKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPerformanceCounterKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPerformanceCounterDescriptionKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkQueryPoolPerformanceCreateInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPerformanceCounterResultKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkAcquireProfilingLockInfoKHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPerformanceQuerySubmitInfoKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSurfaceInfo2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkSurfaceCapabilities2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkSurfaceFormat2KHR& value);
case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: return "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR";
case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: return "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR";
case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: return "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR";
+ case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: return "VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR";
+ case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: return "VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR";
+ case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: return "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR";
+ case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: return "VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR";
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR";
case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR";
case VK_QUERY_TYPE_PIPELINE_STATISTICS: return "VK_QUERY_TYPE_PIPELINE_STATISTICS";
case VK_QUERY_TYPE_TIMESTAMP: return "VK_QUERY_TYPE_TIMESTAMP";
case VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT: return "VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT";
+ case VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR: return "VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR";
case VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: return "VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV";
case VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL: return "VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL";
case VK_QUERY_TYPE_MAX_ENUM: return "VK_QUERY_TYPE_MAX_ENUM";
}
}
+const char* getPerformanceCounterUnitKHRName (VkPerformanceCounterUnitKHR value)
+{
+ switch (value)
+ {
+ case VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR";
+ case VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR: return "VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR";
+ default: return DE_NULL;
+ }
+}
+
+const char* getPerformanceCounterScopeKHRName (VkPerformanceCounterScopeKHR value)
+{
+ switch (value)
+ {
+ case VK_QUERY_SCOPE_COMMAND_BUFFER_KHR: return "VK_QUERY_SCOPE_COMMAND_BUFFER_KHR";
+ case VK_QUERY_SCOPE_RENDER_PASS_KHR: return "VK_QUERY_SCOPE_RENDER_PASS_KHR";
+ case VK_QUERY_SCOPE_COMMAND_KHR: return "VK_QUERY_SCOPE_COMMAND_KHR";
+ case VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR: return "VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR";
+ default: return DE_NULL;
+ }
+}
+
+const char* getPerformanceCounterStorageKHRName (VkPerformanceCounterStorageKHR value)
+{
+ switch (value)
+ {
+ case VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR: return "VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR";
+ case VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR: return "VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR";
+ case VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR: return "VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR";
+ case VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR: return "VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR";
+ case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR: return "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR";
+ case VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR: return "VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR";
+ case VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR: return "VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR";
+ default: return DE_NULL;
+ }
+}
+
const char* getDriverIdKHRName (VkDriverIdKHR value)
{
switch (value)
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
+tcu::Format::Bitfield<32> getPerformanceCounterDescriptionFlagsKHRStr (VkPerformanceCounterDescriptionFlagsKHR value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR, "VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR"),
+ tcu::Format::BitDesc(VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR, "VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR"),
+ tcu::Format::BitDesc(VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR, "VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getAcquireProfilingLockFlagsKHRStr (VkAcquireProfilingLockFlagsKHR value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR, "VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
tcu::Format::Bitfield<32> getResolveModeFlagsKHRStr (VkResolveModeFlagsKHR value)
{
static const tcu::Format::BitDesc s_desc[] =
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePerformanceQueryFeaturesKHR& value)
+{
+ s << "VkPhysicalDevicePerformanceQueryFeaturesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tperformanceCounterQueryPools = " << value.performanceCounterQueryPools << '\n';
+ s << "\tperformanceCounterMultipleQueryPools = " << value.performanceCounterMultipleQueryPools << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePerformanceQueryPropertiesKHR& value)
+{
+ s << "VkPhysicalDevicePerformanceQueryPropertiesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tallowCommandBufferQueryCopies = " << value.allowCommandBufferQueryCopies << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPerformanceCounterKHR& value)
+{
+ s << "VkPerformanceCounterKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tunit = " << value.unit << '\n';
+ s << "\tscope = " << value.scope << '\n';
+ s << "\tstorage = " << value.storage << '\n';
+ s << "\tuuid = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.uuid)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.uuid))) << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPerformanceCounterDescriptionKHR& value)
+{
+ s << "VkPerformanceCounterDescriptionKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tflags = " << getPerformanceCounterDescriptionFlagsKHRStr(value.flags) << '\n';
+ s << "\tname = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<char>(DE_ARRAY_BEGIN(value.name)), tcu::Format::HexIterator<char>(DE_ARRAY_END(value.name))) << '\n';
+ s << "\tcategory = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<char>(DE_ARRAY_BEGIN(value.category)), tcu::Format::HexIterator<char>(DE_ARRAY_END(value.category))) << '\n';
+ s << "\tdescription = " << (const char*)value.description << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkQueryPoolPerformanceCreateInfoKHR& value)
+{
+ s << "VkQueryPoolPerformanceCreateInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tqueueFamilyIndex = " << value.queueFamilyIndex << '\n';
+ s << "\tcounterIndexCount = " << value.counterIndexCount << '\n';
+ s << "\tpCounterIndices = " << value.pCounterIndices << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPerformanceCounterResultKHR& value)
+{
+ s << "VkPerformanceCounterResultKHR = {\n";
+ s << "\tint32 = " << value.int32 << '\n';
+ s << "\tint64 = " << value.int64 << '\n';
+ s << "\tuint32 = " << value.uint32 << '\n';
+ s << "\tuint64 = " << value.uint64 << '\n';
+ s << "\tfloat32 = " << value.float32 << '\n';
+ s << "\tfloat64 = " << value.float64 << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkAcquireProfilingLockInfoKHR& value)
+{
+ s << "VkAcquireProfilingLockInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tflags = " << getAcquireProfilingLockFlagsKHRStr(value.flags) << '\n';
+ s << "\ttimeout = " << value.timeout << '\n';
+ s << '}';
+ return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPerformanceQuerySubmitInfoKHR& value)
+{
+ s << "VkPerformanceQuerySubmitInfoKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tcounterPassIndex = " << value.counterPassIndex << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSurfaceInfo2KHR& value)
{
s << "VkPhysicalDeviceSurfaceInfo2KHR = {\n";
VkExternalFenceHandleTypeFlagBits handleType;
};
+struct VkPhysicalDevicePerformanceQueryFeaturesKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 performanceCounterQueryPools;
+ VkBool32 performanceCounterMultipleQueryPools;
+};
+
+struct VkPhysicalDevicePerformanceQueryPropertiesKHR
+{
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 allowCommandBufferQueryCopies;
+};
+
+struct VkPerformanceCounterKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPerformanceCounterUnitKHR unit;
+ VkPerformanceCounterScopeKHR scope;
+ VkPerformanceCounterStorageKHR storage;
+ deUint8 uuid[VK_UUID_SIZE];
+};
+
+struct VkPerformanceCounterDescriptionKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkPerformanceCounterDescriptionFlagsKHR flags;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char category[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+};
+
+struct VkQueryPoolPerformanceCreateInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 queueFamilyIndex;
+ deUint32 counterIndexCount;
+ const deUint32* pCounterIndices;
+};
+
+union VkPerformanceCounterResultKHR
+{
+ deInt32 int32;
+ deInt64 int64;
+ deUint32 uint32;
+ deUint64 uint64;
+ float float32;
+ double float64;
+};
+
+struct VkAcquireProfilingLockInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkAcquireProfilingLockFlagsKHR flags;
+ deUint64 timeout;
+};
+
+struct VkPerformanceQuerySubmitInfoKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 counterPassIndex;
+};
+
struct VkPhysicalDeviceSurfaceInfo2KHR
{
VkStructureType sType;
virtual VkResult getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const = 0;
virtual VkResult importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const = 0;
virtual VkResult getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const = 0;
+virtual VkResult acquireProfilingLockKHR (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) const = 0;
+virtual void releaseProfilingLockKHR (VkDevice device) const = 0;
virtual void cmdDrawIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const = 0;
virtual void cmdDrawIndexedIndirectCountKHR (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, deUint32 maxDrawCount, deUint32 stride) const = 0;
virtual VkResult getSemaphoreCounterValueKHR (VkDevice device, VkSemaphore semaphore, deUint64* pValue) const = 0;
virtual VkResult createDisplayModeKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) const = 0;
virtual VkResult getDisplayPlaneCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, deUint32 planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) const = 0;
virtual VkResult createDisplayPlaneSurfaceKHR (VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const = 0;
+virtual void enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, deUint32* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) const = 0;
+virtual void getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR (VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, deUint32* pNumPasses) const = 0;
virtual VkResult getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const = 0;
virtual VkResult getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const = 0;
virtual VkResult getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties) const = 0;
VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,
+ VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,
+ VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,
+ VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,
+ VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005,
+ VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
VK_QUERY_TYPE_TIMESTAMP = 2,
VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
+ VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
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"
+
+typedef enum VkPerformanceCounterUnitKHR {
+ VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
+ VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
+ VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
+ VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
+ VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
+ VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
+ VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
+ VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
+ VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
+ VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
+ VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
+ VK_PERFORMANCE_COUNTER_UNIT_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR,
+ VK_PERFORMANCE_COUNTER_UNIT_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR,
+ VK_PERFORMANCE_COUNTER_UNIT_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR - VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR + 1),
+ VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterUnitKHR;
+
+typedef enum VkPerformanceCounterScopeKHR {
+ VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = 0,
+ VK_QUERY_SCOPE_RENDER_PASS_KHR = 1,
+ VK_QUERY_SCOPE_COMMAND_KHR = 2,
+ VK_PERFORMANCE_COUNTER_SCOPE_BEGIN_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR,
+ VK_PERFORMANCE_COUNTER_SCOPE_END_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_KHR,
+ VK_PERFORMANCE_COUNTER_SCOPE_RANGE_SIZE_KHR = (VK_QUERY_SCOPE_COMMAND_KHR - VK_QUERY_SCOPE_COMMAND_BUFFER_KHR + 1),
+ VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterScopeKHR;
+
+typedef enum VkPerformanceCounterStorageKHR {
+ VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
+ VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
+ VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
+ VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
+ VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
+ VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
+ VK_PERFORMANCE_COUNTER_STORAGE_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR,
+ VK_PERFORMANCE_COUNTER_STORAGE_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR,
+ VK_PERFORMANCE_COUNTER_STORAGE_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR - VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR + 1),
+ VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterStorageKHR;
+
+typedef enum VkPerformanceCounterDescriptionFlagBitsKHR {
+ VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 0x00000001,
+ VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 0x00000002,
+ VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterDescriptionFlagBitsKHR;
+typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
+
+typedef enum VkAcquireProfilingLockFlagBitsKHR {
+ VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkAcquireProfilingLockFlagBitsKHR;
+typedef VkFlags VkAcquireProfilingLockFlagsKHR;
+typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 performanceCounterQueryPools;
+ VkBool32 performanceCounterMultipleQueryPools;
+} VkPhysicalDevicePerformanceQueryFeaturesKHR;
+
+typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 allowCommandBufferQueryCopies;
+} VkPhysicalDevicePerformanceQueryPropertiesKHR;
+
+typedef struct VkPerformanceCounterKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPerformanceCounterUnitKHR unit;
+ VkPerformanceCounterScopeKHR scope;
+ VkPerformanceCounterStorageKHR storage;
+ deUint8 uuid[VK_UUID_SIZE];
+} VkPerformanceCounterKHR;
+
+typedef struct VkPerformanceCounterDescriptionKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPerformanceCounterDescriptionFlagsKHR flags;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char category[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+} VkPerformanceCounterDescriptionKHR;
+
+typedef struct VkQueryPoolPerformanceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 queueFamilyIndex;
+ deUint32 counterIndexCount;
+ const deUint32* pCounterIndices;
+} VkQueryPoolPerformanceCreateInfoKHR;
+
+typedef union VkPerformanceCounterResultKHR {
+ deInt32 int32;
+ deInt64 int64;
+ deUint32 uint32;
+ deUint64 uint64;
+ float float32;
+ double float64;
+} VkPerformanceCounterResultKHR;
+
+typedef struct VkAcquireProfilingLockInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkAcquireProfilingLockFlagsKHR flags;
+ deUint64 timeout;
+} VkAcquireProfilingLockInfoKHR;
+
+typedef struct VkPerformanceQuerySubmitInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 counterPassIndex;
+} VkPerformanceQuerySubmitInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex, deUint32* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, deUint32* pNumPasses);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);
+typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+ VkPhysicalDevice physicalDevice,
+ deUint32 queueFamilyIndex,
+ deUint32* pCounterCount,
+ VkPerformanceCounterKHR* pCounters,
+ VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
+ deUint32* pNumPasses);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(
+ VkDevice device,
+ const VkAcquireProfilingLockInfoKHR* pInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(
+ VkDevice device);
+#endif
+
#define VK_KHR_maintenance2 1
#define VK_KHR_MAINTENANCE2_SPEC_VERSION 1
const bool khr_8bit_storage = checkExtension(properties,"VK_KHR_8bit_storage");
const bool ext_conditional_rendering = checkExtension(properties,"VK_EXT_conditional_rendering");
const bool scalar_block_layout = checkExtension(properties,"VK_EXT_scalar_block_layout");
+ const bool khr_performance_counter = checkExtension(properties,"VK_KHR_performance_query");
bool khr_16bit_storage = true;
bool khr_multiview = true;
bool deviceProtectedMemory = true;
VkPhysicalDeviceVariablePointersFeatures variablePointerFeatures[count];
VkPhysicalDeviceScalarBlockLayoutFeaturesEXT scalarBlockLayoutFeatures[count];
VkPhysicalDeviceTimelineSemaphoreFeaturesKHR timelineSemaphoreFeatures[count];
-
+ VkPhysicalDevicePerformanceQueryFeaturesKHR performanceQueryFeatures[count];
for (int ndx = 0; ndx < count; ++ndx)
{
deMemset(&samplerYcbcrConversionFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures));
deMemset(&variablePointerFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceVariablePointersFeatures));
deMemset(&scalarBlockLayoutFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDeviceScalarBlockLayoutFeaturesEXT));
+ deMemset(&performanceQueryFeatures[ndx], 0xFF*ndx, sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR));
device8BitStorageFeatures[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR;
device8BitStorageFeatures[ndx].pNext = &deviceConditionalRenderingFeatures[ndx];
scalarBlockLayoutFeatures[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT;
scalarBlockLayoutFeatures[ndx].pNext = &timelineSemaphoreFeatures[ndx];
- timelineSemaphoreFeatures[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR;
- timelineSemaphoreFeatures[ndx].pNext = DE_NULL;
+ timelineSemaphoreFeatures[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR;
+ timelineSemaphoreFeatures[ndx].pNext = &performanceQueryFeatures[ndx];
+
+ performanceQueryFeatures[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+ performanceQueryFeatures[ndx].pNext = DE_NULL;
deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features));
extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
{
TCU_FAIL("Mismatch between VkPhysicalDeviceConditionalRenderingFeaturesEXT");
}
+ if ( khr_performance_counter &&
+ ( performanceQueryFeatures[0].performanceCounterQueryPools != performanceQueryFeatures[1].performanceCounterQueryPools ||
+ performanceQueryFeatures[0].performanceCounterMultipleQueryPools != performanceQueryFeatures[1].performanceCounterMultipleQueryPools ))
+ {
+ TCU_FAIL("Mismatch between VkPhysicalDevicePerformancQueryFeaturesKHR");
+ }
if ( khr_16bit_storage &&
(device16BitStorageFeatures[0].storageBuffer16BitAccess != device16BitStorageFeatures[1].storageBuffer16BitAccess ||
{
TCU_FAIL("Mismatch between VkPhysicalDeviceScalarBlockLayoutFeaturesEXT");
}
+
if (khr_8bit_storage)
log << TestLog::Message << device8BitStorageFeatures[0] << TestLog::EndMessage;
if (ext_conditional_rendering)
log << TestLog::Message << variablePointerFeatures[0] << TestLog::EndMessage;
if (scalar_block_layout)
log << TestLog::Message << scalarBlockLayoutFeatures[0] << TestLog::EndMessage;
+ if (khr_performance_counter)
+ log << TestLog::Message << performanceQueryFeatures[0] << TestLog::EndMessage;
return tcu::TestStatus::pass("Querying device features succeeded");
}
-
tcu::TestStatus deviceProperties2 (Context& context)
{
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
pciBusInfoProperties[0].pciDevice == DEUINT32_MAX ||
pciBusInfoProperties[0].pciFunction == DEUINT32_MAX)
{
- TCU_FAIL("Invalid information in VkPhysicalDevicePCIBusInfoPropertiesEXT");
+ TCU_FAIL("Invalid information in VkPhysicalDevicePCIBusInfoPropertiesEXT");
+ }
+ }
+ if (isExtensionSupported(extensions, RequiredExtension("VK_KHR_performance_query")))
+ {
+ VkPhysicalDevicePerformanceQueryPropertiesKHR performanceQueryProperties[count];
+
+ for (int ndx = 0; ndx < count; ++ndx)
+ {
+ deMemset(&performanceQueryProperties[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR));
+ performanceQueryProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
+ performanceQueryProperties[ndx].pNext = DE_NULL;
+
+ extProperties.pNext = &performanceQueryProperties[ndx];
+
+ vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
+ }
+
+ log << TestLog::Message << performanceQueryProperties[0] << TestLog::EndMessage;
+
+ if (performanceQueryProperties[0].allowCommandBufferQueryCopies != performanceQueryProperties[0].allowCommandBufferQueryCopies)
+ {
+ TCU_FAIL("Mismatch between VkPhysicalDevicePerformanceQueryPropertiesKHR");
}
}
vktQueryPoolTests.cpp
vktQueryPoolOcclusionTests.hpp
vktQueryPoolOcclusionTests.cpp
+ vktQueryPoolPerformanceTests.hpp
+ vktQueryPoolPerformanceTests.cpp
vktQueryPoolStatisticsTests.hpp
vktQueryPoolStatisticsTests.cpp
)
--- /dev/null
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan Performance Query Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktQueryPoolPerformanceTests.hpp"
+#include "vktTestCase.hpp"
+
+#include "vktDrawImageObjectUtil.hpp"
+#include "vktDrawBufferObjectUtil.hpp"
+#include "vktDrawCreateInfoUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkRefUtil.hpp"
+#include "vkPrograms.hpp"
+#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
+#include "vkQueryUtil.hpp"
+
+#include "deMath.h"
+
+#include "tcuTestLog.hpp"
+#include "tcuResource.hpp"
+#include "tcuImageCompare.hpp"
+#include "vkImageUtil.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuRGBA.hpp"
+
+namespace vkt
+{
+namespace QueryPool
+{
+namespace
+{
+
+using namespace vk;
+using namespace Draw;
+
+std::string uuidToHex(const deUint8 uuid[])
+{
+ const size_t bytesPerPart[] = {4, 2, 2, 2, 6};
+ const deUint8* ptr = &uuid[0];
+ const size_t stringSize = VK_UUID_SIZE * 2 + DE_LENGTH_OF_ARRAY(bytesPerPart) - 1;
+ std::string result;
+
+ result.reserve(stringSize);
+
+ for (size_t partNdx = 0; partNdx < DE_LENGTH_OF_ARRAY(bytesPerPart); ++partNdx)
+ {
+ const size_t bytesInPart = bytesPerPart[partNdx];
+ const size_t symbolsInPart = 2 * bytesInPart;
+ deUint64 part = 0;
+ std::string partString;
+
+ for (size_t byteInPartNdx = 0; byteInPartNdx < bytesInPart; ++byteInPartNdx)
+ {
+ part = (part << 8) | *ptr;
+ ++ptr;
+ }
+
+ partString = tcu::toHex(part).toString();
+
+ DE_ASSERT(partString.size() > symbolsInPart);
+
+ result += (symbolsInPart >= partString.size()) ? partString : partString.substr(partString.size() - symbolsInPart);
+
+ if (partNdx + 1 != DE_LENGTH_OF_ARRAY(bytesPerPart))
+ result += '-';
+ }
+
+ DE_ASSERT(ptr == &uuid[VK_UUID_SIZE]);
+ DE_ASSERT(result.size() == stringSize);
+
+ return result;
+}
+
+class EnumerateAndValidateTest : public TestInstance
+{
+public:
+ EnumerateAndValidateTest (vkt::Context& context, VkQueueFlagBits queueFlagBits);
+ tcu::TestStatus iterate (void);
+
+protected:
+ void basicValidateCounter (const deUint32 familyIndex);
+
+private:
+ VkQueueFlagBits m_queueFlagBits;
+ bool m_requiredExtensionsPresent;
+};
+
+EnumerateAndValidateTest::EnumerateAndValidateTest (vkt::Context& context, VkQueueFlagBits queueFlagBits)
+ : TestInstance(context)
+ , m_queueFlagBits(queueFlagBits)
+ , m_requiredExtensionsPresent(context.requireDeviceFunctionality("VK_KHR_performance_query"))
+{
+}
+
+tcu::TestStatus EnumerateAndValidateTest::iterate (void)
+{
+ const InstanceInterface& vki = m_context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
+ const std::vector<VkQueueFamilyProperties> queueProperties = getPhysicalDeviceQueueFamilyProperties(vki, physicalDevice);
+
+ for (deUint32 queueNdx = 0; queueNdx < queueProperties.size(); queueNdx++)
+ {
+ if ((queueProperties[queueNdx].queueFlags & m_queueFlagBits) == 0)
+ continue;
+
+ deUint32 counterCount = 0;
+ vki.enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueNdx, &counterCount, DE_NULL, DE_NULL);
+ if (counterCount == 0)
+ continue;
+
+ {
+ std::vector<VkPerformanceCounterKHR> counters (counterCount);
+ deUint32 counterCountRead = counterCount;
+ std::map<std::string, size_t> uuidValidator;
+
+ vki.enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueNdx, &counterCountRead, &counters[0], DE_NULL);
+
+ if (counterCountRead != counterCount)
+ TCU_FAIL("Number of counters read (" + de::toString(counterCountRead) + ") is not equal to number of counters reported (" + de::toString(counterCount) + ")");
+
+ for (size_t counterNdx = 0; counterNdx < counters.size(); ++counterNdx)
+ {
+ const VkPerformanceCounterKHR& counter = counters[counterNdx];
+ const std::string uuidStr = uuidToHex(counter.uuid);
+
+ if (uuidValidator.find(uuidStr) != uuidValidator.end())
+ TCU_FAIL("Duplicate counter UUID detected " + uuidStr);
+ else
+ uuidValidator[uuidStr] = counterNdx;
+
+ if (counter.scope >= VK_PERFORMANCE_COUNTER_SCOPE_KHR_LAST)
+ TCU_FAIL("Counter scope is invalid " + de::toString(static_cast<size_t>(counter.scope)));
+
+ if (counter.storage >= VK_PERFORMANCE_COUNTER_STORAGE_KHR_LAST)
+ TCU_FAIL("Counter storage is invalid " + de::toString(static_cast<size_t>(counter.storage)));
+
+ if (counter.unit >= VK_PERFORMANCE_COUNTER_UNIT_KHR_LAST)
+ TCU_FAIL("Counter unit is invalid " + de::toString(static_cast<size_t>(counter.unit)));
+ }
+ }
+ {
+ std::vector<VkPerformanceCounterDescriptionKHR> counterDescriptors (counterCount);
+ deUint32 counterCountRead = counterCount;
+
+ vki.enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueNdx, &counterCountRead, DE_NULL, &counterDescriptors[0]);
+
+ if (counterCountRead != counterCount)
+ TCU_FAIL("Number of counters read (" + de::toString(counterCountRead) + ") is not equal to number of counters reported (" + de::toString(counterCount) + ")");
+
+ for (size_t counterNdx = 0; counterNdx < counterDescriptors.size(); ++counterNdx)
+ {
+ const VkPerformanceCounterDescriptionKHR& counterDescriptor = counterDescriptors[counterNdx];
+ const VkPerformanceCounterDescriptionFlagsKHR allowedFlags = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR
+ | VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR;
+
+ if ((counterDescriptor.flags & ~allowedFlags) != 0)
+ TCU_FAIL("Invalid flags present in VkPerformanceCounterDescriptionFlagsKHR");
+ }
+ }
+ }
+
+ return tcu::TestStatus::pass("Pass");
+}
+
+class QueryTestBase : public TestInstance
+{
+public:
+ QueryTestBase (vkt::Context& context);
+
+protected:
+
+ void setupCounters (void);
+ Move<VkQueryPool> createQueryPool (deUint32 enabledCounterOffset, deUint32 enabledCounterStride);
+ bool acquireProfilingLock (void);
+ void releaseProfilingLock (void);
+ bool verifyQueryResults (VkQueryPool queryPool);
+ deUint32 getRequiredNumerOfPasses(void);
+
+private:
+
+ bool m_requiredExtensionsPresent;
+ deUint32 m_requiredNumerOfPasses;
+ std::map<deUint64, deUint32> m_enabledCountersCountMap; // number of counters that were enabled per query pool
+ std::vector<VkPerformanceCounterKHR> m_counters; // counters provided by the device
+};
+
+QueryTestBase::QueryTestBase(vkt::Context& context)
+ : TestInstance (context)
+ , m_requiredExtensionsPresent(context.requireDeviceFunctionality("VK_KHR_performance_query"))
+ , m_requiredNumerOfPasses(0)
+{
+}
+
+void QueryTestBase::setupCounters()
+{
+ const InstanceInterface& vki = m_context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
+ const CmdPoolCreateInfo cmdPoolCreateInfo = m_context.getUniversalQueueFamilyIndex();
+ deUint32 queueFamilyIndex = cmdPoolCreateInfo.queueFamilyIndex;
+ deUint32 counterCount;
+
+ if (!m_context.getPerformanceQueryFeatures().performanceCounterQueryPools)
+ TCU_THROW(NotSupportedError, "Performance counter query pools feature not supported");
+
+ // get the number of supported counters
+ vki.enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, &counterCount, NULL, NULL);
+ if (!counterCount)
+ TCU_THROW(NotSupportedError, "QualityWarning: there are no performance counters");
+
+ // get supported counters
+ m_counters.resize(counterCount);
+ vki.enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, &counterCount, &m_counters[0], DE_NULL);
+}
+
+Move<VkQueryPool> QueryTestBase::createQueryPool(deUint32 enabledCounterOffset, deUint32 enabledCounterStride)
+{
+ const InstanceInterface& vki = m_context.getInstanceInterface();
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
+ const VkDevice device = m_context.getDevice();
+ const CmdPoolCreateInfo cmdPoolCreateInfo = m_context.getUniversalQueueFamilyIndex();
+ const deUint32 counterCount = (deUint32)m_counters.size();
+ deUint32 enabledIndex = enabledCounterOffset ? 0 : enabledCounterStride;
+ std::vector<deUint32> enabledCounters;
+
+ // enable every <enabledCounterStride> counter that has command or render pass scope
+ for (deUint32 i = 0; i < counterCount; i++)
+ {
+ // skip counters with command buffer scope
+ if (m_counters[i].scope == VK_QUERY_SCOPE_COMMAND_BUFFER_KHR)
+ continue;
+
+ // handle offset
+ if (enabledCounterOffset)
+ {
+ if (enabledCounterOffset == enabledIndex)
+ {
+ // disable handling offset
+ enabledCounterOffset = 0;
+
+ // eneble next index in stride condition
+ enabledIndex = enabledCounterStride;
+ }
+ else
+ {
+ ++enabledIndex;
+ continue;
+ }
+ }
+
+ // handle stride
+ if (enabledIndex == enabledCounterStride)
+ {
+ enabledCounters.push_back(i);
+ enabledIndex = 0;
+ }
+ else
+ ++enabledIndex;
+ }
+
+ // get number of counters that were enabled for this query pool
+ deUint32 enabledCountersCount = static_cast<deUint32>(enabledCounters.size());
+ if (!enabledCountersCount)
+ TCU_THROW(NotSupportedError, "QualityWarning: no performance counters");
+
+ // define performance query
+ VkQueryPoolPerformanceCreateInfoKHR performanceQueryCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
+ NULL,
+ cmdPoolCreateInfo.queueFamilyIndex, // queue family that this performance query is performed on
+ enabledCountersCount, // number of counters to enable
+ &enabledCounters[0] // array of indices of counters to enable
+ };
+
+ // get the number of passes counters will require
+ vki.getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, &performanceQueryCreateInfo, &m_requiredNumerOfPasses);
+
+ // create query pool
+ VkQueryPoolCreateInfo queryPoolCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
+ &performanceQueryCreateInfo,
+ 0, // flags
+ VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, // new query type
+ 1, // queryCount
+ 0
+ };
+
+ Move<VkQueryPool> queryPool = vk::createQueryPool(vkd, device, &queryPoolCreateInfo);
+
+ // memorize number of enabled counters for this query pool
+ m_enabledCountersCountMap[queryPool.get().getInternal()] = enabledCountersCount;
+
+ return queryPool;
+}
+
+bool QueryTestBase::acquireProfilingLock()
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+
+ // acquire profiling lock before we record command buffers
+ VkAcquireProfilingLockInfoKHR lockInfo =
+ {
+ VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR,
+ NULL,
+ 0,
+ 2000000000ull // wait 2s for the lock
+ };
+
+ VkResult result = vkd.acquireProfilingLockKHR(device, &lockInfo);
+ if (result == VK_TIMEOUT)
+ {
+ m_context.getTestContext().getLog() << tcu::TestLog::Message
+ << "Timeout reached, profiling lock wasn't acquired - test had to end earlier"
+ << tcu::TestLog::EndMessage;
+ return false;
+ }
+ if (result != VK_SUCCESS)
+ TCU_FAIL("Profiling lock wasn't acquired");
+
+ return true;
+}
+
+void QueryTestBase::releaseProfilingLock()
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+
+ // release the profiling lock after the command buffer is no longer in the pending state
+ vkd.releaseProfilingLockKHR(device);
+}
+
+bool QueryTestBase::verifyQueryResults(VkQueryPool queryPool)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+
+ // create an array to hold the results of all counters
+ deUint32 enabledCounterCount = m_enabledCountersCountMap[queryPool.getInternal()];
+ std::vector<VkPerformanceCounterResultKHR> recordedCounters(enabledCounterCount);
+
+ // verify that query result can be retrieved
+ VkResult result = vkd.getQueryPoolResults(device, queryPool, 0, 1, sizeof(VkPerformanceCounterResultKHR) * enabledCounterCount,
+ &recordedCounters[0], sizeof(VkPerformanceCounterResultKHR), VK_QUERY_RESULT_WAIT_BIT);
+ if (result == VK_NOT_READY)
+ {
+ m_context.getTestContext().getLog() << tcu::TestLog::Message
+ << "Pass but result is not ready"
+ << tcu::TestLog::EndMessage;
+ return true;
+ }
+ return (result == VK_SUCCESS);
+}
+
+deUint32 QueryTestBase::getRequiredNumerOfPasses()
+{
+ return m_requiredNumerOfPasses;
+}
+
+// Base class for all graphic tests
+class GraphicQueryTestBase : public QueryTestBase
+{
+public:
+ GraphicQueryTestBase(vkt::Context& context);
+
+protected:
+ void initStateObjects(void);
+
+protected:
+ Move<VkPipeline> m_pipeline;
+ Move<VkPipelineLayout> m_pipelineLayout;
+
+ de::SharedPtr<Image> m_colorAttachmentImage;
+ Move<VkImageView> m_attachmentView;
+
+ Move<VkRenderPass> m_renderPass;
+ Move<VkFramebuffer> m_framebuffer;
+
+ de::SharedPtr<Buffer> m_vertexBuffer;
+
+ VkFormat m_colorAttachmentFormat;
+ deUint32 m_size;
+};
+
+GraphicQueryTestBase::GraphicQueryTestBase(vkt::Context& context)
+ : QueryTestBase(context)
+ , m_colorAttachmentFormat(VK_FORMAT_R8G8B8A8_UNORM)
+ , m_size(32)
+{
+}
+
+void GraphicQueryTestBase::initStateObjects(void)
+{
+ const VkDevice device = m_context.getDevice();
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+
+ //attachment images and views
+ {
+ VkExtent3D imageExtent =
+ {
+ m_size, // width
+ m_size, // height
+ 1 // depth
+ };
+
+ const ImageCreateInfo colorImageCreateInfo(VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, imageExtent, 1, 1,
+ VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL,
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
+
+ m_colorAttachmentImage = Image::createAndAlloc(vkd, device, colorImageCreateInfo, m_context.getDefaultAllocator(),
+ m_context.getUniversalQueueFamilyIndex());
+
+ const ImageViewCreateInfo attachmentViewInfo(m_colorAttachmentImage->object(), VK_IMAGE_VIEW_TYPE_2D, m_colorAttachmentFormat);
+ m_attachmentView = createImageView(vkd, device, &attachmentViewInfo);
+ }
+
+ // renderpass and framebuffer
+ {
+ RenderPassCreateInfo renderPassCreateInfo;
+ renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat, // format
+ VK_SAMPLE_COUNT_1_BIT, // samples
+ VK_ATTACHMENT_LOAD_OP_CLEAR, // loadOp
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // storeOp
+ VK_ATTACHMENT_LOAD_OP_DONT_CARE, // stencilLoadOp
+ VK_ATTACHMENT_STORE_OP_DONT_CARE, // stencilLoadOp
+ VK_IMAGE_LAYOUT_GENERAL, // initialLauout
+ VK_IMAGE_LAYOUT_GENERAL)); // finalLayout
+
+ const VkAttachmentReference colorAttachmentReference =
+ {
+ 0, // attachment
+ VK_IMAGE_LAYOUT_GENERAL // layout
+ };
+
+ renderPassCreateInfo.addSubpass(SubpassDescription(VK_PIPELINE_BIND_POINT_GRAPHICS, // pipelineBindPoint
+ 0, // flags
+ 0, // inputCount
+ DE_NULL, // pInputAttachments
+ 1, // colorCount
+ &colorAttachmentReference, // pColorAttachments
+ DE_NULL, // pResolveAttachments
+ AttachmentReference(), // depthStencilAttachment
+ 0, // preserveCount
+ DE_NULL)); // preserveAttachments
+
+ m_renderPass = createRenderPass(vkd, device, &renderPassCreateInfo);
+
+ std::vector<VkImageView> attachments(1);
+ attachments[0] = *m_attachmentView;
+
+ FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, attachments, m_size, m_size, 1);
+ m_framebuffer = createFramebuffer(vkd, device, &framebufferCreateInfo);
+ }
+
+ // pipeline
+ {
+ Unique<VkShaderModule> vs(createShaderModule(vkd, device, m_context.getBinaryCollection().get("vert"), 0));
+ Unique<VkShaderModule> fs(createShaderModule(vkd, device, m_context.getBinaryCollection().get("frag"), 0));
+
+ const PipelineCreateInfo::ColorBlendState::Attachment attachmentState;
+
+ const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
+ m_pipelineLayout = createPipelineLayout(vkd, device, &pipelineLayoutCreateInfo);
+
+ const VkVertexInputBindingDescription vf_binding_desc =
+ {
+ 0, // binding
+ 4 * (deUint32)sizeof(float), // stride
+ VK_VERTEX_INPUT_RATE_VERTEX // inputRate
+ };
+
+ const VkVertexInputAttributeDescription vf_attribute_desc =
+ {
+ 0, // location
+ 0, // binding
+ VK_FORMAT_R32G32B32A32_SFLOAT, // format
+ 0 // offset
+ };
+
+ const VkPipelineVertexInputStateCreateInfo vf_info =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // sType
+ NULL, // pNext
+ 0u, // flags
+ 1, // vertexBindingDescriptionCount
+ &vf_binding_desc, // pVertexBindingDescriptions
+ 1, // vertexAttributeDescriptionCount
+ &vf_attribute_desc // pVertexAttributeDescriptions
+ };
+
+ PipelineCreateInfo pipelineCreateInfo(*m_pipelineLayout, *m_renderPass, 0, 0);
+ pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", VK_SHADER_STAGE_VERTEX_BIT));
+ pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", VK_SHADER_STAGE_FRAGMENT_BIT));
+ pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST));
+ pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &attachmentState));
+ const VkViewport viewport = makeViewport(m_size, m_size);
+ const VkRect2D scissor = makeRect2D(m_size, m_size);
+ pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1, std::vector<VkViewport>(1, viewport), std::vector<VkRect2D>(1, scissor)));
+ pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState(false, false, VK_COMPARE_OP_GREATER_OR_EQUAL));
+ pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
+ pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState());
+ pipelineCreateInfo.addState(vf_info);
+ m_pipeline = createGraphicsPipeline(vkd, device, DE_NULL, &pipelineCreateInfo);
+ }
+
+ // vertex buffer
+ {
+ std::vector<tcu::Vec4> vertices(3);
+ vertices[0] = tcu::Vec4(0.5, 0.5, 0.0, 1.0);
+ vertices[1] = tcu::Vec4(0.5, 0.0, 0.0, 1.0);
+ vertices[2] = tcu::Vec4(0.0, 0.5, 0.0, 1.0);
+
+ const size_t kBufferSize = vertices.size() * sizeof(tcu::Vec4);
+ m_vertexBuffer = Buffer::createAndAlloc(vkd, device, BufferCreateInfo(kBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
+
+ tcu::Vec4 *ptr = reinterpret_cast<tcu::Vec4*>(m_vertexBuffer->getBoundMemory().getHostPtr());
+ deMemcpy(ptr, &vertices[0], kBufferSize);
+
+ flushMappedMemoryRange(vkd, device, m_vertexBuffer->getBoundMemory().getMemory(), m_vertexBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
+ }
+}
+
+
+class GraphicQueryTest : public GraphicQueryTestBase
+{
+public:
+ GraphicQueryTest (vkt::Context& context);
+ tcu::TestStatus iterate (void);
+};
+
+GraphicQueryTest::GraphicQueryTest(vkt::Context& context)
+ : GraphicQueryTestBase(context)
+{
+}
+
+tcu::TestStatus GraphicQueryTest::iterate(void)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkQueue queue = m_context.getUniversalQueue();
+ const CmdPoolCreateInfo cmdPoolCreateInfo = m_context.getUniversalQueueFamilyIndex();
+ Unique<VkCommandPool> cmdPool (createCommandPool(vkd, device, &cmdPoolCreateInfo));
+ Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+
+ initStateObjects();
+ setupCounters();
+
+ vk::Unique<VkQueryPool> queryPool(createQueryPool(0, 1));
+
+ if (!acquireProfilingLock())
+ {
+ // lock was not acquired in given time, we can't fail the test
+ return tcu::TestStatus::pass("Pass");
+ }
+
+ // begin command buffer
+ const VkCommandBufferBeginInfo commandBufBeginParams =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ DE_NULL,
+ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+ VK_CHECK(vkd.beginCommandBuffer(*cmdBuffer, &commandBufBeginParams));
+
+ initialTransitionColor2DImage(vkd, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_GENERAL,
+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
+
+ // begin render pass
+ VkClearValue renderPassClearValue;
+ deMemset(&renderPassClearValue, 0, sizeof(VkClearValue));
+
+ // reset query pool
+ vkd.cmdResetQueryPool(*cmdBuffer, *queryPool, 0, 1);
+
+ // perform query during triangle draw
+ vkd.cmdBeginQuery(*cmdBuffer, *queryPool, 0, VK_QUERY_CONTROL_PRECISE_BIT);
+
+ beginRenderPass(vkd, *cmdBuffer, *m_renderPass, *m_framebuffer,
+ makeRect2D(0, 0, m_size, m_size),
+ 1, &renderPassClearValue);
+
+ // bind pipeline
+ vkd.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
+
+ // bind vertex buffer
+ VkBuffer vertexBuffer = m_vertexBuffer->object();
+ const VkDeviceSize vertexBufferOffset = 0;
+ vkd.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
+
+ vkd.cmdDraw(*cmdBuffer, 3, 1, 0, 0);
+
+ endRenderPass(vkd, *cmdBuffer);
+
+ vkd.cmdEndQuery(*cmdBuffer, *queryPool, 0);
+
+ transition2DImage(vkd, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT,
+ VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+ VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
+
+ endCommandBuffer(vkd, *cmdBuffer);
+
+ // submit command buffer for each pass and wait for its completion
+ for (deUint32 passIndex = 0; passIndex < getRequiredNumerOfPasses(); passIndex++)
+ {
+ const Unique<VkFence> fence(createFence(vkd, device));
+
+ VkPerformanceQuerySubmitInfoKHR performanceQuerySubmitInfo =
+ {
+ VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
+ NULL,
+ passIndex
+ };
+
+ const VkSubmitInfo submitInfo =
+ {
+ VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
+ &performanceQuerySubmitInfo, // pNext
+ 0u, // waitSemaphoreCount
+ DE_NULL, // pWaitSemaphores
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
+ 1u, // commandBufferCount
+ &cmdBuffer.get(), // pCommandBuffers
+ 0u, // signalSemaphoreCount
+ DE_NULL, // pSignalSemaphores
+ };
+
+ VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
+ VK_CHECK(vkd.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
+ }
+
+ releaseProfilingLock();
+
+ VK_CHECK(vkd.resetCommandBuffer(*cmdBuffer, 0));
+
+ if (verifyQueryResults(*queryPool))
+ return tcu::TestStatus::pass("Pass");
+ return tcu::TestStatus::fail("Fail");
+}
+
+class GraphicMultiplePoolsTest : public GraphicQueryTestBase
+{
+public:
+ GraphicMultiplePoolsTest (vkt::Context& context);
+ tcu::TestStatus iterate (void);
+};
+
+GraphicMultiplePoolsTest::GraphicMultiplePoolsTest(vkt::Context& context)
+ : GraphicQueryTestBase(context)
+{
+}
+
+tcu::TestStatus GraphicMultiplePoolsTest::iterate(void)
+{
+ if (!m_context.getPerformanceQueryFeatures().performanceCounterMultipleQueryPools)
+ throw tcu::NotSupportedError("MultipleQueryPools not supported");
+
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkQueue queue = m_context.getUniversalQueue();
+ const CmdPoolCreateInfo cmdPoolCreateInfo = m_context.getUniversalQueueFamilyIndex();
+ Unique<VkCommandPool> cmdPool (createCommandPool(vkd, device, &cmdPoolCreateInfo));
+ Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+
+ initStateObjects();
+ setupCounters();
+
+ vk::Unique<VkQueryPool> queryPool1(createQueryPool(0, 2)),
+ queryPool2(createQueryPool(1, 2));
+
+ if (!acquireProfilingLock())
+ {
+ // lock was not acquired in given time, we can't fail the test
+ return tcu::TestStatus::pass("Pass");
+ }
+
+ // begin command buffer
+ const VkCommandBufferBeginInfo commandBufBeginParams =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ DE_NULL,
+ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+ VK_CHECK(vkd.beginCommandBuffer(*cmdBuffer, &commandBufBeginParams));
+
+ initialTransitionColor2DImage(vkd, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_LAYOUT_GENERAL,
+ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
+
+ // begin render pass
+ VkClearValue renderPassClearValue;
+ deMemset(&renderPassClearValue, 0, sizeof(VkClearValue));
+
+ VkBuffer vertexBuffer = m_vertexBuffer->object();
+ const VkDeviceSize vertexBufferOffset = 0;
+ const VkQueryPool queryPools[] =
+ {
+ *queryPool1,
+ *queryPool2
+ };
+
+ // reset query pools
+ vkd.cmdResetQueryPool(*cmdBuffer, queryPools[0], 0u, 1u);
+ vkd.cmdResetQueryPool(*cmdBuffer, queryPools[1], 0u, 1u);
+
+ // perform two queries during triangle draw
+ for (deUint32 loop = 0; loop < DE_LENGTH_OF_ARRAY(queryPools); ++loop)
+ {
+ const VkQueryPool queryPool = queryPools[loop];
+ vkd.cmdBeginQuery(*cmdBuffer, queryPool, 0u, (VkQueryControlFlags)0u);
+ beginRenderPass(vkd, *cmdBuffer, *m_renderPass, *m_framebuffer,
+ makeRect2D(0, 0, m_size, m_size),
+ 1, &renderPassClearValue);
+
+ vkd.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
+ vkd.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
+ vkd.cmdDraw(*cmdBuffer, 3, 1, 0, 0);
+
+ endRenderPass(vkd, *cmdBuffer);
+ vkd.cmdEndQuery(*cmdBuffer, queryPool, 0u);
+ }
+
+ transition2DImage(vkd, *cmdBuffer, m_colorAttachmentImage->object(), VK_IMAGE_ASPECT_COLOR_BIT,
+ VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+ VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
+
+ endCommandBuffer(vkd, *cmdBuffer);
+
+ // submit command buffer for each pass and wait for its completion
+ for (deUint32 passIndex = 0; passIndex < getRequiredNumerOfPasses(); passIndex++)
+ {
+ const Unique<VkFence> fence(createFence(vkd, device));
+
+ VkPerformanceQuerySubmitInfoKHR performanceQuerySubmitInfo =
+ {
+ VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
+ NULL,
+ passIndex
+ };
+
+ const VkSubmitInfo submitInfo =
+ {
+ VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
+ &performanceQuerySubmitInfo, // pNext
+ 0u, // waitSemaphoreCount
+ DE_NULL, // pWaitSemaphores
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
+ 1u, // commandBufferCount
+ &cmdBuffer.get(), // pCommandBuffers
+ 0u, // signalSemaphoreCount
+ DE_NULL, // pSignalSemaphores
+ };
+
+ VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
+ VK_CHECK(vkd.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
+ }
+
+ releaseProfilingLock();
+
+ VK_CHECK(vkd.resetCommandBuffer(*cmdBuffer, 0));
+
+ if (verifyQueryResults(*queryPool1) && verifyQueryResults(*queryPool2))
+ return tcu::TestStatus::pass("Pass");
+ return tcu::TestStatus::fail("Fail");
+}
+
+// Base class for all compute tests
+class ComputeQueryTestBase : public QueryTestBase
+{
+public:
+ ComputeQueryTestBase(vkt::Context& context);
+
+protected:
+ void initStateObjects(void);
+
+protected:
+ Move<VkPipeline> m_pipeline;
+ Move<VkPipelineLayout> m_pipelineLayout;
+ de::SharedPtr<Buffer> m_buffer;
+ Move<VkDescriptorPool> m_descriptorPool;
+ Move<VkDescriptorSet> m_descriptorSet;
+ VkDescriptorBufferInfo m_descriptorBufferInfo;
+ VkBufferMemoryBarrier m_computeFinishBarrier;
+};
+
+ComputeQueryTestBase::ComputeQueryTestBase(vkt::Context& context)
+ : QueryTestBase(context)
+{
+}
+
+void ComputeQueryTestBase::initStateObjects(void)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkDeviceSize bufferSize = 32 * sizeof(deUint32);
+ const CmdPoolCreateInfo cmdPoolCreateInfo(m_context.getUniversalQueueFamilyIndex());
+ const Unique<VkCommandPool> cmdPool(createCommandPool(vkd, device, &cmdPoolCreateInfo));
+ const Unique<VkCommandBuffer> cmdBuffer(allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+
+ const Unique<VkDescriptorSetLayout> descriptorSetLayout(DescriptorSetLayoutBuilder()
+ .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT)
+ .build(vkd, device));
+
+ // create pipeline layout
+ {
+ const VkPipelineLayoutCreateInfo pipelineLayoutParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // sType
+ DE_NULL, // pNext
+ 0u, // flags
+ 1u, // setLayoutCount
+ &(*descriptorSetLayout), // pSetLayouts
+ 0u, // pushConstantRangeCount
+ DE_NULL, // pPushConstantRanges
+ };
+ m_pipelineLayout = createPipelineLayout(vkd, device, &pipelineLayoutParams);
+ }
+
+ // create compute pipeline
+ {
+ const Unique<VkShaderModule> cs(createShaderModule(vkd, device, m_context.getBinaryCollection().get("comp"), 0u));
+ const VkPipelineShaderStageCreateInfo pipelineShaderStageParams =
+ {
+ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // sType
+ DE_NULL, // pNext
+ (VkPipelineShaderStageCreateFlags)0u, // flags
+ VK_SHADER_STAGE_COMPUTE_BIT, // stage
+ *cs, // module
+ "main", // pName
+ DE_NULL, // pSpecializationInfo
+ };
+ const VkComputePipelineCreateInfo pipelineCreateInfo =
+ {
+ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // sType
+ DE_NULL, // pNext
+ (VkPipelineCreateFlags)0u, // flags
+ pipelineShaderStageParams, // stage
+ *m_pipelineLayout, // layout
+ DE_NULL, // basePipelineHandle
+ 0, // basePipelineIndex
+ };
+ m_pipeline = createComputePipeline(vkd, device, DE_NULL, &pipelineCreateInfo);
+ }
+
+ m_buffer = Buffer::createAndAlloc(vkd, device, BufferCreateInfo(bufferSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT),
+ m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
+ m_descriptorPool = DescriptorPoolBuilder()
+ .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
+ .build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
+ const VkDescriptorSetAllocateInfo allocateParams =
+ {
+ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // sType
+ DE_NULL, // pNext
+ *m_descriptorPool, // descriptorPool
+ 1u, // setLayoutCount
+ &(*descriptorSetLayout), // pSetLayouts
+ };
+
+ m_descriptorSet = allocateDescriptorSet(vkd, device, &allocateParams);
+ const VkDescriptorBufferInfo descriptorInfo =
+ {
+ m_buffer->object(), // buffer
+ 0ull, // offset
+ bufferSize, // range
+ };
+
+ DescriptorSetUpdateBuilder()
+ .writeSingle(*m_descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorInfo)
+ .update(vkd, device);
+
+ // clear buffer
+ const std::vector<deUint8> data((size_t)bufferSize, 0u);
+ const Allocation& allocation = m_buffer->getBoundMemory();
+ void* allocationData = allocation.getHostPtr();
+ invalidateMappedMemoryRange(vkd, device, allocation.getMemory(), allocation.getOffset(), bufferSize);
+ deMemcpy(allocationData, &data[0], (size_t)bufferSize);
+
+ const VkBufferMemoryBarrier barrier =
+ {
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // sType
+ DE_NULL, // pNext
+ VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT, // srcAccessMask
+ VK_ACCESS_HOST_READ_BIT, // dstAccessMask
+ VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
+ VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
+ m_buffer->object(), // buffer
+ 0ull, // offset
+ bufferSize, // size
+ };
+ m_computeFinishBarrier = barrier;
+}
+
+class ComputeQueryTest : public ComputeQueryTestBase
+{
+public:
+ ComputeQueryTest (vkt::Context& context);
+ tcu::TestStatus iterate (void);
+};
+
+ComputeQueryTest::ComputeQueryTest(vkt::Context& context)
+ : ComputeQueryTestBase(context)
+{
+}
+
+tcu::TestStatus ComputeQueryTest::iterate(void)
+{
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkQueue queue = m_context.getUniversalQueue();
+ const CmdPoolCreateInfo cmdPoolCreateInfo (m_context.getUniversalQueueFamilyIndex());
+ const Unique<VkCommandPool> cmdPool (createCommandPool(vkd, device, &cmdPoolCreateInfo));
+ const Unique<VkCommandBuffer> cmdBuffer (allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+
+ initStateObjects();
+ setupCounters();
+
+ vk::Unique<VkQueryPool> queryPool(createQueryPool(0, 1));
+
+ if (!acquireProfilingLock())
+ {
+ // lock was not acquired in given time, we can't fail the test
+ return tcu::TestStatus::pass("Pass");
+ }
+
+ beginCommandBuffer(vkd, *cmdBuffer);
+ vkd.cmdResetQueryPool(*cmdBuffer, *queryPool, 0u, 1u);
+
+ vkd.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_pipeline);
+ vkd.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_pipelineLayout, 0u, 1u, &(m_descriptorSet.get()), 0u, DE_NULL);
+
+ vkd.cmdBeginQuery(*cmdBuffer, *queryPool, 0u, (VkQueryControlFlags)0u);
+ vkd.cmdDispatch(*cmdBuffer, 2, 2, 2);
+ vkd.cmdEndQuery(*cmdBuffer, *queryPool, 0u);
+
+ vkd.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
+ (VkDependencyFlags)0u, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &m_computeFinishBarrier, 0u, (const VkImageMemoryBarrier*)DE_NULL);
+ endCommandBuffer(vkd, *cmdBuffer);
+
+ // submit command buffer for each pass and wait for its completion
+ for (deUint32 passIndex = 0; passIndex < getRequiredNumerOfPasses(); passIndex++)
+ {
+ const Unique<VkFence> fence(createFence(vkd, device));
+
+ VkPerformanceQuerySubmitInfoKHR performanceQuerySubmitInfo =
+ {
+ VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
+ NULL,
+ passIndex
+ };
+
+ const VkSubmitInfo submitInfo =
+ {
+ VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
+ &performanceQuerySubmitInfo, // pNext
+ 0u, // waitSemaphoreCount
+ DE_NULL, // pWaitSemaphores
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
+ 1u, // commandBufferCount
+ &cmdBuffer.get(), // pCommandBuffers
+ 0u, // signalSemaphoreCount
+ DE_NULL, // pSignalSemaphores
+ };
+
+ VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
+ VK_CHECK(vkd.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
+ }
+
+ releaseProfilingLock();
+
+ VK_CHECK(vkd.resetCommandBuffer(*cmdBuffer, 0));
+
+ if (verifyQueryResults(*queryPool))
+ return tcu::TestStatus::pass("Pass");
+ return tcu::TestStatus::fail("Fail");
+}
+
+class ComputeMultiplePoolsTest : public ComputeQueryTestBase
+{
+public:
+ ComputeMultiplePoolsTest (vkt::Context& context);
+ tcu::TestStatus iterate (void);
+};
+
+ComputeMultiplePoolsTest::ComputeMultiplePoolsTest(vkt::Context& context)
+ : ComputeQueryTestBase(context)
+{
+}
+
+tcu::TestStatus ComputeMultiplePoolsTest::iterate(void)
+{
+ if (!m_context.getPerformanceQueryFeatures().performanceCounterMultipleQueryPools)
+ throw tcu::NotSupportedError("MultipleQueryPools not supported");
+
+ const DeviceInterface& vkd = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ const VkQueue queue = m_context.getUniversalQueue();
+ const CmdPoolCreateInfo cmdPoolCreateInfo(m_context.getUniversalQueueFamilyIndex());
+ const Unique<VkCommandPool> cmdPool(createCommandPool(vkd, device, &cmdPoolCreateInfo));
+ const Unique<VkCommandBuffer> cmdBuffer(allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+
+ initStateObjects();
+ setupCounters();
+
+ vk::Unique<VkQueryPool> queryPool1(createQueryPool(0, 2)),
+ queryPool2(createQueryPool(1, 2));
+
+ if (!acquireProfilingLock())
+ {
+ // lock was not acquired in given time, we can't fail the test
+ return tcu::TestStatus::pass("Pass");
+ }
+
+ const VkQueryPool queryPools[] =
+ {
+ *queryPool1,
+ *queryPool2
+ };
+
+ beginCommandBuffer(vkd, *cmdBuffer);
+ vkd.cmdResetQueryPool(*cmdBuffer, queryPools[0], 0u, 1u);
+ vkd.cmdResetQueryPool(*cmdBuffer, queryPools[1], 0u, 1u);
+
+ vkd.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_pipeline);
+ vkd.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_pipelineLayout, 0u, 1u, &(m_descriptorSet.get()), 0u, DE_NULL);
+
+ // perform two queries
+ for (deUint32 loop = 0; loop < DE_LENGTH_OF_ARRAY(queryPools); ++loop)
+ {
+ const VkQueryPool queryPool = queryPools[loop];
+ vkd.cmdBeginQuery(*cmdBuffer, queryPool, 0u, (VkQueryControlFlags)0u);
+ vkd.cmdDispatch(*cmdBuffer, 2, 2, 2);
+ vkd.cmdEndQuery(*cmdBuffer, queryPool, 0u);
+ }
+
+ vkd.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT,
+ (VkDependencyFlags)0u, 0u, (const VkMemoryBarrier*)DE_NULL, 1u, &m_computeFinishBarrier, 0u, (const VkImageMemoryBarrier*)DE_NULL);
+ endCommandBuffer(vkd, *cmdBuffer);
+
+ // submit command buffer for each pass and wait for its completion
+ for (deUint32 passIndex = 0; passIndex < getRequiredNumerOfPasses(); passIndex++)
+ {
+ const Unique<VkFence> fence(createFence(vkd, device));
+
+ VkPerformanceQuerySubmitInfoKHR performanceQuerySubmitInfo =
+ {
+ VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
+ NULL,
+ passIndex
+ };
+
+ const VkSubmitInfo submitInfo =
+ {
+ VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
+ &performanceQuerySubmitInfo, // pNext
+ 0u, // waitSemaphoreCount
+ DE_NULL, // pWaitSemaphores
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
+ 1u, // commandBufferCount
+ &cmdBuffer.get(), // pCommandBuffers
+ 0u, // signalSemaphoreCount
+ DE_NULL, // pSignalSemaphores
+ };
+
+ VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
+ VK_CHECK(vkd.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
+ }
+
+ releaseProfilingLock();
+
+ VK_CHECK(vkd.resetCommandBuffer(*cmdBuffer, 0));
+
+ if (verifyQueryResults(*queryPool1) && verifyQueryResults(*queryPool2))
+ return tcu::TestStatus::pass("Pass");
+ return tcu::TestStatus::fail("Fail");
+}
+
+enum TestType
+{
+ TT_ENUMERATE_AND_VALIDATE = 0,
+ TT_QUERY,
+ TT_MULTIPLE_POOLS
+};
+
+class QueryPoolPerformanceTest : public TestCase
+{
+public:
+ QueryPoolPerformanceTest (tcu::TestContext &context, TestType testType, VkQueueFlagBits queueFlagBits, const char *name)
+ : TestCase (context, name, "")
+ , m_testType (testType)
+ , m_queueFlagBits (queueFlagBits)
+ {
+ }
+
+ vkt::TestInstance* createInstance (vkt::Context& context) const
+ {
+ if (m_testType == TT_ENUMERATE_AND_VALIDATE)
+ return new EnumerateAndValidateTest(context, m_queueFlagBits);
+
+ if (m_queueFlagBits == VK_QUEUE_GRAPHICS_BIT)
+ {
+ if (m_testType == TT_QUERY)
+ return new GraphicQueryTest(context);
+ return new GraphicMultiplePoolsTest(context);
+ }
+
+ // tests for VK_QUEUE_COMPUTE_BIT
+ if (m_testType == TT_QUERY)
+ return new ComputeQueryTest(context);
+ return new ComputeMultiplePoolsTest(context);
+ }
+
+ void initPrograms (SourceCollections& programCollection) const
+ {
+ // validation test do not need programs
+ if (m_testType == TT_ENUMERATE_AND_VALIDATE)
+ return;
+
+ if (m_queueFlagBits == VK_QUEUE_COMPUTE_BIT)
+ {
+ programCollection.glslSources.add("comp")
+ << glu::ComputeSource("#version 430\n"
+ "layout (local_size_x = 1) in;\n"
+ "layout(binding = 0) writeonly buffer Output {\n"
+ " uint values[];\n"
+ "} sb_out;\n\n"
+ "void main (void) {\n"
+ " uint index = uint(gl_GlobalInvocationID.x);\n"
+ " sb_out.values[index] += gl_GlobalInvocationID.y*2;\n"
+ "}\n");
+ return;
+ }
+
+ programCollection.glslSources.add("frag")
+ << glu::FragmentSource("#version 430\n"
+ "layout(location = 0) out vec4 out_FragColor;\n"
+ "void main()\n"
+ "{\n"
+ " out_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
+ "}\n");
+
+ programCollection.glslSources.add("vert")
+ << glu::VertexSource("#version 430\n"
+ "layout(location = 0) in vec4 in_Position;\n"
+ "out gl_PerVertex { vec4 gl_Position; float gl_PointSize; };\n"
+ "void main() {\n"
+ " gl_Position = in_Position;\n"
+ " gl_PointSize = 1.0;\n"
+ "}\n");
+ }
+
+private:
+
+ TestType m_testType;
+ VkQueueFlagBits m_queueFlagBits;
+};
+
+} //anonymous
+
+QueryPoolPerformanceTests::QueryPoolPerformanceTests (tcu::TestContext &testCtx)
+ : TestCaseGroup(testCtx, "performance_query", "Tests for performance queries")
+{
+}
+
+void QueryPoolPerformanceTests::init (void)
+{
+ addChild(new QueryPoolPerformanceTest(m_testCtx, TT_ENUMERATE_AND_VALIDATE, VK_QUEUE_GRAPHICS_BIT, "enumerate_and_validate_graphic"));
+ addChild(new QueryPoolPerformanceTest(m_testCtx, TT_ENUMERATE_AND_VALIDATE, VK_QUEUE_COMPUTE_BIT, "enumerate_and_validate_compute"));
+ addChild(new QueryPoolPerformanceTest(m_testCtx, TT_QUERY, VK_QUEUE_GRAPHICS_BIT, "query_graphic"));
+ addChild(new QueryPoolPerformanceTest(m_testCtx, TT_QUERY, VK_QUEUE_COMPUTE_BIT, "query_compute"));
+ addChild(new QueryPoolPerformanceTest(m_testCtx, TT_MULTIPLE_POOLS, VK_QUEUE_GRAPHICS_BIT, "multiple_pools_graphic"));
+ addChild(new QueryPoolPerformanceTest(m_testCtx, TT_MULTIPLE_POOLS, VK_QUEUE_COMPUTE_BIT, "multiple_pools_compute"));
+}
+
+} //QueryPool
+} //vkt
+
--- /dev/null
+#ifndef _VKTQUERYPOOLPERFORMANCETESTS_HPP
+#define _VKTQUERYPOOLPERFORMANCETESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2018 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Vulkan Performance Query Tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktTestCase.hpp"
+
+namespace vkt
+{
+namespace QueryPool
+{
+
+class QueryPoolPerformanceTests : public tcu::TestCaseGroup
+{
+public:
+ QueryPoolPerformanceTests (tcu::TestContext &testCtx);
+ ~QueryPoolPerformanceTests (void) {}
+ void init (void);
+
+private:
+ QueryPoolPerformanceTests (const QueryPoolPerformanceTests &other);
+ QueryPoolPerformanceTests& operator= (const QueryPoolPerformanceTests &other);
+};
+
+} // QueryPool
+} // vkt
+
+#endif // _VKTQUERYPOOLPERFORMANCETESTS_HPP
#include "vktTestGroupUtil.hpp"
#include "vktQueryPoolOcclusionTests.hpp"
#include "vktQueryPoolStatisticsTests.hpp"
+#include "vktQueryPoolPerformanceTests.hpp"
namespace vkt
{
queryPoolTests->addChild(new QueryPoolOcclusionTests(testCtx));
queryPoolTests->addChild(new QueryPoolStatisticsTests(testCtx));
+ queryPoolTests->addChild(new QueryPoolPerformanceTests(testCtx));
}
} // anonymous
dEQP-VK.query_pool.statistics_query.reset_before_copy.tes_evaluation_shader_invocations.64bits_tes_evaluation_shader_invocations
dEQP-VK.query_pool.statistics_query.reset_before_copy.tes_evaluation_shader_invocations.64bits_tes_evaluation_shader_invocations_secondary
dEQP-VK.query_pool.statistics_query.reset_before_copy.tes_evaluation_shader_invocations.64bits_tes_evaluation_shader_invocations_secondary_inherited
+dEQP-VK.query_pool.performance_query.enumerate_and_validate_graphic
+dEQP-VK.query_pool.performance_query.enumerate_and_validate_compute
+dEQP-VK.query_pool.performance_query.query_graphic
+dEQP-VK.query_pool.performance_query.query_compute
+dEQP-VK.query_pool.performance_query.multiple_pools_graphic
+dEQP-VK.query_pool.performance_query.multiple_pools_compute
dEQP-VK.draw.concurrent.compute_and_triangle_list
dEQP-VK.draw.simple_draw.simple_draw_triangle_list
dEQP-VK.draw.simple_draw.simple_draw_triangle_strip
dEQP-VK.query_pool.statistics_query.reset_before_copy.tes_evaluation_shader_invocations.64bits_tes_evaluation_shader_invocations
dEQP-VK.query_pool.statistics_query.reset_before_copy.tes_evaluation_shader_invocations.64bits_tes_evaluation_shader_invocations_secondary
dEQP-VK.query_pool.statistics_query.reset_before_copy.tes_evaluation_shader_invocations.64bits_tes_evaluation_shader_invocations_secondary_inherited
+dEQP-VK.query_pool.performance_query.enumerate_and_validate_graphic
+dEQP-VK.query_pool.performance_query.enumerate_and_validate_compute
+dEQP-VK.query_pool.performance_query.query_graphic
+dEQP-VK.query_pool.performance_query.query_compute
+dEQP-VK.query_pool.performance_query.multiple_pools_graphic
+dEQP-VK.query_pool.performance_query.multiple_pools_compute
dEQP-VK.draw.concurrent.compute_and_triangle_list
dEQP-VK.draw.simple_draw.simple_draw_triangle_list
dEQP-VK.draw.simple_draw.simple_draw_triangle_strip
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_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,
+ VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,
+ VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,
+ VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,
+ VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005,
+ VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
VK_QUERY_TYPE_TIMESTAMP = 2,
VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,
+ VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,
VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,
VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,
VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
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"
+
+typedef enum VkPerformanceCounterUnitKHR {
+ VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,
+ VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,
+ VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,
+ VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,
+ VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,
+ VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,
+ VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,
+ VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,
+ VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,
+ VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,
+ VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,
+ VK_PERFORMANCE_COUNTER_UNIT_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR,
+ VK_PERFORMANCE_COUNTER_UNIT_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR,
+ VK_PERFORMANCE_COUNTER_UNIT_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR - VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR + 1),
+ VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterUnitKHR;
+
+typedef enum VkPerformanceCounterScopeKHR {
+ VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = 0,
+ VK_QUERY_SCOPE_RENDER_PASS_KHR = 1,
+ VK_QUERY_SCOPE_COMMAND_KHR = 2,
+ VK_PERFORMANCE_COUNTER_SCOPE_BEGIN_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR,
+ VK_PERFORMANCE_COUNTER_SCOPE_END_RANGE_KHR = VK_QUERY_SCOPE_COMMAND_KHR,
+ VK_PERFORMANCE_COUNTER_SCOPE_RANGE_SIZE_KHR = (VK_QUERY_SCOPE_COMMAND_KHR - VK_QUERY_SCOPE_COMMAND_BUFFER_KHR + 1),
+ VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterScopeKHR;
+
+typedef enum VkPerformanceCounterStorageKHR {
+ VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,
+ VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,
+ VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,
+ VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,
+ VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,
+ VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,
+ VK_PERFORMANCE_COUNTER_STORAGE_BEGIN_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR,
+ VK_PERFORMANCE_COUNTER_STORAGE_END_RANGE_KHR = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR,
+ VK_PERFORMANCE_COUNTER_STORAGE_RANGE_SIZE_KHR = (VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR - VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR + 1),
+ VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterStorageKHR;
+
+typedef enum VkPerformanceCounterDescriptionFlagBitsKHR {
+ VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = 0x00000001,
+ VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = 0x00000002,
+ VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPerformanceCounterDescriptionFlagBitsKHR;
+typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;
+
+typedef enum VkAcquireProfilingLockFlagBitsKHR {
+ VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkAcquireProfilingLockFlagBitsKHR;
+typedef VkFlags VkAcquireProfilingLockFlagsKHR;
+typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 performanceCounterQueryPools;
+ VkBool32 performanceCounterMultipleQueryPools;
+} VkPhysicalDevicePerformanceQueryFeaturesKHR;
+
+typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
+ VkStructureType sType;
+ void* pNext;
+ VkBool32 allowCommandBufferQueryCopies;
+} VkPhysicalDevicePerformanceQueryPropertiesKHR;
+
+typedef struct VkPerformanceCounterKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPerformanceCounterUnitKHR unit;
+ VkPerformanceCounterScopeKHR scope;
+ VkPerformanceCounterStorageKHR storage;
+ uint8_t uuid[VK_UUID_SIZE];
+} VkPerformanceCounterKHR;
+
+typedef struct VkPerformanceCounterDescriptionKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkPerformanceCounterDescriptionFlagsKHR flags;
+ char name[VK_MAX_DESCRIPTION_SIZE];
+ char category[VK_MAX_DESCRIPTION_SIZE];
+ char description[VK_MAX_DESCRIPTION_SIZE];
+} VkPerformanceCounterDescriptionKHR;
+
+typedef struct VkQueryPoolPerformanceCreateInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t queueFamilyIndex;
+ uint32_t counterIndexCount;
+ const uint32_t* pCounterIndices;
+} VkQueryPoolPerformanceCreateInfoKHR;
+
+typedef union VkPerformanceCounterResultKHR {
+ int32_t int32;
+ int64_t int64;
+ uint32_t uint32;
+ uint64_t uint64;
+ float float32;
+ double float64;
+} VkPerformanceCounterResultKHR;
+
+typedef struct VkAcquireProfilingLockInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkAcquireProfilingLockFlagsKHR flags;
+ uint64_t timeout;
+} VkAcquireProfilingLockInfoKHR;
+
+typedef struct VkPerformanceQuerySubmitInfoKHR {
+ VkStructureType sType;
+ const void* pNext;
+ uint32_t counterPassIndex;
+} VkPerformanceQuerySubmitInfoKHR;
+
+typedef void (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);
+typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+ VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ uint32_t* pCounterCount,
+ VkPerformanceCounterKHR* pCounters,
+ VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
+ VkPhysicalDevice physicalDevice,
+ const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
+ uint32_t* pNumPasses);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(
+ VkDevice device,
+ const VkAcquireProfilingLockInfoKHR* pInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(
+ VkDevice device);
+#endif
+
#define VK_KHR_maintenance2 1
#define VK_KHR_MAINTENANCE2_SPEC_VERSION 1
projects / platform / upstream / VK-GL-CTS.git / commitdiff