| /*------------------------------------------------------------------------ |
| * 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 <vector> |
| |
| namespace vkt |
| { |
| namespace api |
| { |
| namespace |
| { |
| using namespace vk; |
| using de::UniquePtr; |
| using de::MovePtr; |
| using de::SharedPtr; |
| using namespace vkt::ExternalMemoryUtil; |
| |
| template<typename T> |
| inline const T* dataOrNullPtr(const std::vector<T>& v) |
| { |
| return (v.empty() ? DE_NULL : &v[0]); |
| } |
| |
| template<typename T> |
| inline T* dataOrNullPtr(std::vector<T>& v) |
| { |
| return (v.empty() ? DE_NULL : &v[0]); |
| } |
| |
| //! Common test data related to the device |
| struct WorkingDevice |
| { |
| Move<VkDevice> logicalDevice; |
| MovePtr<DeviceDriver> deviceDriver; |
| MovePtr<Allocator> 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<VkQueueFamilyProperties> queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice); |
| const float queuePriority = 1.0f; |
| VkDeviceQueueCreateInfo queueCreateInfo; |
| deMemset(&queueCreateInfo, 0, sizeof(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<const char*> 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<deUint32>(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<DeviceDriver>(new DeviceDriver(vkp, instance, *wd.logicalDevice)); |
| wd.allocator = MovePtr<Allocator>(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<vk::Allocation>& memory, size_t offset, |
| const std::vector<deUint32>& expected) |
| { |
| invalidateMappedMemoryRange(vk, device, memory->getMemory(), memory->getOffset(), VK_WHOLE_SIZE); |
| |
| const deUint32* data = reinterpret_cast<const deUint32*>(static_cast<const char*>(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<ExternalHostMemory>& 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<VkDeviceMemory> mem, void* hostPtr) : Allocation(*mem, (VkDeviceSize)0, hostPtr), m_memHolder(mem) { } |
| |
| private: |
| const Unique<VkDeviceMemory> m_memHolder; |
| }; |
| |
| void createMarkerBufferMemory(const InstanceInterface& vki, |
| const DeviceInterface& vkd, |
| VkPhysicalDevice physicalDevice, |
| VkDevice device, |
| VkBuffer buffer, |
| MovePtr<Allocator>& allocator, |
| const MemoryRequirement allocRequirement, |
| bool externalHostPtr, |
| MovePtr<ExternalHostMemory>& hostMemory, |
| MovePtr<Allocation>& 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<ExternalHostMemory>(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<Allocation>(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<VkBuffer> markerBuffer(makeBuffer(vk, device, markerBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT)); |
| MovePtr<ExternalHostMemory> hostMemory; |
| MovePtr<Allocation> 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<deUint32> expected(params.size); |
| |
| for (size_t i = 0; i < params.size; ++i) |
| expected[i] = rng.getUint32(); |
| |
| deMemcpy(markerMemory->getHostPtr(), &expected[0], static_cast<size_t>(markerBufferSize)); |
| flushMappedMemoryRange(vk, device, markerMemory->getMemory(), markerMemory->getOffset(), VK_WHOLE_SIZE); |
| |
| const Unique<VkCommandPool> cmdPool(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, wd.queueFamilyIdx)); |
| const Unique<VkCommandBuffer> 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<VkDeviceSize>(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<VkBuffer> markerBuffer(makeBuffer(vk, device, markerBufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT)); |
| MovePtr<ExternalHostMemory> hostMemory; |
| MovePtr<Allocation> 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<deUint32> expected(params.size); |
| |
| for (size_t i = 0; i < params.size; ++i) |
| expected[i] = 0; |
| |
| deMemcpy(markerMemory->getHostPtr(), &expected[0], static_cast<size_t>(markerBufferSize)); |
| flushMappedMemoryRange(vk, device, markerMemory->getMemory(), markerMemory->getOffset(), VK_WHOLE_SIZE); |
| |
| const Unique<VkCommandPool> cmdPool(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, wd.queueFamilyIdx)); |
| const Unique<VkCommandBuffer> 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<deUint32>(params.size); |
| const deUint32 value = i; |
| |
| expected[slot] = value; |
| |
| vk.cmdWriteBufferMarkerAMD(*cmdBuffer, params.stage, *markerBuffer, static_cast<VkDeviceSize>(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<VkBuffer> markerBuffer(makeBuffer(vk, device, params.base.size * sizeof(deUint32), usageFlags)); |
| MovePtr<ExternalHostMemory> hostMemory; |
| MovePtr<Allocation> 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<deUint32> expected(params.base.size, 0); |
| |
| Move<VkDescriptorPool> descriptorPool; |
| Move<VkDescriptorSetLayout> descriptorSetLayout; |
| Move<VkDescriptorSet> descriptorSet; |
| Move<VkPipelineLayout> 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<VkRenderPass> renderPass; |
| Move<VkFramebuffer> fbo; |
| Move<VkPipeline> pipeline; |
| Move<VkShaderModule> vertexModule; |
| Move<VkShaderModule> fragmentModule; |
| Move<VkShaderModule> 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<VkPipelineShaderStageCreateInfo> 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 = |
| { |
| VK_STENCIL_OP_KEEP, // VkStencilOp failOp |
| VK_STENCIL_OP_KEEP, // VkStencilOp passOp |
| VK_STENCIL_OP_KEEP, // VkStencilOp depthFailOp |
| VK_COMPARE_OP_NEVER, // VkCompareOp compareOp |
| 0, // deUint32 compareMask |
| 0, // deUint32 writeMask |
| 0 // deUint32 reference |
| }; |
| |
| 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<deUint32>(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<size_t>(markerBufferSize)); |
| flushMappedMemoryRange(vk, device, markerMemory->getMemory(), markerMemory->getOffset(), VK_WHOLE_SIZE); |
| |
| const Unique<VkCommandPool> cmdPool(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, wd.queueFamilyIdx)); |
| const Unique<VkCommandBuffer> cmdBuffer(allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY)); |
| |
| beginCommandBuffer(vk, *cmdBuffer); |
| |
| VkDescriptorSet setHandle = *descriptorSet; |
| |
| std::vector<MemoryDepOwner> 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<size_t>(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<MemoryDepOwner>(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; |
| deMemset(&base, 0, sizeof(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; |
| deMemset(¶ms, 0, sizeof(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 |
