From d4fd1225b75b9fefd24a4911dbf60e2b7f45c8b3 Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Fri, 3 Jul 2020 22:18:42 -0700 Subject: libvulkan: add SanitizeApiVersion to unify api downgrade and upgrade Bug: 160276146 Test: hardcode 1.0 icd instance and run vkjson Change-Id: Ib45098eea676de1afc5994a92781e90bad8cd13a --- vulkan/libvulkan/driver.cpp | 181 ++++++++++++++++++++------------------------ 1 file changed, 84 insertions(+), 97 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 74ef0e7073..3e31a66d78 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -102,8 +102,6 @@ class CreateInfoWrapper { ~CreateInfoWrapper(); VkResult Validate(); - void DowngradeApiVersion(); - void UpgradeDeviceCoreApiVersion(uint32_t api_version); const std::bitset& GetHookExtensions() const; const std::bitset& GetHalExtensions() const; @@ -120,8 +118,8 @@ class CreateInfoWrapper { uint32_t name_count; }; + VkResult SanitizeApiVersion(); VkResult SanitizePNext(); - VkResult SanitizeLayers(); VkResult SanitizeExtensions(); @@ -133,6 +131,7 @@ class CreateInfoWrapper { const bool is_instance_; const VkAllocationCallbacks& allocator_; + const uint32_t loader_api_version_; VkPhysicalDevice physical_dev_; @@ -327,29 +326,20 @@ CreateInfoWrapper::CreateInfoWrapper(const VkInstanceCreateInfo& create_info, const VkAllocationCallbacks& allocator) : is_instance_(true), allocator_(allocator), + loader_api_version_(VK_API_VERSION_1_1), physical_dev_(VK_NULL_HANDLE), instance_info_(create_info), - extension_filter_() { - // instance core versions need to match the loader api version - for (uint32_t i = ProcHook::EXTENSION_CORE_1_0; - i != ProcHook::EXTENSION_COUNT; ++i) { - hook_extensions_.set(i); - hal_extensions_.set(i); - } -} + extension_filter_() {} CreateInfoWrapper::CreateInfoWrapper(VkPhysicalDevice physical_dev, const VkDeviceCreateInfo& create_info, const VkAllocationCallbacks& allocator) : is_instance_(false), allocator_(allocator), + loader_api_version_(VK_API_VERSION_1_1), physical_dev_(physical_dev), dev_info_(create_info), - extension_filter_() { - // initialize with baseline core API version - hook_extensions_.set(ProcHook::EXTENSION_CORE_1_0); - hal_extensions_.set(ProcHook::EXTENSION_CORE_1_0); -} + extension_filter_() {} CreateInfoWrapper::~CreateInfoWrapper() { allocator_.pfnFree(allocator_.pUserData, extension_filter_.exts); @@ -357,7 +347,9 @@ CreateInfoWrapper::~CreateInfoWrapper() { } VkResult CreateInfoWrapper::Validate() { - VkResult result = SanitizePNext(); + VkResult result = SanitizeApiVersion(); + if (result == VK_SUCCESS) + result = SanitizePNext(); if (result == VK_SUCCESS) result = SanitizeLayers(); if (result == VK_SUCCESS) @@ -384,6 +376,81 @@ CreateInfoWrapper::operator const VkDeviceCreateInfo*() const { return &dev_info_; } +VkResult CreateInfoWrapper::SanitizeApiVersion() { + if (is_instance_) { + // instance core versions need to match the loader api version + for (uint32_t i = ProcHook::EXTENSION_CORE_1_0; + i != ProcHook::EXTENSION_COUNT; i++) { + hook_extensions_.set(i); + hal_extensions_.set(i); + } + + // If pApplicationInfo is NULL, apiVersion is assumed to be 1.0 + if (!instance_info_.pApplicationInfo) + return VK_SUCCESS; + + uint32_t icd_api_version = VK_API_VERSION_1_0; + PFN_vkEnumerateInstanceVersion pfn_enumerate_instance_version = + reinterpret_cast( + Hal::Device().GetInstanceProcAddr( + nullptr, "vkEnumerateInstanceVersion")); + if (pfn_enumerate_instance_version) { + ATRACE_BEGIN("pfn_enumerate_instance_version"); + VkResult result = + (*pfn_enumerate_instance_version)(&icd_api_version); + ATRACE_END(); + if (result != VK_SUCCESS) + return result; + + icd_api_version ^= VK_VERSION_PATCH(icd_api_version); + } + + if (icd_api_version < VK_API_VERSION_1_0) + return VK_SUCCESS; + + if (icd_api_version < loader_api_version_) { + application_info_ = *instance_info_.pApplicationInfo; + application_info_.apiVersion = icd_api_version; + instance_info_.pApplicationInfo = &application_info_; + } + } else { + const auto& driver = GetData(physical_dev_).driver; + + VkPhysicalDeviceProperties properties; + ATRACE_BEGIN("driver.GetPhysicalDeviceProperties"); + driver.GetPhysicalDeviceProperties(physical_dev_, &properties); + ATRACE_END(); + + if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) { + // Log that the app is hitting software Vulkan implementation + android::GraphicsEnv::getInstance().setTargetStats( + android::GpuStatsInfo::Stats::CPU_VULKAN_IN_USE); + } + + uint32_t api_version = properties.apiVersion; + api_version ^= VK_VERSION_PATCH(api_version); + + if (api_version > loader_api_version_) + api_version = loader_api_version_; + + switch (api_version) { + case VK_API_VERSION_1_1: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_1); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_1); + [[clang::fallthrough]]; + case VK_API_VERSION_1_0: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_0); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_0); + break; + default: + ALOGE("Unknown API version[%u]", api_version); + break; + } + } + + return VK_SUCCESS; +} + VkResult CreateInfoWrapper::SanitizePNext() { const struct StructHeader { VkStructureType type; @@ -636,40 +703,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { } } -void CreateInfoWrapper::DowngradeApiVersion() { - // If pApplicationInfo is NULL, apiVersion is assumed to be 1.0: - if (instance_info_.pApplicationInfo) { - application_info_ = *instance_info_.pApplicationInfo; - instance_info_.pApplicationInfo = &application_info_; - application_info_.apiVersion = VK_API_VERSION_1_0; - } -} - -void CreateInfoWrapper::UpgradeDeviceCoreApiVersion(uint32_t api_version) { - ALOG_ASSERT(!is_instance_, "Device only API called by instance wrapper."); - -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wold-style-cast" - api_version ^= VK_VERSION_PATCH(api_version); -#pragma clang diagnostic pop - - // cap the API version to the loader supported highest version - if (api_version > VK_API_VERSION_1_1) - api_version = VK_API_VERSION_1_1; - - switch (api_version) { - case VK_API_VERSION_1_1: - hook_extensions_.set(ProcHook::EXTENSION_CORE_1_1); - hal_extensions_.set(ProcHook::EXTENSION_CORE_1_1); - [[clang::fallthrough]]; - case VK_API_VERSION_1_0: - break; - default: - ALOGD("Unknown upgrade API version[%u]", api_version); - break; - } -} - VKAPI_ATTR void* DefaultAllocate(void*, size_t size, size_t alignment, @@ -1032,45 +1065,12 @@ VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, if (result != VK_SUCCESS) return result; - ATRACE_BEGIN("AllocateInstanceData"); InstanceData* data = AllocateInstanceData(data_allocator); - ATRACE_END(); if (!data) return VK_ERROR_OUT_OF_HOST_MEMORY; data->hook_extensions |= wrapper.GetHookExtensions(); - ATRACE_BEGIN("autoDowngradeApiVersion"); -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wold-style-cast" - uint32_t api_version = ((pCreateInfo->pApplicationInfo) - ? pCreateInfo->pApplicationInfo->apiVersion - : VK_API_VERSION_1_0); - uint32_t api_major_version = VK_VERSION_MAJOR(api_version); - uint32_t api_minor_version = VK_VERSION_MINOR(api_version); - uint32_t icd_api_version; - PFN_vkEnumerateInstanceVersion pfn_enumerate_instance_version = - reinterpret_cast( - Hal::Device().GetInstanceProcAddr(nullptr, - "vkEnumerateInstanceVersion")); - if (!pfn_enumerate_instance_version) { - icd_api_version = VK_API_VERSION_1_0; - } else { - ATRACE_BEGIN("pfn_enumerate_instance_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_minor_version = VK_VERSION_MINOR(icd_api_version); - - if ((icd_api_major_version == 1) && (icd_api_minor_version == 0) && - ((api_major_version > 1) || (api_minor_version > 0))) { - api_version = VK_API_VERSION_1_0; - wrapper.DowngradeApiVersion(); - } -#pragma clang diagnostic pop - ATRACE_END(); - // call into the driver VkInstance instance; ATRACE_BEGIN("driver.CreateInstance"); @@ -1145,13 +1145,6 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice, if (!data) return VK_ERROR_OUT_OF_HOST_MEMORY; - VkPhysicalDeviceProperties properties; - ATRACE_BEGIN("driver.GetPhysicalDeviceProperties"); - instance_data.driver.GetPhysicalDeviceProperties(physicalDevice, - &properties); - ATRACE_END(); - - wrapper.UpgradeDeviceCoreApiVersion(properties.apiVersion); data->hook_extensions |= wrapper.GetHookExtensions(); // call into the driver @@ -1196,12 +1189,6 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice, return VK_ERROR_INCOMPATIBLE_DRIVER; } - if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) { - // Log that the app is hitting software Vulkan implementation - android::GraphicsEnv::getInstance().setTargetStats( - android::GpuStatsInfo::Stats::CPU_VULKAN_IN_USE); - } - data->driver_device = dev; *pDevice = dev; -- cgit v1.2.3-59-g8ed1b From 7c0c07c4e86c5224e12fdff04f2ec4153dd288bb Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Sat, 4 Jul 2020 23:49:47 -0700 Subject: libvulkan: enable promoted instance extensions for 1.0 icd instance QueryPresentationProperties requires GetPhysicalDeviceProperties2KHR, however, for 1.0 icd instance, GPDP2 extension needs to be enabled by the loader since the loader advertises 1.1 instance support. Bug: 160276146 Test: dEQP-VK.wsi.android.shared_presentable_image* Change-Id: Id0195d4a115e78e1d82b719059de271cd29446e0 --- vulkan/libvulkan/driver.cpp | 57 +++++++++++++++++++++++++++++--------- vulkan/libvulkan/driver_gen.cpp | 48 ++++++++++++++++++++++++++++++++ vulkan/libvulkan/driver_gen.h | 8 ++++++ vulkan/scripts/driver_generator.py | 56 +++++++++++++++++++++++++++++++++++++ vulkan/scripts/generator_common.py | 17 ++++++++++++ 5 files changed, 173 insertions(+), 13 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 3e31a66d78..c48d1eebf7 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -141,6 +141,7 @@ class CreateInfoWrapper { }; VkApplicationInfo application_info_; + uint32_t sanitized_api_version_; ExtensionFilter extension_filter_; @@ -329,6 +330,7 @@ CreateInfoWrapper::CreateInfoWrapper(const VkInstanceCreateInfo& create_info, loader_api_version_(VK_API_VERSION_1_1), physical_dev_(VK_NULL_HANDLE), instance_info_(create_info), + sanitized_api_version_(loader_api_version_), extension_filter_() {} CreateInfoWrapper::CreateInfoWrapper(VkPhysicalDevice physical_dev, @@ -385,10 +387,6 @@ VkResult CreateInfoWrapper::SanitizeApiVersion() { hal_extensions_.set(i); } - // If pApplicationInfo is NULL, apiVersion is assumed to be 1.0 - if (!instance_info_.pApplicationInfo) - return VK_SUCCESS; - uint32_t icd_api_version = VK_API_VERSION_1_0; PFN_vkEnumerateInstanceVersion pfn_enumerate_instance_version = reinterpret_cast( @@ -409,8 +407,13 @@ VkResult CreateInfoWrapper::SanitizeApiVersion() { return VK_SUCCESS; if (icd_api_version < loader_api_version_) { + sanitized_api_version_ = icd_api_version; + + if (!instance_info_.pApplicationInfo) + return VK_SUCCESS; + application_info_ = *instance_info_.pApplicationInfo; - application_info_.apiVersion = icd_api_version; + application_info_.apiVersion = sanitized_api_version_; instance_info_.pApplicationInfo = &application_info_; } } else { @@ -498,15 +501,33 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { : dev_info_.ppEnabledExtensionNames; auto& ext_count = (is_instance_) ? instance_info_.enabledExtensionCount : dev_info_.enabledExtensionCount; - if (!ext_count) - return VK_SUCCESS; VkResult result = InitExtensionFilter(); if (result != VK_SUCCESS) return result; - for (uint32_t i = 0; i < ext_count; i++) - FilterExtension(ext_names[i]); + if (is_instance_ && sanitized_api_version_ < loader_api_version_) { + for (uint32_t i = 0; i < ext_count; i++) { + // Upon api downgrade, skip the promoted instance extensions in the + // first pass to avoid duplicate extensions. + const std::optional version = + GetInstanceExtensionPromotedVersion(ext_names[i]); + if (version && *version > sanitized_api_version_ && + *version <= loader_api_version_) + continue; + + FilterExtension(ext_names[i]); + } + + // Enable the required extensions to support core functionalities. + const auto promoted_extensions = GetPromotedInstanceExtensions( + sanitized_api_version_, loader_api_version_); + for (const auto& promoted_extension : promoted_extensions) + FilterExtension(promoted_extension); + } else { + for (uint32_t i = 0; i < ext_count; i++) + FilterExtension(ext_names[i]); + } // Enable device extensions that contain physical-device commands, so that // vkGetInstanceProcAddr will return those physical-device commands. @@ -571,10 +592,20 @@ VkResult CreateInfoWrapper::InitExtensionFilter() { filter.ext_count = count; // allocate name array - uint32_t enabled_ext_count = (is_instance_) - ? instance_info_.enabledExtensionCount - : dev_info_.enabledExtensionCount; - count = std::min(filter.ext_count, enabled_ext_count); + if (is_instance_) { + uint32_t enabled_ext_count = instance_info_.enabledExtensionCount; + + // It requires enabling additional promoted extensions to downgrade api, + // so we reserve enough space here. + if (sanitized_api_version_ < loader_api_version_) { + enabled_ext_count += CountPromotedInstanceExtensions( + sanitized_api_version_, loader_api_version_); + } + + count = std::min(filter.ext_count, enabled_ext_count); + } else { + count = std::min(filter.ext_count, dev_info_.enabledExtensionCount); + } filter.names = reinterpret_cast(allocator_.pfnAllocation( allocator_.pUserData, sizeof(const char*) * count, alignof(const char*), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND)); diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 52205e9e79..39fd15a6cc 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -577,5 +577,53 @@ bool InitDriverTable(VkDevice dev, return success; } +const std::pair g_promoted_instance_extensions[] = { + // clang-format off + std::make_pair("VK_KHR_device_group_creation", VK_API_VERSION_1_1), + std::make_pair("VK_KHR_external_fence_capabilities", VK_API_VERSION_1_1), + std::make_pair("VK_KHR_external_memory_capabilities", VK_API_VERSION_1_1), + std::make_pair("VK_KHR_external_semaphore_capabilities", VK_API_VERSION_1_1), + std::make_pair("VK_KHR_get_physical_device_properties2", VK_API_VERSION_1_1), + // clang-format on +}; + +std::optional GetInstanceExtensionPromotedVersion(const char* name) { + auto begin = std::cbegin(g_promoted_instance_extensions); + auto end = std::cend(g_promoted_instance_extensions); + auto iter = + std::lower_bound(begin, end, name, + [](const std::pair& e, + const char* n) { return strcmp(e.first, n) < 0; }); + return (iter < end && strcmp(iter->first, name) == 0) + ? std::optional(iter->second) + : std::nullopt; +} + +uint32_t CountPromotedInstanceExtensions(uint32_t begin_version, + uint32_t end_version) { + auto begin = std::cbegin(g_promoted_instance_extensions); + auto end = std::cend(g_promoted_instance_extensions); + uint32_t count = 0; + + for (auto iter = begin; iter != end; iter++) + if (iter->second > begin_version && iter->second <= end_version) + count++; + + return count; +} + +std::vector GetPromotedInstanceExtensions(uint32_t begin_version, + uint32_t end_version) { + auto begin = std::cbegin(g_promoted_instance_extensions); + auto end = std::cend(g_promoted_instance_extensions); + std::vector extensions; + + for (auto iter = begin; iter != end; iter++) + if (iter->second > begin_version && iter->second <= end_version) + extensions.emplace_back(iter->first); + + return extensions; +} + } // namespace driver } // namespace vulkan diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 43c4d1469e..4669c25dd8 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -23,6 +23,8 @@ #include #include +#include +#include namespace vulkan { namespace driver { @@ -109,6 +111,12 @@ bool InitDriverTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc, const std::bitset& extensions); +std::optional GetInstanceExtensionPromotedVersion(const char* name); +uint32_t CountPromotedInstanceExtensions(uint32_t begin_version, + uint32_t end_version); +std::vector GetPromotedInstanceExtensions(uint32_t begin_version, + uint32_t end_version); + } // namespace driver } // namespace vulkan diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index a64a7026db..5e78c62df8 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -162,6 +162,8 @@ def gen_h(): #include #include +#include +#include namespace vulkan { namespace driver { @@ -229,6 +231,12 @@ bool InitDriverTable(VkDevice dev, PFN_vkGetDeviceProcAddr get_proc, const std::bitset& extensions); +std::optional GetInstanceExtensionPromotedVersion(const char* name); +uint32_t CountPromotedInstanceExtensions(uint32_t begin_version, + uint32_t end_version); +std::vector GetPromotedInstanceExtensions(uint32_t begin_version, + uint32_t end_version); + } // namespace driver } // namespace vulkan @@ -539,6 +547,54 @@ bool InitDriverTable(VkDevice dev, return success; } +const std::pair g_promoted_instance_extensions[] = { + // clang-format off\n""") + + for key, value in sorted(gencom.promoted_inst_ext_dict.items()): + f.write(gencom.indent(1) + 'std::make_pair("' + key + '", ' + value + '),\n') + + f.write("""\ + // clang-format on +}; + +std::optional GetInstanceExtensionPromotedVersion(const char* name) { + auto begin = std::cbegin(g_promoted_instance_extensions); + auto end = std::cend(g_promoted_instance_extensions); + auto iter = + std::lower_bound(begin, end, name, + [](const std::pair& e, + const char* n) { return strcmp(e.first, n) < 0; }); + return (iter < end && strcmp(iter->first, name) == 0) + ? std::optional(iter->second) + : std::nullopt; +} + +uint32_t CountPromotedInstanceExtensions(uint32_t begin_version, + uint32_t end_version) { + auto begin = std::cbegin(g_promoted_instance_extensions); + auto end = std::cend(g_promoted_instance_extensions); + uint32_t count = 0; + + for (auto iter = begin; iter != end; iter++) + if (iter->second > begin_version && iter->second <= end_version) + count++; + + return count; +} + +std::vector GetPromotedInstanceExtensions(uint32_t begin_version, + uint32_t end_version) { + auto begin = std::cbegin(g_promoted_instance_extensions); + auto end = std::cend(g_promoted_instance_extensions); + std::vector extensions; + + for (auto iter = begin; iter != end; iter++) + if (iter->second > begin_version && iter->second <= end_version) + extensions.emplace_back(iter->first); + + return extensions; +} + } // namespace driver } // namespace vulkan\n""") diff --git a/vulkan/scripts/generator_common.py b/vulkan/scripts/generator_common.py index ef0719db64..ef021f2462 100644 --- a/vulkan/scripts/generator_common.py +++ b/vulkan/scripts/generator_common.py @@ -97,6 +97,9 @@ version_code_list = [] # Dict for mapping a function to the core Vulkan API version. version_dict = {} +# Dict for mapping a promoted instance extension to the core Vulkan API version. +promoted_inst_ext_dict = {} + def indent(num): """Returns the requested indents. @@ -183,6 +186,15 @@ def version_code(version): return version[11:] +def version_2_api_version(version): + """Returns the api version from a version string. + + Args: + version: Vulkan version string. + """ + return 'VK_API' + version[2:] + + def is_function_supported(cmd): """Returns true if a function is core or from a supportable extension. @@ -327,6 +339,7 @@ def parse_vulkan_registry(): return_type_dict version_code_list version_dict + promoted_inst_ext_dict """ registry = os.path.join(os.path.dirname(__file__), '..', '..', '..', '..', 'external', 'vulkan-headers', 'registry', 'vk.xml') @@ -379,6 +392,10 @@ def parse_vulkan_registry(): apiversion = '' if extension.tag == 'extension': extname = extension.get('name') + if (extension.get('type') == 'instance' and + extension.get('promotedto') is not None): + promoted_inst_ext_dict[extname] = \ + version_2_api_version(extension.get('promotedto')) for req in extension: if req.get('feature') is not None: apiversion = req.get('feature') -- cgit v1.2.3-59-g8ed1b From e4f64170c9c754b7c87ce138a5d7493964bd9204 Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Sun, 5 Jul 2020 15:17:32 -0700 Subject: libvulkan: fix support for 1.1 vkEnumeratePhysicalDeviceGroups When the icd instance is 1.0, VK_KHR_device_group_creation will be enabled by the loader if the extension is advertised. Then we will try to use vkEnumeratePhysicalDeviceGroupsKHR as a fallback. Bug: 160276146 Test: adb shell cmd gpu vkjson Test: dEQP-VK.api.info.instance.physical_device_groups Change-Id: I9e2d9af66e80244f1d43b54ac2800316200c0d00 --- vulkan/libvulkan/driver.cpp | 17 +++++++++++++---- vulkan/libvulkan/driver_gen.cpp | 2 ++ vulkan/libvulkan/driver_gen.h | 2 ++ vulkan/scripts/driver_generator.py | 4 ++++ 4 files changed, 21 insertions(+), 4 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index c48d1eebf7..f2712d1f99 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -633,6 +633,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { hook_extensions_.set(ext_bit); break; case ProcHook::KHR_get_physical_device_properties2: + case ProcHook::KHR_device_group_creation: case ProcHook::EXTENSION_UNKNOWN: // Extensions we don't need to do anything about at this level break; @@ -689,6 +690,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_android_surface: case ProcHook::KHR_get_physical_device_properties2: + case ProcHook::KHR_device_group_creation: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::KHR_surface: case ProcHook::EXT_debug_report: @@ -1266,7 +1268,8 @@ VkResult EnumeratePhysicalDeviceGroups( VkResult result = VK_SUCCESS; const auto& data = GetData(instance); - if (!data.driver.EnumeratePhysicalDeviceGroups) { + if (!data.driver.EnumeratePhysicalDeviceGroups && + !data.driver.EnumeratePhysicalDeviceGroupsKHR) { uint32_t device_count = 0; result = EnumeratePhysicalDevices(instance, &device_count, nullptr); if (result < 0) @@ -1298,9 +1301,15 @@ VkResult EnumeratePhysicalDeviceGroups( pPhysicalDeviceGroupProperties[i].subsetAllocation = 0; } } else { - result = data.driver.EnumeratePhysicalDeviceGroups( - instance, pPhysicalDeviceGroupCount, - pPhysicalDeviceGroupProperties); + if (data.driver.EnumeratePhysicalDeviceGroups) { + result = data.driver.EnumeratePhysicalDeviceGroups( + instance, pPhysicalDeviceGroupCount, + pPhysicalDeviceGroupProperties); + } else { + result = data.driver.EnumeratePhysicalDeviceGroupsKHR( + instance, pPhysicalDeviceGroupCount, + pPhysicalDeviceGroupProperties); + } if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && *pPhysicalDeviceGroupCount && pPhysicalDeviceGroupProperties) { for (uint32_t i = 0; i < *pPhysicalDeviceGroupCount; i++) { diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 39fd15a6cc..36577c2622 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -505,6 +505,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_ANDROID_external_memory_android_hardware_buffer") == 0) return ProcHook::ANDROID_external_memory_android_hardware_buffer; if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2; if (strcmp(name, "VK_KHR_get_physical_device_properties2") == 0) return ProcHook::KHR_get_physical_device_properties2; + if (strcmp(name, "VK_KHR_device_group_creation") == 0) return ProcHook::KHR_device_group_creation; // clang-format on return ProcHook::EXTENSION_UNKNOWN; } @@ -546,6 +547,7 @@ bool InitDriverTable(VkInstance instance, INIT_PROC(false, instance, GetPhysicalDeviceProperties2); INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceProperties2KHR); INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups); + INIT_PROC_EXT(KHR_device_group_creation, true, instance, EnumeratePhysicalDeviceGroupsKHR); // clang-format on return success; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 4669c25dd8..dda9bb1194 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -50,6 +50,7 @@ struct ProcHook { ANDROID_external_memory_android_hardware_buffer, KHR_bind_memory2, KHR_get_physical_device_properties2, + KHR_device_group_creation, EXTENSION_CORE_1_0, EXTENSION_CORE_1_1, @@ -79,6 +80,7 @@ struct InstanceDriverTable { PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2; PFN_vkGetPhysicalDeviceProperties2KHR GetPhysicalDeviceProperties2KHR; PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups; + PFN_vkEnumeratePhysicalDeviceGroupsKHR EnumeratePhysicalDeviceGroupsKHR; // clang-format on }; diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index 5e78c62df8..1db1a3715b 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -40,6 +40,7 @@ _KNOWN_EXTENSIONS = _INTERCEPTED_EXTENSIONS + [ 'VK_ANDROID_external_memory_android_hardware_buffer', 'VK_KHR_bind_memory2', 'VK_KHR_get_physical_device_properties2', + 'VK_KHR_device_group_creation', ] # Functions needed at vulkan::driver level. @@ -77,6 +78,9 @@ _NEEDED_COMMANDS = [ # VK_KHR_swapchain v69 requirement 'vkBindImageMemory2', 'vkBindImageMemory2KHR', + + # For promoted VK_KHR_device_group_creation + 'vkEnumeratePhysicalDeviceGroupsKHR', ] # Functions intercepted at vulkan::driver level. -- cgit v1.2.3-59-g8ed1b From a55624ba5ae108daf326b03e1fe68165206b883a Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Sun, 5 Jul 2020 16:05:26 -0700 Subject: libvulkan: fix support for promoted GPDP2 This change intercepts below entry points: vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 Bug: 160276146 Test: adb shell cmd gpu vkjson Test: dEQP-VK.api.* Change-Id: I446192e3d29a3b0496d8d274a5a9cd3f2c0b3ee5 --- vulkan/libvulkan/driver.cpp | 131 +++++++++++++++++++++++++++++++++---- vulkan/libvulkan/driver.h | 8 +++ vulkan/libvulkan/driver_gen.cpp | 61 +++++++++++++++++ vulkan/libvulkan/driver_gen.h | 12 ++++ vulkan/scripts/driver_generator.py | 27 +++++++- 5 files changed, 224 insertions(+), 15 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index f2712d1f99..d2fdf42bd6 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -970,13 +970,6 @@ VkResult EnumerateInstanceExtensionProperties( bool QueryPresentationProperties( VkPhysicalDevice physicalDevice, VkPhysicalDevicePresentationPropertiesANDROID *presentation_properties) { - const InstanceData& data = GetData(physicalDevice); - - // GPDP2 must be present and enabled on the instance. - if (!data.driver.GetPhysicalDeviceProperties2KHR && - !data.driver.GetPhysicalDeviceProperties2) - return false; - // Request the android-specific presentation properties via GPDP2 VkPhysicalDeviceProperties2KHR properties = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, @@ -992,12 +985,7 @@ bool QueryPresentationProperties( presentation_properties->pNext = nullptr; presentation_properties->sharedImage = VK_FALSE; - if (data.driver.GetPhysicalDeviceProperties2KHR) { - data.driver.GetPhysicalDeviceProperties2KHR(physicalDevice, - &properties); - } else { - data.driver.GetPhysicalDeviceProperties2(physicalDevice, &properties); - } + GetPhysicalDeviceProperties2(physicalDevice, &properties); return true; } @@ -1379,5 +1367,122 @@ VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, return data.driver.QueueSubmit(queue, submitCount, pSubmits, fence); } +void GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceFeatures2) { + driver.GetPhysicalDeviceFeatures2(physicalDevice, pFeatures); + return; + } + + driver.GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); +} + +void GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceProperties2) { + driver.GetPhysicalDeviceProperties2(physicalDevice, pProperties); + return; + } + + driver.GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); +} + +void GetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceFormatProperties2) { + driver.GetPhysicalDeviceFormatProperties2(physicalDevice, format, + pFormatProperties); + return; + } + + driver.GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, + pFormatProperties); +} + +VkResult GetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceImageFormatProperties2) { + return driver.GetPhysicalDeviceImageFormatProperties2( + physicalDevice, pImageFormatInfo, pImageFormatProperties); + } + + return driver.GetPhysicalDeviceImageFormatProperties2KHR( + physicalDevice, pImageFormatInfo, pImageFormatProperties); +} + +void GetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceQueueFamilyProperties2) { + driver.GetPhysicalDeviceQueueFamilyProperties2( + physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + return; + } + + driver.GetPhysicalDeviceQueueFamilyProperties2KHR( + physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} + +void GetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceMemoryProperties2) { + driver.GetPhysicalDeviceMemoryProperties2(physicalDevice, + pMemoryProperties); + return; + } + + driver.GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, + pMemoryProperties); +} + +void GetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceSparseImageFormatProperties2) { + driver.GetPhysicalDeviceSparseImageFormatProperties2( + physicalDevice, pFormatInfo, pPropertyCount, pProperties); + return; + } + + driver.GetPhysicalDeviceSparseImageFormatProperties2KHR( + physicalDevice, pFormatInfo, pPropertyCount, pProperties); +} + } // namespace driver } // namespace vulkan diff --git a/vulkan/libvulkan/driver.h b/vulkan/libvulkan/driver.h index 23c717cf5d..360e724589 100644 --- a/vulkan/libvulkan/driver.h +++ b/vulkan/libvulkan/driver.h @@ -126,6 +126,14 @@ VKAPI_ATTR void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint3 VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); VKAPI_ATTR VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); + +VKAPI_ATTR void GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +VKAPI_ATTR void GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +VKAPI_ATTR void GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); // clang-format on template diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 36577c2622..de0ed60673 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -362,6 +362,34 @@ const ProcHook g_proc_hooks[] = { reinterpret_cast(GetPastPresentationTimingGOOGLE), reinterpret_cast(checkedGetPastPresentationTimingGOOGLE), }, + { + "vkGetPhysicalDeviceFeatures2", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceFeatures2), + nullptr, + }, + { + "vkGetPhysicalDeviceFormatProperties2", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceFormatProperties2), + nullptr, + }, + { + "vkGetPhysicalDeviceImageFormatProperties2", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceImageFormatProperties2), + nullptr, + }, + { + "vkGetPhysicalDeviceMemoryProperties2", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceMemoryProperties2), + nullptr, + }, { "vkGetPhysicalDevicePresentRectanglesKHR", ProcHook::INSTANCE, @@ -369,6 +397,27 @@ const ProcHook g_proc_hooks[] = { reinterpret_cast(GetPhysicalDevicePresentRectanglesKHR), nullptr, }, + { + "vkGetPhysicalDeviceProperties2", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceProperties2), + nullptr, + }, + { + "vkGetPhysicalDeviceQueueFamilyProperties2", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceQueueFamilyProperties2), + nullptr, + }, + { + "vkGetPhysicalDeviceSparseImageFormatProperties2", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceSparseImageFormatProperties2), + nullptr, + }, { "vkGetPhysicalDeviceSurfaceCapabilities2KHR", ProcHook::INSTANCE, @@ -544,8 +593,20 @@ bool InitDriverTable(VkInstance instance, INIT_PROC_EXT(EXT_debug_report, true, instance, CreateDebugReportCallbackEXT); INIT_PROC_EXT(EXT_debug_report, true, instance, DestroyDebugReportCallbackEXT); INIT_PROC_EXT(EXT_debug_report, true, instance, DebugReportMessageEXT); + INIT_PROC(false, instance, GetPhysicalDeviceFeatures2); + INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceFeatures2KHR); INIT_PROC(false, instance, GetPhysicalDeviceProperties2); INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceProperties2KHR); + INIT_PROC(false, instance, GetPhysicalDeviceFormatProperties2); + INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceFormatProperties2KHR); + INIT_PROC(false, instance, GetPhysicalDeviceImageFormatProperties2); + INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceImageFormatProperties2KHR); + INIT_PROC(false, instance, GetPhysicalDeviceQueueFamilyProperties2); + INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceQueueFamilyProperties2KHR); + INIT_PROC(false, instance, GetPhysicalDeviceMemoryProperties2); + INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceMemoryProperties2KHR); + INIT_PROC(false, instance, GetPhysicalDeviceSparseImageFormatProperties2); + INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceSparseImageFormatProperties2KHR); INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups); INIT_PROC_EXT(KHR_device_group_creation, true, instance, EnumeratePhysicalDeviceGroupsKHR); // clang-format on diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index dda9bb1194..1f102a90e9 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -77,8 +77,20 @@ struct InstanceDriverTable { PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT; PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT; PFN_vkDebugReportMessageEXT DebugReportMessageEXT; + PFN_vkGetPhysicalDeviceFeatures2 GetPhysicalDeviceFeatures2; + PFN_vkGetPhysicalDeviceFeatures2KHR GetPhysicalDeviceFeatures2KHR; PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2; PFN_vkGetPhysicalDeviceProperties2KHR GetPhysicalDeviceProperties2KHR; + PFN_vkGetPhysicalDeviceFormatProperties2 GetPhysicalDeviceFormatProperties2; + PFN_vkGetPhysicalDeviceFormatProperties2KHR GetPhysicalDeviceFormatProperties2KHR; + PFN_vkGetPhysicalDeviceImageFormatProperties2 GetPhysicalDeviceImageFormatProperties2; + PFN_vkGetPhysicalDeviceImageFormatProperties2KHR GetPhysicalDeviceImageFormatProperties2KHR; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 GetPhysicalDeviceQueueFamilyProperties2; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR GetPhysicalDeviceQueueFamilyProperties2KHR; + PFN_vkGetPhysicalDeviceMemoryProperties2 GetPhysicalDeviceMemoryProperties2; + PFN_vkGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMemoryProperties2KHR; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 GetPhysicalDeviceSparseImageFormatProperties2; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR GetPhysicalDeviceSparseImageFormatProperties2KHR; PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups; PFN_vkEnumeratePhysicalDeviceGroupsKHR EnumeratePhysicalDeviceGroupsKHR; // clang-format on diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index 1db1a3715b..cf1b6cfaba 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -72,8 +72,6 @@ _NEEDED_COMMANDS = [ 'vkDestroyImage', 'vkGetPhysicalDeviceProperties', - 'vkGetPhysicalDeviceProperties2', - 'vkGetPhysicalDeviceProperties2KHR', # VK_KHR_swapchain v69 requirement 'vkBindImageMemory2', @@ -81,6 +79,22 @@ _NEEDED_COMMANDS = [ # For promoted VK_KHR_device_group_creation 'vkEnumeratePhysicalDeviceGroupsKHR', + + # For promoted VK_KHR_get_physical_device_properties2 + 'vkGetPhysicalDeviceFeatures2', + 'vkGetPhysicalDeviceFeatures2KHR', + 'vkGetPhysicalDeviceProperties2', + 'vkGetPhysicalDeviceProperties2KHR', + 'vkGetPhysicalDeviceFormatProperties2', + 'vkGetPhysicalDeviceFormatProperties2KHR', + 'vkGetPhysicalDeviceImageFormatProperties2', + 'vkGetPhysicalDeviceImageFormatProperties2KHR', + 'vkGetPhysicalDeviceQueueFamilyProperties2', + 'vkGetPhysicalDeviceQueueFamilyProperties2KHR', + 'vkGetPhysicalDeviceMemoryProperties2', + 'vkGetPhysicalDeviceMemoryProperties2KHR', + 'vkGetPhysicalDeviceSparseImageFormatProperties2', + 'vkGetPhysicalDeviceSparseImageFormatProperties2KHR', ] # Functions intercepted at vulkan::driver level. @@ -110,6 +124,15 @@ _INTERCEPTED_COMMANDS = [ # VK_KHR_swapchain v69 requirement 'vkBindImageMemory2', 'vkBindImageMemory2KHR', + + # For promoted VK_KHR_get_physical_device_properties2 + 'vkGetPhysicalDeviceFeatures2', + 'vkGetPhysicalDeviceProperties2', + 'vkGetPhysicalDeviceFormatProperties2', + 'vkGetPhysicalDeviceImageFormatProperties2', + 'vkGetPhysicalDeviceQueueFamilyProperties2', + 'vkGetPhysicalDeviceMemoryProperties2', + 'vkGetPhysicalDeviceSparseImageFormatProperties2', ] -- cgit v1.2.3-59-g8ed1b From e1f35011c42fe3f93cfe68c5916a746a92c20557 Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Sun, 5 Jul 2020 22:52:04 -0700 Subject: libvulkan: fix support for promoted VK_KHR_external_* extensions This change intercepts below entry points: vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalFenceProperties Bug: 160276146 Test: adb shell cmd gpu vkjson Test: dEQP-VK.api.external.* Change-Id: I08e5647fd7ea48c2a0b2e28ef688dee44f85684c --- vulkan/libvulkan/driver.cpp | 82 ++++++++++++++++++++++++++++++++++++++ vulkan/libvulkan/driver.h | 4 ++ vulkan/libvulkan/driver_gen.cpp | 30 ++++++++++++++ vulkan/libvulkan/driver_gen.h | 9 +++++ vulkan/scripts/driver_generator.py | 24 +++++++++++ 5 files changed, 149 insertions(+) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index d2fdf42bd6..535e19063f 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -634,6 +634,9 @@ void CreateInfoWrapper::FilterExtension(const char* name) { break; case ProcHook::KHR_get_physical_device_properties2: case ProcHook::KHR_device_group_creation: + case ProcHook::KHR_external_memory_capabilities: + case ProcHook::KHR_external_semaphore_capabilities: + case ProcHook::KHR_external_fence_capabilities: case ProcHook::EXTENSION_UNKNOWN: // Extensions we don't need to do anything about at this level break; @@ -691,6 +694,9 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_android_surface: case ProcHook::KHR_get_physical_device_properties2: case ProcHook::KHR_device_group_creation: + case ProcHook::KHR_external_memory_capabilities: + case ProcHook::KHR_external_semaphore_capabilities: + case ProcHook::KHR_external_fence_capabilities: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::KHR_surface: case ProcHook::EXT_debug_report: @@ -1484,5 +1490,81 @@ void GetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties); } +void GetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceExternalBufferProperties) { + driver.GetPhysicalDeviceExternalBufferProperties( + physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + return; + } + + if (driver.GetPhysicalDeviceExternalBufferPropertiesKHR) { + driver.GetPhysicalDeviceExternalBufferPropertiesKHR( + physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + return; + } + + memset(&pExternalBufferProperties->externalMemoryProperties, 0, + sizeof(VkExternalMemoryProperties)); +} + +void GetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceExternalSemaphoreProperties) { + driver.GetPhysicalDeviceExternalSemaphoreProperties( + physicalDevice, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); + return; + } + + if (driver.GetPhysicalDeviceExternalSemaphorePropertiesKHR) { + driver.GetPhysicalDeviceExternalSemaphorePropertiesKHR( + physicalDevice, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); + return; + } + + pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0; + pExternalSemaphoreProperties->compatibleHandleTypes = 0; + pExternalSemaphoreProperties->externalSemaphoreFeatures = 0; +} + +void GetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties) { + ATRACE_CALL(); + + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceExternalFenceProperties) { + driver.GetPhysicalDeviceExternalFenceProperties( + physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + return; + } + + if (driver.GetPhysicalDeviceExternalFencePropertiesKHR) { + driver.GetPhysicalDeviceExternalFencePropertiesKHR( + physicalDevice, pExternalFenceInfo, pExternalFenceProperties); + return; + } + + pExternalFenceProperties->exportFromImportedHandleTypes = 0; + pExternalFenceProperties->compatibleHandleTypes = 0; + pExternalFenceProperties->externalFenceFeatures = 0; +} + } // namespace driver } // namespace vulkan diff --git a/vulkan/libvulkan/driver.h b/vulkan/libvulkan/driver.h index 360e724589..e7b4bb25bf 100644 --- a/vulkan/libvulkan/driver.h +++ b/vulkan/libvulkan/driver.h @@ -134,6 +134,10 @@ VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice phy VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); + +VKAPI_ATTR void GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +VKAPI_ATTR void GetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +VKAPI_ATTR void GetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); // clang-format on template diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index de0ed60673..6549c370b4 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -362,6 +362,27 @@ const ProcHook g_proc_hooks[] = { reinterpret_cast(GetPastPresentationTimingGOOGLE), reinterpret_cast(checkedGetPastPresentationTimingGOOGLE), }, + { + "vkGetPhysicalDeviceExternalBufferProperties", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceExternalBufferProperties), + nullptr, + }, + { + "vkGetPhysicalDeviceExternalFenceProperties", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceExternalFenceProperties), + nullptr, + }, + { + "vkGetPhysicalDeviceExternalSemaphoreProperties", + ProcHook::INSTANCE, + ProcHook::EXTENSION_CORE_1_1, + reinterpret_cast(GetPhysicalDeviceExternalSemaphoreProperties), + nullptr, + }, { "vkGetPhysicalDeviceFeatures2", ProcHook::INSTANCE, @@ -555,6 +576,9 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2; if (strcmp(name, "VK_KHR_get_physical_device_properties2") == 0) return ProcHook::KHR_get_physical_device_properties2; if (strcmp(name, "VK_KHR_device_group_creation") == 0) return ProcHook::KHR_device_group_creation; + if (strcmp(name, "VK_KHR_external_memory_capabilities") == 0) return ProcHook::KHR_external_memory_capabilities; + if (strcmp(name, "VK_KHR_external_semaphore_capabilities") == 0) return ProcHook::KHR_external_semaphore_capabilities; + if (strcmp(name, "VK_KHR_external_fence_capabilities") == 0) return ProcHook::KHR_external_fence_capabilities; // clang-format on return ProcHook::EXTENSION_UNKNOWN; } @@ -607,6 +631,12 @@ bool InitDriverTable(VkInstance instance, INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceMemoryProperties2KHR); INIT_PROC(false, instance, GetPhysicalDeviceSparseImageFormatProperties2); INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceSparseImageFormatProperties2KHR); + INIT_PROC(false, instance, GetPhysicalDeviceExternalBufferProperties); + INIT_PROC_EXT(KHR_external_memory_capabilities, true, instance, GetPhysicalDeviceExternalBufferPropertiesKHR); + INIT_PROC(false, instance, GetPhysicalDeviceExternalSemaphoreProperties); + INIT_PROC_EXT(KHR_external_semaphore_capabilities, true, instance, GetPhysicalDeviceExternalSemaphorePropertiesKHR); + INIT_PROC(false, instance, GetPhysicalDeviceExternalFenceProperties); + INIT_PROC_EXT(KHR_external_fence_capabilities, true, instance, GetPhysicalDeviceExternalFencePropertiesKHR); INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups); INIT_PROC_EXT(KHR_device_group_creation, true, instance, EnumeratePhysicalDeviceGroupsKHR); // clang-format on diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 1f102a90e9..1aba674c2c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -51,6 +51,9 @@ struct ProcHook { KHR_bind_memory2, KHR_get_physical_device_properties2, KHR_device_group_creation, + KHR_external_memory_capabilities, + KHR_external_semaphore_capabilities, + KHR_external_fence_capabilities, EXTENSION_CORE_1_0, EXTENSION_CORE_1_1, @@ -91,6 +94,12 @@ struct InstanceDriverTable { PFN_vkGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMemoryProperties2KHR; PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 GetPhysicalDeviceSparseImageFormatProperties2; PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR GetPhysicalDeviceSparseImageFormatProperties2KHR; + PFN_vkGetPhysicalDeviceExternalBufferProperties GetPhysicalDeviceExternalBufferProperties; + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR GetPhysicalDeviceExternalBufferPropertiesKHR; + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties GetPhysicalDeviceExternalSemaphoreProperties; + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR GetPhysicalDeviceExternalSemaphorePropertiesKHR; + PFN_vkGetPhysicalDeviceExternalFenceProperties GetPhysicalDeviceExternalFenceProperties; + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR GetPhysicalDeviceExternalFencePropertiesKHR; PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups; PFN_vkEnumeratePhysicalDeviceGroupsKHR EnumeratePhysicalDeviceGroupsKHR; // clang-format on diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index cf1b6cfaba..566e063a57 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -41,6 +41,9 @@ _KNOWN_EXTENSIONS = _INTERCEPTED_EXTENSIONS + [ 'VK_KHR_bind_memory2', 'VK_KHR_get_physical_device_properties2', 'VK_KHR_device_group_creation', + 'VK_KHR_external_memory_capabilities', + 'VK_KHR_external_semaphore_capabilities', + 'VK_KHR_external_fence_capabilities', ] # Functions needed at vulkan::driver level. @@ -95,6 +98,18 @@ _NEEDED_COMMANDS = [ 'vkGetPhysicalDeviceMemoryProperties2KHR', 'vkGetPhysicalDeviceSparseImageFormatProperties2', 'vkGetPhysicalDeviceSparseImageFormatProperties2KHR', + + # For promoted VK_KHR_external_memory_capabilities + 'vkGetPhysicalDeviceExternalBufferProperties', + 'vkGetPhysicalDeviceExternalBufferPropertiesKHR', + + # For promoted VK_KHR_external_semaphore_capabilities + 'vkGetPhysicalDeviceExternalSemaphoreProperties', + 'vkGetPhysicalDeviceExternalSemaphorePropertiesKHR', + + # For promoted VK_KHR_external_fence_capabilities + 'vkGetPhysicalDeviceExternalFenceProperties', + 'vkGetPhysicalDeviceExternalFencePropertiesKHR', ] # Functions intercepted at vulkan::driver level. @@ -133,6 +148,15 @@ _INTERCEPTED_COMMANDS = [ 'vkGetPhysicalDeviceQueueFamilyProperties2', 'vkGetPhysicalDeviceMemoryProperties2', 'vkGetPhysicalDeviceSparseImageFormatProperties2', + + # For promoted VK_KHR_external_memory_capabilities + 'vkGetPhysicalDeviceExternalBufferProperties', + + # For promoted VK_KHR_external_semaphore_capabilities + 'vkGetPhysicalDeviceExternalSemaphoreProperties', + + # For promoted VK_KHR_external_fence_capabilities + 'vkGetPhysicalDeviceExternalFenceProperties', ] -- cgit v1.2.3-59-g8ed1b From 2cefa738de67985a14b401510678222cd0cde853 Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Fri, 10 Jul 2020 21:07:30 -0700 Subject: libvulkan: refactor CreateInfoWrapper::SanitizeApiVersion 1. Do not override app apiVersion when icd is higher than 1.0 2. Move extension related codes into SanitizeExtensions Bug: 160276146 Test: hardcode 1.0, don't dispatch 1.1 core cmds and run vkjson Change-Id: I10e5a6ea45a3c7dabbe12af04185a59f808f89c9 --- vulkan/libvulkan/driver.cpp | 151 +++++++++++++++++++++----------------------- 1 file changed, 72 insertions(+), 79 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 535e19063f..e90cb11c7d 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -95,9 +95,11 @@ class Hal { class CreateInfoWrapper { public: CreateInfoWrapper(const VkInstanceCreateInfo& create_info, + uint32_t icd_api_version, const VkAllocationCallbacks& allocator); CreateInfoWrapper(VkPhysicalDevice physical_dev, const VkDeviceCreateInfo& create_info, + uint32_t icd_api_version, const VkAllocationCallbacks& allocator); ~CreateInfoWrapper(); @@ -132,6 +134,7 @@ class CreateInfoWrapper { const bool is_instance_; const VkAllocationCallbacks& allocator_; const uint32_t loader_api_version_; + const uint32_t icd_api_version_; VkPhysicalDevice physical_dev_; @@ -141,7 +144,6 @@ class CreateInfoWrapper { }; VkApplicationInfo application_info_; - uint32_t sanitized_api_version_; ExtensionFilter extension_filter_; @@ -324,21 +326,24 @@ bool Hal::InitDebugReportIndex() { } CreateInfoWrapper::CreateInfoWrapper(const VkInstanceCreateInfo& create_info, + uint32_t icd_api_version, const VkAllocationCallbacks& allocator) : is_instance_(true), allocator_(allocator), loader_api_version_(VK_API_VERSION_1_1), + icd_api_version_(icd_api_version), physical_dev_(VK_NULL_HANDLE), instance_info_(create_info), - sanitized_api_version_(loader_api_version_), extension_filter_() {} CreateInfoWrapper::CreateInfoWrapper(VkPhysicalDevice physical_dev, const VkDeviceCreateInfo& create_info, + uint32_t icd_api_version, const VkAllocationCallbacks& allocator) : is_instance_(false), allocator_(allocator), loader_api_version_(VK_API_VERSION_1_1), + icd_api_version_(icd_api_version), physical_dev_(physical_dev), dev_info_(create_info), extension_filter_() {} @@ -379,77 +384,17 @@ CreateInfoWrapper::operator const VkDeviceCreateInfo*() const { } VkResult CreateInfoWrapper::SanitizeApiVersion() { - if (is_instance_) { - // instance core versions need to match the loader api version - for (uint32_t i = ProcHook::EXTENSION_CORE_1_0; - i != ProcHook::EXTENSION_COUNT; i++) { - hook_extensions_.set(i); - hal_extensions_.set(i); - } - - uint32_t icd_api_version = VK_API_VERSION_1_0; - PFN_vkEnumerateInstanceVersion pfn_enumerate_instance_version = - reinterpret_cast( - Hal::Device().GetInstanceProcAddr( - nullptr, "vkEnumerateInstanceVersion")); - if (pfn_enumerate_instance_version) { - ATRACE_BEGIN("pfn_enumerate_instance_version"); - VkResult result = - (*pfn_enumerate_instance_version)(&icd_api_version); - ATRACE_END(); - if (result != VK_SUCCESS) - return result; - - icd_api_version ^= VK_VERSION_PATCH(icd_api_version); - } - - if (icd_api_version < VK_API_VERSION_1_0) - return VK_SUCCESS; - - if (icd_api_version < loader_api_version_) { - sanitized_api_version_ = icd_api_version; - - if (!instance_info_.pApplicationInfo) - return VK_SUCCESS; - - application_info_ = *instance_info_.pApplicationInfo; - application_info_.apiVersion = sanitized_api_version_; - instance_info_.pApplicationInfo = &application_info_; - } - } else { - const auto& driver = GetData(physical_dev_).driver; - - VkPhysicalDeviceProperties properties; - ATRACE_BEGIN("driver.GetPhysicalDeviceProperties"); - driver.GetPhysicalDeviceProperties(physical_dev_, &properties); - ATRACE_END(); - - if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) { - // Log that the app is hitting software Vulkan implementation - android::GraphicsEnv::getInstance().setTargetStats( - android::GpuStatsInfo::Stats::CPU_VULKAN_IN_USE); - } - - uint32_t api_version = properties.apiVersion; - api_version ^= VK_VERSION_PATCH(api_version); + if (!is_instance_ || !instance_info_.pApplicationInfo) + return VK_SUCCESS; - if (api_version > loader_api_version_) - api_version = loader_api_version_; + if (icd_api_version_ > VK_API_VERSION_1_0 || + instance_info_.pApplicationInfo->apiVersion < VK_API_VERSION_1_1) + return VK_SUCCESS; - switch (api_version) { - case VK_API_VERSION_1_1: - hook_extensions_.set(ProcHook::EXTENSION_CORE_1_1); - hal_extensions_.set(ProcHook::EXTENSION_CORE_1_1); - [[clang::fallthrough]]; - case VK_API_VERSION_1_0: - hook_extensions_.set(ProcHook::EXTENSION_CORE_1_0); - hal_extensions_.set(ProcHook::EXTENSION_CORE_1_0); - break; - default: - ALOGE("Unknown API version[%u]", api_version); - break; - } - } + // override apiVersion to avoid error return from 1.0 icd + application_info_ = *instance_info_.pApplicationInfo; + application_info_.apiVersion = VK_API_VERSION_1_0; + instance_info_.pApplicationInfo = &application_info_; return VK_SUCCESS; } @@ -506,13 +451,13 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { if (result != VK_SUCCESS) return result; - if (is_instance_ && sanitized_api_version_ < loader_api_version_) { + if (is_instance_ && icd_api_version_ < loader_api_version_) { for (uint32_t i = 0; i < ext_count; i++) { // Upon api downgrade, skip the promoted instance extensions in the // first pass to avoid duplicate extensions. const std::optional version = GetInstanceExtensionPromotedVersion(ext_names[i]); - if (version && *version > sanitized_api_version_ && + if (version && *version > icd_api_version_ && *version <= loader_api_version_) continue; @@ -521,7 +466,7 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { // Enable the required extensions to support core functionalities. const auto promoted_extensions = GetPromotedInstanceExtensions( - sanitized_api_version_, loader_api_version_); + icd_api_version_, loader_api_version_); for (const auto& promoted_extension : promoted_extensions) FilterExtension(promoted_extension); } else { @@ -535,6 +480,23 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { hook_extensions_.set(ProcHook::KHR_swapchain); } + const uint32_t api_version = + is_instance_ ? loader_api_version_ + : std::min(icd_api_version_, loader_api_version_); + switch (api_version) { + case VK_API_VERSION_1_1: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_1); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_1); + [[clang::fallthrough]]; + case VK_API_VERSION_1_0: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_0); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_0); + break; + default: + ALOGE("Unknown API version[%u]", api_version); + break; + } + ext_names = extension_filter_.names; ext_count = extension_filter_.name_count; @@ -597,9 +559,9 @@ VkResult CreateInfoWrapper::InitExtensionFilter() { // It requires enabling additional promoted extensions to downgrade api, // so we reserve enough space here. - if (sanitized_api_version_ < loader_api_version_) { + if (icd_api_version_ < loader_api_version_) { enabled_ext_count += CountPromotedInstanceExtensions( - sanitized_api_version_, loader_api_version_); + icd_api_version_, loader_api_version_); } count = std::min(filter.ext_count, enabled_ext_count); @@ -1087,8 +1049,24 @@ VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks& data_allocator = (pAllocator) ? *pAllocator : GetDefaultAllocator(); - CreateInfoWrapper wrapper(*pCreateInfo, data_allocator); - VkResult result = wrapper.Validate(); + VkResult result = VK_SUCCESS; + uint32_t icd_api_version = VK_API_VERSION_1_0; + PFN_vkEnumerateInstanceVersion pfn_enumerate_instance_version = + reinterpret_cast( + Hal::Device().GetInstanceProcAddr(nullptr, + "vkEnumerateInstanceVersion")); + if (pfn_enumerate_instance_version) { + ATRACE_BEGIN("pfn_enumerate_instance_version"); + result = (*pfn_enumerate_instance_version)(&icd_api_version); + ATRACE_END(); + if (result != VK_SUCCESS) + return result; + + icd_api_version ^= VK_VERSION_PATCH(icd_api_version); + } + + CreateInfoWrapper wrapper(*pCreateInfo, icd_api_version, data_allocator); + result = wrapper.Validate(); if (result != VK_SUCCESS) return result; @@ -1160,7 +1138,16 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkAllocationCallbacks& data_allocator = (pAllocator) ? *pAllocator : instance_data.allocator; - CreateInfoWrapper wrapper(physicalDevice, *pCreateInfo, data_allocator); + VkPhysicalDeviceProperties properties; + ATRACE_BEGIN("driver.GetPhysicalDeviceProperties"); + instance_data.driver.GetPhysicalDeviceProperties(physicalDevice, + &properties); + ATRACE_END(); + + CreateInfoWrapper wrapper( + physicalDevice, *pCreateInfo, + properties.apiVersion ^ VK_VERSION_PATCH(properties.apiVersion), + data_allocator); VkResult result = wrapper.Validate(); if (result != VK_SUCCESS) return result; @@ -1216,6 +1203,12 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice, return VK_ERROR_INCOMPATIBLE_DRIVER; } + if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) { + // Log that the app is hitting software Vulkan implementation + android::GraphicsEnv::getInstance().setTargetStats( + android::GpuStatsInfo::Stats::CPU_VULKAN_IN_USE); + } + data->driver_device = dev; *pDevice = dev; -- cgit v1.2.3-59-g8ed1b From 93b521c1908c89a2ce4654cc5e17a3ef661356fc Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Sat, 11 Jul 2020 16:32:09 -0700 Subject: libvulkan: cleanup some redundant codes This change also removes some unnecessary clang-format operations. Test: build Change-Id: I6dae3a72448b931e07e5f94087e7a477582b4ca4 --- vulkan/libvulkan/api.h | 37 ++++++++--- vulkan/libvulkan/driver.cpp | 32 +++++----- vulkan/libvulkan/driver.h | 123 ++++++++++++++++++++++++++----------- vulkan/libvulkan/driver_gen.cpp | 7 +-- vulkan/libvulkan/swapchain.cpp | 9 ++- vulkan/scripts/driver_generator.py | 7 +-- 6 files changed, 140 insertions(+), 75 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/api.h b/vulkan/libvulkan/api.h index 416cba0125..2a215d7427 100644 --- a/vulkan/libvulkan/api.h +++ b/vulkan/libvulkan/api.h @@ -24,17 +24,34 @@ namespace vulkan { namespace api { -// clang-format off -VKAPI_ATTR VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); -VKAPI_ATTR void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); -VKAPI_ATTR void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties); -VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -VKAPI_ATTR VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); -VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +VKAPI_ATTR VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); +VKAPI_ATTR void DestroyInstance(VkInstance instance, + const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult CreateDevice(VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); +VKAPI_ATTR void DestroyDevice(VkDevice device, + const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult +EnumerateInstanceLayerProperties(uint32_t* pPropertyCount, + VkLayerProperties* pProperties); +VKAPI_ATTR VkResult +EnumerateInstanceExtensionProperties(const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); +VKAPI_ATTR VkResult +EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); +VKAPI_ATTR VkResult +EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); VKAPI_ATTR VkResult EnumerateInstanceVersion(uint32_t* pApiVersion); -// clang-format on inline InstanceData& GetData(VkInstance instance) { return driver::GetData(instance).opaque_api_data; diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index e90cb11c7d..e3fc67e35f 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -935,14 +935,14 @@ VkResult EnumerateInstanceExtensionProperties( return result; } -bool QueryPresentationProperties( +void QueryPresentationProperties( VkPhysicalDevice physicalDevice, - VkPhysicalDevicePresentationPropertiesANDROID *presentation_properties) { + VkPhysicalDevicePresentationPropertiesANDROID* presentation_properties) { // Request the android-specific presentation properties via GPDP2 - VkPhysicalDeviceProperties2KHR properties = { - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + VkPhysicalDeviceProperties2 properties = { + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, presentation_properties, - {} + {}, }; #pragma clang diagnostic push @@ -954,8 +954,6 @@ bool QueryPresentationProperties( presentation_properties->sharedImage = VK_FALSE; GetPhysicalDeviceProperties2(physicalDevice, &properties); - - return true; } VkResult EnumerateDeviceExtensionProperties( @@ -977,8 +975,8 @@ VkResult EnumerateDeviceExtensionProperties( } VkPhysicalDevicePresentationPropertiesANDROID presentation_properties; - if (QueryPresentationProperties(physicalDevice, &presentation_properties) && - presentation_properties.sharedImage) { + QueryPresentationProperties(physicalDevice, &presentation_properties); + if (presentation_properties.sharedImage) { loader_extensions.push_back({ VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME, VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION}); @@ -1337,10 +1335,10 @@ void GetDeviceQueue2(VkDevice device, if (*pQueue != VK_NULL_HANDLE) SetData(*pQueue, data); } -VKAPI_ATTR VkResult -AllocateCommandBuffers(VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers) { +VkResult AllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) { ATRACE_CALL(); const auto& data = GetData(device); @@ -1355,10 +1353,10 @@ AllocateCommandBuffers(VkDevice device, return result; } -VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence) { +VkResult QueueSubmit(VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence) { ATRACE_CALL(); const auto& data = GetData(queue); diff --git a/vulkan/libvulkan/driver.h b/vulkan/libvulkan/driver.h index e7b4bb25bf..14c516b16b 100644 --- a/vulkan/libvulkan/driver.h +++ b/vulkan/libvulkan/driver.h @@ -103,42 +103,95 @@ struct DeviceData { bool OpenHAL(); const VkAllocationCallbacks& GetDefaultAllocator(); -bool QueryPresentationProperties( +void QueryPresentationProperties( VkPhysicalDevice physicalDevice, - VkPhysicalDevicePresentationPropertiesANDROID *presentation_properties); - -// clang-format off -VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName); -VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName); -VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); - -VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); - -VKAPI_ATTR VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); -VKAPI_ATTR void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); -VKAPI_ATTR void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -VKAPI_ATTR VkResult EnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); - -VKAPI_ATTR void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); -VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); -VKAPI_ATTR VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); -VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); - -VKAPI_ATTR void GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -VKAPI_ATTR void GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -VKAPI_ATTR void GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); - -VKAPI_ATTR void GetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); -VKAPI_ATTR void GetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -VKAPI_ATTR void GetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); -// clang-format on + VkPhysicalDevicePresentationPropertiesANDROID* presentation_properties); + +VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, + const char* pName); +VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, + const char* pName); +VKAPI_ATTR VkResult +EnumerateInstanceExtensionProperties(const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); +VKAPI_ATTR VkResult +EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); +VKAPI_ATTR VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); +VKAPI_ATTR void DestroyInstance(VkInstance instance, + const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult CreateDevice(VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); +VKAPI_ATTR void DestroyDevice(VkDevice device, + const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult +EnumeratePhysicalDevices(VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); +VKAPI_ATTR VkResult EnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +VKAPI_ATTR void GetDeviceQueue(VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); +VKAPI_ATTR void GetDeviceQueue2(VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue); +VKAPI_ATTR VkResult +AllocateCommandBuffers(VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); +VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); +VKAPI_ATTR void GetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); +VKAPI_ATTR void GetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); +VKAPI_ATTR void GetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); +VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); +VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); +VKAPI_ATTR void GetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); +VKAPI_ATTR void GetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); +VKAPI_ATTR void GetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +VKAPI_ATTR void GetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); template void StaticAssertDispatchable(DispatchableType) { diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 6549c370b4..5f37a50a03 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -550,10 +550,9 @@ const ProcHook g_proc_hooks[] = { } // namespace const ProcHook* GetProcHook(const char* name) { - const auto& begin = g_proc_hooks; - const auto& end = - g_proc_hooks + sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]); - const auto hook = std::lower_bound( + auto begin = std::cbegin(g_proc_hooks); + auto end = std::cend(g_proc_hooks); + auto hook = std::lower_bound( begin, end, name, [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; }); return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr; diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index c7ff6405f1..0f791c903b 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -881,11 +881,10 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); VkPhysicalDevicePresentationPropertiesANDROID present_properties; - if (QueryPresentationProperties(pdev, &present_properties)) { - if (present_properties.sharedImage) { - present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR); - present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR); - } + QueryPresentationProperties(pdev, &present_properties); + if (present_properties.sharedImage) { + present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR); + present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR); } uint32_t num_modes = uint32_t(present_modes.size()); diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index 566e063a57..6a73023193 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -523,10 +523,9 @@ const ProcHook g_proc_hooks[] = { } // namespace const ProcHook* GetProcHook(const char* name) { - const auto& begin = g_proc_hooks; - const auto& end = - g_proc_hooks + sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]); - const auto hook = std::lower_bound( + auto begin = std::cbegin(g_proc_hooks); + auto end = std::cend(g_proc_hooks); + auto hook = std::lower_bound( begin, end, name, [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; }); return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr; -- cgit v1.2.3-59-g8ed1b From 901f8ee258dbfff2090dc45badf3446266f0ae16 Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Fri, 31 Jul 2020 13:18:49 -0700 Subject: Vulkan: unload builtin driver to reload updated driver if needed Android historically preloads GL driver in Zygote to speed up app launch time and avoid the duplicate extra memory for each process loading the graphics driver. In Android 10, we landed GL driver unloading mechanism to ship updatable driver and ANGLE without perf overhead on the rest of the system. To get prepared for the HWUI Vulkan backend being turned on as the default renderer for UI componments, this CL will do the same to the Vulkan driver to preload it in Zygote and unload so to reload updated driver if needed. Bug: 135536511 Test: atest CtsUiRenderingTestCases no regression on VK backend Change-Id: I2909f6ecc4f011b1f3670aacdf817ed3b6e9a487 --- vulkan/include/hardware/hwvulkan.h | 5 +++-- vulkan/libvulkan/api.cpp | 29 +++++++++++---------------- vulkan/libvulkan/driver.cpp | 41 +++++++++++++++++++++++++++++++++++++- 3 files changed, 55 insertions(+), 20 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/include/hardware/hwvulkan.h b/vulkan/include/hardware/hwvulkan.h index 9e9a14d489..98bc8e3c46 100644 --- a/vulkan/include/hardware/hwvulkan.h +++ b/vulkan/include/hardware/hwvulkan.h @@ -54,8 +54,9 @@ typedef union { /* A hwvulkan_device_t corresponds to an ICD on other systems. Currently there * can only be one on a system (HWVULKAN_DEVICE_0). It is opened once per * process when the Vulkan API is first used; the hw_device_t::close() function - * is never called. Any non-trivial resource allocation should be done when - * the VkInstance is created rather than when the hwvulkan_device_t is opened. + * is called upon driver unloading. Any non-trivial resource allocation should + * be done when the VkInstance is created rather than when the hwvulkan_device_t + * is opened. */ typedef struct hwvulkan_device_t { struct hw_device_t common; diff --git a/vulkan/libvulkan/api.cpp b/vulkan/libvulkan/api.cpp index 80166c8434..2d4690a2af 100644 --- a/vulkan/libvulkan/api.cpp +++ b/vulkan/libvulkan/api.cpp @@ -1174,23 +1174,18 @@ const LayerChain::ActiveLayer* LayerChain::GetActiveLayers( // ---------------------------------------------------------------------------- bool EnsureInitialized() { - static std::once_flag once_flag; - static bool initialized; - - std::call_once(once_flag, []() { - if (driver::OpenHAL()) { - initialized = true; - } - }); - - { - static pid_t pid = getpid() + 1; - static std::mutex layer_lock; - std::lock_guard lock(layer_lock); - if (pid != getpid()) { - pid = getpid(); - DiscoverLayers(); - } + static bool initialized = false; + static pid_t init_attempted_for_pid = 0; + static std::mutex init_lock; + + std::lock_guard lock(init_lock); + if (init_attempted_for_pid == getpid()) + return initialized; + + init_attempted_for_pid = getpid(); + if (driver::OpenHAL()) { + DiscoverLayers(); + initialized = true; } return initialized; diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index e3fc67e35f..8deca47c66 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -84,6 +84,8 @@ class Hal { Hal(const Hal&) = delete; Hal& operator=(const Hal&) = delete; + bool ShouldUnloadBuiltinDriver(); + void UnloadBuiltinDriver(); bool InitDebugReportIndex(); static Hal hal_; @@ -243,7 +245,12 @@ bool Hal::Open() { const nsecs_t openTime = systemTime(); - ALOG_ASSERT(!hal_.dev_, "OpenHAL called more than once"); + if (hal_.ShouldUnloadBuiltinDriver()) { + hal_.UnloadBuiltinDriver(); + } + + if (hal_.dev_) + return true; // Use a stub device unless we successfully open a real HAL device. hal_.dev_ = &stubhal::kDevice; @@ -288,6 +295,38 @@ bool Hal::Open() { return true; } +bool Hal::ShouldUnloadBuiltinDriver() { + // Should not unload since the driver was not loaded + if (!hal_.dev_) + return false; + + // Should not unload if stubhal is used on the device + if (hal_.dev_ == &stubhal::kDevice) + return false; + + // Unload the driver if updated driver is chosen + if (android::GraphicsEnv::getInstance().getDriverNamespace()) + return true; + + return false; +} + +void Hal::UnloadBuiltinDriver() { + ATRACE_CALL(); + + ALOGD("Unload builtin Vulkan driver."); + + // Close the opened device + ALOG_ASSERT(!hal_.dev_->common.close(hal_.dev_->common), + "hw_device_t::close() failed."); + + // Close the opened shared library in the hw_module_t + dlclose(hal_.dev_->common.module->dso); + + hal_.dev_ = nullptr; + hal_.debug_report_index_ = -1; +} + bool Hal::InitDebugReportIndex() { ATRACE_CALL(); -- cgit v1.2.3-59-g8ed1b From d7ea44ab0be84344108b4dff2845e4250b5c3190 Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Thu, 13 Aug 2020 12:54:27 -0700 Subject: libvulkan: avoid allocation if final extension count is zero This change also makes sure ExtensionFilter is properly initialized. Bug: 161810298 Test: dEQP-VK.api.object_management.max_concurrent#instance Change-Id: I2e3526b38fc5eeddf0e96d18dfd6f218bbb80201 --- vulkan/libvulkan/driver.cpp | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 8deca47c66..997b332dd4 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -120,6 +120,8 @@ class CreateInfoWrapper { const char** names; uint32_t name_count; + ExtensionFilter() + : exts(nullptr), ext_count(0), names(nullptr), name_count(0) {} }; VkResult SanitizeApiVersion(); @@ -607,6 +609,10 @@ VkResult CreateInfoWrapper::InitExtensionFilter() { } else { count = std::min(filter.ext_count, dev_info_.enabledExtensionCount); } + + if (!count) + return VK_SUCCESS; + filter.names = reinterpret_cast(allocator_.pfnAllocation( allocator_.pUserData, sizeof(const char*) * count, alignof(const char*), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND)); -- cgit v1.2.3-59-g8ed1b From 40e84f1f8fa962b6b19a402fedf75f1db4a73a6f Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Wed, 14 Oct 2020 08:42:26 -0700 Subject: Vulkan: load built-in driver into default namespace as a fallback There isn't sphal in vendor config because the default has the same access there. This change allows vendor processes to load Vulkan driver into the default namespace. Bug: 170258171 Test: Vulkan driver can be loaded into vendor processes Change-Id: If58493e6954e4e8d2309aaca392fcdffea9c6b9a --- vulkan/libvulkan/Android.bp | 2 +- vulkan/libvulkan/driver.cpp | 50 +++++++++++++++++++-------------------------- 2 files changed, 22 insertions(+), 30 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/Android.bp b/vulkan/libvulkan/Android.bp index f69de1f324..aa8040b8f2 100644 --- a/vulkan/libvulkan/Android.bp +++ b/vulkan/libvulkan/Android.bp @@ -89,7 +89,6 @@ cc_library_shared { "libhardware", "libsync", "libbase", - "libdl_android", "libhidlbase", "liblog", "libui", @@ -100,6 +99,7 @@ cc_library_shared { "libnativebridge_lazy", "libnativeloader_lazy", "libnativewindow", + "libvndksupport", "android.hardware.graphics.common@1.0", "libSurfaceFlingerProp", ], diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 4068a16d80..5c1d023ce9 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -28,20 +28,17 @@ #include #include #include -#include #include #include -#include #include #include #include +#include #include #include #include #include -#include -#include #include #include "stubhal.h" @@ -157,19 +154,11 @@ class CreateInfoWrapper { Hal Hal::hal_; -void* LoadLibrary(const android_dlextinfo& dlextinfo, - const std::string_view subname) { - ATRACE_CALL(); - - std::stringstream ss; - ss << "vulkan." << subname << ".so"; - return android_dlopen_ext(ss.str().c_str(), RTLD_LOCAL | RTLD_NOW, &dlextinfo); -} - const std::array HAL_SUBNAME_KEY_PROPERTIES = {{ "ro.hardware.vulkan", "ro.board.platform", }}; +constexpr int LIB_DL_FLAGS = RTLD_LOCAL | RTLD_NOW; // LoadDriver returns: // * 0 when succeed, or @@ -180,20 +169,26 @@ int LoadDriver(android_namespace_t* library_namespace, const hwvulkan_module_t** module) { ATRACE_CALL(); - const android_dlextinfo dlextinfo = { - .flags = ANDROID_DLEXT_USE_NAMESPACE, - .library_namespace = library_namespace, - }; void* so = nullptr; - char prop[PROPERTY_VALUE_MAX]; for (auto key : HAL_SUBNAME_KEY_PROPERTIES) { - int prop_len = property_get(key, prop, nullptr); - if (prop_len > 0 && prop_len <= UINT_MAX) { - std::string_view lib_name(prop, static_cast(prop_len)); - so = LoadLibrary(dlextinfo, lib_name); - if (so) - break; + std::string lib_name = android::base::GetProperty(key, ""); + if (lib_name.empty()) + continue; + + lib_name = "vulkan." + lib_name + ".so"; + if (library_namespace) { + // load updated driver + const android_dlextinfo dlextinfo = { + .flags = ANDROID_DLEXT_USE_NAMESPACE, + .library_namespace = library_namespace, + }; + so = android_dlopen_ext(lib_name.c_str(), LIB_DL_FLAGS, &dlextinfo); + } else { + // load built-in driver + so = android_load_sphal_library(lib_name.c_str(), LIB_DL_FLAGS); } + if (so) + break; } if (!so) return -ENOENT; @@ -217,12 +212,9 @@ int LoadDriver(android_namespace_t* library_namespace, int LoadBuiltinDriver(const hwvulkan_module_t** module) { ATRACE_CALL(); - auto ns = android_get_exported_namespace("sphal"); - if (!ns) - return -ENOENT; android::GraphicsEnv::getInstance().setDriverToLoad( android::GpuStatsInfo::Driver::VULKAN); - return LoadDriver(ns, module); + return LoadDriver(nullptr, module); } int LoadUpdatedDriver(const hwvulkan_module_t** module) { @@ -323,7 +315,7 @@ void Hal::UnloadBuiltinDriver() { "hw_device_t::close() failed."); // Close the opened shared library in the hw_module_t - dlclose(hal_.dev_->common.module->dso); + android_unload_sphal_library(hal_.dev_->common.module->dso); hal_.dev_ = nullptr; hal_.debug_report_index_ = -1; -- cgit v1.2.3-59-g8ed1b From 9058b8fe8c00609768a828e3e1476d7f24754fed Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Thu, 12 Nov 2020 20:23:00 +0000 Subject: Vulkan/OpenGL: log dlerror for loading updatable gfx driver Test: build Change-Id: Ifcb57266f5d93767ba911f70695e0bbbeace98e6 --- libs/graphicsenv/GraphicsEnv.cpp | 2 +- opengl/libs/EGL/Loader.cpp | 2 ++ vulkan/libvulkan/driver.cpp | 2 ++ 3 files changed, 5 insertions(+), 1 deletion(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/libs/graphicsenv/GraphicsEnv.cpp b/libs/graphicsenv/GraphicsEnv.cpp index 55c5de9477..d54de4999c 100644 --- a/libs/graphicsenv/GraphicsEnv.cpp +++ b/libs/graphicsenv/GraphicsEnv.cpp @@ -548,7 +548,7 @@ void GraphicsEnv::setDebugLayersGLES(const std::string layers) { } // Return true if all the required libraries from vndk and sphal namespace are -// linked to the Game Driver namespace correctly. +// linked to the updatable gfx driver namespace correctly. bool GraphicsEnv::linkDriverNamespaceLocked(android_namespace_t* vndkNamespace) { const std::string llndkLibraries = getSystemNativeLibraries(NativeLibrary::LLNDK); if (llndkLibraries.empty()) { diff --git a/opengl/libs/EGL/Loader.cpp b/opengl/libs/EGL/Loader.cpp index 1afc6934f6..76fd7f0f3f 100644 --- a/opengl/libs/EGL/Loader.cpp +++ b/opengl/libs/EGL/Loader.cpp @@ -514,6 +514,8 @@ static void* load_updated_driver(const char* kind, android_namespace_t* ns) { if (so) { return so; } + ALOGE("Could not load %s from updatable gfx driver namespace: %s.", name.c_str(), + dlerror()); } return nullptr; } diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 6f09a8c45b..d7fdab5586 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -183,6 +183,8 @@ int LoadDriver(android_namespace_t* library_namespace, .library_namespace = library_namespace, }; so = android_dlopen_ext(lib_name.c_str(), LIB_DL_FLAGS, &dlextinfo); + ALOGE("Could not load %s from updatable gfx driver namespace: %s.", + lib_name.c_str(), dlerror()); } else { // load built-in driver so = android_load_sphal_library(lib_name.c_str(), LIB_DL_FLAGS); -- cgit v1.2.3-59-g8ed1b