external/vulkancts/modules/vulkan/robustness/vktRobustnessUtil.hpp

   1 #ifndef _VKTROBUSTNESSUTIL_HPP
   2 #define _VKTROBUSTNESSUTIL_HPP
   3 /*------------------------------------------------------------------------
   4  * Vulkan Conformance Tests
   5  * ------------------------
   6  *
   7  * Copyright (c) 2016 The Khronos Group Inc.
   8  * Copyright (c) 2016 Imagination Technologies Ltd.
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  *//*!
  23  * \file
  24  * \brief Robustness Utilities
  25  *//*--------------------------------------------------------------------*/
  26
  27 #include "tcuDefs.hpp"
  28 #include "vkDefs.hpp"
  29 #include "vkRefUtil.hpp"
  30 #include "vktTestCase.hpp"
  31 #include "vkMemUtil.hpp"
  32 #include "deUniquePtr.hpp"
  33 #include "tcuVectorUtil.hpp"
  34 #include "vktCustomInstancesDevices.hpp"
  35
  36 namespace vkt
  37 {
  38 namespace robustness
  39 {
  40
  41 vk::Move<vk::VkDevice>  createRobustBufferAccessDevice          (Context& context, vk::VkInstance instance, const vk::InstanceInterface& vki, const vk::VkPhysicalDeviceFeatures2* enabledFeatures2 = DE_NULL);
  42 bool                                    areEqual                                                        (float a, float b);
  43 bool                                    isValueZero                                                     (const void* valuePtr, size_t valueSize);
  44 bool                                    isValueWithinBuffer                                     (const void* buffer, vk::VkDeviceSize bufferSize, const void* valuePtr, size_t valueSizeInBytes);
  45 bool                                    isValueWithinBufferOrZero                       (const void* buffer, vk::VkDeviceSize bufferSize, const void* valuePtr, size_t valueSizeInBytes);
  46 bool                                    verifyOutOfBoundsVec4                           (const void* vecPtr, vk::VkFormat bufferFormat);
  47 void                                    populateBufferWithTestValues            (void* buffer, vk::VkDeviceSize size, vk::VkFormat format);
  48 void                                    logValue                                                        (std::ostringstream& logMsg, const void* valuePtr, vk::VkFormat valueFormat, size_t valueSize);
  49
  50 class TestEnvironment
  51 {
  52 public:
  53                                                                         TestEnvironment         (Context&                                               context,
  54                                                                                                                  vk::VkInstance                                 instance,
  55                                                                                                                  const vk::InstanceInterface&   instanceInterface,
  56                                                                                                                  vk::VkDevice                                   device,
  57                                                                                                                  vk::VkDescriptorSetLayout              descriptorSetLayout,
  58                                                                                                                  vk::VkDescriptorSet                    descriptorSet);
  59
  60         virtual                                                 ~TestEnvironment        (void) {}
  61
  62         virtual vk::VkCommandBuffer             getCommandBuffer        (void);
  63
  64 protected:
  65         Context&                                                m_context;
  66         vk::VkInstance                                  m_instance;
  67         const vk::InstanceInterface&    m_instanceInterface;
  68         vk::VkDevice                                    m_device;
  69         vk::VkDescriptorSetLayout               m_descriptorSetLayout;
  70         vk::VkDescriptorSet                             m_descriptorSet;
  71
  72         vk::Move<vk::VkCommandPool>             m_commandPool;
  73         vk::Move<vk::VkCommandBuffer>   m_commandBuffer;
  74 };
  75
  76 class GraphicsEnvironment: public TestEnvironment
  77 {
  78 public:
  79         typedef std::vector<vk::VkVertexInputBindingDescription>        VertexBindings;
  80         typedef std::vector<vk::VkVertexInputAttributeDescription>      VertexAttributes;
  81
  82         struct DrawConfig
  83         {
  84                 std::vector<vk::VkBuffer>       vertexBuffers;
  85                 deUint32                                        vertexCount;
  86                 deUint32                                        instanceCount;
  87
  88                 vk::VkBuffer                            indexBuffer;
  89                 deUint32                                        indexCount;
  90         };
  91
  92                                                                         GraphicsEnvironment             (Context&                                               context,
  93                                                                                                                          vk::VkInstance                                 instance,
  94                                                                                                                          const vk::InstanceInterface&   instanceInterface,
  95                                                                                                                          vk::VkDevice                                   device,
  96                                                                                                                          vk::VkDescriptorSetLayout              descriptorSetLayout,
  97                                                                                                                          vk::VkDescriptorSet                    descriptorSet,
  98                                                                                                                          const VertexBindings&                  vertexBindings,
  99                                                                                                                          const VertexAttributes&                vertexAttributes,
 100                                                                                                                          const DrawConfig&                              drawConfig,
 101                                                                                                                          bool                                                   testPipelineRobustness = false);
 102
 103         virtual                                                 ~GraphicsEnvironment    (void) {}
 104
 105 private:
 106         const tcu::UVec2                                m_renderSize;
 107         const vk::VkFormat                              m_colorFormat;
 108
 109         vk::Move<vk::VkImage>                   m_colorImage;
 110         de::MovePtr<vk::Allocation>             m_colorImageAlloc;
 111         vk::Move<vk::VkImageView>               m_colorAttachmentView;
 112         vk::Move<vk::VkRenderPass>              m_renderPass;
 113         vk::Move<vk::VkFramebuffer>             m_framebuffer;
 114
 115         vk::Move<vk::VkShaderModule>    m_vertexShaderModule;
 116         vk::Move<vk::VkShaderModule>    m_fragmentShaderModule;
 117
 118         vk::Move<vk::VkBuffer>                  m_vertexBuffer;
 119         de::MovePtr<vk::Allocation>             m_vertexBufferAlloc;
 120
 121         vk::Move<vk::VkPipelineLayout>  m_pipelineLayout;
 122         vk::Move<vk::VkPipeline>                m_graphicsPipeline;
 123 };
 124
 125 class ComputeEnvironment: public TestEnvironment
 126 {
 127 public:
 128                                                                         ComputeEnvironment              (Context&                                               context,
 129                                                                                                                          vk::VkInstance                                 instance,
 130                                                                                                                          const vk::InstanceInterface&   instanceInterface,
 131                                                                                                                          vk::VkDevice                                   device,
 132                                                                                                                          vk::VkDescriptorSetLayout              descriptorSetLayout,
 133                                                                                                                          vk::VkDescriptorSet                    descriptorSet,
 134                                                                                                                          bool                                                   testPipelineRobustness = false);
 135
 136         virtual                                                 ~ComputeEnvironment             (void) {}
 137
 138 private:
 139         vk::Move<vk::VkShaderModule>    m_computeShaderModule;
 140         vk::Move<vk::VkPipelineLayout>  m_pipelineLayout;
 141         vk::Move<vk::VkPipeline>                m_computePipeline;
 142 };
 143
 144 } // robustness
 145 } // vkt
 146
 147 #endif // _VKTROBUSTNESSUTIL_HPP