Snap for 12169000 from c1fd24f4eb46f163155837c527bfb752d67e00ba to emu-35-2-release
Change-Id: Iebf0b3cd56b7e6a6d7c058281b22860cb5840adf
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
index af73410..a1abc23 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
@@ -45,6 +45,7 @@
"VK_EXT_debug_report",
"VK_EXT_validation_features",
# Device extensions
+ "VK_EXT_external_memory_host",
"VK_KHR_storage_buffer_storage_class",
"VK_KHR_vulkan_memory_model",
"VK_KHR_buffer_device_address",
@@ -155,6 +156,7 @@
# we wish run wrappers when the module requires it. For example, `VK_GOOGLE_gfxstream`
# shouldn't generate a function table entry since it's an internal interface.
SUPPORTED_MODULES = {
+ "VK_EXT_external_memory_host": HOST_MODULES,
"VK_EXT_debug_utils": HOST_MODULES,
"VK_EXT_debug_report": HOST_MODULES,
"VK_EXT_validation_features": HOST_MODULES,
diff --git a/common/end2end/GfxstreamEnd2EndVkSnapshotPipelineTests.cpp b/common/end2end/GfxstreamEnd2EndVkSnapshotPipelineTests.cpp
index f7a612c..7bd14a9 100644
--- a/common/end2end/GfxstreamEnd2EndVkSnapshotPipelineTests.cpp
+++ b/common/end2end/GfxstreamEnd2EndVkSnapshotPipelineTests.cpp
@@ -526,6 +526,7 @@
commandBuffer->reset();
SnapshotSaveAndLoad();
+ ASSERT_THAT(device->getFenceStatus(*fence), IsVkSuccess());
// TODO(b/332763326): fix validation layer complain about unreleased pipeline layout
// Try to draw something.
diff --git a/common/end2end/GfxstreamEnd2EndVkTests.cpp b/common/end2end/GfxstreamEnd2EndVkTests.cpp
index 3f23ae8..7ffe1ba 100644
--- a/common/end2end/GfxstreamEnd2EndVkTests.cpp
+++ b/common/end2end/GfxstreamEnd2EndVkTests.cpp
@@ -1865,35 +1865,38 @@
}
TEST_P(GfxstreamEnd2EndVkTest, DescriptorUpdateTemplateWithWrapping) {
- auto [instance, physicalDevice, device, queue, queueFamilyIndex] =
- GFXSTREAM_ASSERT(SetUpTypicalVkTestEnvironment());
+ auto vk = GFXSTREAM_ASSERT(SetUpTypicalVkTestEnvironment());
+ auto& [instance, physicalDevice, device, queue, queueFamilyIndex] = vk;
- const vkhpp::BufferCreateInfo bufferCreateInfo = {
- .size = 1024,
- .usage = vkhpp::BufferUsageFlagBits::eUniformBuffer,
- };
- auto buffer = GFXSTREAM_ASSERT_VKHPP_RV(device->createBufferUnique(bufferCreateInfo));
+ const VkDeviceSize kBufferSize = 1024;
+ auto buffer = GFXSTREAM_ASSERT(CreateBuffer(
+ vk, kBufferSize,
+ vkhpp::BufferUsageFlagBits::eTransferDst |
+ vkhpp::BufferUsageFlagBits::eTransferSrc |
+ vkhpp::BufferUsageFlagBits::eUniformBuffer,
+ vkhpp::MemoryPropertyFlagBits::eHostVisible |
+ vkhpp::MemoryPropertyFlagBits::eHostCoherent));
const std::vector<VkDescriptorBufferInfo> descriptorInfo = {
VkDescriptorBufferInfo{
- .buffer = *buffer,
+ .buffer = *buffer.buffer,
.offset = 0,
- .range = 1024,
+ .range = kBufferSize,
},
VkDescriptorBufferInfo{
- .buffer = *buffer,
+ .buffer = *buffer.buffer,
.offset = 0,
- .range = 1024,
+ .range = kBufferSize,
},
VkDescriptorBufferInfo{
- .buffer = *buffer,
+ .buffer = *buffer.buffer,
.offset = 0,
- .range = 1024,
+ .range = kBufferSize,
},
VkDescriptorBufferInfo{
- .buffer = *buffer,
+ .buffer = *buffer.buffer,
.offset = 0,
- .range = 1024,
+ .range = kBufferSize,
},
};
@@ -1984,7 +1987,18 @@
device->createDescriptorUpdateTemplateUnique(descriptorUpdateTemplateCreateInfo));
device->updateDescriptorSetWithTemplate(*descriptorSet, *descriptorUpdateTemplate,
- descriptorInfo.data());
+ (const void*)descriptorInfo.data());
+
+ // Gfxstream optimizes descriptor set updates by batching updates until there is an
+ // actual use in a command buffer. Try to force that flush by binding the descriptor
+ // set here:
+ GFXSTREAM_ASSERT(DoCommandsImmediate(vk,
+ [&](vkhpp::UniqueCommandBuffer& cmd) {
+ cmd->bindDescriptorSets(vkhpp::PipelineBindPoint::eGraphics, *pipelineLayout,
+ /*firstSet=*/0, {*descriptorSet},
+ /*dynamicOffsets=*/{});
+ return Ok{};
+ }));
}
TEST_P(GfxstreamEnd2EndVkTest, MultiThreadedVkMapMemory) {
diff --git a/guest/platform/kumquat/VirtGpuKumquat.h b/guest/platform/kumquat/VirtGpuKumquat.h
index d940ffd..d22f210 100644
--- a/guest/platform/kumquat/VirtGpuKumquat.h
+++ b/guest/platform/kumquat/VirtGpuKumquat.h
@@ -17,7 +17,13 @@
#pragma once
#include "VirtGpu.h"
+
+// Blueprint and Meson builds place things differently
+#if defined(ANDROID)
+#include "virtgpu_kumquat_ffi.h"
+#else
#include "virtgpu_kumquat/virtgpu_kumquat_ffi.h"
+#endif
class VirtGpuKumquatResource : public std::enable_shared_from_this<VirtGpuKumquatResource>,
public VirtGpuResource {
diff --git a/guest/platform/kumquat/VirtGpuKumquatBlob.cpp b/guest/platform/kumquat/VirtGpuKumquatBlob.cpp
index cd0e3e0..991d53d 100644
--- a/guest/platform/kumquat/VirtGpuKumquatBlob.cpp
+++ b/guest/platform/kumquat/VirtGpuKumquatBlob.cpp
@@ -23,7 +23,6 @@
#include <cstring>
#include "VirtGpuKumquat.h"
-#include "virtgpu_kumquat/virtgpu_kumquat_ffi.h"
VirtGpuKumquatResource::VirtGpuKumquatResource(struct virtgpu_kumquat* virtGpu, uint32_t blobHandle,
uint32_t resourceHandle, uint64_t size)
@@ -53,7 +52,8 @@
ret = virtgpu_kumquat_resource_map(mVirtGpu, &map);
if (ret < 0) {
- ALOGE("Mapping failed with %s", strerror(errno));
+ ALOGE("Mapping failed with %s for resource %u blob %u", strerror(errno), mResourceHandle,
+ mBlobHandle);
return nullptr;
}
diff --git a/guest/platform/kumquat/VirtGpuKumquatDevice.cpp b/guest/platform/kumquat/VirtGpuKumquatDevice.cpp
index 6101cc1..774c9dc 100644
--- a/guest/platform/kumquat/VirtGpuKumquatDevice.cpp
+++ b/guest/platform/kumquat/VirtGpuKumquatDevice.cpp
@@ -26,15 +26,13 @@
#include "VirtGpuKumquat.h"
#include "virtgpu_gfxstream_protocol.h"
-#include "virtgpu_kumquat/virtgpu_kumquat_ffi.h"
#define PARAM(x) \
(struct VirtGpuParam) { x, #x, 0 }
static inline uint32_t align_up(uint32_t n, uint32_t a) { return ((n + a - 1) / a) * a; }
-VirtGpuKumquatDevice::VirtGpuKumquatDevice(enum VirtGpuCapset capset, int fd)
- : VirtGpuDevice(capset) {
+VirtGpuKumquatDevice::VirtGpuKumquatDevice(enum VirtGpuCapset capset, int) : VirtGpuDevice(capset) {
struct VirtGpuParam params[] = {
PARAM(VIRTGPU_KUMQUAT_PARAM_3D_FEATURES),
PARAM(VIRTGPU_KUMQUAT_PARAM_CAPSET_QUERY_FIX),
@@ -60,7 +58,7 @@
processName = getprogname();
#endif
- ret = virtgpu_kumquat_init(&mVirtGpu);
+ ret = virtgpu_kumquat_init(&mVirtGpu, nullptr);
if (ret) {
ALOGV("Failed to init virtgpu kumquat");
return;
diff --git a/guest/platform/kumquat/VirtGpuKumquatSync.cpp b/guest/platform/kumquat/VirtGpuKumquatSync.cpp
index d152bff..47884fc 100644
--- a/guest/platform/kumquat/VirtGpuKumquatSync.cpp
+++ b/guest/platform/kumquat/VirtGpuKumquatSync.cpp
@@ -23,9 +23,24 @@
VirtGpuKumquatSyncHelper::VirtGpuKumquatSyncHelper() {}
int VirtGpuKumquatSyncHelper::wait(int syncFd, int timeoutMilliseconds) {
- (void)syncFd;
(void)timeoutMilliseconds;
- return -1;
+ // So far, syncfds are EventFd in the Kumquat layer. This may change
+ uint64_t count = 1;
+ ssize_t bytes_read = read(syncFd, &count, sizeof(count));
+
+ if (bytes_read < 0) {
+ return bytes_read;
+ }
+
+ // A successful read decrements the eventfd's counter to zero. In
+ // case the eventfd is waited on again, or a dup is waited on, we
+ // have to write to the eventfd for the next read.
+ ssize_t bytes_written = write(syncFd, &count, sizeof(count));
+ if (bytes_written < 0) {
+ return bytes_written;
+ }
+
+ return 0;
}
int VirtGpuKumquatSyncHelper::dup(int syncFd) { return ::dup(syncFd); }
diff --git a/guest/vulkan_enc/ResourceTracker.cpp b/guest/vulkan_enc/ResourceTracker.cpp
index fe19b25..4aca2fe 100644
--- a/guest/vulkan_enc/ResourceTracker.cpp
+++ b/guest/vulkan_enc/ResourceTracker.cpp
@@ -6602,7 +6602,9 @@
memcpy(((uint8_t*)bufferInfos) + currBufferInfoOffset, user,
sizeof(VkDescriptorBufferInfo));
-#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+
+ // TODO(b/355497683): move this into gfxstream_vk_UpdateDescriptorSetWithTemplate().
+#if defined(__linux__) || defined(VK_USE_PLATFORM_ANDROID_KHR)
// Convert mesa to internal for objects in the user buffer
VkDescriptorBufferInfo* internalBufferInfo =
(VkDescriptorBufferInfo*)(((uint8_t*)bufferInfos) + currBufferInfoOffset);
diff --git a/host/ColorBuffer.cpp b/host/ColorBuffer.cpp
index 92414e7..2b68fbf 100644
--- a/host/ColorBuffer.cpp
+++ b/host/ColorBuffer.cpp
@@ -226,7 +226,6 @@
if (mColorBufferGl) {
mColorBufferGl->subUpdateFromFrameworkFormat(x, y, width, height, frameworkFormat,
pixelsFormat, pixelsType, pixels, metadata);
- return true;
}
#endif
@@ -234,8 +233,7 @@
return mColorBufferVk->updateFromBytes(x, y, width, height, pixels);
}
- GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER)) << "No ColorBuffer impl?";
- return false;
+ return true;
}
bool ColorBuffer::updateFromBytes(int x, int y, int width, int height, GLenum pixelsFormat,
diff --git a/host/vulkan/VkCommonOperations.cpp b/host/vulkan/VkCommonOperations.cpp
index 21b1ff7..529dd1b 100644
--- a/host/vulkan/VkCommonOperations.cpp
+++ b/host/vulkan/VkCommonOperations.cpp
@@ -826,16 +826,20 @@
deviceInfos[i].supportsDriverProperties =
extensionsSupported(deviceExts, {VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME}) ||
(deviceInfos[i].physdevProps.apiVersion >= VK_API_VERSION_1_2);
+ deviceInfos[i].supportsExternalMemoryHostProps = extensionsSupported(deviceExts, {VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME});
if (!sVkEmulation->getPhysicalDeviceProperties2Func) {
ERR("Warning: device claims to support ID properties "
"but vkGetPhysicalDeviceProperties2 could not be found");
}
}
-
if (sVkEmulation->getPhysicalDeviceProperties2Func) {
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT externalMemoryHostProps = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
+ };
VkPhysicalDeviceProperties2 deviceProps = {
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
+
};
VkPhysicalDeviceIDProperties idProps = {
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR,
@@ -854,9 +858,12 @@
vk_append_struct(&devicePropsChain, &driverProps);
}
+ if(deviceInfos[i].supportsExternalMemoryHostProps) {
+ vk_append_struct(&devicePropsChain, &externalMemoryHostProps);
+ }
sVkEmulation->getPhysicalDeviceProperties2Func(physdevs[i], &deviceProps);
-
deviceInfos[i].idProps = vk_make_orphan_copy(idProps);
+ deviceInfos[i].externalMemoryHostProps = vk_make_orphan_copy(externalMemoryHostProps);
std::stringstream driverVendorBuilder;
driverVendorBuilder << "Vendor " << std::hex << std::setfill('0') << std::showbase
@@ -990,7 +997,6 @@
// in use cases that make sense, if/when they come up.
std::vector<uint32_t> deviceScores(physdevCount, 0);
-
for (uint32_t i = 0; i < physdevCount; ++i) {
uint32_t deviceScore = 0;
if (deviceInfos[i].hasGraphicsQueueFamily) deviceScore += 10000;
diff --git a/host/vulkan/VkCommonOperations.h b/host/vulkan/VkCommonOperations.h
index 43ebc91..a896a2a 100644
--- a/host/vulkan/VkCommonOperations.h
+++ b/host/vulkan/VkCommonOperations.h
@@ -206,6 +206,7 @@
bool supportsDmaBuf = false;
bool supportsIdProperties = false;
bool supportsDriverProperties = false;
+ bool supportsExternalMemoryHostProps = false;
bool hasSamplerYcbcrConversionExtension = false;
bool supportsSamplerYcbcrConversion = false;
bool glInteropSupported = false;
@@ -220,6 +221,7 @@
VkPhysicalDeviceProperties physdevProps;
VkPhysicalDeviceMemoryProperties memProps;
VkPhysicalDeviceIDPropertiesKHR idProps;
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT externalMemoryHostProps;
std::string driverVendor;
std::string driverVersion;
diff --git a/host/vulkan/VkDecoder.cpp b/host/vulkan/VkDecoder.cpp
index 5942c91..99974a9 100644
--- a/host/vulkan/VkDecoder.cpp
+++ b/host/vulkan/VkDecoder.cpp
@@ -18970,6 +18970,82 @@
break;
}
#endif
+#ifdef VK_EXT_external_memory_host
+ case OP_vkGetMemoryHostPointerPropertiesEXT: {
+ android::base::beginTrace("vkGetMemoryHostPointerPropertiesEXT decode");
+ VkDevice device;
+ VkExternalMemoryHandleTypeFlagBits handleType;
+ const void* pHostPointer;
+ VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties;
+ // Begin non wrapped dispatchable handle unboxing for device;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+ auto unboxed_device = unbox_VkDevice(device);
+ auto vk = dispatch_VkDevice(device);
+ // End manual dispatchable handle unboxing for device;
+ memcpy((VkExternalMemoryHandleTypeFlagBits*)&handleType, *readStreamPtrPtr,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
+ *readStreamPtrPtr += sizeof(VkExternalMemoryHandleTypeFlagBits);
+ vkReadStream->alloc((void**)&pHostPointer, sizeof(const uint8_t));
+ memcpy((void*)pHostPointer, *readStreamPtrPtr, sizeof(const uint8_t));
+ *readStreamPtrPtr += sizeof(const uint8_t);
+ // Begin manual dispatchable handle unboxing for pMemoryHostPointerProperties;
+ vkReadStream->unsetHandleMapping();
+ vkReadStream->alloc((void**)&pMemoryHostPointerProperties,
+ sizeof(VkMemoryHostPointerPropertiesEXT));
+ reservedunmarshal_VkMemoryHostPointerPropertiesEXT(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties),
+ readStreamPtrPtr);
+ if (pMemoryHostPointerProperties) {
+ transform_tohost_VkMemoryHostPointerPropertiesEXT(
+ m_state, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+ }
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkGetMemoryHostPointerPropertiesEXT 0x%llx 0x%llx "
+ "0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)device, (unsigned long long)handleType,
+ (unsigned long long)pHostPointer,
+ (unsigned long long)pMemoryHostPointerProperties);
+ }
+ VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+ vkGetMemoryHostPointerPropertiesEXT_VkResult_return =
+ vk->vkGetMemoryHostPointerPropertiesEXT(
+ unboxed_device, handleType, pHostPointer, pMemoryHostPointerProperties);
+ if ((vkGetMemoryHostPointerPropertiesEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+ m_state->on_DeviceLost();
+ m_state->on_CheckOutOfMemory(vkGetMemoryHostPointerPropertiesEXT_VkResult_return,
+ opcode, context);
+ vkStream->unsetHandleMapping();
+ if (pMemoryHostPointerProperties) {
+ transform_fromhost_VkMemoryHostPointerPropertiesEXT(
+ m_state, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+ }
+ marshal_VkMemoryHostPointerPropertiesEXT(
+ vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties));
+ vkStream->write(&vkGetMemoryHostPointerPropertiesEXT_VkResult_return,
+ sizeof(VkResult));
+ vkStream->commitWrite();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkGetMemoryHostPointerPropertiesEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+ vkGetMemoryHostPointerPropertiesEXT_VkResult_return, device, handleType,
+ pHostPointer, pMemoryHostPointerProperties);
+ }
+ vkReadStream->clearPool();
+ if (m_queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+#endif
#ifdef VK_EXT_tooling_info
case OP_vkGetPhysicalDeviceToolPropertiesEXT: {
android::base::beginTrace("vkGetPhysicalDeviceToolPropertiesEXT decode");
diff --git a/host/vulkan/VkDecoderGlobalState.cpp b/host/vulkan/VkDecoderGlobalState.cpp
index 93e5e8f..4ed1bdd 100644
--- a/host/vulkan/VkDecoderGlobalState.cpp
+++ b/host/vulkan/VkDecoderGlobalState.cpp
@@ -194,6 +194,7 @@
static uint32_t kTemporaryContextIdForSnapshotLoading = 1;
static std::unordered_set<std::string> kSnapshotAppAllowList = {"Chromium"};
+static std::unordered_set<std::string> kSnapshotEngineAllowList = {"ANGLE"};
#define DEFINE_BOXED_HANDLE_TYPE_TAG(type) Tag_##type,
@@ -676,6 +677,22 @@
}
}
}
+
+ // Fences
+ std::vector<VkFence> unsignaledFencesBoxed;
+ for (const auto& fence : mFenceInfo) {
+ if (!fence.second.boxed) {
+ continue;
+ }
+ const auto& device = fence.second.device;
+ const auto& deviceInfo = android::base::find(mDeviceInfo, device);
+ VulkanDispatch* dvk = dispatch_VkDevice(deviceInfo->boxed);
+ if (VK_NOT_READY == dvk->vkGetFenceStatus(device, fence.first)) {
+ unsignaledFencesBoxed.push_back(fence.second.boxed);
+ }
+ }
+ stream->putBe64(unsignaledFencesBoxed.size());
+ stream->write(unsignaledFencesBoxed.data(), unsignaledFencesBoxed.size() * sizeof(VkFence));
mSnapshotState = SnapshotState::Normal;
}
@@ -857,7 +874,22 @@
poolIds.data(), whichPool.data(), pendingAlloc.data(), writeStartingIndices.data(),
writeDescriptorSets.size(), writeDescriptorSets.data());
}
-
+ // Fences
+ uint64_t fenceCount = stream->getBe64();
+ std::vector<VkFence> unsignaledFencesBoxed(fenceCount);
+ stream->read(unsignaledFencesBoxed.data(), fenceCount * sizeof(VkFence));
+ for (VkFence boxedFence : unsignaledFencesBoxed) {
+ VkFence unboxedFence = unbox_VkFence(boxedFence);
+ auto it = mFenceInfo.find(unboxedFence);
+ if (it == mFenceInfo.end()) {
+ GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+ << "Snapshot load failure: unrecognized VkFence";
+ }
+ const auto& device = it->second.device;
+ const auto& deviceInfo = android::base::find(mDeviceInfo, device);
+ VulkanDispatch* dvk = dispatch_VkDevice(deviceInfo->boxed);
+ dvk->vkResetFences(device, 1, &unboxedFence);
+ }
#ifdef GFXSTREAM_ENABLE_HOST_VK_SNAPSHOT
if (!mInstanceInfo.empty()) {
get_emugl_vm_operations().setStatSnapshotUseVulkan();
@@ -1009,9 +1041,9 @@
#ifdef GFXSTREAM_ENABLE_HOST_VK_SNAPSHOT
// TODO: bug 129484301
- if (!m_emu->features.VulkanSnapshots.enabled
- || kSnapshotAppAllowList.find(info.applicationName)
- == kSnapshotAppAllowList.end()) {
+ if (!m_emu->features.VulkanSnapshots.enabled ||
+ (kSnapshotAppAllowList.find(info.applicationName) == kSnapshotAppAllowList.end() &&
+ kSnapshotEngineAllowList.find(info.engineName) == kSnapshotEngineAllowList.end())) {
get_emugl_vm_operations().setSkipSnapshotSave(true);
get_emugl_vm_operations().setSkipSnapshotSaveReason(SNAPSHOT_SKIP_UNSUPPORTED_VK_APP);
}
@@ -1033,6 +1065,9 @@
if (vkCleanupEnabled()) {
fb->registerProcessCleanupCallback(unbox_VkInstance(boxed), [this, boxed] {
+ if (snapshotsEnabled()) {
+ snapshot()->vkDestroyInstance(nullptr, 0, nullptr, boxed, nullptr);
+ }
vkDestroyInstanceImpl(unbox_VkInstance(boxed), nullptr);
});
}
@@ -1977,6 +2012,9 @@
destroyFenceLocked(device, deviceDispatch, fence, nullptr, false);
}
+ // Should happen before destroying fences
+ deviceInfo->deviceOpTracker->OnDestroyDevice();
+
// Destroy pooled external fences
auto deviceFences = deviceInfo->externalFencePool->popAll();
for (auto fence : deviceFences) {
@@ -1984,8 +2022,6 @@
mFenceInfo.erase(fence);
}
- deviceInfo->deviceOpTracker->OnDestroyDevice();
-
// Run the underlying API call.
m_vk->vkDestroyDevice(device, pAllocator);
@@ -2029,6 +2065,21 @@
pCreateInfo = &localCreateInfo;
}
+ VkExternalMemoryBufferCreateInfo externalCI = {
+ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO};
+ if (m_emu->features.VulkanAllocateHostMemory.enabled) {
+ localCreateInfo = *pCreateInfo;
+ // Hint that we 'may' use host allocation for this buffer. This will only be used for
+ // host visible memory.
+ externalCI.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
+
+ // Insert the new struct to the chain
+ externalCI.pNext = localCreateInfo.pNext;
+ localCreateInfo.pNext = &externalCI;
+
+ pCreateInfo = &localCreateInfo;
+ }
+
VkResult result = vk->vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
if (result == VK_SUCCESS) {
@@ -2678,6 +2729,13 @@
VkResult on_vkCreateFence(android::base::BumpPool* pool, VkDevice boxed_device,
const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+ VkFenceCreateInfo localCreateInfo;
+ if (mSnapshotState == SnapshotState::Loading) {
+ // On snapshot load we create all fences as signaled then reset those that are not.
+ localCreateInfo = *pCreateInfo;
+ pCreateInfo = &localCreateInfo;
+ localCreateInfo.flags |= VK_FENCE_CREATE_SIGNALED_BIT;
+ }
auto device = unbox_VkDevice(boxed_device);
auto vk = dispatch_VkDevice(boxed_device);
@@ -4802,16 +4860,56 @@
VkImportMemoryHostPointerInfoEXT importHostInfoPrivate{};
if (hostVisible && m_emu->features.VulkanAllocateHostMemory.enabled &&
localAllocInfo.pNext == nullptr) {
- VkDeviceSize alignedSize = __ALIGN(localAllocInfo.allocationSize, kPageSizeforBlob);
+ if (!m_emu || !m_emu->deviceInfo.supportsExternalMemoryHostProps) {
+ ERR("VK_EXT_EXTERNAL_MEMORY_HOST is not supported, cannot use "
+ "VulkanAllocateHostMemory");
+ return VK_ERROR_INCOMPATIBLE_DRIVER;
+ }
+ VkDeviceSize alignmentSize = m_emu->deviceInfo.externalMemoryHostProps.minImportedHostPointerAlignment;
+ VkDeviceSize alignedSize = __ALIGN(localAllocInfo.allocationSize, alignmentSize);
localAllocInfo.allocationSize = alignedSize;
privateMemory =
- std::make_shared<PrivateMemory>(kPageSizeforBlob, localAllocInfo.allocationSize);
+ std::make_shared<PrivateMemory>(alignmentSize, localAllocInfo.allocationSize);
mappedPtr = privateMemory->getAddr();
importHostInfoPrivate = {
.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
.pNext = NULL,
.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
.pHostPointer = mappedPtr};
+
+ VkMemoryHostPointerPropertiesEXT memoryHostPointerProperties = {
+ .sType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
+ .pNext = NULL,
+ .memoryTypeBits = 0,
+ };
+
+ vk->vkGetMemoryHostPointerPropertiesEXT(
+ device, VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, mappedPtr,
+ &memoryHostPointerProperties);
+
+ if (memoryHostPointerProperties.memoryTypeBits == 0) {
+ ERR("Cannot find suitable memory type for VulkanAllocateHostMemory");
+ return VK_ERROR_INCOMPATIBLE_DRIVER;
+ }
+
+ if (((1u << localAllocInfo.memoryTypeIndex) & memoryHostPointerProperties.memoryTypeBits) == 0) {
+
+ // TODO Consider assigning the correct memory index earlier, instead of switching right before allocation.
+
+ // Look for the first available supported memory index and assign it.
+ for(uint32_t i =0; i<= 31; ++i) {
+ if ((memoryHostPointerProperties.memoryTypeBits & (1u << i)) == 0) {
+ continue;
+ }
+ localAllocInfo.memoryTypeIndex = i;
+ break;
+ }
+ VERBOSE(
+ "Detected memoryTypeIndex violation on requested host memory import. Switching "
+ "to a supported memory index %d",
+ localAllocInfo.memoryTypeIndex);
+ }
+
vk_append_struct(&structChainIter, &importHostInfoPrivate);
}
@@ -5312,11 +5410,7 @@
if (info->needUnmap) {
uint64_t hva = (uint64_t)(uintptr_t)(info->ptr);
- uint64_t size = (uint64_t)(uintptr_t)(info->size);
-
uint64_t alignedHva = hva & kPageMaskForBlob;
- uint64_t alignedSize =
- kPageSizeforBlob * ((size + kPageSizeforBlob - 1) / kPageSizeforBlob);
if (hva != alignedHva) {
ERR("Mapping non page-size (0x%" PRIx64
@@ -6792,15 +6886,13 @@
}
VkResult waitForFence(VkFence boxed_fence, uint64_t timeout) {
- VkFence fence;
+ VkFence fence = unbox_VkFence(boxed_fence);
VkDevice device;
VulkanDispatch* vk;
StaticLock* fenceLock;
ConditionVariable* cv;
{
std::lock_guard<std::recursive_mutex> lock(mLock);
-
- fence = unbox_VkFence(boxed_fence);
if (fence == VK_NULL_HANDLE || mFenceInfo.find(fence) == mFenceInfo.end()) {
// No fence, could be a semaphore.
// TODO: Async wait for semaphores
@@ -6848,13 +6940,11 @@
}
VkResult getFenceStatus(VkFence boxed_fence) {
+ VkFence fence = unbox_VkFence(boxed_fence);
VkDevice device;
- VkFence fence;
VulkanDispatch* vk;
{
std::lock_guard<std::recursive_mutex> lock(mLock);
-
- fence = unbox_VkFence(boxed_fence);
if (fence == VK_NULL_HANDLE || mFenceInfo.find(fence) == mFenceInfo.end()) {
// No fence, could be a semaphore.
// TODO: Async get status for semaphores
diff --git a/host/vulkan/VkDecoderSnapshot.cpp b/host/vulkan/VkDecoderSnapshot.cpp
index 25a024a..ac10325 100644
--- a/host/vulkan/VkDecoderSnapshot.cpp
+++ b/host/vulkan/VkDecoderSnapshot.cpp
@@ -3231,6 +3231,12 @@
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {}
#endif
+#ifdef VK_EXT_external_memory_host
+ void vkGetMemoryHostPointerPropertiesEXT(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+ const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {}
+#endif
#ifdef VK_EXT_tooling_info
void vkGetPhysicalDeviceToolPropertiesEXT(const uint8_t* snapshotTraceBegin,
size_t snapshotTraceBytes,
@@ -6797,6 +6803,16 @@
messageSeverity, messageTypes, pCallbackData);
}
#endif
+#ifdef VK_EXT_external_memory_host
+void VkDecoderSnapshot::vkGetMemoryHostPointerPropertiesEXT(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+ const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {
+ mImpl->vkGetMemoryHostPointerPropertiesEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+ input_result, device, handleType, pHostPointer,
+ pMemoryHostPointerProperties);
+}
+#endif
#ifdef VK_EXT_tooling_info
void VkDecoderSnapshot::vkGetPhysicalDeviceToolPropertiesEXT(
const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
diff --git a/host/vulkan/VkDecoderSnapshot.h b/host/vulkan/VkDecoderSnapshot.h
index 466adc6..0072da1 100644
--- a/host/vulkan/VkDecoderSnapshot.h
+++ b/host/vulkan/VkDecoderSnapshot.h
@@ -1321,6 +1321,12 @@
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
#endif
+#ifdef VK_EXT_external_memory_host
+ void vkGetMemoryHostPointerPropertiesEXT(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType,
+ const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
+#endif
#ifdef VK_EXT_tooling_info
void vkGetPhysicalDeviceToolPropertiesEXT(const uint8_t* snapshotTraceBegin,
size_t snapshotTraceBytes,
diff --git a/host/vulkan/VulkanDispatch.cpp b/host/vulkan/VulkanDispatch.cpp
index ea51459..9ca5211 100644
--- a/host/vulkan/VulkanDispatch.cpp
+++ b/host/vulkan/VulkanDispatch.cpp
@@ -94,7 +94,7 @@
// 4: Log errors, warnings, infos and debug messages.
const bool verboseLogs =
(android::base::getEnvironmentVariable("ANDROID_EMUGL_VERBOSE") == "1");
- const char* logLevelValue = verboseLogs ? "4" : "2";
+ const char* logLevelValue = verboseLogs ? "4" : "1";
android::base::setEnvironmentVariable("MVK_CONFIG_LOG_LEVEL", logLevelValue);
// Limit MoltenVK to use single queue, as some older ANGLE versions
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
index 6cf3ab5..b1402aa 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
@@ -7802,6 +7802,79 @@
}
#endif
+#ifdef VK_EXT_external_memory_host
+void deepcopy_VkImportMemoryHostPointerInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* from,
+ VkImportMemoryHostPointerInfoEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pHostPointer = nullptr;
+ if (from->pHostPointer) {
+ to->pHostPointer = (void*)alloc->dupArray(from->pHostPointer, sizeof(uint8_t));
+ }
+}
+
+void deepcopy_VkMemoryHostPointerPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* from,
+ VkMemoryHostPointerPropertiesEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+}
+
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
Allocator* alloc, VkStructureType rootType,
@@ -10469,6 +10542,24 @@
break;
}
#endif
+#ifdef VK_EXT_external_memory_host
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ deepcopy_VkImportMemoryHostPointerInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension),
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension),
+ reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
index 2312fec..86caae3 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
@@ -1714,6 +1714,21 @@
deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
#endif
+#ifdef VK_EXT_external_memory_host
+void deepcopy_VkImportMemoryHostPointerInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* from,
+ VkImportMemoryHostPointerInfoEXT* to);
+
+void deepcopy_VkMemoryHostPointerPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* from,
+ VkMemoryHostPointerPropertiesEXT* to);
+
+void deepcopy_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ Allocator* alloc, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* from,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* to);
+
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
void deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
Allocator* alloc, VkStructureType rootType,
diff --git a/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp b/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
index 4b8d4a3..1f1ea67 100644
--- a/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
@@ -659,6 +659,10 @@
out->vkCmdInsertDebugUtilsLabelEXT =
(PFN_vkCmdInsertDebugUtilsLabelEXT)dlSymFunc(lib, "vkCmdInsertDebugUtilsLabelEXT");
#endif
+#ifdef VK_EXT_external_memory_host
+ out->vkGetMemoryHostPointerPropertiesEXT = (PFN_vkGetMemoryHostPointerPropertiesEXT)dlSymFunc(
+ lib, "vkGetMemoryHostPointerPropertiesEXT");
+#endif
#ifdef VK_NV_device_diagnostic_checkpoints
out->vkCmdSetCheckpointNV = (PFN_vkCmdSetCheckpointNV)dlSymFunc(lib, "vkCmdSetCheckpointNV");
out->vkGetQueueCheckpointDataNV =
@@ -1618,6 +1622,11 @@
(PFN_vkCmdInsertDebugUtilsLabelEXT)vk->vkGetInstanceProcAddr(
instance, "vkCmdInsertDebugUtilsLabelEXT");
#endif
+#ifdef VK_EXT_external_memory_host
+ out->vkGetMemoryHostPointerPropertiesEXT =
+ (PFN_vkGetMemoryHostPointerPropertiesEXT)vk->vkGetInstanceProcAddr(
+ instance, "vkGetMemoryHostPointerPropertiesEXT");
+#endif
#ifdef VK_NV_device_diagnostic_checkpoints
out->vkCmdSetCheckpointNV =
(PFN_vkCmdSetCheckpointNV)vk->vkGetInstanceProcAddr(instance, "vkCmdSetCheckpointNV");
@@ -2585,6 +2594,11 @@
out->vkCmdInsertDebugUtilsLabelEXT = (PFN_vkCmdInsertDebugUtilsLabelEXT)vk->vkGetDeviceProcAddr(
device, "vkCmdInsertDebugUtilsLabelEXT");
#endif
+#ifdef VK_EXT_external_memory_host
+ out->vkGetMemoryHostPointerPropertiesEXT =
+ (PFN_vkGetMemoryHostPointerPropertiesEXT)vk->vkGetDeviceProcAddr(
+ device, "vkGetMemoryHostPointerPropertiesEXT");
+#endif
#ifdef VK_NV_device_diagnostic_checkpoints
out->vkCmdSetCheckpointNV =
(PFN_vkCmdSetCheckpointNV)vk->vkGetDeviceProcAddr(device, "vkCmdSetCheckpointNV");
diff --git a/host/vulkan/cereal/common/goldfish_vk_dispatch.h b/host/vulkan/cereal/common/goldfish_vk_dispatch.h
index 3723f23..797f64d 100644
--- a/host/vulkan/cereal/common/goldfish_vk_dispatch.h
+++ b/host/vulkan/cereal/common/goldfish_vk_dispatch.h
@@ -466,6 +466,9 @@
PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT;
PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT;
#endif
+#ifdef VK_EXT_external_memory_host
+ PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT;
+#endif
#ifdef VK_NV_device_diagnostic_checkpoints
PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV;
PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV;
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
index 0cfedea..30f0e4c 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
@@ -15849,6 +15849,121 @@
}
#endif
+#ifdef VK_EXT_external_memory_host
+void marshal_VkImportMemoryHostPointerInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
+}
+
+void unmarshal_VkImportMemoryHostPointerInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkImportMemoryHostPointerInfoEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
+ vkStream->alloc((void**)&forUnmarshaling->pHostPointer, sizeof(uint8_t));
+ vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(uint8_t));
+}
+
+void marshal_VkMemoryHostPointerPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((uint32_t*)&forMarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void unmarshal_VkMemoryHostPointerPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkMemoryHostPointerPropertiesEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->memoryTypeBits, sizeof(uint32_t));
+}
+
+void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkDeviceSize*)&forMarshaling->minImportedHostPointerAlignment,
+ sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDeviceSize*)&forUnmarshaling->minImportedHostPointerAlignment,
+ sizeof(VkDeviceSize));
+}
+
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStream* vkStream, VkStructureType rootType,
@@ -19592,6 +19707,21 @@
break;
}
#endif
+#ifdef VK_EXT_external_memory_host
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ marshal_VkImportMemoryHostPointerInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -20919,6 +21049,21 @@
break;
}
#endif
+#ifdef VK_EXT_external_memory_host
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ unmarshal_VkImportMemoryHostPointerInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -22068,6 +22213,11 @@
return "OP_vkSubmitDebugUtilsMessageEXT";
}
#endif
+#ifdef VK_EXT_external_memory_host
+ case OP_vkGetMemoryHostPointerPropertiesEXT: {
+ return "OP_vkGetMemoryHostPointerPropertiesEXT";
+ }
+#endif
#ifdef VK_GOOGLE_gfxstream
case OP_vkMapMemoryIntoAddressSpaceGOOGLE: {
return "OP_vkMapMemoryIntoAddressSpaceGOOGLE";
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
index ada18ae..a8ccf33 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
@@ -3263,6 +3263,31 @@
unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
#endif
+#ifdef VK_EXT_external_memory_host
+void marshal_VkImportMemoryHostPointerInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkImportMemoryHostPointerInfoEXT* forMarshaling);
+
+void unmarshal_VkImportMemoryHostPointerInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkImportMemoryHostPointerInfoEXT* forUnmarshaling);
+
+void marshal_VkMemoryHostPointerPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkMemoryHostPointerPropertiesEXT* forMarshaling);
+
+void unmarshal_VkMemoryHostPointerPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkMemoryHostPointerPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling);
+
+#define OP_vkGetMemoryHostPointerPropertiesEXT 20313
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
void marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStream* vkStream, VkStructureType rootType,
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
index 9dba0a7..eba3264 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
@@ -12217,6 +12217,100 @@
}
#endif
+#ifdef VK_EXT_external_memory_host
+void reservedunmarshal_VkImportMemoryHostPointerInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkImportMemoryHostPointerInfoEXT* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, *ptr,
+ sizeof(VkExternalMemoryHandleTypeFlagBits));
+ *ptr += sizeof(VkExternalMemoryHandleTypeFlagBits);
+ vkStream->alloc((void**)&forUnmarshaling->pHostPointer, sizeof(uint8_t));
+ memcpy((void*)forUnmarshaling->pHostPointer, *ptr, sizeof(uint8_t));
+ *ptr += sizeof(uint8_t);
+}
+
+void reservedunmarshal_VkMemoryHostPointerPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkMemoryHostPointerPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((uint32_t*)&forUnmarshaling->memoryTypeBits, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkDeviceSize*)&forUnmarshaling->minImportedHostPointerAlignment, *ptr,
+ sizeof(VkDeviceSize));
+ *ptr += sizeof(VkDeviceSize);
+}
+
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
void reservedunmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStream* vkStream, VkStructureType rootType,
@@ -15418,6 +15512,22 @@
break;
}
#endif
+#ifdef VK_EXT_external_memory_host
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ reservedunmarshal_VkImportMemoryHostPointerInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ reservedunmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out),
+ ptr);
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
reservedunmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
index fcb5de3..1bc9728 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
@@ -1711,6 +1711,20 @@
reservedunmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
#endif
+#ifdef VK_EXT_external_memory_host
+void reservedunmarshal_VkImportMemoryHostPointerInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkImportMemoryHostPointerInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkMemoryHostPointerPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkMemoryHostPointerPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
void reservedunmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VulkanStream* vkStream, VkStructureType rootType,
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.cpp b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
index 5aba5d9..eb4d2e7 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
@@ -7222,6 +7222,70 @@
}
#endif
+#ifdef VK_EXT_external_memory_host
+void transform_tohost_VkImportMemoryHostPointerInfoEXT(
+ VkDecoderGlobalState* resourceTracker, VkImportMemoryHostPointerInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkImportMemoryHostPointerInfoEXT(
+ VkDecoderGlobalState* resourceTracker, VkImportMemoryHostPointerInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkMemoryHostPointerPropertiesEXT(
+ VkDecoderGlobalState* resourceTracker, VkMemoryHostPointerPropertiesEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ resourceTracker->deviceMemoryTransform_tohost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkMemoryHostPointerPropertiesEXT(
+ VkDecoderGlobalState* resourceTracker, VkMemoryHostPointerPropertiesEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ resourceTracker->deviceMemoryTransform_fromhost(
+ (VkDeviceMemory*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0,
+ (uint32_t*)nullptr, 0, (uint32_t*)&toTransform->memoryTypeBits, 1);
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
void transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VkDecoderGlobalState* resourceTracker,
@@ -9473,6 +9537,20 @@
break;
}
#endif
+#ifdef VK_EXT_external_memory_host
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ transform_tohost_VkImportMemoryHostPointerInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ transform_tohost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -10677,6 +10755,20 @@
break;
}
#endif
+#ifdef VK_EXT_external_memory_host
+ case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
+ transform_fromhost_VkImportMemoryHostPointerInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
+ transform_fromhost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ resourceTracker, reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(
+ structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.h b/host/vulkan/cereal/common/goldfish_vk_transform.h
index 45358d5..9024dc4 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.h
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.h
@@ -2850,6 +2850,28 @@
transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
#endif
+#ifdef VK_EXT_external_memory_host
+void transform_tohost_VkImportMemoryHostPointerInfoEXT(
+ VkDecoderGlobalState* resourceTracker, VkImportMemoryHostPointerInfoEXT* toTransform);
+
+void transform_fromhost_VkImportMemoryHostPointerInfoEXT(
+ VkDecoderGlobalState* resourceTracker, VkImportMemoryHostPointerInfoEXT* toTransform);
+
+void transform_tohost_VkMemoryHostPointerPropertiesEXT(
+ VkDecoderGlobalState* resourceTracker, VkMemoryHostPointerPropertiesEXT* toTransform);
+
+void transform_fromhost_VkMemoryHostPointerPropertiesEXT(
+ VkDecoderGlobalState* resourceTracker, VkMemoryHostPointerPropertiesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+ VkDecoderGlobalState* resourceTracker,
+ VkPhysicalDeviceExternalMemoryHostPropertiesEXT* toTransform);
+
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
void transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
VkDecoderGlobalState* resourceTracker,
diff --git a/host/vulkan/cereal/common/vk_struct_id.h b/host/vulkan/cereal/common/vk_struct_id.h
index c526dc1..54641fc 100644
--- a/host/vulkan/cereal/common/vk_struct_id.h
+++ b/host/vulkan/cereal/common/vk_struct_id.h
@@ -99,6 +99,8 @@
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT)
REGISTER_VK_STRUCT_ID(VkPhysicalDeviceProtectedMemoryFeatures,
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalMemoryHostPropertiesEXT,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT);
#if defined(VK_USE_PLATFORM_SCREEN_QNX)
REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX,
