external/vulkancts/modules/vulkan/pipeline/vktPipelineTimestampTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 The Khronos Group Inc.
   6  * Copyright (c) 2015 ARM 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 Timestamp Tests
  23  *//*--------------------------------------------------------------------*/
  24
  25 #include "vktPipelineTimestampTests.hpp"
  26 #include "vktPipelineClearUtil.hpp"
  27 #include "vktPipelineImageUtil.hpp"
  28 #include "vktPipelineVertexUtil.hpp"
  29 #include "vktPipelineReferenceRenderer.hpp"
  30 #include "vktTestCase.hpp"
  31 #include "vktTestCaseUtil.hpp"
  32 #include "vkImageUtil.hpp"
  33 #include "vkMemUtil.hpp"
  34 #include "vkPrograms.hpp"
  35 #include "vkBuilderUtil.hpp"
  36 #include "vkQueryUtil.hpp"
  37 #include "vkRef.hpp"
  38 #include "vkRefUtil.hpp"
  39 #include "tcuImageCompare.hpp"
  40 #include "deUniquePtr.hpp"
  41 #include "deStringUtil.hpp"
  42 #include "deMemory.h"
  43 #include "vkTypeUtil.hpp"
  44
  45 #include <sstream>
  46 #include <vector>
  47 #include <cctype>
  48 #include <locale>
  49
  50 namespace vkt
  51 {
  52 namespace pipeline
  53 {
  54
  55 using namespace vk;
  56
  57 namespace
  58 {
  59 typedef std::vector<VkPipelineStageFlagBits> StageFlagVector;
  60
  61 // helper functions
  62 #define GEN_DESC_STRING(name,postfix)                                      \
  63                 do {                                                               \
  64                    for (std::string::size_type ndx = 0; ndx<strlen(#name); ++ndx)  \
  65                          if(isDescription && #name[ndx] == '_')                        \
  66                            desc << " ";                                                \
  67                          else                                                          \
  68                            desc << std::tolower(#name[ndx],loc);                       \
  69                    if (isDescription)                                              \
  70                          desc << " " << #postfix;                                      \
  71                    else                                                            \
  72                          desc << "_" << #postfix;                                      \
  73                 } while (deGetFalse())
  74
  75 std::string getPipelineStageFlagStr (const VkPipelineStageFlagBits stage,
  76                                                                          bool                          isDescription)
  77 {
  78         std::ostringstream desc;
  79         std::locale loc;
  80         switch(stage)
  81         {
  82 #define STAGE_CASE(p)                              \
  83                 case VK_PIPELINE_STAGE_##p##_BIT:          \
  84                 {                                          \
  85                         GEN_DESC_STRING(p, stage);             \
  86                         break;                                 \
  87                 }
  88                 STAGE_CASE(TOP_OF_PIPE);
  89                 STAGE_CASE(DRAW_INDIRECT);
  90                 STAGE_CASE(VERTEX_INPUT);
  91                 STAGE_CASE(VERTEX_SHADER);
  92                 STAGE_CASE(TESSELLATION_CONTROL_SHADER);
  93                 STAGE_CASE(TESSELLATION_EVALUATION_SHADER);
  94                 STAGE_CASE(GEOMETRY_SHADER);
  95                 STAGE_CASE(FRAGMENT_SHADER);
  96                 STAGE_CASE(EARLY_FRAGMENT_TESTS);
  97                 STAGE_CASE(LATE_FRAGMENT_TESTS);
  98                 STAGE_CASE(COLOR_ATTACHMENT_OUTPUT);
  99                 STAGE_CASE(COMPUTE_SHADER);
 100                 STAGE_CASE(TRANSFER);
 101                 STAGE_CASE(HOST);
 102                 STAGE_CASE(ALL_GRAPHICS);
 103                 STAGE_CASE(ALL_COMMANDS);
 104 #undef STAGE_CASE
 105           default:
 106                 desc << "unknown stage!";
 107                 DE_FATAL("Unknown Stage!");
 108                 break;
 109         };
 110
 111         return desc.str();
 112 }
 113
 114 enum TransferMethod
 115 {
 116         TRANSFER_METHOD_COPY_BUFFER = 0,
 117         TRANSFER_METHOD_COPY_IMAGE,
 118         TRANSFER_METHOD_BLIT_IMAGE,
 119         TRANSFER_METHOD_COPY_BUFFER_TO_IMAGE,
 120         TRANSFER_METHOD_COPY_IMAGE_TO_BUFFER,
 121         TRANSFER_METHOD_UPDATE_BUFFER,
 122         TRANSFER_METHOD_FILL_BUFFER,
 123         TRANSFER_METHOD_CLEAR_COLOR_IMAGE,
 124         TRANSFER_METHOD_CLEAR_DEPTH_STENCIL_IMAGE,
 125         TRANSFER_METHOD_RESOLVE_IMAGE,
 126         TRANSFER_METHOD_COPY_QUERY_POOL_RESULTS,
 127         TRANSFER_METHOD_LAST
 128 };
 129
 130 std::string getTransferMethodStr(const TransferMethod method,
 131                                                                  bool                 isDescription)
 132 {
 133         std::ostringstream desc;
 134         std::locale loc;
 135         switch(method)
 136         {
 137 #define METHOD_CASE(p)                             \
 138                 case TRANSFER_METHOD_##p:                  \
 139                 {                                          \
 140                         GEN_DESC_STRING(p, method);            \
 141                         break;                                 \
 142                 }
 143           METHOD_CASE(COPY_BUFFER)
 144           METHOD_CASE(COPY_IMAGE)
 145           METHOD_CASE(BLIT_IMAGE)
 146           METHOD_CASE(COPY_BUFFER_TO_IMAGE)
 147           METHOD_CASE(COPY_IMAGE_TO_BUFFER)
 148           METHOD_CASE(UPDATE_BUFFER)
 149           METHOD_CASE(FILL_BUFFER)
 150           METHOD_CASE(CLEAR_COLOR_IMAGE)
 151           METHOD_CASE(CLEAR_DEPTH_STENCIL_IMAGE)
 152           METHOD_CASE(RESOLVE_IMAGE)
 153           METHOD_CASE(COPY_QUERY_POOL_RESULTS)
 154 #undef METHOD_CASE
 155           default:
 156                 desc << "unknown method!";
 157                 DE_FATAL("Unknown method!");
 158                 break;
 159         };
 160
 161         return desc.str();
 162 }
 163
 164 // helper classes
 165 class TimestampTestParam
 166 {
 167 public:
 168                                                           TimestampTestParam      (const VkPipelineStageFlagBits* stages,
 169                                                                                                            const deUint32                 stageCount,
 170                                                                                                            const bool                     inRenderPass);
 171                                                           ~TimestampTestParam     (void);
 172         virtual const std::string generateTestName        (void) const;
 173         virtual const std::string generateTestDescription (void) const;
 174         StageFlagVector           getStageVector          (void) const { return m_stageVec; }
 175         bool                      getInRenderPass         (void) const { return m_inRenderPass; }
 176         void                      toggleInRenderPass      (void)       { m_inRenderPass = !m_inRenderPass; }
 177 protected:
 178         StageFlagVector           m_stageVec;
 179         bool                      m_inRenderPass;
 180 };
 181
 182 TimestampTestParam::TimestampTestParam(const VkPipelineStageFlagBits* stages,
 183                                                                            const deUint32                 stageCount,
 184                                                                            const bool                     inRenderPass)
 185         : m_inRenderPass(inRenderPass)
 186 {
 187         for (deUint32 ndx = 0; ndx < stageCount; ndx++)
 188         {
 189                 m_stageVec.push_back(stages[ndx]);
 190         }
 191 }
 192
 193 TimestampTestParam::~TimestampTestParam(void)
 194 {
 195 }
 196
 197 const std::string TimestampTestParam::generateTestName(void) const
 198 {
 199         std::string result("");
 200
 201         for (StageFlagVector::const_iterator it = m_stageVec.begin(); it != m_stageVec.end(); it++)
 202         {
 203                 if(*it != VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT)
 204                 {
 205                         result += getPipelineStageFlagStr(*it, false) + '_';
 206                 }
 207         }
 208         if(m_inRenderPass)
 209                 result += "in_render_pass";
 210         else
 211                 result += "out_of_render_pass";
 212
 213         return result;
 214 }
 215
 216 const std::string TimestampTestParam::generateTestDescription(void) const
 217 {
 218         std::string result("Record timestamp after ");
 219
 220         for (StageFlagVector::const_iterator it = m_stageVec.begin(); it != m_stageVec.end(); it++)
 221         {
 222                 if(*it != VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT)
 223                 {
 224                         result += getPipelineStageFlagStr(*it, true) + ' ';
 225                 }
 226         }
 227         if(m_inRenderPass)
 228                 result += " in the renderpass";
 229         else
 230                 result += " out of the render pass";
 231
 232         return result;
 233 }
 234
 235 class TransferTimestampTestParam : public TimestampTestParam
 236 {
 237 public:
 238                                           TransferTimestampTestParam  (const VkPipelineStageFlagBits* stages,
 239                                                                                                    const deUint32                 stageCount,
 240                                                                                                    const bool                     inRenderPass,
 241                                                                                                    const deUint32                 methodNdx);
 242                                           ~TransferTimestampTestParam (void)       { }
 243         const std::string generateTestName            (void) const;
 244         const std::string generateTestDescription     (void) const;
 245         TransferMethod    getMethod                   (void) const { return m_method; }
 246 protected:
 247         TransferMethod    m_method;
 248 };
 249
 250 TransferTimestampTestParam::TransferTimestampTestParam(const VkPipelineStageFlagBits* stages,
 251                                                                                                            const deUint32                 stageCount,
 252                                                                                                            const bool                     inRenderPass,
 253                                                                                                            const deUint32                 methodNdx)
 254         : TimestampTestParam(stages, stageCount, inRenderPass)
 255 {
 256         DE_ASSERT(methodNdx < (deUint32)TRANSFER_METHOD_LAST);
 257
 258         m_method = (TransferMethod)methodNdx;
 259 }
 260
 261 const std::string TransferTimestampTestParam::generateTestName(void) const
 262 {
 263         std::string result("");
 264
 265         for (StageFlagVector::const_iterator it = m_stageVec.begin(); it != m_stageVec.end(); it++)
 266         {
 267                 if(*it != VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT)
 268                 {
 269                         result += getPipelineStageFlagStr(*it, false) + '_';
 270                 }
 271         }
 272
 273         result += "with_" + getTransferMethodStr(m_method, false);
 274
 275         return result;
 276
 277 }
 278
 279 const std::string TransferTimestampTestParam::generateTestDescription(void) const
 280 {
 281         std::string result("");
 282
 283         for (StageFlagVector::const_iterator it = m_stageVec.begin(); it != m_stageVec.end(); it++)
 284         {
 285                 if(*it != VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT)
 286                 {
 287                         result += getPipelineStageFlagStr(*it, true) + ' ';
 288                 }
 289         }
 290
 291         result += "with " + getTransferMethodStr(m_method, true);
 292
 293         return result;
 294
 295 }
 296
 297 class SimpleGraphicsPipelineBuilder
 298 {
 299 public:
 300                                          SimpleGraphicsPipelineBuilder  (Context&              context);
 301                                          ~SimpleGraphicsPipelineBuilder (void) { }
 302         void             bindShaderStage                (VkShaderStageFlagBits stage,
 303                                                                                                          const char*           source_name,
 304                                                                                                          const char*           entry_name);
 305         void             enableTessellationStage        (deUint32              patchControlPoints);
 306         Move<VkPipeline> buildPipeline                  (tcu::UVec2            renderSize,
 307                                                                                                          VkRenderPass          renderPass);
 308 protected:
 309         enum
 310         {
 311                 VK_MAX_SHADER_STAGES = 6,
 312         };
 313
 314         Context&                            m_context;
 315
 316         Move<VkShaderModule>                m_shaderModules[VK_MAX_SHADER_STAGES];
 317         deUint32                            m_shaderStageCount;
 318         VkPipelineShaderStageCreateInfo     m_shaderStageInfo[VK_MAX_SHADER_STAGES];
 319
 320         deUint32                            m_patchControlPoints;
 321
 322         Move<VkPipelineLayout>              m_pipelineLayout;
 323         Move<VkPipeline>                    m_graphicsPipelines;
 324
 325 };
 326
 327 SimpleGraphicsPipelineBuilder::SimpleGraphicsPipelineBuilder(Context& context)
 328         : m_context(context)
 329 {
 330         m_patchControlPoints = 0;
 331         m_shaderStageCount   = 0;
 332 }
 333
 334 void SimpleGraphicsPipelineBuilder::bindShaderStage(VkShaderStageFlagBits stage,
 335                                                                                                         const char*           source_name,
 336                                                                                                         const char*           entry_name)
 337 {
 338         const DeviceInterface&  vk        = m_context.getDeviceInterface();
 339         const VkDevice          vkDevice  = m_context.getDevice();
 340
 341         // Create shader module
 342         deUint32*               pCode     = (deUint32*)m_context.getBinaryCollection().get(source_name).getBinary();
 343         deUint32                codeSize  = (deUint32)m_context.getBinaryCollection().get(source_name).getSize();
 344
 345         const VkShaderModuleCreateInfo moduleCreateInfo =
 346         {
 347                 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,                // VkStructureType             sType;
 348                 DE_NULL,                                                    // const void*                 pNext;
 349                 0u,                                                         // VkShaderModuleCreateFlags   flags;
 350                 codeSize,                                                   // deUintptr                   codeSize;
 351                 pCode,                                                      // const deUint32*             pCode;
 352         };
 353
 354         m_shaderModules[m_shaderStageCount] = createShaderModule(vk, vkDevice, &moduleCreateInfo);
 355
 356         // Prepare shader stage info
 357         m_shaderStageInfo[m_shaderStageCount].sType               = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
 358         m_shaderStageInfo[m_shaderStageCount].pNext               = DE_NULL;
 359         m_shaderStageInfo[m_shaderStageCount].flags               = 0u;
 360         m_shaderStageInfo[m_shaderStageCount].stage               = stage;
 361         m_shaderStageInfo[m_shaderStageCount].module              = *m_shaderModules[m_shaderStageCount];
 362         m_shaderStageInfo[m_shaderStageCount].pName               = entry_name;
 363         m_shaderStageInfo[m_shaderStageCount].pSpecializationInfo = DE_NULL;
 364
 365         m_shaderStageCount++;
 366 }
 367
 368 Move<VkPipeline> SimpleGraphicsPipelineBuilder::buildPipeline(tcu::UVec2 renderSize, VkRenderPass renderPass)
 369 {
 370         const DeviceInterface&      vk                  = m_context.getDeviceInterface();
 371         const VkDevice              vkDevice            = m_context.getDevice();
 372
 373         // Create pipeline layout
 374         {
 375                 const VkPipelineLayoutCreateInfo pipelineLayoutParams =
 376                 {
 377                         VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,      // VkStructureType                  sType;
 378                         DE_NULL,                                            // const void*                      pNext;
 379                         0u,                                                 // VkPipelineLayoutCreateFlags      flags;
 380                         0u,                                                 // deUint32                         setLayoutCount;
 381                         DE_NULL,                                            // const VkDescriptorSetLayout*     pSetLayouts;
 382                         0u,                                                 // deUint32                         pushConstantRangeCount;
 383                         DE_NULL                                             // const VkPushConstantRange*       pPushConstantRanges;
 384                 };
 385
 386                 m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
 387         }
 388
 389         // Create pipeline
 390         const VkVertexInputBindingDescription vertexInputBindingDescription =
 391         {
 392                 0u,                                 // deUint32                 binding;
 393                 sizeof(Vertex4RGBA),                // deUint32                 strideInBytes;
 394                 VK_VERTEX_INPUT_RATE_VERTEX,        // VkVertexInputRate        inputRate;
 395         };
 396
 397         const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
 398         {
 399                 {
 400                         0u,                                 // deUint32 location;
 401                         0u,                                 // deUint32 binding;
 402                         VK_FORMAT_R32G32B32A32_SFLOAT,      // VkFormat format;
 403                         0u                                  // deUint32 offsetInBytes;
 404                 },
 405                 {
 406                         1u,                                 // deUint32 location;
 407                         0u,                                 // deUint32 binding;
 408                         VK_FORMAT_R32G32B32A32_SFLOAT,      // VkFormat format;
 409                         DE_OFFSET_OF(Vertex4RGBA, color),   // deUint32 offsetInBytes;
 410                 }
 411         };
 412
 413         const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
 414         {
 415                 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,      // VkStructureType                          sType;
 416                 DE_NULL,                                                        // const void*                              pNext;
 417                 0u,                                                             // VkPipelineVertexInputStateCreateFlags    flags;
 418                 1u,                                                             // deUint32                                 vertexBindingDescriptionCount;
 419                 &vertexInputBindingDescription,                                 // const VkVertexInputBindingDescription*   pVertexBindingDescriptions;
 420                 2u,                                                             // deUint32                                 vertexAttributeDescriptionCount;
 421                 vertexInputAttributeDescriptions,                               // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
 422         };
 423
 424         VkPrimitiveTopology primitiveTopology = (m_patchControlPoints > 0) ? VK_PRIMITIVE_TOPOLOGY_PATCH_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 425         const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateParams =
 426         {
 427                 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    // VkStructureType                          sType;
 428                 DE_NULL,                                                        // const void*                              pNext;
 429                 0u,                                                             // VkPipelineInputAssemblyStateCreateFlags  flags;
 430                 primitiveTopology,                                              // VkPrimitiveTopology                      topology;
 431                 VK_FALSE,                                                       // VkBool32                                 primitiveRestartEnable;
 432         };
 433
 434         const VkViewport viewport =
 435         {
 436                 0.0f,                       // float    originX;
 437                 0.0f,                       // float    originY;
 438                 (float)renderSize.x(),      // float    width;
 439                 (float)renderSize.y(),      // float    height;
 440                 0.0f,                       // float    minDepth;
 441                 1.0f                        // float    maxDepth;
 442         };
 443         const VkRect2D scissor =
 444         {
 445                 { 0u, 0u },                                                     // VkOffset2D  offset;
 446                 { renderSize.x(), renderSize.y() }                              // VkExtent2D  extent;
 447         };
 448         const VkPipelineViewportStateCreateInfo viewportStateParams =
 449         {
 450                 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,          // VkStructureType                      sType;
 451                 DE_NULL,                                                        // const void*                          pNext;
 452                 0u,                                                             // VkPipelineViewportStateCreateFlags   flags;
 453                 1u,                                                             // deUint32                             viewportCount;
 454                 &viewport,                                                      // const VkViewport*                    pViewports;
 455                 1u,                                                             // deUint32                             scissorCount;
 456                 &scissor                                                        // const VkRect2D*                      pScissors;
 457         };
 458
 459         const VkPipelineRasterizationStateCreateInfo rasterStateParams =
 460         {
 461                 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,     // VkStructureType                          sType;
 462                 DE_NULL,                                                        // const void*                              pNext;
 463                 0u,                                                             // VkPipelineRasterizationStateCreateFlags  flags;
 464                 VK_FALSE,                                                       // VkBool32                                 depthClampEnable;
 465                 VK_FALSE,                                                       // VkBool32                                 rasterizerDiscardEnable;
 466                 VK_POLYGON_MODE_FILL,                                           // VkPolygonMode                            polygonMode;
 467                 VK_CULL_MODE_NONE,                                              // VkCullModeFlags                          cullMode;
 468                 VK_FRONT_FACE_COUNTER_CLOCKWISE,                                // VkFrontFace                              frontFace;
 469                 VK_FALSE,                                                       // VkBool32                                 depthBiasEnable;
 470                 0.0f,                                                           // float                                    depthBiasConstantFactor;
 471                 0.0f,                                                           // float                                    depthBiasClamp;
 472                 0.0f,                                                           // float                                    depthBiasSlopeFactor;
 473                 1.0f,                                                           // float                                    lineWidth;
 474         };
 475
 476         const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
 477         {
 478                 VK_FALSE,                                                                   // VkBool32                 blendEnable;
 479                 VK_BLEND_FACTOR_ONE,                                                        // VkBlendFactor            srcColorBlendFactor;
 480                 VK_BLEND_FACTOR_ZERO,                                                       // VkBlendFactor            dstColorBlendFactor;
 481                 VK_BLEND_OP_ADD,                                                            // VkBlendOp                colorBlendOp;
 482                 VK_BLEND_FACTOR_ONE,                                                        // VkBlendFactor            srcAlphaBlendFactor;
 483                 VK_BLEND_FACTOR_ZERO,                                                       // VkBlendFactor            dstAlphaBlendFactor;
 484                 VK_BLEND_OP_ADD,                                                            // VkBlendOp                alphaBlendOp;
 485                 VK_COLOR_COMPONENT_R_BIT |
 486                 VK_COLOR_COMPONENT_G_BIT |
 487                 VK_COLOR_COMPONENT_B_BIT |
 488                 VK_COLOR_COMPONENT_A_BIT                                                    // VkColorComponentFlags    colorWriteMask;
 489         };
 490
 491         const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
 492         {
 493                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,   // VkStructureType                              sType;
 494                 DE_NULL,                                                    // const void*                                  pNext;
 495                 0u,                                                         // VkPipelineColorBlendStateCreateFlags         flags;
 496                 VK_FALSE,                                                   // VkBool32                                     logicOpEnable;
 497                 VK_LOGIC_OP_COPY,                                           // VkLogicOp                                    logicOp;
 498                 1u,                                                         // deUint32                                     attachmentCount;
 499                 &colorBlendAttachmentState,                                 // const VkPipelineColorBlendAttachmentState*   pAttachments;
 500                 { 0.0f, 0.0f, 0.0f, 0.0f },                                 // float                                        blendConst[4];
 501         };
 502
 503         const VkPipelineMultisampleStateCreateInfo  multisampleStateParams  =
 504         {
 505                 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,   // VkStructureType                          sType;
 506                 DE_NULL,                                                    // const void*                              pNext;
 507                 0u,                                                         // VkPipelineMultisampleStateCreateFlags    flags;
 508                 VK_SAMPLE_COUNT_1_BIT,                                      // VkSampleCountFlagBits                    rasterizationSamples;
 509                 VK_FALSE,                                                   // VkBool32                                 sampleShadingEnable;
 510                 0.0f,                                                       // float                                    minSampleShading;
 511                 DE_NULL,                                                    // const VkSampleMask*                      pSampleMask;
 512                 VK_FALSE,                                                   // VkBool32                                 alphaToCoverageEnable;
 513                 VK_FALSE,                                                   // VkBool32                                 alphaToOneEnable;
 514         };
 515
 516         VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
 517         {
 518                 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType                          sType;
 519                 DE_NULL,                                                    // const void*                              pNext;
 520                 0u,                                                         // VkPipelineDepthStencilStateCreateFlags   flags;
 521                 VK_TRUE,                                                    // VkBool32                                 depthTestEnable;
 522                 VK_TRUE,                                                    // VkBool32                                 depthWriteEnable;
 523                 VK_COMPARE_OP_LESS_OR_EQUAL,                                // VkCompareOp                              depthCompareOp;
 524                 VK_FALSE,                                                   // VkBool32                                 depthBoundsTestEnable;
 525                 VK_FALSE,                                                   // VkBool32                                 stencilTestEnable;
 526                 // VkStencilOpState front;
 527                 {
 528                         VK_STENCIL_OP_KEEP,     // VkStencilOp  failOp;
 529                         VK_STENCIL_OP_KEEP,     // VkStencilOp  passOp;
 530                         VK_STENCIL_OP_KEEP,     // VkStencilOp  depthFailOp;
 531                         VK_COMPARE_OP_NEVER,    // VkCompareOp  compareOp;
 532                         0u,                     // deUint32     compareMask;
 533                         0u,                     // deUint32     writeMask;
 534                         0u,                     // deUint32     reference;
 535                 },
 536                 // VkStencilOpState back;
 537                 {
 538                         VK_STENCIL_OP_KEEP,     // VkStencilOp  failOp;
 539                         VK_STENCIL_OP_KEEP,     // VkStencilOp  passOp;
 540                         VK_STENCIL_OP_KEEP,     // VkStencilOp  depthFailOp;
 541                         VK_COMPARE_OP_NEVER,    // VkCompareOp  compareOp;
 542                         0u,                     // deUint32     compareMask;
 543                         0u,                     // deUint32     writeMask;
 544                         0u,                     // deUint32     reference;
 545                 },
 546                 0.0f,                                                      // float                                    minDepthBounds;
 547                 1.0f,                                                      // float                                    maxDepthBounds;
 548         };
 549
 550         const VkPipelineTessellationStateCreateInfo*    pTessCreateInfo         = DE_NULL;
 551         const VkPipelineTessellationStateCreateInfo             tessStateCreateInfo     =
 552         {
 553                         VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,  // VkStructureType                          sType;
 554                         DE_NULL,                                                    // const void*                              pNext;
 555                         0u,                                                         // VkPipelineTessellationStateCreateFlags   flags;
 556                         m_patchControlPoints,                                       // deUint32                                 patchControlPoints;
 557         };
 558
 559         if (m_patchControlPoints > 0)
 560                 pTessCreateInfo = &tessStateCreateInfo;
 561
 562         const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
 563         {
 564                 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,    // VkStructureType                                  sType;
 565                 DE_NULL,                                            // const void*                                      pNext;
 566                 0u,                                                 // VkPipelineCreateFlags                            flags;
 567                 m_shaderStageCount,                                 // deUint32                                         stageCount;
 568                 m_shaderStageInfo,                                  // const VkPipelineShaderStageCreateInfo*           pStages;
 569                 &vertexInputStateParams,                            // const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
 570                 &inputAssemblyStateParams,                          // const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
 571                 pTessCreateInfo,                                    // const VkPipelineTessellationStateCreateInfo*     pTessellationState;
 572                 &viewportStateParams,                               // const VkPipelineViewportStateCreateInfo*         pViewportState;
 573                 &rasterStateParams,                                 // const VkPipelineRasterizationStateCreateInfo*    pRasterState;
 574                 &multisampleStateParams,                            // const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
 575                 &depthStencilStateParams,                           // const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
 576                 &colorBlendStateParams,                             // const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
 577                 (const VkPipelineDynamicStateCreateInfo*)DE_NULL,   // const VkPipelineDynamicStateCreateInfo*          pDynamicState;
 578                 *m_pipelineLayout,                                  // VkPipelineLayout                                 layout;
 579                 renderPass,                                         // VkRenderPass                                     renderPass;
 580                 0u,                                                 // deUint32                                         subpass;
 581                 0u,                                                 // VkPipeline                                       basePipelineHandle;
 582                 0,                                                  // deInt32                                          basePipelineIndex;
 583         };
 584
 585         return createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams);
 586 }
 587
 588 void SimpleGraphicsPipelineBuilder::enableTessellationStage(deUint32 patchControlPoints)
 589 {
 590         m_patchControlPoints = patchControlPoints;
 591 }
 592
 593 template <class Test>
 594 vkt::TestCase* newTestCase(tcu::TestContext&     testContext,
 595                                                    TimestampTestParam*   testParam)
 596 {
 597         return new Test(testContext,
 598                                         testParam->generateTestName().c_str(),
 599                                         testParam->generateTestDescription().c_str(),
 600                                         testParam);
 601 }
 602
 603 // Test Classes
 604 class TimestampTest : public vkt::TestCase
 605 {
 606 public:
 607         enum
 608         {
 609                 ENTRY_COUNT = 8
 610         };
 611
 612                                                   TimestampTest(tcu::TestContext&         testContext,
 613                                                                                 const std::string&        name,
 614                                                                                 const std::string&        description,
 615                                                                                 const TimestampTestParam* param)
 616                                                           : vkt::TestCase  (testContext, name, description)
 617                                                           , m_stages       (param->getStageVector())
 618                                                           , m_inRenderPass (param->getInRenderPass())
 619                                                           { }
 620         virtual               ~TimestampTest (void) { }
 621         virtual void          initPrograms   (SourceCollections&      programCollection) const;
 622         virtual TestInstance* createInstance (Context&                context) const;
 623 protected:
 624         const StageFlagVector m_stages;
 625         const bool            m_inRenderPass;
 626 };
 627
 628 class TimestampTestInstance : public vkt::TestInstance
 629 {
 630 public:
 631                                                         TimestampTestInstance      (Context&                 context,
 632                                                                                                                 const StageFlagVector&   stages,
 633                                                                                                                 const bool               inRenderPass);
 634         virtual                 ~TimestampTestInstance     (void);
 635         virtual tcu::TestStatus iterate                    (void);
 636 protected:
 637         virtual tcu::TestStatus verifyTimestamp            (void);
 638         virtual void            configCommandBuffer        (void);
 639         Move<VkBuffer>          createBufferAndBindMemory  (VkDeviceSize             size,
 640                                                                                                                 VkBufferUsageFlags       usage,
 641                                                                                                                 de::MovePtr<Allocation>* pAlloc);
 642         Move<VkImage>           createImage2DAndBindMemory (VkFormat                 format,
 643                                                                                                                 deUint32                 width,
 644                                                                                                                 deUint32                 height,
 645                                                                                                                 VkImageUsageFlags        usage,
 646                                                                                                                 VkSampleCountFlagBits    sampleCount,
 647                                                                                                                 de::MovePtr<Allocation>* pAlloc);
 648 protected:
 649         const StageFlagVector   m_stages;
 650         bool                    m_inRenderPass;
 651
 652         Move<VkCommandPool>     m_cmdPool;
 653         Move<VkCommandBuffer>   m_cmdBuffer;
 654         Move<VkFence>           m_fence;
 655         Move<VkQueryPool>       m_queryPool;
 656         deUint64*               m_timestampValues;
 657 };
 658
 659 void TimestampTest::initPrograms(SourceCollections& programCollection) const
 660 {
 661         vkt::TestCase::initPrograms(programCollection);
 662 }
 663
 664 TestInstance* TimestampTest::createInstance(Context& context) const
 665 {
 666         return new TimestampTestInstance(context,m_stages,m_inRenderPass);
 667 }
 668
 669 TimestampTestInstance::TimestampTestInstance(Context&                context,
 670                                                                                          const StageFlagVector&  stages,
 671                                                                                          const bool              inRenderPass)
 672         : TestInstance  (context)
 673         , m_stages      (stages)
 674         , m_inRenderPass(inRenderPass)
 675 {
 676         const DeviceInterface&      vk                  = context.getDeviceInterface();
 677         const VkDevice              vkDevice            = context.getDevice();
 678         const deUint32              queueFamilyIndex    = context.getUniversalQueueFamilyIndex();
 679
 680         // Check support for timestamp queries
 681         {
 682                 const std::vector<VkQueueFamilyProperties>   queueProperties = vk::getPhysicalDeviceQueueFamilyProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice());
 683
 684                 DE_ASSERT(queueFamilyIndex < (deUint32)queueProperties.size());
 685
 686                 if (!queueProperties[queueFamilyIndex].timestampValidBits)
 687                         throw tcu::NotSupportedError("Universal queue does not support timestamps");
 688         }
 689
 690         // Create Query Pool
 691         {
 692                 const VkQueryPoolCreateInfo queryPoolParams =
 693                 {
 694                    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,    // VkStructureType               sType;
 695                    DE_NULL,                                     // const void*                   pNext;
 696                    0u,                                          // VkQueryPoolCreateFlags        flags;
 697                    VK_QUERY_TYPE_TIMESTAMP,                     // VkQueryType                   queryType;
 698                    TimestampTest::ENTRY_COUNT,                  // deUint32                      entryCount;
 699                    0u,                                          // VkQueryPipelineStatisticFlags pipelineStatistics;
 700                 };
 701
 702                 m_queryPool = createQueryPool(vk, vkDevice, &queryPoolParams);
 703         }
 704
 705         // Create command pool
 706         m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
 707
 708         // Create command buffer
 709         m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 710
 711         // Create fence
 712         {
 713                 const VkFenceCreateInfo fenceParams =
 714                 {
 715                         VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,        // VkStructureType      sType;
 716                         DE_NULL,                                    // const void*          pNext;
 717                         0u,                                         // VkFenceCreateFlags   flags;
 718                 };
 719
 720                 m_fence = createFence(vk, vkDevice, &fenceParams);
 721         }
 722
 723         // alloc timestamp values
 724         m_timestampValues = new deUint64[m_stages.size()];
 725 }
 726
 727 TimestampTestInstance::~TimestampTestInstance(void)
 728 {
 729         if(m_timestampValues)
 730         {
 731                 delete[] m_timestampValues;
 732                 m_timestampValues = NULL;
 733         }
 734 }
 735
 736 void TimestampTestInstance::configCommandBuffer(void)
 737 {
 738         const DeviceInterface&      vk                  = m_context.getDeviceInterface();
 739
 740         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
 741         {
 742                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                  sType;
 743                 DE_NULL,                                        // const void*                      pNext;
 744                 0u,                                             // VkCommandBufferUsageFlags        flags;
 745                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
 746         };
 747
 748         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
 749
 750         vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, TimestampTest::ENTRY_COUNT);
 751
 752         deUint32 timestampEntry = 0;
 753         for (StageFlagVector::const_iterator it = m_stages.begin(); it != m_stages.end(); it++)
 754         {
 755                 vk.cmdWriteTimestamp(*m_cmdBuffer, *it, *m_queryPool, timestampEntry++);
 756         }
 757
 758         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
 759 }
 760
 761 tcu::TestStatus TimestampTestInstance::iterate(void)
 762 {
 763         const DeviceInterface&      vk          = m_context.getDeviceInterface();
 764         const VkDevice              vkDevice    = m_context.getDevice();
 765         const VkQueue               queue       = m_context.getUniversalQueue();
 766
 767         configCommandBuffer();
 768
 769         VK_CHECK(vk.resetFences(vkDevice, 1u, &m_fence.get()));
 770
 771         const VkSubmitInfo          submitInfo =
 772         {
 773                 VK_STRUCTURE_TYPE_SUBMIT_INFO,                      // VkStructureType         sType;
 774                 DE_NULL,                                            // const void*             pNext;
 775                 0u,                                                 // deUint32                waitSemaphoreCount;
 776                 DE_NULL,                                            // const VkSemaphore*      pWaitSemaphores;
 777                 (const VkPipelineStageFlags*)DE_NULL,
 778                 1u,                                                 // deUint32                commandBufferCount;
 779                 &m_cmdBuffer.get(),                                 // const VkCommandBuffer*  pCommandBuffers;
 780                 0u,                                                 // deUint32                signalSemaphoreCount;
 781                 DE_NULL,                                            // const VkSemaphore*      pSignalSemaphores;
 782         };
 783         VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *m_fence));
 784
 785         VK_CHECK(vk.waitForFences(vkDevice, 1u, &m_fence.get(), true, ~(0ull) /* infinity*/));
 786
 787         // Generate the timestamp mask
 788         deUint64                    timestampMask;
 789         const std::vector<VkQueueFamilyProperties>   queueProperties = vk::getPhysicalDeviceQueueFamilyProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice());
 790         if(queueProperties[0].timestampValidBits == 0)
 791         {
 792                 return tcu::TestStatus::fail("Device does not support timestamp!");
 793         }
 794         else if(queueProperties[0].timestampValidBits == 64)
 795         {
 796                 timestampMask = 0xFFFFFFFFFFFFFFFF;
 797         }
 798         else
 799         {
 800                 timestampMask = ((deUint64)1 << queueProperties[0].timestampValidBits) - 1;
 801         }
 802
 803         // Get timestamp value from query pool
 804         deUint32                    stageSize = (deUint32)m_stages.size();
 805
 806         vk.getQueryPoolResults(vkDevice, *m_queryPool, 0u, stageSize, sizeof(deUint64) * stageSize, (void*)m_timestampValues, sizeof(deUint64), VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
 807
 808         for (deUint32 ndx = 0; ndx < stageSize; ndx++)
 809         {
 810                 m_timestampValues[ndx] &= timestampMask;
 811         }
 812
 813         return verifyTimestamp();
 814 }
 815
 816 tcu::TestStatus TimestampTestInstance::verifyTimestamp(void)
 817 {
 818         for (deUint32 first = 0; first < m_stages.size(); first++)
 819         {
 820                 for (deUint32 second = 0; second < first; second++)
 821                 {
 822                         if(m_timestampValues[first] < m_timestampValues[second])
 823                         {
 824                                 return tcu::TestStatus::fail("Latter stage timestamp is smaller than the former stage timestamp.");
 825                         }
 826                 }
 827         }
 828
 829         return tcu::TestStatus::pass("Timestamp increases steadily.");
 830 }
 831
 832 Move<VkBuffer> TimestampTestInstance::createBufferAndBindMemory(VkDeviceSize size, VkBufferUsageFlags usage, de::MovePtr<Allocation>* pAlloc)
 833 {
 834         const DeviceInterface&      vk                  = m_context.getDeviceInterface();
 835         const VkDevice              vkDevice            = m_context.getDevice();
 836         const deUint32              queueFamilyIndex    = m_context.getUniversalQueueFamilyIndex();
 837         SimpleAllocator             memAlloc            (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
 838
 839         const VkBufferCreateInfo vertexBufferParams =
 840         {
 841                 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,       // VkStructureType      sType;
 842                 DE_NULL,                                    // const void*          pNext;
 843                 0u,                                         // VkBufferCreateFlags  flags;
 844                 size,                                       // VkDeviceSize         size;
 845                 usage,                                      // VkBufferUsageFlags   usage;
 846                 VK_SHARING_MODE_EXCLUSIVE,                  // VkSharingMode        sharingMode;
 847                 1u,                                         // deUint32             queueFamilyCount;
 848                 &queueFamilyIndex                           // const deUint32*      pQueueFamilyIndices;
 849         };
 850
 851         Move<VkBuffer> vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);
 852         de::MovePtr<Allocation> vertexBufferAlloc = memAlloc.allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible);
 853
 854         VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, vertexBufferAlloc->getMemory(), vertexBufferAlloc->getOffset()));
 855
 856         DE_ASSERT(pAlloc);
 857         *pAlloc = vertexBufferAlloc;
 858
 859         return vertexBuffer;
 860 }
 861
 862 Move<VkImage> TimestampTestInstance::createImage2DAndBindMemory(VkFormat                          format,
 863                                                                                                                                 deUint32                          width,
 864                                                                                                                                 deUint32                          height,
 865                                                                                                                                 VkImageUsageFlags                 usage,
 866                                                                                                                                 VkSampleCountFlagBits             sampleCount,
 867                                                                                                                                 de::details::MovePtr<Allocation>* pAlloc)
 868 {
 869         const DeviceInterface&      vk                  = m_context.getDeviceInterface();
 870         const VkDevice              vkDevice            = m_context.getDevice();
 871         const deUint32              queueFamilyIndex    = m_context.getUniversalQueueFamilyIndex();
 872         SimpleAllocator             memAlloc            (vk, vkDevice, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));
 873
 874         // Optimal tiling feature check
 875         VkFormatProperties          formatProperty;
 876         m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), format, &formatProperty);
 877         if((usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) && !(formatProperty.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
 878         {
 879                 // Remove color attachment usage if the optimal tiling feature does not support it
 880                 usage &= ~VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 881         }
 882         if((usage & VK_IMAGE_USAGE_STORAGE_BIT) && !(formatProperty.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT))
 883         {
 884                 // Remove storage usage if the optimal tiling feature does not support it
 885                 usage &= ~VK_IMAGE_USAGE_STORAGE_BIT;
 886         }
 887
 888         const VkImageCreateInfo colorImageParams =
 889         {
 890                 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,                                        // VkStructureType      sType;
 891                 DE_NULL,                                                                    // const void*          pNext;
 892                 0u,                                                                         // VkImageCreateFlags   flags;
 893                 VK_IMAGE_TYPE_2D,                                                           // VkImageType          imageType;
 894                 format,                                                                     // VkFormat             format;
 895                 { width, height, 1u },                                                      // VkExtent3D           extent;
 896                 1u,                                                                         // deUint32             mipLevels;
 897                 1u,                                                                         // deUint32             arraySize;
 898                 sampleCount,                                                                // deUint32             samples;
 899                 VK_IMAGE_TILING_OPTIMAL,                                                    // VkImageTiling        tiling;
 900                 usage,                                                                      // VkImageUsageFlags    usage;
 901                 VK_SHARING_MODE_EXCLUSIVE,                                                  // VkSharingMode        sharingMode;
 902                 1u,                                                                         // deUint32             queueFamilyCount;
 903                 &queueFamilyIndex,                                                          // const deUint32*      pQueueFamilyIndices;
 904                 VK_IMAGE_LAYOUT_UNDEFINED,                                                  // VkImageLayout        initialLayout;
 905         };
 906
 907         Move<VkImage> image = createImage(vk, vkDevice, &colorImageParams);
 908
 909         // Allocate and bind image memory
 910         de::MovePtr<Allocation> colorImageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any);
 911         VK_CHECK(vk.bindImageMemory(vkDevice, *image, colorImageAlloc->getMemory(), colorImageAlloc->getOffset()));
 912
 913         DE_ASSERT(pAlloc);
 914         *pAlloc = colorImageAlloc;
 915
 916         return image;
 917 }
 918
 919 class BasicGraphicsTest : public TimestampTest
 920 {
 921 public:
 922                                                   BasicGraphicsTest(tcu::TestContext&         testContext,
 923                                                                                         const std::string&        name,
 924                                                                                         const std::string&        description,
 925                                                                                         const TimestampTestParam* param)
 926                                                           : TimestampTest (testContext, name, description, param)
 927                                                           { }
 928         virtual               ~BasicGraphicsTest (void) { }
 929         virtual void          initPrograms       (SourceCollections&      programCollection) const;
 930         virtual TestInstance* createInstance     (Context&                context) const;
 931 };
 932
 933 class BasicGraphicsTestInstance : public TimestampTestInstance
 934 {
 935 public:
 936         enum
 937         {
 938                 VK_MAX_SHADER_STAGES = 6,
 939         };
 940                                  BasicGraphicsTestInstance  (Context&              context,
 941                                                                                          const StageFlagVector stages,
 942                                                                                          const bool            inRenderPass);
 943         virtual      ~BasicGraphicsTestInstance (void);
 944 protected:
 945         virtual void configCommandBuffer        (void);
 946         virtual void buildVertexBuffer          (void);
 947         virtual void buildRenderPass            (VkFormat colorFormat,
 948                                                                                          VkFormat depthFormat);
 949         virtual void buildFrameBuffer           (tcu::UVec2 renderSize,
 950                                                                                          VkFormat colorFormat,
 951                                                                                          VkFormat depthFormat);
 952 protected:
 953         const tcu::UVec2                    m_renderSize;
 954         const VkFormat                      m_colorFormat;
 955         const VkFormat                      m_depthFormat;
 956
 957         Move<VkImage>                       m_colorImage;
 958         de::MovePtr<Allocation>             m_colorImageAlloc;
 959         Move<VkImage>                       m_depthImage;
 960         de::MovePtr<Allocation>             m_depthImageAlloc;
 961         Move<VkImageView>                   m_colorAttachmentView;
 962         Move<VkImageView>                   m_depthAttachmentView;
 963         Move<VkRenderPass>                  m_renderPass;
 964         Move<VkFramebuffer>                 m_framebuffer;
 965         VkImageMemoryBarrier                            m_imageLayoutBarriers[2];
 966
 967         de::MovePtr<Allocation>             m_vertexBufferAlloc;
 968         Move<VkBuffer>                      m_vertexBuffer;
 969         std::vector<Vertex4RGBA>            m_vertices;
 970
 971         SimpleGraphicsPipelineBuilder       m_pipelineBuilder;
 972         Move<VkPipeline>                    m_graphicsPipelines;
 973 };
 974
 975 void BasicGraphicsTest::initPrograms (SourceCollections& programCollection) const
 976 {
 977         programCollection.glslSources.add("color_vert") << glu::VertexSource(
 978                 "#version 310 es\n"
 979                 "layout(location = 0) in vec4 position;\n"
 980                 "layout(location = 1) in vec4 color;\n"
 981                 "layout(location = 0) out highp vec4 vtxColor;\n"
 982                 "void main (void)\n"
 983                 "{\n"
 984                 "  gl_Position = position;\n"
 985                 "  vtxColor = color;\n"
 986                 "}\n");
 987
 988         programCollection.glslSources.add("color_frag") << glu::FragmentSource(
 989                 "#version 310 es\n"
 990                 "layout(location = 0) in highp vec4 vtxColor;\n"
 991                 "layout(location = 0) out highp vec4 fragColor;\n"
 992                 "void main (void)\n"
 993                 "{\n"
 994                 "  fragColor = vtxColor;\n"
 995                 "}\n");
 996 }
 997
 998 TestInstance* BasicGraphicsTest::createInstance(Context& context) const
 999 {
1000         return new BasicGraphicsTestInstance(context,m_stages,m_inRenderPass);
1001 }
1002
1003 void BasicGraphicsTestInstance::buildVertexBuffer(void)
1004 {
1005         const DeviceInterface&      vk       = m_context.getDeviceInterface();
1006         const VkDevice              vkDevice = m_context.getDevice();
1007
1008         // Create vertex buffer
1009         {
1010                 m_vertexBuffer = createBufferAndBindMemory(1024u, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, &m_vertexBufferAlloc);
1011
1012                 m_vertices          = createOverlappingQuads();
1013                 // Load vertices into vertex buffer
1014                 deMemcpy(m_vertexBufferAlloc->getHostPtr(), m_vertices.data(), m_vertices.size() * sizeof(Vertex4RGBA));
1015                 flushMappedMemoryRange(vk, vkDevice, m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset(), 1024u);
1016         }
1017 }
1018
1019 void BasicGraphicsTestInstance::buildRenderPass(VkFormat colorFormat, VkFormat depthFormat)
1020 {
1021         const DeviceInterface&      vk       = m_context.getDeviceInterface();
1022         const VkDevice              vkDevice = m_context.getDevice();
1023
1024         // Create render pass
1025         {
1026                 const VkAttachmentDescription colorAttachmentDescription =
1027                 {
1028                         0u,                                                 // VkAttachmentDescriptionFlags    flags;
1029                         colorFormat,                                        // VkFormat                        format;
1030                         VK_SAMPLE_COUNT_1_BIT,                              // VkSampleCountFlagBits           samples;
1031                         VK_ATTACHMENT_LOAD_OP_CLEAR,                        // VkAttachmentLoadOp              loadOp;
1032                         VK_ATTACHMENT_STORE_OP_STORE,                       // VkAttachmentStoreOp             storeOp;
1033                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,                    // VkAttachmentLoadOp              stencilLoadOp;
1034                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                   // VkAttachmentStoreOp             stencilStoreOp;
1035                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,           // VkImageLayout                   initialLayout;
1036                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,           // VkImageLayout                   finalLayout;
1037                 };
1038
1039                 const VkAttachmentDescription depthAttachmentDescription =
1040                 {
1041                         0u,                                                 // VkAttachmentDescriptionFlags flags;
1042                         depthFormat,                                        // VkFormat                     format;
1043                         VK_SAMPLE_COUNT_1_BIT,                              // VkSampleCountFlagBits        samples;
1044                         VK_ATTACHMENT_LOAD_OP_CLEAR,                        // VkAttachmentLoadOp           loadOp;
1045                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                   // VkAttachmentStoreOp          storeOp;
1046                         VK_ATTACHMENT_LOAD_OP_DONT_CARE,                    // VkAttachmentLoadOp           stencilLoadOp;
1047                         VK_ATTACHMENT_STORE_OP_DONT_CARE,                   // VkAttachmentStoreOp          stencilStoreOp;
1048                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,   // VkImageLayout                initialLayout;
1049                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,   // VkImageLayout                finalLayout;
1050                 };
1051
1052                 const VkAttachmentDescription attachments[2] =
1053                 {
1054                         colorAttachmentDescription,
1055                         depthAttachmentDescription
1056                 };
1057
1058                 const VkAttachmentReference colorAttachmentReference =
1059                 {
1060                         0u,                                                 // deUint32         attachment;
1061                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL            // VkImageLayout    layout;
1062                 };
1063
1064                 const VkAttachmentReference depthAttachmentReference =
1065                 {
1066                         1u,                                                 // deUint32         attachment;
1067                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL    // VkImageLayout    layout;
1068                 };
1069
1070                 const VkSubpassDescription subpassDescription =
1071                 {
1072                         0u,                                                 // VkSubpassDescriptionFlags        flags;
1073                         VK_PIPELINE_BIND_POINT_GRAPHICS,                    // VkPipelineBindPoint              pipelineBindPoint;
1074                         0u,                                                 // deUint32                         inputAttachmentCount;
1075                         DE_NULL,                                            // const VkAttachmentReference*     pInputAttachments;
1076                         1u,                                                 // deUint32                         colorAttachmentCount;
1077                         &colorAttachmentReference,                          // const VkAttachmentReference*     pColorAttachments;
1078                         DE_NULL,                                            // const VkAttachmentReference*     pResolveAttachments;
1079                         &depthAttachmentReference,                          // const VkAttachmentReference*     pDepthStencilAttachment;
1080                         0u,                                                 // deUint32                         preserveAttachmentCount;
1081                         DE_NULL                                             // const VkAttachmentReference*     pPreserveAttachments;
1082                 };
1083
1084                 const VkRenderPassCreateInfo renderPassParams =
1085                 {
1086                         VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,          // VkStructureType                  sType;
1087                         DE_NULL,                                            // const void*                      pNext;
1088                         0u,                                                 // VkRenderPassCreateFlags          flags;
1089                         2u,                                                 // deUint32                         attachmentCount;
1090                         attachments,                                        // const VkAttachmentDescription*   pAttachments;
1091                         1u,                                                 // deUint32                         subpassCount;
1092                         &subpassDescription,                                // const VkSubpassDescription*      pSubpasses;
1093                         0u,                                                 // deUint32                         dependencyCount;
1094                         DE_NULL                                             // const VkSubpassDependency*       pDependencies;
1095                 };
1096
1097                 m_renderPass = createRenderPass(vk, vkDevice, &renderPassParams);
1098         }
1099
1100 }
1101
1102 void BasicGraphicsTestInstance::buildFrameBuffer(tcu::UVec2 renderSize, VkFormat colorFormat, VkFormat depthFormat)
1103 {
1104         const DeviceInterface&      vk                   = m_context.getDeviceInterface();
1105         const VkDevice              vkDevice             = m_context.getDevice();
1106         const VkComponentMapping    ComponentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A};
1107
1108         // Create color image
1109         {
1110                 m_colorImage = createImage2DAndBindMemory(colorFormat,
1111                                                                                                   renderSize.x(),
1112                                                                                                   renderSize.y(),
1113                                                                                                   VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
1114                                                                                                   VK_SAMPLE_COUNT_1_BIT,
1115                                                                                                   &m_colorImageAlloc);
1116         }
1117
1118         // Create depth image
1119         {
1120                 m_depthImage = createImage2DAndBindMemory(depthFormat,
1121                                                                                                   renderSize.x(),
1122                                                                                                   renderSize.y(),
1123                                                                                                   VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1124                                                                                                   VK_SAMPLE_COUNT_1_BIT,
1125                                                                                                   &m_depthImageAlloc);
1126         }
1127
1128         // Set up image layout transition barriers
1129         {
1130                 const VkImageMemoryBarrier colorImageBarrier =
1131                 {
1132                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType                      sType;
1133                         DE_NULL,                                                                                        // const void*                          pNext;
1134                         0u,                                                                                                     // VkAccessFlags                        srcAccessMask;
1135                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
1136                         VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                        oldLayout;
1137                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,                       // VkImageLayout                        newLayout;
1138                         VK_QUEUE_FAMILY_IGNORED,                                                        // deUint32                                     srcQueueFamilyIndex;
1139                         VK_QUEUE_FAMILY_IGNORED,                                                        // deUint32                                     dstQueueFamilyIndex;
1140                         *m_colorImage,                                                                          // VkImage                                      image;
1141                         { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u },          // VkImageSubresourceRange      subresourceRange;
1142                 };
1143                 const VkImageMemoryBarrier depthImageBarrier =
1144                 {
1145                         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,                         // VkStructureType                      sType;
1146                         DE_NULL,                                                                                        // const void*                          pNext;
1147                         0u,                                                                                                     // VkAccessFlags                        srcAccessMask;
1148                         VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                        dstAccessMask;
1149                         VK_IMAGE_LAYOUT_UNDEFINED,                                                      // VkImageLayout                        oldLayout;
1150                         VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,       // VkImageLayout                        newLayout;
1151                         VK_QUEUE_FAMILY_IGNORED,                                                        // deUint32                                     srcQueueFamilyIndex;
1152                         VK_QUEUE_FAMILY_IGNORED,                                                        // deUint32                                     dstQueueFamilyIndex;
1153                         *m_depthImage,                                                                          // VkImage                                      image;
1154                         { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u },          // VkImageSubresourceRange      subresourceRange;
1155                 };
1156
1157                 m_imageLayoutBarriers[0] = colorImageBarrier;
1158                 m_imageLayoutBarriers[1] = depthImageBarrier;
1159         }
1160
1161         // Create color attachment view
1162         {
1163                 const VkImageViewCreateInfo colorAttachmentViewParams =
1164                 {
1165                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType          sType;
1166                         DE_NULL,                                        // const void*              pNext;
1167                         0u,                                             // VkImageViewCreateFlags   flags;
1168                         *m_colorImage,                                  // VkImage                  image;
1169                         VK_IMAGE_VIEW_TYPE_2D,                          // VkImageViewType          viewType;
1170                         colorFormat,                                    // VkFormat                 format;
1171                         ComponentMappingRGBA,                           // VkComponentMapping       components;
1172                         { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u },  // VkImageSubresourceRange  subresourceRange;
1173                 };
1174
1175                 m_colorAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams);
1176         }
1177
1178         // Create depth attachment view
1179         {
1180                 const VkImageViewCreateInfo depthAttachmentViewParams =
1181                 {
1182                         VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,       // VkStructureType          sType;
1183                         DE_NULL,                                        // const void*              pNext;
1184                         0u,                                             // VkImageViewCreateFlags   flags;
1185                         *m_depthImage,                                  // VkImage                  image;
1186                         VK_IMAGE_VIEW_TYPE_2D,                          // VkImageViewType          viewType;
1187                         depthFormat,                                    // VkFormat                 format;
1188                         ComponentMappingRGBA,                           // VkComponentMapping       components;
1189                         { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 1u, 0u, 1u },  // VkImageSubresourceRange  subresourceRange;
1190                 };
1191
1192                 m_depthAttachmentView = createImageView(vk, vkDevice, &depthAttachmentViewParams);
1193         }
1194
1195         // Create framebuffer
1196         {
1197                 const VkImageView attachmentBindInfos[2] =
1198                 {
1199                         *m_colorAttachmentView,
1200                         *m_depthAttachmentView,
1201                 };
1202
1203                 const VkFramebufferCreateInfo framebufferParams =
1204                 {
1205                         VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,          // VkStructureType              sType;
1206                         DE_NULL,                                            // const void*                  pNext;
1207                         0u,                                                 // VkFramebufferCreateFlags     flags;
1208                         *m_renderPass,                                      // VkRenderPass                 renderPass;
1209                         2u,                                                 // deUint32                     attachmentCount;
1210                         attachmentBindInfos,                                // const VkImageView*           pAttachments;
1211                         (deUint32)renderSize.x(),                           // deUint32                     width;
1212                         (deUint32)renderSize.y(),                           // deUint32                     height;
1213                         1u,                                                 // deUint32                     layers;
1214                 };
1215
1216                 m_framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams);
1217         }
1218
1219 }
1220
1221 BasicGraphicsTestInstance::BasicGraphicsTestInstance(Context&              context,
1222                                                                                                          const StageFlagVector stages,
1223                                                                                                          const bool            inRenderPass)
1224                                                                                                          : TimestampTestInstance (context,stages,inRenderPass)
1225                                                                                                          , m_renderSize  (32, 32)
1226                                                                                                          , m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
1227                                                                                                          , m_depthFormat (VK_FORMAT_D16_UNORM)
1228                                                                                                          , m_pipelineBuilder (context)
1229 {
1230         buildVertexBuffer();
1231
1232         buildRenderPass(m_colorFormat, m_depthFormat);
1233
1234         buildFrameBuffer(m_renderSize, m_colorFormat, m_depthFormat);
1235
1236         m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_VERTEX_BIT, "color_vert", "main");
1237         m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_FRAGMENT_BIT, "color_frag", "main");
1238
1239         m_graphicsPipelines = m_pipelineBuilder.buildPipeline(m_renderSize, *m_renderPass);
1240
1241 }
1242
1243 BasicGraphicsTestInstance::~BasicGraphicsTestInstance(void)
1244 {
1245 }
1246
1247 void BasicGraphicsTestInstance::configCommandBuffer(void)
1248 {
1249         const DeviceInterface&      vk                  = m_context.getDeviceInterface();
1250
1251         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1252         {
1253                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                  sType;
1254                 DE_NULL,                                        // const void*                      pNext;
1255                 0u,                                             // VkCommandBufferUsageFlags        flags;
1256                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1257         };
1258
1259         const VkClearValue attachmentClearValues[2] =
1260         {
1261                 defaultClearValue(m_colorFormat),
1262                 defaultClearValue(m_depthFormat),
1263         };
1264
1265         const VkRenderPassBeginInfo renderPassBeginInfo =
1266         {
1267                 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,               // VkStructureType      sType;
1268                 DE_NULL,                                                // const void*          pNext;
1269                 *m_renderPass,                                          // VkRenderPass         renderPass;
1270                 *m_framebuffer,                                         // VkFramebuffer        framebuffer;
1271                 { { 0u, 0u }, { m_renderSize.x(), m_renderSize.y() } }, // VkRect2D             renderArea;
1272                 2u,                                                     // deUint32             clearValueCount;
1273                 attachmentClearValues                                   // const VkClearValue*  pClearValues;
1274         };
1275
1276         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1277
1278         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0,
1279                 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(m_imageLayoutBarriers), m_imageLayoutBarriers);
1280
1281         vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, TimestampTest::ENTRY_COUNT);
1282
1283         vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
1284
1285         vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipelines);
1286         VkDeviceSize offsets = 0u;
1287         vk.cmdBindVertexBuffers(*m_cmdBuffer, 0u, 1u, &m_vertexBuffer.get(), &offsets);
1288         vk.cmdDraw(*m_cmdBuffer, (deUint32)m_vertices.size(), 1u, 0u, 0u);
1289
1290         if(m_inRenderPass)
1291         {
1292           deUint32 timestampEntry = 0u;
1293           for (StageFlagVector::const_iterator it = m_stages.begin(); it != m_stages.end(); it++)
1294           {
1295                   vk.cmdWriteTimestamp(*m_cmdBuffer, *it, *m_queryPool, timestampEntry++);
1296           }
1297         }
1298
1299         vk.cmdEndRenderPass(*m_cmdBuffer);
1300
1301         if(!m_inRenderPass)
1302         {
1303           deUint32 timestampEntry = 0u;
1304           for (StageFlagVector::const_iterator it = m_stages.begin(); it != m_stages.end(); it++)
1305           {
1306                   vk.cmdWriteTimestamp(*m_cmdBuffer, *it, *m_queryPool, timestampEntry++);
1307           }
1308         }
1309
1310         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1311 }
1312
1313 class AdvGraphicsTest : public BasicGraphicsTest
1314 {
1315 public:
1316                                                   AdvGraphicsTest  (tcu::TestContext&         testContext,
1317                                                                                         const std::string&        name,
1318                                                                                         const std::string&        description,
1319                                                                                         const TimestampTestParam* param)
1320                                                           : BasicGraphicsTest(testContext, name, description, param)
1321                                                           { }
1322         virtual               ~AdvGraphicsTest (void) { }
1323         virtual void          initPrograms     (SourceCollections&        programCollection) const;
1324         virtual TestInstance* createInstance   (Context&                  context) const;
1325 };
1326
1327 class AdvGraphicsTestInstance : public BasicGraphicsTestInstance
1328 {
1329 public:
1330                                  AdvGraphicsTestInstance  (Context&              context,
1331                                                                                    const StageFlagVector stages,
1332                                                                                    const bool            inRenderPass);
1333         virtual      ~AdvGraphicsTestInstance (void);
1334         virtual void configCommandBuffer      (void);
1335 protected:
1336         virtual void featureSupportCheck      (void);
1337 protected:
1338         VkPhysicalDeviceFeatures m_features;
1339         deUint32                 m_draw_count;
1340         de::MovePtr<Allocation>  m_indirectBufferAlloc;
1341         Move<VkBuffer>           m_indirectBuffer;
1342 };
1343
1344 void AdvGraphicsTest::initPrograms(SourceCollections& programCollection) const
1345 {
1346         BasicGraphicsTest::initPrograms(programCollection);
1347
1348         programCollection.glslSources.add("dummy_geo") << glu::GeometrySource(
1349                 "#version 310 es\n"
1350                 "#extension GL_EXT_geometry_shader : enable\n"
1351                 "layout(triangles) in;\n"
1352                 "layout(triangle_strip, max_vertices = 3) out;\n"
1353                 "layout(location = 0) in highp vec4 in_vtxColor[];\n"
1354                 "layout(location = 0) out highp vec4 vtxColor;\n"
1355                 "void main (void)\n"
1356                 "{\n"
1357                 "  for(int ndx=0; ndx<3; ndx++)\n"
1358                 "  {\n"
1359                 "    gl_Position = gl_in[ndx].gl_Position;\n"
1360                 "    vtxColor    = in_vtxColor[ndx];\n"
1361                 "    EmitVertex();\n"
1362                 "  }\n"
1363                 "  EndPrimitive();\n"
1364                 "}\n");
1365
1366         programCollection.glslSources.add("basic_tcs") << glu::TessellationControlSource(
1367                 "#version 310 es\n"
1368                 "#extension GL_EXT_tessellation_shader : enable\n"
1369                 "layout(vertices = 3) out;\n"
1370                 "layout(location = 0) in highp vec4 color[];\n"
1371                 "layout(location = 0) out highp vec4 vtxColor[];\n"
1372                 "void main()\n"
1373                 "{\n"
1374                 "  gl_TessLevelOuter[0] = 4.0;\n"
1375                 "  gl_TessLevelOuter[1] = 4.0;\n"
1376                 "  gl_TessLevelOuter[2] = 4.0;\n"
1377                 "  gl_TessLevelInner[0] = 4.0;\n"
1378                 "  gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
1379                 "  vtxColor[gl_InvocationID] = color[gl_InvocationID];\n"
1380                 "}\n");
1381
1382         programCollection.glslSources.add("basic_tes") << glu::TessellationEvaluationSource(
1383                 "#version 310 es\n"
1384                 "#extension GL_EXT_tessellation_shader : enable\n"
1385                 "layout(triangles, fractional_even_spacing, ccw) in;\n"
1386                 "layout(location = 0) in highp vec4 colors[];\n"
1387                 "layout(location = 0) out highp vec4 vtxColor;\n"
1388                 "void main() \n"
1389                 "{\n"
1390                 "  float u = gl_TessCoord.x;\n"
1391                 "  float v = gl_TessCoord.y;\n"
1392                 "  float w = gl_TessCoord.z;\n"
1393                 "  vec4 pos = vec4(0);\n"
1394                 "  vec4 color = vec4(0);\n"
1395                 "  pos.xyz += u * gl_in[0].gl_Position.xyz;\n"
1396                 "  color.xyz += u * colors[0].xyz;\n"
1397                 "  pos.xyz += v * gl_in[1].gl_Position.xyz;\n"
1398                 "  color.xyz += v * colors[1].xyz;\n"
1399                 "  pos.xyz += w * gl_in[2].gl_Position.xyz;\n"
1400                 "  color.xyz += w * colors[2].xyz;\n"
1401                 "  pos.w = 1.0;\n"
1402                 "  color.w = 1.0;\n"
1403                 "  gl_Position = pos;\n"
1404                 "  vtxColor = color;\n"
1405                 "}\n");
1406 }
1407
1408 TestInstance* AdvGraphicsTest::createInstance(Context& context) const
1409 {
1410         return new AdvGraphicsTestInstance(context,m_stages,m_inRenderPass);
1411 }
1412
1413 void AdvGraphicsTestInstance::featureSupportCheck(void)
1414 {
1415         for (StageFlagVector::const_iterator it = m_stages.begin(); it != m_stages.end(); it++)
1416         {
1417                 switch(*it)
1418                 {
1419                         case VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT:
1420                                 if (m_features.geometryShader == VK_FALSE)
1421                                 {
1422                                         TCU_THROW(NotSupportedError, "Geometry Shader Not Supported");
1423                                 }
1424                                 break;
1425                         case VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT:
1426                         case VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT:
1427                                 if (m_features.tessellationShader == VK_FALSE)
1428                                 {
1429                                         TCU_THROW(NotSupportedError, "Tessellation Not Supported");
1430                                 }
1431                                 break;
1432                         case VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT:
1433                         default:
1434                                 break;
1435                 };
1436         }
1437 }
1438
1439 AdvGraphicsTestInstance::AdvGraphicsTestInstance(Context&              context,
1440                                                                                                  const StageFlagVector stages,
1441                                                                                                  const bool            inRenderPass)
1442         : BasicGraphicsTestInstance(context, stages, inRenderPass)
1443 {
1444         m_features = m_context.getDeviceFeatures();
1445
1446         // If necessary feature is not supported, throw error and fail current test
1447         featureSupportCheck();
1448
1449         if(m_features.geometryShader == VK_TRUE)
1450         {
1451                 m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_GEOMETRY_BIT, "dummy_geo", "main");
1452         }
1453
1454         if(m_features.tessellationShader == VK_TRUE)
1455         {
1456                 m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, "basic_tcs", "main");
1457                 m_pipelineBuilder.bindShaderStage(VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, "basic_tes", "main");
1458                 m_pipelineBuilder.enableTessellationStage(3);
1459         }
1460
1461         m_graphicsPipelines = m_pipelineBuilder.buildPipeline(m_renderSize, *m_renderPass);
1462
1463         // Prepare the indirect draw buffer
1464         const DeviceInterface&      vk                  = m_context.getDeviceInterface();
1465         const VkDevice              vkDevice            = m_context.getDevice();
1466
1467         if(m_features.multiDrawIndirect == VK_TRUE)
1468         {
1469                 m_draw_count = 2;
1470         }
1471         else
1472         {
1473                 m_draw_count = 1;
1474         }
1475         m_indirectBuffer = createBufferAndBindMemory(32u, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, &m_indirectBufferAlloc);
1476
1477         const VkDrawIndirectCommand indirectCmds[] =
1478         {
1479                 {
1480                         12u,                    // deUint32    vertexCount;
1481                         1u,                     // deUint32    instanceCount;
1482                         0u,                     // deUint32    firstVertex;
1483                         0u,                     // deUint32    firstInstance;
1484                 },
1485                 {
1486                         12u,                    // deUint32    vertexCount;
1487                         1u,                     // deUint32    instanceCount;
1488                         11u,                    // deUint32    firstVertex;
1489                         0u,                     // deUint32    firstInstance;
1490                 },
1491         };
1492         // Load data into indirect draw buffer
1493         deMemcpy(m_indirectBufferAlloc->getHostPtr(), indirectCmds, m_draw_count * sizeof(VkDrawIndirectCommand));
1494         flushMappedMemoryRange(vk, vkDevice, m_indirectBufferAlloc->getMemory(), m_indirectBufferAlloc->getOffset(), 32u);
1495
1496 }
1497
1498 AdvGraphicsTestInstance::~AdvGraphicsTestInstance(void)
1499 {
1500 }
1501
1502 void AdvGraphicsTestInstance::configCommandBuffer(void)
1503 {
1504         const DeviceInterface&      vk                  = m_context.getDeviceInterface();
1505
1506         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1507         {
1508                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType              sType;
1509                 DE_NULL,                                        // const void*                  pNext;
1510                 0u,                                             // VkCommandBufferUsageFlags    flags;
1511                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1512         };
1513
1514         const VkClearValue attachmentClearValues[2] =
1515         {
1516                 defaultClearValue(m_colorFormat),
1517                 defaultClearValue(m_depthFormat),
1518         };
1519
1520         const VkRenderPassBeginInfo renderPassBeginInfo =
1521         {
1522                 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,               // VkStructureType      sType;
1523                 DE_NULL,                                                // const void*          pNext;
1524                 *m_renderPass,                                          // VkRenderPass         renderPass;
1525                 *m_framebuffer,                                         // VkFramebuffer        framebuffer;
1526                 { { 0u, 0u }, { m_renderSize.x(), m_renderSize.y() } }, // VkRect2D             renderArea;
1527                 2u,                                                     // deUint32             clearValueCount;
1528                 attachmentClearValues                                   // const VkClearValue*  pClearValues;
1529         };
1530
1531         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1532
1533         vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0,
1534                 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(m_imageLayoutBarriers), m_imageLayoutBarriers);
1535
1536         vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, TimestampTest::ENTRY_COUNT);
1537
1538         vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
1539
1540         vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipelines);
1541
1542         VkDeviceSize offsets = 0u;
1543         vk.cmdBindVertexBuffers(*m_cmdBuffer, 0u, 1u, &m_vertexBuffer.get(), &offsets);
1544
1545         vk.cmdDrawIndirect(*m_cmdBuffer, *m_indirectBuffer, 0u, m_draw_count, sizeof(VkDrawIndirectCommand));
1546
1547         if(m_inRenderPass)
1548         {
1549           deUint32 timestampEntry = 0u;
1550           for (StageFlagVector::const_iterator it = m_stages.begin(); it != m_stages.end(); it++)
1551           {
1552                   vk.cmdWriteTimestamp(*m_cmdBuffer, *it, *m_queryPool, timestampEntry++);
1553           }
1554         }
1555
1556         vk.cmdEndRenderPass(*m_cmdBuffer);
1557
1558         if(!m_inRenderPass)
1559         {
1560           deUint32 timestampEntry = 0u;
1561           for (StageFlagVector::const_iterator it = m_stages.begin(); it != m_stages.end(); it++)
1562           {
1563                   vk.cmdWriteTimestamp(*m_cmdBuffer, *it, *m_queryPool, timestampEntry++);
1564           }
1565         }
1566
1567         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1568
1569 }
1570
1571 class BasicComputeTest : public TimestampTest
1572 {
1573 public:
1574                                                   BasicComputeTest  (tcu::TestContext&         testContext,
1575                                                                                          const std::string&        name,
1576                                                                                          const std::string&        description,
1577                                                                                          const TimestampTestParam* param)
1578                                                           : TimestampTest(testContext, name, description, param)
1579                                                           { }
1580         virtual               ~BasicComputeTest (void) { }
1581         virtual void          initPrograms      (SourceCollections&        programCollection) const;
1582         virtual TestInstance* createInstance    (Context&                  context) const;
1583 };
1584
1585 class BasicComputeTestInstance : public TimestampTestInstance
1586 {
1587 public:
1588                                  BasicComputeTestInstance  (Context&              context,
1589                                                                                         const StageFlagVector stages,
1590                                                                                         const bool            inRenderPass);
1591         virtual      ~BasicComputeTestInstance (void);
1592         virtual void configCommandBuffer       (void);
1593 protected:
1594         de::MovePtr<Allocation>     m_inputBufAlloc;
1595         Move<VkBuffer>              m_inputBuf;
1596         de::MovePtr<Allocation>     m_outputBufAlloc;
1597         Move<VkBuffer>              m_outputBuf;
1598
1599         Move<VkDescriptorPool>      m_descriptorPool;
1600         Move<VkDescriptorSet>       m_descriptorSet;
1601         Move<VkDescriptorSetLayout> m_descriptorSetLayout;
1602
1603         Move<VkPipelineLayout>      m_pipelineLayout;
1604         Move<VkShaderModule>        m_computeShaderModule;
1605         Move<VkPipeline>            m_computePipelines;
1606 };
1607
1608 void BasicComputeTest::initPrograms(SourceCollections& programCollection) const
1609 {
1610         TimestampTest::initPrograms(programCollection);
1611
1612         programCollection.glslSources.add("basic_compute") << glu::ComputeSource(
1613                 "#version 310 es\n"
1614                 "layout(local_size_x = 128) in;\n"
1615                 "layout(std430) buffer;\n"
1616                 "layout(binding = 0) readonly buffer Input0\n"
1617                 "{\n"
1618                 "  vec4 elements[];\n"
1619                 "} input_data0;\n"
1620                 "layout(binding = 1) writeonly buffer Output\n"
1621                 "{\n"
1622                 "  vec4 elements[];\n"
1623                 "} output_data;\n"
1624                 "void main()\n"
1625                 "{\n"
1626                 "  uint ident = gl_GlobalInvocationID.x;\n"
1627                 "  output_data.elements[ident] = input_data0.elements[ident] * input_data0.elements[ident];\n"
1628                 "}");
1629 }
1630
1631 TestInstance* BasicComputeTest::createInstance(Context& context) const
1632 {
1633         return new BasicComputeTestInstance(context,m_stages,m_inRenderPass);
1634 }
1635
1636 BasicComputeTestInstance::BasicComputeTestInstance(Context&              context,
1637                                                                                                    const StageFlagVector stages,
1638                                                                                                    const bool            inRenderPass)
1639         : TimestampTestInstance(context, stages, inRenderPass)
1640 {
1641         const DeviceInterface&      vk                  = context.getDeviceInterface();
1642         const VkDevice              vkDevice            = context.getDevice();
1643
1644         // Create buffer object, allocate storage, and generate input data
1645         const VkDeviceSize          size                = sizeof(tcu::Vec4) * 128u * 128u;
1646         m_inputBuf = createBufferAndBindMemory(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, &m_inputBufAlloc);
1647         // Load vertices into buffer
1648         tcu::Vec4* pVec = reinterpret_cast<tcu::Vec4*>(m_inputBufAlloc->getHostPtr());
1649         for (deUint32 ndx = 0u; ndx < (128u * 128u); ndx++)
1650         {
1651                 for (deUint32 component = 0u; component < 4u; component++)
1652                 {
1653                         pVec[ndx][component]= (float)(ndx * (component + 1u));
1654                 }
1655         }
1656         flushMappedMemoryRange(vk, vkDevice, m_inputBufAlloc->getMemory(), m_inputBufAlloc->getOffset(), size);
1657
1658         m_outputBuf = createBufferAndBindMemory(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, &m_outputBufAlloc);
1659
1660         std::vector<VkDescriptorBufferInfo>        descriptorInfos;
1661         descriptorInfos.push_back(makeDescriptorBufferInfo(*m_inputBuf, 0u, size));
1662         descriptorInfos.push_back(makeDescriptorBufferInfo(*m_outputBuf, 0u, size));
1663
1664         // Create descriptor set layout
1665         DescriptorSetLayoutBuilder descLayoutBuilder;
1666
1667         for (deUint32 bindingNdx = 0u; bindingNdx < 2u; bindingNdx++)
1668         {
1669                 descLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT);
1670         }
1671
1672         m_descriptorSetLayout = descLayoutBuilder.build(vk, vkDevice);
1673
1674         // Create descriptor pool
1675         m_descriptorPool = DescriptorPoolBuilder().addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2).build(vk, vkDevice, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
1676
1677         // Create descriptor set
1678         const VkDescriptorSetAllocateInfo descriptorSetAllocInfo =
1679         {
1680                 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,     // VkStructureType                 sType;
1681                 DE_NULL,                                            // const void*                     pNext;
1682                 *m_descriptorPool,                                  // VkDescriptorPool                descriptorPool;
1683                 1u,                                                 // deUint32                        setLayoutCount;
1684                 &m_descriptorSetLayout.get(),                       // const VkDescriptorSetLayout*    pSetLayouts;
1685         };
1686         m_descriptorSet   = allocateDescriptorSet(vk, vkDevice, &descriptorSetAllocInfo);
1687
1688         DescriptorSetUpdateBuilder  builder;
1689         for (deUint32 descriptorNdx = 0u; descriptorNdx < 2u; descriptorNdx++)
1690         {
1691                 builder.writeSingle(*m_descriptorSet, DescriptorSetUpdateBuilder::Location::binding(descriptorNdx), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &descriptorInfos[descriptorNdx]);
1692         }
1693         builder.update(vk, vkDevice);
1694
1695         // Create compute pipeline layout
1696         const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
1697         {
1698                 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,  // VkStructureType                 sType;
1699                 DE_NULL,                                        // const void*                     pNext;
1700                 0u,                                             // VkPipelineLayoutCreateFlags     flags;
1701                 1u,                                             // deUint32                        setLayoutCount;
1702                 &m_descriptorSetLayout.get(),                   // const VkDescriptorSetLayout*    pSetLayouts;
1703                 0u,                                             // deUint32                        pushConstantRangeCount;
1704                 DE_NULL,                                        // const VkPushConstantRange*      pPushConstantRanges;
1705         };
1706
1707         m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutCreateInfo);
1708
1709         // Create compute shader
1710         VkShaderModuleCreateInfo shaderModuleCreateInfo =
1711         {
1712                 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,                        // VkStructureType             sType;
1713                 DE_NULL,                                                            // const void*                 pNext;
1714                 0u,                                                                 // VkShaderModuleCreateFlags   flags;
1715                 m_context.getBinaryCollection().get("basic_compute").getSize(),     // deUintptr                   codeSize;
1716                 (deUint32*)m_context.getBinaryCollection().get("basic_compute").getBinary(),   // const deUint32*             pCode;
1717
1718         };
1719
1720         m_computeShaderModule = createShaderModule(vk, vkDevice, &shaderModuleCreateInfo);
1721
1722         // Create compute pipeline
1723         const VkPipelineShaderStageCreateInfo stageCreateInfo =
1724         {
1725                 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType                     sType;
1726                 DE_NULL,                                             // const void*                         pNext;
1727                 0u,                                                  // VkPipelineShaderStageCreateFlags    flags;
1728                 VK_SHADER_STAGE_COMPUTE_BIT,                         // VkShaderStageFlagBits               stage;
1729                 *m_computeShaderModule,                              // VkShaderModule                      module;
1730                 "main",                                              // const char*                         pName;
1731                 DE_NULL,                                             // const VkSpecializationInfo*         pSpecializationInfo;
1732         };
1733
1734         const VkComputePipelineCreateInfo pipelineCreateInfo =
1735         {
1736                 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,      // VkStructureType                 sType;
1737                 DE_NULL,                                             // const void*                     pNext;
1738                 0u,                                                  // VkPipelineCreateFlags           flags;
1739                 stageCreateInfo,                                     // VkPipelineShaderStageCreateInfo stage;
1740                 *m_pipelineLayout,                                   // VkPipelineLayout                layout;
1741                 (VkPipeline)0,                                       // VkPipeline                      basePipelineHandle;
1742                 0u,                                                  // deInt32                         basePipelineIndex;
1743         };
1744
1745         m_computePipelines = createComputePipeline(vk, vkDevice, (VkPipelineCache)0u, &pipelineCreateInfo);
1746
1747 }
1748
1749 BasicComputeTestInstance::~BasicComputeTestInstance(void)
1750 {
1751 }
1752
1753 void BasicComputeTestInstance::configCommandBuffer(void)
1754 {
1755         const DeviceInterface&     vk                 = m_context.getDeviceInterface();
1756
1757         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1758         {
1759                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType          sType;
1760                 DE_NULL,                                        // const void*              pNext;
1761                 0u,                                             // VkCmdBufferOptimizeFlags flags;
1762                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1763
1764         };
1765
1766         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1767
1768         vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, TimestampTest::ENTRY_COUNT);
1769
1770         vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_computePipelines);
1771         vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_pipelineLayout, 0u, 1u, &m_descriptorSet.get(), 0u, DE_NULL);
1772         vk.cmdDispatch(*m_cmdBuffer, 128u, 1u, 1u);
1773
1774         deUint32 timestampEntry = 0u;
1775         for (StageFlagVector::const_iterator it = m_stages.begin(); it != m_stages.end(); it++)
1776         {
1777                 vk.cmdWriteTimestamp(*m_cmdBuffer, *it, *m_queryPool, timestampEntry++);
1778         }
1779
1780         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
1781
1782
1783 }
1784
1785 class TransferTest : public TimestampTest
1786 {
1787 public:
1788                                                   TransferTest   (tcu::TestContext&          testContext,
1789                                                                                   const std::string&         name,
1790                                                                                   const std::string&         description,
1791                                                                                   const TimestampTestParam*  param);
1792         virtual               ~TransferTest  (void) { }
1793         virtual void          initPrograms   (SourceCollections&         programCollection) const;
1794         virtual TestInstance* createInstance (Context&                   context) const;
1795 protected:
1796         TransferMethod        m_method;
1797 };
1798
1799 class TransferTestInstance : public TimestampTestInstance
1800 {
1801 public:
1802                                         TransferTestInstance    (Context&                                       context,
1803                                                                                          const StageFlagVector          stages,
1804                                                                                          const bool                                     inRenderPass,
1805                                                                                          const TransferMethod           method);
1806         virtual         ~TransferTestInstance   (void);
1807         virtual void    configCommandBuffer             (void);
1808         virtual void    initialImageTransition  (VkCommandBuffer                        cmdBuffer,
1809                                                                                          VkImage                                        image,
1810                                                                                          VkImageSubresourceRange        subRange,
1811                                                                                          VkImageLayout                          layout);
1812 protected:
1813         TransferMethod                  m_method;
1814
1815         VkDeviceSize                    m_bufSize;
1816         Move<VkBuffer>                  m_srcBuffer;
1817         Move<VkBuffer>                  m_dstBuffer;
1818         de::MovePtr<Allocation> m_srcBufferAlloc;
1819         de::MovePtr<Allocation> m_dstBufferAlloc;
1820
1821         VkFormat                                m_imageFormat;
1822         deInt32                                 m_imageWidth;
1823         deInt32                                 m_imageHeight;
1824         VkDeviceSize                    m_imageSize;
1825         Move<VkImage>                   m_srcImage;
1826         Move<VkImage>                   m_dstImage;
1827         Move<VkImage>                   m_depthImage;
1828         Move<VkImage>                   m_msImage;
1829         de::MovePtr<Allocation> m_srcImageAlloc;
1830         de::MovePtr<Allocation> m_dstImageAlloc;
1831         de::MovePtr<Allocation> m_depthImageAlloc;
1832         de::MovePtr<Allocation> m_msImageAlloc;
1833 };
1834
1835 TransferTest::TransferTest(tcu::TestContext&                 testContext,
1836                                                    const std::string&                name,
1837                                                    const std::string&                description,
1838                                                    const TimestampTestParam*         param)
1839         : TimestampTest(testContext, name, description, param)
1840 {
1841         const TransferTimestampTestParam* transferParam = dynamic_cast<const TransferTimestampTestParam*>(param);
1842         m_method = transferParam->getMethod();
1843 }
1844
1845 void TransferTest::initPrograms(SourceCollections& programCollection) const
1846 {
1847         TimestampTest::initPrograms(programCollection);
1848 }
1849
1850 TestInstance* TransferTest::createInstance(Context& context) const
1851 {
1852   return new TransferTestInstance(context, m_stages, m_inRenderPass, m_method);
1853 }
1854
1855 TransferTestInstance::TransferTestInstance(Context&              context,
1856                                                                                    const StageFlagVector stages,
1857                                                                                    const bool            inRenderPass,
1858                                                                                    const TransferMethod  method)
1859         : TimestampTestInstance(context, stages, inRenderPass)
1860         , m_method(method)
1861         , m_bufSize(256u)
1862         , m_imageFormat(VK_FORMAT_R8G8B8A8_UNORM)
1863         , m_imageWidth(4u)
1864         , m_imageHeight(4u)
1865         , m_imageSize(256u)
1866 {
1867         const DeviceInterface&      vk                  = context.getDeviceInterface();
1868         const VkDevice              vkDevice            = context.getDevice();
1869
1870         // Create src buffer
1871         m_srcBuffer = createBufferAndBindMemory(m_bufSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, &m_srcBufferAlloc);
1872
1873         // Init the source buffer memory
1874         char* pBuf = reinterpret_cast<char*>(m_srcBufferAlloc->getHostPtr());
1875         memset(pBuf, 0xFF, sizeof(char)*(size_t)m_bufSize);
1876         flushMappedMemoryRange(vk, vkDevice, m_srcBufferAlloc->getMemory(), m_srcBufferAlloc->getOffset(), m_bufSize);
1877
1878         // Create dst buffer
1879         m_dstBuffer = createBufferAndBindMemory(m_bufSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, &m_dstBufferAlloc);
1880
1881         // Create src/dst/depth image
1882         m_srcImage   = createImage2DAndBindMemory(m_imageFormat, m_imageWidth, m_imageHeight,
1883                                                                                           VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
1884                                                                                           VK_SAMPLE_COUNT_1_BIT,
1885                                                                                           &m_srcImageAlloc);
1886         m_dstImage   = createImage2DAndBindMemory(m_imageFormat, m_imageWidth, m_imageHeight,
1887                                                                                           VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1888                                                                                           VK_SAMPLE_COUNT_1_BIT,
1889                                                                                           &m_dstImageAlloc);
1890         m_depthImage = createImage2DAndBindMemory(VK_FORMAT_D16_UNORM, m_imageWidth, m_imageHeight,
1891                                                                                           VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1892                                                                                           VK_SAMPLE_COUNT_1_BIT,
1893                                                                                           &m_depthImageAlloc);
1894         m_msImage    = createImage2DAndBindMemory(m_imageFormat, m_imageWidth, m_imageHeight,
1895                                                                                           VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
1896                                                                                           VK_SAMPLE_COUNT_4_BIT,
1897                                                                                           &m_msImageAlloc);
1898 }
1899
1900 TransferTestInstance::~TransferTestInstance(void)
1901 {
1902 }
1903
1904 void TransferTestInstance::configCommandBuffer(void)
1905 {
1906         const DeviceInterface&      vk                  = m_context.getDeviceInterface();
1907
1908         const VkCommandBufferBeginInfo cmdBufferBeginInfo =
1909         {
1910                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                  sType;
1911                 DE_NULL,                                        // const void*                      pNext;
1912                 0u,                                             // VkCmdBufferOptimizeFlags         flags;
1913                 (const VkCommandBufferInheritanceInfo*)DE_NULL,
1914         };
1915
1916         VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
1917
1918         // Initialize buffer/image
1919         vk.cmdFillBuffer(*m_cmdBuffer, *m_dstBuffer, 0u, m_bufSize, 0x0);
1920
1921         const VkClearColorValue srcClearValue =
1922         {
1923                 {1.0f, 1.0f, 1.0f, 1.0f}
1924         };
1925         const VkClearColorValue dstClearValue =
1926         {
1927                 {0.0f, 0.0f, 0.0f, 0.0f}
1928         };
1929         const struct VkImageSubresourceRange subRangeColor =
1930         {
1931                 VK_IMAGE_ASPECT_COLOR_BIT,  // VkImageAspectFlags  aspectMask;
1932                 0u,                         // deUint32            baseMipLevel;
1933                 1u,                         // deUint32            mipLevels;
1934                 0u,                         // deUint32            baseArrayLayer;
1935                 1u,                         // deUint32            arraySize;
1936         };
1937         const struct VkImageSubresourceRange subRangeDepth =
1938         {
1939                 VK_IMAGE_ASPECT_DEPTH_BIT,  // VkImageAspectFlags  aspectMask;
1940                 0u,                  // deUint32            baseMipLevel;
1941                 1u,                  // deUint32            mipLevels;
1942                 0u,                  // deUint32            baseArrayLayer;
1943                 1u,                  // deUint32            arraySize;
1944         };
1945
1946         initialImageTransition(*m_cmdBuffer, *m_srcImage, subRangeColor, VK_IMAGE_LAYOUT_GENERAL);
1947         initialImageTransition(*m_cmdBuffer, *m_dstImage, subRangeColor, VK_IMAGE_LAYOUT_GENERAL);
1948
1949         vk.cmdClearColorImage(*m_cmdBuffer, *m_srcImage, VK_IMAGE_LAYOUT_GENERAL, &srcClearValue, 1u, &subRangeColor);
1950         vk.cmdClearColorImage(*m_cmdBuffer, *m_dstImage, VK_IMAGE_LAYOUT_GENERAL, &dstClearValue, 1u, &subRangeColor);
1951
1952         vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, TimestampTest::ENTRY_COUNT);
1953
1954         // Copy Operations
1955         const VkImageSubresourceLayers imgSubResCopy =
1956         {
1957                 VK_IMAGE_ASPECT_COLOR_BIT,              // VkImageAspectFlags  aspectMask;
1958                 0u,                                     // deUint32            mipLevel;
1959                 0u,                                     // deUint32            baseArrayLayer;
1960                 1u,                                     // deUint32            layerCount;
1961         };
1962
1963         const VkOffset3D nullOffset  = {0u, 0u, 0u};
1964         const VkExtent3D imageExtent = {(deUint32)m_imageWidth, (deUint32)m_imageHeight, 1u};
1965         const VkOffset3D imageOffset = {(int)m_imageWidth, (int)m_imageHeight, 1};
1966         switch(m_method)
1967         {
1968                 case TRANSFER_METHOD_COPY_BUFFER:
1969                         {
1970                                 const VkBufferCopy  copyBufRegion =
1971                                 {
1972                                         0u,      // VkDeviceSize    srcOffset;
1973                                         0u,      // VkDeviceSize    destOffset;
1974                                         512u,    // VkDeviceSize    copySize;
1975                                 };
1976                                 vk.cmdCopyBuffer(*m_cmdBuffer, *m_srcBuffer, *m_dstBuffer, 1u, &copyBufRegion);
1977                                 break;
1978                         }
1979                 case TRANSFER_METHOD_COPY_IMAGE:
1980                         {
1981                                 const VkImageCopy copyImageRegion =
1982                                 {
1983                                         imgSubResCopy,                          // VkImageSubresourceCopy  srcSubresource;
1984                                         nullOffset,                             // VkOffset3D              srcOffset;
1985                                         imgSubResCopy,                          // VkImageSubresourceCopy  destSubresource;
1986                                         nullOffset,                             // VkOffset3D              destOffset;
1987                                         imageExtent,                            // VkExtent3D              extent;
1988
1989                                 };
1990                                 vk.cmdCopyImage(*m_cmdBuffer, *m_srcImage, VK_IMAGE_LAYOUT_GENERAL, *m_dstImage, VK_IMAGE_LAYOUT_GENERAL, 1u, &copyImageRegion);
1991                                 break;
1992                         }
1993                 case TRANSFER_METHOD_COPY_BUFFER_TO_IMAGE:
1994                         {
1995                                 const VkBufferImageCopy bufImageCopy =
1996                                 {
1997                                         0u,                                     // VkDeviceSize            bufferOffset;
1998                                         (deUint32)m_imageWidth,                 // deUint32                bufferRowLength;
1999                                         (deUint32)m_imageHeight,                // deUint32                bufferImageHeight;
2000                                         imgSubResCopy,                          // VkImageSubresourceCopy  imageSubresource;
2001                                         nullOffset,                             // VkOffset3D              imageOffset;
2002                                         imageExtent,                            // VkExtent3D              imageExtent;
2003                                 };
2004                                 vk.cmdCopyBufferToImage(*m_cmdBuffer, *m_srcBuffer, *m_dstImage, VK_IMAGE_LAYOUT_GENERAL, 1u, &bufImageCopy);
2005                                 break;
2006                         }
2007                 case TRANSFER_METHOD_COPY_IMAGE_TO_BUFFER:
2008                         {
2009                                 const VkBufferImageCopy imgBufferCopy =
2010                                 {
2011                                         0u,                                     // VkDeviceSize            bufferOffset;
2012                                         (deUint32)m_imageWidth,                 // deUint32                bufferRowLength;
2013                                         (deUint32)m_imageHeight,                // deUint32                bufferImageHeight;
2014                                         imgSubResCopy,                          // VkImageSubresourceCopy  imageSubresource;
2015                                         nullOffset,                             // VkOffset3D              imageOffset;
2016                                         imageExtent,                            // VkExtent3D              imageExtent;
2017                                 };
2018                                 vk.cmdCopyImageToBuffer(*m_cmdBuffer, *m_srcImage, VK_IMAGE_LAYOUT_GENERAL, *m_dstBuffer, 1u, &imgBufferCopy);
2019                                 break;
2020                         }
2021                 case TRANSFER_METHOD_BLIT_IMAGE:
2022                         {
2023                                 const VkImageBlit imageBlt =
2024                                 {
2025                                         imgSubResCopy,                          // VkImageSubresourceCopy  srcSubresource;
2026                                         {
2027                                                 nullOffset,
2028                                                 imageOffset,
2029                                         },
2030                                         imgSubResCopy,                          // VkImageSubresourceCopy  destSubresource;
2031                                         {
2032                                                 nullOffset,
2033                                                 imageOffset,
2034                                         }
2035                                 };
2036                                 vk.cmdBlitImage(*m_cmdBuffer, *m_srcImage, VK_IMAGE_LAYOUT_GENERAL, *m_dstImage, VK_IMAGE_LAYOUT_GENERAL, 1u, &imageBlt, VK_FILTER_NEAREST);
2037                                 break;
2038                         }
2039                 case TRANSFER_METHOD_CLEAR_COLOR_IMAGE:
2040                         {
2041                                 vk.cmdClearColorImage(*m_cmdBuffer, *m_dstImage, VK_IMAGE_LAYOUT_GENERAL, &srcClearValue, 1u, &subRangeColor);
2042                                 break;
2043                         }
2044                 case TRANSFER_METHOD_CLEAR_DEPTH_STENCIL_IMAGE:
2045                         {
2046                                 initialImageTransition(*m_cmdBuffer, *m_depthImage, subRangeDepth, VK_IMAGE_LAYOUT_GENERAL);
2047                                 const VkClearDepthStencilValue clearDSValue =
2048                                 {
2049                                         1.0f,                                   // float       depth;
2050                                         0u,                                     // deUint32    stencil;
2051                                 };
2052                                 vk.cmdClearDepthStencilImage(*m_cmdBuffer, *m_depthImage, VK_IMAGE_LAYOUT_GENERAL, &clearDSValue, 1u, &subRangeDepth);
2053                                 break;
2054                         }
2055                 case TRANSFER_METHOD_FILL_BUFFER:
2056                         {
2057                                 vk.cmdFillBuffer(*m_cmdBuffer, *m_dstBuffer, 0u, m_bufSize, 0x0);
2058                                 break;
2059                         }
2060                 case TRANSFER_METHOD_UPDATE_BUFFER:
2061                         {
2062                                 const deUint32 data[] =
2063                                 {
2064                                         0xdeadbeef, 0xabcdef00, 0x12345678
2065                                 };
2066                                 vk.cmdUpdateBuffer(*m_cmdBuffer, *m_dstBuffer, 0x10, sizeof(data), data);
2067                                 break;
2068                         }
2069                 case TRANSFER_METHOD_COPY_QUERY_POOL_RESULTS:
2070                         {
2071                                 vk.cmdWriteTimestamp(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, *m_queryPool, 0u);
2072                                 vk.cmdCopyQueryPoolResults(*m_cmdBuffer, *m_queryPool, 0u, 1u, *m_dstBuffer, 0u, 8u, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
2073                                 vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, 1u);
2074                                 break;
2075                         }
2076                 case TRANSFER_METHOD_RESOLVE_IMAGE:
2077                         {
2078                                 const VkImageResolve imageResolve =
2079                                 {
2080                                         imgSubResCopy,                              // VkImageSubresourceLayers  srcSubresource;
2081                                         nullOffset,                                 // VkOffset3D                srcOffset;
2082                                         imgSubResCopy,                              // VkImageSubresourceLayers  destSubresource;
2083                                         nullOffset,                                 // VkOffset3D                destOffset;
2084                                         imageExtent,                                // VkExtent3D                extent;
2085                                 };
2086                                 initialImageTransition(*m_cmdBuffer, *m_msImage, subRangeColor, VK_IMAGE_LAYOUT_GENERAL);
2087                                 vk.cmdClearColorImage(*m_cmdBuffer, *m_msImage, VK_IMAGE_LAYOUT_GENERAL, &srcClearValue, 1u, &subRangeColor);
2088                                 vk.cmdResolveImage(*m_cmdBuffer, *m_msImage, VK_IMAGE_LAYOUT_GENERAL, *m_dstImage, VK_IMAGE_LAYOUT_GENERAL, 1u, &imageResolve);
2089                                 break;
2090                         }
2091                 default:
2092                         DE_FATAL("Unknown Transfer Method!");
2093                         break;
2094         };
2095
2096         deUint32 timestampEntry = 0u;
2097         for (StageFlagVector::const_iterator it = m_stages.begin(); it != m_stages.end(); it++)
2098         {
2099                 vk.cmdWriteTimestamp(*m_cmdBuffer, *it, *m_queryPool, timestampEntry++);
2100         }
2101
2102         VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
2103 }
2104
2105 void TransferTestInstance::initialImageTransition (VkCommandBuffer cmdBuffer, VkImage image, VkImageSubresourceRange subRange, VkImageLayout layout)
2106 {
2107         const DeviceInterface&          vk                              = m_context.getDeviceInterface();
2108         const VkImageMemoryBarrier      imageMemBarrier =
2109         {
2110                 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType          sType;
2111                 DE_NULL,                                // const void*              pNext;
2112                 0u,                                     // VkAccessFlags            srcAccessMask;
2113                 0u,                                     // VkAccessFlags            dstAccessMask;
2114                 VK_IMAGE_LAYOUT_UNDEFINED,              // VkImageLayout            oldLayout;
2115                 layout,                                 // VkImageLayout            newLayout;
2116                 VK_QUEUE_FAMILY_IGNORED,                // uint32_t                 srcQueueFamilyIndex;
2117                 VK_QUEUE_FAMILY_IGNORED,                // uint32_t                 dstQueueFamilyIndex;
2118                 image,                                  // VkImage                  image;
2119                 subRange                                // VkImageSubresourceRange  subresourceRange;
2120         };
2121
2122         vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, DE_NULL, 0, DE_NULL, 1, &imageMemBarrier);
2123 }
2124
2125 } // anonymous
2126
2127 tcu::TestCaseGroup* createTimestampTests (tcu::TestContext& testCtx)
2128 {
2129         de::MovePtr<tcu::TestCaseGroup> timestampTests (new tcu::TestCaseGroup(testCtx, "timestamp", "timestamp tests"));
2130
2131         // Basic Graphics Tests
2132         {
2133                 de::MovePtr<tcu::TestCaseGroup> basicGraphicsTests (new tcu::TestCaseGroup(testCtx, "basic_graphics_tests", "Record timestamp in different pipeline stages of basic graphics tests"));
2134
2135                 const VkPipelineStageFlagBits basicGraphicsStages0[][2] =
2136                 {
2137                   {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,   VK_PIPELINE_STAGE_VERTEX_INPUT_BIT},
2138                   {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,   VK_PIPELINE_STAGE_VERTEX_SHADER_BIT},
2139                   {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,   VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT},
2140                   {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,   VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT},
2141                   {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,   VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT},
2142                   {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,   VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT},
2143                   {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,   VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT},
2144                   {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT},
2145                 };
2146                 for (deUint32 stageNdx = 0u; stageNdx < DE_LENGTH_OF_ARRAY(basicGraphicsStages0); stageNdx++)
2147                 {
2148                         TimestampTestParam param(basicGraphicsStages0[stageNdx], 2u, true);
2149                         basicGraphicsTests->addChild(newTestCase<BasicGraphicsTest>(testCtx, &param));
2150                         param.toggleInRenderPass();
2151                         basicGraphicsTests->addChild(newTestCase<BasicGraphicsTest>(testCtx, &param));
2152                 }
2153
2154                 const VkPipelineStageFlagBits basicGraphicsStages1[][3] =
2155                 {
2156                   {VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,      VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT},
2157                   {VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,  VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT},
2158                 };
2159                 for (deUint32 stageNdx = 0u; stageNdx < DE_LENGTH_OF_ARRAY(basicGraphicsStages1); stageNdx++)
2160                 {
2161                         TimestampTestParam param(basicGraphicsStages1[stageNdx], 3u, true);
2162                         basicGraphicsTests->addChild(newTestCase<BasicGraphicsTest>(testCtx, &param));
2163                         param.toggleInRenderPass();
2164                         basicGraphicsTests->addChild(newTestCase<BasicGraphicsTest>(testCtx, &param));
2165                 }
2166
2167                 timestampTests->addChild(basicGraphicsTests.release());
2168         }
2169
2170         // Advanced Graphics Tests
2171         {
2172                 de::MovePtr<tcu::TestCaseGroup> advGraphicsTests (new tcu::TestCaseGroup(testCtx, "advanced_graphics_tests", "Record timestamp in different pipeline stages of advanced graphics tests"));
2173
2174                 const VkPipelineStageFlagBits advGraphicsStages[][2] =
2175                 {
2176                         {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT},
2177                         {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT},
2178                         {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT},
2179                         {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT},
2180                 };
2181                 for (deUint32 stageNdx = 0u; stageNdx < DE_LENGTH_OF_ARRAY(advGraphicsStages); stageNdx++)
2182                 {
2183                         TimestampTestParam param(advGraphicsStages[stageNdx], 2u, true);
2184                         advGraphicsTests->addChild(newTestCase<AdvGraphicsTest>(testCtx, &param));
2185                         param.toggleInRenderPass();
2186                         advGraphicsTests->addChild(newTestCase<AdvGraphicsTest>(testCtx, &param));
2187                 }
2188
2189                 timestampTests->addChild(advGraphicsTests.release());
2190         }
2191
2192         // Basic Compute Tests
2193         {
2194                 de::MovePtr<tcu::TestCaseGroup> basicComputeTests (new tcu::TestCaseGroup(testCtx, "basic_compute_tests", "Record timestamp for computer stages"));
2195
2196                 const VkPipelineStageFlagBits basicComputeStages[][2] =
2197                 {
2198                         {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT},
2199                         {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT},
2200                 };
2201                 for (deUint32 stageNdx = 0u; stageNdx < DE_LENGTH_OF_ARRAY(basicComputeStages); stageNdx++)
2202                 {
2203                         TimestampTestParam param(basicComputeStages[stageNdx], 2u, false);
2204                         basicComputeTests->addChild(newTestCase<BasicComputeTest>(testCtx, &param));
2205                 }
2206
2207                 timestampTests->addChild(basicComputeTests.release());
2208         }
2209
2210         // Transfer Tests
2211         {
2212                 de::MovePtr<tcu::TestCaseGroup> transferTests (new tcu::TestCaseGroup(testCtx, "transfer_tests", "Record timestamp for transfer stages"));
2213
2214                 const VkPipelineStageFlagBits transferStages[][2] =
2215                 {
2216                         {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT},
2217                         {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_HOST_BIT},
2218                 };
2219                 for (deUint32 stageNdx = 0u; stageNdx < DE_LENGTH_OF_ARRAY(transferStages); stageNdx++)
2220                 {
2221                         for (deUint32 method = 0u; method < TRANSFER_METHOD_LAST; method++)
2222                         {
2223                                 TransferTimestampTestParam param(transferStages[stageNdx], 2u, false, method);
2224                                 transferTests->addChild(newTestCase<TransferTest>(testCtx, &param));
2225                         }
2226                 }
2227
2228                 timestampTests->addChild(transferTests.release());
2229         }
2230
2231         // Misc Tests
2232         {
2233                 de::MovePtr<tcu::TestCaseGroup> miscTests (new tcu::TestCaseGroup(testCtx, "misc_tests", "Misc tests that can not be categorized to other group."));
2234
2235                 const VkPipelineStageFlagBits miscStages[] = {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT};
2236                 TimestampTestParam param(miscStages, 1u, false);
2237                 miscTests->addChild(new TimestampTest(testCtx,
2238                                                                                           "timestamp_only",
2239                                                                                           "Only write timestamp command in the commmand buffer",
2240                                                                                           &param));
2241
2242                 timestampTests->addChild(miscTests.release());
2243         }
2244
2245         return timestampTests.release();
2246 }
2247
2248 } // pipeline
2249
2250 } // vkt