Vulkan: add atrace support (fdd0c2ad) · Commits · e / os / android_frameworks_native-old

vulkan/libvulkan/api.cpp

+21 −0

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,8 @@
	// There are a few of them requiring manual code for things such as layer		// There are a few of them requiring manual code for things such as layer
	// discovery or chaining. They call into functions defined in this file.		// discovery or chaining. They call into functions defined in this file.

			#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	#include <stdlib.h>		#include <stdlib.h>
	#include <string.h>		#include <string.h>

	@@ -32,6 +34,7 @@
	#include <android-base/strings.h>		#include <android-base/strings.h>
	#include <cutils/properties.h>		#include <cutils/properties.h>
	#include <log/log.h>		#include <log/log.h>
			#include <utils/Trace.h>

	#include <vulkan/vk_layer_interface.h>		#include <vulkan/vk_layer_interface.h>
	#include <graphicsenv/GraphicsEnv.h>		#include <graphicsenv/GraphicsEnv.h>
	@@ -1176,6 +1179,8 @@ bool EnsureInitialized() {
	VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,		VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
	const VkAllocationCallbacks* pAllocator,		const VkAllocationCallbacks* pAllocator,
	VkInstance* pInstance) {		VkInstance* pInstance) {
			ATRACE_CALL();

	if (!EnsureInitialized())		if (!EnsureInitialized())
	return VK_ERROR_INITIALIZATION_FAILED;		return VK_ERROR_INITIALIZATION_FAILED;

	@@ -1184,6 +1189,8 @@ VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,

	void DestroyInstance(VkInstance instance,		void DestroyInstance(VkInstance instance,
	const VkAllocationCallbacks* pAllocator) {		const VkAllocationCallbacks* pAllocator) {
			ATRACE_CALL();

	if (instance != VK_NULL_HANDLE)		if (instance != VK_NULL_HANDLE)
	LayerChain::DestroyInstance(instance, pAllocator);		LayerChain::DestroyInstance(instance, pAllocator);
	}		}
	@@ -1192,17 +1199,23 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice,
	const VkDeviceCreateInfo* pCreateInfo,		const VkDeviceCreateInfo* pCreateInfo,
	const VkAllocationCallbacks* pAllocator,		const VkAllocationCallbacks* pAllocator,
	VkDevice* pDevice) {		VkDevice* pDevice) {
			ATRACE_CALL();

	return LayerChain::CreateDevice(physicalDevice, pCreateInfo, pAllocator,		return LayerChain::CreateDevice(physicalDevice, pCreateInfo, pAllocator,
	pDevice);		pDevice);
	}		}

	void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {		void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
			ATRACE_CALL();

	if (device != VK_NULL_HANDLE)		if (device != VK_NULL_HANDLE)
	LayerChain::DestroyDevice(device, pAllocator);		LayerChain::DestroyDevice(device, pAllocator);
	}		}

	VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount,		VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
	VkLayerProperties* pProperties) {		VkLayerProperties* pProperties) {
			ATRACE_CALL();

	if (!EnsureInitialized())		if (!EnsureInitialized())
	return VK_ERROR_INITIALIZATION_FAILED;		return VK_ERROR_INITIALIZATION_FAILED;

	@@ -1225,6 +1238,8 @@ VkResult EnumerateInstanceExtensionProperties(
	const char* pLayerName,		const char* pLayerName,
	uint32_t* pPropertyCount,		uint32_t* pPropertyCount,
	VkExtensionProperties* pProperties) {		VkExtensionProperties* pProperties) {
			ATRACE_CALL();

	if (!EnsureInitialized())		if (!EnsureInitialized())
	return VK_ERROR_INITIALIZATION_FAILED;		return VK_ERROR_INITIALIZATION_FAILED;

	@@ -1253,6 +1268,8 @@ VkResult EnumerateInstanceExtensionProperties(
	VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,		VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
	uint32_t* pPropertyCount,		uint32_t* pPropertyCount,
	VkLayerProperties* pProperties) {		VkLayerProperties* pProperties) {
			ATRACE_CALL();

	uint32_t count;		uint32_t count;
	const LayerChain::ActiveLayer* layers =		const LayerChain::ActiveLayer* layers =
	LayerChain::GetActiveLayers(physicalDevice, count);		LayerChain::GetActiveLayers(physicalDevice, count);
	@@ -1275,6 +1292,8 @@ VkResult EnumerateDeviceExtensionProperties(
	const char* pLayerName,		const char* pLayerName,
	uint32_t* pPropertyCount,		uint32_t* pPropertyCount,
	VkExtensionProperties* pProperties) {		VkExtensionProperties* pProperties) {
			ATRACE_CALL();

	if (pLayerName) {		if (pLayerName) {
	// EnumerateDeviceLayerProperties enumerates active layers for		// EnumerateDeviceLayerProperties enumerates active layers for
	// backward compatibility. The extension query here should work for		// backward compatibility. The extension query here should work for
	@@ -1302,6 +1321,8 @@ VkResult EnumerateDeviceExtensionProperties(
	}		}

	VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) {		VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) {
			ATRACE_CALL();

	*pApiVersion = VK_API_VERSION_1_1;		*pApiVersion = VK_API_VERSION_1_1;
	return VK_SUCCESS;		return VK_SUCCESS;
	}		}

vulkan/libvulkan/driver.cpp

+45 −0

Original line number	Original line	Diff line number	Diff line
	@@ -14,6 +14,8 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

			#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	#include <malloc.h>		#include <malloc.h>
	#include <stdlib.h>		#include <stdlib.h>
	#include <string.h>		#include <string.h>
	@@ -31,6 +33,7 @@
	#include <configstore/Utils.h>		#include <configstore/Utils.h>
	#include <cutils/properties.h>		#include <cutils/properties.h>
	#include <graphicsenv/GraphicsEnv.h>		#include <graphicsenv/GraphicsEnv.h>
			#include <utils/Trace.h>
	#include <utils/Vector.h>		#include <utils/Vector.h>

	#include "android-base/properties.h"		#include "android-base/properties.h"
	@@ -150,6 +153,8 @@ Hal Hal::hal_;
	void* LoadLibrary(const android_dlextinfo& dlextinfo,		void* LoadLibrary(const android_dlextinfo& dlextinfo,
	const char* subname,		const char* subname,
	int subname_len) {		int subname_len) {
			ATRACE_CALL();

	const char kLibFormat[] = "vulkan.%*s.so";		const char kLibFormat[] = "vulkan.%*s.so";
	char* name = static_cast<char*>(		char* name = static_cast<char*>(
	alloca(sizeof(kLibFormat) + static_cast<size_t>(subname_len)));		alloca(sizeof(kLibFormat) + static_cast<size_t>(subname_len)));
	@@ -164,6 +169,8 @@ const std::array<const char*, 2> HAL_SUBNAME_KEY_PROPERTIES = {{

	int LoadDriver(android_namespace_t* library_namespace,		int LoadDriver(android_namespace_t* library_namespace,
	const hwvulkan_module_t** module) {		const hwvulkan_module_t** module) {
			ATRACE_CALL();

	const android_dlextinfo dlextinfo = {		const android_dlextinfo dlextinfo = {
	.flags = ANDROID_DLEXT_USE_NAMESPACE,		.flags = ANDROID_DLEXT_USE_NAMESPACE,
	.library_namespace = library_namespace,		.library_namespace = library_namespace,
	@@ -198,6 +205,8 @@ int LoadDriver(android_namespace_t* library_namespace,
	}		}

	int LoadBuiltinDriver(const hwvulkan_module_t** module) {		int LoadBuiltinDriver(const hwvulkan_module_t** module) {
			ATRACE_CALL();

	auto ns = android_get_exported_namespace("sphal");		auto ns = android_get_exported_namespace("sphal");
	if (!ns)		if (!ns)
	return -ENOENT;		return -ENOENT;
	@@ -205,6 +214,8 @@ int LoadBuiltinDriver(const hwvulkan_module_t** module) {
	}		}

	int LoadUpdatedDriver(const hwvulkan_module_t** module) {		int LoadUpdatedDriver(const hwvulkan_module_t** module) {
			ATRACE_CALL();

	auto ns = android::GraphicsEnv::getInstance().getDriverNamespace();		auto ns = android::GraphicsEnv::getInstance().getDriverNamespace();
	if (!ns)		if (!ns)
	return -ENOENT;		return -ENOENT;
	@@ -212,6 +223,8 @@ int LoadUpdatedDriver(const hwvulkan_module_t** module) {
	}		}

	bool Hal::Open() {		bool Hal::Open() {
			ATRACE_CALL();

	ALOG_ASSERT(!hal_.dev_, "OpenHAL called more than once");		ALOG_ASSERT(!hal_.dev_, "OpenHAL called more than once");

	// Use a stub device unless we successfully open a real HAL device.		// Use a stub device unless we successfully open a real HAL device.
	@@ -242,9 +255,11 @@ bool Hal::Open() {
	}		}

	hwvulkan_device_t* device;		hwvulkan_device_t* device;
			ATRACE_BEGIN("hwvulkan module open");
	result =		result =
	module->common.methods->open(&module->common, HWVULKAN_DEVICE_0,		module->common.methods->open(&module->common, HWVULKAN_DEVICE_0,
	reinterpret_cast<hw_device_t**>(&device));		reinterpret_cast<hw_device_t**>(&device));
			ATRACE_END();
	if (result != 0) {		if (result != 0) {
	// Any device with a Vulkan HAL should be able to open the device.		// Any device with a Vulkan HAL should be able to open the device.
	ALOGE("failed to open Vulkan HAL device: %s (%d)", strerror(-result),		ALOGE("failed to open Vulkan HAL device: %s (%d)", strerror(-result),
	@@ -260,6 +275,8 @@ bool Hal::Open() {
	}		}

	bool Hal::InitDebugReportIndex() {		bool Hal::InitDebugReportIndex() {
			ATRACE_CALL();

	uint32_t count;		uint32_t count;
	if (dev_->EnumerateInstanceExtensionProperties(nullptr, &count, nullptr) !=		if (dev_->EnumerateInstanceExtensionProperties(nullptr, &count, nullptr) !=
	VK_SUCCESS) {		VK_SUCCESS) {
	@@ -821,8 +838,10 @@ VkResult EnumerateInstanceExtensionProperties(
	}		}
	}		}

			ATRACE_BEGIN("driver.EnumerateInstanceExtensionProperties");
	VkResult result = Hal::Device().EnumerateInstanceExtensionProperties(		VkResult result = Hal::Device().EnumerateInstanceExtensionProperties(
	pLayerName, pPropertyCount, pProperties);		pLayerName, pPropertyCount, pProperties);
			ATRACE_END();

	if (!pLayerName && (result == VK_SUCCESS \|\| result == VK_INCOMPLETE)) {		if (!pLayerName && (result == VK_SUCCESS \|\| result == VK_INCOMPLETE)) {
	int idx = Hal::Get().GetDebugReportIndex();		int idx = Hal::Get().GetDebugReportIndex();
	@@ -931,8 +950,10 @@ VkResult EnumerateDeviceExtensionProperties(
	*pPropertyCount -= count;		*pPropertyCount -= count;
	}		}

			ATRACE_BEGIN("driver.EnumerateDeviceExtensionProperties");
	VkResult result = data.driver.EnumerateDeviceExtensionProperties(		VkResult result = data.driver.EnumerateDeviceExtensionProperties(
	physicalDevice, pLayerName, pPropertyCount, pProperties);		physicalDevice, pLayerName, pPropertyCount, pProperties);
			ATRACE_END();

	if (pProperties) {		if (pProperties) {
	// map VK_ANDROID_native_buffer to VK_KHR_swapchain		// map VK_ANDROID_native_buffer to VK_KHR_swapchain
	@@ -968,12 +989,15 @@ VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
	if (result != VK_SUCCESS)		if (result != VK_SUCCESS)
	return result;		return result;

			ATRACE_BEGIN("AllocateInstanceData");
	InstanceData* data = AllocateInstanceData(data_allocator);		InstanceData* data = AllocateInstanceData(data_allocator);
			ATRACE_END();
	if (!data)		if (!data)
	return VK_ERROR_OUT_OF_HOST_MEMORY;		return VK_ERROR_OUT_OF_HOST_MEMORY;

	data->hook_extensions \|= wrapper.GetHookExtensions();		data->hook_extensions \|= wrapper.GetHookExtensions();

			ATRACE_BEGIN("autoDowngradeApiVersion");
	#pragma clang diagnostic push		#pragma clang diagnostic push
	#pragma clang diagnostic ignored "-Wold-style-cast"		#pragma clang diagnostic ignored "-Wold-style-cast"
	uint32_t api_version = ((pCreateInfo->pApplicationInfo)		uint32_t api_version = ((pCreateInfo->pApplicationInfo)
	@@ -989,7 +1013,9 @@ VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
	if (!pfn_enumerate_instance_version) {		if (!pfn_enumerate_instance_version) {
	icd_api_version = VK_API_VERSION_1_0;		icd_api_version = VK_API_VERSION_1_0;
	} else {		} else {
			ATRACE_BEGIN("pfn_enumerate_instance_version");
	result = (*pfn_enumerate_instance_version)(&icd_api_version);		result = (*pfn_enumerate_instance_version)(&icd_api_version);
			ATRACE_END();
	}		}
	uint32_t icd_api_major_version = VK_VERSION_MAJOR(icd_api_version);		uint32_t icd_api_major_version = VK_VERSION_MAJOR(icd_api_version);
	uint32_t icd_api_minor_version = VK_VERSION_MINOR(icd_api_version);		uint32_t icd_api_minor_version = VK_VERSION_MINOR(icd_api_version);
	@@ -1000,12 +1026,15 @@ VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
	wrapper.DowngradeApiVersion();		wrapper.DowngradeApiVersion();
	}		}
	#pragma clang diagnostic pop		#pragma clang diagnostic pop
			ATRACE_END();

	// call into the driver		// call into the driver
	VkInstance instance;		VkInstance instance;
			ATRACE_BEGIN("driver.CreateInstance");
	result = Hal::Device().CreateInstance(		result = Hal::Device().CreateInstance(
	static_cast<const VkInstanceCreateInfo*>(wrapper), pAllocator,		static_cast<const VkInstanceCreateInfo*>(wrapper), pAllocator,
	&instance);		&instance);
			ATRACE_END();
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	FreeInstanceData(data, data_allocator);		FreeInstanceData(data, data_allocator);
	return result;		return result;
	@@ -1066,8 +1095,10 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice,
	if (result != VK_SUCCESS)		if (result != VK_SUCCESS)
	return result;		return result;

			ATRACE_BEGIN("AllocateDeviceData");
	DeviceData* data = AllocateDeviceData(data_allocator,		DeviceData* data = AllocateDeviceData(data_allocator,
	instance_data.debug_report_callbacks);		instance_data.debug_report_callbacks);
			ATRACE_END();
	if (!data)		if (!data)
	return VK_ERROR_OUT_OF_HOST_MEMORY;		return VK_ERROR_OUT_OF_HOST_MEMORY;

	@@ -1075,9 +1106,11 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice,

	// call into the driver		// call into the driver
	VkDevice dev;		VkDevice dev;
			ATRACE_BEGIN("driver.CreateDevice");
	result = instance_data.driver.CreateDevice(		result = instance_data.driver.CreateDevice(
	physicalDevice, static_cast<const VkDeviceCreateInfo*>(wrapper),		physicalDevice, static_cast<const VkDeviceCreateInfo*>(wrapper),
	pAllocator, &dev);		pAllocator, &dev);
			ATRACE_END();
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	FreeDeviceData(data, data_allocator);		FreeDeviceData(data, data_allocator);
	return result;		return result;
	@@ -1114,8 +1147,10 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice,
	}		}

	VkPhysicalDeviceProperties properties;		VkPhysicalDeviceProperties properties;
			ATRACE_BEGIN("driver.GetPhysicalDeviceProperties");
	instance_data.driver.GetPhysicalDeviceProperties(physicalDevice,		instance_data.driver.GetPhysicalDeviceProperties(physicalDevice,
	&properties);		&properties);
			ATRACE_END();

	data->driver_device = dev;		data->driver_device = dev;
	data->driver_version = properties.driverVersion;		data->driver_version = properties.driverVersion;
	@@ -1141,6 +1176,8 @@ void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
	VkResult EnumeratePhysicalDevices(VkInstance instance,		VkResult EnumeratePhysicalDevices(VkInstance instance,
	uint32_t* pPhysicalDeviceCount,		uint32_t* pPhysicalDeviceCount,
	VkPhysicalDevice* pPhysicalDevices) {		VkPhysicalDevice* pPhysicalDevices) {
			ATRACE_CALL();

	const auto& data = GetData(instance);		const auto& data = GetData(instance);

	VkResult result = data.driver.EnumeratePhysicalDevices(		VkResult result = data.driver.EnumeratePhysicalDevices(
	@@ -1157,6 +1194,8 @@ VkResult EnumeratePhysicalDeviceGroups(
	VkInstance instance,		VkInstance instance,
	uint32_t* pPhysicalDeviceGroupCount,		uint32_t* pPhysicalDeviceGroupCount,
	VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {		VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
			ATRACE_CALL();

	VkResult result = VK_SUCCESS;		VkResult result = VK_SUCCESS;
	const auto& data = GetData(instance);		const auto& data = GetData(instance);

	@@ -1217,6 +1256,8 @@ void GetDeviceQueue(VkDevice device,
	uint32_t queueFamilyIndex,		uint32_t queueFamilyIndex,
	uint32_t queueIndex,		uint32_t queueIndex,
	VkQueue* pQueue) {		VkQueue* pQueue) {
			ATRACE_CALL();

	const auto& data = GetData(device);		const auto& data = GetData(device);

	data.driver.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);		data.driver.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
	@@ -1226,6 +1267,8 @@ void GetDeviceQueue(VkDevice device,
	void GetDeviceQueue2(VkDevice device,		void GetDeviceQueue2(VkDevice device,
	const VkDeviceQueueInfo2* pQueueInfo,		const VkDeviceQueueInfo2* pQueueInfo,
	VkQueue* pQueue) {		VkQueue* pQueue) {
			ATRACE_CALL();

	const auto& data = GetData(device);		const auto& data = GetData(device);

	data.driver.GetDeviceQueue2(device, pQueueInfo, pQueue);		data.driver.GetDeviceQueue2(device, pQueueInfo, pQueue);
	@@ -1236,6 +1279,8 @@ VKAPI_ATTR VkResult
	AllocateCommandBuffers(VkDevice device,		AllocateCommandBuffers(VkDevice device,
	const VkCommandBufferAllocateInfo* pAllocateInfo,		const VkCommandBufferAllocateInfo* pAllocateInfo,
	VkCommandBuffer* pCommandBuffers) {		VkCommandBuffer* pCommandBuffers) {
			ATRACE_CALL();

	const auto& data = GetData(device);		const auto& data = GetData(device);

	VkResult result = data.driver.AllocateCommandBuffers(device, pAllocateInfo,		VkResult result = data.driver.AllocateCommandBuffers(device, pAllocateInfo,

vulkan/libvulkan/layers_extensions.cpp

+7 −0

Original line number	Original line	Diff line number	Diff line
	@@ -14,6 +14,8 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

			#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	#include "layers_extensions.h"		#include "layers_extensions.h"

	#include <alloca.h>		#include <alloca.h>
	@@ -33,6 +35,7 @@
	#include <log/log.h>		#include <log/log.h>
	#include <nativebridge/native_bridge.h>		#include <nativebridge/native_bridge.h>
	#include <nativeloader/native_loader.h>		#include <nativeloader/native_loader.h>
			#include <utils/Trace.h>
	#include <ziparchive/zip_archive.h>		#include <ziparchive/zip_archive.h>

	// TODO(jessehall): The whole way we deal with extensions is pretty hokey, and		// TODO(jessehall): The whole way we deal with extensions is pretty hokey, and
	@@ -428,6 +431,8 @@ void ForEachFileInPath(const std::string& path, Functor functor) {
	}		}

	void DiscoverLayersInPathList(const std::string& pathstr) {		void DiscoverLayersInPathList(const std::string& pathstr) {
			ATRACE_CALL();

	std::vector<std::string> paths = android::base::Split(pathstr, ":");		std::vector<std::string> paths = android::base::Split(pathstr, ":");
	for (const auto& path : paths) {		for (const auto& path : paths) {
	ForEachFileInPath(path, [&](const std::string& filename) {		ForEachFileInPath(path, [&](const std::string& filename) {
	@@ -477,6 +482,8 @@ void* GetLayerGetProcAddr(const Layer& layer,
	} // anonymous namespace		} // anonymous namespace

	void DiscoverLayers() {		void DiscoverLayers() {
			ATRACE_CALL();

	if (property_get_bool("ro.debuggable", false) &&		if (property_get_bool("ro.debuggable", false) &&
	prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {		prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {
	DiscoverLayersInPathList(kSystemLayerLibraryDir);		DiscoverLayersInPathList(kSystemLayerLibraryDir);

vulkan/libvulkan/swapchain.cpp

+54 −1

Original line number	Original line	Diff line number	Diff line
	@@ -14,6 +14,8 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

			#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	#include <algorithm>		#include <algorithm>

	#include <grallocusage/GrallocUsageConversion.h>		#include <grallocusage/GrallocUsageConversion.h>
	@@ -21,6 +23,7 @@
	#include <ui/BufferQueueDefs.h>		#include <ui/BufferQueueDefs.h>
	#include <sync/sync.h>		#include <sync/sync.h>
	#include <utils/StrongPointer.h>		#include <utils/StrongPointer.h>
			#include <utils/Trace.h>
	#include <utils/Vector.h>		#include <utils/Vector.h>
	#include <system/window.h>		#include <system/window.h>
	#include <android/hardware/graphics/common/1.0/types.h>		#include <android/hardware/graphics/common/1.0/types.h>
	@@ -486,6 +489,8 @@ VkResult CreateAndroidSurfaceKHR(
	const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,		const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
	const VkAllocationCallbacks* allocator,		const VkAllocationCallbacks* allocator,
	VkSurfaceKHR* out_surface) {		VkSurfaceKHR* out_surface) {
			ATRACE_CALL();

	if (!allocator)		if (!allocator)
	allocator = &GetData(instance).allocator;		allocator = &GetData(instance).allocator;
	void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),		void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
	@@ -528,6 +533,8 @@ VKAPI_ATTR
	void DestroySurfaceKHR(VkInstance instance,		void DestroySurfaceKHR(VkInstance instance,
	VkSurfaceKHR surface_handle,		VkSurfaceKHR surface_handle,
	const VkAllocationCallbacks* allocator) {		const VkAllocationCallbacks* allocator) {
			ATRACE_CALL();

	Surface* surface = SurfaceFromHandle(surface_handle);		Surface* surface = SurfaceFromHandle(surface_handle);
	if (!surface)		if (!surface)
	return;		return;
	@@ -548,6 +555,8 @@ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /pdev/,
	uint32_t /queue_family/,		uint32_t /queue_family/,
	VkSurfaceKHR surface_handle,		VkSurfaceKHR surface_handle,
	VkBool32* supported) {		VkBool32* supported) {
			ATRACE_CALL();

	const Surface* surface = SurfaceFromHandle(surface_handle);		const Surface* surface = SurfaceFromHandle(surface_handle);
	if (!surface) {		if (!surface) {
	return VK_ERROR_SURFACE_LOST_KHR;		return VK_ERROR_SURFACE_LOST_KHR;
	@@ -589,6 +598,8 @@ VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
	VkPhysicalDevice /pdev/,		VkPhysicalDevice /pdev/,
	VkSurfaceKHR surface,		VkSurfaceKHR surface,
	VkSurfaceCapabilitiesKHR* capabilities) {		VkSurfaceCapabilitiesKHR* capabilities) {
			ATRACE_CALL();

	int err;		int err;
	ANativeWindow* window = SurfaceFromHandle(surface)->window.get();		ANativeWindow* window = SurfaceFromHandle(surface)->window.get();

	@@ -662,6 +673,8 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
	VkSurfaceKHR surface_handle,		VkSurfaceKHR surface_handle,
	uint32_t* count,		uint32_t* count,
	VkSurfaceFormatKHR* formats) {		VkSurfaceFormatKHR* formats) {
			ATRACE_CALL();

	const InstanceData& instance_data = GetData(pdev);		const InstanceData& instance_data = GetData(pdev);

	// TODO(jessehall): Fill out the set of supported formats. Longer term, add		// TODO(jessehall): Fill out the set of supported formats. Longer term, add
	@@ -734,6 +747,8 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR(
	VkPhysicalDevice physicalDevice,		VkPhysicalDevice physicalDevice,
	const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,		const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
	VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {		VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
			ATRACE_CALL();

	VkResult result = GetPhysicalDeviceSurfaceCapabilitiesKHR(		VkResult result = GetPhysicalDeviceSurfaceCapabilitiesKHR(
	physicalDevice, pSurfaceInfo->surface,		physicalDevice, pSurfaceInfo->surface,
	&pSurfaceCapabilities->surfaceCapabilities);		&pSurfaceCapabilities->surfaceCapabilities);
	@@ -769,6 +784,8 @@ VkResult GetPhysicalDeviceSurfaceFormats2KHR(
	const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,		const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
	uint32_t* pSurfaceFormatCount,		uint32_t* pSurfaceFormatCount,
	VkSurfaceFormat2KHR* pSurfaceFormats) {		VkSurfaceFormat2KHR* pSurfaceFormats) {
			ATRACE_CALL();

	if (!pSurfaceFormats) {		if (!pSurfaceFormats) {
	return GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,		return GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,
	pSurfaceInfo->surface,		pSurfaceInfo->surface,
	@@ -800,6 +817,8 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
	VkSurfaceKHR surface,		VkSurfaceKHR surface,
	uint32_t* count,		uint32_t* count,
	VkPresentModeKHR* modes) {		VkPresentModeKHR* modes) {
			ATRACE_CALL();

	int err;		int err;
	int query_value;		int query_value;
	ANativeWindow* window = SurfaceFromHandle(surface)->window.get();		ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
	@@ -851,6 +870,8 @@ VKAPI_ATTR
	VkResult GetDeviceGroupPresentCapabilitiesKHR(		VkResult GetDeviceGroupPresentCapabilitiesKHR(
	VkDevice,		VkDevice,
	VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {		VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
			ATRACE_CALL();

	ALOGV_IF(pDeviceGroupPresentCapabilities->sType !=		ALOGV_IF(pDeviceGroupPresentCapabilities->sType !=
	VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,		VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
	"vkGetDeviceGroupPresentCapabilitiesKHR: invalid "		"vkGetDeviceGroupPresentCapabilitiesKHR: invalid "
	@@ -873,6 +894,8 @@ VkResult GetDeviceGroupSurfacePresentModesKHR(
	VkDevice,		VkDevice,
	VkSurfaceKHR,		VkSurfaceKHR,
	VkDeviceGroupPresentModeFlagsKHR* pModes) {		VkDeviceGroupPresentModeFlagsKHR* pModes) {
			ATRACE_CALL();

	*pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;		*pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR;
	return VK_SUCCESS;		return VK_SUCCESS;
	}		}
	@@ -882,6 +905,8 @@ VkResult GetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice,
	VkSurfaceKHR surface,		VkSurfaceKHR surface,
	uint32_t* pRectCount,		uint32_t* pRectCount,
	VkRect2D* pRects) {		VkRect2D* pRects) {
			ATRACE_CALL();

	if (!pRects) {		if (!pRects) {
	*pRectCount = 1;		*pRectCount = 1;
	} else {		} else {
	@@ -923,6 +948,8 @@ VkResult CreateSwapchainKHR(VkDevice device,
	const VkSwapchainCreateInfoKHR* create_info,		const VkSwapchainCreateInfoKHR* create_info,
	const VkAllocationCallbacks* allocator,		const VkAllocationCallbacks* allocator,
	VkSwapchainKHR* swapchain_handle) {		VkSwapchainKHR* swapchain_handle) {
			ATRACE_CALL();

	int err;		int err;
	VkResult result = VK_SUCCESS;		VkResult result = VK_SUCCESS;

	@@ -1147,9 +1174,11 @@ VkResult CreateSwapchainKHR(VkDevice device,
	int32_t legacy_usage = 0;		int32_t legacy_usage = 0;
	if (dispatch.GetSwapchainGrallocUsage2ANDROID) {		if (dispatch.GetSwapchainGrallocUsage2ANDROID) {
	uint64_t consumer_usage, producer_usage;		uint64_t consumer_usage, producer_usage;
			ATRACE_BEGIN("dispatch.GetSwapchainGrallocUsage2ANDROID");
	result = dispatch.GetSwapchainGrallocUsage2ANDROID(		result = dispatch.GetSwapchainGrallocUsage2ANDROID(
	device, create_info->imageFormat, create_info->imageUsage,		device, create_info->imageFormat, create_info->imageUsage,
	swapchain_image_usage, &consumer_usage, &producer_usage);		swapchain_image_usage, &consumer_usage, &producer_usage);
			ATRACE_END();
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);		ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);
	return VK_ERROR_SURFACE_LOST_KHR;		return VK_ERROR_SURFACE_LOST_KHR;
	@@ -1157,9 +1186,11 @@ VkResult CreateSwapchainKHR(VkDevice device,
	legacy_usage =		legacy_usage =
	android_convertGralloc1To0Usage(producer_usage, consumer_usage);		android_convertGralloc1To0Usage(producer_usage, consumer_usage);
	} else if (dispatch.GetSwapchainGrallocUsageANDROID) {		} else if (dispatch.GetSwapchainGrallocUsageANDROID) {
			ATRACE_BEGIN("dispatch.GetSwapchainGrallocUsageANDROID");
	result = dispatch.GetSwapchainGrallocUsageANDROID(		result = dispatch.GetSwapchainGrallocUsageANDROID(
	device, create_info->imageFormat, create_info->imageUsage,		device, create_info->imageFormat, create_info->imageUsage,
	&legacy_usage);		&legacy_usage);
			ATRACE_END();
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);		ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
	return VK_ERROR_SURFACE_LOST_KHR;		return VK_ERROR_SURFACE_LOST_KHR;
	@@ -1254,8 +1285,10 @@ VkResult CreateSwapchainKHR(VkDevice device,
	&image_native_buffer.usage2.producer,		&image_native_buffer.usage2.producer,
	&image_native_buffer.usage2.consumer);		&image_native_buffer.usage2.consumer);

			ATRACE_BEGIN("dispatch.CreateImage");
	result =		result =
	dispatch.CreateImage(device, &image_create, nullptr, &img.image);		dispatch.CreateImage(device, &image_create, nullptr, &img.image);
			ATRACE_END();
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	ALOGD("vkCreateImage w/ native buffer failed: %u", result);		ALOGD("vkCreateImage w/ native buffer failed: %u", result);
	break;		break;
	@@ -1279,8 +1312,11 @@ VkResult CreateSwapchainKHR(VkDevice device,
	}		}
	}		}
	if (result != VK_SUCCESS) {		if (result != VK_SUCCESS) {
	if (img.image)		if (img.image) {
			ATRACE_BEGIN("dispatch.DestroyImage");
	dispatch.DestroyImage(device, img.image, nullptr);		dispatch.DestroyImage(device, img.image, nullptr);
			ATRACE_END();
			}
	}		}
	}		}

	@@ -1299,6 +1335,8 @@ VKAPI_ATTR
	void DestroySwapchainKHR(VkDevice device,		void DestroySwapchainKHR(VkDevice device,
	VkSwapchainKHR swapchain_handle,		VkSwapchainKHR swapchain_handle,
	const VkAllocationCallbacks* allocator) {		const VkAllocationCallbacks* allocator) {
			ATRACE_CALL();

	const auto& dispatch = GetData(device).driver;		const auto& dispatch = GetData(device).driver;
	Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);		Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
	if (!swapchain)		if (!swapchain)
	@@ -1324,6 +1362,8 @@ VkResult GetSwapchainImagesKHR(VkDevice,
	VkSwapchainKHR swapchain_handle,		VkSwapchainKHR swapchain_handle,
	uint32_t* count,		uint32_t* count,
	VkImage* images) {		VkImage* images) {
			ATRACE_CALL();

	Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);		Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
	ALOGW_IF(swapchain.surface.swapchain_handle != swapchain_handle,		ALOGW_IF(swapchain.surface.swapchain_handle != swapchain_handle,
	"getting images for non-active swapchain 0x%" PRIx64		"getting images for non-active swapchain 0x%" PRIx64
	@@ -1352,6 +1392,8 @@ VkResult AcquireNextImageKHR(VkDevice device,
	VkSemaphore semaphore,		VkSemaphore semaphore,
	VkFence vk_fence,		VkFence vk_fence,
	uint32_t* image_index) {		uint32_t* image_index) {
			ATRACE_CALL();

	Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);		Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
	ANativeWindow* window = swapchain.surface.window.get();		ANativeWindow* window = swapchain.surface.window.get();
	VkResult result;		VkResult result;
	@@ -1432,6 +1474,8 @@ VKAPI_ATTR
	VkResult AcquireNextImage2KHR(VkDevice device,		VkResult AcquireNextImage2KHR(VkDevice device,
	const VkAcquireNextImageInfoKHR* pAcquireInfo,		const VkAcquireNextImageInfoKHR* pAcquireInfo,
	uint32_t* pImageIndex) {		uint32_t* pImageIndex) {
			ATRACE_CALL();

	// TODO: this should actually be the other way around and this function		// TODO: this should actually be the other way around and this function
	// should handle any additional structures that get passed in		// should handle any additional structures that get passed in
	return AcquireNextImageKHR(device, pAcquireInfo->swapchain,		return AcquireNextImageKHR(device, pAcquireInfo->swapchain,
	@@ -1461,6 +1505,8 @@ static VkResult WorstPresentResult(VkResult a, VkResult b) {

	VKAPI_ATTR		VKAPI_ATTR
	VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {		VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
			ATRACE_CALL();

	ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,		ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
	"vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",		"vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
	present_info->sType);		present_info->sType);
	@@ -1672,6 +1718,8 @@ VkResult GetRefreshCycleDurationGOOGLE(
	VkDevice,		VkDevice,
	VkSwapchainKHR swapchain_handle,		VkSwapchainKHR swapchain_handle,
	VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {		VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
			ATRACE_CALL();

	Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);		Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
	VkResult result = VK_SUCCESS;		VkResult result = VK_SUCCESS;

	@@ -1687,6 +1735,8 @@ VkResult GetPastPresentationTimingGOOGLE(
	VkSwapchainKHR swapchain_handle,		VkSwapchainKHR swapchain_handle,
	uint32_t* count,		uint32_t* count,
	VkPastPresentationTimingGOOGLE* timings) {		VkPastPresentationTimingGOOGLE* timings) {
			ATRACE_CALL();

	Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);		Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
	ANativeWindow* window = swapchain.surface.window.get();		ANativeWindow* window = swapchain.surface.window.get();
	VkResult result = VK_SUCCESS;		VkResult result = VK_SUCCESS;
	@@ -1711,6 +1761,8 @@ VKAPI_ATTR
	VkResult GetSwapchainStatusKHR(		VkResult GetSwapchainStatusKHR(
	VkDevice,		VkDevice,
	VkSwapchainKHR swapchain_handle) {		VkSwapchainKHR swapchain_handle) {
			ATRACE_CALL();

	Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);		Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
	VkResult result = VK_SUCCESS;		VkResult result = VK_SUCCESS;

	@@ -1728,6 +1780,7 @@ VKAPI_ATTR void SetHdrMetadataEXT(
	uint32_t swapchainCount,		uint32_t swapchainCount,
	const VkSwapchainKHR* pSwapchains,		const VkSwapchainKHR* pSwapchains,
	const VkHdrMetadataEXT* pHdrMetadataEXTs) {		const VkHdrMetadataEXT* pHdrMetadataEXTs) {
			ATRACE_CALL();

	for (uint32_t idx = 0; idx < swapchainCount; idx++) {		for (uint32_t idx = 0; idx < swapchainCount; idx++) {
	Swapchain* swapchain = SwapchainFromHandle(pSwapchains[idx]);		Swapchain* swapchain = SwapchainFromHandle(pSwapchains[idx]);