Merge "Disable device groups" into main
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
