Disable device groups
... by silo'ing each physical device in its own device group.
This unblocks dEQP VK testing until the mesa layer has codegen
to fully translate structs in pNext chains.
Bug: b/333133323
Test: GfxstreamEnd2EndTests
Test: dEQP-VK.api.object_management.single.device_group
Change-Id: I115901009a0de647717414f10bc3cf94551cd09d
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cereal/decoder.py b/codegen/vulkan/vulkan-docs-next/scripts/cereal/decoder.py
index b8d0ca8..640ac78 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cereal/decoder.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cereal/decoder.py
@@ -789,6 +789,10 @@
"vkCmdCopyBufferToImage2KHR" : emit_global_state_wrapped_decoding_with_context,
"vkCmdCopyImage2KHR" : emit_global_state_wrapped_decoding,
"vkCmdCopyImageToBuffer2KHR" : emit_global_state_wrapped_decoding,
+
+ # VK_KHR_device_group_creation / VK_VERSION_1_1
+ "vkEnumeratePhysicalDeviceGroups" : emit_global_state_wrapped_decoding,
+ "vkEnumeratePhysicalDeviceGroupsKHR" : emit_global_state_wrapped_decoding,
}
class VulkanDecoder(VulkanWrapperGenerator):
diff --git a/common/end2end/GfxstreamEnd2EndVkTests.cpp b/common/end2end/GfxstreamEnd2EndVkTests.cpp
index 8140874..3f23ae8 100644
--- a/common/end2end/GfxstreamEnd2EndVkTests.cpp
+++ b/common/end2end/GfxstreamEnd2EndVkTests.cpp
@@ -1801,6 +1801,30 @@
}
}
+TEST_P(GfxstreamEnd2EndVkTest, DeviceCreateWithDeviceGroup) {
+ auto [instance, physicalDevice, device, queue, queueFamilyIndex] =
+ GFXSTREAM_ASSERT(SetUpTypicalVkTestEnvironment());
+
+ const vkhpp::DeviceGroupDeviceCreateInfo deviceGroupDeviceCreateInfo = {
+ .physicalDeviceCount = 1,
+ .pPhysicalDevices = &physicalDevice,
+ };
+
+ const float queuePriority = 1.0f;
+ const vkhpp::DeviceQueueCreateInfo deviceQueueCreateInfo = {
+ .queueFamilyIndex = 0,
+ .queueCount = 1,
+ .pQueuePriorities = &queuePriority,
+ };
+ const vkhpp::DeviceCreateInfo deviceCreateInfo = {
+ .pNext = &deviceGroupDeviceCreateInfo,
+ .pQueueCreateInfos = &deviceQueueCreateInfo,
+ .queueCreateInfoCount = 1,
+ };
+ auto device2 = GFXSTREAM_ASSERT_VKHPP_RV(physicalDevice.createDeviceUnique(deviceCreateInfo));
+ ASSERT_THAT(device2, IsValidHandle());
+}
+
TEST_P(GfxstreamEnd2EndVkTest, AcquireImageAndroidWithFence) {
DoAcquireImageAndroidWithSync(/*withFence=*/true, /*withSemaphore=*/false);
}
diff --git a/guest/vulkan_enc/VkEncoder.cpp b/guest/vulkan_enc/VkEncoder.cpp
index 1516e74..0e41d65 100644
--- a/guest/vulkan_enc/VkEncoder.cpp
+++ b/guest/vulkan_enc/VkEncoder.cpp
@@ -47,6 +47,7 @@
#include "VulkanStreamGuest.h"
#include "aemu/base/AlignedBuf.h"
#include "aemu/base/BumpPool.h"
+#include "aemu/base/synchronization/AndroidLock.h"
#include "gfxstream/guest/IOStream.h"
#include "goldfish_vk_counting_guest.h"
#include "goldfish_vk_deepcopy_guest.h"
diff --git a/host/vulkan/VkDecoder.cpp b/host/vulkan/VkDecoder.cpp
index 66d6500..5942c91 100644
--- a/host/vulkan/VkDecoder.cpp
+++ b/host/vulkan/VkDecoder.cpp
@@ -9089,14 +9089,11 @@
VkInstance instance;
uint32_t* pPhysicalDeviceGroupCount;
VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties;
- // Begin non wrapped dispatchable handle unboxing for instance;
+ // Begin global wrapped dispatchable handle unboxing for instance;
uint64_t cgen_var_0;
memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
*readStreamPtrPtr += 1 * 8;
*(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
- auto unboxed_instance = unbox_VkInstance(instance);
- auto vk = dispatch_VkInstance(instance);
- // End manual dispatchable handle unboxing for instance;
// Begin manual dispatchable handle unboxing for pPhysicalDeviceGroupCount;
vkReadStream->unsetHandleMapping();
// WARNING PTR CHECK
@@ -9147,8 +9144,9 @@
}
VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
vkEnumeratePhysicalDeviceGroups_VkResult_return =
- vk->vkEnumeratePhysicalDeviceGroups(unboxed_instance, pPhysicalDeviceGroupCount,
- pPhysicalDeviceGroupProperties);
+ m_state->on_vkEnumeratePhysicalDeviceGroups(&m_pool, instance,
+ pPhysicalDeviceGroupCount,
+ pPhysicalDeviceGroupProperties);
if ((vkEnumeratePhysicalDeviceGroups_VkResult_return) == VK_ERROR_DEVICE_LOST)
m_state->on_DeviceLost();
m_state->on_CheckOutOfMemory(vkEnumeratePhysicalDeviceGroups_VkResult_return,
diff --git a/host/vulkan/VkDecoderGlobalState.cpp b/host/vulkan/VkDecoderGlobalState.cpp
index 361562a..93e5e8f 100644
--- a/host/vulkan/VkDecoderGlobalState.cpp
+++ b/host/vulkan/VkDecoderGlobalState.cpp
@@ -1096,29 +1096,30 @@
fb->unregisterProcessCleanupCallback(instance);
}
- VkResult on_vkEnumeratePhysicalDevices(android::base::BumpPool* pool, VkInstance boxed_instance,
- uint32_t* physicalDeviceCount,
- VkPhysicalDevice* physicalDevices) {
- auto instance = unbox_VkInstance(boxed_instance);
- auto vk = dispatch_VkInstance(boxed_instance);
-
- uint32_t physicalDevicesSize = 0;
- if (physicalDeviceCount) {
- physicalDevicesSize = *physicalDeviceCount;
- }
-
- uint32_t actualPhysicalDeviceCount;
- auto res = vk->vkEnumeratePhysicalDevices(instance, &actualPhysicalDeviceCount, nullptr);
+ VkResult GetPhysicalDevices(VkInstance instance, VulkanDispatch* vk,
+ std::vector<VkPhysicalDevice>& outPhysicalDevices) {
+ uint32_t physicalDevicesCount = 0;
+ auto res = vk->vkEnumeratePhysicalDevices(instance, &physicalDevicesCount, nullptr);
if (res != VK_SUCCESS) {
return res;
}
- std::vector<VkPhysicalDevice> validPhysicalDevices(actualPhysicalDeviceCount);
- res = vk->vkEnumeratePhysicalDevices(instance, &actualPhysicalDeviceCount,
- validPhysicalDevices.data());
- if (res != VK_SUCCESS) return res;
- std::lock_guard<std::recursive_mutex> lock(mLock);
+ outPhysicalDevices.resize(physicalDevicesCount);
+ res = vk->vkEnumeratePhysicalDevices(instance, &physicalDevicesCount,
+ outPhysicalDevices.data());
+ if (res != VK_SUCCESS) {
+ outPhysicalDevices.clear();
+ return res;
+ }
+
+ outPhysicalDevices.resize(physicalDevicesCount);
+
+ return VK_SUCCESS;
+ }
+
+ void FilterPhysicalDevicesLocked(VkInstance instance, VulkanDispatch* vk,
+ std::vector<VkPhysicalDevice>& toFilterPhysicalDevices) {
if (m_emu->instanceSupportsExternalMemoryCapabilities) {
PFN_vkGetPhysicalDeviceProperties2KHR getPhysdevProps2Func =
vk_util::getVkInstanceProcAddrWithFallback<
@@ -1130,8 +1131,9 @@
instance);
if (getPhysdevProps2Func) {
- validPhysicalDevices.erase(
- std::remove_if(validPhysicalDevices.begin(), validPhysicalDevices.end(),
+ // Remove those devices whose UUIDs don't match the one in VkCommonOperations.
+ toFilterPhysicalDevices.erase(
+ std::remove_if(toFilterPhysicalDevices.begin(), toFilterPhysicalDevices.end(),
[getPhysdevProps2Func, this](VkPhysicalDevice physicalDevice) {
// We can get the device UUID.
VkPhysicalDeviceIDPropertiesKHR idProps = {
@@ -1144,54 +1146,65 @@
};
getPhysdevProps2Func(physicalDevice, &propsWithId);
- // Remove those devices whose UUIDs don't match the one
- // in VkCommonOperations.
return memcmp(m_emu->deviceInfo.idProps.deviceUUID,
idProps.deviceUUID, VK_UUID_SIZE) != 0;
}),
- validPhysicalDevices.end());
+ toFilterPhysicalDevices.end());
} else {
- fprintf(stderr,
- "%s: warning: failed to "
- "vkGetPhysicalDeviceProperties2KHR\n",
- __func__);
+ ERR("Failed to vkGetPhysicalDeviceProperties2KHR().");
}
} else {
// If we don't support ID properties then just advertise only the
// first physical device.
- fprintf(stderr,
- "%s: device id properties not supported, using first "
- "physical device\n",
- __func__);
+ WARN("Device ID not available, returning first physical device.");
}
- if (!validPhysicalDevices.empty()) {
- validPhysicalDevices.erase(std::next(validPhysicalDevices.begin()),
- validPhysicalDevices.end());
+ if (!toFilterPhysicalDevices.empty()) {
+ toFilterPhysicalDevices.erase(std::next(toFilterPhysicalDevices.begin()),
+ toFilterPhysicalDevices.end());
+ }
+ }
+
+ VkResult on_vkEnumeratePhysicalDevices(android::base::BumpPool* pool, VkInstance boxed_instance,
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalDevice* pPhysicalDevices) {
+ auto instance = unbox_VkInstance(boxed_instance);
+ auto vk = dispatch_VkInstance(boxed_instance);
+
+ std::vector<VkPhysicalDevice> physicalDevices;
+ auto res = GetPhysicalDevices(instance, vk, physicalDevices);
+ if (res != VK_SUCCESS) {
+ return res;
}
- if (physicalDeviceCount) {
- *physicalDeviceCount = validPhysicalDevices.size();
+ std::lock_guard<std::recursive_mutex> lock(mLock);
+
+ FilterPhysicalDevicesLocked(instance, vk, physicalDevices);
+
+ const uint32_t requestedCount = pPhysicalDeviceCount ? *pPhysicalDeviceCount : 0;
+ const uint32_t availableCount = static_cast<uint32_t>(physicalDevices.size());
+
+ if (pPhysicalDeviceCount) {
+ *pPhysicalDeviceCount = availableCount;
}
- if (physicalDeviceCount && physicalDevices) {
+ if (pPhysicalDeviceCount && pPhysicalDevices) {
// Box them up
- for (uint32_t i = 0; i < std::min(*physicalDeviceCount, physicalDevicesSize); ++i) {
- mPhysicalDeviceToInstance[validPhysicalDevices[i]] = instance;
+ for (uint32_t i = 0; i < std::min(requestedCount, availableCount); ++i) {
+ mPhysicalDeviceToInstance[physicalDevices[i]] = instance;
- auto& physdevInfo = mPhysdevInfo[validPhysicalDevices[i]];
+ auto& physdevInfo = mPhysdevInfo[physicalDevices[i]];
physdevInfo.instance = instance;
- physdevInfo.boxed = new_boxed_VkPhysicalDevice(validPhysicalDevices[i], vk,
+ physdevInfo.boxed = new_boxed_VkPhysicalDevice(physicalDevices[i], vk,
false /* does not own dispatch */);
- vk->vkGetPhysicalDeviceProperties(validPhysicalDevices[i], &physdevInfo.props);
+ vk->vkGetPhysicalDeviceProperties(physicalDevices[i], &physdevInfo.props);
if (physdevInfo.props.apiVersion > kMaxSafeVersion) {
physdevInfo.props.apiVersion = kMaxSafeVersion;
}
VkPhysicalDeviceMemoryProperties hostMemoryProperties;
- vk->vkGetPhysicalDeviceMemoryProperties(validPhysicalDevices[i],
- &hostMemoryProperties);
+ vk->vkGetPhysicalDeviceMemoryProperties(physicalDevices[i], &hostMemoryProperties);
physdevInfo.memoryPropertiesHelper =
std::make_unique<EmulatedPhysicalDeviceMemoryProperties>(
@@ -1201,18 +1214,18 @@
uint32_t queueFamilyPropCount = 0;
- vk->vkGetPhysicalDeviceQueueFamilyProperties(validPhysicalDevices[i],
+ vk->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevices[i],
&queueFamilyPropCount, nullptr);
physdevInfo.queueFamilyProperties.resize((size_t)queueFamilyPropCount);
vk->vkGetPhysicalDeviceQueueFamilyProperties(
- validPhysicalDevices[i], &queueFamilyPropCount,
+ physicalDevices[i], &queueFamilyPropCount,
physdevInfo.queueFamilyProperties.data());
- physicalDevices[i] = (VkPhysicalDevice)physdevInfo.boxed;
+ pPhysicalDevices[i] = (VkPhysicalDevice)physdevInfo.boxed;
}
- if (physicalDevicesSize < *physicalDeviceCount) {
+ if (requestedCount < availableCount) {
res = VK_INCOMPLETE;
}
}
@@ -1759,6 +1772,9 @@
// Filter device memory report as callbacks can not be passed between guest and host.
vk_struct_chain_filter<VkDeviceDeviceMemoryReportCreateInfoEXT>(&createInfoFiltered);
+ // Filter device groups as they are effectively disabled.
+ vk_struct_chain_filter<VkDeviceGroupDeviceCreateInfo>(&createInfoFiltered);
+
createInfoFiltered.enabledExtensionCount = (uint32_t)updatedDeviceExtensions.size();
createInfoFiltered.ppEnabledExtensionNames = updatedDeviceExtensions.data();
@@ -6699,6 +6715,51 @@
return;
}
+ VkResult on_vkEnumeratePhysicalDeviceGroups(
+ android::base::BumpPool* pool, VkInstance boxed_instance,
+ uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
+ auto instance = unbox_VkInstance(boxed_instance);
+ auto vk = dispatch_VkInstance(boxed_instance);
+
+ std::vector<VkPhysicalDevice> physicalDevices;
+ auto res = GetPhysicalDevices(instance, vk, physicalDevices);
+ if (res != VK_SUCCESS) {
+ return res;
+ }
+
+ {
+ std::lock_guard<std::recursive_mutex> lock(mLock);
+ FilterPhysicalDevicesLocked(instance, vk, physicalDevices);
+ }
+
+ const uint32_t requestedCount = pPhysicalDeviceGroupCount ? *pPhysicalDeviceGroupCount : 0;
+ const uint32_t availableCount = static_cast<uint32_t>(physicalDevices.size());
+
+ if (pPhysicalDeviceGroupCount) {
+ *pPhysicalDeviceGroupCount = availableCount;
+ }
+ if (pPhysicalDeviceGroupCount && pPhysicalDeviceGroupProperties) {
+ for (uint32_t i = 0; i < std::min(requestedCount, availableCount); ++i) {
+ pPhysicalDeviceGroupProperties[i] = VkPhysicalDeviceGroupProperties{
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
+ .pNext = nullptr,
+ .physicalDeviceCount = 1,
+ .physicalDevices =
+ {
+ unboxed_to_boxed_VkPhysicalDevice(physicalDevices[i]),
+ },
+ .subsetAllocation = VK_FALSE,
+ };
+ }
+ if (requestedCount < availableCount) {
+ return VK_INCOMPLETE;
+ }
+ }
+
+ return VK_SUCCESS;
+ }
+
void on_DeviceLost() {
{
std::lock_guard<std::recursive_mutex> lock(mLock);
@@ -9305,6 +9366,20 @@
mImpl->on_vkDestroySamplerYcbcrConversion(pool, device, ycbcrConversion, pAllocator);
}
+VkResult VkDecoderGlobalState::on_vkEnumeratePhysicalDeviceGroups(
+ android::base::BumpPool* pool, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
+ return mImpl->on_vkEnumeratePhysicalDeviceGroups(pool, instance, pPhysicalDeviceGroupCount,
+ pPhysicalDeviceGroupProperties);
+}
+
+VkResult VkDecoderGlobalState::on_vkEnumeratePhysicalDeviceGroupsKHR(
+ android::base::BumpPool* pool, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
+ return mImpl->on_vkEnumeratePhysicalDeviceGroups(pool, instance, pPhysicalDeviceGroupCount,
+ pPhysicalDeviceGroupProperties);
+}
+
void VkDecoderGlobalState::on_DeviceLost() { mImpl->on_DeviceLost(); }
void VkDecoderGlobalState::on_CheckOutOfMemory(VkResult result, uint32_t opCode,
diff --git a/host/vulkan/VkDecoderGlobalState.h b/host/vulkan/VkDecoderGlobalState.h
index 7d4e4ab..dcb24c5 100644
--- a/host/vulkan/VkDecoderGlobalState.h
+++ b/host/vulkan/VkDecoderGlobalState.h
@@ -705,6 +705,13 @@
VkSamplerYcbcrConversion ycbcrConversion,
const VkAllocationCallbacks* pAllocator);
+ VkResult on_vkEnumeratePhysicalDeviceGroups(
+ android::base::BumpPool* pool, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+ VkResult on_vkEnumeratePhysicalDeviceGroupsKHR(
+ android::base::BumpPool* pool, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+
void on_DeviceLost();
void on_CheckOutOfMemory(VkResult result, uint32_t opCode, const VkDecoderContext& context,
diff --git a/host/vulkan/cereal/common/vk_struct_id.h b/host/vulkan/cereal/common/vk_struct_id.h
index e4abeb2..c526dc1 100644
--- a/host/vulkan/cereal/common/vk_struct_id.h
+++ b/host/vulkan/cereal/common/vk_struct_id.h
@@ -124,5 +124,7 @@
REGISTER_VK_STRUCT_ID(VkPhysicalDeviceDiagnosticsConfigFeaturesNV,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV);
+REGISTER_VK_STRUCT_ID(VkDeviceGroupDeviceCreateInfo,
+ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO);
#undef REGISTER_VK_STRUCT_ID
