| /* |
| * Copyright (c) 2021 The Khronos Group Inc. |
| * Copyright (c) 2021 Valve Corporation |
| * Copyright (c) 2021 LunarG, Inc. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and/or associated documentation files (the "Materials"), to |
| * deal in the Materials without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Materials, and to permit persons to whom the Materials are |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice(s) and this permission notice shall be included in |
| * all copies or substantial portions of the Materials. |
| * |
| * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| * |
| * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE |
| * USE OR OTHER DEALINGS IN THE MATERIALS. |
| * |
| * Author: Charles Giessen <charles@lunarg.com> |
| */ |
| |
| #include "test_environment.h" |
| #include <functional> |
| #include <tuple> |
| |
| enum class TestConfig { |
| add_layer_implementation, |
| add_layer_interception, |
| }; |
| |
| bool has_flag(std::vector<TestConfig> const& flags, TestConfig config) { |
| for (auto const& flag : flags) |
| if (flag == config) return true; |
| return false; |
| } |
| |
| /* |
| Creates a TestICD with a function unknown to the loader called vkNotRealFuncTEST. The TestICD, when |
| vk_icdGetPhysicalDeviceProcAddr is called, will return the custom_physical_device_function if the function name matches |
| vkNotRealFuncTEST. The test then calls the function to verify that the unknown physical device function dispatching is |
| working correctly. |
| */ |
| template <typename DispatchableHandleType> |
| struct custom_functions { |
| static VKAPI_ATTR uint32_t VKAPI_CALL func_zero(DispatchableHandleType, uint32_t foo) { return foo; }; |
| static VKAPI_ATTR uint32_t VKAPI_CALL func_one(DispatchableHandleType, uint32_t foo, uint32_t bar) { return foo + bar; }; |
| static VKAPI_ATTR float VKAPI_CALL func_two(DispatchableHandleType, uint32_t foo, uint32_t bar, float baz) { |
| return baz + foo + bar; |
| }; |
| static VKAPI_ATTR int VKAPI_CALL func_three(DispatchableHandleType, int* ptr_a, int* ptr_b) { return *ptr_a + *ptr_b; }; |
| static VKAPI_ATTR float VKAPI_CALL func_four(DispatchableHandleType, int* ptr_a, int* ptr_b, int foo, int bar, float k, float l, |
| char a, char b, char c) { |
| return *ptr_a + *ptr_b + foo + bar + k + l + static_cast<int>(a) + static_cast<int>(b) + static_cast<int>(c); |
| }; |
| }; |
| |
| /* |
| Functions for testing of layer interception of unknown functions. Note the need to pass a pointer to the layer and the name |
| of the called function as a parameter, this is necessary to allow a generic layer implementation, as the layer must look up |
| the function pointer to use. A real layer would store the function pointer in a dedicated structure per-instance/device, but |
| since the TestLayer is a generic layer, there isn't a fixed list of functions that should be supported. |
| */ |
| |
| PFN_vkVoidFunction find_custom_func(TestLayer* layer, const char* name) { |
| if (layer->custom_dispatch_functions.count(name) > 0) { |
| return layer->custom_dispatch_functions.at(name); |
| } |
| return nullptr; |
| } |
| |
| template <typename DispatchableHandleType> |
| struct layer_intercept_functions { |
| static VKAPI_ATTR uint32_t VKAPI_CALL func_zero(DispatchableHandleType handle, TestLayer* layer, const char* name, uint32_t i) { |
| auto func = reinterpret_cast<decltype(&func_zero)>(find_custom_func(layer, name)); |
| if (func == nullptr) return 1337; |
| return func(handle, layer, name, i + 3); |
| } |
| static VKAPI_ATTR uint32_t VKAPI_CALL func_one(DispatchableHandleType handle, TestLayer* layer, const char* name, uint32_t i, |
| float f) { |
| auto func = reinterpret_cast<decltype(&func_one)>(find_custom_func(layer, name)); |
| if (func == nullptr) return 1337; |
| return func(handle, layer, name, i + 2, f + 1.f); |
| } |
| static VKAPI_ATTR float VKAPI_CALL func_two(DispatchableHandleType handle, TestLayer* layer, const char* name, uint32_t foo, |
| uint32_t bar, float baz) { |
| auto func = reinterpret_cast<decltype(&func_two)>(find_custom_func(layer, name)); |
| if (func == nullptr) return -1337; |
| return func(handle, layer, name, foo + 1, bar + 2, baz * 2); |
| }; |
| static VKAPI_ATTR int VKAPI_CALL func_three(DispatchableHandleType handle, TestLayer* layer, const char* name, int* ptr_a, |
| int* ptr_b) { |
| auto func = reinterpret_cast<decltype(&func_three)>(find_custom_func(layer, name)); |
| if (func == nullptr) return -1337; |
| *ptr_a += 1; |
| *ptr_b -= 2; |
| return func(handle, layer, name, ptr_a, ptr_b); |
| }; |
| static VKAPI_ATTR float VKAPI_CALL func_four(DispatchableHandleType handle, TestLayer* layer, const char* name, int* ptr_a, |
| int* ptr_b, int foo, int bar, float k, float l, char, char, char) { |
| auto func = reinterpret_cast<decltype(&func_four)>(find_custom_func(layer, name)); |
| if (func == nullptr) return -1337.f; |
| return func(handle, layer, name, ptr_a, ptr_b, foo + 4, bar + 5, k + 1, l + 2, 'd', 'e', 'f'); |
| }; |
| }; |
| |
| template <typename DispatchableHandleType> |
| struct layer_implementation_functions { |
| static VKAPI_ATTR uint32_t VKAPI_CALL func_zero(DispatchableHandleType, TestLayer*, const char*, uint32_t i) { return i * 3; } |
| static VKAPI_ATTR uint32_t VKAPI_CALL func_one(DispatchableHandleType, TestLayer*, const char*, uint32_t i, float f) { |
| return static_cast<int>(i * 3 + f * 10.f); |
| } |
| static VKAPI_ATTR float VKAPI_CALL func_two(DispatchableHandleType, TestLayer*, const char*, uint32_t foo, uint32_t bar, |
| float baz) { |
| return baz + foo + bar; |
| }; |
| static VKAPI_ATTR int VKAPI_CALL func_three(DispatchableHandleType, TestLayer*, const char*, int* ptr_a, int* ptr_b) { |
| return *ptr_a + *ptr_b; |
| }; |
| static VKAPI_ATTR float VKAPI_CALL func_four(DispatchableHandleType, TestLayer*, const char*, int* ptr_a, int* ptr_b, int foo, |
| int bar, float k, float l, char a, char b, char c) { |
| return *ptr_a + *ptr_b + foo + bar + k + l + static_cast<int>(a) + static_cast<int>(b) + static_cast<int>(c); |
| }; |
| }; |
| |
| // Add function_count strings to the func_names vector, starting at function_start place. Essentially a utility for filling |
| // up a list of names to use later |
| void add_function_names(std::vector<std::string>& func_names, uint32_t function_count, uint32_t function_start = 0) { |
| for (uint32_t i = function_start; i < function_start + function_count;) { |
| func_names.push_back(std::string("vkNotIntRealFuncTEST_") + std::to_string(i++)); |
| func_names.push_back(std::string("vkNotIntRealIntFuncTEST_") + std::to_string(i++)); |
| func_names.push_back(std::string("vkIntNotIntRealFloatFuncTEST_") + std::to_string(i++)); |
| func_names.push_back(std::string("vkNotRealFuncPointerPointerTEST_") + std::to_string(i++)); |
| func_names.push_back(std::string("vkNotRealFuncTEST_pointer_pointer_int_int_float_float_char_char_char_") + |
| std::to_string(i++)); |
| } |
| } |
| |
| // Add data to the function_list, which could be a driver or a layer list of implementation functions. |
| template <typename FunctionStruct> |
| void fill_implementation_functions(std::vector<VulkanFunction>& function_list, std::vector<std::string>& func_names, |
| FunctionStruct const& funcs, uint32_t function_count, uint32_t function_start = 0) { |
| for (uint32_t i = function_start; i < function_start + function_count;) { |
| function_list.push_back(VulkanFunction{func_names.at(i++), to_vkVoidFunction(funcs.func_zero)}); |
| function_list.push_back(VulkanFunction{func_names.at(i++), to_vkVoidFunction(funcs.func_one)}); |
| function_list.push_back(VulkanFunction{func_names.at(i++), to_vkVoidFunction(funcs.func_two)}); |
| function_list.push_back(VulkanFunction{func_names.at(i++), to_vkVoidFunction(funcs.func_three)}); |
| function_list.push_back(VulkanFunction{func_names.at(i++), to_vkVoidFunction(funcs.func_four)}); |
| } |
| } |
| |
| // Add device interception functions to a layer. Need to call `add_custom_device_interception_function` since the layer has |
| // to setup a unordered_map for storing the next function in the chain, and key it based on the name |
| template <typename FunctionStruct> |
| void fill_device_intercept_functions(TestLayer& layer, std::vector<std::string>& func_names, FunctionStruct const& funcs, |
| uint32_t function_count, uint32_t function_start = 0) { |
| for (uint32_t i = function_start; i < function_start + function_count;) { |
| layer.add_custom_device_interception_function(func_names.at(i++), to_vkVoidFunction(funcs.func_zero)); |
| layer.add_custom_device_interception_function(func_names.at(i++), to_vkVoidFunction(funcs.func_one)); |
| layer.add_custom_device_interception_function(func_names.at(i++), to_vkVoidFunction(funcs.func_two)); |
| layer.add_custom_device_interception_function(func_names.at(i++), to_vkVoidFunction(funcs.func_three)); |
| layer.add_custom_device_interception_function(func_names.at(i++), to_vkVoidFunction(funcs.func_four)); |
| } |
| } |
| // Add physical device interception functions to a layer. Need to call `add_custom_device_interception_function` since the |
| // layer has to setup a unordered_map for storing the next function in the chain, and key it based on the name |
| template <typename FunctionStruct> |
| void fill_phys_dev_intercept_functions(TestLayer& layer, std::vector<std::string>& func_names, FunctionStruct const& funcs, |
| uint32_t function_count, uint32_t function_start = 0) { |
| for (uint32_t i = function_start; i < function_start + function_count;) { |
| layer.add_custom_physical_device_intercept_function(func_names.at(i++), to_vkVoidFunction(funcs.func_zero)); |
| layer.add_custom_physical_device_intercept_function(func_names.at(i++), to_vkVoidFunction(funcs.func_one)); |
| layer.add_custom_physical_device_intercept_function(func_names.at(i++), to_vkVoidFunction(funcs.func_two)); |
| layer.add_custom_physical_device_intercept_function(func_names.at(i++), to_vkVoidFunction(funcs.func_three)); |
| layer.add_custom_physical_device_intercept_function(func_names.at(i++), to_vkVoidFunction(funcs.func_four)); |
| } |
| } |
| |
| template <typename FunctionLoader, typename ParentType, typename DispatchableHandleType, typename FunctionStruct> |
| void check_custom_functions(FunctionLoader& loader, ParentType parent, DispatchableHandleType handle, FunctionStruct const&, |
| std::vector<std::string>& func_names, uint32_t function_count, uint32_t function_start = 0) { |
| for (uint32_t i = function_start; i < function_start + function_count;) { |
| decltype(FunctionStruct::func_zero)* returned_func_i = loader.load(parent, func_names.at(i++).c_str()); |
| ASSERT_NE(returned_func_i, nullptr); |
| EXPECT_EQ(returned_func_i(handle, i * 10), i * 10); |
| |
| decltype(FunctionStruct::func_one)* returned_func_ii = loader.load(parent, func_names.at(i++).c_str()); |
| ASSERT_NE(returned_func_ii, nullptr); |
| EXPECT_EQ(returned_func_ii(handle, i * 10, i * 5), i * 10 + i * 5); |
| |
| decltype(FunctionStruct::func_two)* returned_func_iif = loader.load(parent, func_names.at(i++).c_str()); |
| ASSERT_NE(returned_func_iif, nullptr); |
| EXPECT_NEAR(returned_func_iif(handle, i * 10, i * 5, 0.1234f), i * 10 + i * 5 + 0.1234f, 0.001); |
| |
| int x = 5; |
| int y = -505; |
| decltype(FunctionStruct::func_three)* returned_func_pp = loader.load(parent, func_names.at(i++).c_str()); |
| ASSERT_NE(returned_func_pp, nullptr); |
| EXPECT_EQ(returned_func_pp(handle, &x, &y), -500); |
| |
| x = 5; |
| y = -505; |
| decltype(FunctionStruct::func_four)* returned_func_ppiiffccc = loader.load(parent, func_names.at(i++).c_str()); |
| ASSERT_NE(returned_func_ppiiffccc, nullptr); |
| EXPECT_NEAR(returned_func_ppiiffccc(handle, &x, &y, 200, 300, 0.123f, 1001.89f, 'a', 'b', 'c'), |
| -500 + 200 + 300 + 0.123 + 1001.89 + 97 + 98 + 99, 0.001f); |
| } |
| } |
| |
| template <typename FunctionLoader, typename ParentType, typename DispatchableHandleType, typename FunctionStruct> |
| void check_layer_custom_functions(FunctionLoader& loader, ParentType parent, DispatchableHandleType handle, TestLayer& layer, |
| FunctionStruct const&, std::vector<std::string>& func_names, uint32_t function_count, |
| uint32_t function_start = 0) { |
| for (uint32_t i = function_start; i < function_start + function_count;) { |
| decltype(FunctionStruct::func_zero)* returned_func_i = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_i, nullptr); |
| EXPECT_EQ(returned_func_i(handle, &layer, func_names.at(i).c_str(), i), (i + 3) * 3); |
| i++; |
| decltype(FunctionStruct::func_one)* returned_func_if = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_if, nullptr); |
| EXPECT_EQ(returned_func_if(handle, &layer, func_names.at(i).c_str(), i, i + 1.f), (i + 2) * 3 + (i + 2) * 10); |
| i++; |
| |
| decltype(FunctionStruct::func_two)* returned_func_iif = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_iif, nullptr); |
| EXPECT_NEAR(returned_func_iif(handle, &layer, func_names.at(i).c_str(), i * 10, i * 5, 0.1234f), |
| (i * 10 + 1) + (i * 5 + 2) + (0.1234f * 2.f), 0.001); |
| i++; |
| |
| int x = 5 + i; |
| int y = -505 - i; |
| decltype(FunctionStruct::func_three)* returned_func_pp = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_pp, nullptr); |
| EXPECT_EQ(returned_func_pp(handle, &layer, func_names.at(i).c_str(), &x, &y), |
| (5 + static_cast<int>(i) + 1) + (-505 - static_cast<int>(i) - 2)); |
| i++; |
| |
| x = 5; |
| y = -505; |
| decltype(FunctionStruct::func_four)* returned_func_ppiiffccc = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_ppiiffccc, nullptr); |
| EXPECT_NEAR( |
| returned_func_ppiiffccc(handle, &layer, func_names.at(i).c_str(), &x, &y, 200, 300, 0.123f, 1001.89f, 'a', 'b', 'c'), |
| -500 + (200 + 4) + (300 + 5) + (0.123 + 1) + (1001.89 + 2) + 100 + 101 + 102, |
| 0.001f); // layer changes abc to def |
| i++; |
| } |
| } |
| |
| template <typename FunctionLoader, typename ParentType, typename DispatchableHandleType, typename FunctionStruct> |
| void check_layer_custom_functions_no_implementation(FunctionLoader& loader, ParentType parent, DispatchableHandleType handle, |
| TestLayer& layer, FunctionStruct const&, std::vector<std::string>& func_names, |
| uint32_t function_count, uint32_t function_start = 0) { |
| for (uint32_t i = function_start; i < function_start + function_count;) { |
| decltype(FunctionStruct::func_zero)* returned_func_i = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_i, nullptr); |
| EXPECT_EQ(1337U, returned_func_i(handle, &layer, func_names.at(i).c_str(), i)); |
| i++; |
| decltype(FunctionStruct::func_one)* returned_func_if = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_if, nullptr); |
| EXPECT_EQ(1337U, returned_func_if(handle, &layer, func_names.at(i).c_str(), i, i + 1.f)); |
| i++; |
| |
| decltype(FunctionStruct::func_two)* returned_func_iif = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_iif, nullptr); |
| EXPECT_NEAR(-1337.0, returned_func_iif(handle, &layer, func_names.at(i).c_str(), i * 10, i * 5, 0.1234f), 0.001); |
| i++; |
| |
| int x = 5 + i; |
| int y = -505 - i; |
| decltype(FunctionStruct::func_three)* returned_func_pp = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_pp, nullptr); |
| EXPECT_EQ(-1337, returned_func_pp(handle, &layer, func_names.at(i).c_str(), &x, &y)); |
| i++; |
| |
| x = 5; |
| y = -505; |
| decltype(FunctionStruct::func_four)* returned_func_ppiiffccc = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_ppiiffccc, nullptr); |
| EXPECT_NEAR( |
| -1337.0, |
| returned_func_ppiiffccc(handle, &layer, func_names.at(i).c_str(), &x, &y, 200, 300, 0.123f, 1001.89f, 'a', 'b', 'c'), |
| 0.001); |
| i++; |
| } |
| } |
| |
| template <typename FunctionLoader, typename ParentType, typename DispatchableHandleType, typename FunctionStruct> |
| void check_layer_custom_functions_no_interception(FunctionLoader& loader, ParentType parent, DispatchableHandleType handle, |
| TestLayer& layer, FunctionStruct const&, std::vector<std::string>& func_names, |
| uint32_t function_count, uint32_t function_start = 0) { |
| for (uint32_t i = function_start; i < function_start + function_count;) { |
| decltype(FunctionStruct::func_zero)* returned_func_i = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_i, nullptr); |
| EXPECT_EQ(returned_func_i(handle, &layer, func_names.at(i).c_str(), i), (i)*3); |
| i++; |
| decltype(FunctionStruct::func_one)* returned_func_if = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_if, nullptr); |
| EXPECT_EQ(returned_func_if(handle, &layer, func_names.at(i).c_str(), i, i + 1.f), (i)*3 + (i + 1) * 10); |
| i++; |
| |
| decltype(FunctionStruct::func_two)* returned_func_iif = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_iif, nullptr); |
| EXPECT_NEAR(returned_func_iif(handle, &layer, func_names.at(i).c_str(), i * 10, i * 5, 0.1234f), |
| (i * 10) + (i * 5) + (0.1234f), 0.001); |
| i++; |
| |
| int x = 5 + i; |
| int y = -505 - i; |
| decltype(FunctionStruct::func_three)* returned_func_pp = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_pp, nullptr); |
| EXPECT_EQ(returned_func_pp(handle, &layer, func_names.at(i).c_str(), &x, &y), |
| (5 + static_cast<int>(i)) + (-505 - static_cast<int>(i))); |
| i++; |
| |
| x = 5; |
| y = -505; |
| decltype(FunctionStruct::func_four)* returned_func_ppiiffccc = loader.load(parent, func_names.at(i).c_str()); |
| ASSERT_NE(returned_func_ppiiffccc, nullptr); |
| EXPECT_NEAR( |
| returned_func_ppiiffccc(handle, &layer, func_names.at(i).c_str(), &x, &y, 200, 300, 0.123f, 1001.89f, 'a', 'b', 'c'), |
| -500 + (200) + (300) + (0.123) + (1001.89) + 97 + 98 + 99, 0.001f); |
| i++; |
| } |
| } |
| |
| using custom_physical_device_functions = custom_functions<VkPhysicalDevice>; |
| using layer_intercept_physical_device_functions = layer_intercept_functions<VkPhysicalDevice>; |
| using layer_implementation_physical_device_functions = layer_implementation_functions<VkPhysicalDevice>; |
| |
| TEST(UnknownFunction, PhysicalDeviceFunction) { |
| FrameworkEnvironment env{}; |
| auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); |
| uint32_t function_count = MAX_NUM_UNKNOWN_EXTS; |
| std::vector<std::string> function_names; |
| add_function_names(function_names, function_count); |
| |
| fill_implementation_functions(driver.physical_devices.at(0).custom_physical_device_functions, function_names, |
| custom_physical_device_functions{}, function_count); |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| VkPhysicalDevice phys_dev = inst.GetPhysDev(); |
| check_custom_functions(env.vulkan_functions, inst.inst, phys_dev, custom_physical_device_functions{}, function_names, |
| function_count); |
| } |
| |
| TEST(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupport) { |
| FrameworkEnvironment env{}; |
| auto& driver_0 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); |
| auto& driver_1 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); |
| uint32_t function_count = MAX_NUM_UNKNOWN_EXTS; |
| std::vector<std::string> function_names; |
| add_function_names(function_names, function_count); |
| |
| // used to identify the GPUs |
| driver_0.physical_devices.emplace_back("physical_device_0").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; |
| driver_1.physical_devices.emplace_back("physical_device_1").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU; |
| |
| for (uint32_t i = 0; i < function_count / 10; i++) { |
| fill_implementation_functions(driver_0.physical_devices.at(0).custom_physical_device_functions, function_names, |
| custom_physical_device_functions{}, 5, i * 10); |
| fill_implementation_functions(driver_1.physical_devices.at(0).custom_physical_device_functions, function_names, |
| custom_physical_device_functions{}, 5, i * 10 + 5); |
| } |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| auto phys_devs = inst.GetPhysDevs(2); |
| VkPhysicalDevice phys_dev_0 = phys_devs[0]; |
| VkPhysicalDevice phys_dev_1 = phys_devs[1]; |
| VkPhysicalDeviceProperties props{}; |
| env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[0], &props); |
| if (props.deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) { |
| phys_dev_0 = phys_devs[1]; |
| phys_dev_1 = phys_devs[0]; |
| } |
| for (uint32_t i = 0; i < function_count / 10; i++) { |
| check_custom_functions(env.vulkan_functions, inst.inst, phys_dev_0, custom_physical_device_functions{}, function_names, 5, |
| i * 10); |
| check_custom_functions(env.vulkan_functions, inst.inst, phys_dev_1, custom_physical_device_functions{}, function_names, 5, |
| i * 10 + 5); |
| } |
| } |
| |
| // Add unknown functions to driver 0, and try to use them on driver 1. |
| TEST(UnknownFunctionDeathTests, PhysicalDeviceFunctionErrorPath) { |
| FrameworkEnvironment env{}; |
| auto& driver_0 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); |
| auto& driver_1 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); |
| std::vector<std::string> function_names; |
| add_function_names(function_names, 1); |
| |
| // used to identify the GPUs |
| driver_0.physical_devices.emplace_back("physical_device_0").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; |
| driver_1.physical_devices.emplace_back("physical_device_1").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU; |
| function_names.push_back(std::string("vkNotIntRealFuncTEST_0")); |
| |
| custom_physical_device_functions funcs{}; |
| driver_0.physical_devices.at(0).custom_physical_device_functions.push_back( |
| VulkanFunction{function_names.back(), to_vkVoidFunction(funcs.func_zero)}); |
| |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| auto phys_devs = inst.GetPhysDevs(2); |
| VkPhysicalDevice phys_dev_to_use = phys_devs[1]; |
| VkPhysicalDeviceProperties props{}; |
| env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[1], &props); |
| if (props.deviceType != VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) phys_dev_to_use = phys_devs[0]; |
| // use the wrong GPU to query the functions, should get 5 errors |
| |
| decltype(custom_physical_device_functions::func_zero)* returned_func_i = |
| env.vulkan_functions.load(inst.inst, function_names.at(0).c_str()); |
| ASSERT_NE(returned_func_i, nullptr); |
| ASSERT_DEATH(returned_func_i(phys_dev_to_use, 0), "Function vkNotIntRealFuncTEST_0 not supported for this physical device"); |
| } |
| |
| TEST(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayerImplementation) { |
| FrameworkEnvironment env{}; |
| env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); |
| uint32_t function_count = MAX_NUM_UNKNOWN_EXTS; |
| std::vector<std::string> function_names; |
| add_function_names(function_names, function_count); |
| |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept.json"); |
| auto& layer = env.get_test_layer(); |
| fill_implementation_functions(layer.custom_physical_device_implementation_functions, function_names, |
| layer_implementation_physical_device_functions{}, function_count); |
| |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| VkPhysicalDevice phys_dev = inst.GetPhysDev(); |
| check_layer_custom_functions_no_interception(env.vulkan_functions, inst.inst, phys_dev, layer, |
| layer_implementation_physical_device_functions{}, function_names, function_count); |
| } |
| |
| TEST(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupportWithImplicitLayerImplementation) { |
| FrameworkEnvironment env{}; |
| auto& driver_0 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); |
| auto& driver_1 = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); |
| uint32_t function_count = MAX_NUM_UNKNOWN_EXTS; |
| std::vector<std::string> function_names; |
| add_function_names(function_names, function_count); |
| |
| // used to identify the GPUs |
| driver_0.physical_devices.emplace_back("physical_device_0").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; |
| driver_1.physical_devices.emplace_back("physical_device_1").properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU; |
| for (uint32_t i = 0; i < function_count / 10; i++) { |
| fill_implementation_functions(driver_0.physical_devices.at(0).custom_physical_device_functions, function_names, |
| custom_physical_device_functions{}, 5, i * 10); |
| fill_implementation_functions(driver_1.physical_devices.at(0).custom_physical_device_functions, function_names, |
| custom_physical_device_functions{}, 5, i * 10 + 5); |
| } |
| |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept.json"); |
| |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| auto phys_devs = inst.GetPhysDevs(2); |
| VkPhysicalDevice phys_dev_0 = phys_devs[0]; |
| VkPhysicalDevice phys_dev_1 = phys_devs[1]; |
| VkPhysicalDeviceProperties props{}; |
| env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[0], &props); |
| if (props.deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) { |
| phys_dev_0 = phys_devs[1]; |
| phys_dev_1 = phys_devs[0]; |
| } |
| for (uint32_t i = 0; i < function_count / 10; i++) { |
| check_custom_functions(env.vulkan_functions, inst.inst, phys_dev_0, custom_physical_device_functions{}, function_names, 5, |
| i * 10); |
| check_custom_functions(env.vulkan_functions, inst.inst, phys_dev_1, custom_physical_device_functions{}, function_names, 5, |
| i * 10 + 5); |
| } |
| } |
| |
| TEST(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayerInterception) { |
| FrameworkEnvironment env{}; |
| env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); |
| uint32_t function_count = MAX_NUM_UNKNOWN_EXTS; |
| |
| std::vector<std::string> function_names; |
| add_function_names(function_names, function_count); |
| |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept.json"); |
| auto& layer = env.get_test_layer(); |
| fill_phys_dev_intercept_functions(layer, function_names, layer_intercept_physical_device_functions{}, function_count); |
| |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| VkPhysicalDevice phys_dev = inst.GetPhysDev(); |
| check_layer_custom_functions_no_implementation(env.vulkan_functions, inst.inst, phys_dev, layer, |
| layer_intercept_physical_device_functions{}, function_names, function_count); |
| } |
| |
| TEST(UnknownFunction, PhysicalDeviceFunctionDriverSupportWithImplicitLayerInterception) { |
| FrameworkEnvironment env{}; |
| auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); |
| uint32_t function_count = 100; |
| std::vector<std::string> function_names; |
| add_function_names(function_names, function_count); |
| fill_implementation_functions(driver.physical_devices.at(0).custom_physical_device_functions, function_names, |
| layer_implementation_physical_device_functions{}, function_count); |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept.json"); |
| auto& layer = env.get_test_layer(); |
| fill_phys_dev_intercept_functions(layer, function_names, layer_intercept_physical_device_functions{}, function_count); |
| |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| VkPhysicalDevice phys_dev = inst.GetPhysDev(); |
| check_layer_custom_functions(env.vulkan_functions, inst.inst, phys_dev, layer, layer_intercept_physical_device_functions{}, |
| function_names, function_count); |
| } |
| |
| TEST(UnknownFunction, PhysicalDeviceFunctionWithMultipleImplicitLayersInterception) { |
| FrameworkEnvironment env{}; |
| auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)); |
| std::vector<std::string> function_names; |
| uint32_t function_count = MAX_NUM_UNKNOWN_EXTS; |
| add_function_names(function_names, function_count); |
| driver.physical_devices.emplace_back("physical_device_0"); |
| |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept_0") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept_0.json"); |
| auto& layer_0 = env.get_test_layer(0); |
| layer_0.set_use_gipa_GetPhysicalDeviceProcAddr(true); |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept_1") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept_1.json"); |
| auto& layer_1 = env.get_test_layer(1); |
| layer_1.set_use_gipa_GetPhysicalDeviceProcAddr(false); |
| for (uint32_t i = 0; i < function_count / 10; i++) { |
| fill_implementation_functions(driver.physical_devices.at(0).custom_physical_device_functions, function_names, |
| layer_implementation_physical_device_functions{}, 5, i * 10); |
| fill_phys_dev_intercept_functions(layer_0, function_names, layer_intercept_physical_device_functions{}, 5, i * 10); |
| fill_phys_dev_intercept_functions(layer_1, function_names, layer_intercept_physical_device_functions{}, 5, i * 10 + 5); |
| } |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| VkPhysicalDevice phys_dev = inst.GetPhysDev(); |
| for (uint32_t i = 0; i < function_count / 10; i++) { |
| check_layer_custom_functions(env.vulkan_functions, inst.inst, phys_dev, layer_0, |
| layer_intercept_physical_device_functions{}, function_names, 5, i * 10); |
| check_layer_custom_functions_no_implementation(env.vulkan_functions, inst.inst, phys_dev, layer_1, |
| layer_intercept_physical_device_functions{}, function_names, 5, i * 10 + 5); |
| } |
| } |
| |
| template <typename ParentType> |
| ParentType get_parent_type(InstWrapper const& inst, DeviceWrapper const& dev); |
| |
| template <> |
| VkInstance get_parent_type<VkInstance>(InstWrapper const& inst, DeviceWrapper const&) { |
| return inst.inst; |
| } |
| template <> |
| VkDevice get_parent_type<VkDevice>(InstWrapper const&, DeviceWrapper const& dev) { |
| return dev.dev; |
| } |
| |
| template <typename DispatchableHandleType> |
| DispatchableHandleType get_dispatch_handle(FrameworkEnvironment& env, DeviceWrapper const& dev, |
| std::vector<TestConfig> const& flags); |
| |
| template <> |
| VkDevice get_dispatch_handle<VkDevice>(FrameworkEnvironment&, DeviceWrapper const& dev, std::vector<TestConfig> const&) { |
| return dev.dev; |
| } |
| |
| template <> |
| VkCommandBuffer get_dispatch_handle<VkCommandBuffer>(FrameworkEnvironment& env, DeviceWrapper const& dev, |
| std::vector<TestConfig> const&) { |
| VkCommandPool command_pool; |
| VkCommandPoolCreateInfo pool_create_info{}; |
| DeviceFunctions funcs{env.vulkan_functions, dev}; |
| funcs.vkCreateCommandPool(dev, &pool_create_info, nullptr, &command_pool); |
| VkCommandBuffer command_buffer; |
| VkCommandBufferAllocateInfo alloc_info{}; |
| alloc_info.commandBufferCount = 1; |
| alloc_info.commandPool = command_pool; |
| funcs.vkAllocateCommandBuffers(dev, &alloc_info, &command_buffer); |
| return command_buffer; |
| } |
| |
| template <> |
| VkQueue get_dispatch_handle<VkQueue>(FrameworkEnvironment& env, DeviceWrapper const& dev, std::vector<TestConfig> const&) { |
| DeviceFunctions funcs{env.vulkan_functions, dev.dev}; |
| VkQueue queue; |
| funcs.vkGetDeviceQueue(dev, 0, 0, &queue); |
| return queue; |
| } |
| |
| template <typename ParentType, typename DispatchableHandleType> |
| void unknown_function_test_impl(std::vector<TestConfig> const& flags) { |
| using custom_functions_type = custom_functions<DispatchableHandleType>; |
| using layer_implementation_functions_type = layer_implementation_functions<DispatchableHandleType>; |
| using layer_intercept_functions_type = layer_intercept_functions<DispatchableHandleType>; |
| |
| FrameworkEnvironment env{}; |
| auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); |
| uint32_t function_count = MAX_NUM_UNKNOWN_EXTS; |
| |
| std::vector<std::string> function_names; |
| add_function_names(function_names, function_count); |
| |
| if (has_flag(flags, TestConfig::add_layer_interception)) { |
| fill_implementation_functions(driver.physical_devices.back().known_device_functions, function_names, |
| layer_implementation_functions_type{}, function_count); |
| } else { |
| fill_implementation_functions(driver.physical_devices.back().known_device_functions, function_names, |
| custom_functions_type{}, function_count); |
| } |
| TestLayer* layer_ptr = nullptr; |
| if (has_flag(flags, TestConfig::add_layer_implementation) || has_flag(flags, TestConfig::add_layer_interception)) { |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept.json"); |
| layer_ptr = &env.get_test_layer(); |
| } |
| if (has_flag(flags, TestConfig::add_layer_implementation) && has_flag(flags, TestConfig::add_layer_interception)) { |
| for (uint32_t i = 0; i < function_count / 10; i++) { |
| fill_implementation_functions(layer_ptr->custom_device_implementation_functions, function_names, |
| layer_implementation_functions_type{}, 5, i * 10); |
| fill_device_intercept_functions(*layer_ptr, function_names, layer_intercept_functions_type{}, 5, i * 10 + 5); |
| } |
| } else if (has_flag(flags, TestConfig::add_layer_implementation)) { |
| fill_implementation_functions(layer_ptr->custom_device_implementation_functions, function_names, custom_functions_type{}, |
| function_count); |
| } else if (has_flag(flags, TestConfig::add_layer_interception)) { |
| fill_device_intercept_functions(*layer_ptr, function_names, layer_intercept_functions_type{}, function_count); |
| } |
| |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| DeviceWrapper dev{inst}; |
| dev.create_info.add_device_queue({}); |
| dev.CheckCreate(inst.GetPhysDev()); |
| auto dispatch_type = get_dispatch_handle<DispatchableHandleType>(env, dev, flags); |
| auto parent_type = get_parent_type<ParentType>(inst, dev); |
| |
| if (has_flag(flags, TestConfig::add_layer_implementation) && has_flag(flags, TestConfig::add_layer_interception)) { |
| for (uint32_t i = 0; i < function_count / 10; i++) { |
| check_layer_custom_functions_no_interception(env.vulkan_functions, parent_type, dispatch_type, *layer_ptr, |
| layer_implementation_functions_type{}, function_names, 5, i * 10); |
| } |
| } else if (has_flag(flags, TestConfig::add_layer_interception)) { |
| check_layer_custom_functions(env.vulkan_functions, parent_type, dispatch_type, *layer_ptr, layer_intercept_functions_type{}, |
| function_names, function_count); |
| |
| } else { |
| check_custom_functions(env.vulkan_functions, parent_type, dispatch_type, custom_functions_type{}, function_names, |
| function_count); |
| } |
| } |
| |
| // Device |
| |
| TEST(UnknownFunction, DeviceFromGDPA) { unknown_function_test_impl<VkDevice, VkDevice>({}); } |
| |
| TEST(UnknownFunction, DeviceFromGDPAWithLayerImplementation) { |
| unknown_function_test_impl<VkDevice, VkDevice>({TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, DeviceFromGDPAWithLayerInterception) { |
| unknown_function_test_impl<VkDevice, VkDevice>({TestConfig::add_layer_interception}); |
| } |
| |
| TEST(UnknownFunction, DeviceFromGDPAWithLayerInterceptionAndLayerImplementation) { |
| unknown_function_test_impl<VkDevice, VkDevice>({TestConfig::add_layer_interception, TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, DeviceFromGIPA) { unknown_function_test_impl<VkInstance, VkDevice>({}); } |
| |
| TEST(UnknownFunction, DeviceFromGIPAWithLayerImplementation) { |
| unknown_function_test_impl<VkInstance, VkDevice>({TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, DeviceFromGIPAWithLayerInterception) { |
| unknown_function_test_impl<VkInstance, VkDevice>({TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, DeviceFromGIPAWithLayerInterceptionAndLayerImplementation) { |
| unknown_function_test_impl<VkInstance, VkDevice>({TestConfig::add_layer_interception, TestConfig::add_layer_implementation}); |
| } |
| |
| // Command buffers |
| |
| TEST(UnknownFunction, CommandBufferFromGDPA) { unknown_function_test_impl<VkDevice, VkCommandBuffer>({}); } |
| |
| TEST(UnknownFunction, CommandBufferFromGDPAWithLayerImplementation) { |
| unknown_function_test_impl<VkDevice, VkCommandBuffer>({TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, CommandBufferFromGDPAWithLayerInterception) { |
| unknown_function_test_impl<VkDevice, VkCommandBuffer>({TestConfig::add_layer_interception}); |
| } |
| |
| TEST(UnknownFunction, CommandBufferFromGDPAWithLayerInterceptionAndLayerImplementation) { |
| unknown_function_test_impl<VkDevice, VkCommandBuffer>( |
| {TestConfig::add_layer_interception, TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, CommandBufferFromGIPA) { unknown_function_test_impl<VkInstance, VkCommandBuffer>({}); } |
| |
| TEST(UnknownFunction, CommandBufferFromGIPAWithLayerImplementation) { |
| unknown_function_test_impl<VkInstance, VkCommandBuffer>({TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, CommandBufferFromGIPAWithLayerInterception) { |
| unknown_function_test_impl<VkInstance, VkCommandBuffer>({TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, CommandBufferFromGIPAWithLayerInterceptionAndLayerImplementation) { |
| unknown_function_test_impl<VkInstance, VkCommandBuffer>( |
| {TestConfig::add_layer_interception, TestConfig::add_layer_implementation}); |
| } |
| |
| // Queues |
| |
| TEST(UnknownFunction, QueueFromGDPA) { unknown_function_test_impl<VkDevice, VkQueue>({}); } |
| |
| TEST(UnknownFunction, QueueFromGDPAWithLayerImplementation) { |
| unknown_function_test_impl<VkDevice, VkQueue>({TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, QueueFromGDPAWithLayerInterception) { |
| unknown_function_test_impl<VkDevice, VkQueue>({TestConfig::add_layer_interception}); |
| } |
| |
| TEST(UnknownFunction, QueueFromGDPAWithLayerInterceptionAndLayerImplementation) { |
| unknown_function_test_impl<VkDevice, VkQueue>({TestConfig::add_layer_interception, TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, QueueFromGIPA) { unknown_function_test_impl<VkInstance, VkQueue>({}); } |
| |
| TEST(UnknownFunction, QueueFromGIPAWithLayer) { |
| unknown_function_test_impl<VkInstance, VkQueue>({TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, QueueFromGIPAWithLayerInterception) { |
| unknown_function_test_impl<VkInstance, VkQueue>({TestConfig::add_layer_implementation}); |
| } |
| |
| TEST(UnknownFunction, QueueFromGIPAWithLayerInterceptionAndLayerImplementation) { |
| unknown_function_test_impl<VkInstance, VkQueue>({TestConfig::add_layer_interception, TestConfig::add_layer_implementation}); |
| } |
| |
| /* |
| The purpose of LayerInterceptData is to provide a place to store data that is accessible inside the interception function. |
| It works by being a templated type with static variables. Every unique type used creates a new template instantiation, with its own |
| static variable storage. Thus interception functions that are templated correctly have per-template static data storage at their |
| disposal, which is used to query the next function in the chain and call down. |
| */ |
| |
| template <typename UniqueType> |
| struct LayerInterceptData { |
| static TestLayer* layer; |
| static const char* name; |
| }; |
| template <typename UniqueType> |
| TestLayer* LayerInterceptData<UniqueType>::layer = nullptr; |
| template <typename UniqueType> |
| const char* LayerInterceptData<UniqueType>::name = nullptr; |
| |
| template <typename DispatchableHandle> |
| struct FunctionZero { |
| static VKAPI_ATTR uint32_t VKAPI_CALL implementation(DispatchableHandle, uint32_t a, uint32_t b) { return a + b; } |
| |
| template <typename LayerType> |
| static VKAPI_ATTR uint32_t VKAPI_CALL intercept(DispatchableHandle handle, uint32_t a, uint32_t b) { |
| decltype(implementation)* func = |
| reinterpret_cast<decltype(&implementation)>(LayerType::layer->get_custom_intercept_function(LayerType::name)); |
| if (func == nullptr) return 1337; |
| return func(handle, a + 3, b + 7); |
| } |
| |
| template <typename ParentType> |
| static void check(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, const char* name, |
| uint32_t interception_count = 1) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| EXPECT_EQ(returned_func(dispatch_type, 4, 9), (4 + 3 * interception_count) + (9 + 7 * interception_count)); |
| } |
| template <typename ParentType> |
| static void check_no_implementation(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, |
| const char* name) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| EXPECT_EQ(returned_func(dispatch_type, 5, 2), 1337U); |
| } |
| }; |
| |
| template <typename DispatchableHandle> |
| struct FunctionOne { |
| static VKAPI_ATTR uint32_t VKAPI_CALL implementation(DispatchableHandle, uint32_t a, uint32_t b, char c) { return a + b + c; } |
| |
| template <typename LayerType> |
| static VKAPI_ATTR uint32_t VKAPI_CALL intercept(DispatchableHandle handle, uint32_t a, uint32_t b, char c) { |
| decltype(implementation)* func = |
| reinterpret_cast<decltype(&implementation)>(LayerType::layer->get_custom_intercept_function(LayerType::name)); |
| if (func == nullptr) return 1337; |
| return func(handle, a + 2, b + 9, c + 1); |
| } |
| |
| template <typename ParentType> |
| static void check(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, const char* name, |
| uint32_t interception_count = 1) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| EXPECT_EQ(returned_func(dispatch_type, 12, 17, 'a'), |
| (12 + 2 * interception_count) + (17 + 9 * interception_count) + ('a' + 1 * interception_count)); |
| } |
| template <typename ParentType> |
| static void check_no_implementation(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, |
| const char* name) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| EXPECT_EQ(returned_func(dispatch_type, 1, 516, 'c'), 1337U); |
| } |
| }; |
| |
| template <typename DispatchableHandle> |
| struct FunctionTwo { |
| static VKAPI_ATTR float VKAPI_CALL implementation(DispatchableHandle, int* ptr_a, int* ptr_b) { |
| return 0.123f + *ptr_a + *ptr_b; |
| } |
| |
| template <typename LayerType> |
| static VKAPI_ATTR float VKAPI_CALL intercept(DispatchableHandle handle, int* ptr_a, int* ptr_b) { |
| decltype(implementation)* func = |
| reinterpret_cast<decltype(&implementation)>(LayerType::layer->get_custom_intercept_function(LayerType::name)); |
| if (func == nullptr) return -1337.f; |
| *ptr_a += 2; |
| *ptr_b += 5; |
| return func(handle, ptr_a, ptr_b); |
| } |
| |
| template <typename ParentType> |
| static void check(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, const char* name, |
| uint32_t interception_count = 1) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| int x = 10, y = 3; |
| EXPECT_NEAR(returned_func(dispatch_type, &x, &y), 0.123f + (10 + 2 * interception_count) + (3 + 5 * interception_count), |
| 0.001); |
| } |
| template <typename ParentType> |
| static void check_no_implementation(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, |
| const char* name) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| int x = 10, y = 0; |
| EXPECT_NEAR(returned_func(dispatch_type, &x, &y), -1337.f, 0.001); |
| } |
| }; |
| |
| template <typename DispatchableHandle> |
| struct FunctionThree { |
| static VKAPI_ATTR float VKAPI_CALL implementation(DispatchableHandle, int* ptr_a, float* ptr_b, uint32_t c) { |
| return 0.456f + *ptr_a + *ptr_b + c; |
| } |
| |
| template <typename LayerType> |
| static VKAPI_ATTR float VKAPI_CALL intercept(DispatchableHandle handle, int* ptr_a, float* ptr_b, uint32_t c) { |
| decltype(implementation)* func = |
| reinterpret_cast<decltype(&implementation)>(LayerType::layer->get_custom_intercept_function(LayerType::name)); |
| if (func == nullptr) return -1837.f; |
| *ptr_a += 55; |
| *ptr_b += 5.98f; |
| return func(handle, ptr_a, ptr_b, c + 100); |
| } |
| |
| template <typename ParentType> |
| static void check(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, const char* name, |
| uint32_t interception_count = 1) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| int x = 96; |
| float y = 7; |
| EXPECT_NEAR(returned_func(dispatch_type, &x, &y, 30), |
| 0.456f + (96 + 55 * interception_count) + (7 + 5.98f * interception_count) + (30 + 100 * interception_count), |
| 0.001); |
| } |
| template <typename ParentType> |
| static void check_no_implementation(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, |
| const char* name) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| int x = 10; |
| float y = 0; |
| EXPECT_NEAR(returned_func(dispatch_type, &x, &y, 40), -1837.f, 0.001); |
| } |
| }; |
| |
| template <typename DispatchableHandle> |
| struct FunctionFour { |
| static VKAPI_ATTR VkResult VKAPI_CALL implementation(DispatchableHandle, VkPhysicalDeviceLimits* limits, uint32_t* count, |
| VkExtensionProperties* props) { |
| limits->nonCoherentAtomSize = 0x0000ABCD0000FEDCU; |
| if (props == nullptr) { |
| *count = 5; |
| return VK_INCOMPLETE; |
| } else { |
| for (uint32_t i = 0; i < *count; i++) { |
| props[i].specVersion = i; |
| } |
| return VK_SUCCESS; |
| } |
| } |
| |
| template <typename LayerType> |
| static VKAPI_ATTR VkResult VKAPI_CALL intercept(DispatchableHandle handle, VkPhysicalDeviceLimits* limits, uint32_t* count, |
| VkExtensionProperties* props) { |
| decltype(implementation)* func = |
| reinterpret_cast<decltype(&implementation)>(LayerType::layer->get_custom_intercept_function(LayerType::name)); |
| if (func == nullptr) return VK_ERROR_DEVICE_LOST; |
| VkResult res = func(handle, limits, count, props); |
| if (props) { |
| for (uint32_t i = 5; i < *count; i++) { |
| props[i].specVersion = 1234 + i * 2; |
| } |
| } else if (count) { |
| *count += 1; |
| } |
| return res; |
| } |
| |
| template <typename ParentType> |
| static void check(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, const char* name, |
| uint32_t interception_count = 1) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| VkPhysicalDeviceLimits limits{}; |
| uint32_t count = 0; |
| EXPECT_EQ(returned_func(dispatch_type, &limits, &count, nullptr), VK_INCOMPLETE); |
| EXPECT_EQ(count, 5 + interception_count); |
| std::vector<VkExtensionProperties> props(count, VkExtensionProperties{}); |
| EXPECT_EQ(returned_func(dispatch_type, &limits, &count, props.data()), VK_SUCCESS); |
| for (uint32_t i = 0; i < 5; i++) { |
| EXPECT_EQ(props.at(i).specVersion, i); |
| } |
| for (uint32_t i = 5; i < interception_count; i++) { |
| EXPECT_EQ(props.at(i).specVersion, 1234 + i * 2); // interception should do this |
| } |
| } |
| template <typename ParentType> |
| static void check_no_implementation(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type, |
| const char* name) { |
| decltype(implementation)* returned_func = loader.load(parent, name); |
| ASSERT_NE(returned_func, nullptr); |
| VkPhysicalDeviceLimits limits{}; |
| EXPECT_EQ(returned_func(dispatch_type, &limits, nullptr, nullptr), VK_ERROR_DEVICE_LOST); |
| } |
| }; |
| |
| struct UnknownFunction { |
| std::string name; |
| |
| bool has_implementation = false; |
| std::vector<uint32_t> interception_stack; |
| |
| UnknownFunction() = default; |
| UnknownFunction(std::string name) : name(name) {} |
| |
| template <typename FunctionType, typename ParentType, typename DispatchableHandle> |
| void check(VulkanFunctions const& loader, ParentType parent, DispatchableHandle dispatch_type) { |
| if (has_implementation) { |
| // Find how many layers intercept this function, stop if any layer 'implements' the function, thus doesn't return |
| uint32_t intercept_count = 0; |
| for (auto const& elem : interception_stack) { |
| if (elem == 1) break; |
| intercept_count++; |
| } |
| FunctionType::Function::check(loader, parent, dispatch_type, name.c_str(), intercept_count); |
| } else { |
| FunctionType::Function::check_no_implementation(loader, parent, dispatch_type, name.c_str()); |
| } |
| } |
| |
| void push_layer_implementation() { interception_stack.push_back(1); } |
| void push_layer_interception() { interception_stack.push_back(0); } |
| }; |
| |
| // For VkDevice, VkCommandBuffer, & VkQueue |
| template <typename FunctionType, typename DispatchableHandle> |
| struct UnknownFunctionInfo { |
| using Function = FunctionType; |
| |
| static void add_to_driver(UnknownFunction& func, PhysicalDevice& physical_device) { |
| physical_device.add_device_function({func.name.c_str(), to_vkVoidFunction(Function::implementation)}); |
| func.has_implementation = true; |
| } |
| |
| template <typename LayerStruct> |
| static void add_to_layer(UnknownFunction& func, TestLayer& layer, LayerStruct) { |
| LayerInterceptData<LayerStruct>::layer = &layer; |
| LayerInterceptData<LayerStruct>::name = func.name.c_str(); |
| layer.add_custom_device_interception_function( |
| func.name, to_vkVoidFunction(&Function::template intercept<LayerInterceptData<LayerStruct>>)); |
| func.push_layer_interception(); |
| } |
| |
| static void add_implementation_to_layer(UnknownFunction& func, TestLayer& layer) { |
| layer.add_custom_device_implementation_function({func.name.c_str(), to_vkVoidFunction(Function::implementation)}); |
| func.has_implementation = true; |
| func.push_layer_implementation(); |
| } |
| }; |
| |
| // Specialization for VkPhysicalDevice |
| |
| template <typename FunctionType> |
| struct UnknownFunctionInfo<FunctionType, VkPhysicalDevice> { |
| using Function = FunctionType; |
| |
| static void add_to_driver(UnknownFunction& func, PhysicalDevice& physical_device) { |
| physical_device.add_custom_physical_device_function({func.name.c_str(), to_vkVoidFunction(Function::implementation)}); |
| func.has_implementation = true; |
| } |
| |
| template <typename LayerStruct> |
| static void add_to_layer(UnknownFunction& func, TestLayer& layer, LayerStruct) { |
| LayerInterceptData<LayerStruct>::layer = &layer; |
| LayerInterceptData<LayerStruct>::name = func.name.c_str(); |
| layer.add_custom_physical_device_intercept_function( |
| func.name, to_vkVoidFunction(&Function::template intercept<LayerInterceptData<LayerStruct>>)); |
| func.push_layer_interception(); |
| } |
| |
| static void add_implementation_to_layer(UnknownFunction& func, TestLayer& layer) { |
| layer.add_custom_physical_device_implementation_function({func.name.c_str(), to_vkVoidFunction(Function::implementation)}); |
| func.has_implementation = true; |
| func.push_layer_implementation(); |
| } |
| }; |
| |
| struct Functions { |
| template <template <typename> class Function> |
| struct HelperTypedef { |
| using physical_device = UnknownFunctionInfo<Function<VkPhysicalDevice>, VkPhysicalDevice>; |
| using device = UnknownFunctionInfo<Function<VkDevice>, VkDevice>; |
| using command_buffer = UnknownFunctionInfo<Function<VkCommandBuffer>, VkCommandBuffer>; |
| using queue = UnknownFunctionInfo<Function<VkQueue>, VkQueue>; |
| }; |
| |
| using zero = HelperTypedef<FunctionZero>; |
| using one = HelperTypedef<FunctionOne>; |
| using two = HelperTypedef<FunctionTwo>; |
| using three = HelperTypedef<FunctionThree>; |
| using four = HelperTypedef<FunctionFour>; |
| }; |
| |
| template <size_t I> |
| struct D {}; |
| |
| TEST(UnknownFunction, PhysicalDeviceFunctionTwoLayerInterception) { |
| FrameworkEnvironment env{}; |
| auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); |
| PhysicalDevice& pd = driver.physical_devices.back(); |
| |
| UnknownFunction f{"vkFunc1"}; |
| Functions::three::physical_device::add_to_driver(f, pd); |
| |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept.json"); |
| auto& layer0 = env.get_test_layer(0); |
| Functions::three::physical_device::add_to_layer(f, layer0, D<0>{}); |
| |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept2") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept2.json"); |
| auto& layer1 = env.get_test_layer(1); |
| |
| Functions::three::physical_device::add_to_layer(f, layer1, D<1>{}); |
| |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| VkPhysicalDevice phys_dev = inst.GetPhysDev(); |
| |
| f.check<Functions::three::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| } |
| |
| TEST(UnknownFunction, ManyCombinations) { |
| FrameworkEnvironment env{}; |
| auto& driver = env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); |
| PhysicalDevice& physical_device = driver.physical_devices.back(); |
| std::vector<UnknownFunction> unknown_funcs; |
| |
| unknown_funcs.emplace_back("vkZero_uint32_uint32_0"); |
| unknown_funcs.emplace_back("vkOne_uint32_uint32_char_1"); |
| unknown_funcs.emplace_back("vkTwo_ptr_int_ptr_int_2"); |
| unknown_funcs.emplace_back("vkThree_ptr_int_ptr_float_uint_3"); |
| unknown_funcs.emplace_back("vkFour_PD_limits_ptr_uint_ptr_ExtProps_4"); |
| unknown_funcs.emplace_back("vkZero_uint32_uint32_5"); |
| unknown_funcs.emplace_back("vkOne_uint32_uint32_char_6"); |
| unknown_funcs.emplace_back("vkTwo_ptr_int_ptr_int_7"); |
| unknown_funcs.emplace_back("vkThree_ptr_int_ptr_float_uint_8"); |
| unknown_funcs.emplace_back("vkFour_PD_limits_ptr_uint_ptr_ExtProps_9"); |
| unknown_funcs.emplace_back("vkZero_uint32_uint32_10"); |
| unknown_funcs.emplace_back("vkOne_uint32_uint32_char_11"); |
| unknown_funcs.emplace_back("vkTwo_ptr_int_ptr_int_12"); |
| |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept_0") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME") |
| .add_device_extension(ManifestLayer::LayerDescription::Extension{ |
| "VK_EXT_for_the_laughs", 0, {"vkOne_uint32_uint32_char_11"}})), |
| "implicit_layer_unknown_function_intercept_0.json"); |
| auto& layer_0 = env.get_test_layer(0); |
| layer_0.set_use_gipa_GetPhysicalDeviceProcAddr(true); |
| env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_unknown_function_intercept_1") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .set_disable_environment("DISABLE_ME")), |
| "implicit_layer_unknown_function_intercept_1.json"); |
| auto& layer_1 = env.get_test_layer(1); |
| layer_1.set_use_gipa_GetPhysicalDeviceProcAddr(false); |
| |
| // Physical Device functions |
| Functions::zero::physical_device::add_to_driver(unknown_funcs.at(0), physical_device); |
| |
| Functions::one::physical_device::add_to_driver(unknown_funcs.at(1), physical_device); |
| Functions::one::physical_device::add_to_layer(unknown_funcs.at(1), layer_0, D<0>{}); |
| |
| Functions::two::physical_device::add_to_driver(unknown_funcs.at(2), physical_device); |
| Functions::two::physical_device::add_to_layer(unknown_funcs.at(2), layer_1, D<1>{}); |
| |
| Functions::three::physical_device::add_to_driver(unknown_funcs.at(3), physical_device); |
| Functions::three::physical_device::add_to_layer(unknown_funcs.at(3), layer_0, D<2>{}); |
| Functions::three::physical_device::add_to_layer(unknown_funcs.at(3), layer_1, D<3>{}); |
| |
| Functions::four::physical_device::add_implementation_to_layer(unknown_funcs.at(4), layer_0); |
| Functions::four::physical_device::add_to_layer(unknown_funcs.at(4), layer_1, D<4>{}); |
| |
| Functions::zero::physical_device::add_to_layer(unknown_funcs.at(5), layer_0, D<5>{}); |
| Functions::zero::physical_device::add_implementation_to_layer(unknown_funcs.at(5), layer_1); |
| |
| Functions::two::physical_device::add_to_driver(unknown_funcs.at(12), physical_device); |
| Functions::zero::physical_device::add_to_layer(unknown_funcs.at(12), layer_0, D<12>{}); |
| Functions::zero::physical_device::add_implementation_to_layer(unknown_funcs.at(12), layer_1); |
| |
| // Device functions |
| Functions::one::device::add_to_driver(unknown_funcs.at(6), physical_device); |
| |
| Functions::two::device::add_to_driver(unknown_funcs.at(7), physical_device); |
| Functions::two::device::add_to_layer(unknown_funcs.at(7), layer_0, D<6>{}); |
| |
| Functions::three::device::add_to_driver(unknown_funcs.at(8), physical_device); |
| Functions::three::device::add_to_layer(unknown_funcs.at(8), layer_1, D<7>{}); |
| |
| Functions::four::device::add_to_driver(unknown_funcs.at(9), physical_device); |
| Functions::four::device::add_to_layer(unknown_funcs.at(9), layer_0, D<8>{}); |
| Functions::four::device::add_to_layer(unknown_funcs.at(9), layer_1, D<9>{}); |
| |
| Functions::zero::device::add_implementation_to_layer(unknown_funcs.at(10), layer_0); |
| Functions::zero::device::add_to_layer(unknown_funcs.at(10), layer_1, D<10>{}); |
| |
| Functions::one::device::add_to_layer(unknown_funcs.at(11), layer_0, D<11>{}); |
| Functions::one::device::add_implementation_to_layer(unknown_funcs.at(11), layer_1); |
| |
| { |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| VkPhysicalDevice phys_dev = inst.GetPhysDev(); |
| DeviceWrapper dev{inst}; |
| dev.CheckCreate(phys_dev); |
| |
| unknown_funcs.at(0).check<Functions::zero::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(1).check<Functions::one::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(2).check<Functions::two::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(3).check<Functions::three::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(4).check<Functions::four::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(5).check<Functions::zero::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| |
| // Check that GIPA works for device functions |
| unknown_funcs.at(6).check<Functions::one::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(7).check<Functions::two::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(8).check<Functions::three::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(9).check<Functions::four::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(10).check<Functions::zero::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(11).check<Functions::one::device>(env.vulkan_functions, inst.inst, dev.dev); |
| |
| // Check that GDPA works for device functions |
| unknown_funcs.at(6).check<Functions::one::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(7).check<Functions::two::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(8).check<Functions::three::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(9).check<Functions::four::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(10).check<Functions::zero::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(11).check<Functions::one::device>(env.vulkan_functions, dev.dev, dev.dev); |
| } |
| |
| { |
| InstWrapper inst{env.vulkan_functions}; |
| inst.CheckCreate(); |
| |
| VkPhysicalDevice phys_dev = inst.GetPhysDev(); |
| DeviceWrapper dev{inst}; |
| dev.CheckCreate(phys_dev); |
| // Load device functions first, to make sure order of function loading is not important |
| // Check that GIPA works for device functions |
| unknown_funcs.at(6).check<Functions::one::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(7).check<Functions::two::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(8).check<Functions::three::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(9).check<Functions::four::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(10).check<Functions::zero::device>(env.vulkan_functions, inst.inst, dev.dev); |
| unknown_funcs.at(11).check<Functions::one::device>(env.vulkan_functions, inst.inst, dev.dev); |
| |
| // Check that GDPA works for device functions |
| unknown_funcs.at(6).check<Functions::one::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(7).check<Functions::two::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(8).check<Functions::three::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(9).check<Functions::four::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(10).check<Functions::zero::device>(env.vulkan_functions, dev.dev, dev.dev); |
| unknown_funcs.at(11).check<Functions::one::device>(env.vulkan_functions, dev.dev, dev.dev); |
| |
| unknown_funcs.at(0).check<Functions::zero::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(1).check<Functions::one::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(2).check<Functions::two::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(3).check<Functions::three::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(4).check<Functions::four::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| unknown_funcs.at(5).check<Functions::zero::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| } |
| } |
| |
| TEST(UnknownFunction, PhysicalDeviceFunctionInLayer) { |
| FrameworkEnvironment env{}; |
| env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA)).add_physical_device({}); |
| |
| env.add_implicit_layer(ManifestLayer{} |
| .add_layer(ManifestLayer::LayerDescription{} |
| .set_name("VK_LAYER_implicit_layer_1") |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_0) |
| .set_disable_environment("DISABLE_ME")) |
| .set_file_format_version({1, 0, 0}), |
| "implicit_layer_1.json"); |
| |
| UnknownFunction unknown_func{"vkPhysicalDeviceFunctionInLayer"}; |
| const char* ext_name = "VK_EXT_not_funny"; |
| |
| const char* explicit_layer_unknown_function_implement = "VK_LAYER_implement_unknown_function"; |
| env.add_explicit_layer( |
| ManifestLayer{} |
| .add_layer(ManifestLayer::LayerDescription{} |
| .set_name(explicit_layer_unknown_function_implement) |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2) |
| .add_instance_extension(ManifestLayer::LayerDescription::Extension{ext_name, 0, {unknown_func.name}})) |
| .set_file_format_version({1, 1, 0}), |
| "implement_unknown_function.json"); |
| auto& layer0 = env.get_test_layer(1); |
| |
| const char* explicit_layer_to_enable_1 = "VK_LAYER_explicit_layer_1"; |
| env.add_explicit_layer(ManifestLayer{} |
| .add_layer(ManifestLayer::LayerDescription{} |
| .set_name(explicit_layer_to_enable_1) |
| .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)) |
| .set_file_format_version({1, 2, 0}), |
| "explicit_layer_2.json"); |
| |
| Functions::four::physical_device::add_implementation_to_layer(unknown_func, layer0); |
| |
| InstWrapper inst{env.vulkan_functions}; |
| inst.create_info.add_layer(explicit_layer_to_enable_1); |
| inst.create_info.add_layer(explicit_layer_unknown_function_implement); |
| inst.CheckCreate(); |
| |
| VkPhysicalDevice phys_dev = inst.GetPhysDev(); |
| |
| unknown_func.check<Functions::four::physical_device>(env.vulkan_functions, inst.inst, phys_dev); |
| } |
