external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemAttachmentLoadTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2017 The Khronos Group Inc.
   6  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  *//*!
  21  * \file
  22  * \brief Protected memory attachment render pass load tests
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktProtectedMemAttachmentLoadTests.hpp"
  26
  27 #include "deRandom.hpp"
  28 #include "tcuTestLog.hpp"
  29 #include "tcuVector.hpp"
  30 #include "tcuVectorUtil.hpp"
  31
  32 #include "vkPrograms.hpp"
  33 #include "vktTestCase.hpp"
  34 #include "vktTestGroupUtil.hpp"
  35 #include "vkTypeUtil.hpp"
  36 #include "vkBuilderUtil.hpp"
  37 #include "vkCmdUtil.hpp"
  38
  39 #include "vktProtectedMemContext.hpp"
  40 #include "vktProtectedMemUtils.hpp"
  41 #include "vktProtectedMemImageValidator.hpp"
  42
  43 namespace vkt
  44 {
  45 namespace ProtectedMem
  46 {
  47
  48 namespace
  49 {
  50
  51 enum {
  52         RENDER_WIDTH    = 128,
  53         RENDER_HEIGHT   = 128,
  54 };
  55
  56
  57 class AttachmentLoadTestInstance : public ProtectedTestInstance
  58 {
  59 public:
  60                                                                 AttachmentLoadTestInstance      (Context&                                       ctx,
  61                                                                                                                          const vk::VkClearValue&        clearValue,
  62                                                                                                                          const ValidationData&          refData,
  63                                                                                                                          const ImageValidator&          validator);
  64         virtual tcu::TestStatus         iterate                                         (void);
  65
  66 private:
  67         const vk::VkFormat                      m_imageFormat;
  68         const vk::VkClearValue&         m_clearValue;
  69         const ValidationData&           m_refData;
  70         const ImageValidator&           m_validator;
  71 };
  72
  73
  74 class AttachmentLoadTestCase : public TestCase
  75 {
  76 public:
  77                                                         AttachmentLoadTestCase  (tcu::TestContext&              testCtx,
  78                                                                                                          const std::string&             name,
  79                                                                                                          vk::VkClearValue               clearValue,
  80                                                                                                          ValidationData                 data)
  81                                                                 : TestCase              (testCtx, name, "Clear on render pass initialization.")
  82                                                                 , m_clearValue  (clearValue)
  83                                                                 , m_refData             (data)
  84                                                         {
  85                                                         }
  86
  87         virtual                                 ~AttachmentLoadTestCase (void) {}
  88         virtual TestInstance*   createInstance  (Context&                               ctx) const
  89                                                         {
  90                                                                 return new AttachmentLoadTestInstance(ctx, m_clearValue, m_refData, m_validator);
  91                                                         }
  92         virtual void                    initPrograms    (vk::SourceCollections& programCollection) const
  93                                                         {
  94                                                                 m_validator.initPrograms(programCollection);
  95                                                         }
  96 private:
  97         vk::VkClearValue                m_clearValue;
  98         ValidationData                  m_refData;
  99         ImageValidator                  m_validator;
 100 };
 101
 102 AttachmentLoadTestInstance::AttachmentLoadTestInstance  (Context&                                       ctx,
 103                                                                                                                  const vk::VkClearValue&        clearValue,
 104                                                                                                                  const ValidationData&          refData,
 105                                                                                                                  const ImageValidator&          validator)
 106         : ProtectedTestInstance (ctx)
 107         , m_imageFormat (vk::VK_FORMAT_R8G8B8A8_UNORM)
 108         , m_clearValue  (clearValue)
 109         , m_refData             (refData)
 110         , m_validator   (validator)
 111 {
 112 }
 113
 114 tcu::TestStatus AttachmentLoadTestInstance::iterate()
 115 {
 116         ProtectedContext&                                       ctx                                     (m_protectedContext);
 117         const vk::DeviceInterface&                      vk                                      = ctx.getDeviceInterface();
 118         const vk::VkDevice                                      device                          = ctx.getDevice();
 119         const vk::VkQueue                                       queue                           = ctx.getQueue();
 120         const deUint32                                          queueFamilyIndex        = ctx.getQueueFamilyIndex();
 121
 122         // Create output image
 123         de::MovePtr<vk::ImageWithMemory>        colorImage                      (createImage2D(ctx, PROTECTION_ENABLED, queueFamilyIndex,
 124                                                                                                                                                         RENDER_WIDTH, RENDER_HEIGHT,
 125                                                                                                                                                         m_imageFormat,
 126                                                                                                                                                         vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|vk::VK_IMAGE_USAGE_SAMPLED_BIT));
 127         vk::Unique<vk::VkImageView>                     colorImageView          (createImageView(ctx, **colorImage, m_imageFormat));
 128
 129         vk::Unique<vk::VkRenderPass>            renderPass                      (createRenderPass(ctx, m_imageFormat));
 130         vk::Unique<vk::VkFramebuffer>           framebuffer                     (createFramebuffer(ctx, RENDER_WIDTH, RENDER_HEIGHT, *renderPass, *colorImageView));
 131         vk::Unique<vk::VkPipelineLayout>        pipelineLayout          (createPipelineLayout(ctx, 0u, DE_NULL));
 132
 133         vk::Unique<vk::VkCommandPool>           cmdPool                         (makeCommandPool(vk, device, PROTECTION_ENABLED, queueFamilyIndex));
 134         vk::Unique<vk::VkCommandBuffer>         cmdBuffer                       (vk::allocateCommandBuffer(vk, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
 135
 136         // Begin cmd buffer
 137         beginCommandBuffer(vk, *cmdBuffer);
 138
 139         // Start image barrier
 140         {
 141                 const vk::VkImageMemoryBarrier  startImgBarrier         =
 142                 {
 143                         vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                     // sType
 144                         DE_NULL,                                                                                        // pNext
 145                         0,                                                                                                      // srcAccessMask
 146                         vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                       // dstAccessMask
 147                         vk::VK_IMAGE_LAYOUT_UNDEFINED,                                          // oldLayout
 148                         vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,           // newLayout
 149                         queueFamilyIndex,                                                                       // srcQueueFamilyIndex
 150                         queueFamilyIndex,                                                                       // dstQueueFamilyIndex
 151                         **colorImage,                                                                           // image
 152                         {
 153                                 vk::VK_IMAGE_ASPECT_COLOR_BIT,                                  // aspectMask
 154                                 0u,                                                                                             // baseMipLevel
 155                                 1u,                                                                                             // mipLevels
 156                                 0u,                                                                                             // baseArraySlice
 157                                 1u,                                                                                             // subresourceRange
 158                         }
 159                 };
 160
 161                 vk.cmdPipelineBarrier(*cmdBuffer,
 162                                                                 vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
 163                                                                 vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
 164                                                                 (vk::VkDependencyFlags)0,
 165                                                                 0, (const vk::VkMemoryBarrier*)DE_NULL,
 166                                                                 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
 167                                                                 1, &startImgBarrier);
 168         }
 169
 170         // Image clear
 171         beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, vk::makeRect2D(0, 0, RENDER_WIDTH, RENDER_HEIGHT), m_clearValue);
 172         endRenderPass(vk, *cmdBuffer);
 173
 174         {
 175                 // Image validator reads image in compute shader
 176                 const vk::VkImageMemoryBarrier  endImgBarrier           =
 177                 {
 178                         vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                     // sType
 179                         DE_NULL,                                                                                        // pNext
 180                         vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                       // srcAccessMask
 181                         vk::VK_ACCESS_SHADER_READ_BIT,                                          // dstAccessMask
 182                         vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,           // oldLayout
 183                         vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,           // newLayout
 184                         queueFamilyIndex,                                                                       // srcQueueFamilyIndex
 185                         queueFamilyIndex,                                                                       // dstQueueFamilyIndex
 186                         **colorImage,                                                                           // image
 187                         {
 188                                 vk::VK_IMAGE_ASPECT_COLOR_BIT,                                  // aspectMask
 189                                 0u,                                                                                             // baseMipLevel
 190                                 1u,                                                                                             // mipLevels
 191                                 0u,                                                                                             // baseArraySlice
 192                                 1u,                                                                                             // subresourceRange
 193                         }
 194                 };
 195                 vk.cmdPipelineBarrier(*cmdBuffer,
 196                                                                 vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
 197                                                                 vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
 198                                                                 (vk::VkDependencyFlags)0,
 199                                                                 0, (const vk::VkMemoryBarrier*)DE_NULL,
 200                                                                 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
 201                                                                 1, &endImgBarrier);
 202         }
 203
 204         endCommandBuffer(vk, *cmdBuffer);
 205
 206         // Submit command buffer
 207         const vk::Unique<vk::VkFence>   fence           (vk::createFence(vk, device));
 208         VK_CHECK(queueSubmit(ctx, PROTECTION_ENABLED, queue, *cmdBuffer, *fence, ~0ull));
 209
 210         // Log out test data
 211         ctx.getTestContext().getLog()
 212                 << tcu::TestLog::Message << "Color clear value: " << tcu::Vec4(m_clearValue.color.float32) << tcu::TestLog::EndMessage
 213                 << tcu::TestLog::Message << "Depth clear value: " << m_clearValue.depthStencil.depth << tcu::TestLog::EndMessage
 214                 << tcu::TestLog::Message << "Stencil clear value: " << m_clearValue.depthStencil.stencil << tcu::TestLog::EndMessage;
 215
 216         // Validate resulting image
 217         if (m_validator.validateImage(ctx, m_refData, **colorImage, m_imageFormat, vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL))
 218                 return tcu::TestStatus::pass("Everything went OK");
 219         else
 220                 return tcu::TestStatus::fail("Something went really wrong");
 221 }
 222
 223 } // anonymous
 224
 225 tcu::TestCaseGroup*     createAttachmentLoadTests (tcu::TestContext& testCtx)
 226 {
 227         struct {
 228                 const vk::VkClearValue          clearValue;
 229                 const ValidationData            data;
 230         } testData[] = {
 231                 {       vk::makeClearValueColorF32(1.0f, 0.0f, 0.0f, 1.0f),
 232                         {
 233                                 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),  tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
 234                                   tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f),  tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
 235                                 { tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),  tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),
 236                                   tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),  tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), }
 237                         }
 238                 },
 239                 {       vk::makeClearValueColorF32(0.0f, 1.0f, 0.0f, 1.0f),
 240                         {
 241                                 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),  tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
 242                                   tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f),  tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
 243                                 { tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f),  tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f),
 244                                   tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f),  tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f), }
 245                         }
 246                 },
 247                 {       vk::makeClearValueColorF32(0.0f, 0.0f, 1.0f, 1.0f),
 248                         {
 249                                 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),  tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
 250                                   tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f),  tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
 251                                 { tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f),  tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f),
 252                                   tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f),  tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f), }
 253                         }
 254                 },
 255                 {       vk::makeClearValueColorF32(0.0f, 0.0f, 0.0f, 1.0f),
 256                         {
 257                                 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),  tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
 258                                   tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f),  tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
 259                                 { tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),  tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),
 260                                   tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f),  tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f), }
 261                         }
 262                 },
 263                 {       vk::makeClearValueColorF32(1.0f, 0.0f, 0.0f, 1.0f),
 264                         {
 265                                 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),  tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
 266                                   tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f),  tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
 267                                 { tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),  tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),
 268                                   tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f),  tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f), }
 269                         }
 270                 },
 271                 {       vk::makeClearValueColorF32(1.0f, 0.0f, 0.0f, 0.0f),
 272                         {
 273                                 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),  tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
 274                                   tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f),  tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
 275                                 { tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f),  tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f),
 276                                   tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f),  tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f), }
 277                         }
 278                 },
 279                 {       vk::makeClearValueColorF32(0.1f, 0.2f, 0.3f, 0.0f),
 280                         {
 281                                 { tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),  tcu::Vec4(1.0f, 1.0f, 0.0f, 0.0f),
 282                                   tcu::Vec4(0.1f, 0.1f, 0.0f, 0.0f),  tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f), },
 283                                 { tcu::Vec4(0.1f, 0.2f, 0.3f, 0.0f),  tcu::Vec4(0.1f, 0.2f, 0.3f, 0.0f),
 284                                   tcu::Vec4(0.1f, 0.2f, 0.3f, 0.0f),  tcu::Vec4(0.1f, 0.2f, 0.3f, 0.0f), }
 285                         }
 286                 },
 287         };
 288
 289         de::MovePtr<tcu::TestCaseGroup> loadStaticTests (new tcu::TestCaseGroup(testCtx, "static", "Attachment Load Op Tests with static input"));
 290
 291         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testData); ++ndx)
 292         {
 293                 const std::string name = "clear_" + de::toString(ndx + 1);
 294                 loadStaticTests->addChild(new AttachmentLoadTestCase(testCtx, name.c_str(), testData[ndx].clearValue, testData[ndx].data));
 295         }
 296
 297         /* Add a few randomized tests */
 298         de::MovePtr<tcu::TestCaseGroup> loadRandomTests         (new tcu::TestCaseGroup(testCtx, "random", "Attachment Load Op Tests with random input"));
 299         const int                                               testCount                       = 10;
 300         de::Random                                              rnd                                     (testCtx.getCommandLine().getBaseSeed());
 301         for (int ndx = 0; ndx < testCount; ++ndx)
 302         {
 303                 const std::string       name            = "clear_" + de::toString(ndx + 1);
 304                 vk::VkClearValue        clearValue      = vk::makeClearValueColorVec4(tcu::randomVec4(rnd));
 305                 const tcu::Vec4         refValue        (clearValue.color.float32[0], clearValue.color.float32[1], clearValue.color.float32[2], clearValue.color.float32[3]);
 306                 const tcu::Vec4         vec0            = tcu::randomVec4(rnd);
 307                 const tcu::Vec4         vec1            = tcu::randomVec4(rnd);
 308                 const tcu::Vec4         vec2            = tcu::randomVec4(rnd);
 309                 const tcu::Vec4         vec3            = tcu::randomVec4(rnd);
 310
 311                 ValidationData          data = {
 312                         { vec0, vec1, vec2, vec3 },
 313                         { refValue, refValue, refValue, refValue }
 314                 };
 315
 316                 loadRandomTests->addChild(new AttachmentLoadTestCase(testCtx, name.c_str(), clearValue, data));
 317         }
 318
 319         de::MovePtr<tcu::TestCaseGroup> loadTests (new tcu::TestCaseGroup(testCtx, "load_op", "Attachment Load Op Tests"));
 320         loadTests->addChild(loadStaticTests.release());
 321         loadTests->addChild(loadRandomTests.release());
 322         return loadTests.release();
 323 }
 324
 325 } // ProtectedMem
 326 } // vkt