From 879df8296530b06e59a457e5571c591d81ddec3a Mon Sep 17 00:00:00 2001 From: Maciej Jesionowski Date: Wed, 16 Oct 2019 13:15:01 +0200 Subject: [PATCH] Add VK_AMD_buffer_marker tests This extension adds a new operation to execute pipelined writes of small marker values into a VkBuffer object. Components: Vulkan VK-GL-CTS issue: 2104 New tests: dEQP-VK.api.buffer_marker.* Change-Id: I190b0b81564fe58707b6eae40f4768482b01699f --- AndroidGen.mk | 1 + android/cts/master/vk-master.txt | 96 ++ .../vulkancts/modules/vulkan/api/CMakeLists.txt | 2 + .../modules/vulkan/api/vktApiBufferMarkerTests.cpp | 1131 ++++++++++++++++++++ .../modules/vulkan/api/vktApiBufferMarkerTests.hpp | 39 + .../vulkancts/modules/vulkan/api/vktApiTests.cpp | 2 + .../modules/vulkan/util/vktExternalMemoryUtil.cpp | 80 +- .../modules/vulkan/util/vktExternalMemoryUtil.hpp | 30 +- external/vulkancts/modules/vulkan/vktTestCase.cpp | 1 + .../mustpass/master/vk-default-no-waivers.txt | 96 ++ external/vulkancts/mustpass/master/vk-default.txt | 96 ++ 11 files changed, 1572 insertions(+), 2 deletions(-) create mode 100644 external/vulkancts/modules/vulkan/api/vktApiBufferMarkerTests.cpp create mode 100644 external/vulkancts/modules/vulkan/api/vktApiBufferMarkerTests.hpp diff --git a/AndroidGen.mk b/AndroidGen.mk index 6fe0ec5..f743c98 100644 --- a/AndroidGen.mk +++ b/AndroidGen.mk @@ -65,6 +65,7 @@ LOCAL_SRC_FILES := \ external/vulkancts/modules/vulkan/amber/vktAmberTestCaseUtil.cpp \ external/vulkancts/modules/vulkan/api/vktApiBufferAndImageAllocationUtil.cpp \ external/vulkancts/modules/vulkan/api/vktApiBufferComputeInstance.cpp \ + external/vulkancts/modules/vulkan/api/vktApiBufferMarkerTests.cpp \ external/vulkancts/modules/vulkan/api/vktApiBufferTests.cpp \ external/vulkancts/modules/vulkan/api/vktApiBufferViewAccessTests.cpp \ external/vulkancts/modules/vulkan/api/vktApiBufferViewCreateTests.cpp \ diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt index fae1be3..18081b5 100644 --- a/android/cts/master/vk-master.txt +++ b/android/cts/master/vk-master.txt @@ -7167,6 +7167,102 @@ dEQP-VK.api.buffer.dedicated_alloc.index.create.zero dEQP-VK.api.buffer.dedicated_alloc.vertex.indirect.create.zero dEQP-VK.api.buffer.dedicated_alloc.vertex.create.zero dEQP-VK.api.buffer.dedicated_alloc.indirect.create.zero +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.memory_dep.buffer_copy dEQP-VK.api.buffer_view.create.suballocation.uniform.r4g4_unorm_pack8 dEQP-VK.api.buffer_view.create.suballocation.uniform.r4g4b4a4_unorm_pack16 dEQP-VK.api.buffer_view.create.suballocation.uniform.b4g4r4a4_unorm_pack16 diff --git a/external/vulkancts/modules/vulkan/api/CMakeLists.txt b/external/vulkancts/modules/vulkan/api/CMakeLists.txt index 0db5ff9..0fd6c24 100644 --- a/external/vulkancts/modules/vulkan/api/CMakeLists.txt +++ b/external/vulkancts/modules/vulkan/api/CMakeLists.txt @@ -20,6 +20,8 @@ set(DEQP_VK_API_SRCS vktApiObjectManagementTests.hpp vktApiBufferTests.cpp vktApiBufferTests.hpp + vktApiBufferMarkerTests.cpp + vktApiBufferMarkerTests.hpp vktApiBufferViewCreateTests.cpp vktApiBufferViewCreateTests.hpp vktApiBufferViewAccessTests.cpp diff --git a/external/vulkancts/modules/vulkan/api/vktApiBufferMarkerTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiBufferMarkerTests.cpp new file mode 100644 index 0000000..be54a88 --- /dev/null +++ b/external/vulkancts/modules/vulkan/api/vktApiBufferMarkerTests.cpp @@ -0,0 +1,1131 @@ +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2019 Advanced Micro Devices, Inc. + * Copyright (c) 2019 The Khronos Group Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file + * \brief Tests for VK_AMD_buffer_marker + *//*--------------------------------------------------------------------*/ + +#include "vktApiBufferMarkerTests.hpp" +#include "vktTestCase.hpp" +#include "vktTestCaseUtil.hpp" +#include "vktTestGroupUtil.hpp" +#include "vktExternalMemoryUtil.hpp" +#include "vkPlatform.hpp" +#include "vkCmdUtil.hpp" +#include "vkObjUtil.hpp" +#include "vkMemUtil.hpp" +#include "vkQueryUtil.hpp" +#include "vkRefUtil.hpp" +#include "vkBuilderUtil.hpp" +#include "deUniquePtr.hpp" +#include "deSharedPtr.hpp" +#include "deRandom.hpp" + +#include + +namespace vkt +{ +namespace api +{ +namespace +{ +using namespace vk; +using de::UniquePtr; +using de::MovePtr; +using de::SharedPtr; +using namespace vkt::ExternalMemoryUtil; + +template +inline const T* dataOrNullPtr(const std::vector& v) +{ + return (v.empty() ? DE_NULL : &v[0]); +} + +template +inline T* dataOrNullPtr(std::vector& v) +{ + return (v.empty() ? DE_NULL : &v[0]); +} + +//! Common test data related to the device +struct WorkingDevice +{ + Move logicalDevice; + MovePtr deviceDriver; + MovePtr allocator; + VkQueue queue; + deUint32 queueFamilyIdx; + VkQueueFamilyProperties queueProps; +}; + +bool queueFamilyMatchesTestCase(const VkQueueFamilyProperties& props, VkQueueFlagBits testQueue) +{ + // The goal is to find a queue family that most accurately represents the required queue flag. For example, if flag is + // VK_QUEUE_TRANSFER_BIT, we want to target transfer-only queues for such a test case rather than universal queues which + // may include VK_QUEUE_TRANSFER_BIT along with other queue flags. + const VkQueueFlags flags = props.queueFlags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT); + + // for VK_QUEUE_TRANSFER_BIT, target transfer-only queues: + if (testQueue == VK_QUEUE_TRANSFER_BIT) + return (flags == VK_QUEUE_TRANSFER_BIT); + + // for VK_QUEUE_COMPUTE_BIT, target compute only queues + if (testQueue == VK_QUEUE_COMPUTE_BIT) + return ((flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT)) == VK_QUEUE_COMPUTE_BIT); + + // for VK_QUEUE_GRAPHICS_BIT, target universal queues (queues which support graphics) + if (testQueue == VK_QUEUE_GRAPHICS_BIT) + return ((flags & VK_QUEUE_GRAPHICS_BIT) != 0); + + DE_FATAL("Unexpected test queue flag"); + + return false; +} + +// We create a custom device because we don't want to always use the universal queue. +void createDeviceWithExtension (Context& context, WorkingDevice& wd, VkQueueFlagBits testQueue, bool hostPtr) +{ + const PlatformInterface& vkp = context.getPlatformInterface(); + const VkInstance instance = context.getInstance(); + const InstanceInterface& instanceDriver = context.getInstanceInterface(); + const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); + + // Create a device with extension enabled and a queue with a family which supports the buffer marker extension + const std::vector queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice); + const float queuePriority = 1.0f; + VkDeviceQueueCreateInfo queueCreateInfo = {}; + + for (deUint32 familyIdx = 0; familyIdx < queueFamilyProperties.size(); ++familyIdx) + { + if (queueFamilyMatchesTestCase(queueFamilyProperties[familyIdx], testQueue) && + queueFamilyProperties[familyIdx].queueCount > 0) + { + queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + queueCreateInfo.pNext = DE_NULL; + queueCreateInfo.pQueuePriorities = &queuePriority; + queueCreateInfo.queueCount = 1; + queueCreateInfo.queueFamilyIndex = familyIdx; + + break; + } + } + + if (queueCreateInfo.queueCount == 0) + { + TCU_THROW(NotSupportedError, "No compatible queue family for this test case"); + } + + std::vector cstrDeviceExtensions; + + cstrDeviceExtensions.push_back("VK_AMD_buffer_marker"); + + if (hostPtr) + cstrDeviceExtensions.push_back("VK_EXT_external_memory_host"); + + const VkDeviceCreateInfo deviceInfo = + { + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkDeviceCreateFlags flags; + 1, // deUint32 queueCreateInfoCount; + &queueCreateInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos; + 0u, // deUint32 enabledLayerCount; + DE_NULL, // const char* const* ppEnabledLayerNames; + static_cast(cstrDeviceExtensions.size()), // deUint32 enabledExtensionCount; + dataOrNullPtr(cstrDeviceExtensions), // const char* const* ppEnabledExtensionNames; + &context.getDeviceFeatures(), // const VkPhysicalDeviceFeatures* pEnabledFeatures; + }; + + wd.logicalDevice = createDevice(vkp, instance, instanceDriver, physicalDevice, &deviceInfo); + wd.deviceDriver = MovePtr(new DeviceDriver(vkp, instance, *wd.logicalDevice)); + wd.allocator = MovePtr(new SimpleAllocator(*wd.deviceDriver, *wd.logicalDevice, getPhysicalDeviceMemoryProperties(instanceDriver, physicalDevice))); + wd.queueFamilyIdx = queueCreateInfo.queueFamilyIndex; + wd.queue = getDeviceQueue(*wd.deviceDriver, *wd.logicalDevice, wd.queueFamilyIdx, 0u); + wd.queueProps = queueFamilyProperties[queueCreateInfo.queueFamilyIndex]; +} + +bool checkMarkerBuffer (const DeviceInterface& vk, VkDevice device, const MovePtr& memory, size_t offset, + const std::vector& expected) +{ + invalidateMappedMemoryRange(vk, device, memory->getMemory(), memory->getOffset(), VK_WHOLE_SIZE); + + const deUint32* data = reinterpret_cast(static_cast(memory->getHostPtr()) + offset); + + for (size_t i = 0; i < expected.size(); ++i) + { + if (data[i] != expected[i]) + return false; + } + + return true; +} + +struct BaseTestParams +{ + VkQueueFlagBits testQueue; // Queue type that this test case targets + VkPipelineStageFlagBits stage; // Pipeline stage where any marker writes for this test case occur in + deUint32 size; // Number of buffer markers + bool useHostPtr; // Whether to use host pointer as backing buffer memory +}; + +deUint32 chooseExternalMarkerMemoryType(const DeviceInterface& vkd, + VkDevice device, + VkExternalMemoryHandleTypeFlagBits externalType, + deUint32 allowedBits, + MovePtr& hostMemory) +{ + VkMemoryHostPointerPropertiesEXT props = + { + vk::VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, + DE_NULL, + 0u, + }; + + if (vkd.getMemoryHostPointerPropertiesEXT(device, externalType, hostMemory->data, &props) == VK_SUCCESS) + { + allowedBits &= props.memoryTypeBits; + } + + deUint32 index = 0; + + while ((index < VK_MAX_MEMORY_TYPES) && ((allowedBits & 0x1) == 0)) + { + index++; + allowedBits >>= 1; + } + + return index; +} + +class ExternalHostAllocation : public Allocation +{ +public: + ExternalHostAllocation(Move mem, void* hostPtr) : Allocation(*mem, (VkDeviceSize)0, hostPtr), m_memHolder(mem) { } + +private: + const Unique m_memHolder; +}; + +void createMarkerBufferMemory(const InstanceInterface& vki, + const DeviceInterface& vkd, + VkPhysicalDevice physicalDevice, + VkDevice device, + VkBuffer buffer, + MovePtr& allocator, + const MemoryRequirement allocRequirement, + bool externalHostPtr, + MovePtr& hostMemory, + MovePtr& deviceMemory) +{ + VkMemoryRequirements memReqs = getBufferMemoryRequirements(vkd, device, buffer); + + if (externalHostPtr == false) + { + deviceMemory = allocator->allocate(memReqs, allocRequirement); + } + else + { + const VkExternalMemoryHandleTypeFlagBits externalType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT; + + const VkPhysicalDeviceExternalMemoryHostPropertiesEXT hostProps = getPhysicalDeviceExternalMemoryHostProperties(vki, physicalDevice); + + hostMemory = MovePtr(new ExternalHostMemory(memReqs.size, hostProps.minImportedHostPointerAlignment)); + + const deUint32 externalMemType = chooseExternalMarkerMemoryType(vkd, device, externalType, memReqs.memoryTypeBits, hostMemory); + + if (externalMemType == VK_MAX_MEMORY_TYPES) + { + TCU_FAIL("Failed to find compatible external host memory type for marker buffer"); + } + + const VkImportMemoryHostPointerInfoEXT importInfo = + { + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, + DE_NULL, + externalType, + hostMemory->data + }; + + const VkMemoryAllocateInfo info = + { + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + (const void*)&importInfo, + hostMemory->size, + externalMemType + }; + + deviceMemory = MovePtr(new ExternalHostAllocation(allocateMemory(vkd, device, &info), hostMemory->data)); + } + + VK_CHECK(vkd.bindBufferMemory(device, buffer, deviceMemory->getMemory(), deviceMemory->getOffset())); +} + +tcu::TestStatus bufferMarkerSequential(Context& context, BaseTestParams params) +{ + WorkingDevice wd; + + createDeviceWithExtension(context, wd, params.testQueue, params.useHostPtr); + + const DeviceInterface& vk(*wd.deviceDriver); + const VkDevice device(*wd.logicalDevice); + const VkDeviceSize markerBufferSize(params.size * sizeof(deUint32)); + Move markerBuffer(makeBuffer(vk, device, markerBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT)); + MovePtr hostMemory; + MovePtr markerMemory; + + createMarkerBufferMemory(context.getInstanceInterface(), vk, context.getPhysicalDevice(), device, + *markerBuffer, wd.allocator, MemoryRequirement::HostVisible, params.useHostPtr, hostMemory, markerMemory); + + de::Random rng(12345 ^ params.size); + std::vector expected(params.size); + + for (size_t i = 0; i < params.size; ++i) + expected[i] = rng.getUint32(); + + deMemcpy(markerMemory->getHostPtr(), &expected[0], static_cast(markerBufferSize)); + flushMappedMemoryRange(vk, device, markerMemory->getMemory(), markerMemory->getOffset(), VK_WHOLE_SIZE); + + const Unique cmdPool(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, wd.queueFamilyIdx)); + const Unique cmdBuffer(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); + + beginCommandBuffer(vk, *cmdBuffer); + + for (size_t i = 0; i < params.size; ++i) + { + vk.cmdWriteBufferMarkerAMD(*cmdBuffer, params.stage, *markerBuffer, static_cast(sizeof(deUint32) * i), expected[i]); + } + + const VkMemoryBarrier memoryDep = + { + VK_STRUCTURE_TYPE_MEMORY_BARRIER, + DE_NULL, + VK_ACCESS_TRANSFER_WRITE_BIT, + VK_ACCESS_HOST_READ_BIT, + }; + + vk.cmdPipelineBarrier(*cmdBuffer, params.stage, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &memoryDep, 0, DE_NULL, 0, DE_NULL); + + VK_CHECK(vk.endCommandBuffer(*cmdBuffer)); + + submitCommandsAndWait(vk, device, wd.queue, *cmdBuffer); + + if (!checkMarkerBuffer(vk, device, markerMemory, 0, expected)) + return tcu::TestStatus::fail("Some marker values were incorrect"); + + return tcu::TestStatus::pass("Pass"); +} + +tcu::TestStatus bufferMarkerOverwrite(Context& context, BaseTestParams params) +{ + WorkingDevice wd; + + createDeviceWithExtension(context, wd, params.testQueue, params.useHostPtr); + + const DeviceInterface& vk(*wd.deviceDriver); + const VkDevice device(*wd.logicalDevice); + const VkDeviceSize markerBufferSize(params.size * sizeof(deUint32)); + Move markerBuffer(makeBuffer(vk, device, markerBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT)); + MovePtr hostMemory; + MovePtr markerMemory; + + createMarkerBufferMemory(context.getInstanceInterface(), vk, context.getPhysicalDevice(), device, + *markerBuffer, wd.allocator, MemoryRequirement::HostVisible, params.useHostPtr, hostMemory, markerMemory); + + de::Random rng(12345 ^ params.size); + std::vector expected(params.size); + + for (size_t i = 0; i < params.size; ++i) + expected[i] = 0; + + deMemcpy(markerMemory->getHostPtr(), &expected[0], static_cast(markerBufferSize)); + flushMappedMemoryRange(vk, device, markerMemory->getMemory(), markerMemory->getOffset(), VK_WHOLE_SIZE); + + const Unique cmdPool(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, wd.queueFamilyIdx)); + const Unique cmdBuffer(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); + + beginCommandBuffer(vk, *cmdBuffer); + + for (deUint32 i = 0; i < params.size * 10; ++i) + { + const deUint32 slot = rng.getUint32() % static_cast(params.size); + const deUint32 value = i; + + expected[slot] = value; + + vk.cmdWriteBufferMarkerAMD(*cmdBuffer, params.stage, *markerBuffer, static_cast(sizeof(deUint32) * slot), expected[slot]); + } + + const VkMemoryBarrier memoryDep = { + VK_STRUCTURE_TYPE_MEMORY_BARRIER, + DE_NULL, + VK_ACCESS_TRANSFER_WRITE_BIT, + VK_ACCESS_HOST_READ_BIT, + }; + + vk.cmdPipelineBarrier(*cmdBuffer, params.stage, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &memoryDep, 0, DE_NULL, 0, DE_NULL); + + VK_CHECK(vk.endCommandBuffer(*cmdBuffer)); + + submitCommandsAndWait(vk, device, wd.queue, *cmdBuffer); + + if (!checkMarkerBuffer(vk, device, markerMemory, 0, expected)) + return tcu::TestStatus::fail("Some marker values were incorrect"); + + return tcu::TestStatus::pass("Pass"); +} + +enum MemoryDepMethod +{ + MEMORY_DEP_DRAW, + MEMORY_DEP_DISPATCH, + MEMORY_DEP_COPY +}; + +struct MemoryDepParams +{ + BaseTestParams base; + MemoryDepMethod method; +}; + +enum MemoryDepOwner +{ + MEMORY_DEP_OWNER_NOBODY = 0, + MEMORY_DEP_OWNER_MARKER = 1, + MEMORY_DEP_OWNER_NON_MARKER = 2 +}; + +void computeMemoryDepBarrier(MemoryDepMethod method, + MemoryDepOwner owner, + VkPipelineStageFlagBits markerStage, + VkAccessFlags* memoryDepAccess, + VkPipelineStageFlags* executionScope) +{ + DE_ASSERT(owner != MEMORY_DEP_OWNER_NOBODY); + + if (owner == MEMORY_DEP_OWNER_MARKER) + { + *memoryDepAccess = VK_ACCESS_TRANSFER_WRITE_BIT; + *executionScope = markerStage; + } + else + { + if (method == MEMORY_DEP_COPY) + { + *memoryDepAccess = VK_ACCESS_TRANSFER_WRITE_BIT; + *executionScope = VK_PIPELINE_STAGE_TRANSFER_BIT; + } + else if (method == MEMORY_DEP_DISPATCH) + { + *memoryDepAccess = VK_ACCESS_SHADER_WRITE_BIT; + *executionScope = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; + } + else + { + *memoryDepAccess = VK_ACCESS_SHADER_WRITE_BIT; + *executionScope = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + } + } +} + +// Randomly do buffer marker writes and other operations (draws, dispatches) that shader-write to a shared buffer. Insert pipeline barriers +// when necessary and make sure that the synchronization between marker writes and non-marker writes are correctly handled by the barriers. +tcu::TestStatus bufferMarkerMemoryDep(Context& context, MemoryDepParams params) +{ + WorkingDevice wd; + + createDeviceWithExtension(context, wd, params.base.testQueue, params.base.useHostPtr); + + VkBufferUsageFlags usageFlags = VK_BUFFER_USAGE_TRANSFER_DST_BIT; + + if ((params.method == MEMORY_DEP_DRAW) || (params.method == MEMORY_DEP_DISPATCH)) + usageFlags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; + else + usageFlags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; + + const deUint32 numIters(1000); + const DeviceInterface& vk(*wd.deviceDriver); + const VkDevice device(*wd.logicalDevice); + const deUint32 size(params.base.size); + const VkDeviceSize markerBufferSize(params.base.size * sizeof(deUint32)); + Move markerBuffer(makeBuffer(vk, device, params.base.size * sizeof(deUint32), usageFlags)); + MovePtr hostMemory; + MovePtr markerMemory; + + createMarkerBufferMemory(context.getInstanceInterface(), vk, context.getPhysicalDevice(), device, + *markerBuffer, wd.allocator, MemoryRequirement::HostVisible, params.base.useHostPtr, hostMemory, markerMemory); + + de::Random rng(size ^ params.base.size); + std::vector expected(params.base.size, 0); + + Move descriptorPool; + Move descriptorSetLayout; + Move descriptorSet; + Move pipelineLayout; + VkShaderStageFlags pushConstantStage = 0; + + if ((params.method == MEMORY_DEP_DRAW) || (params.method == MEMORY_DEP_DISPATCH)) + { + DescriptorPoolBuilder descriptorPoolBuilder; + + descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u); + descriptorPool = descriptorPoolBuilder.build(vk, device, 0, 1u); + + DescriptorSetLayoutBuilder setLayoutBuilder; + + setLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_ALL); + descriptorSetLayout = setLayoutBuilder.build(vk, device); + + const VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = + { + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + *descriptorPool, // VkDescriptorPool descriptorPool; + 1u, // deUint32 setLayoutCount; + &descriptorSetLayout.get() // const VkDescriptorSetLayout* pSetLayouts; + }; + + descriptorSet = allocateDescriptorSet(vk, device, &descriptorSetAllocateInfo); + + VkDescriptorBufferInfo markerBufferInfo = { *markerBuffer, 0, VK_WHOLE_SIZE }; + + VkWriteDescriptorSet writeSet[] = + { + { + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // VkStructureType sType; + DE_NULL, // const void* pNext; + descriptorSet.get(), // VkDescriptorSet dstSet; + 0, // uint32_t dstBinding; + 0, // uint32_t dstArrayElement; + 1, // uint32_t descriptorCount; + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // VkDescriptorType descriptorType; + DE_NULL, // const VkDescriptorImageInfo* pImageInfo; + &markerBufferInfo, // const VkDescriptorBufferInfo* pBufferInfo; + DE_NULL // const VkBufferView* pTexelBufferViev + } + }; + + vk.updateDescriptorSets(device, DE_LENGTH_OF_ARRAY(writeSet), writeSet, 0, DE_NULL); + + VkDescriptorSetLayout setLayout = descriptorSetLayout.get(); + + pushConstantStage = (params.method == MEMORY_DEP_DISPATCH ? VK_SHADER_STAGE_COMPUTE_BIT : VK_SHADER_STAGE_FRAGMENT_BIT); + + const VkPushConstantRange pushConstantRange = + { + pushConstantStage, // VkShaderStageFlags stageFlags; + 0u, // uint32_t offset; + 2*sizeof(deUint32), // uint32_t size; + }; + + const VkPipelineLayoutCreateInfo pipelineLayoutInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags; + 1u, // deUint32 setLayoutCount; + &setLayout, // const VkDescriptorSetLayout* pSetLayouts; + 1u, // deUint32 pushConstantRangeCount; + &pushConstantRange, // const VkPushConstantRange* pPushConstantRanges; + }; + + pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutInfo); + } + + Move renderPass; + Move fbo; + Move pipeline; + Move vertexModule; + Move fragmentModule; + Move computeModule; + + if (params.method == MEMORY_DEP_DRAW) + { + const VkSubpassDescription subpassInfo = + { + 0, // VkSubpassDescriptionFlags flags; + VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; + 0, // uint32_t inputAttachmentCount; + DE_NULL, // const VkAttachmentReference* pInputAttachments; + 0, // uint32_t colorAttachmentCount; + DE_NULL, // const VkAttachmentReference* pColorAttachments; + 0, // const VkAttachmentReference* pResolveAttachments; + DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment; + 0, // uint32_t preserveAttachmentCount; + DE_NULL // const uint32_t* pPreserveAttachments; + }; + + const VkRenderPassCreateInfo renderPassInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0, // VkRenderPassCreateFlags flags; + 0, // uint32_t attachmentCount; + DE_NULL, // const VkAttachmentDescription* pAttachments; + 1, // uint32_t subpassCount; + &subpassInfo, // const VkSubpassDescription* pSubpasses; + 0, // uint32_t dependencyCount; + DE_NULL // const VkSubpassDependency* pDependencies + }; + + renderPass = createRenderPass(vk, device, &renderPassInfo); + + const VkFramebufferCreateInfo framebufferInfo = + { + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0, // VkFramebufferCreateFlags flags; + renderPass.get(), // VkRenderPass renderPass; + 0, // uint32_t attachmentCount; + DE_NULL, // const VkImageView* pAttachments; + 1, // uint32_t width; + 1, // uint32_t height; + 1, // uint32_t layers; + }; + + fbo = createFramebuffer(vk, device, &framebufferInfo); + + vertexModule = createShaderModule(vk, device, context.getBinaryCollection().get("vert"), 0u); + fragmentModule = createShaderModule(vk, device, context.getBinaryCollection().get("frag"), 0u); + + const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags; + 0, // uint32_t vertexBindingDescriptionCount; + DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions; + 0, // uint32_t vertexAttributeDescriptionCount; + DE_NULL, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; + }; + + const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags; + VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // VkPrimitiveTopology topology; + VK_FALSE, // VkBool32 primitiveRestartEnable; + }; + + std::vector shaderStages; + + { + const VkPipelineShaderStageCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; + VK_SHADER_STAGE_VERTEX_BIT, // VkShaderStageFlagBits stage; + vertexModule.get(), // VkShaderModule module; + "main", // const char* pName; + DE_NULL, // const VkSpecializationInfo* pSpecializationInfo; + }; + + shaderStages.push_back(createInfo); + } + + { + const VkPipelineShaderStageCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; + VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlagBits stage; + fragmentModule.get(), // VkShaderModule module; + "main", // const char* pName; + DE_NULL, // const VkSpecializationInfo* pSpecializationInfo; + }; + + shaderStages.push_back(createInfo); + } + + VkViewport viewport = {}; + + viewport.x = 0; + viewport.y = 0; + viewport.width = 1; + viewport.height = 1; + viewport.minDepth = 0.0f; + viewport.maxDepth = 1.0f; + + VkRect2D scissor = {}; + + scissor.offset.x = 0; + scissor.offset.y = 0; + scissor.extent.width = 1; + scissor.extent.height = 1; + + const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags; + 1u, // uint32_t viewportCount; + &viewport, // const VkViewport* pViewports; + 1u, // uint32_t scissorCount; + &scissor, // const VkRect2D* pScissors; + }; + + const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags; + VK_FALSE, // VkBool32 depthClampEnable; + VK_FALSE, // VkBool32 rasterizerDiscardEnable; + VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode; + VK_CULL_MODE_NONE, // VkCullModeFlags cullMode; + VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace; + VK_FALSE, // VkBool32 depthBiasEnable; + 0.0f, // float depthBiasConstantFactor; + 0.0f, // float depthBiasClamp; + 0.0f, // float depthBiasSlopeFactor; + 1.0f, // float lineWidth; + }; + + const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo = + { + + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags; + VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples; + VK_FALSE, // VkBool32 sampleShadingEnable; + 1.0f, // float minSampleShading; + DE_NULL, // const VkSampleMask* pSampleMask; + VK_FALSE, // VkBool32 alphaToCoverageEnable; + VK_FALSE, // VkBool32 alphaToOneEnable; + }; + + const VkStencilOpState noStencilOp = {}; + + VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags; + VK_FALSE, // VkBool32 depthTestEnable; + VK_FALSE, // VkBool32 depthWriteEnable; + VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp; + VK_FALSE, // VkBool32 depthBoundsTestEnable; + VK_FALSE, // VkBool32 stencilTestEnable; + noStencilOp, // VkStencilOpState front; + noStencilOp, // VkStencilOpState back; + 0.0f, // float minDepthBounds; + 1.0f, // float maxDepthBounds; + }; + + const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags; + VK_FALSE, // VkBool32 logicOpEnable; + VK_LOGIC_OP_COPY, // VkLogicOp logicOp; + 0, // deUint32 attachmentCount; + DE_NULL, // const VkPipelineColorBlendAttachmentState* pAttachments; + { 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConstants[4]; + }; + + const VkGraphicsPipelineCreateInfo graphicsPipelineInfo = + { + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags; + static_cast(shaderStages.size()), // deUint32 stageCount; + dataOrNullPtr(shaderStages), // const VkPipelineShaderStageCreateInfo* pStages; + &vertexInputStateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + &pipelineInputAssemblyStateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState; + &pipelineViewportStateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState; + &pipelineRasterizationStateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + &pipelineMultisampleStateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + &pipelineDepthStencilStateInfo, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + &pipelineColorBlendStateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState; + pipelineLayout.get(), // VkPipelineLayout layout; + renderPass.get(), // VkRenderPass renderPass; + 0, // deUint32 subpass; + DE_NULL, // VkPipeline basePipelineHandle; + -1, // deInt32 basePipelineIndex; + }; + + pipeline = createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo); + } + else if (params.method == MEMORY_DEP_DISPATCH) + { + computeModule = createShaderModule(vk, device, context.getBinaryCollection().get("comp"), 0u); + + const VkPipelineShaderStageCreateInfo shaderStageInfo = + { + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + (VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags; + VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlagBits stage; + computeModule.get(), // VkShaderModule module; + "main", // const char* pName; + DE_NULL // const VkSpecializationInfo* pSpecializationInfo; + }; + + const VkComputePipelineCreateInfo computePipelineInfo = + { + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0u, // VkPipelineCreateFlags flags; + shaderStageInfo, // VkPipelineShaderStageCreateInfo stage; + pipelineLayout.get(), // VkPipelineLayout layout; + DE_NULL, // VkPipeline basePipelineHandle; + 0 // int32_t basePipelineIndex; + }; + + pipeline = createComputePipeline(vk, device, DE_NULL, &computePipelineInfo); + } + + deMemcpy(markerMemory->getHostPtr(), &expected[0], static_cast(markerBufferSize)); + flushMappedMemoryRange(vk, device, markerMemory->getMemory(), markerMemory->getOffset(), VK_WHOLE_SIZE); + + const Unique cmdPool(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, wd.queueFamilyIdx)); + const Unique cmdBuffer(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); + + beginCommandBuffer(vk, *cmdBuffer); + + VkDescriptorSet setHandle = *descriptorSet; + + std::vector dataOwner(size, MEMORY_DEP_OWNER_NOBODY); + + if (params.method == MEMORY_DEP_DRAW) + { + const VkRenderPassBeginInfo beginInfo = + { + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType; + DE_NULL, // const void* pNext; + renderPass.get(), // VkRenderPass renderPass; + fbo.get(), // VkFramebuffer framebuffer; + { { 0, 0, }, { 1, 1 } }, // VkRect2D renderArea; + 0, // uint32_t clearValueCount; + DE_NULL // const VkClearValue* pClearValues; + }; + + vk.cmdBeginRenderPass(*cmdBuffer, &beginInfo, VK_SUBPASS_CONTENTS_INLINE); + vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline); + vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0, 1, &setHandle, 0, DE_NULL); + } + else if (params.method == MEMORY_DEP_DISPATCH) + { + vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline); + vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0, 1, &setHandle, 0, DE_NULL); + } + + deMemcpy(markerMemory->getHostPtr(), &expected[0], static_cast(markerBufferSize)); + flushMappedMemoryRange(vk, device, markerMemory->getMemory(), markerMemory->getOffset(), VK_WHOLE_SIZE); + + deUint32 writeStages = 0; + deUint32 writeAccess = 0; + + for (deUint32 i = 0; i < numIters; ++i) + { + deUint32 slot = rng.getUint32() % size; + MemoryDepOwner oldOwner = dataOwner[slot]; + MemoryDepOwner newOwner = static_cast(1 + (rng.getUint32() % 2)); + + DE_ASSERT(newOwner == MEMORY_DEP_OWNER_MARKER || newOwner == MEMORY_DEP_OWNER_NON_MARKER); + DE_ASSERT(slot < size); + + if ((oldOwner != newOwner && oldOwner != MEMORY_DEP_OWNER_NOBODY) || + (oldOwner == MEMORY_DEP_OWNER_NON_MARKER && newOwner == MEMORY_DEP_OWNER_NON_MARKER)) + { + VkBufferMemoryBarrier memoryDep = + { + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType; + DE_NULL, // const void* pNext; + 0, // VkAccessFlags srcAccessMask; + 0, // VkAccessFlags dstAccessMask; + wd.queueFamilyIdx, // uint32_t srcQueueFamilyIndex; + wd.queueFamilyIdx, // uint32_t dstQueueFamilyIndex; + *markerBuffer, // VkBuffer buffer; + sizeof(deUint32) * slot, // VkDeviceSize offset; + sizeof(deUint32) // VkDeviceSize size; + }; + + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + + computeMemoryDepBarrier(params.method, oldOwner, params.base.stage, &memoryDep.srcAccessMask, &srcStageMask); + computeMemoryDepBarrier(params.method, newOwner, params.base.stage, &memoryDep.dstAccessMask, &dstStageMask); + + vk.cmdPipelineBarrier(*cmdBuffer, srcStageMask, dstStageMask, 0, 0, DE_NULL, 1, &memoryDep, 0, DE_NULL); + } + + const deUint32 value = i; + + if (newOwner == MEMORY_DEP_OWNER_MARKER) + { + vk.cmdWriteBufferMarkerAMD(*cmdBuffer, params.base.stage, *markerBuffer, sizeof(deUint32) * slot, value); + + writeStages |= params.base.stage; + writeAccess |= VK_ACCESS_TRANSFER_WRITE_BIT; + } + else + { + DE_ASSERT(newOwner == MEMORY_DEP_OWNER_NON_MARKER); + + if (params.method == MEMORY_DEP_COPY) + { + vk.cmdUpdateBuffer(*cmdBuffer, *markerBuffer, sizeof(deUint32) * slot, sizeof(deUint32), &value); + + writeStages |= VK_PIPELINE_STAGE_TRANSFER_BIT; + writeAccess |= VK_ACCESS_TRANSFER_WRITE_BIT; + } + else if (params.method == MEMORY_DEP_DRAW) + { + const deUint32 pushConst[] = { slot, value }; + + vk.cmdPushConstants(*cmdBuffer, *pipelineLayout, pushConstantStage, 0, sizeof(pushConst), pushConst); + vk.cmdDraw(*cmdBuffer, 1, 1, i, 0); + + writeStages |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + writeAccess |= VK_ACCESS_SHADER_WRITE_BIT; + } + else + { + const deUint32 pushConst[] = { slot, value }; + + vk.cmdPushConstants(*cmdBuffer, *pipelineLayout, pushConstantStage, 0, sizeof(pushConst), pushConst); + vk.cmdDispatch(*cmdBuffer, 1, 1, 1); + + writeStages |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; + writeAccess |= VK_ACCESS_SHADER_WRITE_BIT; + } + } + + dataOwner[slot] = newOwner; + expected[slot] = value; + } + + if (params.method == MEMORY_DEP_DRAW) + { + vk.cmdEndRenderPass(*cmdBuffer); + } + + const VkMemoryBarrier memoryDep = + { + VK_STRUCTURE_TYPE_MEMORY_BARRIER, + DE_NULL, + writeAccess, + VK_ACCESS_HOST_READ_BIT, + }; + + vk.cmdPipelineBarrier(*cmdBuffer, writeStages, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &memoryDep, 0, DE_NULL, 0, DE_NULL); + + VK_CHECK(vk.endCommandBuffer(*cmdBuffer)); + + submitCommandsAndWait(vk, device, wd.queue, *cmdBuffer); + + if (!checkMarkerBuffer(vk, device, markerMemory, 0, expected)) + return tcu::TestStatus::fail("Some marker values were incorrect"); + + return tcu::TestStatus::pass("Pass"); +} + +void initMemoryDepPrograms(SourceCollections& programCollection, const MemoryDepParams params) +{ + if (params.method == MEMORY_DEP_DRAW) + { + { + std::ostringstream src; + + src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" + << "layout(location = 0) flat out uint offset;\n" + << "out gl_PerVertex { vec4 gl_Position; };\n" + << "void main() {\n" + << " offset = gl_VertexIndex;\n" + << " gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n" + << "}\n"; + + programCollection.glslSources.add("vert") << glu::VertexSource(src.str()); + } + + { + std::ostringstream src; + + src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" + << "layout(push_constant) uniform Constants { uvec2 params; } pc;\n" + << "layout(std430, set = 0, binding = 0) buffer Data { uint elems[]; } data;\n" + << "layout(location = 0) flat in uint offset;\n" + << "void main() {\n" + << " data.elems[pc.params.x] = pc.params.y;\n" + << "}\n"; + + programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); + } + } + else if (params.method == MEMORY_DEP_DISPATCH) + { + { + std::ostringstream src; + + src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n" + << "layout(local_size_x = 1u, local_size_y = 1u, local_size_z = 1u) in;\n" + << "layout(push_constant) uniform Constants { uvec2 params; } pc;\n" + << "layout(std430, set = 0, binding = 0) buffer Data { uint elems[]; } data;\n" + << "void main() {\n" + << " data.elems[pc.params.x] = pc.params.y;\n" + << "}\n"; + + programCollection.glslSources.add("comp") << glu::ComputeSource(src.str()); + } + } +} + +void checkBufferMarkerSupport (Context& context, BaseTestParams params) +{ + if (params.useHostPtr) + context.requireDeviceFunctionality("VK_EXT_external_memory_host"); + + context.requireDeviceFunctionality("VK_AMD_buffer_marker"); +} + +void checkBufferMarkerSupport (Context& context, MemoryDepParams params) +{ + if (params.base.useHostPtr) + context.requireDeviceFunctionality("VK_EXT_external_memory_host"); + + context.requireDeviceFunctionality("VK_AMD_buffer_marker"); +} + +tcu::TestCaseGroup* createBufferMarkerTestsInGroup(tcu::TestContext& testCtx) +{ + tcu::TestCaseGroup* root = (new tcu::TestCaseGroup(testCtx, "buffer_marker", "AMD_buffer_marker Tests")); + + VkQueueFlagBits queues[] = { VK_QUEUE_GRAPHICS_BIT, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT }; + const char* queueNames[] = { "graphics", "compute", "transfer" }; + + BaseTestParams base = {}; + + for (size_t queueNdx = 0; queueNdx < DE_LENGTH_OF_ARRAY(queues); ++queueNdx) + { + tcu::TestCaseGroup* queueGroup = (new tcu::TestCaseGroup(testCtx, queueNames[queueNdx], "Buffer marker tests for a specific queue family")); + + const char* memoryNames[] = { "external_host_mem", "default_mem" }; + const bool memoryTypes[] = { true, false }; + + base.testQueue = queues[queueNdx]; + + for (size_t memNdx = 0; memNdx < DE_LENGTH_OF_ARRAY(memoryTypes); ++memNdx) + { + tcu::TestCaseGroup* memoryGroup = (new tcu::TestCaseGroup(testCtx, memoryNames[memNdx], "Buffer marker tests for different kinds of backing memory")); + + base.useHostPtr = memoryTypes[memNdx]; + + VkPipelineStageFlagBits stages[] = { VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT }; + const char* stageNames[] = { "top_of_pipe", "bottom_of_pipe" }; + + for (size_t stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(stages); ++stageNdx) + { + tcu::TestCaseGroup* stageGroup = (new tcu::TestCaseGroup(testCtx, stageNames[stageNdx], "Buffer marker tests for a specific pipeline stage")); + + base.stage = stages[stageNdx]; + + { + tcu::TestCaseGroup* sequentialGroup = (new tcu::TestCaseGroup(testCtx, "sequential", "Buffer marker tests for sequentially writing")); + + base.size = 4; + + addFunctionCase(sequentialGroup, "4", "Writes 4 sequential marker values into a buffer", checkBufferMarkerSupport, bufferMarkerSequential, base); + + base.size = 64; + + addFunctionCase(sequentialGroup, "64", "Writes 64 sequential marker values into a buffer", checkBufferMarkerSupport, bufferMarkerSequential, base); + + base.size = 65536; + + addFunctionCase(sequentialGroup, "65536", "Writes 65536 sequential marker values into a buffer", checkBufferMarkerSupport, bufferMarkerSequential, base); + + stageGroup->addChild(sequentialGroup); + } + + { + tcu::TestCaseGroup* overwriteGroup = (new tcu::TestCaseGroup(testCtx, "overwrite", "Buffer marker tests for overwriting values with implicit synchronization")); + + base.size = 1; + + addFunctionCase(overwriteGroup, "1", "Randomly overwrites marker values to a 1-size buffer", checkBufferMarkerSupport, bufferMarkerOverwrite, base); + + base.size = 4; + + addFunctionCase(overwriteGroup, "4", "Randomly overwrites marker values to a 4-size buffer", checkBufferMarkerSupport, bufferMarkerOverwrite, base); + + base.size = 64; + + addFunctionCase(overwriteGroup, "64", "Randomly overwrites markers values to a 64-size buffer", checkBufferMarkerSupport, bufferMarkerOverwrite, base); + + stageGroup->addChild(overwriteGroup); + } + + { + tcu::TestCaseGroup* memoryDepGroup = (new tcu::TestCaseGroup(testCtx, "memory_dep", "Buffer marker tests for memory dependencies between marker writes and other operations")); + + MemoryDepParams params = {}; + + params.base = base; + params.base.size = 128; + + if (params.base.testQueue == VK_QUEUE_GRAPHICS_BIT) + { + params.method = MEMORY_DEP_DRAW; + + addFunctionCaseWithPrograms(memoryDepGroup, "draw", "Test memory dependencies between marker writes and draws", checkBufferMarkerSupport, initMemoryDepPrograms, bufferMarkerMemoryDep, params); + } + + if (params.base.testQueue != VK_QUEUE_TRANSFER_BIT) + { + params.method = MEMORY_DEP_DISPATCH; + + addFunctionCaseWithPrograms(memoryDepGroup, "dispatch", "Test memory dependencies between marker writes and compute dispatches", checkBufferMarkerSupport, initMemoryDepPrograms, bufferMarkerMemoryDep, params); + } + + params.method = MEMORY_DEP_COPY; + + addFunctionCaseWithPrograms(memoryDepGroup, "buffer_copy", "Test memory dependencies between marker writes and buffer copies", checkBufferMarkerSupport, initMemoryDepPrograms, bufferMarkerMemoryDep, params); + + stageGroup->addChild(memoryDepGroup); + } + + memoryGroup->addChild(stageGroup); + } + + queueGroup->addChild(memoryGroup); + } + + root->addChild(queueGroup); + } + + return root; +} + +} // anonymous ns + +tcu::TestCaseGroup* createBufferMarkerTests (tcu::TestContext& testCtx) +{ + return createBufferMarkerTestsInGroup(testCtx); +} + +} // api +} // vkt diff --git a/external/vulkancts/modules/vulkan/api/vktApiBufferMarkerTests.hpp b/external/vulkancts/modules/vulkan/api/vktApiBufferMarkerTests.hpp new file mode 100644 index 0000000..da60329 --- /dev/null +++ b/external/vulkancts/modules/vulkan/api/vktApiBufferMarkerTests.hpp @@ -0,0 +1,39 @@ +#ifndef _VKTAPIBUFFERMARKERTESTS_HPP +#define _VKTAPIBUFFERMARKERTESTS_HPP +/*------------------------------------------------------------------------ + * Vulkan Conformance Tests + * ------------------------ + * + * Copyright (c) 2019 Advanced Micro Devices, Inc. + * Copyright (c) 2019 The Khronos Group Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + *//*! + * \file + * \brief Tests for VK_AMD_buffer_marker + *//*--------------------------------------------------------------------*/ + +#include "vktTestCase.hpp" + +namespace vkt +{ +namespace api +{ + +extern tcu::TestCaseGroup* createBufferMarkerTests (tcu::TestContext& testCtx); + +} // api +} // vkt + +#endif // _VKTAPIBUFFERMARKERTESTS_HPP diff --git a/external/vulkancts/modules/vulkan/api/vktApiTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiTests.cpp index c307ead..e19a14d 100644 --- a/external/vulkancts/modules/vulkan/api/vktApiTests.cpp +++ b/external/vulkancts/modules/vulkan/api/vktApiTests.cpp @@ -28,6 +28,7 @@ #include "vktApiDeviceInitializationTests.hpp" #include "vktApiDriverPropertiesTests.hpp" #include "vktApiObjectManagementTests.hpp" +#include "vktApiBufferMarkerTests.hpp" #include "vktApiBufferTests.hpp" #include "vktApiBufferViewCreateTests.hpp" #include "vktApiBufferViewAccessTests.hpp" @@ -74,6 +75,7 @@ void createApiTests (tcu::TestCaseGroup* apiTests) apiTests->addChild(createDeviceInitializationTests (testCtx)); apiTests->addChild(createObjectManagementTests (testCtx)); apiTests->addChild(createBufferTests (testCtx)); + apiTests->addChild(createBufferMarkerTests (testCtx)); apiTests->addChild(createTestGroup (testCtx, "buffer_view", "BufferView tests", createBufferViewTests)); apiTests->addChild(createCommandBuffersTests (testCtx)); apiTests->addChild(createCopiesAndBlittingTests (testCtx)); diff --git a/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.cpp b/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.cpp index c9f2a46..d6b990e 100644 --- a/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.cpp +++ b/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.cpp @@ -73,6 +73,7 @@ NativeHandle::NativeHandle (void) , m_win32HandleType (WIN32HANDLETYPE_LAST) , m_win32Handle (DE_NULL) , m_androidHardwareBuffer (DE_NULL) + , m_hostPtr (DE_NULL) { } @@ -81,6 +82,7 @@ NativeHandle::NativeHandle (const NativeHandle& other) , m_win32HandleType (WIN32HANDLETYPE_LAST) , m_win32Handle (DE_NULL) , m_androidHardwareBuffer (DE_NULL) + , m_hostPtr (DE_NULL) { if (other.m_fd >= 0) { @@ -140,6 +142,7 @@ NativeHandle::NativeHandle (int fd) , m_win32HandleType (WIN32HANDLETYPE_LAST) , m_win32Handle (DE_NULL) , m_androidHardwareBuffer (DE_NULL) + , m_hostPtr (DE_NULL) { } @@ -148,6 +151,7 @@ NativeHandle::NativeHandle (Win32HandleType handleType, vk::pt::Win32Handle hand , m_win32HandleType (handleType) , m_win32Handle (handle) , m_androidHardwareBuffer (DE_NULL) + , m_hostPtr (DE_NULL) { } @@ -156,6 +160,7 @@ NativeHandle::NativeHandle (vk::pt::AndroidHardwareBufferPtr buffer) , m_win32HandleType (WIN32HANDLETYPE_LAST) , m_win32Handle (DE_NULL) , m_androidHardwareBuffer (buffer) + , m_hostPtr (DE_NULL) { } @@ -208,6 +213,7 @@ void NativeHandle::reset (void) m_win32Handle = vk::pt::Win32Handle(DE_NULL); m_win32HandleType = WIN32HANDLETYPE_LAST; m_androidHardwareBuffer = vk::pt::AndroidHardwareBufferPtr(DE_NULL); + m_hostPtr = DE_NULL; } NativeHandle& NativeHandle::operator= (int fd) @@ -236,17 +242,27 @@ void NativeHandle::setWin32Handle (Win32HandleType type, vk::pt::Win32Handle han m_win32Handle = handle; } +void NativeHandle::setHostPtr(void* hostPtr) +{ + reset(); + + m_hostPtr = hostPtr; +} + void NativeHandle::disown (void) { m_fd = -1; m_win32Handle = vk::pt::Win32Handle(DE_NULL); m_androidHardwareBuffer = vk::pt::AndroidHardwareBufferPtr(DE_NULL); + m_hostPtr = DE_NULL; } vk::pt::Win32Handle NativeHandle::getWin32Handle (void) const { DE_ASSERT(m_fd == -1); DE_ASSERT(!m_androidHardwareBuffer.internal); + DE_ASSERT(m_hostPtr == DE_NULL); + return m_win32Handle; } @@ -254,17 +270,25 @@ int NativeHandle::getFd (void) const { DE_ASSERT(!m_win32Handle.internal); DE_ASSERT(!m_androidHardwareBuffer.internal); + DE_ASSERT(m_hostPtr == DE_NULL); return m_fd; } - vk::pt::AndroidHardwareBufferPtr NativeHandle::getAndroidHardwareBuffer (void) const { DE_ASSERT(m_fd == -1); DE_ASSERT(!m_win32Handle.internal); + DE_ASSERT(m_hostPtr == DE_NULL); return m_androidHardwareBuffer; } +void* NativeHandle::getHostPtr(void) const +{ + DE_ASSERT(m_fd == -1); + DE_ASSERT(!m_win32Handle.internal); + return m_hostPtr; +} + const char* externalSemaphoreTypeToName (vk::VkExternalSemaphoreHandleTypeFlagBits type) { switch (type) @@ -343,6 +367,9 @@ const char* externalMemoryTypeToName (vk::VkExternalMemoryHandleTypeFlagBits typ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: return "dma_buf"; + case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: + return "host_allocation"; + default: DE_FATAL("Unknown external memory type"); return DE_NULL; @@ -1134,6 +1161,35 @@ static vk::Move importMemory (const vk::DeviceInterface& return memory; } + else if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT) + { + DE_ASSERT(memoryTypeIndex != ~0U); + + const vk::VkImportMemoryHostPointerInfoEXT importInfo = + { + vk::VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, + DE_NULL, + externalType, + handle.getHostPtr() + }; + const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo = + { + vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + &importInfo, + image, + buffer, + }; + const vk::VkMemoryAllocateInfo info = + { + vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + (isDedicated ? (const void*)&dedicatedInfo : (const void*)&importInfo), + requirements.size, + memoryTypeIndex + }; + vk::Move memory (vk::allocateMemory(vkd, device, &info)); + + return memory; + } else { DE_FATAL("Unknown external memory type"); @@ -1563,5 +1619,27 @@ AndroidHardwareBufferExternalApi* AndroidHardwareBufferExternalApi::getInstance( return DE_NULL; } +vk::VkPhysicalDeviceExternalMemoryHostPropertiesEXT getPhysicalDeviceExternalMemoryHostProperties(const vk::InstanceInterface& vki, + vk::VkPhysicalDevice physicalDevice) +{ + vk::VkPhysicalDeviceExternalMemoryHostPropertiesEXT externalProps = + { + vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, + DE_NULL, + 0u, + }; + + vk::VkPhysicalDeviceProperties2 props2 = + { + vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + &externalProps, + {} + }; + + vki.getPhysicalDeviceProperties2(physicalDevice, &props2); + + return externalProps; +} + } // ExternalMemoryUtil } // vkt diff --git a/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.hpp b/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.hpp index 3dc9be5..2b2dd73 100644 --- a/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.hpp +++ b/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.hpp @@ -26,6 +26,9 @@ #include "vkPlatform.hpp" #include "vkRefUtil.hpp" +#include "deMemory.h" +#include "deInt32.h" + namespace vkt { namespace ExternalMemoryUtil @@ -53,8 +56,9 @@ public: NativeHandle& operator= (vk::pt::AndroidHardwareBufferPtr buffer); void setWin32Handle (Win32HandleType type, vk::pt::Win32Handle handle); - vk::pt::Win32Handle getWin32Handle (void) const; + void setHostPtr (void* hostPtr); + void* getHostPtr (void) const; int getFd (void) const; vk::pt::AndroidHardwareBufferPtr getAndroidHardwareBuffer (void) const; void disown (void); @@ -65,6 +69,7 @@ private: Win32HandleType m_win32HandleType; vk::pt::Win32Handle m_win32Handle; vk::pt::AndroidHardwareBufferPtr m_androidHardwareBuffer; + void* m_hostPtr; // Disabled NativeHandle& operator= (const NativeHandle&); @@ -166,6 +171,26 @@ enum Transference TRANSFERENCE_REFERENCE }; +struct ExternalHostMemory +{ + ExternalHostMemory(vk::VkDeviceSize aSize, vk::VkDeviceSize aAlignment) + : size(deAlignSize(static_cast(aSize), static_cast(aAlignment))) + { + data = deAlignedMalloc(this->size, static_cast(aAlignment)); + } + + ~ExternalHostMemory() + { + if (data != DE_NULL) + { + deAlignedFree(data); + } + } + + size_t size; + void* data; +}; + bool isSupportedPermanence (vk::VkExternalSemaphoreHandleTypeFlagBits type, Permanence permanence); Transference getHandelTypeTransferences (vk::VkExternalSemaphoreHandleTypeFlagBits type); @@ -325,6 +350,9 @@ vk::Move createExternalImage (const vk::DeviceInterface& deUint32 mipLevels = 1u, deUint32 arrayLayers = 1u); +vk::VkPhysicalDeviceExternalMemoryHostPropertiesEXT getPhysicalDeviceExternalMemoryHostProperties(const vk::InstanceInterface& vki, + vk::VkPhysicalDevice physicalDevice); + } // ExternalMemoryUtil } // vkt diff --git a/external/vulkancts/modules/vulkan/vktTestCase.cpp b/external/vulkancts/modules/vulkan/vktTestCase.cpp index cf3ef94..15ea1ee 100644 --- a/external/vulkancts/modules/vulkan/vktTestCase.cpp +++ b/external/vulkancts/modules/vulkan/vktTestCase.cpp @@ -67,6 +67,7 @@ vector filterExtensions (const vector& extensions "VK_NV_ray_tracing", "VK_AMD_mixed_attachment_samples", "VK_AMD_shader_fragment_mask", + "VK_AMD_buffer_marker", }; for (size_t extNdx = 0; extNdx < extensions.size(); extNdx++) diff --git a/external/vulkancts/mustpass/master/vk-default-no-waivers.txt b/external/vulkancts/mustpass/master/vk-default-no-waivers.txt index 51e536f..a8b9a69 100644 --- a/external/vulkancts/mustpass/master/vk-default-no-waivers.txt +++ b/external/vulkancts/mustpass/master/vk-default-no-waivers.txt @@ -7165,6 +7165,102 @@ dEQP-VK.api.buffer.dedicated_alloc.index.create.zero dEQP-VK.api.buffer.dedicated_alloc.vertex.indirect.create.zero dEQP-VK.api.buffer.dedicated_alloc.vertex.create.zero dEQP-VK.api.buffer.dedicated_alloc.indirect.create.zero +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.memory_dep.buffer_copy dEQP-VK.api.buffer_view.create.suballocation.uniform.r4g4_unorm_pack8 dEQP-VK.api.buffer_view.create.suballocation.uniform.r4g4b4a4_unorm_pack16 dEQP-VK.api.buffer_view.create.suballocation.uniform.b4g4r4a4_unorm_pack16 diff --git a/external/vulkancts/mustpass/master/vk-default.txt b/external/vulkancts/mustpass/master/vk-default.txt index 03f1382..6368256 100644 --- a/external/vulkancts/mustpass/master/vk-default.txt +++ b/external/vulkancts/mustpass/master/vk-default.txt @@ -7165,6 +7165,102 @@ dEQP-VK.api.buffer.dedicated_alloc.index.create.zero dEQP-VK.api.buffer.dedicated_alloc.vertex.indirect.create.zero dEQP-VK.api.buffer.dedicated_alloc.vertex.create.zero dEQP-VK.api.buffer.dedicated_alloc.indirect.create.zero +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.external_host_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.external_host_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.default_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.memory_dep.draw +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.graphics.default_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.external_host_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.external_host_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.default_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.memory_dep.dispatch +dEQP-VK.api.buffer_marker.compute.default_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.external_host_mem.bottom_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.top_of_pipe.memory_dep.buffer_copy +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.sequential.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.sequential.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.sequential.65536 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.overwrite.1 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.overwrite.4 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.overwrite.64 +dEQP-VK.api.buffer_marker.transfer.default_mem.bottom_of_pipe.memory_dep.buffer_copy dEQP-VK.api.buffer_view.create.suballocation.uniform.r4g4_unorm_pack8 dEQP-VK.api.buffer_view.create.suballocation.uniform.r4g4b4a4_unorm_pack16 dEQP-VK.api.buffer_view.create.suballocation.uniform.b4g4r4a4_unorm_pack16 -- 2.7.4