Method create_query_pools

framework/stats/vulkan_stats_provider.cpp:209–266

}

bool VulkanStatsProvider::create_query_pools(uint32_t queue_family_index)
{
	vkb::core::DeviceC               &device           = render_context.get_device();
	vkb::core::PhysicalDeviceC const &gpu              = device.get_gpu();
	uint32_t                          num_framebuffers = static_cast<uint32_t>(render_context.get_render_frames().size());

	// Now we know the available counters, we can build a query pool that will collect them.
	// We will check that the counters can be collected in a single pass. Multi-pass would
	// be a big performance hit so for these samples, we don't want to use it.
	VkQueryPoolPerformanceCreateInfoKHR perf_create_info{};
	perf_create_info.sType             = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
	perf_create_info.queueFamilyIndex  = queue_family_index;
	perf_create_info.counterIndexCount = static_cast<uint32_t>(counter_indices.size());
	perf_create_info.pCounterIndices   = counter_indices.data();

	uint32_t passes_needed = gpu.get_queue_family_performance_query_passes(&perf_create_info);
	if (passes_needed != 1)
	{
		// Needs more than one pass, remove all our supported stats
		LOGW("Requested Vulkan stats require multiple passes, we won't collect them");
		return false;
	}

	// We will need a query pool to report the stats back to us
	VkQueryPoolCreateInfo pool_create_info{};
	pool_create_info.sType      = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
	pool_create_info.pNext      = &perf_create_info;
	pool_create_info.queryType  = VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR;
	pool_create_info.queryCount = num_framebuffers;

	query_pool = std::make_unique<QueryPool>(device, pool_create_info);

	if (!query_pool)
	{
		LOGW("Failed to create performance query pool");
		return false;
	}

	// Reset the query pool before first use. We cannot do these in the command buffer
	// as that is invalid usage for performance queries due to the potential for multiple
	// passes being required.
	query_pool->host_reset(0, num_framebuffers);

	if (has_timestamps)
	{
		// If we support timestamp queries we will use those to more accurately measure
		// the time spent executing a command buffer than just a frame-to-frame timer
		// in software.
		VkQueryPoolCreateInfo timestamp_pool_create_info{};
		timestamp_pool_create_info.sType      = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
		timestamp_pool_create_info.queryType  = VK_QUERY_TYPE_TIMESTAMP;
		timestamp_pool_create_info.queryCount = num_framebuffers * 2;        // 2 timestamps per frame (start & end)

		timestamp_pool = std::make_unique<QueryPool>(device, timestamp_pool_create_info);
	}

	return true;
}