Google Git
Sign in
fuchsia / third_party / vulkan-cts / refs/heads/upstream/vulkansc-cts-1.0.0 / . / external / vulkancts / modules / vulkan / sc / vktDeviceObjectReservationTests.cpp
blob: b536d8c7d76a3aee4c7f733114076b14e9ba5ee8 [file] [log] [blame]
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
*
* Copyright (c) 2021 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 VkDeviceObjectReservationCreateInfo tests
*//*--------------------------------------------------------------------*/
#include "vktDeviceObjectReservationTests.hpp"
#include <vector>
#include <string>
#include "tcuTestCase.hpp"
#include "vkDefs.hpp"
#include "vkDeviceUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkSafetyCriticalUtil.hpp"
#include "vkImageWithMemory.hpp"
#include "vkBufferWithMemory.hpp"
#include "vkObjUtil.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktCustomInstancesDevices.hpp"
using namespace vk;
namespace vkt
{
namespace sc
{
namespace
{
enum TestMaxValues
{
TMV_UNDEFINED = 0,
TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT,
TMV_MAX_IMAGEVIEW_MIPLEVELS,
TMV_MAX_IMAGEVIEW_ARRAYLAYERS,
TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS,
TMV_MAX_OCCLUSION_QUERIES_PER_POOL,
TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL,
TMV_MAX_TIMESTAMP_QUERIES_PER_POOL
};
const deUint32 VERIFYMAXVALUES_OBJECT_COUNT = 5U;
const deUint32 VERIFYMAXVALUES_ARRAYLAYERS = 8U;
const deUint32 VERIFYMAXVALUES_MIPLEVELS = 5U;
enum TestRequestCounts
{
TRC_UNDEFINED = 0,
TRC_SEMAPHORE,
TRC_COMMAND_BUFFER,
TRC_FENCE,
TRC_DEVICE_MEMORY,
TRC_BUFFER,
TRC_IMAGE,
TRC_EVENT,
TRC_QUERY_POOL,
TRC_BUFFER_VIEW,
TRC_IMAGE_VIEW,
TRC_LAYERED_IMAGE_VIEW,
TRC_PIPELINE_LAYOUT,
TRC_RENDER_PASS,
TRC_GRAPHICS_PIPELINE,
TRC_COMPUTE_PIPELINE,
TRC_DESCRIPTORSET_LAYOUT,
TRC_SAMPLER,
TRC_DESCRIPTOR_POOL,
TRC_DESCRIPTORSET,
TRC_FRAMEBUFFER,
TRC_COMMANDPOOL,
TRC_SAMPLERYCBCRCONVERSION,
TRC_SURFACE,
TRC_SWAPCHAIN,
TRC_DISPLAY_MODE,
};
enum TestPoolSizes
{
PST_UNDEFINED = 0,
PST_NONE,
PST_ZERO,
PST_TOO_SMALL_SIZE,
PST_ONE_FITS,
PST_MULTIPLE_FIT,
};
struct TestParams
{
TestParams (const TestMaxValues& testMaxValues_ = TMV_UNDEFINED, const TestRequestCounts& testRequestCounts_ = TRC_UNDEFINED, const TestPoolSizes& testPoolSizeType_ = PST_UNDEFINED)
: testMaxValues { testMaxValues_ }
, testRequestCounts { testRequestCounts_ }
, testPoolSizeType { testPoolSizeType_ }
{
}
TestMaxValues testMaxValues;
TestRequestCounts testRequestCounts;
TestPoolSizes testPoolSizeType;
};
typedef de::SharedPtr<Unique<VkSemaphore>> SemaphoreSp;
typedef de::SharedPtr<Unique<VkCommandBuffer>> CommandBufferSp;
typedef de::SharedPtr<Unique<VkFence>> FenceSp;
typedef de::SharedPtr<Unique<VkDeviceMemory> > DeviceMemorySp;
typedef de::SharedPtr<Unique<VkBuffer>> BufferSp;
typedef de::SharedPtr<Unique<VkImage>> ImageSp;
typedef de::SharedPtr<Unique<VkEvent>> EventSp;
typedef de::SharedPtr<Unique<VkQueryPool>> QueryPoolSp;
typedef de::SharedPtr<Unique<VkBufferView>> BufferViewSp;
typedef de::SharedPtr<Unique<VkImageView>> ImageViewSp;
typedef de::SharedPtr<Unique<VkPipelineLayout>> PipelineLayoutSp;
typedef de::SharedPtr<Unique<VkRenderPass>> RenderPassSp;
typedef de::SharedPtr<Unique<VkPipeline>> PipelineSp;
typedef de::SharedPtr<Unique<VkDescriptorSetLayout>> DescriptorSetLayoutSp;
typedef de::SharedPtr<Unique<VkSampler>> SamplerSp;
typedef de::SharedPtr<Unique<VkDescriptorPool>> DescriptorPoolSp;
typedef de::SharedPtr<Unique<VkDescriptorSet>> DescriptorSetSp;
typedef de::SharedPtr<Unique<VkFramebuffer>> FramebufferSp;
typedef de::SharedPtr<Unique<VkCommandPool>> CommandPoolSp;
typedef de::SharedPtr<Unique<VkSamplerYcbcrConversion>> SamplerYcbcrConversionSp;
//typedef de::SharedPtr<Unique<VkSurfaceKHR>> SurfaceSp;
//typedef de::SharedPtr<Unique<VkSwapchainKHR>> SwapchainSp;
//typedef de::SharedPtr<Unique<VkDisplayModeKHR>> DisplayModeSp;
typedef de::SharedPtr<Unique<VkSubpassDescription>> SubpassDescriptionSp;
typedef de::SharedPtr<Unique<VkAttachmentDescription>> AttachmentDescriptionSp;
void createSemaphores (const DeviceInterface& vkd,
const VkDevice device,
std::vector<SemaphoreSp>::iterator begin,
std::vector<SemaphoreSp>::iterator end)
{
for(std::vector<SemaphoreSp>::iterator it=begin; it!=end; ++it)
*it = SemaphoreSp(new Unique<VkSemaphore>(createSemaphore(vkd, device)));
}
void createCommandBuffers (const DeviceInterface& vkd,
const VkDevice device,
const VkCommandPool commandPool,
std::vector<CommandBufferSp>::iterator begin,
std::vector<CommandBufferSp>::iterator end)
{
for (std::vector<CommandBufferSp>::iterator it = begin; it != end; ++it)
{
const vk::VkCommandBufferAllocateInfo commandBufferAI =
{
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
DE_NULL, // pNext
commandPool, // commandPool
vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
1u // commandBufferCount
};
*it = CommandBufferSp(new Unique<VkCommandBuffer>(allocateCommandBuffer(vkd, device, &commandBufferAI)));
}
}
void createFences (const DeviceInterface& vkd,
const VkDevice device,
std::vector<FenceSp>::iterator begin,
std::vector<FenceSp>::iterator end)
{
for (std::vector<FenceSp>::iterator it = begin; it != end; ++it)
{
const VkFenceCreateInfo fenceCI =
{
VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u // VkFenceCreateFlags flags
};
*it = FenceSp(new Unique<VkFence>(createFence(vkd, device, &fenceCI)));
}
}
void allocateDeviceMemory (const DeviceInterface& vkd,
const VkDevice device,
VkDeviceSize size,
std::vector<DeviceMemorySp>::iterator begin,
std::vector<DeviceMemorySp>::iterator end)
{
for (std::vector<DeviceMemorySp>::iterator it = begin; it != end; ++it)
{
VkMemoryAllocateInfo alloc =
{
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // sType
DE_NULL, // pNext
size, // allocationSize
0U // memoryTypeIndex;
};
*it = DeviceMemorySp(new Unique<VkDeviceMemory>(allocateMemory(vkd, device, &alloc)));
}
}
void createBuffers (const DeviceInterface& vkd,
const VkDevice device,
VkDeviceSize size,
std::vector<BufferSp>::iterator begin,
std::vector<BufferSp>::iterator end)
{
deUint32 queueFamilyIndex = 0u;
for (std::vector<BufferSp>::iterator it = begin; it != end; ++it)
{
const VkBufferCreateInfo bufferCI =
{
VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // sType
DE_NULL, // pNext
0u, // flags
size, // size
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, // usage
VK_SHARING_MODE_EXCLUSIVE, // sharingMode
1u, // queueFamilyIndexCount
&queueFamilyIndex, // pQueueFamilyIndices
};
*it = BufferSp(new Unique<VkBuffer>(createBuffer(vkd, device, &bufferCI)));
}
}
void createImages (const DeviceInterface& vkd,
const VkDevice device,
deUint32 size,
std::vector<ImageSp>::iterator begin,
std::vector<ImageSp>::iterator end)
{
deUint32 queueFamilyIndex = 0u;
for (std::vector<ImageSp>::iterator it = begin; it != end; ++it)
{
const VkImageCreateInfo imageCI =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
(VkImageCreateFlags)0u, // VkImageCreateFlags flags
VK_IMAGE_TYPE_2D, // VkImageType imageType
VK_FORMAT_R8_UNORM, // VkFormat format
{
size, // deUint32 width
size, // deUint32 height
1u // deUint32 depth
}, // VkExtent3D extent
1u, // deUint32 mipLevels
1u, // deUint32 arrayLayers
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling
VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
1u, // deUint32 queueFamilyIndexCount
&queueFamilyIndex, // const deUint32* pQueueFamilyIndices
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout
};
*it = ImageSp(new Unique<VkImage>(createImage(vkd, device, &imageCI)));
}
}
void createEvents (const DeviceInterface& vkd,
const VkDevice device,
std::vector<EventSp>::iterator begin,
std::vector<EventSp>::iterator end)
{
for(std::vector<EventSp>::iterator it=begin; it!=end; ++it)
*it = EventSp(new Unique<VkEvent>(createEvent(vkd, device)));
}
void createQueryPools (const DeviceInterface& vkd,
const VkDevice device,
std::vector<QueryPoolSp>::iterator begin,
std::vector<QueryPoolSp>::iterator end)
{
for (std::vector<QueryPoolSp>::iterator it = begin; it != end; ++it)
{
const VkQueryPoolCreateInfo queryPoolCI =
{
VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
(VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags
VK_QUERY_TYPE_OCCLUSION, // VkQueryType queryType
1u, // deUint32 queryCount
0u, // VkQueryPipelineStatisticFlags pipelineStatistics
};
*it = QueryPoolSp(new Unique<VkQueryPool>(createQueryPool(vkd, device, &queryPoolCI)));
}
}
void createBufferViews (const DeviceInterface& vkd,
const VkDevice device,
const VkBuffer buffer,
const VkDeviceSize size,
std::vector<BufferViewSp>::iterator begin,
std::vector<BufferViewSp>::iterator end)
{
for (std::vector<BufferViewSp>::iterator it = begin; it != end; ++it)
{
const VkBufferViewCreateInfo bufferViewCI =
{
VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkBufferViewCreateFlags flags
buffer, // VkBuffer buffer
VK_FORMAT_R8_UNORM, // VkFormat format
0ull, // VkDeviceSize offset
size // VkDeviceSize range
};
*it = BufferViewSp(new Unique<VkBufferView>(createBufferView(vkd, device, &bufferViewCI)));
}
}
void createImageViews (const DeviceInterface& vkd,
const VkDevice device,
const VkImage image,
std::vector<ImageViewSp>::iterator begin,
std::vector<ImageViewSp>::iterator end)
{
for (std::vector<ImageViewSp>::iterator it = begin; it != end; ++it)
{
VkComponentMapping componentMapping { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY };
VkImageViewCreateInfo imageViewCI =
{
VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkImageViewCreateFlags flags
image, // VkImage image
VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType
VK_FORMAT_R8_UNORM, // VkFormat format
componentMapping, // VkComponentMapping components
{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }, // VkImageSubresourceRange subresourceRange
};
*it = ImageViewSp(new Unique<VkImageView>(createImageView(vkd, device, &imageViewCI)));
}
}
void createPipelineLayouts (const DeviceInterface& vkd,
const VkDevice device,
std::vector<PipelineLayoutSp>::iterator begin,
std::vector<PipelineLayoutSp>::iterator end)
{
for (std::vector<PipelineLayoutSp>::iterator it = begin; it != end; ++it)
{
const VkPipelineLayoutCreateInfo pipelineLayoutCI =
{
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkPipelineLayoutCreateFlags flags
0u, // deUint32 setLayoutCount
DE_NULL, // const VkDescriptorSetLayout* pSetLayouts
0u, // deUint32 pushConstantRangeCount
DE_NULL // const VkPushConstantRange* pPushConstantRanges
};
*it = PipelineLayoutSp(new Unique<VkPipelineLayout>(createPipelineLayout(vkd, device, &pipelineLayoutCI)));
}
}
void createRenderPasses (const DeviceInterface& vkd,
const VkDevice device,
VkAttachmentDescription* colorAttachment,
std::vector<RenderPassSp>::iterator begin,
std::vector<RenderPassSp>::iterator end)
{
for (std::vector<RenderPassSp>::iterator it = begin; it != end; ++it)
{
const VkAttachmentReference colorAttachmentRef =
{
0u, // deUint32 attachment
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout
};
const VkSubpassDescription subpassDescription =
{
0u, // VkSubpassDescriptionFlags flags
VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint
0u, // deUint32 inputAttachmentCount
DE_NULL, // const VkAttachmentReference* pInputAttachments
1u, // deUint32 colorAttachmentCount
&colorAttachmentRef, // const VkAttachmentReference* pColorAttachments
DE_NULL, // const VkAttachmentReference* pResolveAttachments
DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment
0u, // deUint32 preserveAttachmentCount
DE_NULL // const deUint32* pPreserveAttachments
};
const VkRenderPassCreateInfo renderPassCI =
{
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkRenderPassCreateFlags flags
1u, // deUint32 attachmentCount
colorAttachment, // const VkAttachmentDescription* pAttachments
1u, // deUint32 subpassCount
&subpassDescription, // const VkSubpassDescription* pSubpasses
0u, // deUint32 dependencyCount
DE_NULL // const VkSubpassDependency* pDependencies
};
*it = RenderPassSp(new Unique<VkRenderPass>(createRenderPass(vkd, device, &renderPassCI)));
}
}
void createGraphicsPipelines (const DeviceInterface& vkd,
const VkDevice device,
VkShaderModule vertexShaderModule,
VkShaderModule fragmentShaderModule,
VkRenderPass renderPass,
VkPipelineLayout pipelineLayout,
VkDeviceSize poolEntrySize,
de::SharedPtr<vk::ResourceInterface> resourceInterface,
std::vector<PipelineSp>::iterator begin,
std::vector<PipelineSp>::iterator end)
{
std::vector<VkPipelineShaderStageCreateInfo> shaderStageCreateInfos;
shaderStageCreateInfos.push_back
(
{
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;
vertexShaderModule, // VkShaderModule shader;
"main", // const char* pName;
DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
}
);
shaderStageCreateInfos.push_back
(
{
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;
fragmentShaderModule, // VkShaderModule shader;
"main", // const char* pName;
DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
}
);
for (std::vector<PipelineSp>::iterator it = begin; it != end; ++it)
{
const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
0u, // deUint32 vertexBindingDescriptionCount;
DE_NULL, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
0u, // deUint32 vertexAttributeDescriptionCount;
DE_NULL // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
};
const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology topology;
VK_FALSE // VkBool32 primitiveRestartEnable;
};
const VkPipelineViewportStateCreateInfo viewPortStateCreateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
1, // deUint32 viewportCount;
DE_NULL, // const VkViewport* pViewports;
1, // deUint32 scissorCount;
DE_NULL // const VkRect2D* pScissors;
};
const VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo =
{
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_BACK_BIT, // VkCullModeFlags cullMode;
VK_FRONT_FACE_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 multisampleStateCreateInfo =
{
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;
0.0f, // float minSampleShading;
DE_NULL, // const VkSampleMask* pSampleMask;
VK_FALSE, // VkBool32 alphaToCoverageEnable;
VK_FALSE // VkBool32 alphaToOneEnable;
};
const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
{
VK_FALSE, // VkBool32 blendEnable;
VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcColorBlendFactor;
VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
VK_BLEND_FACTOR_ZERO, // VkBlendFactor srcAlphaBlendFactor;
VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
(VkColorComponentFlags)0xFu // VkColorComponentFlags colorWriteMask;
};
const VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
DE_FALSE, // VkBool32 logicOpEnable;
VK_LOGIC_OP_CLEAR, // VkLogicOp logicOp;
1, // deUint32 attachmentCount;
&colorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
{ 1.0f, 1.0f, 1.0f, 1.0f } // float blendConstants[4];
};
const VkDynamicState dynamicStates[] =
{
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR
};
const VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineDynamicStateCreateFlags)0u, // VkPipelineDynamicStateCreateFlags flags;
DE_LENGTH_OF_ARRAY(dynamicStates), // deUint32 dynamicStateCount;
dynamicStates // const VkDynamicState* pDynamicStates;
};
VkGraphicsPipelineCreateInfo graphicsPipelineCI =
{
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
deUint32(shaderStageCreateInfos.size()), // deUint32 stageCount;
shaderStageCreateInfos.data(), // const VkPipelineShaderStageCreateInfo* pStages;
&vertexInputStateCreateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
&inputAssemblyStateCreateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState;
&viewPortStateCreateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState;
&rasterizationStateCreateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
&multisampleStateCreateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
DE_NULL, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
&colorBlendStateCreateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
&dynamicStateCreateInfo, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
pipelineLayout, // VkPipelineLayout layout;
renderPass, // VkRenderPass renderPass;
0u, // deUint32 subpass;
DE_NULL, // VkPipeline basePipelineHandle;
0 // int basePipelineIndex;
};
// we have to ensure that proper poolEntrySize is used
VkPipelineOfflineCreateInfo pipelineOfflineCreateInfo;
if (poolEntrySize != 0u)
{
pipelineOfflineCreateInfo = resetPipelineOfflineCreateInfo();
std::size_t hashValue = calculateGraphicsPipelineHash(graphicsPipelineCI, resourceInterface->getObjectHashes());
memcpy(pipelineOfflineCreateInfo.pipelineIdentifier, &hashValue, sizeof(std::size_t));
pipelineOfflineCreateInfo.poolEntrySize = poolEntrySize;
graphicsPipelineCI.pNext = &pipelineOfflineCreateInfo;
}
*it = PipelineSp(new Unique<VkPipeline>(createGraphicsPipeline(vkd, device, (VkPipelineCache)0u, &graphicsPipelineCI)));
}
}
void createComputePipelines (const DeviceInterface& vkd,
const VkDevice device,
VkShaderModule shaderModule,
VkPipelineLayout pipelineLayout,
VkDeviceSize poolEntrySize,
de::SharedPtr<vk::ResourceInterface> resourceInterface,
std::vector<PipelineSp>::iterator begin,
std::vector<PipelineSp>::iterator end)
{
for (std::vector<PipelineSp>::iterator it = begin; it != end; ++it)
{
VkPipelineShaderStageCreateInfo shaderStageCreateInfo =
{
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;
shaderModule, // VkShaderModule shader;
"main", // const char* pName;
DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
};
VkComputePipelineCreateInfo computePipelineCI =
{
VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkPipelineCreateFlags flags
shaderStageCreateInfo, // VkPipelineShaderStageCreateInfo stage
pipelineLayout, // VkPipelineLayout layout
(vk::VkPipeline)0, // VkPipeline basePipelineHandle
0u, // deInt32 basePipelineIndex
};
// we have to ensure that proper poolEntrySize is used
VkPipelineOfflineCreateInfo pipelineOfflineCreateInfo;
if (poolEntrySize != 0u)
{
pipelineOfflineCreateInfo = resetPipelineOfflineCreateInfo();
std::size_t hashValue = calculateComputePipelineHash(computePipelineCI, resourceInterface->getObjectHashes());
memcpy(pipelineOfflineCreateInfo.pipelineIdentifier, &hashValue, sizeof(std::size_t));
pipelineOfflineCreateInfo.poolEntrySize = poolEntrySize;
computePipelineCI.pNext = &pipelineOfflineCreateInfo;
}
*it = PipelineSp(new Unique<VkPipeline>(createComputePipeline(vkd, device, (VkPipelineCache)0u, &computePipelineCI)));
}
}
void createDescriptorSetLayouts (const DeviceInterface& vkd,
const VkDevice device,
std::vector<DescriptorSetLayoutSp>::iterator begin,
std::vector<DescriptorSetLayoutSp>::iterator end)
{
for (std::vector<DescriptorSetLayoutSp>::iterator it = begin; it != end; ++it)
{
const VkDescriptorSetLayoutBinding descriptorSetLayoutBinding =
{
0, // binding
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, // descriptorType
1u, // descriptorCount
VK_SHADER_STAGE_ALL, // stageFlags
NULL // pImmutableSamplers
};
const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCI =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // sType
NULL, // pNext
(VkDescriptorSetLayoutCreateFlags)0u, // flags
1u, // bindingCount
&descriptorSetLayoutBinding // pBindings
};
*it = DescriptorSetLayoutSp(new Unique<VkDescriptorSetLayout>(createDescriptorSetLayout(vkd, device, &descriptorSetLayoutCI)));
}
}
void createSamplers (const DeviceInterface& vkd,
const VkDevice device,
std::vector<SamplerSp>::iterator begin,
std::vector<SamplerSp>::iterator end)
{
for (std::vector<SamplerSp>::iterator it = begin; it != end; ++it)
{
const VkSamplerCreateInfo samplerCI =
{
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, //VkStructureType sType
DE_NULL, //const void* pNext
0u, //VkSamplerCreateFlags flags
VK_FILTER_NEAREST, //VkFilter magFilter
VK_FILTER_NEAREST, //VkFilter minFilter
VK_SAMPLER_MIPMAP_MODE_NEAREST, //VkSamplerMipmapMode mipmapMode
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeU
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeV
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, //VkSamplerAddressMode addressModeW
0.0f, //float mipLodBias
VK_FALSE, //VkBool32 anisotropyEnable
1.0f, //float maxAnisotropy
VK_FALSE, //VkBool32 compareEnable
VK_COMPARE_OP_EQUAL, //VkCompareOp compareOp
0.0f, //float minLod
0.0f, //float maxLod
VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, //VkBorderColor borderColor
VK_TRUE, //VkBool32 unnormalizedCoordinates
};
*it = SamplerSp(new Unique<VkSampler>(createSampler(vkd, device, &samplerCI)));
}
}
void createDescriptorPools (const DeviceInterface& vkd,
const VkDevice device,
deUint32 maxSets,
std::vector<DescriptorPoolSp>::iterator begin,
std::vector<DescriptorPoolSp>::iterator end)
{
for (std::vector<DescriptorPoolSp>::iterator it = begin; it != end; ++it)
{
const VkDescriptorPoolSize poolSizes =
{
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1u
};
const VkDescriptorPoolCreateInfo descriptorPoolCI =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // sType
DE_NULL, // pNext
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, // flags
maxSets, // maxSets
1u, // poolSizeCount
&poolSizes, // pPoolSizes
};
*it = DescriptorPoolSp(new Unique<VkDescriptorPool>(createDescriptorPool(vkd, device, &descriptorPoolCI)));
}
}
void createDescriptorSets (const DeviceInterface& vkd,
const VkDevice device,
const VkDescriptorPool descriptorPool,
const VkDescriptorSetLayout setLayout,
std::vector<DescriptorSetSp>::iterator begin,
std::vector<DescriptorSetSp>::iterator end)
{
for (std::vector<DescriptorSetSp>::iterator it = begin; it != end; ++it)
{
const VkDescriptorSetAllocateInfo descriptorSetAI =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
descriptorPool, // VkDescriptorPool descriptorPool
1u, // deUint32 descriptorSetCount
&setLayout // const VkDescriptorSetLayout* pSetLayouts
};
*it = DescriptorSetSp(new Unique<VkDescriptorSet>(allocateDescriptorSet(vkd, device, &descriptorSetAI)));
}
}
void createFramebuffers (const DeviceInterface& vkd,
const VkDevice device,
const VkRenderPass renderPass,
const VkImageView imageView,
std::vector<FramebufferSp>::iterator begin,
std::vector<FramebufferSp>::iterator end)
{
for (std::vector<FramebufferSp>::iterator it = begin; it != end; ++it)
{
const VkFramebufferCreateInfo framebufferCi =
{
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkFramebufferCreateFlags flags
renderPass, // VkRenderPass renderPass
1u, // uint32_t attachmentCount
&imageView, // const VkImageView* pAttachments
8u, // uint32_t width
8u, // uint32_t height
1u // uint32_t layers
};
*it = FramebufferSp(new Unique<VkFramebuffer>(createFramebuffer(vkd, device, &framebufferCi)));
}
}
void createCommandPools (const DeviceInterface& vkd,
const VkDevice device,
std::vector<CommandPoolSp>::iterator begin,
std::vector<CommandPoolSp>::iterator end)
{
for (std::vector<CommandPoolSp>::iterator it = begin; it != end; ++it)
{
const VkCommandPoolCreateInfo commandPoolCI =
{
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // sType
DE_NULL, // pNext
0u, // flags
0u, // queueFamilyIndex
};
*it = CommandPoolSp(new Unique<VkCommandPool>(createCommandPool(vkd, device, &commandPoolCI)));
}
}
void createSamplerYcbcrConversions (const DeviceInterface& vkd,
const VkDevice device,
std::vector<SamplerYcbcrConversionSp>::iterator begin,
std::vector<SamplerYcbcrConversionSp>::iterator end)
{
for (std::vector<SamplerYcbcrConversionSp>::iterator it = begin; it != end; ++it)
{
const VkSamplerYcbcrConversionCreateInfo ycbcrConversionCI =
{
VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, // sType
DE_NULL, // pNext
VK_FORMAT_G8B8G8R8_422_UNORM, // format
VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, // ycbcrModel
VK_SAMPLER_YCBCR_RANGE_ITU_FULL, // ycbcrRange
{
VK_COMPONENT_SWIZZLE_IDENTITY, // r
VK_COMPONENT_SWIZZLE_IDENTITY, // g
VK_COMPONENT_SWIZZLE_IDENTITY, // b
VK_COMPONENT_SWIZZLE_IDENTITY, // a
}, // components
VK_CHROMA_LOCATION_MIDPOINT, // xChromaOffset
VK_CHROMA_LOCATION_MIDPOINT, // yChromaOffset
VK_FILTER_NEAREST, // chromaFilter
VK_FALSE, // forceExplicitReconstruction
};
*it = SamplerYcbcrConversionSp(new Unique<VkSamplerYcbcrConversion>(createSamplerYcbcrConversion(vkd, device, &ycbcrConversionCI)));
}
}
// Base class for all VkDeviceObjectReservationCreateInfo tests.
// Creates a device with 0 for all "max" values / and "RequestCounts"
class DeviceObjectReservationInstance : public vkt::TestInstance
{
public:
DeviceObjectReservationInstance (Context& context,
const TestParams& testParams_);
tcu::TestStatus iterate (void) override;
virtual Move<VkDevice> createTestDevice (VkDeviceCreateInfo& deviceCreateInfo,
VkDeviceObjectReservationCreateInfo& objectInfo,
VkPhysicalDeviceVulkanSC10Features& sc10Features);
virtual void performTest (const DeviceInterface& vkd,
VkDevice device);
virtual bool verifyTestResults (const DeviceInterface& vkd,
VkDevice device);
protected:
TestParams testParams;
vkt::CustomInstance instance;
VkPhysicalDevice physicalDevice;
};
DeviceObjectReservationInstance::DeviceObjectReservationInstance (Context& context,
const TestParams& testParams_)
: vkt::TestInstance ( context )
, testParams ( testParams_ )
, instance ( vkt::createCustomInstanceFromContext(context) )
, physicalDevice ( chooseDevice(instance.getDriver(), instance, context.getTestContext().getCommandLine()) )
{
}
tcu::TestStatus DeviceObjectReservationInstance::iterate (void)
{
const float queuePriority = 1.0f;
const VkDeviceQueueCreateInfo deviceQueueCI =
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
DE_NULL, // pNext
(VkDeviceQueueCreateFlags)0u, // flags
0, //queueFamilyIndex;
1, //queueCount;
&queuePriority, //pQueuePriorities;
};
VkDeviceCreateInfo deviceCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType;
DE_NULL, // pNext;
(VkDeviceCreateFlags)0u, // flags
1, // queueRecordCount;
&deviceQueueCI, // pRequestedQueues;
0, // layerCount;
DE_NULL, // ppEnabledLayerNames;
0, // extensionCount;
DE_NULL, // ppEnabledExtensionNames;
DE_NULL, // pEnabledFeatures;
};
void* pNext = DE_NULL;
VkDeviceObjectReservationCreateInfo objectInfo = resetDeviceObjectReservationCreateInfo();
objectInfo.pipelineCacheRequestCount = 1u;
objectInfo.pNext = pNext;
pNext = &objectInfo;
VkPhysicalDeviceVulkanSC10Features sc10Features = createDefaultSC10Features();
sc10Features.pNext = pNext;
pNext = &sc10Features;
deviceCreateInfo.pNext = pNext;
Move<VkDevice> device = createTestDevice(deviceCreateInfo, objectInfo, sc10Features);
de::MovePtr<DeviceDriverSC, DeinitDeviceDeleter>
deviceDriver = de::MovePtr<DeviceDriverSC, DeinitDeviceDeleter>(new DeviceDriverSC(m_context.getPlatformInterface(), instance, *device, m_context.getTestContext().getCommandLine(), m_context.getResourceInterface(), m_context.getDeviceVulkanSC10Properties()),
DeinitDeviceDeleter(m_context.getResourceInterface().get(), *device));
performTest(*deviceDriver, *device);
const VkQueue queue = getDeviceQueue(*deviceDriver, *device, 0, 0);
VK_CHECK(deviceDriver->queueWaitIdle(queue));
if (!verifyTestResults(*deviceDriver, *device))
return tcu::TestStatus::fail("Failed");
return tcu::TestStatus::pass("Pass");
}
Move<VkDevice> DeviceObjectReservationInstance::createTestDevice (VkDeviceCreateInfo& deviceCreateInfo,
VkDeviceObjectReservationCreateInfo& objectInfo,
VkPhysicalDeviceVulkanSC10Features& sc10Features)
{
DE_UNREF(sc10Features);
// perform any non pipeline operations - create 2 semaphores
objectInfo.semaphoreRequestCount = 2u;
return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
}
void DeviceObjectReservationInstance::performTest (const DeviceInterface& vkd,
VkDevice device)
{
std::vector<SemaphoreSp> semaphores(2u);
createSemaphores(vkd, device, begin(semaphores), end(semaphores));
}
bool DeviceObjectReservationInstance::verifyTestResults (const DeviceInterface& vkd,
VkDevice device)
{
DE_UNREF(vkd);
DE_UNREF(device);
return true;
}
// Creates device with multiple VkDeviceObjectReservationCreateInfo and ensures that the limits of an individual VkDeviceObjectReservationCreateInfo can be exceeded.
class MultipleReservation : public DeviceObjectReservationInstance
{
public:
MultipleReservation (Context& context,
const TestParams& testParams_)
: DeviceObjectReservationInstance(context, testParams_)
{
}
Move<VkDevice> createTestDevice (VkDeviceCreateInfo& deviceCreateInfo,
VkDeviceObjectReservationCreateInfo& objectInfo,
VkPhysicalDeviceVulkanSC10Features& sc10Features) override
{
DE_UNREF(sc10Features);
VkDeviceObjectReservationCreateInfo thirdObjectInfo = resetDeviceObjectReservationCreateInfo();
thirdObjectInfo.deviceMemoryRequestCount = 2;
VkDeviceObjectReservationCreateInfo secondObjectInfo = resetDeviceObjectReservationCreateInfo();
secondObjectInfo.deviceMemoryRequestCount = 2;
secondObjectInfo.pNext = &thirdObjectInfo;
objectInfo.deviceMemoryRequestCount = 2;
objectInfo.pNext = &secondObjectInfo;
return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
}
void performTest (const DeviceInterface& vkd,
VkDevice device) override
{
std::vector<VkDeviceMemory> memoryObjects(6, (VkDeviceMemory)0);
for (size_t ndx = 0; ndx < 6; ndx++)
{
VkMemoryAllocateInfo alloc =
{
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // sType
DE_NULL, // pNext
128U, // allocationSize
0U // memoryTypeIndex;
};
VK_CHECK(vkd.allocateMemory(device, &alloc, (const VkAllocationCallbacks*)DE_NULL, &memoryObjects[ndx]));
TCU_CHECK(!!memoryObjects[ndx]);
}
}
};
void checkSupportVerifyMaxValues (vkt::Context& context, TestParams testParams)
{
if (testParams.testMaxValues == TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL && context.getDeviceFeatures().pipelineStatisticsQuery == VK_FALSE)
TCU_THROW(NotSupportedError, "pipelineStatisticsQuery is not supported");
}
// For each of the various resource "max" values, create resources that exercise the maximum values requested
class VerifyMaxValues : public DeviceObjectReservationInstance
{
public:
VerifyMaxValues (Context& context,
const TestParams& testParams_)
: DeviceObjectReservationInstance(context, testParams_)
{
}
Move<VkDevice> createTestDevice (VkDeviceCreateInfo& deviceCreateInfo,
VkDeviceObjectReservationCreateInfo& objectInfo,
VkPhysicalDeviceVulkanSC10Features& sc10Features) override
{
DE_UNREF(sc10Features);
switch (testParams.testMaxValues)
{
case TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT:
objectInfo.descriptorSetLayoutBindingLimit = VERIFYMAXVALUES_OBJECT_COUNT+1u;
objectInfo.descriptorSetLayoutBindingRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.descriptorSetLayoutRequestCount = 1u;
break;
case TMV_MAX_IMAGEVIEW_MIPLEVELS:
objectInfo.maxImageViewMipLevels = VERIFYMAXVALUES_MIPLEVELS;
objectInfo.maxImageViewArrayLayers = 1u;
objectInfo.imageRequestCount = 1u;
objectInfo.deviceMemoryRequestCount = 1u;
break;
case TMV_MAX_IMAGEVIEW_ARRAYLAYERS:
objectInfo.maxImageViewMipLevels = 1u;
objectInfo.maxImageViewArrayLayers = VERIFYMAXVALUES_ARRAYLAYERS;
objectInfo.imageRequestCount = 1u;
objectInfo.deviceMemoryRequestCount = 1u;
break;
case TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS:
objectInfo.maxLayeredImageViewMipLevels = VERIFYMAXVALUES_MIPLEVELS;
objectInfo.maxImageViewArrayLayers = VERIFYMAXVALUES_ARRAYLAYERS;
objectInfo.imageRequestCount = 1u;
objectInfo.deviceMemoryRequestCount = 1u;
break;
case TMV_MAX_OCCLUSION_QUERIES_PER_POOL:
objectInfo.maxOcclusionQueriesPerPool = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.queryPoolRequestCount = 1u;
break;
case TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL:
objectInfo.maxPipelineStatisticsQueriesPerPool = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.queryPoolRequestCount = 1u;
break;
case TMV_MAX_TIMESTAMP_QUERIES_PER_POOL:
objectInfo.maxTimestampQueriesPerPool = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.queryPoolRequestCount = 1u;
break;
default:
TCU_THROW(InternalError, "Unsupported max value");
}
return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
}
void performTest (const DeviceInterface& vkd,
VkDevice device) override
{
SimpleAllocator allocator(vkd, device, getPhysicalDeviceMemoryProperties(instance.getDriver(), physicalDevice));
de::MovePtr<ImageWithMemory> image;
Move<VkQueryPool> queryPool;
Move<VkDescriptorSetLayout> descriptorSetLayout;
deUint32 queueFamilyIndex = 0u;
switch (testParams.testMaxValues)
{
case TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT:
{
const VkDescriptorSetLayoutBinding binding =
{
VERIFYMAXVALUES_OBJECT_COUNT, // binding
VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, // descriptorType
1u, // descriptorCount
VK_SHADER_STAGE_ALL, // stageFlags
DE_NULL, // pImmutableSamplers
};
const VkDescriptorSetLayoutCreateInfo layoutCreateInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
DE_NULL, // pNext
0u, // flags
1u, // bindingCount
&binding, // pBindings
};
descriptorSetLayout = createDescriptorSetLayout(vkd, device, &layoutCreateInfo);
break;
}
case TMV_MAX_IMAGEVIEW_MIPLEVELS:
{
const VkImageCreateInfo imageCreateInfo =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkImageCreateFlags)0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
VK_FORMAT_R8_UNORM, // VkFormat format;
{
1 << VERIFYMAXVALUES_MIPLEVELS, // deUint32 width;
1 << VERIFYMAXVALUES_MIPLEVELS, // deUint32 height;
1u // deUint32 depth;
}, // VkExtent3D extent;
VERIFYMAXVALUES_MIPLEVELS, // deUint32 mipLevels;
1u, // deUint32 arrayLayers;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
&queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
};
image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
break;
}
case TMV_MAX_IMAGEVIEW_ARRAYLAYERS:
{
const VkImageCreateInfo imageCreateInfo =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkImageCreateFlags)0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
VK_FORMAT_R8_UNORM, // VkFormat format;
{
16U, // deUint32 width;
16U, // deUint32 height;
1u // deUint32 depth;
}, // VkExtent3D extent;
1u, // deUint32 mipLevels;
VERIFYMAXVALUES_ARRAYLAYERS, // deUint32 arrayLayers;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
&queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
};
image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
break;
}
case TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS:
{
const VkImageCreateInfo imageCreateInfo =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkImageCreateFlags)0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
VK_FORMAT_R8_UNORM, // VkFormat format;
{
1 << VERIFYMAXVALUES_MIPLEVELS, // deUint32 width;
1 << VERIFYMAXVALUES_MIPLEVELS, // deUint32 height;
1u // deUint32 depth;
}, // VkExtent3D extent;
VERIFYMAXVALUES_MIPLEVELS, // deUint32 mipLevels;
VERIFYMAXVALUES_ARRAYLAYERS, // deUint32 arrayLayers;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
&queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
};
image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
break;
}
case TMV_MAX_OCCLUSION_QUERIES_PER_POOL:
{
const VkQueryPoolCreateInfo queryPoolCreateInfo =
{
VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags;
VK_QUERY_TYPE_OCCLUSION, // VkQueryType queryType;
VERIFYMAXVALUES_OBJECT_COUNT, // deUint32 queryCount;
0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
};
queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
break;
}
case TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL:
{
const VkQueryPoolCreateInfo queryPoolCreateInfo =
{
VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags;
VK_QUERY_TYPE_PIPELINE_STATISTICS, // VkQueryType queryType;
VERIFYMAXVALUES_OBJECT_COUNT, // deUint32 queryCount;
0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
};
queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
break;
}
case TMV_MAX_TIMESTAMP_QUERIES_PER_POOL:
{
const VkQueryPoolCreateInfo queryPoolCreateInfo =
{
VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkQueryPoolCreateFlags)0, // VkQueryPoolCreateFlags flags;
VK_QUERY_TYPE_TIMESTAMP, // VkQueryType queryType;
VERIFYMAXVALUES_OBJECT_COUNT, // deUint32 queryCount;
0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
};
queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
break;
}
default:
TCU_THROW(InternalError, "Unsupported max value");
}
}
};
void checkSupportVerifyRequestCounts (vkt::Context& context, TestParams testParams)
{
if (testParams.testRequestCounts == TRC_SAMPLERYCBCRCONVERSION && context.getDeviceVulkan11Features().samplerYcbcrConversion == VK_FALSE)
TCU_THROW(NotSupportedError, "samplerYcbcrConversion is not supported");
}
// create programs for VerifyRequestCounts tests
struct ProgramsVerifyLimits
{
void init(SourceCollections& dst, TestParams testParams) const
{
if (testParams.testRequestCounts == TRC_GRAPHICS_PIPELINE || testParams.testPoolSizeType != PST_UNDEFINED)
{
dst.glslSources.add("vertex") << glu::VertexSource(
"#version 450\n"
"\n"
"void main (void)\n"
"{\n"
" gl_Position = vec4(0);\n"
"}\n");
dst.glslSources.add("fragment") << glu::FragmentSource(
"#version 450\n"
"\n"
"layout(location=0) out vec4 x;\n"
"void main (void)\n"
"{\n"
" x = vec4(1);\n"
"}\n");
}
else if (testParams.testRequestCounts == TRC_COMPUTE_PIPELINE)
{
dst.glslSources.add("compute") << glu::ComputeSource(
"#version 450\n"
"layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
"void main (void)\n"
"{\n"
" uvec4 x = uvec4(0);\n"
"}\n");
}
}
};
// For each of the various resource "max" values, create resources that exercise the maximum values requested
class VerifyRequestCounts : public DeviceObjectReservationInstance
{
public:
VerifyRequestCounts (Context& context,
const TestParams& testParams_)
: DeviceObjectReservationInstance(context, testParams_)
{
}
Move<VkDevice> createTestDevice (VkDeviceCreateInfo& deviceCreateInfo,
VkDeviceObjectReservationCreateInfo& objectInfo,
VkPhysicalDeviceVulkanSC10Features& sc10Features) override
{
DE_UNREF(sc10Features);
std::vector<VkPipelinePoolSize> poolSizes;
VkDeviceSize pipelineDefaultSize = VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
switch (testParams.testRequestCounts)
{
case TRC_SEMAPHORE:
objectInfo.semaphoreRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_COMMAND_BUFFER:
objectInfo.commandPoolRequestCount = 1u;
objectInfo.commandBufferRequestCount = 2 * VERIFYMAXVALUES_OBJECT_COUNT + (VERIFYMAXVALUES_OBJECT_COUNT - VERIFYMAXVALUES_OBJECT_COUNT / 2) ;
break;
case TRC_FENCE:
objectInfo.fenceRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_DEVICE_MEMORY:
objectInfo.deviceMemoryRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_BUFFER:
objectInfo.bufferRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_IMAGE:
objectInfo.imageRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.maxImageViewMipLevels = 1u;
objectInfo.maxImageViewArrayLayers = 1u;
break;
case TRC_EVENT:
objectInfo.eventRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_QUERY_POOL:
objectInfo.queryPoolRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_BUFFER_VIEW:
objectInfo.deviceMemoryRequestCount = 1u;
objectInfo.bufferRequestCount = 1u;
objectInfo.bufferViewRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_IMAGE_VIEW:
objectInfo.deviceMemoryRequestCount = 1u;
objectInfo.imageViewRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.imageRequestCount = 1u;
objectInfo.maxImageViewMipLevels = 1u;
objectInfo.maxImageViewArrayLayers = 1u;
break;
case TRC_LAYERED_IMAGE_VIEW:
objectInfo.deviceMemoryRequestCount = 1u;
objectInfo.imageViewRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.layeredImageViewRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.imageRequestCount = 1u;
objectInfo.maxImageViewMipLevels = 1u;
objectInfo.maxImageViewArrayLayers = VERIFYMAXVALUES_ARRAYLAYERS;
break;
case TRC_PIPELINE_LAYOUT:
objectInfo.pipelineLayoutRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_RENDER_PASS:
objectInfo.renderPassRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.subpassDescriptionRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.attachmentDescriptionRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_GRAPHICS_PIPELINE:
objectInfo.pipelineLayoutRequestCount = 1u;
objectInfo.renderPassRequestCount = 1u;
objectInfo.subpassDescriptionRequestCount = 1u;
objectInfo.attachmentDescriptionRequestCount = 1u;
objectInfo.graphicsPipelineRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, pipelineDefaultSize, VERIFYMAXVALUES_OBJECT_COUNT });
break;
case TRC_COMPUTE_PIPELINE:
objectInfo.pipelineLayoutRequestCount = 1u;
objectInfo.computePipelineRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, pipelineDefaultSize, VERIFYMAXVALUES_OBJECT_COUNT });
break;
case TRC_DESCRIPTORSET_LAYOUT:
objectInfo.descriptorSetLayoutRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.descriptorSetLayoutBindingRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.descriptorSetLayoutBindingLimit = 2u;
break;
case TRC_SAMPLER:
objectInfo.samplerRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_DESCRIPTOR_POOL:
objectInfo.descriptorPoolRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_DESCRIPTORSET:
objectInfo.descriptorSetLayoutRequestCount = 1u;
objectInfo.descriptorSetLayoutBindingRequestCount = 1u;
objectInfo.descriptorSetLayoutBindingLimit = 2u;
objectInfo.descriptorPoolRequestCount = 1u;
objectInfo.descriptorSetRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_FRAMEBUFFER:
objectInfo.deviceMemoryRequestCount = 1u;
objectInfo.imageViewRequestCount = 1u;
objectInfo.imageRequestCount = 1u;
objectInfo.maxImageViewMipLevels = 1u;
objectInfo.maxImageViewArrayLayers = 1u;
objectInfo.renderPassRequestCount = 1u;
objectInfo.subpassDescriptionRequestCount = 1u;
objectInfo.attachmentDescriptionRequestCount = 1u;
objectInfo.framebufferRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_COMMANDPOOL:
objectInfo.commandPoolRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
objectInfo.commandBufferRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
case TRC_SAMPLERYCBCRCONVERSION:
objectInfo.samplerYcbcrConversionRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
break;
// case TRC_SURFACE:
// objectInfo.surfaceRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
// break;
// case TRC_SWAPCHAIN:
// objectInfo.swapchainRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
// break;
// case TRC_DISPLAY_MODE:
// objectInfo.displayModeRequestCount = VERIFYMAXVALUES_OBJECT_COUNT;
// break;
default:
TCU_THROW(InternalError, "Unsupported request count");
}
objectInfo.pipelinePoolSizeCount = deUint32(poolSizes.size());
objectInfo.pPipelinePoolSizes = poolSizes.empty() ? DE_NULL : poolSizes.data();
return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
}
void performTest (const DeviceInterface& vkd,
VkDevice device) override
{
SimpleAllocator allocator (vkd, device, getPhysicalDeviceMemoryProperties(instance.getDriver(), physicalDevice));
VkDeviceSize pipelineDefaultSize = VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
deUint32 queueFamilyIndex = 0u;
switch (testParams.testRequestCounts)
{
case TRC_SEMAPHORE:
{
std::vector<SemaphoreSp> semaphores(VERIFYMAXVALUES_OBJECT_COUNT);
createSemaphores(vkd, device, begin(semaphores), end(semaphores));
std::fill(begin(semaphores) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(semaphores), SemaphoreSp());
createSemaphores(vkd, device, begin(semaphores) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(semaphores));
std::fill(begin(semaphores), end(semaphores), SemaphoreSp());
createSemaphores(vkd, device, begin(semaphores), end(semaphores));
break;
}
case TRC_COMMAND_BUFFER:
{
std::vector<CommandPoolSp> commandPools(1u);
createCommandPools(vkd, device, begin(commandPools), end(commandPools));
std::vector<CommandBufferSp> commandBuffers(VERIFYMAXVALUES_OBJECT_COUNT);
createCommandBuffers(vkd, device, commandPools[0]->get(), begin(commandBuffers), end(commandBuffers));
std::fill(begin(commandBuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(commandBuffers), CommandBufferSp());
createCommandBuffers(vkd, device, commandPools[0]->get(), begin(commandBuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(commandBuffers));
std::fill(begin(commandBuffers), end(commandBuffers), CommandBufferSp());
createCommandBuffers(vkd, device, commandPools[0]->get(), begin(commandBuffers), end(commandBuffers));
break;
}
case TRC_FENCE:
{
std::vector<FenceSp> fences(VERIFYMAXVALUES_OBJECT_COUNT);
createFences(vkd, device, begin(fences), end(fences));
std::fill(begin(fences) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(fences), FenceSp());
createFences(vkd, device, begin(fences) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(fences));
std::fill(begin(fences), end(fences), FenceSp());
createFences(vkd, device, begin(fences), end(fences));
break;
}
case TRC_DEVICE_MEMORY:
{
std::vector<DeviceMemorySp> mems(VERIFYMAXVALUES_OBJECT_COUNT);
allocateDeviceMemory(vkd, device, 16U, begin(mems), end(mems));
break;
}
case TRC_BUFFER:
{
std::vector<BufferSp> buffers(VERIFYMAXVALUES_OBJECT_COUNT);
createBuffers(vkd, device, 32ull, begin(buffers), end(buffers));
std::fill(begin(buffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(buffers), BufferSp());
createBuffers(vkd, device, 32ull, begin(buffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(buffers));
std::fill(begin(buffers), end(buffers), BufferSp());
createBuffers(vkd, device, 32ull, begin(buffers), end(buffers));
break;
}
case TRC_IMAGE:
{
std::vector<ImageSp> images(VERIFYMAXVALUES_OBJECT_COUNT);
createImages(vkd, device, 16u, begin(images), end(images));
std::fill(begin(images) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(images), ImageSp());
createImages(vkd, device, 16u, begin(images) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(images));
std::fill(begin(images), end(images), ImageSp());
createImages(vkd, device, 16u, begin(images), end(images));
break;
}
case TRC_EVENT:
{
std::vector<EventSp> events(VERIFYMAXVALUES_OBJECT_COUNT);
createEvents(vkd, device, begin(events), end(events));
std::fill(begin(events) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(events), EventSp());
createEvents(vkd, device, begin(events) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(events));
std::fill(begin(events), end(events), EventSp());
createEvents(vkd, device, begin(events), end(events));
break;
}
case TRC_QUERY_POOL:
{
std::vector<QueryPoolSp> queryPools(VERIFYMAXVALUES_OBJECT_COUNT);
createQueryPools(vkd, device, begin(queryPools), end(queryPools));
break;
}
case TRC_BUFFER_VIEW:
{
const VkBufferCreateInfo bufferCI = makeBufferCreateInfo(128ull, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
BufferWithMemory buffer(vkd, device, allocator, bufferCI, MemoryRequirement::HostVisible);
std::vector<BufferViewSp> bufferViews(VERIFYMAXVALUES_OBJECT_COUNT);
createBufferViews(vkd, device, buffer.get(), 128ull, begin(bufferViews), end(bufferViews));
std::fill(begin(bufferViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(bufferViews), BufferViewSp());
createBufferViews(vkd, device, buffer.get(), 128ull, begin(bufferViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(bufferViews));
std::fill(begin(bufferViews), end(bufferViews), BufferViewSp());
createBufferViews(vkd, device, buffer.get(), 128ull, begin(bufferViews), end(bufferViews));
break;
}
case TRC_IMAGE_VIEW:
{
const VkImageCreateInfo imageCI =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkImageCreateFlags)0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
VK_FORMAT_R8_UNORM, // VkFormat format;
{
8u, // deUint32 width;
8u, // deUint32 height;
1u // deUint32 depth;
}, // VkExtent3D extent;
1u, // deUint32 mipLevels;
1u, // deUint32 arrayLayers;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
&queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
};
ImageWithMemory image(vkd, device, allocator, imageCI, MemoryRequirement::Any);
std::vector<ImageViewSp> imageViews(VERIFYMAXVALUES_OBJECT_COUNT);
createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));
std::fill(begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews), ImageViewSp());
createImageViews(vkd, device, image.get(), begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews));
std::fill(begin(imageViews), end(imageViews), ImageViewSp());
createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));
break;
}
case TRC_LAYERED_IMAGE_VIEW:
{
const VkImageCreateInfo imageCI =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkImageCreateFlags)0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
VK_FORMAT_R8_UNORM, // VkFormat format;
{
8u, // deUint32 width;
8u, // deUint32 height;
1u // deUint32 depth;
}, // VkExtent3D extent;
1u, // deUint32 mipLevels;
VERIFYMAXVALUES_ARRAYLAYERS, // deUint32 arrayLayers;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
&queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout initialLayout;
};
ImageWithMemory image(vkd, device, allocator, imageCI, MemoryRequirement::Any);
std::vector<ImageViewSp> imageViews(VERIFYMAXVALUES_OBJECT_COUNT);
createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));
std::fill(begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews), ImageViewSp());
createImageViews(vkd, device, image.get(), begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews));
std::fill(begin(imageViews), end(imageViews), ImageViewSp());
createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));
break;
}
case TRC_PIPELINE_LAYOUT:
{
std::vector<PipelineLayoutSp> pipelineLayouts(VERIFYMAXVALUES_OBJECT_COUNT);
createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
std::fill(begin(pipelineLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelineLayouts), PipelineLayoutSp());
createPipelineLayouts(vkd, device, begin(pipelineLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelineLayouts));
std::fill(begin(pipelineLayouts), end(pipelineLayouts), PipelineLayoutSp());
createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
break;
}
case TRC_RENDER_PASS:
{
VkAttachmentDescription attachmentDescription =
{
0u, // VkAttachmentDescriptionFlags flags;
VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
};
std::vector<RenderPassSp> renderPasses(VERIFYMAXVALUES_OBJECT_COUNT);
createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
std::fill(begin(renderPasses) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(renderPasses), RenderPassSp());
createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(renderPasses));
std::fill(begin(renderPasses), end(renderPasses), RenderPassSp());
createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
break;
}
case TRC_GRAPHICS_PIPELINE:
{
VkAttachmentDescription attachmentDescription =
{
0u, // VkAttachmentDescriptionFlags flags;
VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
};
std::vector<RenderPassSp> renderPasses(1u);
createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
std::vector<PipelineLayoutSp> pipelineLayouts(1u);
createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
Move<VkShaderModule> vertexShaderModule = createShaderModule(vkd, device, m_context.getBinaryCollection().get("vertex"), 0u);
Move<VkShaderModule> fragmentShaderModule = createShaderModule(vkd, device, m_context.getBinaryCollection().get("fragment"), 0u);
std::vector<PipelineSp> pipelines(VERIFYMAXVALUES_OBJECT_COUNT);
createGraphicsPipelines(vkd, device, vertexShaderModule.get(), fragmentShaderModule.get(), renderPasses[0]->get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines), end(pipelines));
if (m_context.getDeviceVulkanSC10Properties().recyclePipelineMemory)
{
std::fill(begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines), PipelineSp());
createGraphicsPipelines(vkd, device, vertexShaderModule.get(), fragmentShaderModule.get(), renderPasses[0]->get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines));
std::fill(begin(pipelines), end(pipelines), PipelineSp());
createGraphicsPipelines(vkd, device, vertexShaderModule.get(), fragmentShaderModule.get(), renderPasses[0]->get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines), end(pipelines));
}
break;
}
case TRC_COMPUTE_PIPELINE:
{
std::vector<PipelineLayoutSp> pipelineLayouts (1u);
createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
Move<VkShaderModule> shaderModule = createShaderModule(vkd, device, m_context.getBinaryCollection().get("compute"), 0u);
std::vector<PipelineSp> pipelines(VERIFYMAXVALUES_OBJECT_COUNT);
createComputePipelines(vkd, device, shaderModule.get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines), end(pipelines));
if (m_context.getDeviceVulkanSC10Properties().recyclePipelineMemory)
{
std::fill(begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines), PipelineSp());
createComputePipelines(vkd, device, shaderModule.get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines));
std::fill(begin(pipelines), end(pipelines), PipelineSp());
createComputePipelines(vkd, device, shaderModule.get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines), end(pipelines));
}
break;
}
case TRC_DESCRIPTORSET_LAYOUT:
{
std::vector<DescriptorSetLayoutSp> descriptorSetLayouts(VERIFYMAXVALUES_OBJECT_COUNT);
createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts), end(descriptorSetLayouts));
std::fill(begin(descriptorSetLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSetLayouts), DescriptorSetLayoutSp());
createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSetLayouts));
std::fill(begin(descriptorSetLayouts), end(descriptorSetLayouts), DescriptorSetLayoutSp());
createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts), end(descriptorSetLayouts));
break;
}
case TRC_SAMPLER:
{
std::vector<SamplerSp> samplers(VERIFYMAXVALUES_OBJECT_COUNT);
createSamplers(vkd, device, begin(samplers), end(samplers));
std::fill(begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers), SamplerSp());
createSamplers(vkd, device, begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers));
std::fill(begin(samplers), end(samplers), SamplerSp());
createSamplers(vkd, device, begin(samplers), end(samplers));
break;
}
case TRC_DESCRIPTOR_POOL:
{
std::vector<DescriptorPoolSp> descriptorPools(VERIFYMAXVALUES_OBJECT_COUNT);
createDescriptorPools(vkd, device, 1u, begin(descriptorPools), end(descriptorPools));
break;
}
case TRC_DESCRIPTORSET:
{
std::vector<DescriptorSetLayoutSp> descriptorSetLayouts(1u);
createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts), end(descriptorSetLayouts));
std::vector<DescriptorPoolSp> descriptorPools(1u);
createDescriptorPools(vkd, device, VERIFYMAXVALUES_OBJECT_COUNT, begin(descriptorPools), end(descriptorPools));
std::vector<DescriptorSetSp> descriptorSets(VERIFYMAXVALUES_OBJECT_COUNT);
createDescriptorSets(vkd, device, descriptorPools[0]->get(), descriptorSetLayouts[0]->get(), begin(descriptorSets), end(descriptorSets));
if (m_context.getDeviceVulkanSC10Properties().recycleDescriptorSetMemory)
{
std::fill(begin(descriptorSets) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSets), DescriptorSetSp());
createDescriptorSets(vkd, device, descriptorPools[0]->get(), descriptorSetLayouts[0]->get(), begin(descriptorSets) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSets));
std::fill(begin(descriptorSets), end(descriptorSets), DescriptorSetSp());
createDescriptorSets(vkd, device, descriptorPools[0]->get(), descriptorSetLayouts[0]->get(), begin(descriptorSets), end(descriptorSets));
}
break;
}
case TRC_FRAMEBUFFER:
{
VkImageCreateInfo imageCI =
{
VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
(VkImageCreateFlags)0u, // VkImageCreateFlags flags
VK_IMAGE_TYPE_2D, // VkImageType imageType
VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format
{
8u, // deUint32 width
8u, // deUint32 height
1u // deUint32 depth
}, // VkExtent3D extent
1u, // deUint32 mipLevels
1u, // deUint32 arrayLayers
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples
VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // VkImageUsageFlags usage;
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1u, // deUint32 queueFamilyIndexCount;
&queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
};
ImageWithMemory image(vkd, device, allocator, imageCI, MemoryRequirement::Any);
VkAttachmentDescription attachmentDescription =
{
0u, // VkAttachmentDescriptionFlags flags;
VK_FORMAT_R8G8B8A8_UNORM, // VkFormat format;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
};
std::vector<RenderPassSp> renderPasses(1u);
createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
std::vector<ImageViewSp> imageViews(1u);
createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));
std::vector<FramebufferSp> framebuffers(VERIFYMAXVALUES_OBJECT_COUNT);
createFramebuffers(vkd, device, renderPasses[0]->get(), imageViews[0]->get(), begin(framebuffers), end(framebuffers));
std::fill(begin(framebuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(framebuffers), FramebufferSp());
createFramebuffers(vkd, device, renderPasses[0]->get(), imageViews[0]->get(), begin(framebuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(framebuffers));
std::fill(begin(framebuffers), end(framebuffers), FramebufferSp());
createFramebuffers(vkd, device, renderPasses[0]->get(), imageViews[0]->get(), begin(framebuffers), end(framebuffers));
break;
}
case TRC_COMMANDPOOL:
{
std::vector<CommandPoolSp> commandPools(VERIFYMAXVALUES_OBJECT_COUNT);
createCommandPools(vkd, device, begin(commandPools), end(commandPools));
break;
}
case TRC_SAMPLERYCBCRCONVERSION:
{
std::vector<SamplerYcbcrConversionSp> samplers(VERIFYMAXVALUES_OBJECT_COUNT);
createSamplerYcbcrConversions(vkd, device, begin(samplers), end(samplers));
std::fill(begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers), SamplerYcbcrConversionSp());
createSamplerYcbcrConversions(vkd, device, begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers));
std::fill(begin(samplers), end(samplers), SamplerYcbcrConversionSp());
createSamplerYcbcrConversions(vkd, device, begin(samplers), end(samplers));
break;
}
// case TRC_SURFACE:
// break;
// case TRC_SWAPCHAIN:
// break;
// case TRC_DISPLAY_MODE:
// break;
default:
TCU_THROW(InternalError, "Unsupported max value");
}
}
};
// test pipeline pool sizes
class VerifyPipelinePoolSizes : public DeviceObjectReservationInstance
{
public:
VerifyPipelinePoolSizes (Context& context,
const TestParams& testParams_)
: DeviceObjectReservationInstance(context, testParams_)
{
}
Move<VkDevice> createTestDevice (VkDeviceCreateInfo& deviceCreateInfo,
VkDeviceObjectReservationCreateInfo& objectInfo,
VkPhysicalDeviceVulkanSC10Features& sc10Features) override
{
DE_UNREF(sc10Features);
std::vector<VkPipelinePoolSize> poolSizes;
const VkDeviceSize psTooSmall = 64u;
const VkDeviceSize psForOnePipeline = VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
switch (testParams.testPoolSizeType)
{
case PST_NONE:
objectInfo.graphicsPipelineRequestCount = 1u;
break;
case PST_ZERO:
objectInfo.graphicsPipelineRequestCount = 1u;
poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, 0u, 1u });
break;
case PST_TOO_SMALL_SIZE:
poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, psTooSmall, 1u });
objectInfo.graphicsPipelineRequestCount = 1u;
break;
case PST_ONE_FITS:
poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, psForOnePipeline, 1u });
objectInfo.graphicsPipelineRequestCount = 1u;
break;
case PST_MULTIPLE_FIT:
poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, psForOnePipeline, 16u });
objectInfo.graphicsPipelineRequestCount = 16u;
break;
default:
TCU_THROW(InternalError, "Unsupported pool size type");
}
objectInfo.pipelinePoolSizeCount = deUint32(poolSizes.size());
objectInfo.pPipelinePoolSizes = poolSizes.empty() ? DE_NULL : poolSizes.data();
objectInfo.pipelineLayoutRequestCount = 1u;
objectInfo.renderPassRequestCount = 1u;
objectInfo.subpassDescriptionRequestCount = 1u;
objectInfo.attachmentDescriptionRequestCount = 1u;
return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
}
void performTest (const DeviceInterface& vk,
VkDevice device) override
{
const vk::PlatformInterface& vkp = m_context.getPlatformInterface();
const InstanceInterface& vki = instance.getDriver();
Move<VkShaderModule> vertexShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("vertex"), 0);
Move<VkShaderModule> fragmentShader = createShaderModule(vk, device, m_context.getBinaryCollection().get("fragment"), 0);
std::vector<VkPipelineShaderStageCreateInfo> shaderStageCreateInfos =
{
{
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;
*vertexShader, // VkShaderModule shader;
"main", // const char* pName;
DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
},
{
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;
*fragmentShader, // VkShaderModule shader;
"main", // const char* pName;
DE_NULL, // const VkSpecializationInfo* pSpecializationInfo;
}
};
VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo;
VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo;
VkPipelineViewportStateCreateInfo viewPortStateCreateInfo;
VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo;
VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo;
VkPipelineColorBlendAttachmentState colorBlendAttachmentState;
VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo;
VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo;
std::vector<VkDynamicState> dynamicStates = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
{
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkPipelineLayoutCreateFlags)0u, // VkPipelineLayoutCreateFlags flags;
0u, // deUint32 setLayoutCount;
DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
0u, // deUint32 pushConstantRangeCount;
DE_NULL // const VkPushConstantRange* pPushConstantRanges;
};
Move<VkPipelineLayout> pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);
const VkFormat format = getRenderTargetFormat(vki, physicalDevice);
VkAttachmentDescription attachmentDescription;
VkAttachmentReference attachmentReference;
VkSubpassDescription subpassDescription;
VkRenderPassCreateInfo renderPassCreateInfo = prepareSimpleRenderPassCI(format, attachmentDescription, attachmentReference, subpassDescription);
Move<VkRenderPass> renderPass = createRenderPass(vk, device, &renderPassCreateInfo);
VkGraphicsPipelineCreateInfo graphicsPipelineCreateInfo = prepareSimpleGraphicsPipelineCI(vertexInputStateCreateInfo, shaderStageCreateInfos,
inputAssemblyStateCreateInfo, viewPortStateCreateInfo, rasterizationStateCreateInfo, multisampleStateCreateInfo, colorBlendAttachmentState, colorBlendStateCreateInfo,
dynamicStateCreateInfo, dynamicStates, *pipelineLayout, *renderPass);
// create custom VkPipelineIdentifierInfo
VkPipelineOfflineCreateInfo pipelineID = resetPipelineOfflineCreateInfo();
applyPipelineIdentifier(pipelineID, "ID_DR_PS_00");
pipelineID.pNext = graphicsPipelineCreateInfo.pNext;
graphicsPipelineCreateInfo.pNext = &pipelineID;
if (m_context.getTestContext().getCommandLine().isSubProcess())
{
pipelineID.poolEntrySize = VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
}
std::size_t pipelineCount = 0u;
switch (testParams.testPoolSizeType)
{
case PST_NONE:
case PST_ZERO:
case PST_TOO_SMALL_SIZE:
case PST_ONE_FITS:
pipelineCount = 1u;
break;
case PST_MULTIPLE_FIT:
pipelineCount = 16u;
break;
default:
TCU_THROW(InternalError, "Unsupported pool size type");
};
if (!m_context.getTestContext().getCommandLine().isSubProcess())
{
std::vector<Move<VkPipeline>> pipelines;
for (deUint32 i = 0; i < pipelineCount; ++i)
pipelines.emplace_back(createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo));
return;
}
GetDeviceProcAddrFunc getDeviceProcAddrFunc = (GetDeviceProcAddrFunc)vkp.getInstanceProcAddr(instance, "vkGetDeviceProcAddr");
CreateGraphicsPipelinesFunc createGraphicsPipelinesFunc = (CreateGraphicsPipelinesFunc)getDeviceProcAddrFunc(device, "vkCreateGraphicsPipelines");
DestroyPipelineFunc destroyPipelineFunc = (DestroyPipelineFunc)getDeviceProcAddrFunc(device, "vkDestroyPipeline");
VkPipelineCache pipelineCache = m_context.getResourceInterface()->getPipelineCache(device);
std::vector<VkPipeline> pipelines (pipelineCount, VkPipeline(DE_NULL));
deUint32 iterations = m_context.getDeviceVulkanSC10Properties().recyclePipelineMemory ? 1u : 4u;
// if recyclePipelineMemory is set then we are able to create the same pipelines again
for (deUint32 iter = 0; iter < iterations; ++iter)
{
for (deUint32 i = 0; i < pipelineCount; ++i)
{
VkResult result = createGraphicsPipelinesFunc(device, pipelineCache, 1u, &graphicsPipelineCreateInfo, DE_NULL, &pipelines[i]);
results.push_back(result);
if (result != VK_SUCCESS)
{
for (deUint32 j = 0; j < pipelineCount; ++j)
if (pipelines[j].getInternal() != DE_NULL)
destroyPipelineFunc(device, pipelines[j], DE_NULL);
return;
}
}
for (deUint32 i = 0; i < pipelineCount; ++i)
{
destroyPipelineFunc(device, pipelines[i], DE_NULL);
pipelines[i] = VkPipeline(DE_NULL);
}
}
}
bool verifyTestResults (const DeviceInterface& vkd,
VkDevice device) override
{
DE_UNREF(vkd);
DE_UNREF(device);
if (!m_context.getTestContext().getCommandLine().isSubProcess())
return true;
switch (testParams.testPoolSizeType)
{
case PST_NONE:
case PST_ZERO:
case PST_TOO_SMALL_SIZE:
return (results.back() == VK_ERROR_OUT_OF_POOL_MEMORY);
case PST_ONE_FITS:
return (results.back() == VK_SUCCESS);
case PST_MULTIPLE_FIT:
return (results.back() == VK_SUCCESS);
default:
TCU_THROW(InternalError, "Unsupported pool size type");
};
return true;
}
std::vector<VkResult> results;
};
} // anonymous
tcu::TestCaseGroup* createDeviceObjectReservationTests (tcu::TestContext& testCtx)
{
de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "device_object_reservation", "Tests verifying VkDeviceObjectReservationCreateInfo"));
// add basic tests
{
de::MovePtr<tcu::TestCaseGroup> basicGroup(new tcu::TestCaseGroup(group->getTestContext(), "basic", ""));
basicGroup->addChild(new InstanceFactory1<DeviceObjectReservationInstance, TestParams>(testCtx, tcu::NODETYPE_SELF_VALIDATE, "create_device", "", TestParams()));
basicGroup->addChild(new InstanceFactory1<MultipleReservation, TestParams>(testCtx, tcu::NODETYPE_SELF_VALIDATE, "multiple_device_object_reservation", "", TestParams()));
group->addChild(basicGroup.release());
}
// add tests verifying device limits
{
de::MovePtr<tcu::TestCaseGroup> limitGroup(new tcu::TestCaseGroup(group->getTestContext(), "limits", ""));
struct TestMaxValuesData
{
TestMaxValues testMaxValues;
const char* name;
} testMaxValues[] =
{
{ TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT, "descriptor_set_layout_binding_limit" },
{ TMV_MAX_IMAGEVIEW_MIPLEVELS, "max_imageview_miplevels" },
{ TMV_MAX_IMAGEVIEW_ARRAYLAYERS, "max_imageview_arraylayers" },
{ TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS, "max_layeredimageview_miplevels" },
{ TMV_MAX_OCCLUSION_QUERIES_PER_POOL, "max_occlusion_queries_per_pool" },
{ TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL, "max_pipelinestatistics_queries_per_pool" },
{ TMV_MAX_TIMESTAMP_QUERIES_PER_POOL, "max_timestamp_queries_per_pool" },
};
{
de::MovePtr<tcu::TestCaseGroup> maxValGroup(new tcu::TestCaseGroup(group->getTestContext(), "max_values", ""));
for (deInt32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testMaxValues); ndx++)
{
TestParams testParams
{
testMaxValues[ndx].testMaxValues,
TRC_UNDEFINED
};
maxValGroup->addChild(new InstanceFactory1WithSupport<VerifyMaxValues, TestParams, FunctionSupport1<TestParams>>(testCtx, tcu::NODETYPE_SELF_VALIDATE, testMaxValues[ndx].name, "", testParams,
typename FunctionSupport1<TestParams>::Args(checkSupportVerifyMaxValues, testParams)));
}
limitGroup->addChild(maxValGroup.release());
}
struct TestRequestCountData
{
TestRequestCounts requestCount;
const char* name;
} testRequestCounts[] =
{
{ TRC_SEMAPHORE, "semaphore" },
{ TRC_COMMAND_BUFFER, "command_buffer" },
{ TRC_FENCE, "fence" },
{ TRC_DEVICE_MEMORY, "device_memory" },
{ TRC_BUFFER, "buffer" },
{ TRC_IMAGE, "image" },
{ TRC_EVENT, "event" },
{ TRC_QUERY_POOL, "query_pool" },
{ TRC_BUFFER_VIEW, "buffer_view" },
{ TRC_IMAGE_VIEW, "image_view" },
{ TRC_LAYERED_IMAGE_VIEW, "layered_image_view" },
{ TRC_PIPELINE_LAYOUT, "pipeline_layout" },
{ TRC_RENDER_PASS, "render_pass" },
{ TRC_GRAPHICS_PIPELINE, "graphics_pipeline" },
{ TRC_COMPUTE_PIPELINE, "compute_pipeline" },
{ TRC_DESCRIPTORSET_LAYOUT, "descriptorset_layout" },
{ TRC_SAMPLER, "sampler" },
{ TRC_DESCRIPTOR_POOL, "descriptor_pool" },
{ TRC_DESCRIPTORSET, "descriptorset" },
{ TRC_FRAMEBUFFER, "framebuffer" },
{ TRC_COMMANDPOOL, "commandpool" },
{ TRC_SAMPLERYCBCRCONVERSION, "samplerycbcrconversion" },
// { TRC_SURFACE, "surface" },
// { TRC_SWAPCHAIN, "swapchain" },
// { TRC_DISPLAY_MODE, "display_mode" },
};
{
de::MovePtr<tcu::TestCaseGroup> requestCountGroup(new tcu::TestCaseGroup(group->getTestContext(), "request_count", ""));
for (deInt32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testRequestCounts); ndx++)
{
TestParams testParams
{
TMV_UNDEFINED,
testRequestCounts[ndx].requestCount
};
requestCountGroup->addChild(new InstanceFactory1WithSupport<VerifyRequestCounts, TestParams, FunctionSupport1<TestParams>, ProgramsVerifyLimits>(testCtx, tcu::NODETYPE_SELF_VALIDATE, testRequestCounts[ndx].name, "",
ProgramsVerifyLimits(), testParams, typename FunctionSupport1<TestParams>::Args(checkSupportVerifyRequestCounts, testParams)));
}
limitGroup->addChild(requestCountGroup.release());
}
group->addChild(limitGroup.release());
}
// add tests verifying pipeline pool sizes
{
de::MovePtr<tcu::TestCaseGroup> ppsGroup(new tcu::TestCaseGroup(group->getTestContext(), "pipeline_pool_size", ""));
struct PoolSizesData
{
TestPoolSizes type;
const char* name;
} poolSizes[] =
{
{ PST_NONE, "none" },
{ PST_ZERO, "zero" },
{ PST_TOO_SMALL_SIZE, "too_small_size" },
{ PST_ONE_FITS, "one_fits" },
{ PST_MULTIPLE_FIT, "multiple_fit" },
};
for (deInt32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(poolSizes); ndx++)
{
TestParams testParams(TMV_UNDEFINED, TRC_UNDEFINED, poolSizes[ndx].type);
ppsGroup->addChild(new InstanceFactory1<VerifyPipelinePoolSizes, TestParams, ProgramsVerifyLimits>(testCtx, tcu::NODETYPE_SELF_VALIDATE, poolSizes[ndx].name, "", ProgramsVerifyLimits(), testParams));
}
group->addChild(ppsGroup.release());
}
return group.release();
}
} // sc
} // vkt