diff options
Diffstat (limited to 'system/vulkan_enc')
21 files changed, 770 insertions, 1358 deletions
diff --git a/system/vulkan_enc/CMakeLists.txt b/system/vulkan_enc/CMakeLists.txt index 5b970156..44886583 100644 --- a/system/vulkan_enc/CMakeLists.txt +++ b/system/vulkan_enc/CMakeLists.txt @@ -4,7 +4,7 @@ android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc/Android.mk" "103f3f10c8af73d3d5c4263c4faa5bb70ebdbfbc9ed6f068a338d57344e2aa45") set(vulkan_enc_src AndroidHardwareBuffer.cpp HostVisibleMemoryVirtualization.cpp Resources.cpp Validation.cpp VulkanStreamGuest.cpp VulkanHandleMapping.cpp ResourceTracker.cpp VkEncoder.cpp goldfish_vk_extension_structs_guest.cpp goldfish_vk_marshaling_guest.cpp goldfish_vk_deepcopy_guest.cpp goldfish_vk_handlemap_guest.cpp goldfish_vk_transform_guest.cpp) android_add_library(TARGET vulkan_enc SHARED LICENSE Apache-2.0 SRC AndroidHardwareBuffer.cpp HostVisibleMemoryVirtualization.cpp Resources.cpp Validation.cpp VulkanStreamGuest.cpp VulkanHandleMapping.cpp ResourceTracker.cpp VkEncoder.cpp goldfish_vk_extension_structs_guest.cpp goldfish_vk_marshaling_guest.cpp goldfish_vk_deepcopy_guest.cpp goldfish_vk_handlemap_guest.cpp goldfish_vk_transform_guest.cpp) -target_include_directories(vulkan_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include/vulkan) -target_compile_definitions(vulkan_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGOLDFISH_VULKAN" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_ANDROID_native_buffer" "-DVK_GOOGLE_address_space" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES" "-D__ANDROID_API__=28") +target_include_directories(vulkan_enc PRIVATE ${GOLDFISH_DEVICE_ROOT}/shared/GoldfishAddressSpace/include ${GOLDFISH_DEVICE_ROOT}/system/renderControl_enc ${GOLDFISH_DEVICE_ROOT}/shared/OpenglCodecCommon ${GOLDFISH_DEVICE_ROOT}/android-emu ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include-types ${GOLDFISH_DEVICE_ROOT}/shared/qemupipe/include ${GOLDFISH_DEVICE_ROOT}/system/vulkan_enc ${GOLDFISH_DEVICE_ROOT}/./host/include/libOpenglRender ${GOLDFISH_DEVICE_ROOT}/./system/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/guest ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include ${GOLDFISH_DEVICE_ROOT}/./../../../external/qemu/android/android-emugl/host/include/vulkan) +target_compile_definitions(vulkan_enc PRIVATE "-DWITH_GLES2" "-DPLATFORM_SDK_VERSION=29" "-DGOLDFISH_HIDL_GRALLOC" "-DEMULATOR_OPENGL_POST_O=1" "-DHOST_BUILD" "-DANDROID" "-DGL_GLEXT_PROTOTYPES" "-DPAGE_SIZE=4096" "-DGFXSTREAM" "-DLOG_TAG=\"goldfish_vulkan\"" "-DVK_ANDROID_native_buffer" "-DVK_GOOGLE_address_space" "-DVK_USE_PLATFORM_ANDROID_KHR" "-DVK_NO_PROTOTYPES" "-D__ANDROID_API__=28") target_compile_options(vulkan_enc PRIVATE "-fvisibility=default" "-Wno-unused-parameter" "-Wno-missing-field-initializers" "-Werror" "-fstrict-aliasing") -target_link_libraries(vulkan_enc PRIVATE gui log android-emu-shared androidemu cutils utils _renderControl_enc OpenglCodecCommon_host PRIVATE GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file +target_link_libraries(vulkan_enc PRIVATE gui log android-emu-shared _renderControl_enc OpenglCodecCommon_host cutils utils androidemu PRIVATE GoldfishAddressSpace_host qemupipe_host)
\ No newline at end of file diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp index 2293df01..b00a5627 100644 --- a/system/vulkan_enc/ResourceTracker.cpp +++ b/system/vulkan_enc/ResourceTracker.cpp @@ -46,16 +46,21 @@ void zx_event_create(int, zx_handle_t*) { } #ifdef VK_USE_PLATFORM_FUCHSIA #include <cutils/native_handle.h> -#include <fuchsia/hardware/goldfish/cpp/fidl.h> -#include <fuchsia/sysmem/cpp/fidl.h> +#include <fuchsia/hardware/goldfish/llcpp/fidl.h> +#include <fuchsia/sysmem/llcpp/fidl.h> #include <lib/zx/channel.h> #include <lib/zx/vmo.h> +#include <zircon/errors.h> #include <zircon/process.h> +#include <zircon/rights.h> #include <zircon/syscalls.h> #include <zircon/syscalls/object.h> #include "services/service_connector.h" +#define GET_STATUS_SAFE(result, member) \ + ((result).ok() ? ((result).Unwrap()->member) : ZX_OK) + struct AHardwareBuffer; void AHardwareBuffer_release(AHardwareBuffer*) { } @@ -271,12 +276,12 @@ public: }; struct VkCommandBuffer_Info { - VkEncoder** lastUsedEncoderPtr = nullptr; + VkEncoder* lastUsedEncoder = nullptr; uint32_t sequenceNumber = 0; }; struct VkQueue_Info { - VkEncoder** lastUsedEncoderPtr = nullptr; + VkEncoder* lastUsedEncoder = nullptr; uint32_t sequenceNumber = 0; }; @@ -394,15 +399,10 @@ public: auto it = info_VkCommandBuffer.find(commandBuffer); if (it == info_VkCommandBuffer.end()) return; auto& info = it->second; - auto lastUsedEncoder = - info.lastUsedEncoderPtr ? - *(info.lastUsedEncoderPtr) : nullptr; - - if (lastUsedEncoder) { - delete info.lastUsedEncoderPtr; - info.lastUsedEncoderPtr = nullptr; + if (info.lastUsedEncoder) { + info.lastUsedEncoder->decRef(); } - + info.lastUsedEncoder = nullptr; info_VkCommandBuffer.erase(commandBuffer); } @@ -412,15 +412,11 @@ public: auto it = info_VkQueue.find(queue); if (it == info_VkQueue.end()) return; auto& info = it->second; - auto lastUsedEncoder = - info.lastUsedEncoderPtr ? - *(info.lastUsedEncoderPtr) : nullptr; - - if (lastUsedEncoder) { - delete info.lastUsedEncoderPtr; - info.lastUsedEncoderPtr = nullptr; + auto lastUsedEncoder = info.lastUsedEncoder; + if (info.lastUsedEncoder) { + info.lastUsedEncoder->decRef(); } - + info.lastUsedEncoder = nullptr; info_VkQueue.erase(queue); } @@ -811,13 +807,17 @@ public: ALOGE("failed to open control device"); abort(); } - mControlDevice.Bind(std::move(channel)); + mControlDevice = std::make_unique< + llcpp::fuchsia::hardware::goldfish::ControlDevice::SyncClient>( + std::move(channel)); zx::channel sysmem_channel(GetConnectToServiceFunction()("/svc/fuchsia.sysmem.Allocator")); if (!sysmem_channel) { ALOGE("failed to open sysmem connection"); } - mSysmemAllocator.Bind(std::move(sysmem_channel)); + mSysmemAllocator = + std::make_unique<llcpp::fuchsia::sysmem::Allocator::SyncClient>( + std::move(sysmem_channel)); } #endif @@ -1676,24 +1676,47 @@ public: const VkBufferCollectionCreateInfoFUCHSIA* pInfo, const VkAllocationCallbacks*, VkBufferCollectionFUCHSIA* pCollection) { - fuchsia::sysmem::BufferCollectionTokenSyncPtr token; + zx::channel token_client; + if (pInfo->collectionToken) { - token.Bind(zx::channel(pInfo->collectionToken)); + token_client = zx::channel(pInfo->collectionToken); } else { - zx_status_t status = mSysmemAllocator->AllocateSharedCollection(token.NewRequest()); + zx::channel token_server; + zx_status_t status = + zx::channel::create(0, &token_server, &token_client); if (status != ZX_OK) { - ALOGE("AllocateSharedCollection failed: %d", status); + ALOGE("zx_channel_create failed: %d", status); + return VK_ERROR_INITIALIZATION_FAILED; + } + + auto result = mSysmemAllocator->AllocateSharedCollection( + std::move(token_server)); + if (!result.ok()) { + ALOGE("AllocateSharedCollection failed: %d", result.status()); return VK_ERROR_INITIALIZATION_FAILED; } } - auto sysmem_collection = new fuchsia::sysmem::BufferCollectionSyncPtr; - zx_status_t status = mSysmemAllocator->BindSharedCollection( - std::move(token), sysmem_collection->NewRequest()); + + zx::channel collection_client, collection_server; + zx_status_t status = + zx::channel::create(0, &collection_client, &collection_server); if (status != ZX_OK) { - ALOGE("BindSharedCollection failed: %d", status); + ALOGE("zx_channel_create failed: %d", status); + return VK_ERROR_INITIALIZATION_FAILED; + } + + auto result = mSysmemAllocator->BindSharedCollection( + std::move(token_client), std::move(collection_server)); + if (!result.ok()) { + ALOGE("BindSharedCollection failed: %d", result.status()); return VK_ERROR_INITIALIZATION_FAILED; } + + auto sysmem_collection = + new llcpp::fuchsia::sysmem::BufferCollection::SyncClient( + std::move(collection_client)); *pCollection = reinterpret_cast<VkBufferCollectionFUCHSIA>(sysmem_collection); + return VK_SUCCESS; } @@ -1701,32 +1724,37 @@ public: void*, VkResult, VkDevice, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks*) { - auto sysmem_collection = reinterpret_cast<fuchsia::sysmem::BufferCollectionSyncPtr*>(collection); - if (sysmem_collection->is_bound()) { - (*sysmem_collection)->Close(); + auto sysmem_collection = reinterpret_cast< + llcpp::fuchsia::sysmem::BufferCollection::SyncClient*>(collection); + if (sysmem_collection) { + sysmem_collection->Close(); } delete sysmem_collection; } - inline fuchsia::sysmem::BufferCollectionConstraints - defaultBufferCollectionConstraints(size_t min_size_bytes, - size_t buffer_count) { - fuchsia::sysmem::BufferCollectionConstraints constraints = {}; + inline llcpp::fuchsia::sysmem::BufferCollectionConstraints defaultBufferCollectionConstraints( + size_t min_size_bytes, + size_t buffer_count) { + llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints = {}; constraints.min_buffer_count = buffer_count; constraints.has_buffer_memory_constraints = true; - fuchsia::sysmem::BufferMemoryConstraints& buffer_constraints = + llcpp::fuchsia::sysmem::BufferMemoryConstraints& buffer_constraints = constraints.buffer_memory_constraints; buffer_constraints.min_size_bytes = min_size_bytes; buffer_constraints.max_size_bytes = 0xffffffff; buffer_constraints.physically_contiguous_required = false; buffer_constraints.secure_required = false; - buffer_constraints.ram_domain_supported = false; - buffer_constraints.cpu_domain_supported = false; + + // No restrictions on coherency domain or Heaps. + buffer_constraints.ram_domain_supported = true; + buffer_constraints.cpu_domain_supported = true; buffer_constraints.inaccessible_domain_supported = true; - buffer_constraints.heap_permitted_count = 1; + buffer_constraints.heap_permitted_count = 2; buffer_constraints.heap_permitted[0] = - fuchsia::sysmem::HeapType::GOLDFISH_DEVICE_LOCAL; + llcpp::fuchsia::sysmem::HeapType::GOLDFISH_DEVICE_LOCAL; + buffer_constraints.heap_permitted[1] = + llcpp::fuchsia::sysmem::HeapType::GOLDFISH_HOST_VISIBLE; return constraints; } @@ -1736,9 +1764,9 @@ public: uint32_t usage = 0u; VkImageUsageFlags imageUsage = pImageInfo->usage; -#define SetUsageBit(USAGE) \ - if (imageUsage & VK_IMAGE_USAGE_##USAGE##_BIT) { \ - usage |= fuchsia::sysmem::VULKAN_IMAGE_USAGE_##USAGE; \ +#define SetUsageBit(USAGE) \ + if (imageUsage & VK_IMAGE_USAGE_##USAGE##_BIT) { \ + usage |= llcpp::fuchsia::sysmem::VULKAN_IMAGE_USAGE_##USAGE; \ } SetUsageBit(COLOR_ATTACHMENT); @@ -1756,9 +1784,9 @@ public: VkBufferUsageFlags bufferUsage = pBufferConstraintsInfo->pBufferCreateInfo->usage; -#define SetUsageBit(USAGE) \ - if (bufferUsage & VK_BUFFER_USAGE_##USAGE##_BIT) { \ - usage |= fuchsia::sysmem::VULKAN_BUFFER_USAGE_##USAGE; \ +#define SetUsageBit(USAGE) \ + if (bufferUsage & VK_BUFFER_USAGE_##USAGE##_BIT) { \ + usage |= llcpp::fuchsia::sysmem::VULKAN_BUFFER_USAGE_##USAGE; \ } SetUsageBit(TRANSFER_SRC); @@ -1776,20 +1804,17 @@ public: } VkResult setBufferCollectionConstraints( - fuchsia::sysmem::BufferCollectionSyncPtr* collection, + VkEncoder* enc, VkDevice device, + llcpp::fuchsia::sysmem::BufferCollection::SyncClient* collection, const VkImageCreateInfo* pImageInfo) { if (pImageInfo == nullptr) { ALOGE("setBufferCollectionConstraints: pImageInfo cannot be null."); return VK_ERROR_OUT_OF_DEVICE_MEMORY; } - // TODO(liyl): Currently the size only works for RGBA8 and BGRA8 images. - // We should set the size based on its actual format. - fuchsia::sysmem::BufferCollectionConstraints constraints = + llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints = defaultBufferCollectionConstraints( - /* min_size_bytes */ pImageInfo->extent.width * - pImageInfo->extent.height * 4, - /* buffer_count */ 1u); + /* min_size_bytes */ 0, /* buffer_count */ 1u); constraints.usage.vulkan = getBufferCollectionConstraintsVulkanImageUsage(pImageInfo); @@ -1805,11 +1830,46 @@ public: VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, }; + } else { + // If image format is predefined, check on host if the format, + // tiling and usage is supported. + AutoLock lock(mLock); + auto deviceIt = info_VkDevice.find(device); + if (deviceIt == info_VkDevice.end()) { + return VK_ERROR_INITIALIZATION_FAILED; + } + auto& deviceInfo = deviceIt->second; + + VkImageFormatProperties format_properties; + auto result = enc->vkGetPhysicalDeviceImageFormatProperties( + deviceInfo.physdev, pImageInfo->format, pImageInfo->imageType, + pImageInfo->tiling, pImageInfo->usage, pImageInfo->flags, &format_properties); + if (result != VK_SUCCESS) { + ALOGE( + "%s: Image format (%u) type (%u) tiling (%u) " + "usage (%u) flags (%u) not supported by physical " + "device", + __func__, static_cast<uint32_t>(pImageInfo->format), + static_cast<uint32_t>(pImageInfo->imageType), + static_cast<uint32_t>(pImageInfo->tiling), + static_cast<uint32_t>(pImageInfo->usage), + static_cast<uint32_t>(pImageInfo->flags)); + return VK_ERROR_FORMAT_NOT_SUPPORTED; + } } constraints.image_format_constraints_count = formats.size(); uint32_t format_index = 0; for (VkFormat format : formats) { - fuchsia::sysmem::ImageFormatConstraints& image_constraints = + // Get row alignment from host GPU. + VkDeviceSize offset; + VkDeviceSize rowPitchAlignment; + enc->vkGetLinearImageLayoutGOOGLE(device, format, &offset, &rowPitchAlignment); + + ALOGD("vkGetLinearImageLayoutGOOGLE: format %d offset %lu rowPitchAlignment = %lu", + (int)format, offset, rowPitchAlignment); + + llcpp::fuchsia::sysmem::ImageFormatConstraints& + image_constraints = constraints.image_format_constraints[format_index++]; switch (format) { case VK_FORMAT_B8G8R8A8_SINT: @@ -1819,7 +1879,7 @@ public: case VK_FORMAT_B8G8R8A8_SSCALED: case VK_FORMAT_B8G8R8A8_USCALED: image_constraints.pixel_format.type = - fuchsia::sysmem::PixelFormatType::BGRA32; + llcpp::fuchsia::sysmem::PixelFormatType::BGRA32; break; case VK_FORMAT_R8G8B8A8_SINT: case VK_FORMAT_R8G8B8A8_UNORM: @@ -1828,39 +1888,45 @@ public: case VK_FORMAT_R8G8B8A8_SSCALED: case VK_FORMAT_R8G8B8A8_USCALED: image_constraints.pixel_format.type = - fuchsia::sysmem::PixelFormatType::R8G8B8A8; + llcpp::fuchsia::sysmem::PixelFormatType::R8G8B8A8; break; default: return VK_ERROR_FORMAT_NOT_SUPPORTED; } image_constraints.color_spaces_count = 1; image_constraints.color_space[0].type = - fuchsia::sysmem::ColorSpaceType::SRGB; + llcpp::fuchsia::sysmem::ColorSpaceType::SRGB; image_constraints.min_coded_width = pImageInfo->extent.width; image_constraints.max_coded_width = 0xfffffff; image_constraints.min_coded_height = pImageInfo->extent.height; image_constraints.max_coded_height = 0xffffffff; - image_constraints.min_bytes_per_row = - pImageInfo->extent.width * 4; + // The min_bytes_per_row can be calculated by sysmem using + // |min_coded_width|, |bytes_per_row_divisor| and color format. + image_constraints.min_bytes_per_row = 0; image_constraints.max_bytes_per_row = 0xffffffff; image_constraints.max_coded_width_times_coded_height = 0xffffffff; image_constraints.layers = 1; image_constraints.coded_width_divisor = 1; image_constraints.coded_height_divisor = 1; - image_constraints.bytes_per_row_divisor = 1; + image_constraints.bytes_per_row_divisor = rowPitchAlignment; image_constraints.start_offset_divisor = 1; image_constraints.display_width_divisor = 1; image_constraints.display_height_divisor = 1; } } - (*collection)->SetConstraints(true, constraints); + auto result = collection->SetConstraints(true, std::move(constraints)); + if (!result.ok()) { + ALOGE("setBufferCollectionConstraints: SetConstraints failed: %d", + result.status()); + return VK_ERROR_OUT_OF_DEVICE_MEMORY; + } return VK_SUCCESS; } VkResult setBufferCollectionBufferConstraints( - fuchsia::sysmem::BufferCollectionSyncPtr* collection, + llcpp::fuchsia::sysmem::BufferCollection::SyncClient* collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) { if (pBufferConstraintsInfo == nullptr) { ALOGE( @@ -1869,26 +1935,31 @@ public: return VK_ERROR_OUT_OF_DEVICE_MEMORY; } - fuchsia::sysmem::BufferCollectionConstraints constraints = + llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints = defaultBufferCollectionConstraints( - /* min_size_bytes */ pBufferConstraintsInfo->pBufferCreateInfo - ->size, + /* min_size_bytes */ pBufferConstraintsInfo->pBufferCreateInfo->size, /* buffer_count */ pBufferConstraintsInfo->minCount); constraints.usage.vulkan = getBufferCollectionConstraintsVulkanBufferUsage( pBufferConstraintsInfo); - (*collection)->SetConstraints(true, constraints); + auto result = collection->SetConstraints(true, std::move(constraints)); + if (!result.ok()) { + ALOGE("setBufferCollectionConstraints: SetConstraints failed: %d", + result.status()); + return VK_ERROR_OUT_OF_DEVICE_MEMORY; + } return VK_SUCCESS; } VkResult on_vkSetBufferCollectionConstraintsFUCHSIA( - void*, VkResult, VkDevice, + void* context, VkResult, VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageCreateInfo* pImageInfo) { - auto sysmem_collection = - reinterpret_cast<fuchsia::sysmem::BufferCollectionSyncPtr*>(collection); - return setBufferCollectionConstraints(sysmem_collection, pImageInfo); + VkEncoder* enc = (VkEncoder*)context; + auto sysmem_collection = reinterpret_cast< + llcpp::fuchsia::sysmem::BufferCollection::SyncClient*>(collection); + return setBufferCollectionConstraints(enc, device, sysmem_collection, pImageInfo); } VkResult on_vkSetBufferCollectionBufferConstraintsFUCHSIA( @@ -1897,9 +1968,8 @@ public: VkDevice, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) { - auto sysmem_collection = - reinterpret_cast<fuchsia::sysmem::BufferCollectionSyncPtr*>( - collection); + auto sysmem_collection = reinterpret_cast< + llcpp::fuchsia::sysmem::BufferCollection::SyncClient*>(collection); return setBufferCollectionBufferConstraints(sysmem_collection, pBufferConstraintsInfo); } @@ -1909,17 +1979,28 @@ public: VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) { - auto sysmem_collection = reinterpret_cast<fuchsia::sysmem::BufferCollectionSyncPtr*>(collection); - fuchsia::sysmem::BufferCollectionInfo_2 info; - zx_status_t status2; - zx_status_t status = (*sysmem_collection)->WaitForBuffersAllocated(&status2, &info); - if (status != ZX_OK || status2 != ZX_OK) { - ALOGE("Failed wait for allocation: %d %d", status, status2); + auto sysmem_collection = reinterpret_cast< + llcpp::fuchsia::sysmem::BufferCollection::SyncClient*>(collection); + + auto result = sysmem_collection->WaitForBuffersAllocated(); + if (!result.ok() || result.Unwrap()->status != ZX_OK) { + ALOGE("Failed wait for allocation: %d %d", result.status(), + GET_STATUS_SAFE(result, status)); return VK_ERROR_INITIALIZATION_FAILED; } - if (!info.settings.has_image_format_constraints) { + llcpp::fuchsia::sysmem::BufferCollectionInfo_2 info = + std::move(result.Unwrap()->buffer_collection_info); + + bool is_host_visible = info.settings.buffer_settings.heap == + llcpp::fuchsia::sysmem::HeapType::GOLDFISH_HOST_VISIBLE; + bool is_device_local = info.settings.buffer_settings.heap == + llcpp::fuchsia::sysmem::HeapType::GOLDFISH_DEVICE_LOCAL; + if (!is_host_visible && !is_device_local) { + ALOGE("buffer collection uses a non-goldfish heap (type 0x%lu)", + static_cast<uint64_t>(info.settings.buffer_settings.heap)); return VK_ERROR_INITIALIZATION_FAILED; } + pProperties->count = info.buffer_count; AutoLock lock(mLock); @@ -1935,8 +2016,10 @@ public: // Device local memory type supported. pProperties->memoryTypeBits = 0; for (uint32_t i = 0; i < deviceInfo.memProps.memoryTypeCount; ++i) { - if (deviceInfo.memProps.memoryTypes[i].propertyFlags & - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) { + if ((is_device_local && (deviceInfo.memProps.memoryTypes[i].propertyFlags & + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) || + (is_host_visible && (deviceInfo.memProps.memoryTypes[i].propertyFlags & + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))) { pProperties->memoryTypeBits |= 1ull << i; } } @@ -2057,9 +2140,9 @@ public: abort(); } - struct drm_virtgpu_map map_info = { - .handle = drm_rc_blob.bo_handle, - }; + drm_virtgpu_map map_info; + memset(&map_info, 0, sizeof(map_info)); + map_info.handle = drm_rc_blob.bo_handle; res = drmIoctl(mRendernodeFd, DRM_IOCTL_VIRTGPU_MAP, &map_info); if (res) { @@ -2298,15 +2381,17 @@ public: if (importBufferCollection) { #ifdef VK_USE_PLATFORM_FUCHSIA - auto collection = reinterpret_cast<fuchsia::sysmem::BufferCollectionSyncPtr*>( + auto collection = reinterpret_cast< + llcpp::fuchsia::sysmem::BufferCollection::SyncClient*>( importBufferCollectionInfoPtr->collection); - fuchsia::sysmem::BufferCollectionInfo_2 info; - zx_status_t status2; - zx_status_t status = (*collection)->WaitForBuffersAllocated(&status2, &info); - if (status != ZX_OK || status2 != ZX_OK) { - ALOGE("WaitForBuffersAllocated failed: %d %d", status); + auto result = collection->WaitForBuffersAllocated(); + if (!result.ok() || result.Unwrap()->status != ZX_OK) { + ALOGE("WaitForBuffersAllocated failed: %d %d", result.status(), + GET_STATUS_SAFE(result, status)); return VK_ERROR_INITIALIZATION_FAILED; } + llcpp::fuchsia::sysmem::BufferCollectionInfo_2& info = + result.Unwrap()->buffer_collection_info; uint32_t index = importBufferCollectionInfoPtr->index; if (info.buffer_count < index) { ALOGE("Invalid buffer index: %d %d", index); @@ -2381,25 +2466,52 @@ public: pBufferConstraintsInfo); if (hasDedicatedImage || hasDedicatedBuffer) { - fuchsia::sysmem::BufferCollectionTokenSyncPtr token; - zx_status_t status = mSysmemAllocator->AllocateSharedCollection( - token.NewRequest()); + zx::channel token_server, token_client; + zx_status_t status = + zx::channel::create(0, &token_server, &token_client); if (status != ZX_OK) { - ALOGE("AllocateSharedCollection failed: %d", status); + ALOGE("zx_channel_create failed: %d", status); abort(); } - fuchsia::sysmem::BufferCollectionSyncPtr collection; - status = mSysmemAllocator->BindSharedCollection( - std::move(token), collection.NewRequest()); + { + auto result = mSysmemAllocator->AllocateSharedCollection( + std::move(token_server)); + if (!result.ok()) { + ALOGE("AllocateSharedCollection failed: %d", + result.status()); + abort(); + } + } + + zx::channel collection_server, collection_client; + status = zx::channel::create(0, &collection_server, + &collection_client); if (status != ZX_OK) { - ALOGE("BindSharedCollection failed: %d", status); + ALOGE("zx_channel_create failed: %d", status); abort(); } + { + auto result = mSysmemAllocator->BindSharedCollection( + std::move(token_client), std::move(collection_server)); + if (!result.ok()) { + ALOGE("BindSharedCollection failed: %d", + result.status()); + abort(); + } + } + + llcpp::fuchsia::sysmem::BufferCollection::SyncClient collection( + std::move(collection_client)); if (hasDedicatedImage) { VkResult res = setBufferCollectionConstraints( - &collection, pImageCreateInfo); + enc, device, &collection, pImageCreateInfo); + if (res == VK_ERROR_FORMAT_NOT_SUPPORTED) { + ALOGE("setBufferCollectionConstraints failed: format %u is not supported", + pImageCreateInfo->format); + return VK_ERROR_OUT_OF_DEVICE_MEMORY; + } if (res != VK_SUCCESS) { ALOGE("setBufferCollectionConstraints failed: %d", res); abort(); @@ -2416,25 +2528,30 @@ public: } } - fuchsia::sysmem::BufferCollectionInfo_2 info; - zx_status_t status2; - status = collection->WaitForBuffersAllocated(&status2, &info); - if (status == ZX_OK && status2 == ZX_OK) { - if (!info.buffer_count) { - ALOGE("WaitForBuffersAllocated returned invalid count: %d", status); - abort(); + { + auto result = collection.WaitForBuffersAllocated(); + if (result.ok() && result.Unwrap()->status == ZX_OK) { + llcpp::fuchsia::sysmem::BufferCollectionInfo_2& info = + result.Unwrap()->buffer_collection_info; + if (!info.buffer_count) { + ALOGE( + "WaitForBuffersAllocated returned " + "invalid count: %d", + info.buffer_count); + abort(); + } + vmo_handle = info.buffers[0].vmo.release(); + } else { + ALOGE("WaitForBuffersAllocated failed: %d %d", + result.status(), GET_STATUS_SAFE(result, status)); + abort(); } - vmo_handle = info.buffers[0].vmo.release(); - } else { - ALOGE("WaitForBuffersAllocated failed: %d %d", status, status2); - abort(); } - collection->Close(); + collection.Close(); zx::vmo vmo_copy; - status = zx_handle_duplicate(vmo_handle, - ZX_RIGHT_SAME_RIGHTS, + status = zx_handle_duplicate(vmo_handle, ZX_RIGHT_SAME_RIGHTS, vmo_copy.reset_and_get_address()); if (status != ZX_OK) { ALOGE("Failed to duplicate VMO: %d", status); @@ -2442,7 +2559,8 @@ public: } if (pImageCreateInfo) { - fuchsia::hardware::goldfish::ColorBufferFormatType format; + llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType + format; switch (pImageCreateInfo->format) { case VK_FORMAT_B8G8R8A8_SINT: case VK_FORMAT_B8G8R8A8_UNORM: @@ -2450,7 +2568,7 @@ public: case VK_FORMAT_B8G8R8A8_SNORM: case VK_FORMAT_B8G8R8A8_SSCALED: case VK_FORMAT_B8G8R8A8_USCALED: - format = fuchsia::hardware::goldfish:: + format = llcpp::fuchsia::hardware::goldfish:: ColorBufferFormatType::BGRA; break; case VK_FORMAT_R8G8B8A8_SINT: @@ -2459,7 +2577,7 @@ public: case VK_FORMAT_R8G8B8A8_SNORM: case VK_FORMAT_R8G8B8A8_SSCALED: case VK_FORMAT_R8G8B8A8_USCALED: - format = fuchsia::hardware::goldfish:: + format = llcpp::fuchsia::hardware::goldfish:: ColorBufferFormatType::RGBA; break; default: @@ -2468,23 +2586,42 @@ public: abort(); } - status = mControlDevice->CreateColorBuffer( - std::move(vmo_copy), pImageCreateInfo->extent.width, - pImageCreateInfo->extent.height, format, &status2); - if (status != ZX_OK || status2 != ZX_OK) { - ALOGE("CreateColorBuffer failed: %d:%d", status, - status2); - abort(); + auto createParams = + llcpp::fuchsia::hardware::goldfish::CreateColorBuffer2Params::Builder( + std::make_unique<llcpp::fuchsia::hardware::goldfish:: + CreateColorBuffer2Params::Frame>()) + .set_width(std::make_unique<uint32_t>(pImageCreateInfo->extent.width)) + .set_height(std::make_unique<uint32_t>(pImageCreateInfo->extent.height)) + .set_format(std::make_unique< + llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType>( + format)) + .set_memory_property(std::make_unique<uint32_t>( + llcpp::fuchsia::hardware::goldfish::MEMORY_PROPERTY_DEVICE_LOCAL)) + .build(); + + auto result = mControlDevice->CreateColorBuffer2(std::move(vmo_copy), + std::move(createParams)); + if (!result.ok() || result.Unwrap()->res != ZX_OK) { + if (result.ok() && + result.Unwrap()->res == ZX_ERR_ALREADY_EXISTS) { + ALOGD("CreateColorBuffer: color buffer already " + "exists\n"); + } else { + ALOGE("CreateColorBuffer failed: %d:%d", + result.status(), + GET_STATUS_SAFE(result, res)); + abort(); + } } } if (pBufferConstraintsInfo) { - status = mControlDevice->CreateBuffer( + auto result = mControlDevice->CreateBuffer( std::move(vmo_copy), - pBufferConstraintsInfo->pBufferCreateInfo->size, - &status2); - if (status != ZX_OK || status2 != ZX_OK) { - ALOGE("CreateBuffer failed: %d:%d", status, status2); + pBufferConstraintsInfo->pBufferCreateInfo->size); + if (!result.ok() || result.Unwrap()->res != ZX_OK) { + ALOGE("CreateBuffer failed: %d:%d", result.status(), + GET_STATUS_SAFE(result, res)); abort(); } } @@ -2502,23 +2639,23 @@ public: } zx_status_t status2 = ZX_OK; - fuchsia::hardware::goldfish::BufferHandleType handle_type; - uint32_t buffer_handle; - - status = mControlDevice->GetBufferHandle(std::move(vmo_copy), - &status2, &buffer_handle, - &handle_type); - if (status != ZX_OK || status2 != ZX_OK) { - ALOGE("GetBufferHandle failed: %d:%d", status, status2); - } - - if (handle_type == - fuchsia::hardware::goldfish::BufferHandleType::BUFFER) { - importBufferInfo.buffer = buffer_handle; - vk_append_struct(&structChainIter, &importBufferInfo); + auto result = mControlDevice->GetBufferHandle(std::move(vmo_copy)); + if (!result.ok() || result.Unwrap()->res != ZX_OK) { + ALOGE("GetBufferHandle failed: %d:%d", result.status(), + GET_STATUS_SAFE(result, res)); } else { - importCbInfo.colorBuffer = buffer_handle; - vk_append_struct(&structChainIter, &importCbInfo); + llcpp::fuchsia::hardware::goldfish::BufferHandleType + handle_type = result.Unwrap()->type; + uint32_t buffer_handle = result.Unwrap()->id; + + if (handle_type == llcpp::fuchsia::hardware::goldfish:: + BufferHandleType::BUFFER) { + importBufferInfo.buffer = buffer_handle; + vk_append_struct(&structChainIter, &importBufferInfo); + } else { + importCbInfo.colorBuffer = buffer_handle; + vk_append_struct(&structChainIter, &importCbInfo); + } } } #endif @@ -2554,12 +2691,44 @@ public: abort(); } +#ifdef VK_USE_PLATFORM_FUCHSIA if (vmo_handle != ZX_HANDLE_INVALID) { - ALOGE("%s: Host visible export/import allocation " - "of VMO is not supported yet.", - __func__); - abort(); + input_result = enc->vkAllocateMemory(device, &finalAllocInfo, pAllocator, pMemory); + + // Get VMO handle rights, and only use allowed rights to map the + // host memory. + zx_info_handle_basic handle_info; + zx_status_t status = zx_object_get_info(vmo_handle, ZX_INFO_HANDLE_BASIC, &handle_info, + sizeof(handle_info), nullptr, nullptr); + if (status != ZX_OK) { + ALOGE("%s: cannot get vmo object info: vmo = %u status: %d.", __func__, vmo_handle, + status); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + + zx_vm_option_t vm_permission = 0u; + vm_permission |= (handle_info.rights & ZX_RIGHT_READ) ? ZX_VM_PERM_READ : 0; + vm_permission |= (handle_info.rights & ZX_RIGHT_WRITE) ? ZX_VM_PERM_WRITE : 0; + + zx_paddr_t addr; + status = zx_vmar_map(zx_vmar_root_self(), vm_permission, 0, vmo_handle, 0, + finalAllocInfo.allocationSize, &addr); + if (status != ZX_OK) { + ALOGE("%s: cannot map vmar: status %d.", __func__, status); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + + D("host visible alloc (external): " + "size 0x%llx host ptr %p mapped size 0x%llx", + (unsigned long long)finalAllocInfo.allocationSize, mappedPtr, + (unsigned long long)mappedSize); + setDeviceMemoryInfo(device, *pMemory, + finalAllocInfo.allocationSize, finalAllocInfo.allocationSize, + reinterpret_cast<uint8_t*>(addr), finalAllocInfo.memoryTypeIndex, + /*ahw=*/nullptr, vmo_handle); + return VK_SUCCESS; } +#endif // Host visible memory, non external bool directMappingSupported = usingDirectMapping(); @@ -2655,6 +2824,17 @@ public: if (it == info_VkDeviceMemory.end()) return; auto& info = it->second; +#ifdef VK_USE_PLATFORM_FUCHSIA + if (info.vmoHandle && info.mappedPtr) { + zx_status_t status = zx_vmar_unmap( + zx_vmar_root_self(), reinterpret_cast<zx_paddr_t>(info.mappedPtr), info.mappedSize); + if (status != ZX_OK) { + ALOGE("%s: Cannot unmap mappedPtr: status %d", status); + } + info.mappedPtr = nullptr; + } +#endif + if (!info.directMapped) { lock.unlock(); VkEncoder* enc = (VkEncoder*)context; @@ -2893,35 +3073,90 @@ public: const VkBufferCollectionImageCreateInfoFUCHSIA* extBufferCollectionPtr = vk_find_struct<VkBufferCollectionImageCreateInfoFUCHSIA>(pCreateInfo); bool isSysmemBackedMemory = false; + + if (extImgCiPtr && + (extImgCiPtr->handleTypes & + VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)) { + isSysmemBackedMemory = true; + } + if (extBufferCollectionPtr) { - auto collection = reinterpret_cast<fuchsia::sysmem::BufferCollectionSyncPtr*>( + auto collection = reinterpret_cast< + llcpp::fuchsia::sysmem::BufferCollection::SyncClient*>( extBufferCollectionPtr->collection); uint32_t index = extBufferCollectionPtr->index; zx::vmo vmo; - fuchsia::sysmem::BufferCollectionInfo_2 info; - zx_status_t status2; - zx_status_t status = (*collection)->WaitForBuffersAllocated(&status2, &info); - if (status == ZX_OK && status2 == ZX_OK) { + llcpp::fuchsia::sysmem::BufferCollectionInfo_2 info; + + auto result = collection->WaitForBuffersAllocated(); + if (result.ok() && result.Unwrap()->status == ZX_OK) { + info = std::move(result.Unwrap()->buffer_collection_info); if (index < info.buffer_count && info.settings.has_image_format_constraints) { vmo = std::move(info.buffers[index].vmo); } } else { - ALOGE("WaitForBuffersAllocated failed: %d %d", status, status2); + ALOGE("WaitForBuffersAllocated failed: %d %d", result.status(), + GET_STATUS_SAFE(result, status)); } if (vmo.is_valid()) { - zx_status_t status2 = ZX_OK; - status = mControlDevice->CreateColorBuffer( - std::move(vmo), - info.settings.image_format_constraints.min_coded_width, - info.settings.image_format_constraints.min_coded_height, - info.settings.image_format_constraints.pixel_format.type == fuchsia::sysmem::PixelFormatType::R8G8B8A8 - ? fuchsia::hardware::goldfish::ColorBufferFormatType::RGBA - : fuchsia::hardware::goldfish::ColorBufferFormatType::BGRA, - &status2); - if (status != ZX_OK || (status2 != ZX_OK && status2 != ZX_ERR_ALREADY_EXISTS)) { - ALOGE("CreateColorBuffer failed: %d:%d", status, status2); + zx::vmo vmo_dup; + if (zx_status_t status = vmo.duplicate(ZX_RIGHT_SAME_RIGHTS, &vmo_dup); + status != ZX_OK) { + ALOGE("%s: zx_vmo_duplicate failed: %d", __func__, status); + abort(); + } + + auto buffer_handle_result = mControlDevice->GetBufferHandle(std::move(vmo_dup)); + if (!buffer_handle_result.ok()) { + ALOGE("%s: GetBufferHandle FIDL error: %d", __func__, + buffer_handle_result.status()); + abort(); + } + if (buffer_handle_result.value().res == ZX_OK) { + // Buffer handle already exists. + // If it is a ColorBuffer, no-op; Otherwise return error. + if (buffer_handle_result.value().type != + llcpp::fuchsia::hardware::goldfish::BufferHandleType::COLOR_BUFFER) { + ALOGE("%s: BufferHandle %u is not a ColorBuffer", __func__, + buffer_handle_result.value().id); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + } else if (buffer_handle_result.value().res == ZX_ERR_NOT_FOUND) { + // Buffer handle not found. Create ColorBuffer based on buffer settings. + auto format = + info.settings.image_format_constraints.pixel_format.type == + llcpp::fuchsia::sysmem::PixelFormatType::R8G8B8A8 + ? llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType::RGBA + : llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType::BGRA; + + uint32_t memory_property = + info.settings.buffer_settings.heap == + llcpp::fuchsia::sysmem::HeapType::GOLDFISH_DEVICE_LOCAL + ? llcpp::fuchsia::hardware::goldfish::MEMORY_PROPERTY_DEVICE_LOCAL + : llcpp::fuchsia::hardware::goldfish::MEMORY_PROPERTY_HOST_VISIBLE; + + auto createParams = + llcpp::fuchsia::hardware::goldfish::CreateColorBuffer2Params::Builder( + std::make_unique<llcpp::fuchsia::hardware::goldfish:: + CreateColorBuffer2Params::Frame>()) + .set_width(std::make_unique<uint32_t>( + info.settings.image_format_constraints.min_coded_width)) + .set_height(std::make_unique<uint32_t>( + info.settings.image_format_constraints.min_coded_height)) + .set_format(std::make_unique< + llcpp::fuchsia::hardware::goldfish::ColorBufferFormatType>( + format)) + .set_memory_property(std::make_unique<uint32_t>(memory_property)) + .build(); + + auto result = + mControlDevice->CreateColorBuffer2(std::move(vmo), std::move(createParams)); + if (!result.ok() || result.Unwrap()->res != ZX_OK) { + ALOGE("CreateColorBuffer failed: %d:%d", result.status(), + GET_STATUS_SAFE(result, res)); + } } } isSysmemBackedMemory = true; @@ -3733,37 +3968,44 @@ public: Optional<zx::vmo> vmo; bool isSysmemBackedMemory = false; + const VkExternalMemoryBufferCreateInfo* extBufCiPtr = + vk_find_struct<VkExternalMemoryBufferCreateInfo>(pCreateInfo); + if (extBufCiPtr && + (extBufCiPtr->handleTypes & + VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)) { + isSysmemBackedMemory = true; + } + const auto* extBufferCollectionPtr = vk_find_struct<VkBufferCollectionBufferCreateInfoFUCHSIA>( pCreateInfo); if (extBufferCollectionPtr) { - auto collection = - reinterpret_cast<fuchsia::sysmem::BufferCollectionSyncPtr*>( - extBufferCollectionPtr->collection); + auto collection = reinterpret_cast< + llcpp::fuchsia::sysmem::BufferCollection::SyncClient*>( + extBufferCollectionPtr->collection); uint32_t index = extBufferCollectionPtr->index; - fuchsia::sysmem::BufferCollectionInfo_2 info; - zx_status_t status2; - zx_status_t status = - (*collection)->WaitForBuffersAllocated(&status2, &info); - - if (status == ZX_OK && status2 == ZX_OK) { + auto result = collection->WaitForBuffersAllocated(); + if (result.ok() && result.Unwrap()->status == ZX_OK) { + auto& info = result.Unwrap()->buffer_collection_info; if (index < info.buffer_count) { vmo = android::base::makeOptional( std::move(info.buffers[index].vmo)); } } else { - ALOGE("WaitForBuffersAllocated failed: %d %d", status, status2); + ALOGE("WaitForBuffersAllocated failed: %d %d", result.status(), + GET_STATUS_SAFE(result, status)); } if (vmo && vmo->is_valid()) { - zx_status_t status2 = ZX_OK; - status = mControlDevice->CreateBuffer( - std::move(*vmo), pCreateInfo->size, &status2); - if (status != ZX_OK || - (status2 != ZX_OK && status2 != ZX_ERR_ALREADY_EXISTS)) { - ALOGE("CreateBuffer failed: %d:%d", status, status2); + auto result = mControlDevice->CreateBuffer(std::move(*vmo), + pCreateInfo->size); + if (!result.ok() || + (result.Unwrap()->res != ZX_OK && + result.Unwrap()->res != ZX_ERR_ALREADY_EXISTS)) { + ALOGE("CreateBuffer failed: %d:%d", result.status(), + GET_STATUS_SAFE(result, res)); } isSysmemBackedMemory = true; } @@ -4583,6 +4825,35 @@ public: VkEncoder* enc = (VkEncoder*)context; (void)input_result; +#ifdef VK_USE_PLATFORM_FUCHSIA + + constexpr VkFormat kExternalImageSupportedFormats[] = { + VK_FORMAT_B8G8R8A8_SINT, + VK_FORMAT_B8G8R8A8_UNORM, + VK_FORMAT_B8G8R8A8_SRGB, + VK_FORMAT_B8G8R8A8_SNORM, + VK_FORMAT_B8G8R8A8_SSCALED, + VK_FORMAT_B8G8R8A8_USCALED, + VK_FORMAT_R8G8B8A8_SINT, + VK_FORMAT_R8G8B8A8_UNORM, + VK_FORMAT_R8G8B8A8_SRGB, + VK_FORMAT_R8G8B8A8_SNORM, + VK_FORMAT_R8G8B8A8_SSCALED, + VK_FORMAT_R8G8B8A8_USCALED, + }; + + VkExternalImageFormatProperties* ext_img_properties = + vk_find_struct<VkExternalImageFormatProperties>(pImageFormatProperties); + + if (ext_img_properties) { + if (std::find(std::begin(kExternalImageSupportedFormats), + std::end(kExternalImageSupportedFormats), + pImageFormatInfo->format) == std::end(kExternalImageSupportedFormats)) { + return VK_ERROR_FORMAT_NOT_SUPPORTED; + } + } +#endif + VkAndroidHardwareBufferUsageANDROID* output_ahw_usage = vk_find_struct<VkAndroidHardwareBufferUsageANDROID>(pImageFormatProperties); @@ -4663,48 +4934,39 @@ public: auto& info = it->second; - if (!info.lastUsedEncoderPtr) { - info.lastUsedEncoderPtr = new VkEncoder*; - *(info.lastUsedEncoderPtr) = currentEncoder; - } - - auto lastUsedEncoderPtr = info.lastUsedEncoderPtr; - - auto lastEncoder = *(lastUsedEncoderPtr); - - // We always make lastUsedEncoderPtr track - // the current encoder, even if the last encoder - // is null. - *(lastUsedEncoderPtr) = currentEncoder; + currentEncoder->incRef(); + auto lastEncoder = info.lastUsedEncoder; + info.lastUsedEncoder = currentEncoder; if (!lastEncoder) return 0; - if (lastEncoder == currentEncoder) return 0; - auto oldSeq = info.sequenceNumber; + bool lookupAgain = false; - lock.unlock(); + if (lastEncoder != currentEncoder) { + info.sequenceNumber += 2; + lookupAgain = true; + lock.unlock(); - lastEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, false, oldSeq + 1); - lastEncoder->flush(); - currentEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, true, oldSeq + 2); + lastEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, false, oldSeq + 1); + lastEncoder->flush(); - unregisterEncoderCleanupCallback(lastEncoder, commandBuffer); + currentEncoder->vkCommandBufferHostSyncGOOGLE(commandBuffer, true, oldSeq + 2); - registerEncoderCleanupCallback(currentEncoder, commandBuffer, [this, currentEncoder, commandBuffer]() { - AutoLock lock(mLock); - auto it = info_VkCommandBuffer.find(commandBuffer); - if (it == info_VkCommandBuffer.end()) return; - - auto& info = it->second; - if (!info.lastUsedEncoderPtr) return; - if (!*(info.lastUsedEncoderPtr)) return; + lock.lock(); + } - if (currentEncoder == *(info.lastUsedEncoderPtr)) { - *(info.lastUsedEncoderPtr) = nullptr; + if (lastEncoder->decRef()) { + if (lookupAgain) { + auto it2 = info_VkCommandBuffer.find(commandBuffer); + if (it2 == info_VkCommandBuffer.end()) return 0; + auto& info2 = it2->second; + info2.lastUsedEncoder = nullptr; + } else { + info.lastUsedEncoder = nullptr; } - }); + } - return 1; + return 0; } uint32_t syncEncodersForQueue(VkQueue queue, VkEncoder* currentEncoder) { @@ -4719,52 +4981,38 @@ public: auto& info = it->second; - if (!info.lastUsedEncoderPtr) { - info.lastUsedEncoderPtr = new VkEncoder*; - *(info.lastUsedEncoderPtr) = currentEncoder; - } - - auto lastUsedEncoderPtr = info.lastUsedEncoderPtr; - - auto lastEncoder = *(lastUsedEncoderPtr); - - // We always make lastUsedEncoderPtr track - // the current encoder, even if the last encoder - // is null. - *(lastUsedEncoderPtr) = currentEncoder; + currentEncoder->incRef(); + auto lastEncoder = info.lastUsedEncoder; + info.lastUsedEncoder = currentEncoder; if (!lastEncoder) return 0; - if (lastEncoder == currentEncoder) return 0; - auto oldSeq = info.sequenceNumber; + bool lookupAgain = false; - info.sequenceNumber += 2; - - lock.unlock(); - - // at this point the seqno for the old thread is determined - - lastEncoder->vkQueueHostSyncGOOGLE(queue, false, oldSeq + 1); - lastEncoder->flush(); - currentEncoder->vkQueueHostSyncGOOGLE(queue, true, oldSeq + 2); - - unregisterEncoderCleanupCallback(lastEncoder, queue); + if (lastEncoder != currentEncoder) { + info.sequenceNumber += 2; + lookupAgain = true; + lock.unlock(); - registerEncoderCleanupCallback(currentEncoder, queue, [this, currentEncoder, queue]() { - AutoLock lock(mLock); - auto it = info_VkQueue.find(queue); - if (it == info_VkQueue.end()) return; + lastEncoder->vkQueueHostSyncGOOGLE(queue, false, oldSeq + 1); + lastEncoder->flush(); + currentEncoder->vkQueueHostSyncGOOGLE(queue, true, oldSeq + 2); - auto& info = it->second; - if (!info.lastUsedEncoderPtr) return; - if (!*(info.lastUsedEncoderPtr)) return; + lock.lock(); + } - if (currentEncoder == *(info.lastUsedEncoderPtr)) { - *(info.lastUsedEncoderPtr) = nullptr; + if (lastEncoder->decRef()) { + if (lookupAgain) { + auto it2 = info_VkQueue.find(queue); + if (it2 == info_VkQueue.end()) return 0; + auto& info2 = it2->second; + info2.lastUsedEncoder = nullptr; + } else { + info.lastUsedEncoder = nullptr; } - }); + } - return 1; + return 0; } VkResult on_vkBeginCommandBuffer( @@ -4904,8 +5152,11 @@ private: #endif #ifdef VK_USE_PLATFORM_FUCHSIA - fuchsia::hardware::goldfish::ControlDeviceSyncPtr mControlDevice; - fuchsia::sysmem::AllocatorSyncPtr mSysmemAllocator; + std::unique_ptr< + llcpp::fuchsia::hardware::goldfish::ControlDevice::SyncClient> + mControlDevice; + std::unique_ptr<llcpp::fuchsia::sysmem::Allocator::SyncClient> + mSysmemAllocator; #endif WorkPool mWorkPool { 4 }; diff --git a/system/vulkan_enc/VkEncoder.cpp b/system/vulkan_enc/VkEncoder.cpp index 0eeba153..8f16a528 100644 --- a/system/vulkan_enc/VkEncoder.cpp +++ b/system/vulkan_enc/VkEncoder.cpp @@ -59,105 +59,7 @@ using android::base::guest::AutoLock; using android::base::guest::Lock; using android::base::Pool; -class VkEncoder::Impl { -public: - Impl(IOStream* stream) : m_stream(stream), m_logEncodes(false) { - const char* emuVkLogEncodesPropName = "qemu.vk.log"; - char encodeProp[PROPERTY_VALUE_MAX]; - if (property_get(emuVkLogEncodesPropName, encodeProp, nullptr) > 0) { - m_logEncodes = atoi(encodeProp) > 0; - } - } - - ~Impl() { } - - VulkanCountingStream* countingStream() { return &m_countingStream; } - VulkanStreamGuest* stream() { return &m_stream; } - Pool* pool() { return &m_pool; } - ResourceTracker* resources() { return ResourceTracker::get(); } - Validation* validation() { return &m_validation; } - - void log(const char* text) { - if (!m_logEncodes) return; - ALOGD("encoder log: %s", text); - } - - void flush() { - lock(); - m_stream.flush(); - unlock(); - } - - // can be recursive - void lock() { - if (this == sAcquiredEncoderThreadLocal) { - ++sAcquiredEncoderThreadLockLevels; - return; // recursive - } - while (mLock.test_and_set(std::memory_order_acquire)); - sAcquiredEncoderThreadLocal = this; - sAcquiredEncoderThreadLockLevels = 1; - } - - void unlock() { - if (this != sAcquiredEncoderThreadLocal) { - // error, trying to unlock without having locked first - return; - } - - --sAcquiredEncoderThreadLockLevels; - if (0 == sAcquiredEncoderThreadLockLevels) { - mLock.clear(std::memory_order_release); - sAcquiredEncoderThreadLocal = nullptr; - } - } - -private: - VulkanCountingStream m_countingStream; - VulkanStreamGuest m_stream; - Pool m_pool { 8, 4096, 64 }; - - Validation m_validation; - bool m_logEncodes; - std::atomic_flag mLock = ATOMIC_FLAG_INIT; - static thread_local Impl* sAcquiredEncoderThreadLocal; - static thread_local uint32_t sAcquiredEncoderThreadLockLevels; -}; - -VkEncoder::~VkEncoder() { - auto rt = ResourceTracker::get(); - if (!rt) return; - rt->onEncoderDeleted(this); -} - -// static -thread_local VkEncoder::Impl* VkEncoder::Impl::sAcquiredEncoderThreadLocal = nullptr; -thread_local uint32_t VkEncoder::Impl::sAcquiredEncoderThreadLockLevels = 0; - -struct EncoderAutoLock { - EncoderAutoLock(VkEncoder* enc) : mEnc(enc) { - mEnc->lock(); - } - ~EncoderAutoLock() { - mEnc->unlock(); - } - VkEncoder* mEnc; -}; - -VkEncoder::VkEncoder(IOStream *stream) : - mImpl(new VkEncoder::Impl(stream)) { } - -void VkEncoder::flush() { - mImpl->flush(); -} - -void VkEncoder::lock() { - mImpl->lock(); -} - -void VkEncoder::unlock() { - mImpl->unlock(); -} +#include "VkEncoder.cpp.inl" #define VALIDATE_RET(retType, success, validate) \ retType goldfish_vk_validateResult = validate; \ @@ -174,7 +76,6 @@ VkResult VkEncoder::vkCreateInstance( VkInstance* pInstance) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateInstance encode"); mImpl->log("start vkCreateInstance"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -236,13 +137,11 @@ VkResult VkEncoder::vkCreateInstance( stream->handleMapping()->mapHandles_VkInstance_u64(pInstance, &cgen_var_3, 1); stream->write((uint64_t*)&cgen_var_3, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateInstance readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_4; stream->read((uint64_t*)&cgen_var_4, 8); stream->handleMapping()->mapHandles_u64_VkInstance(&cgen_var_4, (VkInstance*)pInstance, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateInstance returnUnmarshal"); VkResult vkCreateInstance_VkResult_return = (VkResult)0; stream->read(&vkCreateInstance_VkResult_return, sizeof(VkResult)); mImpl->resources()->on_vkCreateInstance(this, vkCreateInstance_VkResult_return, pCreateInfo, pAllocator, pInstance); @@ -258,7 +157,6 @@ void VkEncoder::vkDestroyInstance( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyInstance encode"); mImpl->log("start vkDestroyInstance"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -307,8 +205,6 @@ void VkEncoder::vkDestroyInstance( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyInstance readParams"); - AEMU_SCOPED_TRACE("vkDestroyInstance returnUnmarshal"); resources->destroyMapping()->mapHandles_VkInstance((VkInstance*)&instance); pool->freeAll(); countingStream->clearPool(); @@ -322,7 +218,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDevices( VkPhysicalDevice* pPhysicalDevices) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices encode"); mImpl->log("start vkEnumeratePhysicalDevices"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -387,7 +282,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDevices( } } stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices readParams"); // WARNING PTR CHECK uint32_t* check_pPhysicalDeviceCount; check_pPhysicalDeviceCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -418,7 +312,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDevices( } } stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices returnUnmarshal"); VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0; stream->read(&vkEnumeratePhysicalDevices_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -433,7 +326,6 @@ void VkEncoder::vkGetPhysicalDeviceFeatures( VkPhysicalDeviceFeatures* pFeatures) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures encode"); mImpl->log("start vkGetPhysicalDeviceFeatures"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -458,13 +350,11 @@ void VkEncoder::vkGetPhysicalDeviceFeatures( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_21, 1); stream->write((uint64_t*)&cgen_var_21, 1 * 8); marshal_VkPhysicalDeviceFeatures(stream, (VkPhysicalDeviceFeatures*)(pFeatures)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures readParams"); unmarshal_VkPhysicalDeviceFeatures(stream, (VkPhysicalDeviceFeatures*)(pFeatures)); if (pFeatures) { transform_fromhost_VkPhysicalDeviceFeatures(mImpl->resources(), (VkPhysicalDeviceFeatures*)(pFeatures)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -477,7 +367,6 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties( VkFormatProperties* pFormatProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties encode"); mImpl->log("start vkGetPhysicalDeviceFormatProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -506,13 +395,11 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties( stream->write((uint64_t*)&cgen_var_23, 1 * 8); stream->write((VkFormat*)&local_format, sizeof(VkFormat)); marshal_VkFormatProperties(stream, (VkFormatProperties*)(pFormatProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties readParams"); unmarshal_VkFormatProperties(stream, (VkFormatProperties*)(pFormatProperties)); if (pFormatProperties) { transform_fromhost_VkFormatProperties(mImpl->resources(), (VkFormatProperties*)(pFormatProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -529,7 +416,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties( VkImageFormatProperties* pImageFormatProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties encode"); mImpl->log("start vkGetPhysicalDeviceImageFormatProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -574,13 +460,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties( stream->write((VkImageUsageFlags*)&local_usage, sizeof(VkImageUsageFlags)); stream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags)); marshal_VkImageFormatProperties(stream, (VkImageFormatProperties*)(pImageFormatProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties readParams"); unmarshal_VkImageFormatProperties(stream, (VkImageFormatProperties*)(pImageFormatProperties)); if (pImageFormatProperties) { transform_fromhost_VkImageFormatProperties(mImpl->resources(), (VkImageFormatProperties*)(pImageFormatProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties returnUnmarshal"); VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceImageFormatProperties_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -595,7 +479,6 @@ void VkEncoder::vkGetPhysicalDeviceProperties( VkPhysicalDeviceProperties* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties encode"); mImpl->log("start vkGetPhysicalDeviceProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -620,13 +503,11 @@ void VkEncoder::vkGetPhysicalDeviceProperties( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_27, 1); stream->write((uint64_t*)&cgen_var_27, 1 * 8); marshal_VkPhysicalDeviceProperties(stream, (VkPhysicalDeviceProperties*)(pProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties readParams"); unmarshal_VkPhysicalDeviceProperties(stream, (VkPhysicalDeviceProperties*)(pProperties)); if (pProperties) { transform_fromhost_VkPhysicalDeviceProperties(mImpl->resources(), (VkPhysicalDeviceProperties*)(pProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties returnUnmarshal"); mImpl->resources()->on_vkGetPhysicalDeviceProperties(this, physicalDevice, pProperties); pool->freeAll(); countingStream->clearPool(); @@ -640,7 +521,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties( VkQueueFamilyProperties* pQueueFamilyProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties encode"); mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -697,7 +577,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties( marshal_VkQueueFamilyProperties(stream, (VkQueueFamilyProperties*)(pQueueFamilyProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties readParams"); // WARNING PTR CHECK uint32_t* check_pQueueFamilyPropertyCount; check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -730,7 +609,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties( transform_fromhost_VkQueueFamilyProperties(mImpl->resources(), (VkQueueFamilyProperties*)(pQueueFamilyProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -742,7 +620,6 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties* pMemoryProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties encode"); mImpl->log("start vkGetPhysicalDeviceMemoryProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -767,13 +644,11 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_37, 1); stream->write((uint64_t*)&cgen_var_37, 1 * 8); marshal_VkPhysicalDeviceMemoryProperties(stream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties readParams"); unmarshal_VkPhysicalDeviceMemoryProperties(stream, (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties)); if (pMemoryProperties) { transform_fromhost_VkPhysicalDeviceMemoryProperties(mImpl->resources(), (VkPhysicalDeviceMemoryProperties*)(pMemoryProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties returnUnmarshal"); mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties(this, physicalDevice, pMemoryProperties); pool->freeAll(); countingStream->clearPool(); @@ -786,7 +661,6 @@ PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr( const char* pName) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetInstanceProcAddr encode"); mImpl->log("start vkGetInstanceProcAddr"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -817,8 +691,6 @@ PFN_vkVoidFunction VkEncoder::vkGetInstanceProcAddr( stream->handleMapping()->mapHandles_VkInstance_u64(&local_instance, &cgen_var_39, 1); stream->write((uint64_t*)&cgen_var_39, 1 * 8); stream->putString(local_pName); - AEMU_SCOPED_TRACE("vkGetInstanceProcAddr readParams"); - AEMU_SCOPED_TRACE("vkGetInstanceProcAddr returnUnmarshal"); PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0; stream->read(&vkGetInstanceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction)); pool->freeAll(); @@ -833,7 +705,6 @@ PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr( const char* pName) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDeviceProcAddr encode"); mImpl->log("start vkGetDeviceProcAddr"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -864,8 +735,6 @@ PFN_vkVoidFunction VkEncoder::vkGetDeviceProcAddr( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_41, 1); stream->write((uint64_t*)&cgen_var_41, 1 * 8); stream->putString(local_pName); - AEMU_SCOPED_TRACE("vkGetDeviceProcAddr readParams"); - AEMU_SCOPED_TRACE("vkGetDeviceProcAddr returnUnmarshal"); PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0; stream->read(&vkGetDeviceProcAddr_PFN_vkVoidFunction_return, sizeof(PFN_vkVoidFunction)); pool->freeAll(); @@ -882,7 +751,6 @@ VkResult VkEncoder::vkCreateDevice( VkDevice* pDevice) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateDevice encode"); mImpl->log("start vkCreateDevice"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -952,13 +820,11 @@ VkResult VkEncoder::vkCreateDevice( stream->handleMapping()->mapHandles_VkDevice_u64(pDevice, &cgen_var_47, 1); stream->write((uint64_t*)&cgen_var_47, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateDevice readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_48; stream->read((uint64_t*)&cgen_var_48, 8); stream->handleMapping()->mapHandles_u64_VkDevice(&cgen_var_48, (VkDevice*)pDevice, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateDevice returnUnmarshal"); VkResult vkCreateDevice_VkResult_return = (VkResult)0; stream->read(&vkCreateDevice_VkResult_return, sizeof(VkResult)); mImpl->resources()->on_vkCreateDevice(this, vkCreateDevice_VkResult_return, physicalDevice, pCreateInfo, pAllocator, pDevice); @@ -974,7 +840,6 @@ void VkEncoder::vkDestroyDevice( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyDevice encode"); mImpl->log("start vkDestroyDevice"); mImpl->resources()->on_vkDestroyDevice_pre(this, device, pAllocator); auto stream = mImpl->stream(); @@ -1024,8 +889,6 @@ void VkEncoder::vkDestroyDevice( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyDevice readParams"); - AEMU_SCOPED_TRACE("vkDestroyDevice returnUnmarshal"); resources->destroyMapping()->mapHandles_VkDevice((VkDevice*)&device); stream->flush(); pool->freeAll(); @@ -1040,7 +903,6 @@ VkResult VkEncoder::vkEnumerateInstanceExtensionProperties( VkExtensionProperties* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties encode"); mImpl->log("start vkEnumerateInstanceExtensionProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1123,7 +985,6 @@ VkResult VkEncoder::vkEnumerateInstanceExtensionProperties( marshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -1156,7 +1017,6 @@ VkResult VkEncoder::vkEnumerateInstanceExtensionProperties( transform_fromhost_VkExtensionProperties(mImpl->resources(), (VkExtensionProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties returnUnmarshal"); VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0; stream->read(&vkEnumerateInstanceExtensionProperties_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -1173,7 +1033,6 @@ VkResult VkEncoder::vkEnumerateDeviceExtensionProperties( VkExtensionProperties* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties encode"); mImpl->log("start vkEnumerateDeviceExtensionProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1264,7 +1123,6 @@ VkResult VkEncoder::vkEnumerateDeviceExtensionProperties( marshal_VkExtensionProperties(stream, (VkExtensionProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -1297,7 +1155,6 @@ VkResult VkEncoder::vkEnumerateDeviceExtensionProperties( transform_fromhost_VkExtensionProperties(mImpl->resources(), (VkExtensionProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties returnUnmarshal"); VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0; stream->read(&vkEnumerateDeviceExtensionProperties_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -1312,7 +1169,6 @@ VkResult VkEncoder::vkEnumerateInstanceLayerProperties( VkLayerProperties* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties encode"); mImpl->log("start vkEnumerateInstanceLayerProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1361,7 +1217,6 @@ VkResult VkEncoder::vkEnumerateInstanceLayerProperties( marshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -1394,7 +1249,6 @@ VkResult VkEncoder::vkEnumerateInstanceLayerProperties( transform_fromhost_VkLayerProperties(mImpl->resources(), (VkLayerProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties returnUnmarshal"); VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0; stream->read(&vkEnumerateInstanceLayerProperties_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -1410,7 +1264,6 @@ VkResult VkEncoder::vkEnumerateDeviceLayerProperties( VkLayerProperties* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties encode"); mImpl->log("start vkEnumerateDeviceLayerProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1467,7 +1320,6 @@ VkResult VkEncoder::vkEnumerateDeviceLayerProperties( marshal_VkLayerProperties(stream, (VkLayerProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -1500,7 +1352,6 @@ VkResult VkEncoder::vkEnumerateDeviceLayerProperties( transform_fromhost_VkLayerProperties(mImpl->resources(), (VkLayerProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties returnUnmarshal"); VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0; stream->read(&vkEnumerateDeviceLayerProperties_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -1517,7 +1368,6 @@ void VkEncoder::vkGetDeviceQueue( VkQueue* pQueue) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDeviceQueue encode"); mImpl->log("start vkGetDeviceQueue"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1556,13 +1406,11 @@ void VkEncoder::vkGetDeviceQueue( stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_88, 1); stream->write((uint64_t*)&cgen_var_88, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkGetDeviceQueue readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_89; stream->read((uint64_t*)&cgen_var_89, 8); stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_89, (VkQueue*)pQueue, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkGetDeviceQueue returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -1576,7 +1424,6 @@ VkResult VkEncoder::vkQueueSubmit( VkFence fence) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueSubmit encode"); mImpl->log("start vkQueueSubmit"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1636,8 +1483,6 @@ VkResult VkEncoder::vkQueueSubmit( uint64_t cgen_var_93; stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_93, 1); stream->write((uint64_t*)&cgen_var_93, 1 * 8); - AEMU_SCOPED_TRACE("vkQueueSubmit readParams"); - AEMU_SCOPED_TRACE("vkQueueSubmit returnUnmarshal"); VkResult vkQueueSubmit_VkResult_return = (VkResult)0; stream->read(&vkQueueSubmit_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -1651,7 +1496,6 @@ VkResult VkEncoder::vkQueueWaitIdle( VkQueue queue) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueWaitIdle encode"); mImpl->log("start vkQueueWaitIdle"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1674,8 +1518,6 @@ VkResult VkEncoder::vkQueueWaitIdle( uint64_t cgen_var_95; stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_95, 1); stream->write((uint64_t*)&cgen_var_95, 1 * 8); - AEMU_SCOPED_TRACE("vkQueueWaitIdle readParams"); - AEMU_SCOPED_TRACE("vkQueueWaitIdle returnUnmarshal"); VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0; stream->read(&vkQueueWaitIdle_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -1689,7 +1531,6 @@ VkResult VkEncoder::vkDeviceWaitIdle( VkDevice device) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDeviceWaitIdle encode"); mImpl->log("start vkDeviceWaitIdle"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1712,8 +1553,6 @@ VkResult VkEncoder::vkDeviceWaitIdle( uint64_t cgen_var_97; stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_97, 1); stream->write((uint64_t*)&cgen_var_97, 1 * 8); - AEMU_SCOPED_TRACE("vkDeviceWaitIdle readParams"); - AEMU_SCOPED_TRACE("vkDeviceWaitIdle returnUnmarshal"); VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0; stream->read(&vkDeviceWaitIdle_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -1730,7 +1569,6 @@ VkResult VkEncoder::vkAllocateMemory( VkDeviceMemory* pMemory) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkAllocateMemory encode"); mImpl->log("start vkAllocateMemory"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1800,13 +1638,11 @@ VkResult VkEncoder::vkAllocateMemory( stream->handleMapping()->mapHandles_VkDeviceMemory_u64(pMemory, &cgen_var_103, 1); stream->write((uint64_t*)&cgen_var_103, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkAllocateMemory readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_104; stream->read((uint64_t*)&cgen_var_104, 8); stream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_104, (VkDeviceMemory*)pMemory, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkAllocateMemory returnUnmarshal"); VkResult vkAllocateMemory_VkResult_return = (VkResult)0; stream->read(&vkAllocateMemory_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -1822,7 +1658,6 @@ void VkEncoder::vkFreeMemory( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkFreeMemory encode"); mImpl->log("start vkFreeMemory"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -1876,8 +1711,6 @@ void VkEncoder::vkFreeMemory( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkFreeMemory readParams"); - AEMU_SCOPED_TRACE("vkFreeMemory returnUnmarshal"); resources->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory); pool->freeAll(); countingStream->clearPool(); @@ -1893,7 +1726,6 @@ VkResult VkEncoder::vkMapMemory( VkMemoryMapFlags flags, void** ppData) { - AEMU_SCOPED_TRACE("vkMapMemory resourceEvent"); VkResult vkMapMemory_VkResult_return = (VkResult)0; vkMapMemory_VkResult_return = mImpl->resources()->on_vkMapMemory(this, VK_SUCCESS, device, memory, offset, size, flags, ppData); mImpl->log("finish vkMapMemory");; @@ -1904,7 +1736,6 @@ void VkEncoder::vkUnmapMemory( VkDevice device, VkDeviceMemory memory) { - AEMU_SCOPED_TRACE("vkUnmapMemory resourceEvent"); mImpl->resources()->on_vkUnmapMemory(this, device, memory); } @@ -1914,7 +1745,6 @@ VkResult VkEncoder::vkFlushMappedMemoryRanges( const VkMappedMemoryRange* pMemoryRanges) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges encode"); mImpl->log("start vkFlushMappedMemoryRanges"); VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkFlushMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges)); auto stream = mImpl->stream(); @@ -2005,8 +1835,6 @@ VkResult VkEncoder::vkFlushMappedMemoryRanges( stream->write(targetRange, actualSize); } } - AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges readParams"); - AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges returnUnmarshal"); VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0; stream->read(&vkFlushMappedMemoryRanges_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -2022,7 +1850,6 @@ VkResult VkEncoder::vkInvalidateMappedMemoryRanges( const VkMappedMemoryRange* pMemoryRanges) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges encode"); mImpl->log("start vkInvalidateMappedMemoryRanges"); VALIDATE_RET(VkResult, VK_SUCCESS, mImpl->validation()->on_vkInvalidateMappedMemoryRanges(this, VK_SUCCESS, device, memoryRangeCount, pMemoryRanges)); auto stream = mImpl->stream(); @@ -2075,8 +1902,6 @@ VkResult VkEncoder::vkInvalidateMappedMemoryRanges( { marshal_VkMappedMemoryRange(stream, (VkMappedMemoryRange*)(local_pMemoryRanges + i)); } - AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges readParams"); - AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges returnUnmarshal"); VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0; stream->read(&vkInvalidateMappedMemoryRanges_VkResult_return, sizeof(VkResult)); if (!resources->usingDirectMapping()) @@ -2111,7 +1936,6 @@ void VkEncoder::vkGetDeviceMemoryCommitment( VkDeviceSize* pCommittedMemoryInBytes) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment encode"); mImpl->log("start vkGetDeviceMemoryCommitment"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2145,9 +1969,7 @@ void VkEncoder::vkGetDeviceMemoryCommitment( stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_118, 1); stream->write((uint64_t*)&cgen_var_118, 1 * 8); stream->write((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize)); - AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment readParams"); stream->read((VkDeviceSize*)pCommittedMemoryInBytes, sizeof(VkDeviceSize)); - AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -2161,7 +1983,6 @@ VkResult VkEncoder::vkBindBufferMemory( VkDeviceSize memoryOffset) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkBindBufferMemory encode"); mImpl->log("start vkBindBufferMemory"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2205,8 +2026,6 @@ VkResult VkEncoder::vkBindBufferMemory( stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_124, 1); stream->write((uint64_t*)&cgen_var_124, 1 * 8); stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize)); - AEMU_SCOPED_TRACE("vkBindBufferMemory readParams"); - AEMU_SCOPED_TRACE("vkBindBufferMemory returnUnmarshal"); VkResult vkBindBufferMemory_VkResult_return = (VkResult)0; stream->read(&vkBindBufferMemory_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -2223,7 +2042,6 @@ VkResult VkEncoder::vkBindImageMemory( VkDeviceSize memoryOffset) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkBindImageMemory encode"); mImpl->log("start vkBindImageMemory"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2267,8 +2085,6 @@ VkResult VkEncoder::vkBindImageMemory( stream->handleMapping()->mapHandles_VkDeviceMemory_u64(&local_memory, &cgen_var_130, 1); stream->write((uint64_t*)&cgen_var_130, 1 * 8); stream->write((VkDeviceSize*)&local_memoryOffset, sizeof(VkDeviceSize)); - AEMU_SCOPED_TRACE("vkBindImageMemory readParams"); - AEMU_SCOPED_TRACE("vkBindImageMemory returnUnmarshal"); VkResult vkBindImageMemory_VkResult_return = (VkResult)0; stream->read(&vkBindImageMemory_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -2284,7 +2100,6 @@ void VkEncoder::vkGetBufferMemoryRequirements( VkMemoryRequirements* pMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements encode"); mImpl->log("start vkGetBufferMemoryRequirements"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2317,13 +2132,11 @@ void VkEncoder::vkGetBufferMemoryRequirements( stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_134, 1); stream->write((uint64_t*)&cgen_var_134, 1 * 8); marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements)); - AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements readParams"); unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements)); if (pMemoryRequirements) { transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements)); } - AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -2336,7 +2149,6 @@ void VkEncoder::vkGetImageMemoryRequirements( VkMemoryRequirements* pMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements encode"); mImpl->log("start vkGetImageMemoryRequirements"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2369,13 +2181,11 @@ void VkEncoder::vkGetImageMemoryRequirements( stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_138, 1); stream->write((uint64_t*)&cgen_var_138, 1 * 8); marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements)); - AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements readParams"); unmarshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements)); if (pMemoryRequirements) { transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements)); } - AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -2389,7 +2199,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements( VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements encode"); mImpl->log("start vkGetImageSparseMemoryRequirements"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2454,7 +2263,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements( marshal_VkSparseImageMemoryRequirements(stream, (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i)); } } - AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements readParams"); // WARNING PTR CHECK uint32_t* check_pSparseMemoryRequirementCount; check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -2487,7 +2295,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements( transform_fromhost_VkSparseImageMemoryRequirements(mImpl->resources(), (VkSparseImageMemoryRequirements*)(pSparseMemoryRequirements + i)); } } - AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -2505,7 +2312,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties( VkSparseImageFormatProperties* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties encode"); mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2582,7 +2388,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties( marshal_VkSparseImageFormatProperties(stream, (VkSparseImageFormatProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -2615,7 +2420,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties( transform_fromhost_VkSparseImageFormatProperties(mImpl->resources(), (VkSparseImageFormatProperties*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -2629,7 +2433,6 @@ VkResult VkEncoder::vkQueueBindSparse( VkFence fence) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueBindSparse encode"); mImpl->log("start vkQueueBindSparse"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2689,8 +2492,6 @@ VkResult VkEncoder::vkQueueBindSparse( uint64_t cgen_var_160; stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_160, 1); stream->write((uint64_t*)&cgen_var_160, 1 * 8); - AEMU_SCOPED_TRACE("vkQueueBindSparse readParams"); - AEMU_SCOPED_TRACE("vkQueueBindSparse returnUnmarshal"); VkResult vkQueueBindSparse_VkResult_return = (VkResult)0; stream->read(&vkQueueBindSparse_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -2707,7 +2508,6 @@ VkResult VkEncoder::vkCreateFence( VkFence* pFence) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateFence encode"); mImpl->log("start vkCreateFence"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2777,13 +2577,11 @@ VkResult VkEncoder::vkCreateFence( stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_166, 1); stream->write((uint64_t*)&cgen_var_166, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateFence readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_167; stream->read((uint64_t*)&cgen_var_167, 8); stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_167, (VkFence*)pFence, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateFence returnUnmarshal"); VkResult vkCreateFence_VkResult_return = (VkResult)0; stream->read(&vkCreateFence_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -2799,7 +2597,6 @@ void VkEncoder::vkDestroyFence( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyFence encode"); mImpl->log("start vkDestroyFence"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2856,8 +2653,6 @@ void VkEncoder::vkDestroyFence( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyFence readParams"); - AEMU_SCOPED_TRACE("vkDestroyFence returnUnmarshal"); resources->destroyMapping()->mapHandles_VkFence((VkFence*)&fence); pool->freeAll(); countingStream->clearPool(); @@ -2871,7 +2666,6 @@ VkResult VkEncoder::vkResetFences( const VkFence* pFences) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkResetFences encode"); mImpl->log("start vkResetFences"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2918,8 +2712,6 @@ VkResult VkEncoder::vkResetFences( stream->handleMapping()->mapHandles_VkFence_u64(local_pFences, cgen_var_177, ((fenceCount))); stream->write((uint64_t*)cgen_var_177, ((fenceCount)) * 8); } - AEMU_SCOPED_TRACE("vkResetFences readParams"); - AEMU_SCOPED_TRACE("vkResetFences returnUnmarshal"); VkResult vkResetFences_VkResult_return = (VkResult)0; stream->read(&vkResetFences_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -2934,7 +2726,6 @@ VkResult VkEncoder::vkGetFenceStatus( VkFence fence) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetFenceStatus encode"); mImpl->log("start vkGetFenceStatus"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -2965,8 +2756,6 @@ VkResult VkEncoder::vkGetFenceStatus( uint64_t cgen_var_181; stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_181, 1); stream->write((uint64_t*)&cgen_var_181, 1 * 8); - AEMU_SCOPED_TRACE("vkGetFenceStatus readParams"); - AEMU_SCOPED_TRACE("vkGetFenceStatus returnUnmarshal"); VkResult vkGetFenceStatus_VkResult_return = (VkResult)0; stream->read(&vkGetFenceStatus_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -2984,7 +2773,6 @@ VkResult VkEncoder::vkWaitForFences( uint64_t timeout) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkWaitForFences encode"); mImpl->log("start vkWaitForFences"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3039,8 +2827,6 @@ VkResult VkEncoder::vkWaitForFences( } stream->write((VkBool32*)&local_waitAll, sizeof(VkBool32)); stream->write((uint64_t*)&local_timeout, sizeof(uint64_t)); - AEMU_SCOPED_TRACE("vkWaitForFences readParams"); - AEMU_SCOPED_TRACE("vkWaitForFences returnUnmarshal"); VkResult vkWaitForFences_VkResult_return = (VkResult)0; stream->read(&vkWaitForFences_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -3057,7 +2843,6 @@ VkResult VkEncoder::vkCreateSemaphore( VkSemaphore* pSemaphore) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateSemaphore encode"); mImpl->log("start vkCreateSemaphore"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3127,13 +2912,11 @@ VkResult VkEncoder::vkCreateSemaphore( stream->handleMapping()->mapHandles_VkSemaphore_u64(pSemaphore, &cgen_var_191, 1); stream->write((uint64_t*)&cgen_var_191, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateSemaphore readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_192; stream->read((uint64_t*)&cgen_var_192, 8); stream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_192, (VkSemaphore*)pSemaphore, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateSemaphore returnUnmarshal"); VkResult vkCreateSemaphore_VkResult_return = (VkResult)0; stream->read(&vkCreateSemaphore_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -3149,7 +2932,6 @@ void VkEncoder::vkDestroySemaphore( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroySemaphore encode"); mImpl->log("start vkDestroySemaphore"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3206,8 +2988,6 @@ void VkEncoder::vkDestroySemaphore( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroySemaphore readParams"); - AEMU_SCOPED_TRACE("vkDestroySemaphore returnUnmarshal"); resources->destroyMapping()->mapHandles_VkSemaphore((VkSemaphore*)&semaphore); pool->freeAll(); countingStream->clearPool(); @@ -3222,7 +3002,6 @@ VkResult VkEncoder::vkCreateEvent( VkEvent* pEvent) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateEvent encode"); mImpl->log("start vkCreateEvent"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3292,13 +3071,11 @@ VkResult VkEncoder::vkCreateEvent( stream->handleMapping()->mapHandles_VkEvent_u64(pEvent, &cgen_var_204, 1); stream->write((uint64_t*)&cgen_var_204, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateEvent readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_205; stream->read((uint64_t*)&cgen_var_205, 8); stream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_205, (VkEvent*)pEvent, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateEvent returnUnmarshal"); VkResult vkCreateEvent_VkResult_return = (VkResult)0; stream->read(&vkCreateEvent_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -3314,7 +3091,6 @@ void VkEncoder::vkDestroyEvent( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyEvent encode"); mImpl->log("start vkDestroyEvent"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3371,8 +3147,6 @@ void VkEncoder::vkDestroyEvent( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyEvent readParams"); - AEMU_SCOPED_TRACE("vkDestroyEvent returnUnmarshal"); resources->destroyMapping()->mapHandles_VkEvent((VkEvent*)&event); pool->freeAll(); countingStream->clearPool(); @@ -3385,7 +3159,6 @@ VkResult VkEncoder::vkGetEventStatus( VkEvent event) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetEventStatus encode"); mImpl->log("start vkGetEventStatus"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3416,8 +3189,6 @@ VkResult VkEncoder::vkGetEventStatus( uint64_t cgen_var_215; stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_215, 1); stream->write((uint64_t*)&cgen_var_215, 1 * 8); - AEMU_SCOPED_TRACE("vkGetEventStatus readParams"); - AEMU_SCOPED_TRACE("vkGetEventStatus returnUnmarshal"); VkResult vkGetEventStatus_VkResult_return = (VkResult)0; stream->read(&vkGetEventStatus_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -3432,7 +3203,6 @@ VkResult VkEncoder::vkSetEvent( VkEvent event) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkSetEvent encode"); mImpl->log("start vkSetEvent"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3463,8 +3233,6 @@ VkResult VkEncoder::vkSetEvent( uint64_t cgen_var_219; stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_219, 1); stream->write((uint64_t*)&cgen_var_219, 1 * 8); - AEMU_SCOPED_TRACE("vkSetEvent readParams"); - AEMU_SCOPED_TRACE("vkSetEvent returnUnmarshal"); VkResult vkSetEvent_VkResult_return = (VkResult)0; stream->read(&vkSetEvent_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -3479,7 +3247,6 @@ VkResult VkEncoder::vkResetEvent( VkEvent event) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkResetEvent encode"); mImpl->log("start vkResetEvent"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3510,8 +3277,6 @@ VkResult VkEncoder::vkResetEvent( uint64_t cgen_var_223; stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_223, 1); stream->write((uint64_t*)&cgen_var_223, 1 * 8); - AEMU_SCOPED_TRACE("vkResetEvent readParams"); - AEMU_SCOPED_TRACE("vkResetEvent returnUnmarshal"); VkResult vkResetEvent_VkResult_return = (VkResult)0; stream->read(&vkResetEvent_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -3528,7 +3293,6 @@ VkResult VkEncoder::vkCreateQueryPool( VkQueryPool* pQueryPool) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateQueryPool encode"); mImpl->log("start vkCreateQueryPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3598,13 +3362,11 @@ VkResult VkEncoder::vkCreateQueryPool( stream->handleMapping()->mapHandles_VkQueryPool_u64(pQueryPool, &cgen_var_229, 1); stream->write((uint64_t*)&cgen_var_229, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateQueryPool readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_230; stream->read((uint64_t*)&cgen_var_230, 8); stream->handleMapping()->mapHandles_u64_VkQueryPool(&cgen_var_230, (VkQueryPool*)pQueryPool, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateQueryPool returnUnmarshal"); VkResult vkCreateQueryPool_VkResult_return = (VkResult)0; stream->read(&vkCreateQueryPool_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -3620,7 +3382,6 @@ void VkEncoder::vkDestroyQueryPool( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyQueryPool encode"); mImpl->log("start vkDestroyQueryPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3677,8 +3438,6 @@ void VkEncoder::vkDestroyQueryPool( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyQueryPool readParams"); - AEMU_SCOPED_TRACE("vkDestroyQueryPool returnUnmarshal"); resources->destroyMapping()->mapHandles_VkQueryPool((VkQueryPool*)&queryPool); pool->freeAll(); countingStream->clearPool(); @@ -3697,7 +3456,6 @@ VkResult VkEncoder::vkGetQueryPoolResults( VkQueryResultFlags flags) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetQueryPoolResults encode"); mImpl->log("start vkGetQueryPoolResults"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3752,9 +3510,7 @@ VkResult VkEncoder::vkGetQueryPoolResults( stream->write((void*)pData, ((dataSize)) * sizeof(uint8_t)); stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize)); stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags)); - AEMU_SCOPED_TRACE("vkGetQueryPoolResults readParams"); stream->read((void*)pData, ((dataSize)) * sizeof(uint8_t)); - AEMU_SCOPED_TRACE("vkGetQueryPoolResults returnUnmarshal"); VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0; stream->read(&vkGetQueryPoolResults_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -3771,7 +3527,6 @@ VkResult VkEncoder::vkCreateBuffer( VkBuffer* pBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateBuffer encode"); mImpl->log("start vkCreateBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3841,13 +3596,11 @@ VkResult VkEncoder::vkCreateBuffer( stream->handleMapping()->mapHandles_VkBuffer_u64(pBuffer, &cgen_var_248, 1); stream->write((uint64_t*)&cgen_var_248, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateBuffer readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_249; stream->read((uint64_t*)&cgen_var_249, 8); stream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_249, (VkBuffer*)pBuffer, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateBuffer returnUnmarshal"); VkResult vkCreateBuffer_VkResult_return = (VkResult)0; stream->read(&vkCreateBuffer_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -3863,7 +3616,6 @@ void VkEncoder::vkDestroyBuffer( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyBuffer encode"); mImpl->log("start vkDestroyBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -3920,8 +3672,6 @@ void VkEncoder::vkDestroyBuffer( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyBuffer readParams"); - AEMU_SCOPED_TRACE("vkDestroyBuffer returnUnmarshal"); resources->destroyMapping()->mapHandles_VkBuffer((VkBuffer*)&buffer); pool->freeAll(); countingStream->clearPool(); @@ -3936,7 +3686,6 @@ VkResult VkEncoder::vkCreateBufferView( VkBufferView* pView) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateBufferView encode"); mImpl->log("start vkCreateBufferView"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4006,13 +3755,11 @@ VkResult VkEncoder::vkCreateBufferView( stream->handleMapping()->mapHandles_VkBufferView_u64(pView, &cgen_var_261, 1); stream->write((uint64_t*)&cgen_var_261, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateBufferView readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_262; stream->read((uint64_t*)&cgen_var_262, 8); stream->handleMapping()->mapHandles_u64_VkBufferView(&cgen_var_262, (VkBufferView*)pView, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateBufferView returnUnmarshal"); VkResult vkCreateBufferView_VkResult_return = (VkResult)0; stream->read(&vkCreateBufferView_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -4028,7 +3775,6 @@ void VkEncoder::vkDestroyBufferView( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyBufferView encode"); mImpl->log("start vkDestroyBufferView"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4085,8 +3831,6 @@ void VkEncoder::vkDestroyBufferView( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyBufferView readParams"); - AEMU_SCOPED_TRACE("vkDestroyBufferView returnUnmarshal"); resources->destroyMapping()->mapHandles_VkBufferView((VkBufferView*)&bufferView); pool->freeAll(); countingStream->clearPool(); @@ -4101,7 +3845,6 @@ VkResult VkEncoder::vkCreateImage( VkImage* pImage) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateImage encode"); mImpl->log("start vkCreateImage"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4172,13 +3915,11 @@ VkResult VkEncoder::vkCreateImage( stream->handleMapping()->mapHandles_VkImage_u64(pImage, &cgen_var_274, 1); stream->write((uint64_t*)&cgen_var_274, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateImage readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_275; stream->read((uint64_t*)&cgen_var_275, 8); stream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_275, (VkImage*)pImage, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateImage returnUnmarshal"); VkResult vkCreateImage_VkResult_return = (VkResult)0; stream->read(&vkCreateImage_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -4194,7 +3935,6 @@ void VkEncoder::vkDestroyImage( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyImage encode"); mImpl->log("start vkDestroyImage"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4251,8 +3991,6 @@ void VkEncoder::vkDestroyImage( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyImage readParams"); - AEMU_SCOPED_TRACE("vkDestroyImage returnUnmarshal"); resources->destroyMapping()->mapHandles_VkImage((VkImage*)&image); pool->freeAll(); countingStream->clearPool(); @@ -4267,7 +4005,6 @@ void VkEncoder::vkGetImageSubresourceLayout( VkSubresourceLayout* pLayout) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout encode"); mImpl->log("start vkGetImageSubresourceLayout"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4313,13 +4050,11 @@ void VkEncoder::vkGetImageSubresourceLayout( stream->write((uint64_t*)&cgen_var_285, 1 * 8); marshal_VkImageSubresource(stream, (VkImageSubresource*)(local_pSubresource)); marshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout)); - AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout readParams"); unmarshal_VkSubresourceLayout(stream, (VkSubresourceLayout*)(pLayout)); if (pLayout) { transform_fromhost_VkSubresourceLayout(mImpl->resources(), (VkSubresourceLayout*)(pLayout)); } - AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -4333,7 +4068,6 @@ VkResult VkEncoder::vkCreateImageView( VkImageView* pView) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateImageView encode"); mImpl->log("start vkCreateImageView"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4403,13 +4137,11 @@ VkResult VkEncoder::vkCreateImageView( stream->handleMapping()->mapHandles_VkImageView_u64(pView, &cgen_var_291, 1); stream->write((uint64_t*)&cgen_var_291, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateImageView readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_292; stream->read((uint64_t*)&cgen_var_292, 8); stream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_292, (VkImageView*)pView, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateImageView returnUnmarshal"); VkResult vkCreateImageView_VkResult_return = (VkResult)0; stream->read(&vkCreateImageView_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -4425,7 +4157,6 @@ void VkEncoder::vkDestroyImageView( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyImageView encode"); mImpl->log("start vkDestroyImageView"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4482,8 +4213,6 @@ void VkEncoder::vkDestroyImageView( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyImageView readParams"); - AEMU_SCOPED_TRACE("vkDestroyImageView returnUnmarshal"); resources->destroyMapping()->mapHandles_VkImageView((VkImageView*)&imageView); pool->freeAll(); countingStream->clearPool(); @@ -4498,7 +4227,6 @@ VkResult VkEncoder::vkCreateShaderModule( VkShaderModule* pShaderModule) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateShaderModule encode"); mImpl->log("start vkCreateShaderModule"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4568,13 +4296,11 @@ VkResult VkEncoder::vkCreateShaderModule( stream->handleMapping()->mapHandles_VkShaderModule_u64(pShaderModule, &cgen_var_304, 1); stream->write((uint64_t*)&cgen_var_304, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateShaderModule readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_305; stream->read((uint64_t*)&cgen_var_305, 8); stream->handleMapping()->mapHandles_u64_VkShaderModule(&cgen_var_305, (VkShaderModule*)pShaderModule, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateShaderModule returnUnmarshal"); VkResult vkCreateShaderModule_VkResult_return = (VkResult)0; stream->read(&vkCreateShaderModule_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -4590,7 +4316,6 @@ void VkEncoder::vkDestroyShaderModule( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyShaderModule encode"); mImpl->log("start vkDestroyShaderModule"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4647,8 +4372,6 @@ void VkEncoder::vkDestroyShaderModule( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyShaderModule readParams"); - AEMU_SCOPED_TRACE("vkDestroyShaderModule returnUnmarshal"); resources->destroyMapping()->mapHandles_VkShaderModule((VkShaderModule*)&shaderModule); pool->freeAll(); countingStream->clearPool(); @@ -4663,7 +4386,6 @@ VkResult VkEncoder::vkCreatePipelineCache( VkPipelineCache* pPipelineCache) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreatePipelineCache encode"); mImpl->log("start vkCreatePipelineCache"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4733,13 +4455,11 @@ VkResult VkEncoder::vkCreatePipelineCache( stream->handleMapping()->mapHandles_VkPipelineCache_u64(pPipelineCache, &cgen_var_317, 1); stream->write((uint64_t*)&cgen_var_317, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreatePipelineCache readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_318; stream->read((uint64_t*)&cgen_var_318, 8); stream->handleMapping()->mapHandles_u64_VkPipelineCache(&cgen_var_318, (VkPipelineCache*)pPipelineCache, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreatePipelineCache returnUnmarshal"); VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0; stream->read(&vkCreatePipelineCache_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -4755,7 +4475,6 @@ void VkEncoder::vkDestroyPipelineCache( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyPipelineCache encode"); mImpl->log("start vkDestroyPipelineCache"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4812,8 +4531,6 @@ void VkEncoder::vkDestroyPipelineCache( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyPipelineCache readParams"); - AEMU_SCOPED_TRACE("vkDestroyPipelineCache returnUnmarshal"); resources->destroyMapping()->mapHandles_VkPipelineCache((VkPipelineCache*)&pipelineCache); pool->freeAll(); countingStream->clearPool(); @@ -4828,7 +4545,6 @@ VkResult VkEncoder::vkGetPipelineCacheData( void* pData) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPipelineCacheData encode"); mImpl->log("start vkGetPipelineCacheData"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4889,7 +4605,6 @@ VkResult VkEncoder::vkGetPipelineCacheData( { stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkGetPipelineCacheData readParams"); // WARNING PTR CHECK size_t* check_pDataSize; check_pDataSize = (size_t*)(uintptr_t)stream->getBe64(); @@ -4912,7 +4627,6 @@ VkResult VkEncoder::vkGetPipelineCacheData( } stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkGetPipelineCacheData returnUnmarshal"); VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0; stream->read(&vkGetPipelineCacheData_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -4929,7 +4643,6 @@ VkResult VkEncoder::vkMergePipelineCaches( const VkPipelineCache* pSrcCaches) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkMergePipelineCaches encode"); mImpl->log("start vkMergePipelineCaches"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -4984,8 +4697,6 @@ VkResult VkEncoder::vkMergePipelineCaches( stream->handleMapping()->mapHandles_VkPipelineCache_u64(local_pSrcCaches, cgen_var_343, ((srcCacheCount))); stream->write((uint64_t*)cgen_var_343, ((srcCacheCount)) * 8); } - AEMU_SCOPED_TRACE("vkMergePipelineCaches readParams"); - AEMU_SCOPED_TRACE("vkMergePipelineCaches returnUnmarshal"); VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0; stream->read(&vkMergePipelineCaches_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -5004,7 +4715,6 @@ VkResult VkEncoder::vkCreateGraphicsPipelines( VkPipeline* pPipelines) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines encode"); mImpl->log("start vkCreateGraphicsPipelines"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5106,7 +4816,6 @@ VkResult VkEncoder::vkCreateGraphicsPipelines( stream->write((uint64_t*)cgen_var_351, ((createInfoCount)) * 8); } stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines readParams"); stream->setHandleMapping(resources->createMapping()); if (((createInfoCount))) { @@ -5116,7 +4825,6 @@ VkResult VkEncoder::vkCreateGraphicsPipelines( stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_352, (VkPipeline*)pPipelines, ((createInfoCount))); } stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines returnUnmarshal"); VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0; stream->read(&vkCreateGraphicsPipelines_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -5135,7 +4843,6 @@ VkResult VkEncoder::vkCreateComputePipelines( VkPipeline* pPipelines) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateComputePipelines encode"); mImpl->log("start vkCreateComputePipelines"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5237,7 +4944,6 @@ VkResult VkEncoder::vkCreateComputePipelines( stream->write((uint64_t*)cgen_var_360, ((createInfoCount)) * 8); } stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateComputePipelines readParams"); stream->setHandleMapping(resources->createMapping()); if (((createInfoCount))) { @@ -5247,7 +4953,6 @@ VkResult VkEncoder::vkCreateComputePipelines( stream->handleMapping()->mapHandles_u64_VkPipeline(cgen_var_361, (VkPipeline*)pPipelines, ((createInfoCount))); } stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateComputePipelines returnUnmarshal"); VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0; stream->read(&vkCreateComputePipelines_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -5263,7 +4968,6 @@ void VkEncoder::vkDestroyPipeline( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyPipeline encode"); mImpl->log("start vkDestroyPipeline"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5320,8 +5024,6 @@ void VkEncoder::vkDestroyPipeline( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyPipeline readParams"); - AEMU_SCOPED_TRACE("vkDestroyPipeline returnUnmarshal"); resources->destroyMapping()->mapHandles_VkPipeline((VkPipeline*)&pipeline); pool->freeAll(); countingStream->clearPool(); @@ -5336,7 +5038,6 @@ VkResult VkEncoder::vkCreatePipelineLayout( VkPipelineLayout* pPipelineLayout) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreatePipelineLayout encode"); mImpl->log("start vkCreatePipelineLayout"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5406,13 +5107,11 @@ VkResult VkEncoder::vkCreatePipelineLayout( stream->handleMapping()->mapHandles_VkPipelineLayout_u64(pPipelineLayout, &cgen_var_373, 1); stream->write((uint64_t*)&cgen_var_373, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreatePipelineLayout readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_374; stream->read((uint64_t*)&cgen_var_374, 8); stream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_374, (VkPipelineLayout*)pPipelineLayout, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreatePipelineLayout returnUnmarshal"); VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0; stream->read(&vkCreatePipelineLayout_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -5428,7 +5127,6 @@ void VkEncoder::vkDestroyPipelineLayout( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyPipelineLayout encode"); mImpl->log("start vkDestroyPipelineLayout"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5485,8 +5183,6 @@ void VkEncoder::vkDestroyPipelineLayout( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyPipelineLayout readParams"); - AEMU_SCOPED_TRACE("vkDestroyPipelineLayout returnUnmarshal"); resources->destroyMapping()->mapHandles_VkPipelineLayout((VkPipelineLayout*)&pipelineLayout); pool->freeAll(); countingStream->clearPool(); @@ -5501,7 +5197,6 @@ VkResult VkEncoder::vkCreateSampler( VkSampler* pSampler) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateSampler encode"); mImpl->log("start vkCreateSampler"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5571,13 +5266,11 @@ VkResult VkEncoder::vkCreateSampler( stream->handleMapping()->mapHandles_VkSampler_u64(pSampler, &cgen_var_386, 1); stream->write((uint64_t*)&cgen_var_386, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateSampler readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_387; stream->read((uint64_t*)&cgen_var_387, 8); stream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_387, (VkSampler*)pSampler, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateSampler returnUnmarshal"); VkResult vkCreateSampler_VkResult_return = (VkResult)0; stream->read(&vkCreateSampler_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -5593,7 +5286,6 @@ void VkEncoder::vkDestroySampler( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroySampler encode"); mImpl->log("start vkDestroySampler"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5650,8 +5342,6 @@ void VkEncoder::vkDestroySampler( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroySampler readParams"); - AEMU_SCOPED_TRACE("vkDestroySampler returnUnmarshal"); resources->destroyMapping()->mapHandles_VkSampler((VkSampler*)&sampler); pool->freeAll(); countingStream->clearPool(); @@ -5666,7 +5356,6 @@ VkResult VkEncoder::vkCreateDescriptorSetLayout( VkDescriptorSetLayout* pSetLayout) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout encode"); mImpl->log("start vkCreateDescriptorSetLayout"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5736,13 +5425,11 @@ VkResult VkEncoder::vkCreateDescriptorSetLayout( stream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(pSetLayout, &cgen_var_399, 1); stream->write((uint64_t*)&cgen_var_399, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_400; stream->read((uint64_t*)&cgen_var_400, 8); stream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_400, (VkDescriptorSetLayout*)pSetLayout, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout returnUnmarshal"); VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0; stream->read(&vkCreateDescriptorSetLayout_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -5758,7 +5445,6 @@ void VkEncoder::vkDestroyDescriptorSetLayout( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout encode"); mImpl->log("start vkDestroyDescriptorSetLayout"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5815,8 +5501,6 @@ void VkEncoder::vkDestroyDescriptorSetLayout( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout readParams"); - AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout returnUnmarshal"); resources->destroyMapping()->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)&descriptorSetLayout); pool->freeAll(); countingStream->clearPool(); @@ -5831,7 +5515,6 @@ VkResult VkEncoder::vkCreateDescriptorPool( VkDescriptorPool* pDescriptorPool) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateDescriptorPool encode"); mImpl->log("start vkCreateDescriptorPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5901,13 +5584,11 @@ VkResult VkEncoder::vkCreateDescriptorPool( stream->handleMapping()->mapHandles_VkDescriptorPool_u64(pDescriptorPool, &cgen_var_412, 1); stream->write((uint64_t*)&cgen_var_412, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateDescriptorPool readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_413; stream->read((uint64_t*)&cgen_var_413, 8); stream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_413, (VkDescriptorPool*)pDescriptorPool, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateDescriptorPool returnUnmarshal"); VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0; stream->read(&vkCreateDescriptorPool_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -5923,7 +5604,6 @@ void VkEncoder::vkDestroyDescriptorPool( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyDescriptorPool encode"); mImpl->log("start vkDestroyDescriptorPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -5980,8 +5660,6 @@ void VkEncoder::vkDestroyDescriptorPool( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyDescriptorPool readParams"); - AEMU_SCOPED_TRACE("vkDestroyDescriptorPool returnUnmarshal"); resources->destroyMapping()->mapHandles_VkDescriptorPool((VkDescriptorPool*)&descriptorPool); pool->freeAll(); countingStream->clearPool(); @@ -5995,7 +5673,6 @@ VkResult VkEncoder::vkResetDescriptorPool( VkDescriptorPoolResetFlags flags) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkResetDescriptorPool encode"); mImpl->log("start vkResetDescriptorPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6030,8 +5707,6 @@ VkResult VkEncoder::vkResetDescriptorPool( stream->handleMapping()->mapHandles_VkDescriptorPool_u64(&local_descriptorPool, &cgen_var_423, 1); stream->write((uint64_t*)&cgen_var_423, 1 * 8); stream->write((VkDescriptorPoolResetFlags*)&local_flags, sizeof(VkDescriptorPoolResetFlags)); - AEMU_SCOPED_TRACE("vkResetDescriptorPool readParams"); - AEMU_SCOPED_TRACE("vkResetDescriptorPool returnUnmarshal"); VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0; stream->read(&vkResetDescriptorPool_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -6047,7 +5722,6 @@ VkResult VkEncoder::vkAllocateDescriptorSets( VkDescriptorSet* pDescriptorSets) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkAllocateDescriptorSets encode"); mImpl->log("start vkAllocateDescriptorSets"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6099,7 +5773,6 @@ VkResult VkEncoder::vkAllocateDescriptorSets( stream->write((uint64_t*)cgen_var_427, pAllocateInfo->descriptorSetCount * 8); } stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkAllocateDescriptorSets readParams"); stream->setHandleMapping(resources->createMapping()); if (pAllocateInfo->descriptorSetCount) { @@ -6109,7 +5782,6 @@ VkResult VkEncoder::vkAllocateDescriptorSets( stream->handleMapping()->mapHandles_u64_VkDescriptorSet(cgen_var_428, (VkDescriptorSet*)pDescriptorSets, pAllocateInfo->descriptorSetCount); } stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkAllocateDescriptorSets returnUnmarshal"); VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0; stream->read(&vkAllocateDescriptorSets_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -6126,7 +5798,6 @@ VkResult VkEncoder::vkFreeDescriptorSets( const VkDescriptorSet* pDescriptorSets) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkFreeDescriptorSets encode"); mImpl->log("start vkFreeDescriptorSets"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6193,8 +5864,6 @@ VkResult VkEncoder::vkFreeDescriptorSets( stream->write((uint64_t*)cgen_var_436, ((descriptorSetCount)) * 8); } } - AEMU_SCOPED_TRACE("vkFreeDescriptorSets readParams"); - AEMU_SCOPED_TRACE("vkFreeDescriptorSets returnUnmarshal"); VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0; stream->read(&vkFreeDescriptorSets_VkResult_return, sizeof(VkResult)); if (pDescriptorSets) @@ -6216,7 +5885,6 @@ void VkEncoder::vkUpdateDescriptorSets( const VkCopyDescriptorSet* pDescriptorCopies) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkUpdateDescriptorSets encode"); mImpl->log("start vkUpdateDescriptorSets"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6297,8 +5965,6 @@ void VkEncoder::vkUpdateDescriptorSets( { marshal_VkCopyDescriptorSet(stream, (VkCopyDescriptorSet*)(local_pDescriptorCopies + i)); } - AEMU_SCOPED_TRACE("vkUpdateDescriptorSets readParams"); - AEMU_SCOPED_TRACE("vkUpdateDescriptorSets returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -6312,7 +5978,6 @@ VkResult VkEncoder::vkCreateFramebuffer( VkFramebuffer* pFramebuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateFramebuffer encode"); mImpl->log("start vkCreateFramebuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6382,13 +6047,11 @@ VkResult VkEncoder::vkCreateFramebuffer( stream->handleMapping()->mapHandles_VkFramebuffer_u64(pFramebuffer, &cgen_var_444, 1); stream->write((uint64_t*)&cgen_var_444, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateFramebuffer readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_445; stream->read((uint64_t*)&cgen_var_445, 8); stream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_445, (VkFramebuffer*)pFramebuffer, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateFramebuffer returnUnmarshal"); VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0; stream->read(&vkCreateFramebuffer_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -6404,7 +6067,6 @@ void VkEncoder::vkDestroyFramebuffer( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyFramebuffer encode"); mImpl->log("start vkDestroyFramebuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6461,8 +6123,6 @@ void VkEncoder::vkDestroyFramebuffer( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyFramebuffer readParams"); - AEMU_SCOPED_TRACE("vkDestroyFramebuffer returnUnmarshal"); resources->destroyMapping()->mapHandles_VkFramebuffer((VkFramebuffer*)&framebuffer); pool->freeAll(); countingStream->clearPool(); @@ -6477,7 +6137,6 @@ VkResult VkEncoder::vkCreateRenderPass( VkRenderPass* pRenderPass) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateRenderPass encode"); mImpl->log("start vkCreateRenderPass"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6547,13 +6206,11 @@ VkResult VkEncoder::vkCreateRenderPass( stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_457, 1); stream->write((uint64_t*)&cgen_var_457, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateRenderPass readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_458; stream->read((uint64_t*)&cgen_var_458, 8); stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_458, (VkRenderPass*)pRenderPass, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateRenderPass returnUnmarshal"); VkResult vkCreateRenderPass_VkResult_return = (VkResult)0; stream->read(&vkCreateRenderPass_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -6569,7 +6226,6 @@ void VkEncoder::vkDestroyRenderPass( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyRenderPass encode"); mImpl->log("start vkDestroyRenderPass"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6626,8 +6282,6 @@ void VkEncoder::vkDestroyRenderPass( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyRenderPass readParams"); - AEMU_SCOPED_TRACE("vkDestroyRenderPass returnUnmarshal"); resources->destroyMapping()->mapHandles_VkRenderPass((VkRenderPass*)&renderPass); pool->freeAll(); countingStream->clearPool(); @@ -6641,7 +6295,6 @@ void VkEncoder::vkGetRenderAreaGranularity( VkExtent2D* pGranularity) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity encode"); mImpl->log("start vkGetRenderAreaGranularity"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6674,13 +6327,11 @@ void VkEncoder::vkGetRenderAreaGranularity( stream->handleMapping()->mapHandles_VkRenderPass_u64(&local_renderPass, &cgen_var_468, 1); stream->write((uint64_t*)&cgen_var_468, 1 * 8); marshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity)); - AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity readParams"); unmarshal_VkExtent2D(stream, (VkExtent2D*)(pGranularity)); if (pGranularity) { transform_fromhost_VkExtent2D(mImpl->resources(), (VkExtent2D*)(pGranularity)); } - AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -6694,7 +6345,6 @@ VkResult VkEncoder::vkCreateCommandPool( VkCommandPool* pCommandPool) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateCommandPool encode"); mImpl->log("start vkCreateCommandPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6764,13 +6414,11 @@ VkResult VkEncoder::vkCreateCommandPool( stream->handleMapping()->mapHandles_VkCommandPool_u64(pCommandPool, &cgen_var_474, 1); stream->write((uint64_t*)&cgen_var_474, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateCommandPool readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_475; stream->read((uint64_t*)&cgen_var_475, 8); stream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_475, (VkCommandPool*)pCommandPool, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateCommandPool returnUnmarshal"); VkResult vkCreateCommandPool_VkResult_return = (VkResult)0; stream->read(&vkCreateCommandPool_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -6786,7 +6434,6 @@ void VkEncoder::vkDestroyCommandPool( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyCommandPool encode"); mImpl->log("start vkDestroyCommandPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6843,8 +6490,6 @@ void VkEncoder::vkDestroyCommandPool( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyCommandPool readParams"); - AEMU_SCOPED_TRACE("vkDestroyCommandPool returnUnmarshal"); resources->destroyMapping()->mapHandles_VkCommandPool((VkCommandPool*)&commandPool); pool->freeAll(); countingStream->clearPool(); @@ -6858,7 +6503,6 @@ VkResult VkEncoder::vkResetCommandPool( VkCommandPoolResetFlags flags) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkResetCommandPool encode"); mImpl->log("start vkResetCommandPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6893,8 +6537,6 @@ VkResult VkEncoder::vkResetCommandPool( stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_485, 1); stream->write((uint64_t*)&cgen_var_485, 1 * 8); stream->write((VkCommandPoolResetFlags*)&local_flags, sizeof(VkCommandPoolResetFlags)); - AEMU_SCOPED_TRACE("vkResetCommandPool readParams"); - AEMU_SCOPED_TRACE("vkResetCommandPool returnUnmarshal"); VkResult vkResetCommandPool_VkResult_return = (VkResult)0; stream->read(&vkResetCommandPool_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -6910,7 +6552,6 @@ VkResult VkEncoder::vkAllocateCommandBuffers( VkCommandBuffer* pCommandBuffers) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkAllocateCommandBuffers encode"); mImpl->log("start vkAllocateCommandBuffers"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -6962,7 +6603,6 @@ VkResult VkEncoder::vkAllocateCommandBuffers( stream->write((uint64_t*)cgen_var_489, pAllocateInfo->commandBufferCount * 8); } stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkAllocateCommandBuffers readParams"); stream->setHandleMapping(resources->createMapping()); if (pAllocateInfo->commandBufferCount) { @@ -6972,7 +6612,6 @@ VkResult VkEncoder::vkAllocateCommandBuffers( stream->handleMapping()->mapHandles_u64_VkCommandBuffer(cgen_var_490, (VkCommandBuffer*)pCommandBuffers, pAllocateInfo->commandBufferCount); } stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkAllocateCommandBuffers returnUnmarshal"); VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0; stream->read(&vkAllocateCommandBuffers_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -6989,7 +6628,6 @@ void VkEncoder::vkFreeCommandBuffers( const VkCommandBuffer* pCommandBuffers) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkFreeCommandBuffers encode"); mImpl->log("start vkFreeCommandBuffers"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7056,8 +6694,6 @@ void VkEncoder::vkFreeCommandBuffers( stream->write((uint64_t*)cgen_var_498, ((commandBufferCount)) * 8); } } - AEMU_SCOPED_TRACE("vkFreeCommandBuffers readParams"); - AEMU_SCOPED_TRACE("vkFreeCommandBuffers returnUnmarshal"); if (pCommandBuffers) { resources->destroyMapping()->mapHandles_VkCommandBuffer((VkCommandBuffer*)pCommandBuffers, ((commandBufferCount))); @@ -7073,7 +6709,6 @@ VkResult VkEncoder::vkBeginCommandBuffer( const VkCommandBufferBeginInfo* pBeginInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkBeginCommandBuffer encode"); mImpl->log("start vkBeginCommandBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7109,8 +6744,6 @@ VkResult VkEncoder::vkBeginCommandBuffer( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_500, 1); stream->write((uint64_t*)&cgen_var_500, 1 * 8); marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo)); - AEMU_SCOPED_TRACE("vkBeginCommandBuffer readParams"); - AEMU_SCOPED_TRACE("vkBeginCommandBuffer returnUnmarshal"); VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0; stream->read(&vkBeginCommandBuffer_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -7124,7 +6757,6 @@ VkResult VkEncoder::vkEndCommandBuffer( VkCommandBuffer commandBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEndCommandBuffer encode"); mImpl->log("start vkEndCommandBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7147,8 +6779,6 @@ VkResult VkEncoder::vkEndCommandBuffer( uint64_t cgen_var_502; stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_502, 1); stream->write((uint64_t*)&cgen_var_502, 1 * 8); - AEMU_SCOPED_TRACE("vkEndCommandBuffer readParams"); - AEMU_SCOPED_TRACE("vkEndCommandBuffer returnUnmarshal"); VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0; stream->read(&vkEndCommandBuffer_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -7163,7 +6793,6 @@ VkResult VkEncoder::vkResetCommandBuffer( VkCommandBufferResetFlags flags) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkResetCommandBuffer encode"); mImpl->log("start vkResetCommandBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7190,8 +6819,6 @@ VkResult VkEncoder::vkResetCommandBuffer( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_504, 1); stream->write((uint64_t*)&cgen_var_504, 1 * 8); stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags)); - AEMU_SCOPED_TRACE("vkResetCommandBuffer readParams"); - AEMU_SCOPED_TRACE("vkResetCommandBuffer returnUnmarshal"); VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0; stream->read(&vkResetCommandBuffer_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -7207,7 +6834,6 @@ void VkEncoder::vkCmdBindPipeline( VkPipeline pipeline) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBindPipeline encode"); mImpl->log("start vkCmdBindPipeline"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7242,8 +6868,6 @@ void VkEncoder::vkCmdBindPipeline( uint64_t cgen_var_508; stream->handleMapping()->mapHandles_VkPipeline_u64(&local_pipeline, &cgen_var_508, 1); stream->write((uint64_t*)&cgen_var_508, 1 * 8); - AEMU_SCOPED_TRACE("vkCmdBindPipeline readParams"); - AEMU_SCOPED_TRACE("vkCmdBindPipeline returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7257,7 +6881,6 @@ void VkEncoder::vkCmdSetViewport( const VkViewport* pViewports) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetViewport encode"); mImpl->log("start vkCmdSetViewport"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7313,8 +6936,6 @@ void VkEncoder::vkCmdSetViewport( { marshal_VkViewport(stream, (VkViewport*)(local_pViewports + i)); } - AEMU_SCOPED_TRACE("vkCmdSetViewport readParams"); - AEMU_SCOPED_TRACE("vkCmdSetViewport returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7328,7 +6949,6 @@ void VkEncoder::vkCmdSetScissor( const VkRect2D* pScissors) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetScissor encode"); mImpl->log("start vkCmdSetScissor"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7384,8 +7004,6 @@ void VkEncoder::vkCmdSetScissor( { marshal_VkRect2D(stream, (VkRect2D*)(local_pScissors + i)); } - AEMU_SCOPED_TRACE("vkCmdSetScissor readParams"); - AEMU_SCOPED_TRACE("vkCmdSetScissor returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7397,7 +7015,6 @@ void VkEncoder::vkCmdSetLineWidth( float lineWidth) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetLineWidth encode"); mImpl->log("start vkCmdSetLineWidth"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7424,8 +7041,6 @@ void VkEncoder::vkCmdSetLineWidth( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_514, 1); stream->write((uint64_t*)&cgen_var_514, 1 * 8); stream->write((float*)&local_lineWidth, sizeof(float)); - AEMU_SCOPED_TRACE("vkCmdSetLineWidth readParams"); - AEMU_SCOPED_TRACE("vkCmdSetLineWidth returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7439,7 +7054,6 @@ void VkEncoder::vkCmdSetDepthBias( float depthBiasSlopeFactor) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetDepthBias encode"); mImpl->log("start vkCmdSetDepthBias"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7474,8 +7088,6 @@ void VkEncoder::vkCmdSetDepthBias( stream->write((float*)&local_depthBiasConstantFactor, sizeof(float)); stream->write((float*)&local_depthBiasClamp, sizeof(float)); stream->write((float*)&local_depthBiasSlopeFactor, sizeof(float)); - AEMU_SCOPED_TRACE("vkCmdSetDepthBias readParams"); - AEMU_SCOPED_TRACE("vkCmdSetDepthBias returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7487,7 +7099,6 @@ void VkEncoder::vkCmdSetBlendConstants( const float blendConstants[4]) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetBlendConstants encode"); mImpl->log("start vkCmdSetBlendConstants"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7514,8 +7125,6 @@ void VkEncoder::vkCmdSetBlendConstants( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_518, 1); stream->write((uint64_t*)&cgen_var_518, 1 * 8); stream->write((float*)local_blendConstants, 4 * sizeof(float)); - AEMU_SCOPED_TRACE("vkCmdSetBlendConstants readParams"); - AEMU_SCOPED_TRACE("vkCmdSetBlendConstants returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7528,7 +7137,6 @@ void VkEncoder::vkCmdSetDepthBounds( float maxDepthBounds) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetDepthBounds encode"); mImpl->log("start vkCmdSetDepthBounds"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7559,8 +7167,6 @@ void VkEncoder::vkCmdSetDepthBounds( stream->write((uint64_t*)&cgen_var_520, 1 * 8); stream->write((float*)&local_minDepthBounds, sizeof(float)); stream->write((float*)&local_maxDepthBounds, sizeof(float)); - AEMU_SCOPED_TRACE("vkCmdSetDepthBounds readParams"); - AEMU_SCOPED_TRACE("vkCmdSetDepthBounds returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7573,7 +7179,6 @@ void VkEncoder::vkCmdSetStencilCompareMask( uint32_t compareMask) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask encode"); mImpl->log("start vkCmdSetStencilCompareMask"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7604,8 +7209,6 @@ void VkEncoder::vkCmdSetStencilCompareMask( stream->write((uint64_t*)&cgen_var_522, 1 * 8); stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags)); stream->write((uint32_t*)&local_compareMask, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask readParams"); - AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7618,7 +7221,6 @@ void VkEncoder::vkCmdSetStencilWriteMask( uint32_t writeMask) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask encode"); mImpl->log("start vkCmdSetStencilWriteMask"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7649,8 +7251,6 @@ void VkEncoder::vkCmdSetStencilWriteMask( stream->write((uint64_t*)&cgen_var_524, 1 * 8); stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags)); stream->write((uint32_t*)&local_writeMask, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask readParams"); - AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7663,7 +7263,6 @@ void VkEncoder::vkCmdSetStencilReference( uint32_t reference) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetStencilReference encode"); mImpl->log("start vkCmdSetStencilReference"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7694,8 +7293,6 @@ void VkEncoder::vkCmdSetStencilReference( stream->write((uint64_t*)&cgen_var_526, 1 * 8); stream->write((VkStencilFaceFlags*)&local_faceMask, sizeof(VkStencilFaceFlags)); stream->write((uint32_t*)&local_reference, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdSetStencilReference readParams"); - AEMU_SCOPED_TRACE("vkCmdSetStencilReference returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7713,7 +7310,6 @@ void VkEncoder::vkCmdBindDescriptorSets( const uint32_t* pDynamicOffsets) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets encode"); mImpl->log("start vkCmdBindDescriptorSets"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7788,8 +7384,6 @@ void VkEncoder::vkCmdBindDescriptorSets( } stream->write((uint32_t*)&local_dynamicOffsetCount, sizeof(uint32_t)); stream->write((uint32_t*)local_pDynamicOffsets, ((dynamicOffsetCount)) * sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets readParams"); - AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7803,7 +7397,6 @@ void VkEncoder::vkCmdBindIndexBuffer( VkIndexType indexType) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer encode"); mImpl->log("start vkCmdBindIndexBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7842,8 +7435,6 @@ void VkEncoder::vkCmdBindIndexBuffer( stream->write((uint64_t*)&cgen_var_536, 1 * 8); stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize)); stream->write((VkIndexType*)&local_indexType, sizeof(VkIndexType)); - AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer readParams"); - AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7858,7 +7449,6 @@ void VkEncoder::vkCmdBindVertexBuffers( const VkDeviceSize* pOffsets) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers encode"); mImpl->log("start vkCmdBindVertexBuffers"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7917,8 +7507,6 @@ void VkEncoder::vkCmdBindVertexBuffers( stream->write((uint64_t*)cgen_var_540, ((bindingCount)) * 8); } stream->write((VkDeviceSize*)local_pOffsets, ((bindingCount)) * sizeof(VkDeviceSize)); - AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers readParams"); - AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7933,7 +7521,6 @@ void VkEncoder::vkCmdDraw( uint32_t firstInstance) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDraw encode"); mImpl->log("start vkCmdDraw"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -7972,8 +7559,6 @@ void VkEncoder::vkCmdDraw( stream->write((uint32_t*)&local_instanceCount, sizeof(uint32_t)); stream->write((uint32_t*)&local_firstVertex, sizeof(uint32_t)); stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDraw readParams"); - AEMU_SCOPED_TRACE("vkCmdDraw returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -7989,7 +7574,6 @@ void VkEncoder::vkCmdDrawIndexed( uint32_t firstInstance) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDrawIndexed encode"); mImpl->log("start vkCmdDrawIndexed"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8032,8 +7616,6 @@ void VkEncoder::vkCmdDrawIndexed( stream->write((uint32_t*)&local_firstIndex, sizeof(uint32_t)); stream->write((int32_t*)&local_vertexOffset, sizeof(int32_t)); stream->write((uint32_t*)&local_firstInstance, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDrawIndexed readParams"); - AEMU_SCOPED_TRACE("vkCmdDrawIndexed returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8048,7 +7630,6 @@ void VkEncoder::vkCmdDrawIndirect( uint32_t stride) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDrawIndirect encode"); mImpl->log("start vkCmdDrawIndirect"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8091,8 +7672,6 @@ void VkEncoder::vkCmdDrawIndirect( stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize)); stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t)); stream->write((uint32_t*)&local_stride, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDrawIndirect readParams"); - AEMU_SCOPED_TRACE("vkCmdDrawIndirect returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8107,7 +7686,6 @@ void VkEncoder::vkCmdDrawIndexedIndirect( uint32_t stride) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect encode"); mImpl->log("start vkCmdDrawIndexedIndirect"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8150,8 +7728,6 @@ void VkEncoder::vkCmdDrawIndexedIndirect( stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize)); stream->write((uint32_t*)&local_drawCount, sizeof(uint32_t)); stream->write((uint32_t*)&local_stride, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect readParams"); - AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8165,7 +7741,6 @@ void VkEncoder::vkCmdDispatch( uint32_t groupCountZ) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDispatch encode"); mImpl->log("start vkCmdDispatch"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8200,8 +7775,6 @@ void VkEncoder::vkCmdDispatch( stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t)); stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t)); stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDispatch readParams"); - AEMU_SCOPED_TRACE("vkCmdDispatch returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8214,7 +7787,6 @@ void VkEncoder::vkCmdDispatchIndirect( VkDeviceSize offset) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDispatchIndirect encode"); mImpl->log("start vkCmdDispatchIndirect"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8249,8 +7821,6 @@ void VkEncoder::vkCmdDispatchIndirect( stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_558, 1); stream->write((uint64_t*)&cgen_var_558, 1 * 8); stream->write((VkDeviceSize*)&local_offset, sizeof(VkDeviceSize)); - AEMU_SCOPED_TRACE("vkCmdDispatchIndirect readParams"); - AEMU_SCOPED_TRACE("vkCmdDispatchIndirect returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8265,7 +7835,6 @@ void VkEncoder::vkCmdCopyBuffer( const VkBufferCopy* pRegions) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdCopyBuffer encode"); mImpl->log("start vkCmdCopyBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8333,8 +7902,6 @@ void VkEncoder::vkCmdCopyBuffer( { marshal_VkBufferCopy(stream, (VkBufferCopy*)(local_pRegions + i)); } - AEMU_SCOPED_TRACE("vkCmdCopyBuffer readParams"); - AEMU_SCOPED_TRACE("vkCmdCopyBuffer returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8351,7 +7918,6 @@ void VkEncoder::vkCmdCopyImage( const VkImageCopy* pRegions) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdCopyImage encode"); mImpl->log("start vkCmdCopyImage"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8427,8 +7993,6 @@ void VkEncoder::vkCmdCopyImage( { marshal_VkImageCopy(stream, (VkImageCopy*)(local_pRegions + i)); } - AEMU_SCOPED_TRACE("vkCmdCopyImage readParams"); - AEMU_SCOPED_TRACE("vkCmdCopyImage returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8446,7 +8010,6 @@ void VkEncoder::vkCmdBlitImage( VkFilter filter) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBlitImage encode"); mImpl->log("start vkCmdBlitImage"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8526,8 +8089,6 @@ void VkEncoder::vkCmdBlitImage( marshal_VkImageBlit(stream, (VkImageBlit*)(local_pRegions + i)); } stream->write((VkFilter*)&local_filter, sizeof(VkFilter)); - AEMU_SCOPED_TRACE("vkCmdBlitImage readParams"); - AEMU_SCOPED_TRACE("vkCmdBlitImage returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8543,7 +8104,6 @@ void VkEncoder::vkCmdCopyBufferToImage( const VkBufferImageCopy* pRegions) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage encode"); mImpl->log("start vkCmdCopyBufferToImage"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8615,8 +8175,6 @@ void VkEncoder::vkCmdCopyBufferToImage( { marshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i)); } - AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage readParams"); - AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8632,7 +8190,6 @@ void VkEncoder::vkCmdCopyImageToBuffer( const VkBufferImageCopy* pRegions) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer encode"); mImpl->log("start vkCmdCopyImageToBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8704,8 +8261,6 @@ void VkEncoder::vkCmdCopyImageToBuffer( { marshal_VkBufferImageCopy(stream, (VkBufferImageCopy*)(local_pRegions + i)); } - AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer readParams"); - AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8720,7 +8275,6 @@ void VkEncoder::vkCmdUpdateBuffer( const void* pData) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdUpdateBuffer encode"); mImpl->log("start vkCmdUpdateBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8767,8 +8321,6 @@ void VkEncoder::vkCmdUpdateBuffer( stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize)); stream->write((VkDeviceSize*)&local_dataSize, sizeof(VkDeviceSize)); stream->write((void*)local_pData, ((dataSize)) * sizeof(uint8_t)); - AEMU_SCOPED_TRACE("vkCmdUpdateBuffer readParams"); - AEMU_SCOPED_TRACE("vkCmdUpdateBuffer returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8783,7 +8335,6 @@ void VkEncoder::vkCmdFillBuffer( uint32_t data) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdFillBuffer encode"); mImpl->log("start vkCmdFillBuffer"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8826,8 +8377,6 @@ void VkEncoder::vkCmdFillBuffer( stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize)); stream->write((VkDeviceSize*)&local_size, sizeof(VkDeviceSize)); stream->write((uint32_t*)&local_data, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdFillBuffer readParams"); - AEMU_SCOPED_TRACE("vkCmdFillBuffer returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8843,7 +8392,6 @@ void VkEncoder::vkCmdClearColorImage( const VkImageSubresourceRange* pRanges) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdClearColorImage encode"); mImpl->log("start vkCmdClearColorImage"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -8920,8 +8468,6 @@ void VkEncoder::vkCmdClearColorImage( { marshal_VkImageSubresourceRange(stream, (VkImageSubresourceRange*)(local_pRanges + i)); } - AEMU_SCOPED_TRACE("vkCmdClearColorImage readParams"); - AEMU_SCOPED_TRACE("vkCmdClearColorImage returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -8937,7 +8483,6 @@ void VkEncoder::vkCmdClearDepthStencilImage( const VkImageSubresourceRange* pRanges) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage encode"); mImpl->log("start vkCmdClearDepthStencilImage"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9014,8 +8559,6 @@ void VkEncoder::vkCmdClearDepthStencilImage( { marshal_VkImageSubresourceRange(stream, (VkImageSubresourceRange*)(local_pRanges + i)); } - AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage readParams"); - AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9030,7 +8573,6 @@ void VkEncoder::vkCmdClearAttachments( const VkClearRect* pRects) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdClearAttachments encode"); mImpl->log("start vkCmdClearAttachments"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9111,8 +8653,6 @@ void VkEncoder::vkCmdClearAttachments( { marshal_VkClearRect(stream, (VkClearRect*)(local_pRects + i)); } - AEMU_SCOPED_TRACE("vkCmdClearAttachments readParams"); - AEMU_SCOPED_TRACE("vkCmdClearAttachments returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9129,7 +8669,6 @@ void VkEncoder::vkCmdResolveImage( const VkImageResolve* pRegions) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdResolveImage encode"); mImpl->log("start vkCmdResolveImage"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9205,8 +8744,6 @@ void VkEncoder::vkCmdResolveImage( { marshal_VkImageResolve(stream, (VkImageResolve*)(local_pRegions + i)); } - AEMU_SCOPED_TRACE("vkCmdResolveImage readParams"); - AEMU_SCOPED_TRACE("vkCmdResolveImage returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9219,7 +8756,6 @@ void VkEncoder::vkCmdSetEvent( VkPipelineStageFlags stageMask) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetEvent encode"); mImpl->log("start vkCmdSetEvent"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9254,8 +8790,6 @@ void VkEncoder::vkCmdSetEvent( stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_616, 1); stream->write((uint64_t*)&cgen_var_616, 1 * 8); stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags)); - AEMU_SCOPED_TRACE("vkCmdSetEvent readParams"); - AEMU_SCOPED_TRACE("vkCmdSetEvent returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9268,7 +8802,6 @@ void VkEncoder::vkCmdResetEvent( VkPipelineStageFlags stageMask) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdResetEvent encode"); mImpl->log("start vkCmdResetEvent"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9303,8 +8836,6 @@ void VkEncoder::vkCmdResetEvent( stream->handleMapping()->mapHandles_VkEvent_u64(&local_event, &cgen_var_620, 1); stream->write((uint64_t*)&cgen_var_620, 1 * 8); stream->write((VkPipelineStageFlags*)&local_stageMask, sizeof(VkPipelineStageFlags)); - AEMU_SCOPED_TRACE("vkCmdResetEvent readParams"); - AEMU_SCOPED_TRACE("vkCmdResetEvent returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9325,7 +8856,6 @@ void VkEncoder::vkCmdWaitEvents( const VkImageMemoryBarrier* pImageMemoryBarriers) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdWaitEvents encode"); mImpl->log("start vkCmdWaitEvents"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9467,8 +8997,6 @@ void VkEncoder::vkCmdWaitEvents( { marshal_VkImageMemoryBarrier(stream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i)); } - AEMU_SCOPED_TRACE("vkCmdWaitEvents readParams"); - AEMU_SCOPED_TRACE("vkCmdWaitEvents returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9488,7 +9016,6 @@ void VkEncoder::vkCmdPipelineBarrier( const VkImageMemoryBarrier* pImageMemoryBarriers) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdPipelineBarrier encode"); mImpl->log("start vkCmdPipelineBarrier"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9610,8 +9137,6 @@ void VkEncoder::vkCmdPipelineBarrier( { marshal_VkImageMemoryBarrier(stream, (VkImageMemoryBarrier*)(local_pImageMemoryBarriers + i)); } - AEMU_SCOPED_TRACE("vkCmdPipelineBarrier readParams"); - AEMU_SCOPED_TRACE("vkCmdPipelineBarrier returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9625,7 +9150,6 @@ void VkEncoder::vkCmdBeginQuery( VkQueryControlFlags flags) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBeginQuery encode"); mImpl->log("start vkCmdBeginQuery"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9664,8 +9188,6 @@ void VkEncoder::vkCmdBeginQuery( stream->write((uint64_t*)&cgen_var_630, 1 * 8); stream->write((uint32_t*)&local_query, sizeof(uint32_t)); stream->write((VkQueryControlFlags*)&local_flags, sizeof(VkQueryControlFlags)); - AEMU_SCOPED_TRACE("vkCmdBeginQuery readParams"); - AEMU_SCOPED_TRACE("vkCmdBeginQuery returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9678,7 +9200,6 @@ void VkEncoder::vkCmdEndQuery( uint32_t query) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdEndQuery encode"); mImpl->log("start vkCmdEndQuery"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9713,8 +9234,6 @@ void VkEncoder::vkCmdEndQuery( stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_634, 1); stream->write((uint64_t*)&cgen_var_634, 1 * 8); stream->write((uint32_t*)&local_query, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdEndQuery readParams"); - AEMU_SCOPED_TRACE("vkCmdEndQuery returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9728,7 +9247,6 @@ void VkEncoder::vkCmdResetQueryPool( uint32_t queryCount) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdResetQueryPool encode"); mImpl->log("start vkCmdResetQueryPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9767,8 +9285,6 @@ void VkEncoder::vkCmdResetQueryPool( stream->write((uint64_t*)&cgen_var_638, 1 * 8); stream->write((uint32_t*)&local_firstQuery, sizeof(uint32_t)); stream->write((uint32_t*)&local_queryCount, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdResetQueryPool readParams"); - AEMU_SCOPED_TRACE("vkCmdResetQueryPool returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9782,7 +9298,6 @@ void VkEncoder::vkCmdWriteTimestamp( uint32_t query) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdWriteTimestamp encode"); mImpl->log("start vkCmdWriteTimestamp"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9821,8 +9336,6 @@ void VkEncoder::vkCmdWriteTimestamp( stream->handleMapping()->mapHandles_VkQueryPool_u64(&local_queryPool, &cgen_var_642, 1); stream->write((uint64_t*)&cgen_var_642, 1 * 8); stream->write((uint32_t*)&local_query, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdWriteTimestamp readParams"); - AEMU_SCOPED_TRACE("vkCmdWriteTimestamp returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9840,7 +9353,6 @@ void VkEncoder::vkCmdCopyQueryPoolResults( VkQueryResultFlags flags) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults encode"); mImpl->log("start vkCmdCopyQueryPoolResults"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9899,8 +9411,6 @@ void VkEncoder::vkCmdCopyQueryPoolResults( stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize)); stream->write((VkDeviceSize*)&local_stride, sizeof(VkDeviceSize)); stream->write((VkQueryResultFlags*)&local_flags, sizeof(VkQueryResultFlags)); - AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults readParams"); - AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9916,7 +9426,6 @@ void VkEncoder::vkCmdPushConstants( const void* pValues) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdPushConstants encode"); mImpl->log("start vkCmdPushConstants"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -9967,8 +9476,6 @@ void VkEncoder::vkCmdPushConstants( stream->write((uint32_t*)&local_offset, sizeof(uint32_t)); stream->write((uint32_t*)&local_size, sizeof(uint32_t)); stream->write((void*)local_pValues, ((size)) * sizeof(uint8_t)); - AEMU_SCOPED_TRACE("vkCmdPushConstants readParams"); - AEMU_SCOPED_TRACE("vkCmdPushConstants returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -9981,7 +9488,6 @@ void VkEncoder::vkCmdBeginRenderPass( VkSubpassContents contents) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBeginRenderPass encode"); mImpl->log("start vkCmdBeginRenderPass"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10021,8 +9527,6 @@ void VkEncoder::vkCmdBeginRenderPass( stream->write((uint64_t*)&cgen_var_654, 1 * 8); marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin)); stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents)); - AEMU_SCOPED_TRACE("vkCmdBeginRenderPass readParams"); - AEMU_SCOPED_TRACE("vkCmdBeginRenderPass returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10034,7 +9538,6 @@ void VkEncoder::vkCmdNextSubpass( VkSubpassContents contents) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdNextSubpass encode"); mImpl->log("start vkCmdNextSubpass"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10061,8 +9564,6 @@ void VkEncoder::vkCmdNextSubpass( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_656, 1); stream->write((uint64_t*)&cgen_var_656, 1 * 8); stream->write((VkSubpassContents*)&local_contents, sizeof(VkSubpassContents)); - AEMU_SCOPED_TRACE("vkCmdNextSubpass readParams"); - AEMU_SCOPED_TRACE("vkCmdNextSubpass returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10073,7 +9574,6 @@ void VkEncoder::vkCmdEndRenderPass( VkCommandBuffer commandBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdEndRenderPass encode"); mImpl->log("start vkCmdEndRenderPass"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10096,8 +9596,6 @@ void VkEncoder::vkCmdEndRenderPass( uint64_t cgen_var_658; stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_658, 1); stream->write((uint64_t*)&cgen_var_658, 1 * 8); - AEMU_SCOPED_TRACE("vkCmdEndRenderPass readParams"); - AEMU_SCOPED_TRACE("vkCmdEndRenderPass returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10110,7 +9608,6 @@ void VkEncoder::vkCmdExecuteCommands( const VkCommandBuffer* pCommandBuffers) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdExecuteCommands encode"); mImpl->log("start vkCmdExecuteCommands"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10157,8 +9654,6 @@ void VkEncoder::vkCmdExecuteCommands( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(local_pCommandBuffers, cgen_var_662, ((commandBufferCount))); stream->write((uint64_t*)cgen_var_662, ((commandBufferCount)) * 8); } - AEMU_SCOPED_TRACE("vkCmdExecuteCommands readParams"); - AEMU_SCOPED_TRACE("vkCmdExecuteCommands returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10171,7 +9666,6 @@ VkResult VkEncoder::vkEnumerateInstanceVersion( uint32_t* pApiVersion) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion encode"); mImpl->log("start vkEnumerateInstanceVersion"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10188,9 +9682,7 @@ VkResult VkEncoder::vkEnumerateInstanceVersion( stream->write(&opcode_vkEnumerateInstanceVersion, sizeof(uint32_t)); stream->write(&packetSize_vkEnumerateInstanceVersion, sizeof(uint32_t)); stream->write((uint32_t*)pApiVersion, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion readParams"); stream->read((uint32_t*)pApiVersion, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion returnUnmarshal"); VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0; stream->read(&vkEnumerateInstanceVersion_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -10206,7 +9698,6 @@ VkResult VkEncoder::vkBindBufferMemory2( const VkBindBufferMemoryInfo* pBindInfos) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkBindBufferMemory2 encode"); mImpl->log("start vkBindBufferMemory2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10258,8 +9749,6 @@ VkResult VkEncoder::vkBindBufferMemory2( { marshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i)); } - AEMU_SCOPED_TRACE("vkBindBufferMemory2 readParams"); - AEMU_SCOPED_TRACE("vkBindBufferMemory2 returnUnmarshal"); VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0; stream->read(&vkBindBufferMemory2_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -10275,7 +9764,6 @@ VkResult VkEncoder::vkBindImageMemory2( const VkBindImageMemoryInfo* pBindInfos) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkBindImageMemory2 encode"); mImpl->log("start vkBindImageMemory2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10327,8 +9815,6 @@ VkResult VkEncoder::vkBindImageMemory2( { marshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i)); } - AEMU_SCOPED_TRACE("vkBindImageMemory2 readParams"); - AEMU_SCOPED_TRACE("vkBindImageMemory2 returnUnmarshal"); VkResult vkBindImageMemory2_VkResult_return = (VkResult)0; stream->read(&vkBindImageMemory2_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -10346,7 +9832,6 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures( VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures encode"); mImpl->log("start vkGetDeviceGroupPeerMemoryFeatures"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10383,9 +9868,7 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeatures( stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t)); stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t)); stream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags)); - AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures readParams"); stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags)); - AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10397,7 +9880,6 @@ void VkEncoder::vkCmdSetDeviceMask( uint32_t deviceMask) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetDeviceMask encode"); mImpl->log("start vkCmdSetDeviceMask"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10424,8 +9906,6 @@ void VkEncoder::vkCmdSetDeviceMask( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_670, 1); stream->write((uint64_t*)&cgen_var_670, 1 * 8); stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdSetDeviceMask readParams"); - AEMU_SCOPED_TRACE("vkCmdSetDeviceMask returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10442,7 +9922,6 @@ void VkEncoder::vkCmdDispatchBase( uint32_t groupCountZ) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDispatchBase encode"); mImpl->log("start vkCmdDispatchBase"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10489,8 +9968,6 @@ void VkEncoder::vkCmdDispatchBase( stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t)); stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t)); stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDispatchBase readParams"); - AEMU_SCOPED_TRACE("vkCmdDispatchBase returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10503,7 +9980,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups( VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups encode"); mImpl->log("start vkEnumeratePhysicalDeviceGroups"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10560,7 +10036,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups( marshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups readParams"); // WARNING PTR CHECK uint32_t* check_pPhysicalDeviceGroupCount; check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -10593,7 +10068,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroups( transform_fromhost_VkPhysicalDeviceGroupProperties(mImpl->resources(), (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups returnUnmarshal"); VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0; stream->read(&vkEnumeratePhysicalDeviceGroups_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -10609,7 +10083,6 @@ void VkEncoder::vkGetImageMemoryRequirements2( VkMemoryRequirements2* pMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 encode"); mImpl->log("start vkGetImageMemoryRequirements2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10647,13 +10120,11 @@ void VkEncoder::vkGetImageMemoryRequirements2( stream->write((uint64_t*)&cgen_var_682, 1 * 8); marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo)); marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements)); - AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 readParams"); unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements)); if (pMemoryRequirements) { transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements)); } - AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2 returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10666,7 +10137,6 @@ void VkEncoder::vkGetBufferMemoryRequirements2( VkMemoryRequirements2* pMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 encode"); mImpl->log("start vkGetBufferMemoryRequirements2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10704,13 +10174,11 @@ void VkEncoder::vkGetBufferMemoryRequirements2( stream->write((uint64_t*)&cgen_var_684, 1 * 8); marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo)); marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements)); - AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 readParams"); unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements)); if (pMemoryRequirements) { transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements)); } - AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2 returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10724,7 +10192,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2( VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2 encode"); mImpl->log("start vkGetImageSparseMemoryRequirements2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10794,7 +10261,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2( marshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i)); } } - AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2 readParams"); // WARNING PTR CHECK uint32_t* check_pSparseMemoryRequirementCount; check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -10827,7 +10293,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2( transform_fromhost_VkSparseImageMemoryRequirements2(mImpl->resources(), (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i)); } } - AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2 returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10839,7 +10304,6 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2* pFeatures) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 encode"); mImpl->log("start vkGetPhysicalDeviceFeatures2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10864,13 +10328,11 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_694, 1); stream->write((uint64_t*)&cgen_var_694, 1 * 8); marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 readParams"); unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures)); if (pFeatures) { transform_fromhost_VkPhysicalDeviceFeatures2(mImpl->resources(), (VkPhysicalDeviceFeatures2*)(pFeatures)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2 returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10882,7 +10344,6 @@ void VkEncoder::vkGetPhysicalDeviceProperties2( VkPhysicalDeviceProperties2* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 encode"); mImpl->log("start vkGetPhysicalDeviceProperties2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10907,13 +10368,11 @@ void VkEncoder::vkGetPhysicalDeviceProperties2( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_696, 1); stream->write((uint64_t*)&cgen_var_696, 1 * 8); marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 readParams"); unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties)); if (pProperties) { transform_fromhost_VkPhysicalDeviceProperties2(mImpl->resources(), (VkPhysicalDeviceProperties2*)(pProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2 returnUnmarshal"); mImpl->resources()->on_vkGetPhysicalDeviceProperties2(this, physicalDevice, pProperties); pool->freeAll(); countingStream->clearPool(); @@ -10927,7 +10386,6 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2( VkFormatProperties2* pFormatProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 encode"); mImpl->log("start vkGetPhysicalDeviceFormatProperties2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -10956,13 +10414,11 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2( stream->write((uint64_t*)&cgen_var_698, 1 * 8); stream->write((VkFormat*)&local_format, sizeof(VkFormat)); marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 readParams"); unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties)); if (pFormatProperties) { transform_fromhost_VkFormatProperties2(mImpl->resources(), (VkFormatProperties2*)(pFormatProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2 returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -10975,7 +10431,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2( VkImageFormatProperties2* pImageFormatProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 encode"); mImpl->log("start vkGetPhysicalDeviceImageFormatProperties2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11013,13 +10468,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2( stream->write((uint64_t*)&cgen_var_700, 1 * 8); marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo)); marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 readParams"); unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties)); if (pImageFormatProperties) { transform_fromhost_VkImageFormatProperties2(mImpl->resources(), (VkImageFormatProperties2*)(pImageFormatProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2 returnUnmarshal"); VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceImageFormatProperties2_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -11035,7 +10488,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2( VkQueueFamilyProperties2* pQueueFamilyProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2 encode"); mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11092,7 +10544,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2( marshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2 readParams"); // WARNING PTR CHECK uint32_t* check_pQueueFamilyPropertyCount; check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -11125,7 +10576,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2( transform_fromhost_VkQueueFamilyProperties2(mImpl->resources(), (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2 returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -11137,7 +10587,6 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 encode"); mImpl->log("start vkGetPhysicalDeviceMemoryProperties2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11162,13 +10611,11 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_710, 1); stream->write((uint64_t*)&cgen_var_710, 1 * 8); marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 readParams"); unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties)); if (pMemoryProperties) { transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2 returnUnmarshal"); mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2(this, physicalDevice, pMemoryProperties); pool->freeAll(); countingStream->clearPool(); @@ -11183,7 +10630,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2( VkSparseImageFormatProperties2* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2 encode"); mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11253,7 +10699,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2( marshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2 readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -11286,7 +10731,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2( transform_fromhost_VkSparseImageFormatProperties2(mImpl->resources(), (VkSparseImageFormatProperties2*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2 returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -11299,7 +10743,6 @@ void VkEncoder::vkTrimCommandPool( VkCommandPoolTrimFlags flags) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkTrimCommandPool encode"); mImpl->log("start vkTrimCommandPool"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11334,8 +10777,6 @@ void VkEncoder::vkTrimCommandPool( stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_722, 1); stream->write((uint64_t*)&cgen_var_722, 1 * 8); stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags)); - AEMU_SCOPED_TRACE("vkTrimCommandPool readParams"); - AEMU_SCOPED_TRACE("vkTrimCommandPool returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -11348,7 +10789,6 @@ void VkEncoder::vkGetDeviceQueue2( VkQueue* pQueue) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDeviceQueue2 encode"); mImpl->log("start vkGetDeviceQueue2"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11392,11 +10832,9 @@ void VkEncoder::vkGetDeviceQueue2( stream->handleMapping()->mapHandles_VkQueue_u64(pQueue, &cgen_var_726, 1); stream->write((uint64_t*)&cgen_var_726, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkGetDeviceQueue2 readParams"); uint64_t cgen_var_727; stream->read((uint64_t*)&cgen_var_727, 8); stream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_727, (VkQueue*)pQueue, 1); - AEMU_SCOPED_TRACE("vkGetDeviceQueue2 returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -11410,7 +10848,6 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversion( VkSamplerYcbcrConversion* pYcbcrConversion) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion encode"); mImpl->log("start vkCreateSamplerYcbcrConversion"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11480,13 +10917,11 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversion( stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_733, 1); stream->write((uint64_t*)&cgen_var_733, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_734; stream->read((uint64_t*)&cgen_var_734, 8); stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_734, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion returnUnmarshal"); VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0; stream->read(&vkCreateSamplerYcbcrConversion_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -11502,7 +10937,6 @@ void VkEncoder::vkDestroySamplerYcbcrConversion( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion encode"); mImpl->log("start vkDestroySamplerYcbcrConversion"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11559,8 +10993,6 @@ void VkEncoder::vkDestroySamplerYcbcrConversion( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion readParams"); - AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion returnUnmarshal"); resources->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion); pool->freeAll(); countingStream->clearPool(); @@ -11575,7 +11007,6 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplate( VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate encode"); mImpl->log("start vkCreateDescriptorUpdateTemplate"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11645,13 +11076,11 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplate( stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_746, 1); stream->write((uint64_t*)&cgen_var_746, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_747; stream->read((uint64_t*)&cgen_var_747, 8); stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_747, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate returnUnmarshal"); VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0; stream->read(&vkCreateDescriptorUpdateTemplate_VkResult_return, sizeof(VkResult)); mImpl->resources()->on_vkCreateDescriptorUpdateTemplate(this, vkCreateDescriptorUpdateTemplate_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); @@ -11668,7 +11097,6 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplate( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate encode"); mImpl->log("start vkDestroyDescriptorUpdateTemplate"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11725,8 +11153,6 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplate( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate readParams"); - AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate returnUnmarshal"); resources->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate); pool->freeAll(); countingStream->clearPool(); @@ -11741,7 +11167,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplate( const void* pData) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate encode"); mImpl->log("start vkUpdateDescriptorSetWithTemplate"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11800,8 +11225,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplate( { stream->write((void*)local_pData, sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate readParams"); - AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -11814,7 +11237,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties( VkExternalBufferProperties* pExternalBufferProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties encode"); mImpl->log("start vkGetPhysicalDeviceExternalBufferProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11853,14 +11275,12 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferProperties( stream->write((uint64_t*)&cgen_var_763, 1 * 8); marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo)); marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties readParams"); unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties)); if (pExternalBufferProperties) { mImpl->resources()->transformImpl_VkExternalBufferProperties_fromhost(pExternalBufferProperties, 1); transform_fromhost_VkExternalBufferProperties(mImpl->resources(), (VkExternalBufferProperties*)(pExternalBufferProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -11873,7 +11293,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties( VkExternalFenceProperties* pExternalFenceProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties encode"); mImpl->log("start vkGetPhysicalDeviceExternalFenceProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11911,13 +11330,11 @@ void VkEncoder::vkGetPhysicalDeviceExternalFenceProperties( stream->write((uint64_t*)&cgen_var_765, 1 * 8); marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo)); marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties readParams"); unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties)); if (pExternalFenceProperties) { transform_fromhost_VkExternalFenceProperties(mImpl->resources(), (VkExternalFenceProperties*)(pExternalFenceProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -11930,7 +11347,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphoreProperties( VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties encode"); mImpl->log("start vkGetPhysicalDeviceExternalSemaphoreProperties"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -11968,13 +11384,11 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphoreProperties( stream->write((uint64_t*)&cgen_var_767, 1 * 8); marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo)); marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties readParams"); unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties)); if (pExternalSemaphoreProperties) { transform_fromhost_VkExternalSemaphoreProperties(mImpl->resources(), (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -11987,7 +11401,6 @@ void VkEncoder::vkGetDescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport* pSupport) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport encode"); mImpl->log("start vkGetDescriptorSetLayoutSupport"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12025,13 +11438,11 @@ void VkEncoder::vkGetDescriptorSetLayoutSupport( stream->write((uint64_t*)&cgen_var_769, 1 * 8); marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo)); marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport)); - AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport readParams"); unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport)); if (pSupport) { transform_fromhost_VkDescriptorSetLayoutSupport(mImpl->resources(), (VkDescriptorSetLayoutSupport*)(pSupport)); } - AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -12046,7 +11457,6 @@ void VkEncoder::vkDestroySurfaceKHR( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroySurfaceKHR encode"); mImpl->log("start vkDestroySurfaceKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12103,8 +11513,6 @@ void VkEncoder::vkDestroySurfaceKHR( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroySurfaceKHR readParams"); - AEMU_SCOPED_TRACE("vkDestroySurfaceKHR returnUnmarshal"); resources->destroyMapping()->mapHandles_VkSurfaceKHR((VkSurfaceKHR*)&surface); pool->freeAll(); countingStream->clearPool(); @@ -12119,7 +11527,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR( VkBool32* pSupported) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR encode"); mImpl->log("start vkGetPhysicalDeviceSurfaceSupportKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12156,9 +11563,7 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceSupportKHR( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_779, 1); stream->write((uint64_t*)&cgen_var_779, 1 * 8); stream->write((VkBool32*)pSupported, sizeof(VkBool32)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR readParams"); stream->read((VkBool32*)pSupported, sizeof(VkBool32)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR returnUnmarshal"); VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12174,7 +11579,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR encode"); mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12207,13 +11611,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_783, 1); stream->write((uint64_t*)&cgen_var_783, 1 * 8); marshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR readParams"); unmarshal_VkSurfaceCapabilitiesKHR(stream, (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities)); if (pSurfaceCapabilities) { transform_fromhost_VkSurfaceCapabilitiesKHR(mImpl->resources(), (VkSurfaceCapabilitiesKHR*)(pSurfaceCapabilities)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR returnUnmarshal"); VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12230,7 +11632,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR( VkSurfaceFormatKHR* pSurfaceFormats) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR encode"); mImpl->log("start vkGetPhysicalDeviceSurfaceFormatsKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12295,7 +11696,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR( marshal_VkSurfaceFormatKHR(stream, (VkSurfaceFormatKHR*)(pSurfaceFormats + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR readParams"); // WARNING PTR CHECK uint32_t* check_pSurfaceFormatCount; check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -12328,7 +11728,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormatsKHR( transform_fromhost_VkSurfaceFormatKHR(mImpl->resources(), (VkSurfaceFormatKHR*)(pSurfaceFormats + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR returnUnmarshal"); VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12345,7 +11744,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR( VkPresentModeKHR* pPresentModes) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR encode"); mImpl->log("start vkGetPhysicalDeviceSurfacePresentModesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12404,7 +11802,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR( { stream->write((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR readParams"); // WARNING PTR CHECK uint32_t* check_pPresentModeCount; check_pPresentModeCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -12427,7 +11824,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfacePresentModesKHR( } stream->read((VkPresentModeKHR*)pPresentModes, (*(pPresentModeCount)) * sizeof(VkPresentModeKHR)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR returnUnmarshal"); VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12446,7 +11842,6 @@ VkResult VkEncoder::vkCreateSwapchainKHR( VkSwapchainKHR* pSwapchain) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateSwapchainKHR encode"); mImpl->log("start vkCreateSwapchainKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12516,13 +11911,11 @@ VkResult VkEncoder::vkCreateSwapchainKHR( stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(pSwapchain, &cgen_var_809, 1); stream->write((uint64_t*)&cgen_var_809, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateSwapchainKHR readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_810; stream->read((uint64_t*)&cgen_var_810, 8); stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_810, (VkSwapchainKHR*)pSwapchain, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateSwapchainKHR returnUnmarshal"); VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateSwapchainKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12538,7 +11931,6 @@ void VkEncoder::vkDestroySwapchainKHR( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroySwapchainKHR encode"); mImpl->log("start vkDestroySwapchainKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12595,8 +11987,6 @@ void VkEncoder::vkDestroySwapchainKHR( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroySwapchainKHR readParams"); - AEMU_SCOPED_TRACE("vkDestroySwapchainKHR returnUnmarshal"); resources->destroyMapping()->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&swapchain); pool->freeAll(); countingStream->clearPool(); @@ -12611,7 +12001,6 @@ VkResult VkEncoder::vkGetSwapchainImagesKHR( VkImage* pSwapchainImages) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR encode"); mImpl->log("start vkGetSwapchainImagesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12684,7 +12073,6 @@ VkResult VkEncoder::vkGetSwapchainImagesKHR( } } stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR readParams"); // WARNING PTR CHECK uint32_t* check_pSwapchainImageCount; check_pSwapchainImageCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -12713,7 +12101,6 @@ VkResult VkEncoder::vkGetSwapchainImagesKHR( stream->handleMapping()->mapHandles_u64_VkImage(cgen_var_829, (VkImage*)pSwapchainImages, (*(pSwapchainImageCount))); } } - AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR returnUnmarshal"); VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetSwapchainImagesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12732,7 +12119,6 @@ VkResult VkEncoder::vkAcquireNextImageKHR( uint32_t* pImageIndex) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkAcquireNextImageKHR encode"); mImpl->log("start vkAcquireNextImageKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12785,9 +12171,7 @@ VkResult VkEncoder::vkAcquireNextImageKHR( stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_837, 1); stream->write((uint64_t*)&cgen_var_837, 1 * 8); stream->write((uint32_t*)pImageIndex, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkAcquireNextImageKHR readParams"); stream->read((uint32_t*)pImageIndex, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkAcquireNextImageKHR returnUnmarshal"); VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0; stream->read(&vkAcquireNextImageKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12802,7 +12186,6 @@ VkResult VkEncoder::vkQueuePresentKHR( const VkPresentInfoKHR* pPresentInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueuePresentKHR encode"); mImpl->log("start vkQueuePresentKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12838,8 +12221,6 @@ VkResult VkEncoder::vkQueuePresentKHR( stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_839, 1); stream->write((uint64_t*)&cgen_var_839, 1 * 8); marshal_VkPresentInfoKHR(stream, (VkPresentInfoKHR*)(local_pPresentInfo)); - AEMU_SCOPED_TRACE("vkQueuePresentKHR readParams"); - AEMU_SCOPED_TRACE("vkQueuePresentKHR returnUnmarshal"); VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0; stream->read(&vkQueuePresentKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12854,7 +12235,6 @@ VkResult VkEncoder::vkGetDeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR encode"); mImpl->log("start vkGetDeviceGroupPresentCapabilitiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12879,13 +12259,11 @@ VkResult VkEncoder::vkGetDeviceGroupPresentCapabilitiesKHR( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_841, 1); stream->write((uint64_t*)&cgen_var_841, 1 * 8); marshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities)); - AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR readParams"); unmarshal_VkDeviceGroupPresentCapabilitiesKHR(stream, (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities)); if (pDeviceGroupPresentCapabilities) { transform_fromhost_VkDeviceGroupPresentCapabilitiesKHR(mImpl->resources(), (VkDeviceGroupPresentCapabilitiesKHR*)(pDeviceGroupPresentCapabilities)); } - AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR returnUnmarshal"); VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12901,7 +12279,6 @@ VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR( VkDeviceGroupPresentModeFlagsKHR* pModes) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR encode"); mImpl->log("start vkGetDeviceGroupSurfacePresentModesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -12946,7 +12323,6 @@ VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR( { stream->write((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR)); } - AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR readParams"); // WARNING PTR CHECK VkDeviceGroupPresentModeFlagsKHR* check_pModes; check_pModes = (VkDeviceGroupPresentModeFlagsKHR*)(uintptr_t)stream->getBe64(); @@ -12958,7 +12334,6 @@ VkResult VkEncoder::vkGetDeviceGroupSurfacePresentModesKHR( } stream->read((VkDeviceGroupPresentModeFlagsKHR*)pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR)); } - AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR returnUnmarshal"); VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -12975,7 +12350,6 @@ VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR( VkRect2D* pRects) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR encode"); mImpl->log("start vkGetPhysicalDevicePresentRectanglesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13040,7 +12414,6 @@ VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR( marshal_VkRect2D(stream, (VkRect2D*)(pRects + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR readParams"); // WARNING PTR CHECK uint32_t* check_pRectCount; check_pRectCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -13073,7 +12446,6 @@ VkResult VkEncoder::vkGetPhysicalDevicePresentRectanglesKHR( transform_fromhost_VkRect2D(mImpl->resources(), (VkRect2D*)(pRects + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR returnUnmarshal"); VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13089,7 +12461,6 @@ VkResult VkEncoder::vkAcquireNextImage2KHR( uint32_t* pImageIndex) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR encode"); mImpl->log("start vkAcquireNextImage2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13127,9 +12498,7 @@ VkResult VkEncoder::vkAcquireNextImage2KHR( stream->write((uint64_t*)&cgen_var_860, 1 * 8); marshal_VkAcquireNextImageInfoKHR(stream, (VkAcquireNextImageInfoKHR*)(local_pAcquireInfo)); stream->write((uint32_t*)pImageIndex, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR readParams"); stream->read((uint32_t*)pImageIndex, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR returnUnmarshal"); VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0; stream->read(&vkAcquireNextImage2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13147,7 +12516,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR( VkDisplayPropertiesKHR* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR encode"); mImpl->log("start vkGetPhysicalDeviceDisplayPropertiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13204,7 +12572,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR( marshal_VkDisplayPropertiesKHR(stream, (VkDisplayPropertiesKHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -13237,7 +12604,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPropertiesKHR( transform_fromhost_VkDisplayPropertiesKHR(mImpl->resources(), (VkDisplayPropertiesKHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR returnUnmarshal"); VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13253,7 +12619,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR encode"); mImpl->log("start vkGetPhysicalDeviceDisplayPlanePropertiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13310,7 +12675,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( marshal_VkDisplayPlanePropertiesKHR(stream, (VkDisplayPlanePropertiesKHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -13343,7 +12707,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( transform_fromhost_VkDisplayPlanePropertiesKHR(mImpl->resources(), (VkDisplayPlanePropertiesKHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR returnUnmarshal"); VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13360,7 +12723,6 @@ VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR( VkDisplayKHR* pDisplays) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR encode"); mImpl->log("start vkGetDisplayPlaneSupportedDisplaysKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13429,7 +12791,6 @@ VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR( } } stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR readParams"); // WARNING PTR CHECK uint32_t* check_pDisplayCount; check_pDisplayCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -13458,7 +12819,6 @@ VkResult VkEncoder::vkGetDisplayPlaneSupportedDisplaysKHR( stream->handleMapping()->mapHandles_u64_VkDisplayKHR(cgen_var_887, (VkDisplayKHR*)pDisplays, (*(pDisplayCount))); } } - AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR returnUnmarshal"); VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0; stream->read(&vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13475,7 +12835,6 @@ VkResult VkEncoder::vkGetDisplayModePropertiesKHR( VkDisplayModePropertiesKHR* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR encode"); mImpl->log("start vkGetDisplayModePropertiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13540,7 +12899,6 @@ VkResult VkEncoder::vkGetDisplayModePropertiesKHR( marshal_VkDisplayModePropertiesKHR(stream, (VkDisplayModePropertiesKHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -13573,7 +12931,6 @@ VkResult VkEncoder::vkGetDisplayModePropertiesKHR( transform_fromhost_VkDisplayModePropertiesKHR(mImpl->resources(), (VkDisplayModePropertiesKHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR returnUnmarshal"); VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetDisplayModePropertiesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13591,7 +12948,6 @@ VkResult VkEncoder::vkCreateDisplayModeKHR( VkDisplayModeKHR* pMode) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR encode"); mImpl->log("start vkCreateDisplayModeKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13669,13 +13025,11 @@ VkResult VkEncoder::vkCreateDisplayModeKHR( stream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(pMode, &cgen_var_905, 1); stream->write((uint64_t*)&cgen_var_905, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_906; stream->read((uint64_t*)&cgen_var_906, 8); stream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_906, (VkDisplayModeKHR*)pMode, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR returnUnmarshal"); VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateDisplayModeKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13692,7 +13046,6 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR* pCapabilities) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR encode"); mImpl->log("start vkGetDisplayPlaneCapabilitiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13729,13 +13082,11 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilitiesKHR( stream->write((uint64_t*)&cgen_var_910, 1 * 8); stream->write((uint32_t*)&local_planeIndex, sizeof(uint32_t)); marshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities)); - AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR readParams"); unmarshal_VkDisplayPlaneCapabilitiesKHR(stream, (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities)); if (pCapabilities) { transform_fromhost_VkDisplayPlaneCapabilitiesKHR(mImpl->resources(), (VkDisplayPlaneCapabilitiesKHR*)(pCapabilities)); } - AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR returnUnmarshal"); VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetDisplayPlaneCapabilitiesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13752,7 +13103,6 @@ VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR encode"); mImpl->log("start vkCreateDisplayPlaneSurfaceKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13822,11 +13172,9 @@ VkResult VkEncoder::vkCreateDisplayPlaneSurfaceKHR( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_916, 1); stream->write((uint64_t*)&cgen_var_916, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR readParams"); uint64_t cgen_var_917; stream->read((uint64_t*)&cgen_var_917, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_917, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR returnUnmarshal"); VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateDisplayPlaneSurfaceKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13846,7 +13194,6 @@ VkResult VkEncoder::vkCreateSharedSwapchainsKHR( VkSwapchainKHR* pSwapchains) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR encode"); mImpl->log("start vkCreateSharedSwapchainsKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -13940,7 +13287,6 @@ VkResult VkEncoder::vkCreateSharedSwapchainsKHR( stream->write((uint64_t*)cgen_var_923, ((swapchainCount)) * 8); } stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR readParams"); if (((swapchainCount))) { uint64_t* cgen_var_924; @@ -13948,7 +13294,6 @@ VkResult VkEncoder::vkCreateSharedSwapchainsKHR( stream->read((uint64_t*)cgen_var_924, ((swapchainCount)) * 8); stream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_924, (VkSwapchainKHR*)pSwapchains, ((swapchainCount))); } - AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR returnUnmarshal"); VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateSharedSwapchainsKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -13967,7 +13312,6 @@ VkResult VkEncoder::vkCreateXlibSurfaceKHR( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR encode"); mImpl->log("start vkCreateXlibSurfaceKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14037,11 +13381,9 @@ VkResult VkEncoder::vkCreateXlibSurfaceKHR( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_930, 1); stream->write((uint64_t*)&cgen_var_930, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR readParams"); uint64_t cgen_var_931; stream->read((uint64_t*)&cgen_var_931, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_931, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR returnUnmarshal"); VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateXlibSurfaceKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -14058,7 +13400,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR( VisualID visualID) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR encode"); mImpl->log("start vkGetPhysicalDeviceXlibPresentationSupportKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14091,9 +13432,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXlibPresentationSupportKHR( stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t)); stream->write((Display*)dpy, sizeof(Display)); stream->write((VisualID*)&local_visualID, sizeof(VisualID)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR readParams"); stream->read((Display*)dpy, sizeof(Display)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR returnUnmarshal"); VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0; stream->read(&vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return, sizeof(VkBool32)); pool->freeAll(); @@ -14112,7 +13451,6 @@ VkResult VkEncoder::vkCreateXcbSurfaceKHR( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR encode"); mImpl->log("start vkCreateXcbSurfaceKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14182,11 +13520,9 @@ VkResult VkEncoder::vkCreateXcbSurfaceKHR( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_939, 1); stream->write((uint64_t*)&cgen_var_939, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR readParams"); uint64_t cgen_var_940; stream->read((uint64_t*)&cgen_var_940, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_940, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR returnUnmarshal"); VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateXcbSurfaceKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -14203,7 +13539,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR( xcb_visualid_t visual_id) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR encode"); mImpl->log("start vkGetPhysicalDeviceXcbPresentationSupportKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14236,9 +13571,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceXcbPresentationSupportKHR( stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t)); stream->write((xcb_connection_t*)connection, sizeof(xcb_connection_t)); stream->write((xcb_visualid_t*)&local_visual_id, sizeof(xcb_visualid_t)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR readParams"); stream->read((xcb_connection_t*)connection, sizeof(xcb_connection_t)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR returnUnmarshal"); VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0; stream->read(&vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return, sizeof(VkBool32)); pool->freeAll(); @@ -14257,7 +13590,6 @@ VkResult VkEncoder::vkCreateWaylandSurfaceKHR( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR encode"); mImpl->log("start vkCreateWaylandSurfaceKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14327,11 +13659,9 @@ VkResult VkEncoder::vkCreateWaylandSurfaceKHR( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_948, 1); stream->write((uint64_t*)&cgen_var_948, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR readParams"); uint64_t cgen_var_949; stream->read((uint64_t*)&cgen_var_949, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_949, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR returnUnmarshal"); VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateWaylandSurfaceKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -14347,7 +13677,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWaylandPresentationSupportKHR( wl_display* display) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR encode"); mImpl->log("start vkGetPhysicalDeviceWaylandPresentationSupportKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14376,9 +13705,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWaylandPresentationSupportKHR( stream->write((uint64_t*)&cgen_var_951, 1 * 8); stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t)); stream->write((wl_display*)display, sizeof(wl_display)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR readParams"); stream->read((wl_display*)display, sizeof(wl_display)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWaylandPresentationSupportKHR returnUnmarshal"); VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return = (VkBool32)0; stream->read(&vkGetPhysicalDeviceWaylandPresentationSupportKHR_VkBool32_return, sizeof(VkBool32)); pool->freeAll(); @@ -14397,7 +13724,6 @@ VkResult VkEncoder::vkCreateMirSurfaceKHR( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR encode"); mImpl->log("start vkCreateMirSurfaceKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14467,11 +13793,9 @@ VkResult VkEncoder::vkCreateMirSurfaceKHR( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_957, 1); stream->write((uint64_t*)&cgen_var_957, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR readParams"); uint64_t cgen_var_958; stream->read((uint64_t*)&cgen_var_958, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_958, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateMirSurfaceKHR returnUnmarshal"); VkResult vkCreateMirSurfaceKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateMirSurfaceKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -14487,7 +13811,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceMirPresentationSupportKHR( MirConnection* connection) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR encode"); mImpl->log("start vkGetPhysicalDeviceMirPresentationSupportKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14516,9 +13839,7 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceMirPresentationSupportKHR( stream->write((uint64_t*)&cgen_var_960, 1 * 8); stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t)); stream->write((MirConnection*)connection, sizeof(MirConnection)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR readParams"); stream->read((MirConnection*)connection, sizeof(MirConnection)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMirPresentationSupportKHR returnUnmarshal"); VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return = (VkBool32)0; stream->read(&vkGetPhysicalDeviceMirPresentationSupportKHR_VkBool32_return, sizeof(VkBool32)); pool->freeAll(); @@ -14537,7 +13858,6 @@ VkResult VkEncoder::vkCreateAndroidSurfaceKHR( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR encode"); mImpl->log("start vkCreateAndroidSurfaceKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14607,11 +13927,9 @@ VkResult VkEncoder::vkCreateAndroidSurfaceKHR( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_966, 1); stream->write((uint64_t*)&cgen_var_966, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR readParams"); uint64_t cgen_var_967; stream->read((uint64_t*)&cgen_var_967, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_967, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR returnUnmarshal"); VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateAndroidSurfaceKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -14630,7 +13948,6 @@ VkResult VkEncoder::vkCreateWin32SurfaceKHR( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR encode"); mImpl->log("start vkCreateWin32SurfaceKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14700,11 +14017,9 @@ VkResult VkEncoder::vkCreateWin32SurfaceKHR( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_973, 1); stream->write((uint64_t*)&cgen_var_973, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR readParams"); uint64_t cgen_var_974; stream->read((uint64_t*)&cgen_var_974, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_974, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateWin32SurfaceKHR returnUnmarshal"); VkResult vkCreateWin32SurfaceKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateWin32SurfaceKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -14719,7 +14034,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR( uint32_t queueFamilyIndex) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR encode"); mImpl->log("start vkGetPhysicalDeviceWin32PresentationSupportKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14746,8 +14060,6 @@ VkBool32 VkEncoder::vkGetPhysicalDeviceWin32PresentationSupportKHR( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_976, 1); stream->write((uint64_t*)&cgen_var_976, 1 * 8); stream->write((uint32_t*)&local_queueFamilyIndex, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR readParams"); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceWin32PresentationSupportKHR returnUnmarshal"); VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return = (VkBool32)0; stream->read(&vkGetPhysicalDeviceWin32PresentationSupportKHR_VkBool32_return, sizeof(VkBool32)); pool->freeAll(); @@ -14768,7 +14080,6 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDeviceFeatures2* pFeatures) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR encode"); mImpl->log("start vkGetPhysicalDeviceFeatures2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14793,13 +14104,11 @@ void VkEncoder::vkGetPhysicalDeviceFeatures2KHR( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_978, 1); stream->write((uint64_t*)&cgen_var_978, 1 * 8); marshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR readParams"); unmarshal_VkPhysicalDeviceFeatures2(stream, (VkPhysicalDeviceFeatures2*)(pFeatures)); if (pFeatures) { transform_fromhost_VkPhysicalDeviceFeatures2(mImpl->resources(), (VkPhysicalDeviceFeatures2*)(pFeatures)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -14811,7 +14120,6 @@ void VkEncoder::vkGetPhysicalDeviceProperties2KHR( VkPhysicalDeviceProperties2* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR encode"); mImpl->log("start vkGetPhysicalDeviceProperties2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14836,13 +14144,11 @@ void VkEncoder::vkGetPhysicalDeviceProperties2KHR( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_980, 1); stream->write((uint64_t*)&cgen_var_980, 1 * 8); marshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR readParams"); unmarshal_VkPhysicalDeviceProperties2(stream, (VkPhysicalDeviceProperties2*)(pProperties)); if (pProperties) { transform_fromhost_VkPhysicalDeviceProperties2(mImpl->resources(), (VkPhysicalDeviceProperties2*)(pProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR returnUnmarshal"); mImpl->resources()->on_vkGetPhysicalDeviceProperties2KHR(this, physicalDevice, pProperties); pool->freeAll(); countingStream->clearPool(); @@ -14856,7 +14162,6 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR( VkFormatProperties2* pFormatProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR encode"); mImpl->log("start vkGetPhysicalDeviceFormatProperties2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14885,13 +14190,11 @@ void VkEncoder::vkGetPhysicalDeviceFormatProperties2KHR( stream->write((uint64_t*)&cgen_var_982, 1 * 8); stream->write((VkFormat*)&local_format, sizeof(VkFormat)); marshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR readParams"); unmarshal_VkFormatProperties2(stream, (VkFormatProperties2*)(pFormatProperties)); if (pFormatProperties) { transform_fromhost_VkFormatProperties2(mImpl->resources(), (VkFormatProperties2*)(pFormatProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -14904,7 +14207,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR( VkImageFormatProperties2* pImageFormatProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR encode"); mImpl->log("start vkGetPhysicalDeviceImageFormatProperties2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -14942,13 +14244,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceImageFormatProperties2KHR( stream->write((uint64_t*)&cgen_var_984, 1 * 8); marshal_VkPhysicalDeviceImageFormatInfo2(stream, (VkPhysicalDeviceImageFormatInfo2*)(local_pImageFormatInfo)); marshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR readParams"); unmarshal_VkImageFormatProperties2(stream, (VkImageFormatProperties2*)(pImageFormatProperties)); if (pImageFormatProperties) { transform_fromhost_VkImageFormatProperties2(mImpl->resources(), (VkImageFormatProperties2*)(pImageFormatProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR returnUnmarshal"); VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -14964,7 +14264,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkQueueFamilyProperties2* pQueueFamilyProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR encode"); mImpl->log("start vkGetPhysicalDeviceQueueFamilyProperties2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15021,7 +14320,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR( marshal_VkQueueFamilyProperties2(stream, (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR readParams"); // WARNING PTR CHECK uint32_t* check_pQueueFamilyPropertyCount; check_pQueueFamilyPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -15054,7 +14352,6 @@ void VkEncoder::vkGetPhysicalDeviceQueueFamilyProperties2KHR( transform_fromhost_VkQueueFamilyProperties2(mImpl->resources(), (VkQueueFamilyProperties2*)(pQueueFamilyProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -15066,7 +14363,6 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR encode"); mImpl->log("start vkGetPhysicalDeviceMemoryProperties2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15091,13 +14387,11 @@ void VkEncoder::vkGetPhysicalDeviceMemoryProperties2KHR( stream->handleMapping()->mapHandles_VkPhysicalDevice_u64(&local_physicalDevice, &cgen_var_994, 1); stream->write((uint64_t*)&cgen_var_994, 1 * 8); marshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR readParams"); unmarshal_VkPhysicalDeviceMemoryProperties2(stream, (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties)); if (pMemoryProperties) { transform_fromhost_VkPhysicalDeviceMemoryProperties2(mImpl->resources(), (VkPhysicalDeviceMemoryProperties2*)(pMemoryProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR returnUnmarshal"); mImpl->resources()->on_vkGetPhysicalDeviceMemoryProperties2KHR(this, physicalDevice, pMemoryProperties); pool->freeAll(); countingStream->clearPool(); @@ -15112,7 +14406,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkSparseImageFormatProperties2* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR encode"); mImpl->log("start vkGetPhysicalDeviceSparseImageFormatProperties2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15182,7 +14475,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( marshal_VkSparseImageFormatProperties2(stream, (VkSparseImageFormatProperties2*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -15215,7 +14507,6 @@ void VkEncoder::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( transform_fromhost_VkSparseImageFormatProperties2(mImpl->resources(), (VkSparseImageFormatProperties2*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -15232,7 +14523,6 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR( VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR encode"); mImpl->log("start vkGetDeviceGroupPeerMemoryFeaturesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15269,9 +14559,7 @@ void VkEncoder::vkGetDeviceGroupPeerMemoryFeaturesKHR( stream->write((uint32_t*)&local_localDeviceIndex, sizeof(uint32_t)); stream->write((uint32_t*)&local_remoteDeviceIndex, sizeof(uint32_t)); stream->write((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags)); - AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR readParams"); stream->read((VkPeerMemoryFeatureFlags*)pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags)); - AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -15283,7 +14571,6 @@ void VkEncoder::vkCmdSetDeviceMaskKHR( uint32_t deviceMask) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR encode"); mImpl->log("start vkCmdSetDeviceMaskKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15310,8 +14597,6 @@ void VkEncoder::vkCmdSetDeviceMaskKHR( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1006, 1); stream->write((uint64_t*)&cgen_var_1006, 1 * 8); stream->write((uint32_t*)&local_deviceMask, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR readParams"); - AEMU_SCOPED_TRACE("vkCmdSetDeviceMaskKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -15328,7 +14613,6 @@ void VkEncoder::vkCmdDispatchBaseKHR( uint32_t groupCountZ) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR encode"); mImpl->log("start vkCmdDispatchBaseKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15375,8 +14659,6 @@ void VkEncoder::vkCmdDispatchBaseKHR( stream->write((uint32_t*)&local_groupCountX, sizeof(uint32_t)); stream->write((uint32_t*)&local_groupCountY, sizeof(uint32_t)); stream->write((uint32_t*)&local_groupCountZ, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR readParams"); - AEMU_SCOPED_TRACE("vkCmdDispatchBaseKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -15393,7 +14675,6 @@ void VkEncoder::vkTrimCommandPoolKHR( VkCommandPoolTrimFlags flags) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR encode"); mImpl->log("start vkTrimCommandPoolKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15428,8 +14709,6 @@ void VkEncoder::vkTrimCommandPoolKHR( stream->handleMapping()->mapHandles_VkCommandPool_u64(&local_commandPool, &cgen_var_1012, 1); stream->write((uint64_t*)&cgen_var_1012, 1 * 8); stream->write((VkCommandPoolTrimFlags*)&local_flags, sizeof(VkCommandPoolTrimFlags)); - AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR readParams"); - AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -15444,7 +14723,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR( VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR encode"); mImpl->log("start vkEnumeratePhysicalDeviceGroupsKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15501,7 +14779,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR( marshal_VkPhysicalDeviceGroupProperties(stream, (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR readParams"); // WARNING PTR CHECK uint32_t* check_pPhysicalDeviceGroupCount; check_pPhysicalDeviceGroupCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -15534,7 +14811,6 @@ VkResult VkEncoder::vkEnumeratePhysicalDeviceGroupsKHR( transform_fromhost_VkPhysicalDeviceGroupProperties(mImpl->resources(), (VkPhysicalDeviceGroupProperties*)(pPhysicalDeviceGroupProperties + i)); } } - AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroupsKHR returnUnmarshal"); VkResult vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return = (VkResult)0; stream->read(&vkEnumeratePhysicalDeviceGroupsKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -15552,7 +14828,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkExternalBufferProperties* pExternalBufferProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR encode"); mImpl->log("start vkGetPhysicalDeviceExternalBufferPropertiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15591,14 +14866,12 @@ void VkEncoder::vkGetPhysicalDeviceExternalBufferPropertiesKHR( stream->write((uint64_t*)&cgen_var_1022, 1 * 8); marshal_VkPhysicalDeviceExternalBufferInfo(stream, (VkPhysicalDeviceExternalBufferInfo*)(local_pExternalBufferInfo)); marshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR readParams"); unmarshal_VkExternalBufferProperties(stream, (VkExternalBufferProperties*)(pExternalBufferProperties)); if (pExternalBufferProperties) { mImpl->resources()->transformImpl_VkExternalBufferProperties_fromhost(pExternalBufferProperties, 1); transform_fromhost_VkExternalBufferProperties(mImpl->resources(), (VkExternalBufferProperties*)(pExternalBufferProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -15615,7 +14888,6 @@ VkResult VkEncoder::vkGetMemoryWin32HandleKHR( HANDLE* pHandle) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR encode"); mImpl->log("start vkGetMemoryWin32HandleKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15653,9 +14925,7 @@ VkResult VkEncoder::vkGetMemoryWin32HandleKHR( stream->write((uint64_t*)&cgen_var_1024, 1 * 8); marshal_VkMemoryGetWin32HandleInfoKHR(stream, (VkMemoryGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo)); stream->write((HANDLE*)pHandle, sizeof(HANDLE)); - AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR readParams"); stream->read((HANDLE*)pHandle, sizeof(HANDLE)); - AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR returnUnmarshal"); VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0; stream->read(&vkGetMemoryWin32HandleKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -15672,7 +14942,6 @@ VkResult VkEncoder::vkGetMemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR encode"); mImpl->log("start vkGetMemoryWin32HandlePropertiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15705,13 +14974,11 @@ VkResult VkEncoder::vkGetMemoryWin32HandlePropertiesKHR( stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits)); stream->write((HANDLE*)&local_handle, sizeof(HANDLE)); marshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties)); - AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR readParams"); unmarshal_VkMemoryWin32HandlePropertiesKHR(stream, (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties)); if (pMemoryWin32HandleProperties) { transform_fromhost_VkMemoryWin32HandlePropertiesKHR(mImpl->resources(), (VkMemoryWin32HandlePropertiesKHR*)(pMemoryWin32HandleProperties)); } - AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR returnUnmarshal"); VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetMemoryWin32HandlePropertiesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -15729,7 +14996,6 @@ VkResult VkEncoder::vkGetMemoryFdKHR( int* pFd) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetMemoryFdKHR encode"); mImpl->log("start vkGetMemoryFdKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15767,9 +15033,7 @@ VkResult VkEncoder::vkGetMemoryFdKHR( stream->write((uint64_t*)&cgen_var_1028, 1 * 8); marshal_VkMemoryGetFdInfoKHR(stream, (VkMemoryGetFdInfoKHR*)(local_pGetFdInfo)); stream->write((int*)pFd, sizeof(int)); - AEMU_SCOPED_TRACE("vkGetMemoryFdKHR readParams"); stream->read((int*)pFd, sizeof(int)); - AEMU_SCOPED_TRACE("vkGetMemoryFdKHR returnUnmarshal"); VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0; stream->read(&vkGetMemoryFdKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -15786,7 +15050,6 @@ VkResult VkEncoder::vkGetMemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR* pMemoryFdProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR encode"); mImpl->log("start vkGetMemoryFdPropertiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15819,13 +15082,11 @@ VkResult VkEncoder::vkGetMemoryFdPropertiesKHR( stream->write((VkExternalMemoryHandleTypeFlagBits*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagBits)); stream->write((int*)&local_fd, sizeof(int)); marshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties)); - AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR readParams"); unmarshal_VkMemoryFdPropertiesKHR(stream, (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties)); if (pMemoryFdProperties) { transform_fromhost_VkMemoryFdPropertiesKHR(mImpl->resources(), (VkMemoryFdPropertiesKHR*)(pMemoryFdProperties)); } - AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR returnUnmarshal"); VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0; stream->read(&vkGetMemoryFdPropertiesKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -15845,7 +15106,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR encode"); mImpl->log("start vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15883,13 +15143,11 @@ void VkEncoder::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( stream->write((uint64_t*)&cgen_var_1032, 1 * 8); marshal_VkPhysicalDeviceExternalSemaphoreInfo(stream, (VkPhysicalDeviceExternalSemaphoreInfo*)(local_pExternalSemaphoreInfo)); marshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR readParams"); unmarshal_VkExternalSemaphoreProperties(stream, (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties)); if (pExternalSemaphoreProperties) { transform_fromhost_VkExternalSemaphoreProperties(mImpl->resources(), (VkExternalSemaphoreProperties*)(pExternalSemaphoreProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -15905,7 +15163,6 @@ VkResult VkEncoder::vkImportSemaphoreWin32HandleKHR( const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR encode"); mImpl->log("start vkImportSemaphoreWin32HandleKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15941,8 +15198,6 @@ VkResult VkEncoder::vkImportSemaphoreWin32HandleKHR( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1034, 1); stream->write((uint64_t*)&cgen_var_1034, 1 * 8); marshal_VkImportSemaphoreWin32HandleInfoKHR(stream, (VkImportSemaphoreWin32HandleInfoKHR*)(local_pImportSemaphoreWin32HandleInfo)); - AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR readParams"); - AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR returnUnmarshal"); VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0; stream->read(&vkImportSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -15958,7 +15213,6 @@ VkResult VkEncoder::vkGetSemaphoreWin32HandleKHR( HANDLE* pHandle) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR encode"); mImpl->log("start vkGetSemaphoreWin32HandleKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -15996,9 +15250,7 @@ VkResult VkEncoder::vkGetSemaphoreWin32HandleKHR( stream->write((uint64_t*)&cgen_var_1036, 1 * 8); marshal_VkSemaphoreGetWin32HandleInfoKHR(stream, (VkSemaphoreGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo)); stream->write((HANDLE*)pHandle, sizeof(HANDLE)); - AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR readParams"); stream->read((HANDLE*)pHandle, sizeof(HANDLE)); - AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR returnUnmarshal"); VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0; stream->read(&vkGetSemaphoreWin32HandleKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -16015,7 +15267,6 @@ VkResult VkEncoder::vkImportSemaphoreFdKHR( const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR encode"); mImpl->log("start vkImportSemaphoreFdKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16051,8 +15302,6 @@ VkResult VkEncoder::vkImportSemaphoreFdKHR( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1038, 1); stream->write((uint64_t*)&cgen_var_1038, 1 * 8); marshal_VkImportSemaphoreFdInfoKHR(stream, (VkImportSemaphoreFdInfoKHR*)(local_pImportSemaphoreFdInfo)); - AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR readParams"); - AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR returnUnmarshal"); VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0; stream->read(&vkImportSemaphoreFdKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -16068,7 +15317,6 @@ VkResult VkEncoder::vkGetSemaphoreFdKHR( int* pFd) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR encode"); mImpl->log("start vkGetSemaphoreFdKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16106,9 +15354,7 @@ VkResult VkEncoder::vkGetSemaphoreFdKHR( stream->write((uint64_t*)&cgen_var_1040, 1 * 8); marshal_VkSemaphoreGetFdInfoKHR(stream, (VkSemaphoreGetFdInfoKHR*)(local_pGetFdInfo)); stream->write((int*)pFd, sizeof(int)); - AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR readParams"); stream->read((int*)pFd, sizeof(int)); - AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR returnUnmarshal"); VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0; stream->read(&vkGetSemaphoreFdKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -16129,7 +15375,6 @@ void VkEncoder::vkCmdPushDescriptorSetKHR( const VkWriteDescriptorSet* pDescriptorWrites) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR encode"); mImpl->log("start vkCmdPushDescriptorSetKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16197,8 +15442,6 @@ void VkEncoder::vkCmdPushDescriptorSetKHR( { marshal_VkWriteDescriptorSet(stream, (VkWriteDescriptorSet*)(local_pDescriptorWrites + i)); } - AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR readParams"); - AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -16213,7 +15456,6 @@ void VkEncoder::vkCmdPushDescriptorSetWithTemplateKHR( const void* pData) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR encode"); mImpl->log("start vkCmdPushDescriptorSetWithTemplateKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16276,8 +15518,6 @@ void VkEncoder::vkCmdPushDescriptorSetWithTemplateKHR( { stream->write((void*)local_pData, sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR readParams"); - AEMU_SCOPED_TRACE("vkCmdPushDescriptorSetWithTemplateKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -16297,7 +15537,6 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplateKHR( VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR encode"); mImpl->log("start vkCreateDescriptorUpdateTemplateKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16367,13 +15606,11 @@ VkResult VkEncoder::vkCreateDescriptorUpdateTemplateKHR( stream->handleMapping()->mapHandles_VkDescriptorUpdateTemplate_u64(pDescriptorUpdateTemplate, &cgen_var_1058, 1); stream->write((uint64_t*)&cgen_var_1058, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_1059; stream->read((uint64_t*)&cgen_var_1059, 8); stream->handleMapping()->mapHandles_u64_VkDescriptorUpdateTemplate(&cgen_var_1059, (VkDescriptorUpdateTemplate*)pDescriptorUpdateTemplate, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR returnUnmarshal"); VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateDescriptorUpdateTemplateKHR_VkResult_return, sizeof(VkResult)); mImpl->resources()->on_vkCreateDescriptorUpdateTemplateKHR(this, vkCreateDescriptorUpdateTemplateKHR_VkResult_return, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); @@ -16390,7 +15627,6 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR encode"); mImpl->log("start vkDestroyDescriptorUpdateTemplateKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16447,8 +15683,6 @@ void VkEncoder::vkDestroyDescriptorUpdateTemplateKHR( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR readParams"); - AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR returnUnmarshal"); resources->destroyMapping()->mapHandles_VkDescriptorUpdateTemplate((VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate); pool->freeAll(); countingStream->clearPool(); @@ -16463,7 +15697,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR( const void* pData) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR encode"); mImpl->log("start vkUpdateDescriptorSetWithTemplateKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16522,8 +15755,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateKHR( { stream->write((void*)local_pData, sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR readParams"); - AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -16539,7 +15770,6 @@ VkResult VkEncoder::vkCreateRenderPass2KHR( VkRenderPass* pRenderPass) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR encode"); mImpl->log("start vkCreateRenderPass2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16609,11 +15839,9 @@ VkResult VkEncoder::vkCreateRenderPass2KHR( stream->handleMapping()->mapHandles_VkRenderPass_u64(pRenderPass, &cgen_var_1079, 1); stream->write((uint64_t*)&cgen_var_1079, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR readParams"); uint64_t cgen_var_1080; stream->read((uint64_t*)&cgen_var_1080, 8); stream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_1080, (VkRenderPass*)pRenderPass, 1); - AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR returnUnmarshal"); VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0; stream->read(&vkCreateRenderPass2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -16629,7 +15857,6 @@ void VkEncoder::vkCmdBeginRenderPass2KHR( const VkSubpassBeginInfoKHR* pSubpassBeginInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR encode"); mImpl->log("start vkCmdBeginRenderPass2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16678,8 +15905,6 @@ void VkEncoder::vkCmdBeginRenderPass2KHR( stream->write((uint64_t*)&cgen_var_1082, 1 * 8); marshal_VkRenderPassBeginInfo(stream, (VkRenderPassBeginInfo*)(local_pRenderPassBegin)); marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo)); - AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR readParams"); - AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -16692,7 +15917,6 @@ void VkEncoder::vkCmdNextSubpass2KHR( const VkSubpassEndInfoKHR* pSubpassEndInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR encode"); mImpl->log("start vkCmdNextSubpass2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16741,8 +15965,6 @@ void VkEncoder::vkCmdNextSubpass2KHR( stream->write((uint64_t*)&cgen_var_1084, 1 * 8); marshal_VkSubpassBeginInfoKHR(stream, (VkSubpassBeginInfoKHR*)(local_pSubpassBeginInfo)); marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo)); - AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR readParams"); - AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -16754,7 +15976,6 @@ void VkEncoder::vkCmdEndRenderPass2KHR( const VkSubpassEndInfoKHR* pSubpassEndInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR encode"); mImpl->log("start vkCmdEndRenderPass2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16790,8 +16011,6 @@ void VkEncoder::vkCmdEndRenderPass2KHR( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1086, 1); stream->write((uint64_t*)&cgen_var_1086, 1 * 8); marshal_VkSubpassEndInfoKHR(stream, (VkSubpassEndInfoKHR*)(local_pSubpassEndInfo)); - AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR readParams"); - AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -16805,7 +16024,6 @@ VkResult VkEncoder::vkGetSwapchainStatusKHR( VkSwapchainKHR swapchain) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR encode"); mImpl->log("start vkGetSwapchainStatusKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16836,8 +16054,6 @@ VkResult VkEncoder::vkGetSwapchainStatusKHR( uint64_t cgen_var_1090; stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1090, 1); stream->write((uint64_t*)&cgen_var_1090, 1 * 8); - AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR readParams"); - AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR returnUnmarshal"); VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0; stream->read(&vkGetSwapchainStatusKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -16855,7 +16071,6 @@ void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR( VkExternalFenceProperties* pExternalFenceProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR encode"); mImpl->log("start vkGetPhysicalDeviceExternalFencePropertiesKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16893,13 +16108,11 @@ void VkEncoder::vkGetPhysicalDeviceExternalFencePropertiesKHR( stream->write((uint64_t*)&cgen_var_1092, 1 * 8); marshal_VkPhysicalDeviceExternalFenceInfo(stream, (VkPhysicalDeviceExternalFenceInfo*)(local_pExternalFenceInfo)); marshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR readParams"); unmarshal_VkExternalFenceProperties(stream, (VkExternalFenceProperties*)(pExternalFenceProperties)); if (pExternalFenceProperties) { transform_fromhost_VkExternalFenceProperties(mImpl->resources(), (VkExternalFenceProperties*)(pExternalFenceProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -16915,7 +16128,6 @@ VkResult VkEncoder::vkImportFenceWin32HandleKHR( const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR encode"); mImpl->log("start vkImportFenceWin32HandleKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -16951,8 +16163,6 @@ VkResult VkEncoder::vkImportFenceWin32HandleKHR( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1094, 1); stream->write((uint64_t*)&cgen_var_1094, 1 * 8); marshal_VkImportFenceWin32HandleInfoKHR(stream, (VkImportFenceWin32HandleInfoKHR*)(local_pImportFenceWin32HandleInfo)); - AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR readParams"); - AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR returnUnmarshal"); VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0; stream->read(&vkImportFenceWin32HandleKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -16968,7 +16178,6 @@ VkResult VkEncoder::vkGetFenceWin32HandleKHR( HANDLE* pHandle) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR encode"); mImpl->log("start vkGetFenceWin32HandleKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17006,9 +16215,7 @@ VkResult VkEncoder::vkGetFenceWin32HandleKHR( stream->write((uint64_t*)&cgen_var_1096, 1 * 8); marshal_VkFenceGetWin32HandleInfoKHR(stream, (VkFenceGetWin32HandleInfoKHR*)(local_pGetWin32HandleInfo)); stream->write((HANDLE*)pHandle, sizeof(HANDLE)); - AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR readParams"); stream->read((HANDLE*)pHandle, sizeof(HANDLE)); - AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR returnUnmarshal"); VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0; stream->read(&vkGetFenceWin32HandleKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -17025,7 +16232,6 @@ VkResult VkEncoder::vkImportFenceFdKHR( const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkImportFenceFdKHR encode"); mImpl->log("start vkImportFenceFdKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17061,8 +16267,6 @@ VkResult VkEncoder::vkImportFenceFdKHR( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1098, 1); stream->write((uint64_t*)&cgen_var_1098, 1 * 8); marshal_VkImportFenceFdInfoKHR(stream, (VkImportFenceFdInfoKHR*)(local_pImportFenceFdInfo)); - AEMU_SCOPED_TRACE("vkImportFenceFdKHR readParams"); - AEMU_SCOPED_TRACE("vkImportFenceFdKHR returnUnmarshal"); VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0; stream->read(&vkImportFenceFdKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -17078,7 +16282,6 @@ VkResult VkEncoder::vkGetFenceFdKHR( int* pFd) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetFenceFdKHR encode"); mImpl->log("start vkGetFenceFdKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17116,9 +16319,7 @@ VkResult VkEncoder::vkGetFenceFdKHR( stream->write((uint64_t*)&cgen_var_1100, 1 * 8); marshal_VkFenceGetFdInfoKHR(stream, (VkFenceGetFdInfoKHR*)(local_pGetFdInfo)); stream->write((int*)pFd, sizeof(int)); - AEMU_SCOPED_TRACE("vkGetFenceFdKHR readParams"); stream->read((int*)pFd, sizeof(int)); - AEMU_SCOPED_TRACE("vkGetFenceFdKHR returnUnmarshal"); VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0; stream->read(&vkGetFenceFdKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -17138,7 +16339,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR encode"); mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilities2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17176,13 +16376,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2KHR( stream->write((uint64_t*)&cgen_var_1102, 1 * 8); marshal_VkPhysicalDeviceSurfaceInfo2KHR(stream, (VkPhysicalDeviceSurfaceInfo2KHR*)(local_pSurfaceInfo)); marshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR readParams"); unmarshal_VkSurfaceCapabilities2KHR(stream, (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities)); if (pSurfaceCapabilities) { transform_fromhost_VkSurfaceCapabilities2KHR(mImpl->resources(), (VkSurfaceCapabilities2KHR*)(pSurfaceCapabilities)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2KHR returnUnmarshal"); VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -17199,7 +16397,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR( VkSurfaceFormat2KHR* pSurfaceFormats) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR encode"); mImpl->log("start vkGetPhysicalDeviceSurfaceFormats2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17269,7 +16466,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR( marshal_VkSurfaceFormat2KHR(stream, (VkSurfaceFormat2KHR*)(pSurfaceFormats + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR readParams"); // WARNING PTR CHECK uint32_t* check_pSurfaceFormatCount; check_pSurfaceFormatCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -17302,7 +16498,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceFormats2KHR( transform_fromhost_VkSurfaceFormat2KHR(mImpl->resources(), (VkSurfaceFormat2KHR*)(pSurfaceFormats + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormats2KHR returnUnmarshal"); VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceSurfaceFormats2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -17322,7 +16517,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR( VkDisplayProperties2KHR* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR encode"); mImpl->log("start vkGetPhysicalDeviceDisplayProperties2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17379,7 +16573,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR( marshal_VkDisplayProperties2KHR(stream, (VkDisplayProperties2KHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -17412,7 +16605,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayProperties2KHR( transform_fromhost_VkDisplayProperties2KHR(mImpl->resources(), (VkDisplayProperties2KHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayProperties2KHR returnUnmarshal"); VkResult vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceDisplayProperties2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -17428,7 +16620,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR encode"); mImpl->log("start vkGetPhysicalDeviceDisplayPlaneProperties2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17485,7 +16676,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( marshal_VkDisplayPlaneProperties2KHR(stream, (VkDisplayPlaneProperties2KHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -17518,7 +16708,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( transform_fromhost_VkDisplayPlaneProperties2KHR(mImpl->resources(), (VkDisplayPlaneProperties2KHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlaneProperties2KHR returnUnmarshal"); VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceDisplayPlaneProperties2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -17535,7 +16724,6 @@ VkResult VkEncoder::vkGetDisplayModeProperties2KHR( VkDisplayModeProperties2KHR* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR encode"); mImpl->log("start vkGetDisplayModeProperties2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17600,7 +16788,6 @@ VkResult VkEncoder::vkGetDisplayModeProperties2KHR( marshal_VkDisplayModeProperties2KHR(stream, (VkDisplayModeProperties2KHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR readParams"); // WARNING PTR CHECK uint32_t* check_pPropertyCount; check_pPropertyCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -17633,7 +16820,6 @@ VkResult VkEncoder::vkGetDisplayModeProperties2KHR( transform_fromhost_VkDisplayModeProperties2KHR(mImpl->resources(), (VkDisplayModeProperties2KHR*)(pProperties + i)); } } - AEMU_SCOPED_TRACE("vkGetDisplayModeProperties2KHR returnUnmarshal"); VkResult vkGetDisplayModeProperties2KHR_VkResult_return = (VkResult)0; stream->read(&vkGetDisplayModeProperties2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -17649,7 +16835,6 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR* pCapabilities) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR encode"); mImpl->log("start vkGetDisplayPlaneCapabilities2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17687,13 +16872,11 @@ VkResult VkEncoder::vkGetDisplayPlaneCapabilities2KHR( stream->write((uint64_t*)&cgen_var_1138, 1 * 8); marshal_VkDisplayPlaneInfo2KHR(stream, (VkDisplayPlaneInfo2KHR*)(local_pDisplayPlaneInfo)); marshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities)); - AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR readParams"); unmarshal_VkDisplayPlaneCapabilities2KHR(stream, (VkDisplayPlaneCapabilities2KHR*)(pCapabilities)); if (pCapabilities) { transform_fromhost_VkDisplayPlaneCapabilities2KHR(mImpl->resources(), (VkDisplayPlaneCapabilities2KHR*)(pCapabilities)); } - AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilities2KHR returnUnmarshal"); VkResult vkGetDisplayPlaneCapabilities2KHR_VkResult_return = (VkResult)0; stream->read(&vkGetDisplayPlaneCapabilities2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -17717,7 +16900,6 @@ void VkEncoder::vkGetImageMemoryRequirements2KHR( VkMemoryRequirements2* pMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR encode"); mImpl->log("start vkGetImageMemoryRequirements2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17755,13 +16937,11 @@ void VkEncoder::vkGetImageMemoryRequirements2KHR( stream->write((uint64_t*)&cgen_var_1140, 1 * 8); marshal_VkImageMemoryRequirementsInfo2(stream, (VkImageMemoryRequirementsInfo2*)(local_pInfo)); marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements)); - AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR readParams"); unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements)); if (pMemoryRequirements) { transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements)); } - AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -17774,7 +16954,6 @@ void VkEncoder::vkGetBufferMemoryRequirements2KHR( VkMemoryRequirements2* pMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR encode"); mImpl->log("start vkGetBufferMemoryRequirements2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17812,13 +16991,11 @@ void VkEncoder::vkGetBufferMemoryRequirements2KHR( stream->write((uint64_t*)&cgen_var_1142, 1 * 8); marshal_VkBufferMemoryRequirementsInfo2(stream, (VkBufferMemoryRequirementsInfo2*)(local_pInfo)); marshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements)); - AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR readParams"); unmarshal_VkMemoryRequirements2(stream, (VkMemoryRequirements2*)(pMemoryRequirements)); if (pMemoryRequirements) { transform_fromhost_VkMemoryRequirements2(mImpl->resources(), (VkMemoryRequirements2*)(pMemoryRequirements)); } - AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -17832,7 +17009,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2KHR( VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR encode"); mImpl->log("start vkGetImageSparseMemoryRequirements2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -17902,7 +17078,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2KHR( marshal_VkSparseImageMemoryRequirements2(stream, (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i)); } } - AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR readParams"); // WARNING PTR CHECK uint32_t* check_pSparseMemoryRequirementCount; check_pSparseMemoryRequirementCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -17935,7 +17110,6 @@ void VkEncoder::vkGetImageSparseMemoryRequirements2KHR( transform_fromhost_VkSparseImageMemoryRequirements2(mImpl->resources(), (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i)); } } - AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -17953,7 +17127,6 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversionKHR( VkSamplerYcbcrConversion* pYcbcrConversion) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR encode"); mImpl->log("start vkCreateSamplerYcbcrConversionKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18023,13 +17196,11 @@ VkResult VkEncoder::vkCreateSamplerYcbcrConversionKHR( stream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(pYcbcrConversion, &cgen_var_1156, 1); stream->write((uint64_t*)&cgen_var_1156, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_1157; stream->read((uint64_t*)&cgen_var_1157, 8); stream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_1157, (VkSamplerYcbcrConversion*)pYcbcrConversion, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR returnUnmarshal"); VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0; stream->read(&vkCreateSamplerYcbcrConversionKHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -18045,7 +17216,6 @@ void VkEncoder::vkDestroySamplerYcbcrConversionKHR( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR encode"); mImpl->log("start vkDestroySamplerYcbcrConversionKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18102,8 +17272,6 @@ void VkEncoder::vkDestroySamplerYcbcrConversionKHR( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR readParams"); - AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR returnUnmarshal"); resources->destroyMapping()->mapHandles_VkSamplerYcbcrConversion((VkSamplerYcbcrConversion*)&ycbcrConversion); pool->freeAll(); countingStream->clearPool(); @@ -18119,7 +17287,6 @@ VkResult VkEncoder::vkBindBufferMemory2KHR( const VkBindBufferMemoryInfo* pBindInfos) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR encode"); mImpl->log("start vkBindBufferMemory2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18171,8 +17338,6 @@ VkResult VkEncoder::vkBindBufferMemory2KHR( { marshal_VkBindBufferMemoryInfo(stream, (VkBindBufferMemoryInfo*)(local_pBindInfos + i)); } - AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR readParams"); - AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR returnUnmarshal"); VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0; stream->read(&vkBindBufferMemory2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -18188,7 +17353,6 @@ VkResult VkEncoder::vkBindImageMemory2KHR( const VkBindImageMemoryInfo* pBindInfos) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkBindImageMemory2KHR encode"); mImpl->log("start vkBindImageMemory2KHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18240,8 +17404,6 @@ VkResult VkEncoder::vkBindImageMemory2KHR( { marshal_VkBindImageMemoryInfo(stream, (VkBindImageMemoryInfo*)(local_pBindInfos + i)); } - AEMU_SCOPED_TRACE("vkBindImageMemory2KHR readParams"); - AEMU_SCOPED_TRACE("vkBindImageMemory2KHR returnUnmarshal"); VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0; stream->read(&vkBindImageMemory2KHR_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -18259,7 +17421,6 @@ void VkEncoder::vkGetDescriptorSetLayoutSupportKHR( VkDescriptorSetLayoutSupport* pSupport) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR encode"); mImpl->log("start vkGetDescriptorSetLayoutSupportKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18297,13 +17458,11 @@ void VkEncoder::vkGetDescriptorSetLayoutSupportKHR( stream->write((uint64_t*)&cgen_var_1169, 1 * 8); marshal_VkDescriptorSetLayoutCreateInfo(stream, (VkDescriptorSetLayoutCreateInfo*)(local_pCreateInfo)); marshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport)); - AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR readParams"); unmarshal_VkDescriptorSetLayoutSupport(stream, (VkDescriptorSetLayoutSupport*)(pSupport)); if (pSupport) { transform_fromhost_VkDescriptorSetLayoutSupport(mImpl->resources(), (VkDescriptorSetLayoutSupport*)(pSupport)); } - AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -18322,7 +17481,6 @@ void VkEncoder::vkCmdDrawIndirectCountKHR( uint32_t stride) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR encode"); mImpl->log("start vkCmdDrawIndirectCountKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18377,8 +17535,6 @@ void VkEncoder::vkCmdDrawIndirectCountKHR( stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize)); stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t)); stream->write((uint32_t*)&local_stride, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR readParams"); - AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -18395,7 +17551,6 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountKHR( uint32_t stride) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR encode"); mImpl->log("start vkCmdDrawIndexedIndirectCountKHR"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18450,8 +17605,6 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountKHR( stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize)); stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t)); stream->write((uint32_t*)&local_stride, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR readParams"); - AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountKHR returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -18471,7 +17624,6 @@ VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID( int* grallocUsage) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID encode"); mImpl->log("start vkGetSwapchainGrallocUsageANDROID"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18504,9 +17656,7 @@ VkResult VkEncoder::vkGetSwapchainGrallocUsageANDROID( stream->write((VkFormat*)&local_format, sizeof(VkFormat)); stream->write((VkImageUsageFlags*)&local_imageUsage, sizeof(VkImageUsageFlags)); stream->write((int*)grallocUsage, sizeof(int)); - AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID readParams"); stream->read((int*)grallocUsage, sizeof(int)); - AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID returnUnmarshal"); VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0; stream->read(&vkGetSwapchainGrallocUsageANDROID_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -18524,7 +17674,6 @@ VkResult VkEncoder::vkAcquireImageANDROID( VkFence fence) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkAcquireImageANDROID encode"); mImpl->log("start vkAcquireImageANDROID"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18576,8 +17725,6 @@ VkResult VkEncoder::vkAcquireImageANDROID( uint64_t cgen_var_1191; stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1191, 1); stream->write((uint64_t*)&cgen_var_1191, 1 * 8); - AEMU_SCOPED_TRACE("vkAcquireImageANDROID readParams"); - AEMU_SCOPED_TRACE("vkAcquireImageANDROID returnUnmarshal"); VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0; stream->read(&vkAcquireImageANDROID_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -18595,7 +17742,6 @@ VkResult VkEncoder::vkQueueSignalReleaseImageANDROID( int* pNativeFenceFd) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID encode"); mImpl->log("start vkQueueSignalReleaseImageANDROID"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18664,9 +17810,7 @@ VkResult VkEncoder::vkQueueSignalReleaseImageANDROID( stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1199, 1); stream->write((uint64_t*)&cgen_var_1199, 1 * 8); stream->write((int*)pNativeFenceFd, sizeof(int)); - AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID readParams"); stream->read((int*)pNativeFenceFd, sizeof(int)); - AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID returnUnmarshal"); VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0; stream->read(&vkQueueSignalReleaseImageANDROID_VkResult_return, sizeof(VkResult)); stream->flush(); @@ -18686,7 +17830,6 @@ VkResult VkEncoder::vkCreateDebugReportCallbackEXT( VkDebugReportCallbackEXT* pCallback) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT encode"); mImpl->log("start vkCreateDebugReportCallbackEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18756,13 +17899,11 @@ VkResult VkEncoder::vkCreateDebugReportCallbackEXT( stream->handleMapping()->mapHandles_VkDebugReportCallbackEXT_u64(pCallback, &cgen_var_1205, 1); stream->write((uint64_t*)&cgen_var_1205, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_1206; stream->read((uint64_t*)&cgen_var_1206, 8); stream->handleMapping()->mapHandles_u64_VkDebugReportCallbackEXT(&cgen_var_1206, (VkDebugReportCallbackEXT*)pCallback, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateDebugReportCallbackEXT returnUnmarshal"); VkResult vkCreateDebugReportCallbackEXT_VkResult_return = (VkResult)0; stream->read(&vkCreateDebugReportCallbackEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -18778,7 +17919,6 @@ void VkEncoder::vkDestroyDebugReportCallbackEXT( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT encode"); mImpl->log("start vkDestroyDebugReportCallbackEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18835,8 +17975,6 @@ void VkEncoder::vkDestroyDebugReportCallbackEXT( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT readParams"); - AEMU_SCOPED_TRACE("vkDestroyDebugReportCallbackEXT returnUnmarshal"); resources->destroyMapping()->mapHandles_VkDebugReportCallbackEXT((VkDebugReportCallbackEXT*)&callback); pool->freeAll(); countingStream->clearPool(); @@ -18855,7 +17993,6 @@ void VkEncoder::vkDebugReportMessageEXT( const char* pMessage) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDebugReportMessageEXT encode"); mImpl->log("start vkDebugReportMessageEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18916,8 +18053,6 @@ void VkEncoder::vkDebugReportMessageEXT( stream->write((int32_t*)&local_messageCode, sizeof(int32_t)); stream->putString(local_pLayerPrefix); stream->putString(local_pMessage); - AEMU_SCOPED_TRACE("vkDebugReportMessageEXT readParams"); - AEMU_SCOPED_TRACE("vkDebugReportMessageEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -18943,7 +18078,6 @@ VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT( const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT encode"); mImpl->log("start vkDebugMarkerSetObjectTagEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -18979,8 +18113,6 @@ VkResult VkEncoder::vkDebugMarkerSetObjectTagEXT( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1218, 1); stream->write((uint64_t*)&cgen_var_1218, 1 * 8); marshal_VkDebugMarkerObjectTagInfoEXT(stream, (VkDebugMarkerObjectTagInfoEXT*)(local_pTagInfo)); - AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT readParams"); - AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT returnUnmarshal"); VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0; stream->read(&vkDebugMarkerSetObjectTagEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -18995,7 +18127,6 @@ VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT( const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT encode"); mImpl->log("start vkDebugMarkerSetObjectNameEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19031,8 +18162,6 @@ VkResult VkEncoder::vkDebugMarkerSetObjectNameEXT( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1220, 1); stream->write((uint64_t*)&cgen_var_1220, 1 * 8); marshal_VkDebugMarkerObjectNameInfoEXT(stream, (VkDebugMarkerObjectNameInfoEXT*)(local_pNameInfo)); - AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT readParams"); - AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT returnUnmarshal"); VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0; stream->read(&vkDebugMarkerSetObjectNameEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -19047,7 +18176,6 @@ void VkEncoder::vkCmdDebugMarkerBeginEXT( const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT encode"); mImpl->log("start vkCmdDebugMarkerBeginEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19083,8 +18211,6 @@ void VkEncoder::vkCmdDebugMarkerBeginEXT( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1222, 1); stream->write((uint64_t*)&cgen_var_1222, 1 * 8); marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo)); - AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdDebugMarkerBeginEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -19095,7 +18221,6 @@ void VkEncoder::vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT encode"); mImpl->log("start vkCmdDebugMarkerEndEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19118,8 +18243,6 @@ void VkEncoder::vkCmdDebugMarkerEndEXT( uint64_t cgen_var_1224; stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1224, 1); stream->write((uint64_t*)&cgen_var_1224, 1 * 8); - AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdDebugMarkerEndEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -19131,7 +18254,6 @@ void VkEncoder::vkCmdDebugMarkerInsertEXT( const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT encode"); mImpl->log("start vkCmdDebugMarkerInsertEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19167,8 +18289,6 @@ void VkEncoder::vkCmdDebugMarkerInsertEXT( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1226, 1); stream->write((uint64_t*)&cgen_var_1226, 1 * 8); marshal_VkDebugMarkerMarkerInfoEXT(stream, (VkDebugMarkerMarkerInfoEXT*)(local_pMarkerInfo)); - AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdDebugMarkerInsertEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -19191,7 +18311,6 @@ void VkEncoder::vkCmdDrawIndirectCountAMD( uint32_t stride) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD encode"); mImpl->log("start vkCmdDrawIndirectCountAMD"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19246,8 +18365,6 @@ void VkEncoder::vkCmdDrawIndirectCountAMD( stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize)); stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t)); stream->write((uint32_t*)&local_stride, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD readParams"); - AEMU_SCOPED_TRACE("vkCmdDrawIndirectCountAMD returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -19264,7 +18381,6 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountAMD( uint32_t stride) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD encode"); mImpl->log("start vkCmdDrawIndexedIndirectCountAMD"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19319,8 +18435,6 @@ void VkEncoder::vkCmdDrawIndexedIndirectCountAMD( stream->write((VkDeviceSize*)&local_countBufferOffset, sizeof(VkDeviceSize)); stream->write((uint32_t*)&local_maxDrawCount, sizeof(uint32_t)); stream->write((uint32_t*)&local_stride, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD readParams"); - AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCountAMD returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -19346,7 +18460,6 @@ VkResult VkEncoder::vkGetShaderInfoAMD( void* pInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetShaderInfoAMD encode"); mImpl->log("start vkGetShaderInfoAMD"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19415,7 +18528,6 @@ VkResult VkEncoder::vkGetShaderInfoAMD( { stream->write((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkGetShaderInfoAMD readParams"); // WARNING PTR CHECK size_t* check_pInfoSize; check_pInfoSize = (size_t*)(uintptr_t)stream->getBe64(); @@ -19438,7 +18550,6 @@ VkResult VkEncoder::vkGetShaderInfoAMD( } stream->read((void*)pInfo, (*(pInfoSize)) * sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkGetShaderInfoAMD returnUnmarshal"); VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0; stream->read(&vkGetShaderInfoAMD_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -19465,7 +18576,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV encode"); mImpl->log("start vkGetPhysicalDeviceExternalImageFormatPropertiesNV"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19514,13 +18624,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( stream->write((VkImageCreateFlags*)&local_flags, sizeof(VkImageCreateFlags)); stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_externalHandleType, sizeof(VkExternalMemoryHandleTypeFlagsNV)); marshal_VkExternalImageFormatPropertiesNV(stream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV readParams"); unmarshal_VkExternalImageFormatPropertiesNV(stream, (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties)); if (pExternalImageFormatProperties) { transform_fromhost_VkExternalImageFormatPropertiesNV(mImpl->resources(), (VkExternalImageFormatPropertiesNV*)(pExternalImageFormatProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalImageFormatPropertiesNV returnUnmarshal"); VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceExternalImageFormatPropertiesNV_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -19541,7 +18649,6 @@ VkResult VkEncoder::vkGetMemoryWin32HandleNV( HANDLE* pHandle) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV encode"); mImpl->log("start vkGetMemoryWin32HandleNV"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19579,9 +18686,7 @@ VkResult VkEncoder::vkGetMemoryWin32HandleNV( stream->write((uint64_t*)&cgen_var_1257, 1 * 8); stream->write((VkExternalMemoryHandleTypeFlagsNV*)&local_handleType, sizeof(VkExternalMemoryHandleTypeFlagsNV)); stream->write((HANDLE*)pHandle, sizeof(HANDLE)); - AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV readParams"); stream->read((HANDLE*)pHandle, sizeof(HANDLE)); - AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV returnUnmarshal"); VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0; stream->read(&vkGetMemoryWin32HandleNV_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -19604,7 +18709,6 @@ VkResult VkEncoder::vkCreateViSurfaceNN( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateViSurfaceNN encode"); mImpl->log("start vkCreateViSurfaceNN"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19674,11 +18778,9 @@ VkResult VkEncoder::vkCreateViSurfaceNN( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1263, 1); stream->write((uint64_t*)&cgen_var_1263, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateViSurfaceNN readParams"); uint64_t cgen_var_1264; stream->read((uint64_t*)&cgen_var_1264, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1264, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateViSurfaceNN returnUnmarshal"); VkResult vkCreateViSurfaceNN_VkResult_return = (VkResult)0; stream->read(&vkCreateViSurfaceNN_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -19699,7 +18801,6 @@ void VkEncoder::vkCmdBeginConditionalRenderingEXT( const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT encode"); mImpl->log("start vkCmdBeginConditionalRenderingEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19735,8 +18836,6 @@ void VkEncoder::vkCmdBeginConditionalRenderingEXT( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1266, 1); stream->write((uint64_t*)&cgen_var_1266, 1 * 8); marshal_VkConditionalRenderingBeginInfoEXT(stream, (VkConditionalRenderingBeginInfoEXT*)(local_pConditionalRenderingBegin)); - AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdBeginConditionalRenderingEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -19747,7 +18846,6 @@ void VkEncoder::vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT encode"); mImpl->log("start vkCmdEndConditionalRenderingEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19770,8 +18868,6 @@ void VkEncoder::vkCmdEndConditionalRenderingEXT( uint64_t cgen_var_1268; stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1268, 1); stream->write((uint64_t*)&cgen_var_1268, 1 * 8); - AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdEndConditionalRenderingEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -19785,7 +18881,6 @@ void VkEncoder::vkCmdProcessCommandsNVX( const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX encode"); mImpl->log("start vkCmdProcessCommandsNVX"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19821,8 +18916,6 @@ void VkEncoder::vkCmdProcessCommandsNVX( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1270, 1); stream->write((uint64_t*)&cgen_var_1270, 1 * 8); marshal_VkCmdProcessCommandsInfoNVX(stream, (VkCmdProcessCommandsInfoNVX*)(local_pProcessCommandsInfo)); - AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX readParams"); - AEMU_SCOPED_TRACE("vkCmdProcessCommandsNVX returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -19834,7 +18927,6 @@ void VkEncoder::vkCmdReserveSpaceForCommandsNVX( const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX encode"); mImpl->log("start vkCmdReserveSpaceForCommandsNVX"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19870,8 +18962,6 @@ void VkEncoder::vkCmdReserveSpaceForCommandsNVX( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1272, 1); stream->write((uint64_t*)&cgen_var_1272, 1 * 8); marshal_VkCmdReserveSpaceForCommandsInfoNVX(stream, (VkCmdReserveSpaceForCommandsInfoNVX*)(local_pReserveSpaceInfo)); - AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX readParams"); - AEMU_SCOPED_TRACE("vkCmdReserveSpaceForCommandsNVX returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -19885,7 +18975,6 @@ VkResult VkEncoder::vkCreateIndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX encode"); mImpl->log("start vkCreateIndirectCommandsLayoutNVX"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -19955,13 +19044,11 @@ VkResult VkEncoder::vkCreateIndirectCommandsLayoutNVX( stream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(pIndirectCommandsLayout, &cgen_var_1278, 1); stream->write((uint64_t*)&cgen_var_1278, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_1279; stream->read((uint64_t*)&cgen_var_1279, 8); stream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_1279, (VkIndirectCommandsLayoutNVX*)pIndirectCommandsLayout, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX returnUnmarshal"); VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0; stream->read(&vkCreateIndirectCommandsLayoutNVX_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -19977,7 +19064,6 @@ void VkEncoder::vkDestroyIndirectCommandsLayoutNVX( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX encode"); mImpl->log("start vkDestroyIndirectCommandsLayoutNVX"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20034,8 +19120,6 @@ void VkEncoder::vkDestroyIndirectCommandsLayoutNVX( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX readParams"); - AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX returnUnmarshal"); resources->destroyMapping()->mapHandles_VkIndirectCommandsLayoutNVX((VkIndirectCommandsLayoutNVX*)&indirectCommandsLayout); pool->freeAll(); countingStream->clearPool(); @@ -20050,7 +19134,6 @@ VkResult VkEncoder::vkCreateObjectTableNVX( VkObjectTableNVX* pObjectTable) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateObjectTableNVX encode"); mImpl->log("start vkCreateObjectTableNVX"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20120,13 +19203,11 @@ VkResult VkEncoder::vkCreateObjectTableNVX( stream->handleMapping()->mapHandles_VkObjectTableNVX_u64(pObjectTable, &cgen_var_1291, 1); stream->write((uint64_t*)&cgen_var_1291, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateObjectTableNVX readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_1292; stream->read((uint64_t*)&cgen_var_1292, 8); stream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_1292, (VkObjectTableNVX*)pObjectTable, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateObjectTableNVX returnUnmarshal"); VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0; stream->read(&vkCreateObjectTableNVX_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20142,7 +19223,6 @@ void VkEncoder::vkDestroyObjectTableNVX( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX encode"); mImpl->log("start vkDestroyObjectTableNVX"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20199,8 +19279,6 @@ void VkEncoder::vkDestroyObjectTableNVX( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX readParams"); - AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX returnUnmarshal"); resources->destroyMapping()->mapHandles_VkObjectTableNVX((VkObjectTableNVX*)&objectTable); pool->freeAll(); countingStream->clearPool(); @@ -20216,7 +19294,6 @@ VkResult VkEncoder::vkRegisterObjectsNVX( const uint32_t* pObjectIndices) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkRegisterObjectsNVX encode"); mImpl->log("start vkRegisterObjectsNVX"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20264,8 +19341,6 @@ VkResult VkEncoder::vkRegisterObjectsNVX( stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t)); (void)local_ppObjectTableEntries; stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkRegisterObjectsNVX readParams"); - AEMU_SCOPED_TRACE("vkRegisterObjectsNVX returnUnmarshal"); VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0; stream->read(&vkRegisterObjectsNVX_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20283,7 +19358,6 @@ VkResult VkEncoder::vkUnregisterObjectsNVX( const uint32_t* pObjectIndices) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX encode"); mImpl->log("start vkUnregisterObjectsNVX"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20334,8 +19408,6 @@ VkResult VkEncoder::vkUnregisterObjectsNVX( stream->write((uint32_t*)&local_objectCount, sizeof(uint32_t)); stream->write((VkObjectEntryTypeNVX*)local_pObjectEntryTypes, ((objectCount)) * sizeof(VkObjectEntryTypeNVX)); stream->write((uint32_t*)local_pObjectIndices, ((objectCount)) * sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX readParams"); - AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX returnUnmarshal"); VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0; stream->read(&vkUnregisterObjectsNVX_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20351,7 +19423,6 @@ void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( VkDeviceGeneratedCommandsLimitsNVX* pLimits) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX encode"); mImpl->log("start vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20378,7 +19449,6 @@ void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( stream->write((uint64_t*)&cgen_var_1308, 1 * 8); marshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures)); marshal_VkDeviceGeneratedCommandsLimitsNVX(stream, (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX readParams"); unmarshal_VkDeviceGeneratedCommandsFeaturesNVX(stream, (VkDeviceGeneratedCommandsFeaturesNVX*)(pFeatures)); if (pFeatures) { @@ -20389,7 +19459,6 @@ void VkEncoder::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( { transform_fromhost_VkDeviceGeneratedCommandsLimitsNVX(mImpl->resources(), (VkDeviceGeneratedCommandsLimitsNVX*)(pLimits)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -20405,7 +19474,6 @@ void VkEncoder::vkCmdSetViewportWScalingNV( const VkViewportWScalingNV* pViewportWScalings) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV encode"); mImpl->log("start vkCmdSetViewportWScalingNV"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20461,8 +19529,6 @@ void VkEncoder::vkCmdSetViewportWScalingNV( { marshal_VkViewportWScalingNV(stream, (VkViewportWScalingNV*)(local_pViewportWScalings + i)); } - AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV readParams"); - AEMU_SCOPED_TRACE("vkCmdSetViewportWScalingNV returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -20476,7 +19542,6 @@ VkResult VkEncoder::vkReleaseDisplayEXT( VkDisplayKHR display) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkReleaseDisplayEXT encode"); mImpl->log("start vkReleaseDisplayEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20507,8 +19572,6 @@ VkResult VkEncoder::vkReleaseDisplayEXT( uint64_t cgen_var_1314; stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1314, 1); stream->write((uint64_t*)&cgen_var_1314, 1 * 8); - AEMU_SCOPED_TRACE("vkReleaseDisplayEXT readParams"); - AEMU_SCOPED_TRACE("vkReleaseDisplayEXT returnUnmarshal"); VkResult vkReleaseDisplayEXT_VkResult_return = (VkResult)0; stream->read(&vkReleaseDisplayEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20526,7 +19589,6 @@ VkResult VkEncoder::vkAcquireXlibDisplayEXT( VkDisplayKHR display) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT encode"); mImpl->log("start vkAcquireXlibDisplayEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20559,9 +19621,7 @@ VkResult VkEncoder::vkAcquireXlibDisplayEXT( uint64_t cgen_var_1318; stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1318, 1); stream->write((uint64_t*)&cgen_var_1318, 1 * 8); - AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT readParams"); stream->read((Display*)dpy, sizeof(Display)); - AEMU_SCOPED_TRACE("vkAcquireXlibDisplayEXT returnUnmarshal"); VkResult vkAcquireXlibDisplayEXT_VkResult_return = (VkResult)0; stream->read(&vkAcquireXlibDisplayEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20578,7 +19638,6 @@ VkResult VkEncoder::vkGetRandROutputDisplayEXT( VkDisplayKHR* pDisplay) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT encode"); mImpl->log("start vkGetRandROutputDisplayEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20615,12 +19674,10 @@ VkResult VkEncoder::vkGetRandROutputDisplayEXT( stream->handleMapping()->mapHandles_VkDisplayKHR_u64(pDisplay, &cgen_var_1322, 1); stream->write((uint64_t*)&cgen_var_1322, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT readParams"); stream->read((Display*)dpy, sizeof(Display)); uint64_t cgen_var_1323; stream->read((uint64_t*)&cgen_var_1323, 8); stream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_1323, (VkDisplayKHR*)pDisplay, 1); - AEMU_SCOPED_TRACE("vkGetRandROutputDisplayEXT returnUnmarshal"); VkResult vkGetRandROutputDisplayEXT_VkResult_return = (VkResult)0; stream->read(&vkGetRandROutputDisplayEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20638,7 +19695,6 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT encode"); mImpl->log("start vkGetPhysicalDeviceSurfaceCapabilities2EXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20671,13 +19727,11 @@ VkResult VkEncoder::vkGetPhysicalDeviceSurfaceCapabilities2EXT( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&local_surface, &cgen_var_1327, 1); stream->write((uint64_t*)&cgen_var_1327, 1 * 8); marshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT readParams"); unmarshal_VkSurfaceCapabilities2EXT(stream, (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities)); if (pSurfaceCapabilities) { transform_fromhost_VkSurfaceCapabilities2EXT(mImpl->resources(), (VkSurfaceCapabilities2EXT*)(pSurfaceCapabilities)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilities2EXT returnUnmarshal"); VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return = (VkResult)0; stream->read(&vkGetPhysicalDeviceSurfaceCapabilities2EXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20695,7 +19749,6 @@ VkResult VkEncoder::vkDisplayPowerControlEXT( const VkDisplayPowerInfoEXT* pDisplayPowerInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT encode"); mImpl->log("start vkDisplayPowerControlEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20739,8 +19792,6 @@ VkResult VkEncoder::vkDisplayPowerControlEXT( stream->handleMapping()->mapHandles_VkDisplayKHR_u64(&local_display, &cgen_var_1331, 1); stream->write((uint64_t*)&cgen_var_1331, 1 * 8); marshal_VkDisplayPowerInfoEXT(stream, (VkDisplayPowerInfoEXT*)(local_pDisplayPowerInfo)); - AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT readParams"); - AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT returnUnmarshal"); VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0; stream->read(&vkDisplayPowerControlEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20757,7 +19808,6 @@ VkResult VkEncoder::vkRegisterDeviceEventEXT( VkFence* pFence) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT encode"); mImpl->log("start vkRegisterDeviceEventEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20827,11 +19877,9 @@ VkResult VkEncoder::vkRegisterDeviceEventEXT( stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1337, 1); stream->write((uint64_t*)&cgen_var_1337, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT readParams"); uint64_t cgen_var_1338; stream->read((uint64_t*)&cgen_var_1338, 8); stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1338, (VkFence*)pFence, 1); - AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT returnUnmarshal"); VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0; stream->read(&vkRegisterDeviceEventEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20849,7 +19897,6 @@ VkResult VkEncoder::vkRegisterDisplayEventEXT( VkFence* pFence) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT encode"); mImpl->log("start vkRegisterDisplayEventEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20927,11 +19974,9 @@ VkResult VkEncoder::vkRegisterDisplayEventEXT( stream->handleMapping()->mapHandles_VkFence_u64(pFence, &cgen_var_1346, 1); stream->write((uint64_t*)&cgen_var_1346, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT readParams"); uint64_t cgen_var_1347; stream->read((uint64_t*)&cgen_var_1347, 8); stream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_1347, (VkFence*)pFence, 1); - AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT returnUnmarshal"); VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0; stream->read(&vkRegisterDisplayEventEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -20948,7 +19993,6 @@ VkResult VkEncoder::vkGetSwapchainCounterEXT( uint64_t* pCounterValue) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT encode"); mImpl->log("start vkGetSwapchainCounterEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -20985,9 +20029,7 @@ VkResult VkEncoder::vkGetSwapchainCounterEXT( stream->write((uint64_t*)&cgen_var_1351, 1 * 8); stream->write((VkSurfaceCounterFlagBitsEXT*)&local_counter, sizeof(VkSurfaceCounterFlagBitsEXT)); stream->write((uint64_t*)pCounterValue, sizeof(uint64_t)); - AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT readParams"); stream->read((uint64_t*)pCounterValue, sizeof(uint64_t)); - AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT returnUnmarshal"); VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0; stream->read(&vkGetSwapchainCounterEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -21005,7 +20047,6 @@ VkResult VkEncoder::vkGetRefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE encode"); mImpl->log("start vkGetRefreshCycleDurationGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21038,13 +20079,11 @@ VkResult VkEncoder::vkGetRefreshCycleDurationGOOGLE( stream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&local_swapchain, &cgen_var_1355, 1); stream->write((uint64_t*)&cgen_var_1355, 1 * 8); marshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties)); - AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE readParams"); unmarshal_VkRefreshCycleDurationGOOGLE(stream, (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties)); if (pDisplayTimingProperties) { transform_fromhost_VkRefreshCycleDurationGOOGLE(mImpl->resources(), (VkRefreshCycleDurationGOOGLE*)(pDisplayTimingProperties)); } - AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE returnUnmarshal"); VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0; stream->read(&vkGetRefreshCycleDurationGOOGLE_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -21061,7 +20100,6 @@ VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE* pPresentationTimings) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE encode"); mImpl->log("start vkGetPastPresentationTimingGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21126,7 +20164,6 @@ VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE( marshal_VkPastPresentationTimingGOOGLE(stream, (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i)); } } - AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE readParams"); // WARNING PTR CHECK uint32_t* check_pPresentationTimingCount; check_pPresentationTimingCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -21159,7 +20196,6 @@ VkResult VkEncoder::vkGetPastPresentationTimingGOOGLE( transform_fromhost_VkPastPresentationTimingGOOGLE(mImpl->resources(), (VkPastPresentationTimingGOOGLE*)(pPresentationTimings + i)); } } - AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE returnUnmarshal"); VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0; stream->read(&vkGetPastPresentationTimingGOOGLE_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -21188,7 +20224,6 @@ void VkEncoder::vkCmdSetDiscardRectangleEXT( const VkRect2D* pDiscardRectangles) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT encode"); mImpl->log("start vkCmdSetDiscardRectangleEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21244,8 +20279,6 @@ void VkEncoder::vkCmdSetDiscardRectangleEXT( { marshal_VkRect2D(stream, (VkRect2D*)(local_pDiscardRectangles + i)); } - AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdSetDiscardRectangleEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -21265,7 +20298,6 @@ void VkEncoder::vkSetHdrMetadataEXT( const VkHdrMetadataEXT* pMetadata) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT encode"); mImpl->log("start vkSetHdrMetadataEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21337,8 +20369,6 @@ void VkEncoder::vkSetHdrMetadataEXT( { marshal_VkHdrMetadataEXT(stream, (VkHdrMetadataEXT*)(local_pMetadata + i)); } - AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT readParams"); - AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -21354,7 +20384,6 @@ VkResult VkEncoder::vkCreateIOSSurfaceMVK( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK encode"); mImpl->log("start vkCreateIOSSurfaceMVK"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21424,11 +20453,9 @@ VkResult VkEncoder::vkCreateIOSSurfaceMVK( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1377, 1); stream->write((uint64_t*)&cgen_var_1377, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK readParams"); uint64_t cgen_var_1378; stream->read((uint64_t*)&cgen_var_1378, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1378, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateIOSSurfaceMVK returnUnmarshal"); VkResult vkCreateIOSSurfaceMVK_VkResult_return = (VkResult)0; stream->read(&vkCreateIOSSurfaceMVK_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -21447,7 +20474,6 @@ VkResult VkEncoder::vkCreateMacOSSurfaceMVK( VkSurfaceKHR* pSurface) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK encode"); mImpl->log("start vkCreateMacOSSurfaceMVK"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21517,11 +20543,9 @@ VkResult VkEncoder::vkCreateMacOSSurfaceMVK( stream->handleMapping()->mapHandles_VkSurfaceKHR_u64(pSurface, &cgen_var_1384, 1); stream->write((uint64_t*)&cgen_var_1384, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK readParams"); uint64_t cgen_var_1385; stream->read((uint64_t*)&cgen_var_1385, 8); stream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_1385, (VkSurfaceKHR*)pSurface, 1); - AEMU_SCOPED_TRACE("vkCreateMacOSSurfaceMVK returnUnmarshal"); VkResult vkCreateMacOSSurfaceMVK_VkResult_return = (VkResult)0; stream->read(&vkCreateMacOSSurfaceMVK_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -21542,7 +20566,6 @@ VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT( const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT encode"); mImpl->log("start vkSetDebugUtilsObjectNameEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21578,8 +20601,6 @@ VkResult VkEncoder::vkSetDebugUtilsObjectNameEXT( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1387, 1); stream->write((uint64_t*)&cgen_var_1387, 1 * 8); marshal_VkDebugUtilsObjectNameInfoEXT(stream, (VkDebugUtilsObjectNameInfoEXT*)(local_pNameInfo)); - AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT readParams"); - AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT returnUnmarshal"); VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0; stream->read(&vkSetDebugUtilsObjectNameEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -21594,7 +20615,6 @@ VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT( const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT encode"); mImpl->log("start vkSetDebugUtilsObjectTagEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21630,8 +20650,6 @@ VkResult VkEncoder::vkSetDebugUtilsObjectTagEXT( stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1389, 1); stream->write((uint64_t*)&cgen_var_1389, 1 * 8); marshal_VkDebugUtilsObjectTagInfoEXT(stream, (VkDebugUtilsObjectTagInfoEXT*)(local_pTagInfo)); - AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT readParams"); - AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT returnUnmarshal"); VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0; stream->read(&vkSetDebugUtilsObjectTagEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -21646,7 +20664,6 @@ void VkEncoder::vkQueueBeginDebugUtilsLabelEXT( const VkDebugUtilsLabelEXT* pLabelInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT encode"); mImpl->log("start vkQueueBeginDebugUtilsLabelEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21682,8 +20699,6 @@ void VkEncoder::vkQueueBeginDebugUtilsLabelEXT( stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1391, 1); stream->write((uint64_t*)&cgen_var_1391, 1 * 8); marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo)); - AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT readParams"); - AEMU_SCOPED_TRACE("vkQueueBeginDebugUtilsLabelEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -21694,7 +20709,6 @@ void VkEncoder::vkQueueEndDebugUtilsLabelEXT( VkQueue queue) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT encode"); mImpl->log("start vkQueueEndDebugUtilsLabelEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21717,8 +20731,6 @@ void VkEncoder::vkQueueEndDebugUtilsLabelEXT( uint64_t cgen_var_1393; stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1393, 1); stream->write((uint64_t*)&cgen_var_1393, 1 * 8); - AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT readParams"); - AEMU_SCOPED_TRACE("vkQueueEndDebugUtilsLabelEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -21730,7 +20742,6 @@ void VkEncoder::vkQueueInsertDebugUtilsLabelEXT( const VkDebugUtilsLabelEXT* pLabelInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT encode"); mImpl->log("start vkQueueInsertDebugUtilsLabelEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21766,8 +20777,6 @@ void VkEncoder::vkQueueInsertDebugUtilsLabelEXT( stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1395, 1); stream->write((uint64_t*)&cgen_var_1395, 1 * 8); marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo)); - AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT readParams"); - AEMU_SCOPED_TRACE("vkQueueInsertDebugUtilsLabelEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -21779,7 +20788,6 @@ void VkEncoder::vkCmdBeginDebugUtilsLabelEXT( const VkDebugUtilsLabelEXT* pLabelInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT encode"); mImpl->log("start vkCmdBeginDebugUtilsLabelEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21815,8 +20823,6 @@ void VkEncoder::vkCmdBeginDebugUtilsLabelEXT( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1397, 1); stream->write((uint64_t*)&cgen_var_1397, 1 * 8); marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo)); - AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdBeginDebugUtilsLabelEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -21827,7 +20833,6 @@ void VkEncoder::vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT encode"); mImpl->log("start vkCmdEndDebugUtilsLabelEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21850,8 +20855,6 @@ void VkEncoder::vkCmdEndDebugUtilsLabelEXT( uint64_t cgen_var_1399; stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1399, 1); stream->write((uint64_t*)&cgen_var_1399, 1 * 8); - AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdEndDebugUtilsLabelEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -21863,7 +20866,6 @@ void VkEncoder::vkCmdInsertDebugUtilsLabelEXT( const VkDebugUtilsLabelEXT* pLabelInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT encode"); mImpl->log("start vkCmdInsertDebugUtilsLabelEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21899,8 +20901,6 @@ void VkEncoder::vkCmdInsertDebugUtilsLabelEXT( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1401, 1); stream->write((uint64_t*)&cgen_var_1401, 1 * 8); marshal_VkDebugUtilsLabelEXT(stream, (VkDebugUtilsLabelEXT*)(local_pLabelInfo)); - AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdInsertDebugUtilsLabelEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -21914,7 +20914,6 @@ VkResult VkEncoder::vkCreateDebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT* pMessenger) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT encode"); mImpl->log("start vkCreateDebugUtilsMessengerEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -21984,13 +20983,11 @@ VkResult VkEncoder::vkCreateDebugUtilsMessengerEXT( stream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT_u64(pMessenger, &cgen_var_1407, 1); stream->write((uint64_t*)&cgen_var_1407, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_1408; stream->read((uint64_t*)&cgen_var_1408, 8); stream->handleMapping()->mapHandles_u64_VkDebugUtilsMessengerEXT(&cgen_var_1408, (VkDebugUtilsMessengerEXT*)pMessenger, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateDebugUtilsMessengerEXT returnUnmarshal"); VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0; stream->read(&vkCreateDebugUtilsMessengerEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -22006,7 +21003,6 @@ void VkEncoder::vkDestroyDebugUtilsMessengerEXT( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT encode"); mImpl->log("start vkDestroyDebugUtilsMessengerEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22063,8 +21059,6 @@ void VkEncoder::vkDestroyDebugUtilsMessengerEXT( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT readParams"); - AEMU_SCOPED_TRACE("vkDestroyDebugUtilsMessengerEXT returnUnmarshal"); resources->destroyMapping()->mapHandles_VkDebugUtilsMessengerEXT((VkDebugUtilsMessengerEXT*)&messenger); pool->freeAll(); countingStream->clearPool(); @@ -22079,7 +21073,6 @@ void VkEncoder::vkSubmitDebugUtilsMessageEXT( const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT encode"); mImpl->log("start vkSubmitDebugUtilsMessageEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22123,8 +21116,6 @@ void VkEncoder::vkSubmitDebugUtilsMessageEXT( stream->write((VkDebugUtilsMessageSeverityFlagBitsEXT*)&local_messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT)); stream->write((VkDebugUtilsMessageTypeFlagsEXT*)&local_messageTypes, sizeof(VkDebugUtilsMessageTypeFlagsEXT)); marshal_VkDebugUtilsMessengerCallbackDataEXT(stream, (VkDebugUtilsMessengerCallbackDataEXT*)(local_pCallbackData)); - AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT readParams"); - AEMU_SCOPED_TRACE("vkSubmitDebugUtilsMessageEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -22139,7 +21130,6 @@ VkResult VkEncoder::vkGetAndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID* pProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID encode"); mImpl->log("start vkGetAndroidHardwareBufferPropertiesANDROID"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22172,13 +21162,11 @@ VkResult VkEncoder::vkGetAndroidHardwareBufferPropertiesANDROID( stream->write((uint64_t*)&cgen_var_1418, 1 * 8); stream->write((AHardwareBuffer*)local_buffer, sizeof(AHardwareBuffer)); marshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties)); - AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID readParams"); unmarshal_VkAndroidHardwareBufferPropertiesANDROID(stream, (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties)); if (pProperties) { transform_fromhost_VkAndroidHardwareBufferPropertiesANDROID(mImpl->resources(), (VkAndroidHardwareBufferPropertiesANDROID*)(pProperties)); } - AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID returnUnmarshal"); VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0; stream->read(&vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -22194,7 +21182,6 @@ VkResult VkEncoder::vkGetMemoryAndroidHardwareBufferANDROID( AHardwareBuffer** pBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID encode"); mImpl->log("start vkGetMemoryAndroidHardwareBufferANDROID"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22232,9 +21219,7 @@ VkResult VkEncoder::vkGetMemoryAndroidHardwareBufferANDROID( stream->write((uint64_t*)&cgen_var_1420, 1 * 8); marshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(stream, (VkMemoryGetAndroidHardwareBufferInfoANDROID*)(local_pInfo)); stream->write((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*)); - AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID readParams"); stream->read((AHardwareBuffer**)pBuffer, sizeof(AHardwareBuffer*)); - AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID returnUnmarshal"); VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0; stream->read(&vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -22261,7 +21246,6 @@ void VkEncoder::vkCmdSetSampleLocationsEXT( const VkSampleLocationsInfoEXT* pSampleLocationsInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT encode"); mImpl->log("start vkCmdSetSampleLocationsEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22297,8 +21281,6 @@ void VkEncoder::vkCmdSetSampleLocationsEXT( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1422, 1); stream->write((uint64_t*)&cgen_var_1422, 1 * 8); marshal_VkSampleLocationsInfoEXT(stream, (VkSampleLocationsInfoEXT*)(local_pSampleLocationsInfo)); - AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT readParams"); - AEMU_SCOPED_TRACE("vkCmdSetSampleLocationsEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -22311,7 +21293,6 @@ void VkEncoder::vkGetPhysicalDeviceMultisamplePropertiesEXT( VkMultisamplePropertiesEXT* pMultisampleProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT encode"); mImpl->log("start vkGetPhysicalDeviceMultisamplePropertiesEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22340,13 +21321,11 @@ void VkEncoder::vkGetPhysicalDeviceMultisamplePropertiesEXT( stream->write((uint64_t*)&cgen_var_1424, 1 * 8); stream->write((VkSampleCountFlagBits*)&local_samples, sizeof(VkSampleCountFlagBits)); marshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties)); - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT readParams"); unmarshal_VkMultisamplePropertiesEXT(stream, (VkMultisamplePropertiesEXT*)(pMultisampleProperties)); if (pMultisampleProperties) { transform_fromhost_VkMultisamplePropertiesEXT(mImpl->resources(), (VkMultisamplePropertiesEXT*)(pMultisampleProperties)); } - AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMultisamplePropertiesEXT returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -22372,7 +21351,6 @@ VkResult VkEncoder::vkCreateValidationCacheEXT( VkValidationCacheEXT* pValidationCache) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT encode"); mImpl->log("start vkCreateValidationCacheEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22442,13 +21420,11 @@ VkResult VkEncoder::vkCreateValidationCacheEXT( stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(pValidationCache, &cgen_var_1430, 1); stream->write((uint64_t*)&cgen_var_1430, 8); stream->setHandleMapping(resources->unwrapMapping()); - AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_1431; stream->read((uint64_t*)&cgen_var_1431, 8); stream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_1431, (VkValidationCacheEXT*)pValidationCache, 1); stream->unsetHandleMapping(); - AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT returnUnmarshal"); VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0; stream->read(&vkCreateValidationCacheEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -22464,7 +21440,6 @@ void VkEncoder::vkDestroyValidationCacheEXT( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT encode"); mImpl->log("start vkDestroyValidationCacheEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22521,8 +21496,6 @@ void VkEncoder::vkDestroyValidationCacheEXT( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT readParams"); - AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT returnUnmarshal"); resources->destroyMapping()->mapHandles_VkValidationCacheEXT((VkValidationCacheEXT*)&validationCache); pool->freeAll(); countingStream->clearPool(); @@ -22537,7 +21510,6 @@ VkResult VkEncoder::vkMergeValidationCachesEXT( const VkValidationCacheEXT* pSrcCaches) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT encode"); mImpl->log("start vkMergeValidationCachesEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22592,8 +21564,6 @@ VkResult VkEncoder::vkMergeValidationCachesEXT( stream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(local_pSrcCaches, cgen_var_1443, ((srcCacheCount))); stream->write((uint64_t*)cgen_var_1443, ((srcCacheCount)) * 8); } - AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT readParams"); - AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT returnUnmarshal"); VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0; stream->read(&vkMergeValidationCachesEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -22610,7 +21580,6 @@ VkResult VkEncoder::vkGetValidationCacheDataEXT( void* pData) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT encode"); mImpl->log("start vkGetValidationCacheDataEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22671,7 +21640,6 @@ VkResult VkEncoder::vkGetValidationCacheDataEXT( { stream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT readParams"); // WARNING PTR CHECK size_t* check_pDataSize; check_pDataSize = (size_t*)(uintptr_t)stream->getBe64(); @@ -22694,7 +21662,6 @@ VkResult VkEncoder::vkGetValidationCacheDataEXT( } stream->read((void*)pData, (*(pDataSize)) * sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT returnUnmarshal"); VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0; stream->read(&vkGetValidationCacheDataEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -22719,7 +21686,6 @@ VkResult VkEncoder::vkGetMemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT encode"); mImpl->log("start vkGetMemoryHostPointerPropertiesEXT"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22768,13 +21734,11 @@ VkResult VkEncoder::vkGetMemoryHostPointerPropertiesEXT( stream->write((void*)local_pHostPointer, sizeof(uint8_t)); } marshal_VkMemoryHostPointerPropertiesEXT(stream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties)); - AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT readParams"); unmarshal_VkMemoryHostPointerPropertiesEXT(stream, (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties)); if (pMemoryHostPointerProperties) { transform_fromhost_VkMemoryHostPointerPropertiesEXT(mImpl->resources(), (VkMemoryHostPointerPropertiesEXT*)(pMemoryHostPointerProperties)); } - AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT returnUnmarshal"); VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0; stream->read(&vkGetMemoryHostPointerPropertiesEXT_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -22794,7 +21758,6 @@ void VkEncoder::vkCmdWriteBufferMarkerAMD( uint32_t marker) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD encode"); mImpl->log("start vkCmdWriteBufferMarkerAMD"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22837,8 +21800,6 @@ void VkEncoder::vkCmdWriteBufferMarkerAMD( stream->write((uint64_t*)&cgen_var_1464, 1 * 8); stream->write((VkDeviceSize*)&local_dstOffset, sizeof(VkDeviceSize)); stream->write((uint32_t*)&local_marker, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD readParams"); - AEMU_SCOPED_TRACE("vkCmdWriteBufferMarkerAMD returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -22858,7 +21819,6 @@ void VkEncoder::vkCmdSetCheckpointNV( const void* pCheckpointMarker) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV encode"); mImpl->log("start vkCmdSetCheckpointNV"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22901,8 +21861,6 @@ void VkEncoder::vkCmdSetCheckpointNV( { stream->write((void*)local_pCheckpointMarker, sizeof(uint8_t)); } - AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV readParams"); - AEMU_SCOPED_TRACE("vkCmdSetCheckpointNV returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -22915,7 +21873,6 @@ void VkEncoder::vkGetQueueCheckpointDataNV( VkCheckpointDataNV* pCheckpointData) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV encode"); mImpl->log("start vkGetQueueCheckpointDataNV"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -22972,7 +21929,6 @@ void VkEncoder::vkGetQueueCheckpointDataNV( marshal_VkCheckpointDataNV(stream, (VkCheckpointDataNV*)(pCheckpointData + i)); } } - AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV readParams"); // WARNING PTR CHECK uint32_t* check_pCheckpointDataCount; check_pCheckpointDataCount = (uint32_t*)(uintptr_t)stream->getBe64(); @@ -23005,7 +21961,6 @@ void VkEncoder::vkGetQueueCheckpointDataNV( transform_fromhost_VkCheckpointDataNV(mImpl->resources(), (VkCheckpointDataNV*)(pCheckpointData + i)); } } - AEMU_SCOPED_TRACE("vkGetQueueCheckpointDataNV returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -23020,7 +21975,6 @@ VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE( uint64_t* pAddress) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE encode"); mImpl->log("start vkMapMemoryIntoAddressSpaceGOOGLE"); mImpl->resources()->on_vkMapMemoryIntoAddressSpaceGOOGLE_pre(this, VK_SUCCESS, device, memory, pAddress); auto stream = mImpl->stream(); @@ -23067,7 +22021,6 @@ VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE( { stream->write((uint64_t*)pAddress, sizeof(uint64_t)); } - AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE readParams"); // WARNING PTR CHECK uint64_t* check_pAddress; check_pAddress = (uint64_t*)(uintptr_t)stream->getBe64(); @@ -23079,7 +22032,6 @@ VkResult VkEncoder::vkMapMemoryIntoAddressSpaceGOOGLE( } stream->read((uint64_t*)pAddress, sizeof(uint64_t)); } - AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE returnUnmarshal"); VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0; stream->read(&vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, sizeof(VkResult)); mImpl->resources()->on_vkMapMemoryIntoAddressSpaceGOOGLE(this, vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return, device, memory, pAddress); @@ -23098,7 +22050,6 @@ VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE( uint32_t colorBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE encode"); mImpl->log("start vkRegisterImageColorBufferGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23133,8 +22084,6 @@ VkResult VkEncoder::vkRegisterImageColorBufferGOOGLE( stream->handleMapping()->mapHandles_VkImage_u64(&local_image, &cgen_var_1487, 1); stream->write((uint64_t*)&cgen_var_1487, 1 * 8); stream->write((uint32_t*)&local_colorBuffer, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE returnUnmarshal"); VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0; stream->read(&vkRegisterImageColorBufferGOOGLE_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -23150,7 +22099,6 @@ VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE( uint32_t colorBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE encode"); mImpl->log("start vkRegisterBufferColorBufferGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23185,8 +22133,6 @@ VkResult VkEncoder::vkRegisterBufferColorBufferGOOGLE( stream->handleMapping()->mapHandles_VkBuffer_u64(&local_buffer, &cgen_var_1491, 1); stream->write((uint64_t*)&cgen_var_1491, 1 * 8); stream->write((uint32_t*)&local_colorBuffer, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE returnUnmarshal"); VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0; stream->read(&vkRegisterBufferColorBufferGOOGLE_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -23213,7 +22159,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateSizedGOOGLE( const VkBufferView* pBufferViews) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE encode"); mImpl->log("start vkUpdateDescriptorSetWithTemplateSizedGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23430,8 +22375,6 @@ void VkEncoder::vkUpdateDescriptorSetWithTemplateSizedGOOGLE( stream->write((uint64_t*)cgen_var_1511, ((bufferViewCount)) * 8); } } - AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -23445,7 +22388,6 @@ void VkEncoder::vkBeginCommandBufferAsyncGOOGLE( const VkCommandBufferBeginInfo* pBeginInfo) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE encode"); mImpl->log("start vkBeginCommandBufferAsyncGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23481,8 +22423,6 @@ void VkEncoder::vkBeginCommandBufferAsyncGOOGLE( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1513, 1); stream->write((uint64_t*)&cgen_var_1513, 1 * 8); marshal_VkCommandBufferBeginInfo(stream, (VkCommandBufferBeginInfo*)(local_pBeginInfo)); - AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -23493,7 +22433,6 @@ void VkEncoder::vkEndCommandBufferAsyncGOOGLE( VkCommandBuffer commandBuffer) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE encode"); mImpl->log("start vkEndCommandBufferAsyncGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23516,8 +22455,6 @@ void VkEncoder::vkEndCommandBufferAsyncGOOGLE( uint64_t cgen_var_1515; stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1515, 1); stream->write((uint64_t*)&cgen_var_1515, 1 * 8); - AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE returnUnmarshal"); stream->flush(); pool->freeAll(); countingStream->clearPool(); @@ -23530,7 +22467,6 @@ void VkEncoder::vkResetCommandBufferAsyncGOOGLE( VkCommandBufferResetFlags flags) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE encode"); mImpl->log("start vkResetCommandBufferAsyncGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23557,8 +22493,6 @@ void VkEncoder::vkResetCommandBufferAsyncGOOGLE( stream->handleMapping()->mapHandles_VkCommandBuffer_u64(&local_commandBuffer, &cgen_var_1517, 1); stream->write((uint64_t*)&cgen_var_1517, 1 * 8); stream->write((VkCommandBufferResetFlags*)&local_flags, sizeof(VkCommandBufferResetFlags)); - AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -23571,7 +22505,6 @@ void VkEncoder::vkCommandBufferHostSyncGOOGLE( uint32_t sequenceNumber) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE encode"); mImpl->log("start vkCommandBufferHostSyncGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23602,8 +22535,6 @@ void VkEncoder::vkCommandBufferHostSyncGOOGLE( stream->write((uint64_t*)&cgen_var_1519, 1 * 8); stream->write((uint32_t*)&local_needHostSync, sizeof(uint32_t)); stream->write((uint32_t*)&local_sequenceNumber, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -23620,7 +22551,6 @@ VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE( VkMemoryRequirements* pMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE encode"); mImpl->log("start vkCreateImageWithRequirementsGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23693,7 +22623,6 @@ VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE( stream->write((uint64_t*)&cgen_var_1525, 8); stream->setHandleMapping(resources->unwrapMapping()); marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements)); - AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_1526; stream->read((uint64_t*)&cgen_var_1526, 8); @@ -23704,7 +22633,6 @@ VkResult VkEncoder::vkCreateImageWithRequirementsGOOGLE( { transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements)); } - AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE returnUnmarshal"); VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0; stream->read(&vkCreateImageWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -23722,7 +22650,6 @@ VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE( VkMemoryRequirements* pMemoryRequirements) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE encode"); mImpl->log("start vkCreateBufferWithRequirementsGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23794,7 +22721,6 @@ VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE( stream->write((uint64_t*)&cgen_var_1532, 8); stream->setHandleMapping(resources->unwrapMapping()); marshal_VkMemoryRequirements(stream, (VkMemoryRequirements*)(pMemoryRequirements)); - AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE readParams"); stream->setHandleMapping(resources->createMapping()); uint64_t cgen_var_1533; stream->read((uint64_t*)&cgen_var_1533, 8); @@ -23805,7 +22731,6 @@ VkResult VkEncoder::vkCreateBufferWithRequirementsGOOGLE( { transform_fromhost_VkMemoryRequirements(mImpl->resources(), (VkMemoryRequirements*)(pMemoryRequirements)); } - AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE returnUnmarshal"); VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0; stream->read(&vkCreateBufferWithRequirementsGOOGLE_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -23825,7 +22750,6 @@ VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE( uint64_t* pHostmemId) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE encode"); mImpl->log("start vkGetMemoryHostAddressInfoGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -23899,7 +22823,6 @@ VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE( { stream->write((uint64_t*)pHostmemId, sizeof(uint64_t)); } - AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE readParams"); // WARNING PTR CHECK uint64_t* check_pAddress; check_pAddress = (uint64_t*)(uintptr_t)stream->getBe64(); @@ -23933,7 +22856,6 @@ VkResult VkEncoder::vkGetMemoryHostAddressInfoGOOGLE( } stream->read((uint64_t*)pHostmemId, sizeof(uint64_t)); } - AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE returnUnmarshal"); VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0; stream->read(&vkGetMemoryHostAddressInfoGOOGLE_VkResult_return, sizeof(VkResult)); pool->freeAll(); @@ -23951,7 +22873,6 @@ VkResult VkEncoder::vkFreeMemorySyncGOOGLE( const VkAllocationCallbacks* pAllocator) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE encode"); mImpl->log("start vkFreeMemorySyncGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -24005,8 +22926,6 @@ VkResult VkEncoder::vkFreeMemorySyncGOOGLE( { marshal_VkAllocationCallbacks(stream, (VkAllocationCallbacks*)(local_pAllocator)); } - AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE returnUnmarshal"); VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0; stream->read(&vkFreeMemorySyncGOOGLE_VkResult_return, sizeof(VkResult)); resources->destroyMapping()->mapHandles_VkDeviceMemory((VkDeviceMemory*)&memory); @@ -24025,7 +22944,6 @@ void VkEncoder::vkQueueHostSyncGOOGLE( uint32_t sequenceNumber) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE encode"); mImpl->log("start vkQueueHostSyncGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -24056,8 +22974,6 @@ void VkEncoder::vkQueueHostSyncGOOGLE( stream->write((uint64_t*)&cgen_var_1554, 1 * 8); stream->write((uint32_t*)&local_needHostSync, sizeof(uint32_t)); stream->write((uint32_t*)&local_sequenceNumber, sizeof(uint32_t)); - AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE returnUnmarshal"); pool->freeAll(); countingStream->clearPool(); stream->clearPool(); @@ -24071,7 +22987,6 @@ void VkEncoder::vkQueueSubmitAsyncGOOGLE( VkFence fence) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE encode"); mImpl->log("start vkQueueSubmitAsyncGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -24131,8 +23046,6 @@ void VkEncoder::vkQueueSubmitAsyncGOOGLE( uint64_t cgen_var_1558; stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1558, 1); stream->write((uint64_t*)&cgen_var_1558, 1 * 8); - AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE returnUnmarshal"); stream->flush(); pool->freeAll(); countingStream->clearPool(); @@ -24144,7 +23057,6 @@ void VkEncoder::vkQueueWaitIdleAsyncGOOGLE( VkQueue queue) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE encode"); mImpl->log("start vkQueueWaitIdleAsyncGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -24167,8 +23079,6 @@ void VkEncoder::vkQueueWaitIdleAsyncGOOGLE( uint64_t cgen_var_1560; stream->handleMapping()->mapHandles_VkQueue_u64(&local_queue, &cgen_var_1560, 1); stream->write((uint64_t*)&cgen_var_1560, 1 * 8); - AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE returnUnmarshal"); stream->flush(); pool->freeAll(); countingStream->clearPool(); @@ -24183,7 +23093,6 @@ void VkEncoder::vkQueueBindSparseAsyncGOOGLE( VkFence fence) { EncoderAutoLock encoderLock(this); - AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE encode"); mImpl->log("start vkQueueBindSparseAsyncGOOGLE"); auto stream = mImpl->stream(); auto countingStream = mImpl->countingStream(); @@ -24243,8 +23152,6 @@ void VkEncoder::vkQueueBindSparseAsyncGOOGLE( uint64_t cgen_var_1564; stream->handleMapping()->mapHandles_VkFence_u64(&local_fence, &cgen_var_1564, 1); stream->write((uint64_t*)&cgen_var_1564, 1 * 8); - AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE readParams"); - AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE returnUnmarshal"); stream->flush(); pool->freeAll(); countingStream->clearPool(); @@ -24253,5 +23160,52 @@ void VkEncoder::vkQueueBindSparseAsyncGOOGLE( } #endif +#ifdef VK_GOOGLE_linear_image_layout +void VkEncoder::vkGetLinearImageLayoutGOOGLE( + VkDevice device, + VkFormat format, + VkDeviceSize* pOffset, + VkDeviceSize* pRowPitchAlignment) +{ + EncoderAutoLock encoderLock(this); + mImpl->log("start vkGetLinearImageLayoutGOOGLE"); + auto stream = mImpl->stream(); + auto countingStream = mImpl->countingStream(); + auto resources = mImpl->resources(); + auto pool = mImpl->pool(); + stream->setHandleMapping(resources->unwrapMapping()); + VkDevice local_device; + VkFormat local_format; + local_device = device; + local_format = format; + countingStream->rewind(); + { + uint64_t cgen_var_1565; + countingStream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1565, 1); + countingStream->write((uint64_t*)&cgen_var_1565, 1 * 8); + countingStream->write((VkFormat*)&local_format, sizeof(VkFormat)); + countingStream->write((VkDeviceSize*)pOffset, sizeof(VkDeviceSize)); + countingStream->write((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize)); + } + uint32_t packetSize_vkGetLinearImageLayoutGOOGLE = 4 + 4 + (uint32_t)countingStream->bytesWritten(); + countingStream->rewind(); + uint32_t opcode_vkGetLinearImageLayoutGOOGLE = OP_vkGetLinearImageLayoutGOOGLE; + stream->write(&opcode_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t)); + stream->write(&packetSize_vkGetLinearImageLayoutGOOGLE, sizeof(uint32_t)); + uint64_t cgen_var_1566; + stream->handleMapping()->mapHandles_VkDevice_u64(&local_device, &cgen_var_1566, 1); + stream->write((uint64_t*)&cgen_var_1566, 1 * 8); + stream->write((VkFormat*)&local_format, sizeof(VkFormat)); + stream->write((VkDeviceSize*)pOffset, sizeof(VkDeviceSize)); + stream->write((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize)); + stream->read((VkDeviceSize*)pOffset, sizeof(VkDeviceSize)); + stream->read((VkDeviceSize*)pRowPitchAlignment, sizeof(VkDeviceSize)); + pool->freeAll(); + countingStream->clearPool(); + stream->clearPool(); + mImpl->log("finish vkGetLinearImageLayoutGOOGLE");; +} + +#endif } // namespace goldfish_vk diff --git a/system/vulkan_enc/VkEncoder.cpp.inl b/system/vulkan_enc/VkEncoder.cpp.inl new file mode 100644 index 00000000..5e1c5f39 --- /dev/null +++ b/system/vulkan_enc/VkEncoder.cpp.inl @@ -0,0 +1,124 @@ + +class VkEncoder::Impl { +public: + Impl(IOStream* stream) : m_stream(stream), m_logEncodes(false) { + m_stream.incStreamRef(); + const char* emuVkLogEncodesPropName = "qemu.vk.log"; + char encodeProp[PROPERTY_VALUE_MAX]; + if (property_get(emuVkLogEncodesPropName, encodeProp, nullptr) > 0) { + m_logEncodes = atoi(encodeProp) > 0; + } + } + + ~Impl() { + m_stream.decStreamRef(); + } + + VulkanCountingStream* countingStream() { return &m_countingStream; } + VulkanStreamGuest* stream() { return &m_stream; } + Pool* pool() { return &m_pool; } + ResourceTracker* resources() { return ResourceTracker::get(); } + Validation* validation() { return &m_validation; } + + void log(const char* text) { + if (!m_logEncodes) return; + ALOGD("encoder log: %s", text); + } + + void flush() { + lock(); + m_stream.flush(); + unlock(); + } + + // can be recursive + void lock() { + if (this == sAcquiredEncoderThreadLocal) { + ++sAcquiredEncoderThreadLockLevels; + return; // recursive + } + while (mLock.test_and_set(std::memory_order_acquire)); + sAcquiredEncoderThreadLocal = this; + sAcquiredEncoderThreadLockLevels = 1; + } + + void unlock() { + if (this != sAcquiredEncoderThreadLocal) { + // error, trying to unlock without having locked first + return; + } + + --sAcquiredEncoderThreadLockLevels; + if (0 == sAcquiredEncoderThreadLockLevels) { + mLock.clear(std::memory_order_release); + sAcquiredEncoderThreadLocal = nullptr; + } + } + + void incRef() { + __atomic_add_fetch(&m_refCount, 1, __ATOMIC_SEQ_CST); + } + + bool decRef() { + if (0 == __atomic_sub_fetch(&m_refCount, 1, __ATOMIC_SEQ_CST)) { + return true; + } + return false; + } + +private: + VulkanCountingStream m_countingStream; + VulkanStreamGuest m_stream; + Pool m_pool { 8, 4096, 64 }; + + Validation m_validation; + bool m_logEncodes; + std::atomic_flag mLock = ATOMIC_FLAG_INIT; + static thread_local Impl* sAcquiredEncoderThreadLocal; + static thread_local uint32_t sAcquiredEncoderThreadLockLevels; + uint32_t m_refCount = 1; +}; + +VkEncoder::~VkEncoder() { } + +// static +thread_local VkEncoder::Impl* VkEncoder::Impl::sAcquiredEncoderThreadLocal = nullptr; +thread_local uint32_t VkEncoder::Impl::sAcquiredEncoderThreadLockLevels = 0; + +struct EncoderAutoLock { + EncoderAutoLock(VkEncoder* enc) : mEnc(enc) { + mEnc->lock(); + } + ~EncoderAutoLock() { + mEnc->unlock(); + } + VkEncoder* mEnc; +}; + +VkEncoder::VkEncoder(IOStream *stream) : + mImpl(new VkEncoder::Impl(stream)) { } + +void VkEncoder::flush() { + mImpl->flush(); +} + +void VkEncoder::lock() { + mImpl->lock(); +} + +void VkEncoder::unlock() { + mImpl->unlock(); +} + +void VkEncoder::incRef() { + mImpl->incRef(); +} + +bool VkEncoder::decRef() { + if (mImpl->decRef()) { + delete this; + return true; + } + return false; +} + diff --git a/system/vulkan_enc/VkEncoder.h b/system/vulkan_enc/VkEncoder.h index bde9ab8a..d2638238 100644 --- a/system/vulkan_enc/VkEncoder.h +++ b/system/vulkan_enc/VkEncoder.h @@ -40,9 +40,7 @@ public: VkEncoder(IOStream* stream); ~VkEncoder(); - void flush(); - void lock(); - void unlock(); +#include "VkEncoder.h.inl" #ifdef VK_VERSION_1_0 VkResult vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, @@ -1838,6 +1836,13 @@ public: const VkBindSparseInfo* pBindInfo, VkFence fence); #endif +#ifdef VK_GOOGLE_linear_image_layout + void vkGetLinearImageLayoutGOOGLE( + VkDevice device, + VkFormat format, + VkDeviceSize* pOffset, + VkDeviceSize* pRowPitchAlignment); +#endif private: class Impl; diff --git a/system/vulkan_enc/VkEncoder.h.inl b/system/vulkan_enc/VkEncoder.h.inl new file mode 100644 index 00000000..d4155966 --- /dev/null +++ b/system/vulkan_enc/VkEncoder.h.inl @@ -0,0 +1,5 @@ + void flush(); + void lock(); + void unlock(); + void incRef(); + bool decRef(); diff --git a/system/vulkan_enc/VulkanStreamGuest.cpp b/system/vulkan_enc/VulkanStreamGuest.cpp index 43f3706c..32993b6d 100644 --- a/system/vulkan_enc/VulkanStreamGuest.cpp +++ b/system/vulkan_enc/VulkanStreamGuest.cpp @@ -84,6 +84,14 @@ public: return mFeatureBits; } + void incStreamRef() { + mStream->incRef(); + } + + bool decStreamRef() { + return mStream->decRef(); + } + private: size_t oustandingWriteBuffer() const { return mWritePos; @@ -190,6 +198,14 @@ uint32_t VulkanStreamGuest::getFeatureBits() const { return mImpl->getFeatureBits(); } +void VulkanStreamGuest::incStreamRef() { + mImpl->incStreamRef(); +} + +bool VulkanStreamGuest::decStreamRef() { + return mImpl->decStreamRef(); +} + VulkanCountingStream::VulkanCountingStream() : VulkanStreamGuest(nullptr) { } VulkanCountingStream::~VulkanCountingStream() = default; diff --git a/system/vulkan_enc/VulkanStreamGuest.h b/system/vulkan_enc/VulkanStreamGuest.h index d70b9fbb..e8425e15 100644 --- a/system/vulkan_enc/VulkanStreamGuest.h +++ b/system/vulkan_enc/VulkanStreamGuest.h @@ -56,6 +56,9 @@ public: uint32_t getFeatureBits() const; + void incStreamRef(); + bool decStreamRef(); + private: class Impl; std::unique_ptr<Impl> mImpl; diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp index 4f59d219..512554f8 100644 --- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp +++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.cpp @@ -6426,6 +6426,8 @@ void deepcopy_VkImportPhysicalAddressGOOGLE( #endif #ifdef VK_GOOGLE_async_queue_submit #endif +#ifdef VK_GOOGLE_linear_image_layout +#endif void deepcopy_extension_struct( Pool* pool, const void* structExtension, diff --git a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h index 243240a4..8cca9b1c 100644 --- a/system/vulkan_enc/goldfish_vk_deepcopy_guest.h +++ b/system/vulkan_enc/goldfish_vk_deepcopy_guest.h @@ -2046,5 +2046,7 @@ void deepcopy_VkImportPhysicalAddressGOOGLE( #endif #ifdef VK_GOOGLE_async_queue_submit #endif +#ifdef VK_GOOGLE_linear_image_layout +#endif } // namespace goldfish_vk diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp index 1bc69fa1..ee84c212 100644 --- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp +++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.cpp @@ -292,6 +292,8 @@ namespace goldfish_vk { #endif #ifdef VK_GOOGLE_async_queue_submit #endif +#ifdef VK_GOOGLE_linear_image_layout +#endif uint32_t goldfish_vk_struct_type( const void* structExtension) { diff --git a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h index 9d91cdc4..e549de9a 100644 --- a/system/vulkan_enc/goldfish_vk_extension_structs_guest.h +++ b/system/vulkan_enc/goldfish_vk_extension_structs_guest.h @@ -313,5 +313,7 @@ size_t goldfish_vk_extension_struct_size_with_stream_features( #endif #ifdef VK_GOOGLE_async_queue_submit #endif +#ifdef VK_GOOGLE_linear_image_layout +#endif } // namespace goldfish_vk diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp index 2e22fb0c..ff9a0697 100644 --- a/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp +++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.cpp @@ -4782,6 +4782,8 @@ void handlemap_VkImportPhysicalAddressGOOGLE( #endif #ifdef VK_GOOGLE_async_queue_submit #endif +#ifdef VK_GOOGLE_linear_image_layout +#endif void handlemap_extension_struct( VulkanHandleMapping* handlemap, void* structExtension_out) diff --git a/system/vulkan_enc/goldfish_vk_handlemap_guest.h b/system/vulkan_enc/goldfish_vk_handlemap_guest.h index 79eeaf66..88fca6c6 100644 --- a/system/vulkan_enc/goldfish_vk_handlemap_guest.h +++ b/system/vulkan_enc/goldfish_vk_handlemap_guest.h @@ -1697,5 +1697,7 @@ void handlemap_VkImportPhysicalAddressGOOGLE( #endif #ifdef VK_GOOGLE_async_queue_submit #endif +#ifdef VK_GOOGLE_linear_image_layout +#endif } // namespace goldfish_vk diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp index f857a2a8..15fa96f9 100644 --- a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp +++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp @@ -10370,6 +10370,8 @@ void unmarshal_VkImportPhysicalAddressGOOGLE( #endif #ifdef VK_GOOGLE_async_queue_submit #endif +#ifdef VK_GOOGLE_linear_image_layout +#endif void marshal_extension_struct( VulkanStreamGuest* vkStream, const void* structExtension) @@ -13241,6 +13243,12 @@ const char* api_opcode_to_string( return "OP_vkQueueBindSparseAsyncGOOGLE"; } #endif +#ifdef VK_GOOGLE_linear_image_layout + case OP_vkGetLinearImageLayoutGOOGLE: + { + return "OP_vkGetLinearImageLayoutGOOGLE"; + } +#endif default: { return "OP_UNKNOWN_API_CALL"; diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.h b/system/vulkan_enc/goldfish_vk_marshaling_guest.h index df07272c..d8cb1b0b 100644 --- a/system/vulkan_enc/goldfish_vk_marshaling_guest.h +++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.h @@ -3424,6 +3424,9 @@ void unmarshal_VkImportPhysicalAddressGOOGLE( #define OP_vkQueueWaitIdleAsyncGOOGLE 20331 #define OP_vkQueueBindSparseAsyncGOOGLE 20332 #endif +#ifdef VK_GOOGLE_linear_image_layout +#define OP_vkGetLinearImageLayoutGOOGLE 20333 +#endif const char* api_opcode_to_string( const uint32_t opcode); diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h index dc4b7c64..b844cdde 100644 --- a/system/vulkan_enc/goldfish_vk_private_defs.h +++ b/system/vulkan_enc/goldfish_vk_private_defs.h @@ -282,6 +282,13 @@ enum AHardwareBuffer_Format { * OpenGL ES: GL_STENCIL_INDEX8 */ AHARDWAREBUFFER_FORMAT_S8_UINT = 0x35, + /** + * YUV 420 888 format. + * Must have an even width and height. Can be accessed in OpenGL + * shaders through an external sampler. Does not support mip-maps + * cube-maps or multi-layered textures. + */ + AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 = 0x23, }; /** * Buffer usage flags, specifying how the buffer will be accessed. @@ -618,6 +625,10 @@ typedef void (VKAPI_PTR *PFN_vkQueueWaitIdleAsyncGOOGLE)(VkQueue queue); typedef void (VKAPI_PTR *PFN_vkQueueBindSparseAsyncGOOGLE)( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +#define VK_GOOGLE_linear_image_layout 1 + +typedef VkResult (VKAPI_PTR *PFN_vkGetLinearImageLayoutGOOGLE)(VkDevice device, VkFormat format, VkDeviceSize* pOffset, VkDeviceSize* pRowPitchAlignment); + #ifdef __cplusplus } // extern "C" #endif diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.cpp b/system/vulkan_enc/goldfish_vk_transform_guest.cpp index 6fc3e46c..b829c49f 100644 --- a/system/vulkan_enc/goldfish_vk_transform_guest.cpp +++ b/system/vulkan_enc/goldfish_vk_transform_guest.cpp @@ -9003,6 +9003,8 @@ void transform_fromhost_VkImportPhysicalAddressGOOGLE( #endif #ifdef VK_GOOGLE_async_queue_submit #endif +#ifdef VK_GOOGLE_linear_image_layout +#endif void transform_tohost_extension_struct( ResourceTracker* resourceTracker, void* structExtension_out) diff --git a/system/vulkan_enc/goldfish_vk_transform_guest.h b/system/vulkan_enc/goldfish_vk_transform_guest.h index b9699583..b29e205f 100644 --- a/system/vulkan_enc/goldfish_vk_transform_guest.h +++ b/system/vulkan_enc/goldfish_vk_transform_guest.h @@ -3093,5 +3093,7 @@ void transform_fromhost_VkImportPhysicalAddressGOOGLE( #endif #ifdef VK_GOOGLE_async_queue_submit #endif +#ifdef VK_GOOGLE_linear_image_layout +#endif } // namespace goldfish_vk diff --git a/system/vulkan_enc/vk_format_info.h b/system/vulkan_enc/vk_format_info.h index dd9c99bc..d80d9c34 100644 --- a/system/vulkan_enc/vk_format_info.h +++ b/system/vulkan_enc/vk_format_info.h @@ -29,6 +29,11 @@ #include <stdbool.h> #ifdef VK_USE_PLATFORM_ANDROID_KHR #include <system/graphics.h> +#else +/* See system/graphics.h. */ +enum { + HAL_PIXEL_FORMAT_YV12 = 842094169, +}; #endif #include <vulkan/vulkan.h> #include <vndk/hardware_buffer.h> @@ -36,6 +41,11 @@ /* See i915_private_android_types.h in minigbm. */ #define HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL 0x100 +// TODO(b/167698976): We should not use OMX_COLOR_FormatYUV420Planar +// but we seem to miss a format translation somewhere. + +#define OMX_COLOR_FormatYUV420Planar 0x13 + static inline VkFormat vk_format_from_android(unsigned android_format) { @@ -54,11 +64,12 @@ vk_format_from_android(unsigned android_format) return VK_FORMAT_A2B10G10R10_UNORM_PACK32; case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL: return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; + case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420: + return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; #ifdef VK_USE_PLATFORM_ANDROID_KHR case HAL_PIXEL_FORMAT_YV12: - // YUV converter will convert this format to R8G8B8A8 - // TODO: should we use R8G8B8A8 for other YUV format as well? - return VK_FORMAT_R8G8B8A8_UNORM; + case OMX_COLOR_FormatYUV420Planar: + return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; case AHARDWAREBUFFER_FORMAT_BLOB: #endif default: @@ -82,6 +93,8 @@ android_format_from_vk(VkFormat vk_format) return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM; case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: return HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL; + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + return HAL_PIXEL_FORMAT_YV12; default: return AHARDWAREBUFFER_FORMAT_BLOB; } @@ -92,6 +105,8 @@ android_format_is_yuv(unsigned android_format) { switch (android_format) { case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL: + case OMX_COLOR_FormatYUV420Planar: + case HAL_PIXEL_FORMAT_YV12: return true; default: diff --git a/system/vulkan_enc/vk_struct_id.h b/system/vulkan_enc/vk_struct_id.h index b720edf6..0aaf7a9a 100644 --- a/system/vulkan_enc/vk_struct_id.h +++ b/system/vulkan_enc/vk_struct_id.h @@ -52,5 +52,6 @@ REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionInfo, VK_STRUCTURE_TYPE_SAMPLER_YC REGISTER_VK_STRUCT_ID(VkFenceCreateInfo, VK_STRUCTURE_TYPE_FENCE_CREATE_INFO); REGISTER_VK_STRUCT_ID(VkExportFenceCreateInfo, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO); REGISTER_VK_STRUCT_ID(VkImportBufferGOOGLE, VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE); +REGISTER_VK_STRUCT_ID(VkExternalImageFormatProperties, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES); #undef REGISTER_VK_STRUCT_ID |