1 /*------------------------------------------------------------------------- 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2015 Google Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Pipeline barrier tests 22 *//*--------------------------------------------------------------------*/ 23 24 #include "vktMemoryPipelineBarrierTests.hpp" 25 26 #include "vktTestCaseUtil.hpp" 27 28 #include "vkDefs.hpp" 29 #include "vkPlatform.hpp" 30 #include "vkRefUtil.hpp" 31 #include "vkQueryUtil.hpp" 32 #include "vkMemUtil.hpp" 33 #include "vkTypeUtil.hpp" 34 #include "vkPrograms.hpp" 35 36 #include "tcuMaybe.hpp" 37 #include "tcuTextureUtil.hpp" 38 #include "tcuTestLog.hpp" 39 #include "tcuResultCollector.hpp" 40 #include "tcuTexture.hpp" 41 #include "tcuImageCompare.hpp" 42 43 #include "deUniquePtr.hpp" 44 #include "deStringUtil.hpp" 45 #include "deRandom.hpp" 46 47 #include "deInt32.h" 48 #include "deMath.h" 49 #include "deMemory.h" 50 51 #include <map> 52 #include <set> 53 #include <sstream> 54 #include <string> 55 #include <vector> 56 57 using tcu::TestLog; 58 using tcu::Maybe; 59 60 using de::MovePtr; 61 62 using std::string; 63 using std::vector; 64 using std::map; 65 using std::set; 66 using std::pair; 67 68 using tcu::IVec2; 69 using tcu::UVec2; 70 using tcu::UVec4; 71 using tcu::Vec4; 72 using tcu::ConstPixelBufferAccess; 73 using tcu::PixelBufferAccess; 74 using tcu::TextureFormat; 75 using tcu::TextureLevel; 76 77 namespace vkt 78 { 79 namespace memory 80 { 81 namespace 82 { 83 enum 84 { 85 MAX_UNIFORM_BUFFER_SIZE = 1024, 86 MAX_STORAGE_BUFFER_SIZE = (1<<28), 87 MAX_SIZE = (128 * 1024) 88 }; 89 90 // \todo [mika] Add to utilities 91 template<typename T> 92 T divRoundUp (const T& a, const T& b) 93 { 94 return (a / b) + (a % b == 0 ? 0 : 1); 95 } 96 97 enum 98 { 99 ALL_PIPELINE_STAGES = vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT 100 | vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT 101 | vk::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT 102 | vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT 103 | vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT 104 | vk::VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT 105 | vk::VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT 106 | vk::VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT 107 | vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT 108 | vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT 109 | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT 110 | vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT 111 | vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT 112 | vk::VK_PIPELINE_STAGE_TRANSFER_BIT 113 | vk::VK_PIPELINE_STAGE_HOST_BIT 114 }; 115 116 enum 117 { 118 ALL_ACCESSES = vk::VK_ACCESS_INDIRECT_COMMAND_READ_BIT 119 | vk::VK_ACCESS_INDEX_READ_BIT 120 | vk::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT 121 | vk::VK_ACCESS_UNIFORM_READ_BIT 122 | vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT 123 | vk::VK_ACCESS_SHADER_READ_BIT 124 | vk::VK_ACCESS_SHADER_WRITE_BIT 125 | vk::VK_ACCESS_COLOR_ATTACHMENT_READ_BIT 126 | vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT 127 | vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT 128 | vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT 129 | vk::VK_ACCESS_TRANSFER_READ_BIT 130 | vk::VK_ACCESS_TRANSFER_WRITE_BIT 131 | vk::VK_ACCESS_HOST_READ_BIT 132 | vk::VK_ACCESS_HOST_WRITE_BIT 133 | vk::VK_ACCESS_MEMORY_READ_BIT 134 | vk::VK_ACCESS_MEMORY_WRITE_BIT 135 }; 136 137 enum Usage 138 { 139 // Mapped host read and write 140 USAGE_HOST_READ = (0x1u<<0), 141 USAGE_HOST_WRITE = (0x1u<<1), 142 143 // Copy and other transfer operations 144 USAGE_TRANSFER_SRC = (0x1u<<2), 145 USAGE_TRANSFER_DST = (0x1u<<3), 146 147 // Buffer usage flags 148 USAGE_INDEX_BUFFER = (0x1u<<4), 149 USAGE_VERTEX_BUFFER = (0x1u<<5), 150 151 USAGE_UNIFORM_BUFFER = (0x1u<<6), 152 USAGE_STORAGE_BUFFER = (0x1u<<7), 153 154 USAGE_UNIFORM_TEXEL_BUFFER = (0x1u<<8), 155 USAGE_STORAGE_TEXEL_BUFFER = (0x1u<<9), 156 157 // \todo [2016-03-09 mika] This is probably almost impossible to do 158 USAGE_INDIRECT_BUFFER = (0x1u<<10), 159 160 // Texture usage flags 161 USAGE_SAMPLED_IMAGE = (0x1u<<11), 162 USAGE_STORAGE_IMAGE = (0x1u<<12), 163 USAGE_COLOR_ATTACHMENT = (0x1u<<13), 164 USAGE_INPUT_ATTACHMENT = (0x1u<<14), 165 USAGE_DEPTH_STENCIL_ATTACHMENT = (0x1u<<15), 166 }; 167 168 bool supportsDeviceBufferWrites (Usage usage) 169 { 170 if (usage & USAGE_TRANSFER_DST) 171 return true; 172 173 if (usage & USAGE_STORAGE_BUFFER) 174 return true; 175 176 if (usage & USAGE_STORAGE_TEXEL_BUFFER) 177 return true; 178 179 return false; 180 } 181 182 bool supportsDeviceImageWrites (Usage usage) 183 { 184 if (usage & USAGE_TRANSFER_DST) 185 return true; 186 187 if (usage & USAGE_STORAGE_IMAGE) 188 return true; 189 190 if (usage & USAGE_COLOR_ATTACHMENT) 191 return true; 192 193 return false; 194 } 195 196 // Sequential access enums 197 enum Access 198 { 199 ACCESS_INDIRECT_COMMAND_READ_BIT = 0, 200 ACCESS_INDEX_READ_BIT, 201 ACCESS_VERTEX_ATTRIBUTE_READ_BIT, 202 ACCESS_UNIFORM_READ_BIT, 203 ACCESS_INPUT_ATTACHMENT_READ_BIT, 204 ACCESS_SHADER_READ_BIT, 205 ACCESS_SHADER_WRITE_BIT, 206 ACCESS_COLOR_ATTACHMENT_READ_BIT, 207 ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 208 ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, 209 ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, 210 ACCESS_TRANSFER_READ_BIT, 211 ACCESS_TRANSFER_WRITE_BIT, 212 ACCESS_HOST_READ_BIT, 213 ACCESS_HOST_WRITE_BIT, 214 ACCESS_MEMORY_READ_BIT, 215 ACCESS_MEMORY_WRITE_BIT, 216 217 ACCESS_LAST 218 }; 219 220 // Sequential stage enums 221 enum PipelineStage 222 { 223 PIPELINESTAGE_TOP_OF_PIPE_BIT = 0, 224 PIPELINESTAGE_BOTTOM_OF_PIPE_BIT, 225 PIPELINESTAGE_DRAW_INDIRECT_BIT, 226 PIPELINESTAGE_VERTEX_INPUT_BIT, 227 PIPELINESTAGE_VERTEX_SHADER_BIT, 228 PIPELINESTAGE_TESSELLATION_CONTROL_SHADER_BIT, 229 PIPELINESTAGE_TESSELLATION_EVALUATION_SHADER_BIT, 230 PIPELINESTAGE_GEOMETRY_SHADER_BIT, 231 PIPELINESTAGE_FRAGMENT_SHADER_BIT, 232 PIPELINESTAGE_EARLY_FRAGMENT_TESTS_BIT, 233 PIPELINESTAGE_LATE_FRAGMENT_TESTS_BIT, 234 PIPELINESTAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 235 PIPELINESTAGE_COMPUTE_SHADER_BIT, 236 PIPELINESTAGE_TRANSFER_BIT, 237 PIPELINESTAGE_HOST_BIT, 238 239 PIPELINESTAGE_LAST 240 }; 241 242 PipelineStage pipelineStageFlagToPipelineStage (vk::VkPipelineStageFlagBits flags) 243 { 244 switch (flags) 245 { 246 case vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: return PIPELINESTAGE_TOP_OF_PIPE_BIT; 247 case vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: return PIPELINESTAGE_BOTTOM_OF_PIPE_BIT; 248 case vk::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT: return PIPELINESTAGE_DRAW_INDIRECT_BIT; 249 case vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT: return PIPELINESTAGE_VERTEX_INPUT_BIT; 250 case vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT: return PIPELINESTAGE_VERTEX_SHADER_BIT; 251 case vk::VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT: return PIPELINESTAGE_TESSELLATION_CONTROL_SHADER_BIT; 252 case vk::VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT: return PIPELINESTAGE_TESSELLATION_EVALUATION_SHADER_BIT; 253 case vk::VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT: return PIPELINESTAGE_GEOMETRY_SHADER_BIT; 254 case vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT: return PIPELINESTAGE_FRAGMENT_SHADER_BIT; 255 case vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: return PIPELINESTAGE_EARLY_FRAGMENT_TESTS_BIT; 256 case vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: return PIPELINESTAGE_LATE_FRAGMENT_TESTS_BIT; 257 case vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: return PIPELINESTAGE_COLOR_ATTACHMENT_OUTPUT_BIT; 258 case vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT: return PIPELINESTAGE_COMPUTE_SHADER_BIT; 259 case vk::VK_PIPELINE_STAGE_TRANSFER_BIT: return PIPELINESTAGE_TRANSFER_BIT; 260 case vk::VK_PIPELINE_STAGE_HOST_BIT: return PIPELINESTAGE_HOST_BIT; 261 262 default: 263 DE_FATAL("Unknown pipeline stage flags"); 264 return PIPELINESTAGE_LAST; 265 } 266 } 267 268 Usage operator| (Usage a, Usage b) 269 { 270 return (Usage)((deUint32)a | (deUint32)b); 271 } 272 273 Usage operator& (Usage a, Usage b) 274 { 275 return (Usage)((deUint32)a & (deUint32)b); 276 } 277 278 string usageToName (Usage usage) 279 { 280 const struct 281 { 282 Usage usage; 283 const char* const name; 284 } usageNames[] = 285 { 286 { USAGE_HOST_READ, "host_read" }, 287 { USAGE_HOST_WRITE, "host_write" }, 288 289 { USAGE_TRANSFER_SRC, "transfer_src" }, 290 { USAGE_TRANSFER_DST, "transfer_dst" }, 291 292 { USAGE_INDEX_BUFFER, "index_buffer" }, 293 { USAGE_VERTEX_BUFFER, "vertex_buffer" }, 294 { USAGE_UNIFORM_BUFFER, "uniform_buffer" }, 295 { USAGE_STORAGE_BUFFER, "storage_buffer" }, 296 { USAGE_UNIFORM_TEXEL_BUFFER, "uniform_texel_buffer" }, 297 { USAGE_STORAGE_TEXEL_BUFFER, "storage_texel_buffer" }, 298 { USAGE_INDIRECT_BUFFER, "indirect_buffer" }, 299 { USAGE_SAMPLED_IMAGE, "image_sampled" }, 300 { USAGE_STORAGE_IMAGE, "storage_image" }, 301 { USAGE_COLOR_ATTACHMENT, "color_attachment" }, 302 { USAGE_INPUT_ATTACHMENT, "input_attachment" }, 303 { USAGE_DEPTH_STENCIL_ATTACHMENT, "depth_stencil_attachment" }, 304 }; 305 306 std::ostringstream stream; 307 bool first = true; 308 309 for (size_t usageNdx = 0; usageNdx < DE_LENGTH_OF_ARRAY(usageNames); usageNdx++) 310 { 311 if (usage & usageNames[usageNdx].usage) 312 { 313 if (!first) 314 stream << "_"; 315 else 316 first = false; 317 318 stream << usageNames[usageNdx].name; 319 } 320 } 321 322 return stream.str(); 323 } 324 325 vk::VkBufferUsageFlags usageToBufferUsageFlags (Usage usage) 326 { 327 vk::VkBufferUsageFlags flags = 0; 328 329 if (usage & USAGE_TRANSFER_SRC) 330 flags |= vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT; 331 332 if (usage & USAGE_TRANSFER_DST) 333 flags |= vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT; 334 335 if (usage & USAGE_INDEX_BUFFER) 336 flags |= vk::VK_BUFFER_USAGE_INDEX_BUFFER_BIT; 337 338 if (usage & USAGE_VERTEX_BUFFER) 339 flags |= vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; 340 341 if (usage & USAGE_INDIRECT_BUFFER) 342 flags |= vk::VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; 343 344 if (usage & USAGE_UNIFORM_BUFFER) 345 flags |= vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; 346 347 if (usage & USAGE_STORAGE_BUFFER) 348 flags |= vk::VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; 349 350 if (usage & USAGE_UNIFORM_TEXEL_BUFFER) 351 flags |= vk::VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT; 352 353 if (usage & USAGE_STORAGE_TEXEL_BUFFER) 354 flags |= vk::VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT; 355 356 return flags; 357 } 358 359 vk::VkImageUsageFlags usageToImageUsageFlags (Usage usage) 360 { 361 vk::VkImageUsageFlags flags = 0; 362 363 if (usage & USAGE_TRANSFER_SRC) 364 flags |= vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT; 365 366 if (usage & USAGE_TRANSFER_DST) 367 flags |= vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT; 368 369 if (usage & USAGE_SAMPLED_IMAGE) 370 flags |= vk::VK_IMAGE_USAGE_SAMPLED_BIT; 371 372 if (usage & USAGE_STORAGE_IMAGE) 373 flags |= vk::VK_IMAGE_USAGE_STORAGE_BIT; 374 375 if (usage & USAGE_COLOR_ATTACHMENT) 376 flags |= vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; 377 378 if (usage & USAGE_INPUT_ATTACHMENT) 379 flags |= vk::VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; 380 381 if (usage & USAGE_DEPTH_STENCIL_ATTACHMENT) 382 flags |= vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; 383 384 return flags; 385 } 386 387 vk::VkPipelineStageFlags usageToStageFlags (Usage usage) 388 { 389 vk::VkPipelineStageFlags flags = 0; 390 391 if (usage & (USAGE_HOST_READ|USAGE_HOST_WRITE)) 392 flags |= vk::VK_PIPELINE_STAGE_HOST_BIT; 393 394 if (usage & (USAGE_TRANSFER_SRC|USAGE_TRANSFER_DST)) 395 flags |= vk::VK_PIPELINE_STAGE_TRANSFER_BIT; 396 397 if (usage & (USAGE_VERTEX_BUFFER|USAGE_INDEX_BUFFER)) 398 flags |= vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; 399 400 if (usage & USAGE_INDIRECT_BUFFER) 401 flags |= vk::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT; 402 403 if (usage & 404 (USAGE_UNIFORM_BUFFER 405 | USAGE_STORAGE_BUFFER 406 | USAGE_UNIFORM_TEXEL_BUFFER 407 | USAGE_STORAGE_TEXEL_BUFFER 408 | USAGE_SAMPLED_IMAGE 409 | USAGE_STORAGE_IMAGE)) 410 { 411 flags |= (vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT 412 | vk::VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT 413 | vk::VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT 414 | vk::VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT 415 | vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT 416 | vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); 417 } 418 419 if (usage & USAGE_INPUT_ATTACHMENT) 420 flags |= vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; 421 422 if (usage & USAGE_COLOR_ATTACHMENT) 423 flags |= vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; 424 425 if (usage & USAGE_DEPTH_STENCIL_ATTACHMENT) 426 { 427 flags |= vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT 428 | vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; 429 } 430 431 return flags; 432 } 433 434 vk::VkAccessFlags usageToAccessFlags (Usage usage) 435 { 436 vk::VkAccessFlags flags = 0; 437 438 if (usage & USAGE_HOST_READ) 439 flags |= vk::VK_ACCESS_HOST_READ_BIT; 440 441 if (usage & USAGE_HOST_WRITE) 442 flags |= vk::VK_ACCESS_HOST_WRITE_BIT; 443 444 if (usage & USAGE_TRANSFER_SRC) 445 flags |= vk::VK_ACCESS_TRANSFER_READ_BIT; 446 447 if (usage & USAGE_TRANSFER_DST) 448 flags |= vk::VK_ACCESS_TRANSFER_WRITE_BIT; 449 450 if (usage & USAGE_INDEX_BUFFER) 451 flags |= vk::VK_ACCESS_INDEX_READ_BIT; 452 453 if (usage & USAGE_VERTEX_BUFFER) 454 flags |= vk::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT; 455 456 if (usage & (USAGE_UNIFORM_BUFFER | USAGE_UNIFORM_TEXEL_BUFFER)) 457 flags |= vk::VK_ACCESS_UNIFORM_READ_BIT; 458 459 if (usage & USAGE_SAMPLED_IMAGE) 460 flags |= vk::VK_ACCESS_SHADER_READ_BIT; 461 462 if (usage & (USAGE_STORAGE_BUFFER 463 | USAGE_STORAGE_TEXEL_BUFFER 464 | USAGE_STORAGE_IMAGE)) 465 flags |= vk::VK_ACCESS_SHADER_READ_BIT | vk::VK_ACCESS_SHADER_WRITE_BIT; 466 467 if (usage & USAGE_INDIRECT_BUFFER) 468 flags |= vk::VK_ACCESS_INDIRECT_COMMAND_READ_BIT; 469 470 if (usage & USAGE_COLOR_ATTACHMENT) 471 flags |= vk::VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; 472 473 if (usage & USAGE_INPUT_ATTACHMENT) 474 flags |= vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; 475 476 if (usage & USAGE_DEPTH_STENCIL_ATTACHMENT) 477 flags |= vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT 478 | vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; 479 480 return flags; 481 } 482 483 struct TestConfig 484 { 485 Usage usage; 486 vk::VkDeviceSize size; 487 vk::VkSharingMode sharing; 488 }; 489 490 vk::Move<vk::VkCommandBuffer> createBeginCommandBuffer (const vk::DeviceInterface& vkd, 491 vk::VkDevice device, 492 vk::VkCommandPool pool, 493 vk::VkCommandBufferLevel level) 494 { 495 const vk::VkCommandBufferInheritanceInfo inheritInfo = 496 { 497 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, 498 DE_NULL, 499 0, 500 0, 501 0, 502 VK_FALSE, 503 0u, 504 0u 505 }; 506 const vk::VkCommandBufferBeginInfo beginInfo = 507 { 508 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, 509 DE_NULL, 510 0u, 511 (level == vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY ? &inheritInfo : (const vk::VkCommandBufferInheritanceInfo*)DE_NULL), 512 }; 513 514 vk::Move<vk::VkCommandBuffer> commandBuffer (allocateCommandBuffer(vkd, device, pool, level)); 515 516 vkd.beginCommandBuffer(*commandBuffer, &beginInfo); 517 518 return commandBuffer; 519 } 520 521 vk::Move<vk::VkBuffer> createBuffer (const vk::DeviceInterface& vkd, 522 vk::VkDevice device, 523 vk::VkDeviceSize size, 524 vk::VkBufferUsageFlags usage, 525 vk::VkSharingMode sharingMode, 526 const vector<deUint32>& queueFamilies) 527 { 528 const vk::VkBufferCreateInfo createInfo = 529 { 530 vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, 531 DE_NULL, 532 533 0, // flags 534 size, 535 usage, 536 sharingMode, 537 (deUint32)queueFamilies.size(), 538 &queueFamilies[0] 539 }; 540 541 return vk::createBuffer(vkd, device, &createInfo); 542 } 543 544 vk::Move<vk::VkDeviceMemory> allocMemory (const vk::DeviceInterface& vkd, 545 vk::VkDevice device, 546 vk::VkDeviceSize size, 547 deUint32 memoryTypeIndex) 548 { 549 const vk::VkMemoryAllocateInfo alloc = 550 { 551 vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, // sType 552 DE_NULL, // pNext 553 554 size, 555 memoryTypeIndex 556 }; 557 558 return vk::allocateMemory(vkd, device, &alloc); 559 } 560 561 vk::Move<vk::VkDeviceMemory> bindBufferMemory (const vk::InstanceInterface& vki, 562 const vk::DeviceInterface& vkd, 563 vk::VkPhysicalDevice physicalDevice, 564 vk::VkDevice device, 565 vk::VkBuffer buffer, 566 vk::VkMemoryPropertyFlags properties) 567 { 568 const vk::VkMemoryRequirements memoryRequirements = vk::getBufferMemoryRequirements(vkd, device, buffer); 569 const vk::VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(vki, physicalDevice); 570 deUint32 memoryTypeIndex; 571 572 for (memoryTypeIndex = 0; memoryTypeIndex < memoryProperties.memoryTypeCount; memoryTypeIndex++) 573 { 574 if ((memoryRequirements.memoryTypeBits & (0x1u << memoryTypeIndex)) 575 && (memoryProperties.memoryTypes[memoryTypeIndex].propertyFlags & properties) == properties) 576 { 577 try 578 { 579 const vk::VkMemoryAllocateInfo allocationInfo = 580 { 581 vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, 582 DE_NULL, 583 memoryRequirements.size, 584 memoryTypeIndex 585 }; 586 vk::Move<vk::VkDeviceMemory> memory (vk::allocateMemory(vkd, device, &allocationInfo)); 587 588 VK_CHECK(vkd.bindBufferMemory(device, buffer, *memory, 0)); 589 590 return memory; 591 } 592 catch (const vk::Error& error) 593 { 594 if (error.getError() == vk::VK_ERROR_OUT_OF_DEVICE_MEMORY 595 || error.getError() == vk::VK_ERROR_OUT_OF_HOST_MEMORY) 596 { 597 // Try next memory type/heap if out of memory 598 } 599 else 600 { 601 // Throw all other errors forward 602 throw; 603 } 604 } 605 } 606 } 607 608 TCU_FAIL("Failed to allocate memory for buffer"); 609 } 610 611 vk::Move<vk::VkDeviceMemory> bindImageMemory (const vk::InstanceInterface& vki, 612 const vk::DeviceInterface& vkd, 613 vk::VkPhysicalDevice physicalDevice, 614 vk::VkDevice device, 615 vk::VkImage image, 616 vk::VkMemoryPropertyFlags properties) 617 { 618 const vk::VkMemoryRequirements memoryRequirements = vk::getImageMemoryRequirements(vkd, device, image); 619 const vk::VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(vki, physicalDevice); 620 deUint32 memoryTypeIndex; 621 622 for (memoryTypeIndex = 0; memoryTypeIndex < memoryProperties.memoryTypeCount; memoryTypeIndex++) 623 { 624 if ((memoryRequirements.memoryTypeBits & (0x1u << memoryTypeIndex)) 625 && (memoryProperties.memoryTypes[memoryTypeIndex].propertyFlags & properties) == properties) 626 { 627 try 628 { 629 const vk::VkMemoryAllocateInfo allocationInfo = 630 { 631 vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, 632 DE_NULL, 633 memoryRequirements.size, 634 memoryTypeIndex 635 }; 636 vk::Move<vk::VkDeviceMemory> memory (vk::allocateMemory(vkd, device, &allocationInfo)); 637 638 VK_CHECK(vkd.bindImageMemory(device, image, *memory, 0)); 639 640 return memory; 641 } 642 catch (const vk::Error& error) 643 { 644 if (error.getError() == vk::VK_ERROR_OUT_OF_DEVICE_MEMORY 645 || error.getError() == vk::VK_ERROR_OUT_OF_HOST_MEMORY) 646 { 647 // Try next memory type/heap if out of memory 648 } 649 else 650 { 651 // Throw all other errors forward 652 throw; 653 } 654 } 655 } 656 } 657 658 TCU_FAIL("Failed to allocate memory for image"); 659 } 660 661 void queueRun (const vk::DeviceInterface& vkd, 662 vk::VkQueue queue, 663 vk::VkCommandBuffer commandBuffer) 664 { 665 const vk::VkSubmitInfo submitInfo = 666 { 667 vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, 668 DE_NULL, 669 670 0, 671 DE_NULL, 672 (const vk::VkPipelineStageFlags*)DE_NULL, 673 674 1, 675 &commandBuffer, 676 677 0, 678 DE_NULL 679 }; 680 681 VK_CHECK(vkd.queueSubmit(queue, 1, &submitInfo, 0)); 682 VK_CHECK(vkd.queueWaitIdle(queue)); 683 } 684 685 void* mapMemory (const vk::DeviceInterface& vkd, 686 vk::VkDevice device, 687 vk::VkDeviceMemory memory, 688 vk::VkDeviceSize size) 689 { 690 void* ptr; 691 692 VK_CHECK(vkd.mapMemory(device, memory, 0, size, 0, &ptr)); 693 694 return ptr; 695 } 696 697 class ReferenceMemory 698 { 699 public: 700 ReferenceMemory (size_t size); 701 702 void set (size_t pos, deUint8 val); 703 deUint8 get (size_t pos) const; 704 bool isDefined (size_t pos) const; 705 706 void setDefined (size_t offset, size_t size, const void* data); 707 void setUndefined (size_t offset, size_t size); 708 void setData (size_t offset, size_t size, const void* data); 709 710 size_t getSize (void) const { return m_data.size(); } 711 712 private: 713 vector<deUint8> m_data; 714 vector<deUint64> m_defined; 715 }; 716 717 ReferenceMemory::ReferenceMemory (size_t size) 718 : m_data (size, 0) 719 , m_defined (size / 64 + (size % 64 == 0 ? 0 : 1), 0ull) 720 { 721 } 722 723 void ReferenceMemory::set (size_t pos, deUint8 val) 724 { 725 DE_ASSERT(pos < m_data.size()); 726 727 m_data[pos] = val; 728 m_defined[pos / 64] |= 0x1ull << (pos % 64); 729 } 730 731 void ReferenceMemory::setData (size_t offset, size_t size, const void* data_) 732 { 733 const deUint8* data = (const deUint8*)data_; 734 735 DE_ASSERT(offset < m_data.size()); 736 DE_ASSERT(offset + size <= m_data.size()); 737 738 // \todo [2016-03-09 mika] Optimize 739 for (size_t pos = 0; pos < size; pos++) 740 { 741 m_data[offset + pos] = data[pos]; 742 m_defined[(offset + pos) / 64] |= 0x1ull << ((offset + pos) % 64); 743 } 744 } 745 746 void ReferenceMemory::setUndefined (size_t offset, size_t size) 747 { 748 // \todo [2016-03-09 mika] Optimize 749 for (size_t pos = 0; pos < size; pos++) 750 m_defined[(offset + pos) / 64] |= 0x1ull << ((offset + pos) % 64); 751 } 752 753 deUint8 ReferenceMemory::get (size_t pos) const 754 { 755 DE_ASSERT(pos < m_data.size()); 756 DE_ASSERT(isDefined(pos)); 757 return m_data[pos]; 758 } 759 760 bool ReferenceMemory::isDefined (size_t pos) const 761 { 762 DE_ASSERT(pos < m_data.size()); 763 764 return (m_defined[pos / 64] & (0x1ull << (pos % 64))) != 0; 765 } 766 767 class Memory 768 { 769 public: 770 Memory (const vk::InstanceInterface& vki, 771 const vk::DeviceInterface& vkd, 772 vk::VkPhysicalDevice physicalDevice, 773 vk::VkDevice device, 774 vk::VkDeviceSize size, 775 deUint32 memoryTypeIndex, 776 vk::VkDeviceSize maxBufferSize, 777 deInt32 maxImageWidth, 778 deInt32 maxImageHeight); 779 780 vk::VkDeviceSize getSize (void) const { return m_size; } 781 vk::VkDeviceSize getMaxBufferSize (void) const { return m_maxBufferSize; } 782 bool getSupportBuffers (void) const { return m_maxBufferSize > 0; } 783 784 deInt32 getMaxImageWidth (void) const { return m_maxImageWidth; } 785 deInt32 getMaxImageHeight (void) const { return m_maxImageHeight; } 786 bool getSupportImages (void) const { return m_maxImageWidth > 0; } 787 788 const vk::VkMemoryType& getMemoryType (void) const { return m_memoryType; } 789 deUint32 getMemoryTypeIndex (void) const { return m_memoryTypeIndex; } 790 vk::VkDeviceMemory getMemory (void) const { return *m_memory; } 791 792 private: 793 const vk::VkDeviceSize m_size; 794 const deUint32 m_memoryTypeIndex; 795 const vk::VkMemoryType m_memoryType; 796 const vk::Unique<vk::VkDeviceMemory> m_memory; 797 const vk::VkDeviceSize m_maxBufferSize; 798 const deInt32 m_maxImageWidth; 799 const deInt32 m_maxImageHeight; 800 }; 801 802 vk::VkMemoryType getMemoryTypeInfo (const vk::InstanceInterface& vki, 803 vk::VkPhysicalDevice device, 804 deUint32 memoryTypeIndex) 805 { 806 const vk::VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(vki, device); 807 808 DE_ASSERT(memoryTypeIndex < memoryProperties.memoryTypeCount); 809 810 return memoryProperties.memoryTypes[memoryTypeIndex]; 811 } 812 813 vk::VkDeviceSize findMaxBufferSize (const vk::DeviceInterface& vkd, 814 vk::VkDevice device, 815 816 vk::VkBufferUsageFlags usage, 817 vk::VkSharingMode sharingMode, 818 const vector<deUint32>& queueFamilies, 819 820 vk::VkDeviceSize memorySize, 821 deUint32 memoryTypeIndex) 822 { 823 vk::VkDeviceSize lastSuccess = 0; 824 vk::VkDeviceSize currentSize = memorySize / 2; 825 826 { 827 const vk::Unique<vk::VkBuffer> buffer (createBuffer(vkd, device, memorySize, usage, sharingMode, queueFamilies)); 828 const vk::VkMemoryRequirements requirements (vk::getBufferMemoryRequirements(vkd, device, *buffer)); 829 830 if (requirements.size == memorySize && requirements.memoryTypeBits & (0x1u << memoryTypeIndex)) 831 return memorySize; 832 } 833 834 for (vk::VkDeviceSize stepSize = memorySize / 4; currentSize > 0; stepSize /= 2) 835 { 836 const vk::Unique<vk::VkBuffer> buffer (createBuffer(vkd, device, currentSize, usage, sharingMode, queueFamilies)); 837 const vk::VkMemoryRequirements requirements (vk::getBufferMemoryRequirements(vkd, device, *buffer)); 838 839 if (requirements.size <= memorySize && requirements.memoryTypeBits & (0x1u << memoryTypeIndex)) 840 { 841 lastSuccess = currentSize; 842 currentSize += stepSize; 843 } 844 else 845 currentSize -= stepSize; 846 847 if (stepSize == 0) 848 break; 849 } 850 851 return lastSuccess; 852 } 853 854 // Round size down maximum W * H * 4, where W and H < 4096 855 vk::VkDeviceSize roundBufferSizeToWxHx4 (vk::VkDeviceSize size) 856 { 857 const vk::VkDeviceSize maxTextureSize = 4096; 858 vk::VkDeviceSize maxTexelCount = size / 4; 859 vk::VkDeviceSize bestW = de::max(maxTexelCount, maxTextureSize); 860 vk::VkDeviceSize bestH = maxTexelCount / bestW; 861 862 // \todo [2016-03-09 mika] Could probably be faster? 863 for (vk::VkDeviceSize w = 1; w * w < maxTexelCount && w < maxTextureSize && bestW * bestH * 4 < size; w++) 864 { 865 const vk::VkDeviceSize h = maxTexelCount / w; 866 867 if (bestW * bestH < w * h) 868 { 869 bestW = w; 870 bestH = h; 871 } 872 } 873 874 return bestW * bestH * 4; 875 } 876 877 // Find RGBA8 image size that has exactly "size" of number of bytes. 878 // "size" must be W * H * 4 where W and H < 4096 879 IVec2 findImageSizeWxHx4 (vk::VkDeviceSize size) 880 { 881 const vk::VkDeviceSize maxTextureSize = 4096; 882 vk::VkDeviceSize texelCount = size / 4; 883 884 DE_ASSERT((size % 4) == 0); 885 886 // \todo [2016-03-09 mika] Could probably be faster? 887 for (vk::VkDeviceSize w = 1; w < maxTextureSize && w < texelCount; w++) 888 { 889 const vk::VkDeviceSize h = texelCount / w; 890 891 if ((texelCount % w) == 0 && h < maxTextureSize) 892 return IVec2((int)w, (int)h); 893 } 894 895 DE_FATAL("Invalid size"); 896 return IVec2(-1, -1); 897 } 898 899 IVec2 findMaxRGBA8ImageSize (const vk::DeviceInterface& vkd, 900 vk::VkDevice device, 901 902 vk::VkImageUsageFlags usage, 903 vk::VkSharingMode sharingMode, 904 const vector<deUint32>& queueFamilies, 905 906 vk::VkDeviceSize memorySize, 907 deUint32 memoryTypeIndex) 908 { 909 IVec2 lastSuccess (0); 910 IVec2 currentSize; 911 912 { 913 const deUint32 texelCount = (deUint32)(memorySize / 4); 914 const deUint32 width = (deUint32)deFloatSqrt((float)texelCount); 915 const deUint32 height = texelCount / width; 916 917 currentSize[0] = deMaxu32(width, height); 918 currentSize[1] = deMinu32(width, height); 919 } 920 921 for (deInt32 stepSize = currentSize[0] / 2; currentSize[0] > 0; stepSize /= 2) 922 { 923 const vk::VkImageCreateInfo createInfo = 924 { 925 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 926 DE_NULL, 927 928 0u, 929 vk::VK_IMAGE_TYPE_2D, 930 vk::VK_FORMAT_R8G8B8A8_UNORM, 931 { 932 (deUint32)currentSize[0], 933 (deUint32)currentSize[1], 934 1u, 935 }, 936 1u, 1u, 937 vk::VK_SAMPLE_COUNT_1_BIT, 938 vk::VK_IMAGE_TILING_OPTIMAL, 939 usage, 940 sharingMode, 941 (deUint32)queueFamilies.size(), 942 &queueFamilies[0], 943 vk::VK_IMAGE_LAYOUT_UNDEFINED 944 }; 945 const vk::Unique<vk::VkImage> image (vk::createImage(vkd, device, &createInfo)); 946 const vk::VkMemoryRequirements requirements (vk::getImageMemoryRequirements(vkd, device, *image)); 947 948 if (requirements.size <= memorySize && requirements.memoryTypeBits & (0x1u << memoryTypeIndex)) 949 { 950 lastSuccess = currentSize; 951 currentSize[0] += stepSize; 952 currentSize[1] += stepSize; 953 } 954 else 955 { 956 currentSize[0] -= stepSize; 957 currentSize[1] -= stepSize; 958 } 959 960 if (stepSize == 0) 961 break; 962 } 963 964 return lastSuccess; 965 } 966 967 Memory::Memory (const vk::InstanceInterface& vki, 968 const vk::DeviceInterface& vkd, 969 vk::VkPhysicalDevice physicalDevice, 970 vk::VkDevice device, 971 vk::VkDeviceSize size, 972 deUint32 memoryTypeIndex, 973 vk::VkDeviceSize maxBufferSize, 974 deInt32 maxImageWidth, 975 deInt32 maxImageHeight) 976 : m_size (size) 977 , m_memoryTypeIndex (memoryTypeIndex) 978 , m_memoryType (getMemoryTypeInfo(vki, physicalDevice, memoryTypeIndex)) 979 , m_memory (allocMemory(vkd, device, size, memoryTypeIndex)) 980 , m_maxBufferSize (maxBufferSize) 981 , m_maxImageWidth (maxImageWidth) 982 , m_maxImageHeight (maxImageHeight) 983 { 984 } 985 986 class Context 987 { 988 public: 989 Context (const vk::InstanceInterface& vki, 990 const vk::DeviceInterface& vkd, 991 vk::VkPhysicalDevice physicalDevice, 992 vk::VkDevice device, 993 vk::VkQueue queue, 994 deUint32 queueFamilyIndex, 995 const vector<pair<deUint32, vk::VkQueue> >& queues, 996 const vk::BinaryCollection& binaryCollection) 997 : m_vki (vki) 998 , m_vkd (vkd) 999 , m_physicalDevice (physicalDevice) 1000 , m_device (device) 1001 , m_queue (queue) 1002 , m_queueFamilyIndex (queueFamilyIndex) 1003 , m_queues (queues) 1004 , m_commandPool (createCommandPool(vkd, device, vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex)) 1005 , m_binaryCollection (binaryCollection) 1006 { 1007 for (size_t queueNdx = 0; queueNdx < m_queues.size(); queueNdx++) 1008 m_queueFamilies.push_back(m_queues[queueNdx].first); 1009 } 1010 1011 const vk::InstanceInterface& getInstanceInterface (void) const { return m_vki; } 1012 vk::VkPhysicalDevice getPhysicalDevice (void) const { return m_physicalDevice; } 1013 vk::VkDevice getDevice (void) const { return m_device; } 1014 const vk::DeviceInterface& getDeviceInterface (void) const { return m_vkd; } 1015 vk::VkQueue getQueue (void) const { return m_queue; } 1016 deUint32 getQueueFamily (void) const { return m_queueFamilyIndex; } 1017 const vector<pair<deUint32, vk::VkQueue> >& getQueues (void) const { return m_queues; } 1018 const vector<deUint32> getQueueFamilies (void) const { return m_queueFamilies; } 1019 vk::VkCommandPool getCommandPool (void) const { return *m_commandPool; } 1020 const vk::BinaryCollection& getBinaryCollection (void) const { return m_binaryCollection; } 1021 1022 private: 1023 const vk::InstanceInterface& m_vki; 1024 const vk::DeviceInterface& m_vkd; 1025 const vk::VkPhysicalDevice m_physicalDevice; 1026 const vk::VkDevice m_device; 1027 const vk::VkQueue m_queue; 1028 const deUint32 m_queueFamilyIndex; 1029 const vector<pair<deUint32, vk::VkQueue> > m_queues; 1030 const vk::Unique<vk::VkCommandPool> m_commandPool; 1031 const vk::BinaryCollection& m_binaryCollection; 1032 vector<deUint32> m_queueFamilies; 1033 }; 1034 1035 class PrepareContext 1036 { 1037 public: 1038 PrepareContext (const Context& context, 1039 const Memory& memory) 1040 : m_context (context) 1041 , m_memory (memory) 1042 { 1043 } 1044 1045 const Memory& getMemory (void) const { return m_memory; } 1046 const Context& getContext (void) const { return m_context; } 1047 const vk::BinaryCollection& getBinaryCollection (void) const { return m_context.getBinaryCollection(); } 1048 1049 void setBuffer (vk::Move<vk::VkBuffer> buffer, 1050 vk::VkDeviceSize size) 1051 { 1052 DE_ASSERT(!m_currentImage); 1053 DE_ASSERT(!m_currentBuffer); 1054 1055 m_currentBuffer = buffer; 1056 m_currentBufferSize = size; 1057 } 1058 1059 vk::VkBuffer getBuffer (void) const { return *m_currentBuffer; } 1060 vk::VkDeviceSize getBufferSize (void) const 1061 { 1062 DE_ASSERT(m_currentBuffer); 1063 return m_currentBufferSize; 1064 } 1065 1066 void releaseBuffer (void) { m_currentBuffer.disown(); } 1067 1068 void setImage (vk::Move<vk::VkImage> image, 1069 vk::VkImageLayout layout, 1070 vk::VkDeviceSize memorySize, 1071 deInt32 width, 1072 deInt32 height) 1073 { 1074 DE_ASSERT(!m_currentImage); 1075 DE_ASSERT(!m_currentBuffer); 1076 1077 m_currentImage = image; 1078 m_currentImageMemorySize = memorySize; 1079 m_currentImageLayout = layout; 1080 m_currentImageWidth = width; 1081 m_currentImageHeight = height; 1082 } 1083 1084 void setImageLayout (vk::VkImageLayout layout) 1085 { 1086 DE_ASSERT(m_currentImage); 1087 m_currentImageLayout = layout; 1088 } 1089 1090 vk::VkImage getImage (void) const { return *m_currentImage; } 1091 deInt32 getImageWidth (void) const 1092 { 1093 DE_ASSERT(m_currentImage); 1094 return m_currentImageWidth; 1095 } 1096 deInt32 getImageHeight (void) const 1097 { 1098 DE_ASSERT(m_currentImage); 1099 return m_currentImageHeight; 1100 } 1101 vk::VkDeviceSize getImageMemorySize (void) const 1102 { 1103 DE_ASSERT(m_currentImage); 1104 return m_currentImageMemorySize; 1105 } 1106 1107 void releaseImage (void) { m_currentImage.disown(); } 1108 1109 vk::VkImageLayout getImageLayout (void) const 1110 { 1111 DE_ASSERT(m_currentImage); 1112 return m_currentImageLayout; 1113 } 1114 1115 private: 1116 const Context& m_context; 1117 const Memory& m_memory; 1118 1119 vk::Move<vk::VkBuffer> m_currentBuffer; 1120 vk::VkDeviceSize m_currentBufferSize; 1121 1122 vk::Move<vk::VkImage> m_currentImage; 1123 vk::VkDeviceSize m_currentImageMemorySize; 1124 vk::VkImageLayout m_currentImageLayout; 1125 deInt32 m_currentImageWidth; 1126 deInt32 m_currentImageHeight; 1127 }; 1128 1129 class ExecuteContext 1130 { 1131 public: 1132 ExecuteContext (const Context& context) 1133 : m_context (context) 1134 { 1135 } 1136 1137 const Context& getContext (void) const { return m_context; } 1138 void setMapping (void* ptr) { m_mapping = ptr; } 1139 void* getMapping (void) const { return m_mapping; } 1140 1141 private: 1142 const Context& m_context; 1143 void* m_mapping; 1144 }; 1145 1146 class VerifyContext 1147 { 1148 public: 1149 VerifyContext (TestLog& log, 1150 tcu::ResultCollector& resultCollector, 1151 const Context& context, 1152 vk::VkDeviceSize size) 1153 : m_log (log) 1154 , m_resultCollector (resultCollector) 1155 , m_context (context) 1156 , m_reference ((size_t)size) 1157 { 1158 } 1159 1160 const Context& getContext (void) const { return m_context; } 1161 TestLog& getLog (void) const { return m_log; } 1162 tcu::ResultCollector& getResultCollector (void) const { return m_resultCollector; } 1163 1164 ReferenceMemory& getReference (void) { return m_reference; } 1165 TextureLevel& getReferenceImage (void) { return m_referenceImage;} 1166 1167 private: 1168 TestLog& m_log; 1169 tcu::ResultCollector& m_resultCollector; 1170 const Context& m_context; 1171 ReferenceMemory m_reference; 1172 TextureLevel m_referenceImage; 1173 }; 1174 1175 class Command 1176 { 1177 public: 1178 // Constructor should allocate all non-vulkan resources. 1179 virtual ~Command (void) {} 1180 1181 // Get name of the command 1182 virtual const char* getName (void) const = 0; 1183 1184 // Log prepare operations 1185 virtual void logPrepare (TestLog&, size_t) const {} 1186 // Log executed operations 1187 virtual void logExecute (TestLog&, size_t) const {} 1188 1189 // Prepare should allocate all vulkan resources and resources that require 1190 // that buffer or memory has been already allocated. This should build all 1191 // command buffers etc. 1192 virtual void prepare (PrepareContext&) {} 1193 1194 // Execute command. Write or read mapped memory, submit commands to queue 1195 // etc. 1196 virtual void execute (ExecuteContext&) {} 1197 1198 // Verify that results are correct. 1199 virtual void verify (VerifyContext&, size_t) {} 1200 1201 protected: 1202 // Allow only inheritance 1203 Command (void) {} 1204 1205 private: 1206 // Disallow copying 1207 Command (const Command&); 1208 Command& operator& (const Command&); 1209 }; 1210 1211 class Map : public Command 1212 { 1213 public: 1214 Map (void) {} 1215 ~Map (void) {} 1216 const char* getName (void) const { return "Map"; } 1217 1218 1219 void logExecute (TestLog& log, size_t commandIndex) const 1220 { 1221 log << TestLog::Message << commandIndex << ":" << getName() << " Map memory" << TestLog::EndMessage; 1222 } 1223 1224 void prepare (PrepareContext& context) 1225 { 1226 m_memory = context.getMemory().getMemory(); 1227 m_size = context.getMemory().getSize(); 1228 } 1229 1230 void execute (ExecuteContext& context) 1231 { 1232 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1233 const vk::VkDevice device = context.getContext().getDevice(); 1234 1235 context.setMapping(mapMemory(vkd, device, m_memory, m_size)); 1236 } 1237 1238 private: 1239 vk::VkDeviceMemory m_memory; 1240 vk::VkDeviceSize m_size; 1241 }; 1242 1243 class UnMap : public Command 1244 { 1245 public: 1246 UnMap (void) {} 1247 ~UnMap (void) {} 1248 const char* getName (void) const { return "UnMap"; } 1249 1250 void logExecute (TestLog& log, size_t commandIndex) const 1251 { 1252 log << TestLog::Message << commandIndex << ": Unmap memory" << TestLog::EndMessage; 1253 } 1254 1255 void prepare (PrepareContext& context) 1256 { 1257 m_memory = context.getMemory().getMemory(); 1258 } 1259 1260 void execute (ExecuteContext& context) 1261 { 1262 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1263 const vk::VkDevice device = context.getContext().getDevice(); 1264 1265 vkd.unmapMemory(device, m_memory); 1266 context.setMapping(DE_NULL); 1267 } 1268 1269 private: 1270 vk::VkDeviceMemory m_memory; 1271 }; 1272 1273 class Invalidate : public Command 1274 { 1275 public: 1276 Invalidate (void) {} 1277 ~Invalidate (void) {} 1278 const char* getName (void) const { return "Invalidate"; } 1279 1280 void logExecute (TestLog& log, size_t commandIndex) const 1281 { 1282 log << TestLog::Message << commandIndex << ": Invalidate mapped memory" << TestLog::EndMessage; 1283 } 1284 1285 void prepare (PrepareContext& context) 1286 { 1287 m_memory = context.getMemory().getMemory(); 1288 m_size = context.getMemory().getSize(); 1289 } 1290 1291 void execute (ExecuteContext& context) 1292 { 1293 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1294 const vk::VkDevice device = context.getContext().getDevice(); 1295 1296 vk::invalidateMappedMemoryRange(vkd, device, m_memory, 0, m_size); 1297 } 1298 1299 private: 1300 vk::VkDeviceMemory m_memory; 1301 vk::VkDeviceSize m_size; 1302 }; 1303 1304 class Flush : public Command 1305 { 1306 public: 1307 Flush (void) {} 1308 ~Flush (void) {} 1309 const char* getName (void) const { return "Flush"; } 1310 1311 void logExecute (TestLog& log, size_t commandIndex) const 1312 { 1313 log << TestLog::Message << commandIndex << ": Flush mapped memory" << TestLog::EndMessage; 1314 } 1315 1316 void prepare (PrepareContext& context) 1317 { 1318 m_memory = context.getMemory().getMemory(); 1319 m_size = context.getMemory().getSize(); 1320 } 1321 1322 void execute (ExecuteContext& context) 1323 { 1324 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1325 const vk::VkDevice device = context.getContext().getDevice(); 1326 1327 vk::flushMappedMemoryRange(vkd, device, m_memory, 0, m_size); 1328 } 1329 1330 private: 1331 vk::VkDeviceMemory m_memory; 1332 vk::VkDeviceSize m_size; 1333 }; 1334 1335 // Host memory reads and writes 1336 class HostMemoryAccess : public Command 1337 { 1338 public: 1339 HostMemoryAccess (bool read, bool write, deUint32 seed); 1340 ~HostMemoryAccess (void) {} 1341 const char* getName (void) const { return "HostMemoryAccess"; } 1342 1343 void logExecute (TestLog& log, size_t commandIndex) const; 1344 void prepare (PrepareContext& context); 1345 void execute (ExecuteContext& context); 1346 void verify (VerifyContext& context, size_t commandIndex); 1347 1348 private: 1349 const bool m_read; 1350 const bool m_write; 1351 const deUint32 m_seed; 1352 1353 size_t m_size; 1354 vector<deUint8> m_readData; 1355 }; 1356 1357 HostMemoryAccess::HostMemoryAccess (bool read, bool write, deUint32 seed) 1358 : m_read (read) 1359 , m_write (write) 1360 , m_seed (seed) 1361 { 1362 } 1363 1364 void HostMemoryAccess::logExecute (TestLog& log, size_t commandIndex) const 1365 { 1366 log << TestLog::Message << commandIndex << ": Host memory access:" << (m_read ? " read" : "") << (m_write ? " write" : "") << ", seed: " << m_seed << TestLog::EndMessage; 1367 } 1368 1369 void HostMemoryAccess::prepare (PrepareContext& context) 1370 { 1371 m_size = (size_t)context.getMemory().getSize(); 1372 1373 if (m_read) 1374 m_readData.resize(m_size, 0); 1375 } 1376 1377 void HostMemoryAccess::execute (ExecuteContext& context) 1378 { 1379 de::Random rng (m_seed); 1380 deUint8* const ptr = (deUint8*)context.getMapping(); 1381 1382 if (m_read && m_write) 1383 { 1384 for (size_t pos = 0; pos < m_size; pos++) 1385 { 1386 const deUint8 mask = rng.getUint8(); 1387 const deUint8 value = ptr[pos]; 1388 1389 m_readData[pos] = value; 1390 ptr[pos] = value ^ mask; 1391 } 1392 } 1393 else if (m_read) 1394 { 1395 for (size_t pos = 0; pos < m_size; pos++) 1396 { 1397 const deUint8 value = ptr[pos]; 1398 1399 m_readData[pos] = value; 1400 } 1401 } 1402 else if (m_write) 1403 { 1404 for (size_t pos = 0; pos < m_size; pos++) 1405 { 1406 const deUint8 value = rng.getUint8(); 1407 1408 ptr[pos] = value; 1409 } 1410 } 1411 else 1412 DE_FATAL("Host memory access without read or write."); 1413 } 1414 1415 void HostMemoryAccess::verify (VerifyContext& context, size_t commandIndex) 1416 { 1417 tcu::ResultCollector& resultCollector = context.getResultCollector(); 1418 ReferenceMemory& reference = context.getReference(); 1419 de::Random rng (m_seed); 1420 1421 if (m_read && m_write) 1422 { 1423 for (size_t pos = 0; pos < m_size; pos++) 1424 { 1425 const deUint8 mask = rng.getUint8(); 1426 const deUint8 value = m_readData[pos]; 1427 1428 if (reference.isDefined(pos)) 1429 { 1430 if (value != reference.get(pos)) 1431 { 1432 resultCollector.fail( 1433 de::toString(commandIndex) + ":" + getName() 1434 + " Result differs from reference, Expected: " 1435 + de::toString(tcu::toHex<8>(reference.get(pos))) 1436 + ", Got: " 1437 + de::toString(tcu::toHex<8>(value)) 1438 + ", At offset: " 1439 + de::toString(pos)); 1440 break; 1441 } 1442 1443 reference.set(pos, reference.get(pos) ^ mask); 1444 } 1445 } 1446 } 1447 else if (m_read) 1448 { 1449 for (size_t pos = 0; pos < m_size; pos++) 1450 { 1451 const deUint8 value = m_readData[pos]; 1452 1453 if (reference.isDefined(pos)) 1454 { 1455 if (value != reference.get(pos)) 1456 { 1457 resultCollector.fail( 1458 de::toString(commandIndex) + ":" + getName() 1459 + " Result differs from reference, Expected: " 1460 + de::toString(tcu::toHex<8>(reference.get(pos))) 1461 + ", Got: " 1462 + de::toString(tcu::toHex<8>(value)) 1463 + ", At offset: " 1464 + de::toString(pos)); 1465 break; 1466 } 1467 } 1468 } 1469 } 1470 else if (m_write) 1471 { 1472 for (size_t pos = 0; pos < m_size; pos++) 1473 { 1474 const deUint8 value = rng.getUint8(); 1475 1476 reference.set(pos, value); 1477 } 1478 } 1479 else 1480 DE_FATAL("Host memory access without read or write."); 1481 } 1482 1483 class CreateBuffer : public Command 1484 { 1485 public: 1486 CreateBuffer (vk::VkBufferUsageFlags usage, 1487 vk::VkSharingMode sharing); 1488 ~CreateBuffer (void) {} 1489 const char* getName (void) const { return "CreateBuffer"; } 1490 1491 void logPrepare (TestLog& log, size_t commandIndex) const; 1492 void prepare (PrepareContext& context); 1493 1494 private: 1495 const vk::VkBufferUsageFlags m_usage; 1496 const vk::VkSharingMode m_sharing; 1497 }; 1498 1499 CreateBuffer::CreateBuffer (vk::VkBufferUsageFlags usage, 1500 vk::VkSharingMode sharing) 1501 : m_usage (usage) 1502 , m_sharing (sharing) 1503 { 1504 } 1505 1506 void CreateBuffer::logPrepare (TestLog& log, size_t commandIndex) const 1507 { 1508 log << TestLog::Message << commandIndex << ":" << getName() << " Create buffer, Sharing mode: " << m_sharing << ", Usage: " << vk::getBufferUsageFlagsStr(m_usage) << TestLog::EndMessage; 1509 } 1510 1511 void CreateBuffer::prepare (PrepareContext& context) 1512 { 1513 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1514 const vk::VkDevice device = context.getContext().getDevice(); 1515 const vk::VkDeviceSize bufferSize = context.getMemory().getMaxBufferSize(); 1516 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 1517 1518 context.setBuffer(createBuffer(vkd, device, bufferSize, m_usage, m_sharing, queueFamilies), bufferSize); 1519 } 1520 1521 class DestroyBuffer : public Command 1522 { 1523 public: 1524 DestroyBuffer (void); 1525 ~DestroyBuffer (void) {} 1526 const char* getName (void) const { return "DestroyBuffer"; } 1527 1528 void logExecute (TestLog& log, size_t commandIndex) const; 1529 void prepare (PrepareContext& context); 1530 void execute (ExecuteContext& context); 1531 1532 private: 1533 vk::Move<vk::VkBuffer> m_buffer; 1534 }; 1535 1536 DestroyBuffer::DestroyBuffer (void) 1537 { 1538 } 1539 1540 void DestroyBuffer::prepare (PrepareContext& context) 1541 { 1542 m_buffer = vk::Move<vk::VkBuffer>(vk::check(context.getBuffer()), vk::Deleter<vk::VkBuffer>(context.getContext().getDeviceInterface(), context.getContext().getDevice(), DE_NULL)); 1543 context.releaseBuffer(); 1544 } 1545 1546 void DestroyBuffer::logExecute (TestLog& log, size_t commandIndex) const 1547 { 1548 log << TestLog::Message << commandIndex << ":" << getName() << " Destroy buffer" << TestLog::EndMessage; 1549 } 1550 1551 void DestroyBuffer::execute (ExecuteContext& context) 1552 { 1553 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1554 const vk::VkDevice device = context.getContext().getDevice(); 1555 1556 vkd.destroyBuffer(device, m_buffer.disown(), DE_NULL); 1557 } 1558 1559 class BindBufferMemory : public Command 1560 { 1561 public: 1562 BindBufferMemory (void) {} 1563 ~BindBufferMemory (void) {} 1564 const char* getName (void) const { return "BindBufferMemory"; } 1565 1566 void logPrepare (TestLog& log, size_t commandIndex) const; 1567 void prepare (PrepareContext& context); 1568 }; 1569 1570 void BindBufferMemory::logPrepare (TestLog& log, size_t commandIndex) const 1571 { 1572 log << TestLog::Message << commandIndex << ":" << getName() << " Bind memory to buffer" << TestLog::EndMessage; 1573 } 1574 1575 void BindBufferMemory::prepare (PrepareContext& context) 1576 { 1577 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1578 const vk::VkDevice device = context.getContext().getDevice(); 1579 1580 VK_CHECK(vkd.bindBufferMemory(device, context.getBuffer(), context.getMemory().getMemory(), 0)); 1581 } 1582 1583 class CreateImage : public Command 1584 { 1585 public: 1586 CreateImage (vk::VkImageUsageFlags usage, 1587 vk::VkSharingMode sharing); 1588 ~CreateImage (void) {} 1589 const char* getName (void) const { return "CreateImage"; } 1590 1591 void logPrepare (TestLog& log, size_t commandIndex) const; 1592 void prepare (PrepareContext& context); 1593 void verify (VerifyContext& context, size_t commandIndex); 1594 1595 private: 1596 const vk::VkImageUsageFlags m_usage; 1597 const vk::VkSharingMode m_sharing; 1598 deInt32 m_imageWidth; 1599 deInt32 m_imageHeight; 1600 }; 1601 1602 CreateImage::CreateImage (vk::VkImageUsageFlags usage, 1603 vk::VkSharingMode sharing) 1604 : m_usage (usage) 1605 , m_sharing (sharing) 1606 { 1607 } 1608 1609 void CreateImage::logPrepare (TestLog& log, size_t commandIndex) const 1610 { 1611 log << TestLog::Message << commandIndex << ":" << getName() << " Create image, sharing: " << m_sharing << ", usage: " << vk::getImageUsageFlagsStr(m_usage) << TestLog::EndMessage; 1612 } 1613 1614 void CreateImage::prepare (PrepareContext& context) 1615 { 1616 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1617 const vk::VkDevice device = context.getContext().getDevice(); 1618 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 1619 1620 m_imageWidth = context.getMemory().getMaxImageWidth(); 1621 m_imageHeight = context.getMemory().getMaxImageHeight(); 1622 1623 { 1624 const vk::VkImageCreateInfo createInfo = 1625 { 1626 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 1627 DE_NULL, 1628 1629 0u, 1630 vk::VK_IMAGE_TYPE_2D, 1631 vk::VK_FORMAT_R8G8B8A8_UNORM, 1632 { 1633 (deUint32)m_imageWidth, 1634 (deUint32)m_imageHeight, 1635 1u, 1636 }, 1637 1u, 1u, 1638 vk::VK_SAMPLE_COUNT_1_BIT, 1639 vk::VK_IMAGE_TILING_OPTIMAL, 1640 m_usage, 1641 m_sharing, 1642 (deUint32)queueFamilies.size(), 1643 &queueFamilies[0], 1644 vk::VK_IMAGE_LAYOUT_UNDEFINED 1645 }; 1646 vk::Move<vk::VkImage> image (createImage(vkd, device, &createInfo)); 1647 const vk::VkMemoryRequirements requirements = vk::getImageMemoryRequirements(vkd, device, *image); 1648 1649 context.setImage(image, vk::VK_IMAGE_LAYOUT_UNDEFINED, requirements.size, m_imageWidth, m_imageHeight); 1650 } 1651 } 1652 1653 void CreateImage::verify (VerifyContext& context, size_t) 1654 { 1655 context.getReferenceImage() = TextureLevel(TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_imageWidth, m_imageHeight); 1656 } 1657 1658 class DestroyImage : public Command 1659 { 1660 public: 1661 DestroyImage (void); 1662 ~DestroyImage (void) {} 1663 const char* getName (void) const { return "DestroyImage"; } 1664 1665 void logExecute (TestLog& log, size_t commandIndex) const; 1666 void prepare (PrepareContext& context); 1667 void execute (ExecuteContext& context); 1668 1669 private: 1670 vk::Move<vk::VkImage> m_image; 1671 }; 1672 1673 DestroyImage::DestroyImage (void) 1674 { 1675 } 1676 1677 void DestroyImage::prepare (PrepareContext& context) 1678 { 1679 m_image = vk::Move<vk::VkImage>(vk::check(context.getImage()), vk::Deleter<vk::VkImage>(context.getContext().getDeviceInterface(), context.getContext().getDevice(), DE_NULL)); 1680 context.releaseImage(); 1681 } 1682 1683 1684 void DestroyImage::logExecute (TestLog& log, size_t commandIndex) const 1685 { 1686 log << TestLog::Message << commandIndex << ":" << getName() << " Destroy image" << TestLog::EndMessage; 1687 } 1688 1689 void DestroyImage::execute (ExecuteContext& context) 1690 { 1691 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1692 const vk::VkDevice device = context.getContext().getDevice(); 1693 1694 vkd.destroyImage(device, m_image.disown(), DE_NULL); 1695 } 1696 1697 class BindImageMemory : public Command 1698 { 1699 public: 1700 BindImageMemory (void) {} 1701 ~BindImageMemory (void) {} 1702 const char* getName (void) const { return "BindImageMemory"; } 1703 1704 void logPrepare (TestLog& log, size_t commandIndex) const; 1705 void prepare (PrepareContext& context); 1706 }; 1707 1708 void BindImageMemory::logPrepare (TestLog& log, size_t commandIndex) const 1709 { 1710 log << TestLog::Message << commandIndex << ":" << getName() << " Bind memory to image" << TestLog::EndMessage; 1711 } 1712 1713 void BindImageMemory::prepare (PrepareContext& context) 1714 { 1715 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1716 const vk::VkDevice device = context.getContext().getDevice(); 1717 1718 VK_CHECK(vkd.bindImageMemory(device, context.getImage(), context.getMemory().getMemory(), 0)); 1719 } 1720 1721 class QueueWaitIdle : public Command 1722 { 1723 public: 1724 QueueWaitIdle (void) {} 1725 ~QueueWaitIdle (void) {} 1726 const char* getName (void) const { return "QueuetWaitIdle"; } 1727 1728 void logExecute (TestLog& log, size_t commandIndex) const; 1729 void execute (ExecuteContext& context); 1730 }; 1731 1732 void QueueWaitIdle::logExecute (TestLog& log, size_t commandIndex) const 1733 { 1734 log << TestLog::Message << commandIndex << ":" << getName() << " Queue wait idle" << TestLog::EndMessage; 1735 } 1736 1737 void QueueWaitIdle::execute (ExecuteContext& context) 1738 { 1739 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1740 const vk::VkQueue queue = context.getContext().getQueue(); 1741 1742 VK_CHECK(vkd.queueWaitIdle(queue)); 1743 } 1744 1745 class DeviceWaitIdle : public Command 1746 { 1747 public: 1748 DeviceWaitIdle (void) {} 1749 ~DeviceWaitIdle (void) {} 1750 const char* getName (void) const { return "DeviceWaitIdle"; } 1751 1752 void logExecute (TestLog& log, size_t commandIndex) const; 1753 void execute (ExecuteContext& context); 1754 }; 1755 1756 void DeviceWaitIdle::logExecute (TestLog& log, size_t commandIndex) const 1757 { 1758 log << TestLog::Message << commandIndex << ":" << getName() << " Device wait idle" << TestLog::EndMessage; 1759 } 1760 1761 void DeviceWaitIdle::execute (ExecuteContext& context) 1762 { 1763 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1764 const vk::VkDevice device = context.getContext().getDevice(); 1765 1766 VK_CHECK(vkd.deviceWaitIdle(device)); 1767 } 1768 1769 class SubmitContext 1770 { 1771 public: 1772 SubmitContext (const PrepareContext& context, 1773 const vk::VkCommandBuffer commandBuffer) 1774 : m_context (context) 1775 , m_commandBuffer (commandBuffer) 1776 { 1777 } 1778 1779 const Memory& getMemory (void) const { return m_context.getMemory(); } 1780 const Context& getContext (void) const { return m_context.getContext(); } 1781 vk::VkCommandBuffer getCommandBuffer (void) const { return m_commandBuffer; } 1782 1783 vk::VkBuffer getBuffer (void) const { return m_context.getBuffer(); } 1784 vk::VkDeviceSize getBufferSize (void) const { return m_context.getBufferSize(); } 1785 1786 vk::VkImage getImage (void) const { return m_context.getImage(); } 1787 deInt32 getImageWidth (void) const { return m_context.getImageWidth(); } 1788 deInt32 getImageHeight (void) const { return m_context.getImageHeight(); } 1789 1790 private: 1791 const PrepareContext& m_context; 1792 const vk::VkCommandBuffer m_commandBuffer; 1793 }; 1794 1795 class CmdCommand 1796 { 1797 public: 1798 virtual ~CmdCommand (void) {} 1799 virtual const char* getName (void) const = 0; 1800 1801 // Log things that are done during prepare 1802 virtual void logPrepare (TestLog&, size_t) const {} 1803 // Log submitted calls etc. 1804 virtual void logSubmit (TestLog&, size_t) const {} 1805 1806 // Allocate vulkan resources and prepare for submit. 1807 virtual void prepare (PrepareContext&) {} 1808 1809 // Submit commands to command buffer. 1810 virtual void submit (SubmitContext&) {} 1811 1812 // Verify results 1813 virtual void verify (VerifyContext&, size_t) {} 1814 }; 1815 1816 class SubmitCommandBuffer : public Command 1817 { 1818 public: 1819 SubmitCommandBuffer (const vector<CmdCommand*>& commands); 1820 ~SubmitCommandBuffer (void); 1821 1822 const char* getName (void) const { return "SubmitCommandBuffer"; } 1823 void logExecute (TestLog& log, size_t commandIndex) const; 1824 void logPrepare (TestLog& log, size_t commandIndex) const; 1825 1826 // Allocate command buffer and submit commands to command buffer 1827 void prepare (PrepareContext& context); 1828 void execute (ExecuteContext& context); 1829 1830 // Verify that results are correct. 1831 void verify (VerifyContext& context, size_t commandIndex); 1832 1833 private: 1834 vector<CmdCommand*> m_commands; 1835 vk::Move<vk::VkCommandBuffer> m_commandBuffer; 1836 }; 1837 1838 SubmitCommandBuffer::SubmitCommandBuffer (const vector<CmdCommand*>& commands) 1839 : m_commands (commands) 1840 { 1841 } 1842 1843 SubmitCommandBuffer::~SubmitCommandBuffer (void) 1844 { 1845 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 1846 delete m_commands[cmdNdx]; 1847 } 1848 1849 void SubmitCommandBuffer::prepare (PrepareContext& context) 1850 { 1851 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1852 const vk::VkDevice device = context.getContext().getDevice(); 1853 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 1854 1855 m_commandBuffer = createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY); 1856 1857 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 1858 { 1859 CmdCommand& command = *m_commands[cmdNdx]; 1860 1861 command.prepare(context); 1862 } 1863 1864 { 1865 SubmitContext submitContext (context, *m_commandBuffer); 1866 1867 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 1868 { 1869 CmdCommand& command = *m_commands[cmdNdx]; 1870 1871 command.submit(submitContext); 1872 } 1873 1874 VK_CHECK(vkd.endCommandBuffer(*m_commandBuffer)); 1875 } 1876 } 1877 1878 void SubmitCommandBuffer::execute (ExecuteContext& context) 1879 { 1880 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1881 const vk::VkCommandBuffer cmd = *m_commandBuffer; 1882 const vk::VkQueue queue = context.getContext().getQueue(); 1883 const vk::VkSubmitInfo submit = 1884 { 1885 vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, 1886 DE_NULL, 1887 1888 0, 1889 DE_NULL, 1890 (const vk::VkPipelineStageFlags*)DE_NULL, 1891 1892 1, 1893 &cmd, 1894 1895 0, 1896 DE_NULL 1897 }; 1898 1899 vkd.queueSubmit(queue, 1, &submit, 0); 1900 } 1901 1902 void SubmitCommandBuffer::verify (VerifyContext& context, size_t commandIndex) 1903 { 1904 const string sectionName (de::toString(commandIndex) + ":" + getName()); 1905 const tcu::ScopedLogSection section (context.getLog(), sectionName, sectionName); 1906 1907 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 1908 m_commands[cmdNdx]->verify(context, cmdNdx); 1909 } 1910 1911 void SubmitCommandBuffer::logPrepare (TestLog& log, size_t commandIndex) const 1912 { 1913 const string sectionName (de::toString(commandIndex) + ":" + getName()); 1914 const tcu::ScopedLogSection section (log, sectionName, sectionName); 1915 1916 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 1917 m_commands[cmdNdx]->logPrepare(log, cmdNdx); 1918 } 1919 1920 void SubmitCommandBuffer::logExecute (TestLog& log, size_t commandIndex) const 1921 { 1922 const string sectionName (de::toString(commandIndex) + ":" + getName()); 1923 const tcu::ScopedLogSection section (log, sectionName, sectionName); 1924 1925 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 1926 m_commands[cmdNdx]->logSubmit(log, cmdNdx); 1927 } 1928 1929 class PipelineBarrier : public CmdCommand 1930 { 1931 public: 1932 enum Type 1933 { 1934 TYPE_GLOBAL = 0, 1935 TYPE_BUFFER, 1936 TYPE_IMAGE, 1937 TYPE_LAST 1938 }; 1939 PipelineBarrier (const vk::VkPipelineStageFlags srcStages, 1940 const vk::VkAccessFlags srcAccesses, 1941 const vk::VkPipelineStageFlags dstStages, 1942 const vk::VkAccessFlags dstAccesses, 1943 Type type, 1944 const tcu::Maybe<vk::VkImageLayout> imageLayout); 1945 ~PipelineBarrier (void) {} 1946 const char* getName (void) const { return "PipelineBarrier"; } 1947 1948 void logSubmit (TestLog& log, size_t commandIndex) const; 1949 void submit (SubmitContext& context); 1950 1951 private: 1952 const vk::VkPipelineStageFlags m_srcStages; 1953 const vk::VkAccessFlags m_srcAccesses; 1954 const vk::VkPipelineStageFlags m_dstStages; 1955 const vk::VkAccessFlags m_dstAccesses; 1956 const Type m_type; 1957 const tcu::Maybe<vk::VkImageLayout> m_imageLayout; 1958 }; 1959 1960 PipelineBarrier::PipelineBarrier (const vk::VkPipelineStageFlags srcStages, 1961 const vk::VkAccessFlags srcAccesses, 1962 const vk::VkPipelineStageFlags dstStages, 1963 const vk::VkAccessFlags dstAccesses, 1964 Type type, 1965 const tcu::Maybe<vk::VkImageLayout> imageLayout) 1966 : m_srcStages (srcStages) 1967 , m_srcAccesses (srcAccesses) 1968 , m_dstStages (dstStages) 1969 , m_dstAccesses (dstAccesses) 1970 , m_type (type) 1971 , m_imageLayout (imageLayout) 1972 { 1973 } 1974 1975 void PipelineBarrier::logSubmit (TestLog& log, size_t commandIndex) const 1976 { 1977 log << TestLog::Message << commandIndex << ":" << getName() 1978 << " " << (m_type == TYPE_GLOBAL ? "Global pipeline barrier" 1979 : m_type == TYPE_BUFFER ? "Buffer pipeline barrier" 1980 : "Image pipeline barrier") 1981 << ", srcStages: " << vk::getPipelineStageFlagsStr(m_srcStages) << ", srcAccesses: " << vk::getAccessFlagsStr(m_srcAccesses) 1982 << ", dstStages: " << vk::getPipelineStageFlagsStr(m_dstStages) << ", dstAccesses: " << vk::getAccessFlagsStr(m_dstAccesses) << TestLog::EndMessage; 1983 } 1984 1985 void PipelineBarrier::submit (SubmitContext& context) 1986 { 1987 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 1988 const vk::VkCommandBuffer cmd = context.getCommandBuffer(); 1989 1990 switch (m_type) 1991 { 1992 case TYPE_GLOBAL: 1993 { 1994 const vk::VkMemoryBarrier barrier = 1995 { 1996 vk::VK_STRUCTURE_TYPE_MEMORY_BARRIER, 1997 DE_NULL, 1998 1999 m_srcAccesses, 2000 m_dstAccesses 2001 }; 2002 2003 vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, (vk::VkDependencyFlags)0, 1, &barrier, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 0, (const vk::VkImageMemoryBarrier*)DE_NULL); 2004 break; 2005 } 2006 2007 case TYPE_BUFFER: 2008 { 2009 const vk::VkBufferMemoryBarrier barrier = 2010 { 2011 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, 2012 DE_NULL, 2013 2014 m_srcAccesses, 2015 m_dstAccesses, 2016 2017 VK_QUEUE_FAMILY_IGNORED, 2018 VK_QUEUE_FAMILY_IGNORED, 2019 2020 context.getBuffer(), 2021 0, 2022 VK_WHOLE_SIZE 2023 }; 2024 2025 vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &barrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL); 2026 break; 2027 } 2028 2029 case TYPE_IMAGE: 2030 { 2031 const vk::VkImageMemoryBarrier barrier = 2032 { 2033 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 2034 DE_NULL, 2035 2036 m_srcAccesses, 2037 m_dstAccesses, 2038 2039 *m_imageLayout, 2040 *m_imageLayout, 2041 2042 VK_QUEUE_FAMILY_IGNORED, 2043 VK_QUEUE_FAMILY_IGNORED, 2044 2045 context.getImage(), 2046 { 2047 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2048 0, 1, 2049 0, 1 2050 } 2051 }; 2052 2053 vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier); 2054 break; 2055 } 2056 2057 default: 2058 DE_FATAL("Unknown pipeline barrier type"); 2059 } 2060 } 2061 2062 class ImageTransition : public CmdCommand 2063 { 2064 public: 2065 ImageTransition (vk::VkPipelineStageFlags srcStages, 2066 vk::VkAccessFlags srcAccesses, 2067 2068 vk::VkPipelineStageFlags dstStages, 2069 vk::VkAccessFlags dstAccesses, 2070 2071 vk::VkImageLayout srcLayout, 2072 vk::VkImageLayout dstLayout); 2073 2074 ~ImageTransition (void) {} 2075 const char* getName (void) const { return "ImageTransition"; } 2076 2077 void prepare (PrepareContext& context); 2078 void logSubmit (TestLog& log, size_t commandIndex) const; 2079 void submit (SubmitContext& context); 2080 void verify (VerifyContext& context, size_t); 2081 2082 private: 2083 const vk::VkPipelineStageFlags m_srcStages; 2084 const vk::VkAccessFlags m_srcAccesses; 2085 const vk::VkPipelineStageFlags m_dstStages; 2086 const vk::VkAccessFlags m_dstAccesses; 2087 const vk::VkImageLayout m_srcLayout; 2088 const vk::VkImageLayout m_dstLayout; 2089 2090 vk::VkDeviceSize m_imageMemorySize; 2091 }; 2092 2093 ImageTransition::ImageTransition (vk::VkPipelineStageFlags srcStages, 2094 vk::VkAccessFlags srcAccesses, 2095 2096 vk::VkPipelineStageFlags dstStages, 2097 vk::VkAccessFlags dstAccesses, 2098 2099 vk::VkImageLayout srcLayout, 2100 vk::VkImageLayout dstLayout) 2101 : m_srcStages (srcStages) 2102 , m_srcAccesses (srcAccesses) 2103 , m_dstStages (dstStages) 2104 , m_dstAccesses (dstAccesses) 2105 , m_srcLayout (srcLayout) 2106 , m_dstLayout (dstLayout) 2107 { 2108 } 2109 2110 void ImageTransition::logSubmit (TestLog& log, size_t commandIndex) const 2111 { 2112 log << TestLog::Message << commandIndex << ":" << getName() 2113 << " Image transition pipeline barrier" 2114 << ", srcStages: " << vk::getPipelineStageFlagsStr(m_srcStages) << ", srcAccesses: " << vk::getAccessFlagsStr(m_srcAccesses) 2115 << ", dstStages: " << vk::getPipelineStageFlagsStr(m_dstStages) << ", dstAccesses: " << vk::getAccessFlagsStr(m_dstAccesses) 2116 << ", srcLayout: " << m_srcLayout << ", dstLayout: " << m_dstLayout << TestLog::EndMessage; 2117 } 2118 2119 void ImageTransition::prepare (PrepareContext& context) 2120 { 2121 DE_ASSERT(context.getImageLayout() == vk::VK_IMAGE_LAYOUT_UNDEFINED || m_srcLayout == vk::VK_IMAGE_LAYOUT_UNDEFINED || context.getImageLayout() == m_srcLayout); 2122 2123 context.setImageLayout(m_dstLayout); 2124 m_imageMemorySize = context.getImageMemorySize(); 2125 } 2126 2127 void ImageTransition::submit (SubmitContext& context) 2128 { 2129 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2130 const vk::VkCommandBuffer cmd = context.getCommandBuffer(); 2131 const vk::VkImageMemoryBarrier barrier = 2132 { 2133 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 2134 DE_NULL, 2135 2136 m_srcAccesses, 2137 m_dstAccesses, 2138 2139 m_srcLayout, 2140 m_dstLayout, 2141 2142 VK_QUEUE_FAMILY_IGNORED, 2143 VK_QUEUE_FAMILY_IGNORED, 2144 2145 context.getImage(), 2146 { 2147 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2148 0u, 1u, 2149 0u, 1u 2150 } 2151 }; 2152 2153 vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier); 2154 } 2155 2156 void ImageTransition::verify (VerifyContext& context, size_t) 2157 { 2158 context.getReference().setUndefined(0, (size_t)m_imageMemorySize); 2159 } 2160 2161 class FillBuffer : public CmdCommand 2162 { 2163 public: 2164 FillBuffer (deUint32 value) : m_value(value) {} 2165 ~FillBuffer (void) {} 2166 const char* getName (void) const { return "FillBuffer"; } 2167 2168 void logSubmit (TestLog& log, size_t commandIndex) const; 2169 void submit (SubmitContext& context); 2170 void verify (VerifyContext& context, size_t commandIndex); 2171 2172 private: 2173 const deUint32 m_value; 2174 vk::VkDeviceSize m_bufferSize; 2175 }; 2176 2177 void FillBuffer::logSubmit (TestLog& log, size_t commandIndex) const 2178 { 2179 log << TestLog::Message << commandIndex << ":" << getName() << " Fill value: " << m_value << TestLog::EndMessage; 2180 } 2181 2182 void FillBuffer::submit (SubmitContext& context) 2183 { 2184 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2185 const vk::VkCommandBuffer cmd = context.getCommandBuffer(); 2186 const vk::VkBuffer buffer = context.getBuffer(); 2187 const vk::VkDeviceSize sizeMask = ~(0x3ull); // \note Round down to multiple of 4 2188 2189 m_bufferSize = sizeMask & context.getBufferSize(); 2190 vkd.cmdFillBuffer(cmd, buffer, 0, m_bufferSize, m_value); 2191 } 2192 2193 void FillBuffer::verify (VerifyContext& context, size_t) 2194 { 2195 ReferenceMemory& reference = context.getReference(); 2196 2197 for (size_t ndx = 0; ndx < m_bufferSize; ndx++) 2198 { 2199 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 2200 reference.set(ndx, (deUint8)(0xffu & (m_value >> (8*(ndx % 4))))); 2201 #else 2202 reference.set(ndx, (deUint8)(0xffu & (m_value >> (8*(3 - (ndx % 4)))))); 2203 #endif 2204 } 2205 } 2206 2207 class UpdateBuffer : public CmdCommand 2208 { 2209 public: 2210 UpdateBuffer (deUint32 seed) : m_seed(seed) {} 2211 ~UpdateBuffer (void) {} 2212 const char* getName (void) const { return "UpdateBuffer"; } 2213 2214 void logSubmit (TestLog& log, size_t commandIndex) const; 2215 void submit (SubmitContext& context); 2216 void verify (VerifyContext& context, size_t commandIndex); 2217 2218 private: 2219 const deUint32 m_seed; 2220 vk::VkDeviceSize m_bufferSize; 2221 }; 2222 2223 void UpdateBuffer::logSubmit (TestLog& log, size_t commandIndex) const 2224 { 2225 log << TestLog::Message << commandIndex << ":" << getName() << " Update buffer, seed: " << m_seed << TestLog::EndMessage; 2226 } 2227 2228 void UpdateBuffer::submit (SubmitContext& context) 2229 { 2230 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2231 const vk::VkCommandBuffer cmd = context.getCommandBuffer(); 2232 const vk::VkBuffer buffer = context.getBuffer(); 2233 const size_t blockSize = 65536; 2234 std::vector<deUint8> data (blockSize, 0); 2235 de::Random rng (m_seed); 2236 2237 m_bufferSize = context.getBufferSize(); 2238 2239 for (size_t updated = 0; updated < m_bufferSize; updated += blockSize) 2240 { 2241 for (size_t ndx = 0; ndx < data.size(); ndx++) 2242 data[ndx] = rng.getUint8(); 2243 2244 if (m_bufferSize - updated > blockSize) 2245 vkd.cmdUpdateBuffer(cmd, buffer, updated, blockSize, (const deUint32*)(&data[0])); 2246 else 2247 vkd.cmdUpdateBuffer(cmd, buffer, updated, m_bufferSize - updated, (const deUint32*)(&data[0])); 2248 } 2249 } 2250 2251 void UpdateBuffer::verify (VerifyContext& context, size_t) 2252 { 2253 ReferenceMemory& reference = context.getReference(); 2254 const size_t blockSize = 65536; 2255 vector<deUint8> data (blockSize, 0); 2256 de::Random rng (m_seed); 2257 2258 for (size_t updated = 0; updated < m_bufferSize; updated += blockSize) 2259 { 2260 for (size_t ndx = 0; ndx < data.size(); ndx++) 2261 data[ndx] = rng.getUint8(); 2262 2263 if (m_bufferSize - updated > blockSize) 2264 reference.setData(updated, blockSize, &data[0]); 2265 else 2266 reference.setData(updated, (size_t)(m_bufferSize - updated), &data[0]); 2267 } 2268 } 2269 2270 class BufferCopyToBuffer : public CmdCommand 2271 { 2272 public: 2273 BufferCopyToBuffer (void) {} 2274 ~BufferCopyToBuffer (void) {} 2275 const char* getName (void) const { return "BufferCopyToBuffer"; } 2276 2277 void logPrepare (TestLog& log, size_t commandIndex) const; 2278 void prepare (PrepareContext& context); 2279 void logSubmit (TestLog& log, size_t commandIndex) const; 2280 void submit (SubmitContext& context); 2281 void verify (VerifyContext& context, size_t commandIndex); 2282 2283 private: 2284 vk::VkDeviceSize m_bufferSize; 2285 vk::Move<vk::VkBuffer> m_dstBuffer; 2286 vk::Move<vk::VkDeviceMemory> m_memory; 2287 }; 2288 2289 void BufferCopyToBuffer::logPrepare (TestLog& log, size_t commandIndex) const 2290 { 2291 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate destination buffer for buffer to buffer copy." << TestLog::EndMessage; 2292 } 2293 2294 void BufferCopyToBuffer::prepare (PrepareContext& context) 2295 { 2296 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 2297 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2298 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 2299 const vk::VkDevice device = context.getContext().getDevice(); 2300 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 2301 2302 m_bufferSize = context.getBufferSize(); 2303 2304 m_dstBuffer = createBuffer(vkd, device, m_bufferSize, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies); 2305 m_memory = bindBufferMemory(vki, vkd, physicalDevice, device, *m_dstBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); 2306 } 2307 2308 void BufferCopyToBuffer::logSubmit (TestLog& log, size_t commandIndex) const 2309 { 2310 log << TestLog::Message << commandIndex << ":" << getName() << " Copy buffer to another buffer" << TestLog::EndMessage; 2311 } 2312 2313 void BufferCopyToBuffer::submit (SubmitContext& context) 2314 { 2315 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2316 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 2317 const vk::VkBufferCopy range = 2318 { 2319 0, 0, // Offsets 2320 m_bufferSize 2321 }; 2322 2323 vkd.cmdCopyBuffer(commandBuffer, context.getBuffer(), *m_dstBuffer, 1, &range); 2324 } 2325 2326 void BufferCopyToBuffer::verify (VerifyContext& context, size_t commandIndex) 2327 { 2328 tcu::ResultCollector& resultCollector (context.getResultCollector()); 2329 ReferenceMemory& reference (context.getReference()); 2330 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2331 const vk::VkDevice device = context.getContext().getDevice(); 2332 const vk::VkQueue queue = context.getContext().getQueue(); 2333 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 2334 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 2335 const vk::VkBufferMemoryBarrier barrier = 2336 { 2337 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, 2338 DE_NULL, 2339 2340 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 2341 vk::VK_ACCESS_HOST_READ_BIT, 2342 2343 VK_QUEUE_FAMILY_IGNORED, 2344 VK_QUEUE_FAMILY_IGNORED, 2345 *m_dstBuffer, 2346 0, 2347 VK_WHOLE_SIZE 2348 }; 2349 2350 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &barrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL); 2351 2352 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 2353 queueRun(vkd, queue, *commandBuffer); 2354 2355 { 2356 void* const ptr = mapMemory(vkd, device, *m_memory, m_bufferSize); 2357 bool isOk = true; 2358 2359 vk::invalidateMappedMemoryRange(vkd, device, *m_memory, 0, m_bufferSize); 2360 2361 { 2362 const deUint8* const data = (const deUint8*)ptr; 2363 2364 for (size_t pos = 0; pos < (size_t)m_bufferSize; pos++) 2365 { 2366 if (reference.isDefined(pos)) 2367 { 2368 if (data[pos] != reference.get(pos)) 2369 { 2370 resultCollector.fail( 2371 de::toString(commandIndex) + ":" + getName() 2372 + " Result differs from reference, Expected: " 2373 + de::toString(tcu::toHex<8>(reference.get(pos))) 2374 + ", Got: " 2375 + de::toString(tcu::toHex<8>(data[pos])) 2376 + ", At offset: " 2377 + de::toString(pos)); 2378 break; 2379 } 2380 } 2381 } 2382 } 2383 2384 vkd.unmapMemory(device, *m_memory); 2385 2386 if (!isOk) 2387 context.getLog() << TestLog::Message << commandIndex << ": Buffer copy to buffer verification failed" << TestLog::EndMessage; 2388 } 2389 } 2390 2391 class BufferCopyFromBuffer : public CmdCommand 2392 { 2393 public: 2394 BufferCopyFromBuffer (deUint32 seed) : m_seed(seed) {} 2395 ~BufferCopyFromBuffer (void) {} 2396 const char* getName (void) const { return "BufferCopyFromBuffer"; } 2397 2398 void logPrepare (TestLog& log, size_t commandIndex) const; 2399 void prepare (PrepareContext& context); 2400 void logSubmit (TestLog& log, size_t commandIndex) const; 2401 void submit (SubmitContext& context); 2402 void verify (VerifyContext& context, size_t commandIndex); 2403 2404 private: 2405 const deUint32 m_seed; 2406 vk::VkDeviceSize m_bufferSize; 2407 vk::Move<vk::VkBuffer> m_srcBuffer; 2408 vk::Move<vk::VkDeviceMemory> m_memory; 2409 }; 2410 2411 void BufferCopyFromBuffer::logPrepare (TestLog& log, size_t commandIndex) const 2412 { 2413 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate source buffer for buffer to buffer copy. Seed: " << m_seed << TestLog::EndMessage; 2414 } 2415 2416 void BufferCopyFromBuffer::prepare (PrepareContext& context) 2417 { 2418 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 2419 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2420 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 2421 const vk::VkDevice device = context.getContext().getDevice(); 2422 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 2423 2424 m_bufferSize = context.getBufferSize(); 2425 m_srcBuffer = createBuffer(vkd, device, m_bufferSize, vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies); 2426 m_memory = bindBufferMemory(vki, vkd, physicalDevice, device, *m_srcBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); 2427 2428 { 2429 void* const ptr = mapMemory(vkd, device, *m_memory, m_bufferSize); 2430 de::Random rng (m_seed); 2431 2432 { 2433 deUint8* const data = (deUint8*)ptr; 2434 2435 for (size_t ndx = 0; ndx < (size_t)m_bufferSize; ndx++) 2436 data[ndx] = rng.getUint8(); 2437 } 2438 2439 vk::flushMappedMemoryRange(vkd, device, *m_memory, 0, m_bufferSize); 2440 vkd.unmapMemory(device, *m_memory); 2441 } 2442 } 2443 2444 void BufferCopyFromBuffer::logSubmit (TestLog& log, size_t commandIndex) const 2445 { 2446 log << TestLog::Message << commandIndex << ":" << getName() << " Copy buffer data from another buffer" << TestLog::EndMessage; 2447 } 2448 2449 void BufferCopyFromBuffer::submit (SubmitContext& context) 2450 { 2451 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2452 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 2453 const vk::VkBufferCopy range = 2454 { 2455 0, 0, // Offsets 2456 m_bufferSize 2457 }; 2458 2459 vkd.cmdCopyBuffer(commandBuffer, *m_srcBuffer, context.getBuffer(), 1, &range); 2460 } 2461 2462 void BufferCopyFromBuffer::verify (VerifyContext& context, size_t) 2463 { 2464 ReferenceMemory& reference (context.getReference()); 2465 de::Random rng (m_seed); 2466 2467 for (size_t ndx = 0; ndx < (size_t)m_bufferSize; ndx++) 2468 reference.set(ndx, rng.getUint8()); 2469 } 2470 2471 class BufferCopyToImage : public CmdCommand 2472 { 2473 public: 2474 BufferCopyToImage (void) {} 2475 ~BufferCopyToImage (void) {} 2476 const char* getName (void) const { return "BufferCopyToImage"; } 2477 2478 void logPrepare (TestLog& log, size_t commandIndex) const; 2479 void prepare (PrepareContext& context); 2480 void logSubmit (TestLog& log, size_t commandIndex) const; 2481 void submit (SubmitContext& context); 2482 void verify (VerifyContext& context, size_t commandIndex); 2483 2484 private: 2485 deInt32 m_imageWidth; 2486 deInt32 m_imageHeight; 2487 vk::Move<vk::VkImage> m_dstImage; 2488 vk::Move<vk::VkDeviceMemory> m_memory; 2489 }; 2490 2491 void BufferCopyToImage::logPrepare (TestLog& log, size_t commandIndex) const 2492 { 2493 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate destination image for buffer to image copy." << TestLog::EndMessage; 2494 } 2495 2496 void BufferCopyToImage::prepare (PrepareContext& context) 2497 { 2498 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 2499 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2500 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 2501 const vk::VkDevice device = context.getContext().getDevice(); 2502 const vk::VkQueue queue = context.getContext().getQueue(); 2503 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 2504 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 2505 const IVec2 imageSize = findImageSizeWxHx4(context.getBufferSize()); 2506 2507 m_imageWidth = imageSize[0]; 2508 m_imageHeight = imageSize[1]; 2509 2510 { 2511 const vk::VkImageCreateInfo createInfo = 2512 { 2513 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 2514 DE_NULL, 2515 2516 0, 2517 vk::VK_IMAGE_TYPE_2D, 2518 vk::VK_FORMAT_R8G8B8A8_UNORM, 2519 { 2520 (deUint32)m_imageWidth, 2521 (deUint32)m_imageHeight, 2522 1u, 2523 }, 2524 1, 1, // mipLevels, arrayLayers 2525 vk::VK_SAMPLE_COUNT_1_BIT, 2526 2527 vk::VK_IMAGE_TILING_OPTIMAL, 2528 vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT|vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 2529 vk::VK_SHARING_MODE_EXCLUSIVE, 2530 2531 (deUint32)queueFamilies.size(), 2532 &queueFamilies[0], 2533 vk::VK_IMAGE_LAYOUT_UNDEFINED 2534 }; 2535 2536 m_dstImage = vk::createImage(vkd, device, &createInfo); 2537 } 2538 2539 m_memory = bindImageMemory(vki, vkd, physicalDevice, device, *m_dstImage, 0); 2540 2541 { 2542 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 2543 const vk::VkImageMemoryBarrier barrier = 2544 { 2545 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 2546 DE_NULL, 2547 2548 0, 2549 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 2550 2551 vk::VK_IMAGE_LAYOUT_UNDEFINED, 2552 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 2553 2554 VK_QUEUE_FAMILY_IGNORED, 2555 VK_QUEUE_FAMILY_IGNORED, 2556 2557 *m_dstImage, 2558 { 2559 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2560 0, // Mip level 2561 1, // Mip level count 2562 0, // Layer 2563 1 // Layer count 2564 } 2565 }; 2566 2567 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier); 2568 2569 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 2570 queueRun(vkd, queue, *commandBuffer); 2571 } 2572 } 2573 2574 void BufferCopyToImage::logSubmit (TestLog& log, size_t commandIndex) const 2575 { 2576 log << TestLog::Message << commandIndex << ":" << getName() << " Copy buffer to image" << TestLog::EndMessage; 2577 } 2578 2579 void BufferCopyToImage::submit (SubmitContext& context) 2580 { 2581 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2582 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 2583 const vk::VkBufferImageCopy region = 2584 { 2585 0, 2586 0, 0, 2587 { 2588 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2589 0, // mipLevel 2590 0, // arrayLayer 2591 1 // layerCount 2592 }, 2593 { 0, 0, 0 }, 2594 { 2595 (deUint32)m_imageWidth, 2596 (deUint32)m_imageHeight, 2597 1u 2598 } 2599 }; 2600 2601 vkd.cmdCopyBufferToImage(commandBuffer, context.getBuffer(), *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); 2602 } 2603 2604 void BufferCopyToImage::verify (VerifyContext& context, size_t commandIndex) 2605 { 2606 tcu::ResultCollector& resultCollector (context.getResultCollector()); 2607 ReferenceMemory& reference (context.getReference()); 2608 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 2609 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2610 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 2611 const vk::VkDevice device = context.getContext().getDevice(); 2612 const vk::VkQueue queue = context.getContext().getQueue(); 2613 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 2614 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 2615 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 2616 const vk::Unique<vk::VkBuffer> dstBuffer (createBuffer(vkd, device, 4 * m_imageWidth * m_imageHeight, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies)); 2617 const vk::Unique<vk::VkDeviceMemory> memory (bindBufferMemory(vki, vkd, physicalDevice, device, *dstBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); 2618 { 2619 const vk::VkImageMemoryBarrier imageBarrier = 2620 { 2621 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 2622 DE_NULL, 2623 2624 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 2625 vk::VK_ACCESS_TRANSFER_READ_BIT, 2626 2627 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 2628 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 2629 2630 VK_QUEUE_FAMILY_IGNORED, 2631 VK_QUEUE_FAMILY_IGNORED, 2632 2633 *m_dstImage, 2634 { 2635 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2636 0, // Mip level 2637 1, // Mip level count 2638 0, // Layer 2639 1 // Layer count 2640 } 2641 }; 2642 const vk::VkBufferMemoryBarrier bufferBarrier = 2643 { 2644 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, 2645 DE_NULL, 2646 2647 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 2648 vk::VK_ACCESS_HOST_READ_BIT, 2649 2650 VK_QUEUE_FAMILY_IGNORED, 2651 VK_QUEUE_FAMILY_IGNORED, 2652 *dstBuffer, 2653 0, 2654 VK_WHOLE_SIZE 2655 }; 2656 2657 const vk::VkBufferImageCopy region = 2658 { 2659 0, 2660 0, 0, 2661 { 2662 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2663 0, // mipLevel 2664 0, // arrayLayer 2665 1 // layerCount 2666 }, 2667 { 0, 0, 0 }, 2668 { 2669 (deUint32)m_imageWidth, 2670 (deUint32)m_imageHeight, 2671 1u 2672 } 2673 }; 2674 2675 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier); 2676 vkd.cmdCopyImageToBuffer(*commandBuffer, *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dstBuffer, 1, ®ion); 2677 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL); 2678 } 2679 2680 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 2681 queueRun(vkd, queue, *commandBuffer); 2682 2683 { 2684 void* const ptr = mapMemory(vkd, device, *memory, 4 * m_imageWidth * m_imageHeight); 2685 2686 vk::invalidateMappedMemoryRange(vkd, device, *memory, 0, 4 * m_imageWidth * m_imageHeight); 2687 2688 { 2689 const deUint8* const data = (const deUint8*)ptr; 2690 2691 for (size_t pos = 0; pos < (size_t)( 4 * m_imageWidth * m_imageHeight); pos++) 2692 { 2693 if (reference.isDefined(pos)) 2694 { 2695 if (data[pos] != reference.get(pos)) 2696 { 2697 resultCollector.fail( 2698 de::toString(commandIndex) + ":" + getName() 2699 + " Result differs from reference, Expected: " 2700 + de::toString(tcu::toHex<8>(reference.get(pos))) 2701 + ", Got: " 2702 + de::toString(tcu::toHex<8>(data[pos])) 2703 + ", At offset: " 2704 + de::toString(pos)); 2705 break; 2706 } 2707 } 2708 } 2709 } 2710 2711 vkd.unmapMemory(device, *memory); 2712 } 2713 } 2714 2715 class BufferCopyFromImage : public CmdCommand 2716 { 2717 public: 2718 BufferCopyFromImage (deUint32 seed) : m_seed(seed) {} 2719 ~BufferCopyFromImage (void) {} 2720 const char* getName (void) const { return "BufferCopyFromImage"; } 2721 2722 void logPrepare (TestLog& log, size_t commandIndex) const; 2723 void prepare (PrepareContext& context); 2724 void logSubmit (TestLog& log, size_t commandIndex) const; 2725 void submit (SubmitContext& context); 2726 void verify (VerifyContext& context, size_t commandIndex); 2727 2728 private: 2729 const deUint32 m_seed; 2730 deInt32 m_imageWidth; 2731 deInt32 m_imageHeight; 2732 vk::Move<vk::VkImage> m_srcImage; 2733 vk::Move<vk::VkDeviceMemory> m_memory; 2734 }; 2735 2736 void BufferCopyFromImage::logPrepare (TestLog& log, size_t commandIndex) const 2737 { 2738 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate source image for image to buffer copy." << TestLog::EndMessage; 2739 } 2740 2741 void BufferCopyFromImage::prepare (PrepareContext& context) 2742 { 2743 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 2744 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2745 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 2746 const vk::VkDevice device = context.getContext().getDevice(); 2747 const vk::VkQueue queue = context.getContext().getQueue(); 2748 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 2749 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 2750 const IVec2 imageSize = findImageSizeWxHx4(context.getBufferSize()); 2751 2752 m_imageWidth = imageSize[0]; 2753 m_imageHeight = imageSize[1]; 2754 2755 { 2756 const vk::VkImageCreateInfo createInfo = 2757 { 2758 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 2759 DE_NULL, 2760 2761 0, 2762 vk::VK_IMAGE_TYPE_2D, 2763 vk::VK_FORMAT_R8G8B8A8_UNORM, 2764 { 2765 (deUint32)m_imageWidth, 2766 (deUint32)m_imageHeight, 2767 1u, 2768 }, 2769 1, 1, // mipLevels, arrayLayers 2770 vk::VK_SAMPLE_COUNT_1_BIT, 2771 2772 vk::VK_IMAGE_TILING_OPTIMAL, 2773 vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT|vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 2774 vk::VK_SHARING_MODE_EXCLUSIVE, 2775 2776 (deUint32)queueFamilies.size(), 2777 &queueFamilies[0], 2778 vk::VK_IMAGE_LAYOUT_UNDEFINED 2779 }; 2780 2781 m_srcImage = vk::createImage(vkd, device, &createInfo); 2782 } 2783 2784 m_memory = bindImageMemory(vki, vkd, physicalDevice, device, *m_srcImage, 0); 2785 2786 { 2787 const vk::Unique<vk::VkBuffer> srcBuffer (createBuffer(vkd, device, 4 * m_imageWidth * m_imageHeight, vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies)); 2788 const vk::Unique<vk::VkDeviceMemory> memory (bindBufferMemory(vki, vkd, physicalDevice, device, *srcBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); 2789 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 2790 const vk::VkImageMemoryBarrier preImageBarrier = 2791 { 2792 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 2793 DE_NULL, 2794 2795 0, 2796 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 2797 2798 vk::VK_IMAGE_LAYOUT_UNDEFINED, 2799 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 2800 2801 VK_QUEUE_FAMILY_IGNORED, 2802 VK_QUEUE_FAMILY_IGNORED, 2803 2804 *m_srcImage, 2805 { 2806 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2807 0, // Mip level 2808 1, // Mip level count 2809 0, // Layer 2810 1 // Layer count 2811 } 2812 }; 2813 const vk::VkImageMemoryBarrier postImageBarrier = 2814 { 2815 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 2816 DE_NULL, 2817 2818 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 2819 0, 2820 2821 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 2822 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 2823 2824 VK_QUEUE_FAMILY_IGNORED, 2825 VK_QUEUE_FAMILY_IGNORED, 2826 2827 *m_srcImage, 2828 { 2829 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2830 0, // Mip level 2831 1, // Mip level count 2832 0, // Layer 2833 1 // Layer count 2834 } 2835 }; 2836 const vk::VkBufferImageCopy region = 2837 { 2838 0, 2839 0, 0, 2840 { 2841 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2842 0, // mipLevel 2843 0, // arrayLayer 2844 1 // layerCount 2845 }, 2846 { 0, 0, 0 }, 2847 { 2848 (deUint32)m_imageWidth, 2849 (deUint32)m_imageHeight, 2850 1u 2851 } 2852 }; 2853 2854 { 2855 void* const ptr = mapMemory(vkd, device, *memory, 4 * m_imageWidth * m_imageHeight); 2856 de::Random rng (m_seed); 2857 2858 { 2859 deUint8* const data = (deUint8*)ptr; 2860 2861 for (size_t ndx = 0; ndx < (size_t)(4 * m_imageWidth * m_imageHeight); ndx++) 2862 data[ndx] = rng.getUint8(); 2863 } 2864 2865 vk::flushMappedMemoryRange(vkd, device, *memory, 0, 4 * m_imageWidth * m_imageHeight); 2866 vkd.unmapMemory(device, *memory); 2867 } 2868 2869 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &preImageBarrier); 2870 vkd.cmdCopyBufferToImage(*commandBuffer, *srcBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); 2871 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier); 2872 2873 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 2874 queueRun(vkd, queue, *commandBuffer); 2875 } 2876 } 2877 2878 void BufferCopyFromImage::logSubmit (TestLog& log, size_t commandIndex) const 2879 { 2880 log << TestLog::Message << commandIndex << ":" << getName() << " Copy buffer data from image" << TestLog::EndMessage; 2881 } 2882 2883 void BufferCopyFromImage::submit (SubmitContext& context) 2884 { 2885 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2886 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 2887 const vk::VkBufferImageCopy region = 2888 { 2889 0, 2890 0, 0, 2891 { 2892 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2893 0, // mipLevel 2894 0, // arrayLayer 2895 1 // layerCount 2896 }, 2897 { 0, 0, 0 }, 2898 { 2899 (deUint32)m_imageWidth, 2900 (deUint32)m_imageHeight, 2901 1u 2902 } 2903 }; 2904 2905 vkd.cmdCopyImageToBuffer(commandBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, context.getBuffer(), 1, ®ion); 2906 } 2907 2908 void BufferCopyFromImage::verify (VerifyContext& context, size_t) 2909 { 2910 ReferenceMemory& reference (context.getReference()); 2911 de::Random rng (m_seed); 2912 2913 for (size_t ndx = 0; ndx < (size_t)(4 * m_imageWidth * m_imageHeight); ndx++) 2914 reference.set(ndx, rng.getUint8()); 2915 } 2916 2917 class ImageCopyToBuffer : public CmdCommand 2918 { 2919 public: 2920 ImageCopyToBuffer (vk::VkImageLayout imageLayout) : m_imageLayout (imageLayout) {} 2921 ~ImageCopyToBuffer (void) {} 2922 const char* getName (void) const { return "BufferCopyToImage"; } 2923 2924 void logPrepare (TestLog& log, size_t commandIndex) const; 2925 void prepare (PrepareContext& context); 2926 void logSubmit (TestLog& log, size_t commandIndex) const; 2927 void submit (SubmitContext& context); 2928 void verify (VerifyContext& context, size_t commandIndex); 2929 2930 private: 2931 vk::VkImageLayout m_imageLayout; 2932 vk::VkDeviceSize m_bufferSize; 2933 vk::Move<vk::VkBuffer> m_dstBuffer; 2934 vk::Move<vk::VkDeviceMemory> m_memory; 2935 vk::VkDeviceSize m_imageMemorySize; 2936 deInt32 m_imageWidth; 2937 deInt32 m_imageHeight; 2938 }; 2939 2940 void ImageCopyToBuffer::logPrepare (TestLog& log, size_t commandIndex) const 2941 { 2942 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate destination buffer for image to buffer copy." << TestLog::EndMessage; 2943 } 2944 2945 void ImageCopyToBuffer::prepare (PrepareContext& context) 2946 { 2947 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 2948 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2949 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 2950 const vk::VkDevice device = context.getContext().getDevice(); 2951 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 2952 2953 m_imageWidth = context.getImageWidth(); 2954 m_imageHeight = context.getImageHeight(); 2955 m_bufferSize = 4 * m_imageWidth * m_imageHeight; 2956 m_imageMemorySize = context.getImageMemorySize(); 2957 m_dstBuffer = createBuffer(vkd, device, m_bufferSize, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies); 2958 m_memory = bindBufferMemory(vki, vkd, physicalDevice, device, *m_dstBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); 2959 } 2960 2961 void ImageCopyToBuffer::logSubmit (TestLog& log, size_t commandIndex) const 2962 { 2963 log << TestLog::Message << commandIndex << ":" << getName() << " Copy image to buffer" << TestLog::EndMessage; 2964 } 2965 2966 void ImageCopyToBuffer::submit (SubmitContext& context) 2967 { 2968 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2969 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 2970 const vk::VkBufferImageCopy region = 2971 { 2972 0, 2973 0, 0, 2974 { 2975 vk::VK_IMAGE_ASPECT_COLOR_BIT, 2976 0, // mipLevel 2977 0, // arrayLayer 2978 1 // layerCount 2979 }, 2980 { 0, 0, 0 }, 2981 { 2982 (deUint32)m_imageWidth, 2983 (deUint32)m_imageHeight, 2984 1u 2985 } 2986 }; 2987 2988 vkd.cmdCopyImageToBuffer(commandBuffer, context.getImage(), m_imageLayout, *m_dstBuffer, 1, ®ion); 2989 } 2990 2991 void ImageCopyToBuffer::verify (VerifyContext& context, size_t commandIndex) 2992 { 2993 tcu::ResultCollector& resultCollector (context.getResultCollector()); 2994 ReferenceMemory& reference (context.getReference()); 2995 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 2996 const vk::VkDevice device = context.getContext().getDevice(); 2997 const vk::VkQueue queue = context.getContext().getQueue(); 2998 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 2999 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 3000 const vk::VkBufferMemoryBarrier barrier = 3001 { 3002 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, 3003 DE_NULL, 3004 3005 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 3006 vk::VK_ACCESS_HOST_READ_BIT, 3007 3008 VK_QUEUE_FAMILY_IGNORED, 3009 VK_QUEUE_FAMILY_IGNORED, 3010 *m_dstBuffer, 3011 0, 3012 VK_WHOLE_SIZE 3013 }; 3014 3015 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &barrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL); 3016 3017 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 3018 queueRun(vkd, queue, *commandBuffer); 3019 3020 reference.setUndefined(0, (size_t)m_imageMemorySize); 3021 { 3022 void* const ptr = mapMemory(vkd, device, *m_memory, m_bufferSize); 3023 const ConstPixelBufferAccess referenceImage (context.getReferenceImage().getAccess()); 3024 const ConstPixelBufferAccess resultImage (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_imageWidth, m_imageHeight, 1, ptr); 3025 3026 vk::invalidateMappedMemoryRange(vkd, device, *m_memory, 0, m_bufferSize); 3027 3028 if (!tcu::intThresholdCompare(context.getLog(), (de::toString(commandIndex) + ":" + getName()).c_str(), (de::toString(commandIndex) + ":" + getName()).c_str(), referenceImage, resultImage, UVec4(0), tcu::COMPARE_LOG_ON_ERROR)) 3029 resultCollector.fail(de::toString(commandIndex) + ":" + getName() + " Image comparison failed"); 3030 3031 vkd.unmapMemory(device, *m_memory); 3032 } 3033 } 3034 3035 class ImageCopyFromBuffer : public CmdCommand 3036 { 3037 public: 3038 ImageCopyFromBuffer (deUint32 seed, vk::VkImageLayout imageLayout) : m_seed(seed), m_imageLayout(imageLayout) {} 3039 ~ImageCopyFromBuffer (void) {} 3040 const char* getName (void) const { return "ImageCopyFromBuffer"; } 3041 3042 void logPrepare (TestLog& log, size_t commandIndex) const; 3043 void prepare (PrepareContext& context); 3044 void logSubmit (TestLog& log, size_t commandIndex) const; 3045 void submit (SubmitContext& context); 3046 void verify (VerifyContext& context, size_t commandIndex); 3047 3048 private: 3049 const deUint32 m_seed; 3050 const vk::VkImageLayout m_imageLayout; 3051 deInt32 m_imageWidth; 3052 deInt32 m_imageHeight; 3053 vk::VkDeviceSize m_imageMemorySize; 3054 vk::VkDeviceSize m_bufferSize; 3055 vk::Move<vk::VkBuffer> m_srcBuffer; 3056 vk::Move<vk::VkDeviceMemory> m_memory; 3057 }; 3058 3059 void ImageCopyFromBuffer::logPrepare (TestLog& log, size_t commandIndex) const 3060 { 3061 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate source buffer for buffer to image copy. Seed: " << m_seed << TestLog::EndMessage; 3062 } 3063 3064 void ImageCopyFromBuffer::prepare (PrepareContext& context) 3065 { 3066 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 3067 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3068 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 3069 const vk::VkDevice device = context.getContext().getDevice(); 3070 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 3071 3072 m_imageWidth = context.getImageHeight(); 3073 m_imageHeight = context.getImageWidth(); 3074 m_imageMemorySize = context.getImageMemorySize(); 3075 m_bufferSize = m_imageWidth * m_imageHeight * 4; 3076 m_srcBuffer = createBuffer(vkd, device, m_bufferSize, vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies); 3077 m_memory = bindBufferMemory(vki, vkd, physicalDevice, device, *m_srcBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); 3078 3079 { 3080 void* const ptr = mapMemory(vkd, device, *m_memory, m_bufferSize); 3081 de::Random rng (m_seed); 3082 3083 { 3084 deUint8* const data = (deUint8*)ptr; 3085 3086 for (size_t ndx = 0; ndx < (size_t)m_bufferSize; ndx++) 3087 data[ndx] = rng.getUint8(); 3088 } 3089 3090 vk::flushMappedMemoryRange(vkd, device, *m_memory, 0, m_bufferSize); 3091 vkd.unmapMemory(device, *m_memory); 3092 } 3093 } 3094 3095 void ImageCopyFromBuffer::logSubmit (TestLog& log, size_t commandIndex) const 3096 { 3097 log << TestLog::Message << commandIndex << ":" << getName() << " Copy image data from buffer" << TestLog::EndMessage; 3098 } 3099 3100 void ImageCopyFromBuffer::submit (SubmitContext& context) 3101 { 3102 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3103 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 3104 const vk::VkBufferImageCopy region = 3105 { 3106 0, 3107 0, 0, 3108 { 3109 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3110 0, // mipLevel 3111 0, // arrayLayer 3112 1 // layerCount 3113 }, 3114 { 0, 0, 0 }, 3115 { 3116 (deUint32)m_imageWidth, 3117 (deUint32)m_imageHeight, 3118 1u 3119 } 3120 }; 3121 3122 vkd.cmdCopyBufferToImage(commandBuffer, *m_srcBuffer, context.getImage(), m_imageLayout, 1, ®ion); 3123 } 3124 3125 void ImageCopyFromBuffer::verify (VerifyContext& context, size_t) 3126 { 3127 ReferenceMemory& reference (context.getReference()); 3128 de::Random rng (m_seed); 3129 3130 reference.setUndefined(0, (size_t)m_imageMemorySize); 3131 3132 { 3133 const PixelBufferAccess& refAccess (context.getReferenceImage().getAccess()); 3134 3135 for (deInt32 y = 0; y < m_imageHeight; y++) 3136 for (deInt32 x = 0; x < m_imageWidth; x++) 3137 { 3138 const deUint8 r8 = rng.getUint8(); 3139 const deUint8 g8 = rng.getUint8(); 3140 const deUint8 b8 = rng.getUint8(); 3141 const deUint8 a8 = rng.getUint8(); 3142 3143 refAccess.setPixel(UVec4(r8, g8, b8, a8), x, y); 3144 } 3145 } 3146 } 3147 3148 class ImageCopyFromImage : public CmdCommand 3149 { 3150 public: 3151 ImageCopyFromImage (deUint32 seed, vk::VkImageLayout imageLayout) : m_seed(seed), m_imageLayout(imageLayout) {} 3152 ~ImageCopyFromImage (void) {} 3153 const char* getName (void) const { return "ImageCopyFromImage"; } 3154 3155 void logPrepare (TestLog& log, size_t commandIndex) const; 3156 void prepare (PrepareContext& context); 3157 void logSubmit (TestLog& log, size_t commandIndex) const; 3158 void submit (SubmitContext& context); 3159 void verify (VerifyContext& context, size_t commandIndex); 3160 3161 private: 3162 const deUint32 m_seed; 3163 const vk::VkImageLayout m_imageLayout; 3164 deInt32 m_imageWidth; 3165 deInt32 m_imageHeight; 3166 vk::VkDeviceSize m_imageMemorySize; 3167 vk::Move<vk::VkImage> m_srcImage; 3168 vk::Move<vk::VkDeviceMemory> m_memory; 3169 }; 3170 3171 void ImageCopyFromImage::logPrepare (TestLog& log, size_t commandIndex) const 3172 { 3173 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate source image for image to image copy." << TestLog::EndMessage; 3174 } 3175 3176 void ImageCopyFromImage::prepare (PrepareContext& context) 3177 { 3178 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 3179 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3180 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 3181 const vk::VkDevice device = context.getContext().getDevice(); 3182 const vk::VkQueue queue = context.getContext().getQueue(); 3183 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 3184 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 3185 3186 m_imageWidth = context.getImageWidth(); 3187 m_imageHeight = context.getImageHeight(); 3188 m_imageMemorySize = context.getImageMemorySize(); 3189 3190 { 3191 const vk::VkImageCreateInfo createInfo = 3192 { 3193 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 3194 DE_NULL, 3195 3196 0, 3197 vk::VK_IMAGE_TYPE_2D, 3198 vk::VK_FORMAT_R8G8B8A8_UNORM, 3199 { 3200 (deUint32)m_imageWidth, 3201 (deUint32)m_imageHeight, 3202 1u, 3203 }, 3204 1, 1, // mipLevels, arrayLayers 3205 vk::VK_SAMPLE_COUNT_1_BIT, 3206 3207 vk::VK_IMAGE_TILING_OPTIMAL, 3208 vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT|vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 3209 vk::VK_SHARING_MODE_EXCLUSIVE, 3210 3211 (deUint32)queueFamilies.size(), 3212 &queueFamilies[0], 3213 vk::VK_IMAGE_LAYOUT_UNDEFINED 3214 }; 3215 3216 m_srcImage = vk::createImage(vkd, device, &createInfo); 3217 } 3218 3219 m_memory = bindImageMemory(vki, vkd, physicalDevice, device, *m_srcImage, 0); 3220 3221 { 3222 const vk::Unique<vk::VkBuffer> srcBuffer (createBuffer(vkd, device, 4 * m_imageWidth * m_imageHeight, vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies)); 3223 const vk::Unique<vk::VkDeviceMemory> memory (bindBufferMemory(vki, vkd, physicalDevice, device, *srcBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); 3224 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 3225 const vk::VkImageMemoryBarrier preImageBarrier = 3226 { 3227 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 3228 DE_NULL, 3229 3230 0, 3231 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 3232 3233 vk::VK_IMAGE_LAYOUT_UNDEFINED, 3234 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 3235 3236 VK_QUEUE_FAMILY_IGNORED, 3237 VK_QUEUE_FAMILY_IGNORED, 3238 3239 *m_srcImage, 3240 { 3241 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3242 0, // Mip level 3243 1, // Mip level count 3244 0, // Layer 3245 1 // Layer count 3246 } 3247 }; 3248 const vk::VkImageMemoryBarrier postImageBarrier = 3249 { 3250 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 3251 DE_NULL, 3252 3253 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 3254 0, 3255 3256 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 3257 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 3258 3259 VK_QUEUE_FAMILY_IGNORED, 3260 VK_QUEUE_FAMILY_IGNORED, 3261 3262 *m_srcImage, 3263 { 3264 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3265 0, // Mip level 3266 1, // Mip level count 3267 0, // Layer 3268 1 // Layer count 3269 } 3270 }; 3271 const vk::VkBufferImageCopy region = 3272 { 3273 0, 3274 0, 0, 3275 { 3276 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3277 0, // mipLevel 3278 0, // arrayLayer 3279 1 // layerCount 3280 }, 3281 { 0, 0, 0 }, 3282 { 3283 (deUint32)m_imageWidth, 3284 (deUint32)m_imageHeight, 3285 1u 3286 } 3287 }; 3288 3289 { 3290 void* const ptr = mapMemory(vkd, device, *memory, 4 * m_imageWidth * m_imageHeight); 3291 de::Random rng (m_seed); 3292 3293 { 3294 deUint8* const data = (deUint8*)ptr; 3295 3296 for (size_t ndx = 0; ndx < (size_t)(4 * m_imageWidth * m_imageHeight); ndx++) 3297 data[ndx] = rng.getUint8(); 3298 } 3299 3300 vk::flushMappedMemoryRange(vkd, device, *memory, 0, 4 * m_imageWidth * m_imageHeight); 3301 vkd.unmapMemory(device, *memory); 3302 } 3303 3304 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &preImageBarrier); 3305 vkd.cmdCopyBufferToImage(*commandBuffer, *srcBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); 3306 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier); 3307 3308 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 3309 queueRun(vkd, queue, *commandBuffer); 3310 } 3311 } 3312 3313 void ImageCopyFromImage::logSubmit (TestLog& log, size_t commandIndex) const 3314 { 3315 log << TestLog::Message << commandIndex << ":" << getName() << " Copy image data from another image" << TestLog::EndMessage; 3316 } 3317 3318 void ImageCopyFromImage::submit (SubmitContext& context) 3319 { 3320 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3321 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 3322 const vk::VkImageCopy region = 3323 { 3324 { 3325 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3326 0, // mipLevel 3327 0, // arrayLayer 3328 1 // layerCount 3329 }, 3330 { 0, 0, 0 }, 3331 3332 { 3333 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3334 0, // mipLevel 3335 0, // arrayLayer 3336 1 // layerCount 3337 }, 3338 { 0, 0, 0 }, 3339 { 3340 (deUint32)m_imageWidth, 3341 (deUint32)m_imageHeight, 3342 1u 3343 } 3344 }; 3345 3346 vkd.cmdCopyImage(commandBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, context.getImage(), m_imageLayout, 1, ®ion); 3347 } 3348 3349 void ImageCopyFromImage::verify (VerifyContext& context, size_t) 3350 { 3351 ReferenceMemory& reference (context.getReference()); 3352 de::Random rng (m_seed); 3353 3354 reference.setUndefined(0, (size_t)m_imageMemorySize); 3355 3356 { 3357 const PixelBufferAccess& refAccess (context.getReferenceImage().getAccess()); 3358 3359 for (deInt32 y = 0; y < m_imageHeight; y++) 3360 for (deInt32 x = 0; x < m_imageWidth; x++) 3361 { 3362 const deUint8 r8 = rng.getUint8(); 3363 const deUint8 g8 = rng.getUint8(); 3364 const deUint8 b8 = rng.getUint8(); 3365 const deUint8 a8 = rng.getUint8(); 3366 3367 refAccess.setPixel(UVec4(r8, g8, b8, a8), x, y); 3368 } 3369 } 3370 } 3371 3372 class ImageCopyToImage : public CmdCommand 3373 { 3374 public: 3375 ImageCopyToImage (vk::VkImageLayout imageLayout) : m_imageLayout(imageLayout) {} 3376 ~ImageCopyToImage (void) {} 3377 const char* getName (void) const { return "ImageCopyToImage"; } 3378 3379 void logPrepare (TestLog& log, size_t commandIndex) const; 3380 void prepare (PrepareContext& context); 3381 void logSubmit (TestLog& log, size_t commandIndex) const; 3382 void submit (SubmitContext& context); 3383 void verify (VerifyContext& context, size_t commandIndex); 3384 3385 private: 3386 const vk::VkImageLayout m_imageLayout; 3387 deInt32 m_imageWidth; 3388 deInt32 m_imageHeight; 3389 vk::VkDeviceSize m_imageMemorySize; 3390 vk::Move<vk::VkImage> m_dstImage; 3391 vk::Move<vk::VkDeviceMemory> m_memory; 3392 }; 3393 3394 void ImageCopyToImage::logPrepare (TestLog& log, size_t commandIndex) const 3395 { 3396 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate destination image for image to image copy." << TestLog::EndMessage; 3397 } 3398 3399 void ImageCopyToImage::prepare (PrepareContext& context) 3400 { 3401 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 3402 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3403 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 3404 const vk::VkDevice device = context.getContext().getDevice(); 3405 const vk::VkQueue queue = context.getContext().getQueue(); 3406 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 3407 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 3408 3409 m_imageWidth = context.getImageWidth(); 3410 m_imageHeight = context.getImageHeight(); 3411 m_imageMemorySize = context.getImageMemorySize(); 3412 3413 { 3414 const vk::VkImageCreateInfo createInfo = 3415 { 3416 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 3417 DE_NULL, 3418 3419 0, 3420 vk::VK_IMAGE_TYPE_2D, 3421 vk::VK_FORMAT_R8G8B8A8_UNORM, 3422 { 3423 (deUint32)m_imageWidth, 3424 (deUint32)m_imageHeight, 3425 1u, 3426 }, 3427 1, 1, // mipLevels, arrayLayers 3428 vk::VK_SAMPLE_COUNT_1_BIT, 3429 3430 vk::VK_IMAGE_TILING_OPTIMAL, 3431 vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT|vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 3432 vk::VK_SHARING_MODE_EXCLUSIVE, 3433 3434 (deUint32)queueFamilies.size(), 3435 &queueFamilies[0], 3436 vk::VK_IMAGE_LAYOUT_UNDEFINED 3437 }; 3438 3439 m_dstImage = vk::createImage(vkd, device, &createInfo); 3440 } 3441 3442 m_memory = bindImageMemory(vki, vkd, physicalDevice, device, *m_dstImage, 0); 3443 3444 { 3445 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 3446 const vk::VkImageMemoryBarrier barrier = 3447 { 3448 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 3449 DE_NULL, 3450 3451 0, 3452 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 3453 3454 vk::VK_IMAGE_LAYOUT_UNDEFINED, 3455 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 3456 3457 VK_QUEUE_FAMILY_IGNORED, 3458 VK_QUEUE_FAMILY_IGNORED, 3459 3460 *m_dstImage, 3461 { 3462 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3463 0, // Mip level 3464 1, // Mip level count 3465 0, // Layer 3466 1 // Layer count 3467 } 3468 }; 3469 3470 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier); 3471 3472 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 3473 queueRun(vkd, queue, *commandBuffer); 3474 } 3475 } 3476 3477 void ImageCopyToImage::logSubmit (TestLog& log, size_t commandIndex) const 3478 { 3479 log << TestLog::Message << commandIndex << ":" << getName() << " Copy image to another image" << TestLog::EndMessage; 3480 } 3481 3482 void ImageCopyToImage::submit (SubmitContext& context) 3483 { 3484 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3485 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 3486 const vk::VkImageCopy region = 3487 { 3488 { 3489 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3490 0, // mipLevel 3491 0, // arrayLayer 3492 1 // layerCount 3493 }, 3494 { 0, 0, 0 }, 3495 3496 { 3497 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3498 0, // mipLevel 3499 0, // arrayLayer 3500 1 // layerCount 3501 }, 3502 { 0, 0, 0 }, 3503 { 3504 (deUint32)m_imageWidth, 3505 (deUint32)m_imageHeight, 3506 1u 3507 } 3508 }; 3509 3510 vkd.cmdCopyImage(commandBuffer, context.getImage(), m_imageLayout, *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); 3511 } 3512 3513 void ImageCopyToImage::verify (VerifyContext& context, size_t commandIndex) 3514 { 3515 tcu::ResultCollector& resultCollector (context.getResultCollector()); 3516 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 3517 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3518 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 3519 const vk::VkDevice device = context.getContext().getDevice(); 3520 const vk::VkQueue queue = context.getContext().getQueue(); 3521 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 3522 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 3523 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 3524 const vk::Unique<vk::VkBuffer> dstBuffer (createBuffer(vkd, device, 4 * m_imageWidth * m_imageHeight, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies)); 3525 const vk::Unique<vk::VkDeviceMemory> memory (bindBufferMemory(vki, vkd, physicalDevice, device, *dstBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); 3526 { 3527 const vk::VkImageMemoryBarrier imageBarrier = 3528 { 3529 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 3530 DE_NULL, 3531 3532 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 3533 vk::VK_ACCESS_TRANSFER_READ_BIT, 3534 3535 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 3536 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 3537 3538 VK_QUEUE_FAMILY_IGNORED, 3539 VK_QUEUE_FAMILY_IGNORED, 3540 3541 *m_dstImage, 3542 { 3543 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3544 0, // Mip level 3545 1, // Mip level count 3546 0, // Layer 3547 1 // Layer count 3548 } 3549 }; 3550 const vk::VkBufferMemoryBarrier bufferBarrier = 3551 { 3552 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, 3553 DE_NULL, 3554 3555 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 3556 vk::VK_ACCESS_HOST_READ_BIT, 3557 3558 VK_QUEUE_FAMILY_IGNORED, 3559 VK_QUEUE_FAMILY_IGNORED, 3560 *dstBuffer, 3561 0, 3562 VK_WHOLE_SIZE 3563 }; 3564 const vk::VkBufferImageCopy region = 3565 { 3566 0, 3567 0, 0, 3568 { 3569 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3570 0, // mipLevel 3571 0, // arrayLayer 3572 1 // layerCount 3573 }, 3574 { 0, 0, 0 }, 3575 { 3576 (deUint32)m_imageWidth, 3577 (deUint32)m_imageHeight, 3578 1u 3579 } 3580 }; 3581 3582 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier); 3583 vkd.cmdCopyImageToBuffer(*commandBuffer, *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dstBuffer, 1, ®ion); 3584 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL); 3585 } 3586 3587 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 3588 queueRun(vkd, queue, *commandBuffer); 3589 3590 { 3591 void* const ptr = mapMemory(vkd, device, *memory, 4 * m_imageWidth * m_imageHeight); 3592 3593 vk::invalidateMappedMemoryRange(vkd, device, *memory, 0, 4 * m_imageWidth * m_imageHeight); 3594 3595 { 3596 const deUint8* const data = (const deUint8*)ptr; 3597 const ConstPixelBufferAccess resAccess (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_imageWidth, m_imageHeight, 1, data); 3598 const ConstPixelBufferAccess& refAccess (context.getReferenceImage().getAccess()); 3599 3600 if (!tcu::intThresholdCompare(context.getLog(), (de::toString(commandIndex) + ":" + getName()).c_str(), (de::toString(commandIndex) + ":" + getName()).c_str(), refAccess, resAccess, UVec4(0), tcu::COMPARE_LOG_ON_ERROR)) 3601 resultCollector.fail(de::toString(commandIndex) + ":" + getName() + " Image comparison failed"); 3602 } 3603 3604 vkd.unmapMemory(device, *memory); 3605 } 3606 } 3607 3608 enum BlitScale 3609 { 3610 BLIT_SCALE_20, 3611 BLIT_SCALE_10, 3612 }; 3613 3614 class ImageBlitFromImage : public CmdCommand 3615 { 3616 public: 3617 ImageBlitFromImage (deUint32 seed, BlitScale scale, vk::VkImageLayout imageLayout) : m_seed(seed), m_scale(scale), m_imageLayout(imageLayout) {} 3618 ~ImageBlitFromImage (void) {} 3619 const char* getName (void) const { return "ImageBlitFromImage"; } 3620 3621 void logPrepare (TestLog& log, size_t commandIndex) const; 3622 void prepare (PrepareContext& context); 3623 void logSubmit (TestLog& log, size_t commandIndex) const; 3624 void submit (SubmitContext& context); 3625 void verify (VerifyContext& context, size_t commandIndex); 3626 3627 private: 3628 const deUint32 m_seed; 3629 const BlitScale m_scale; 3630 const vk::VkImageLayout m_imageLayout; 3631 deInt32 m_imageWidth; 3632 deInt32 m_imageHeight; 3633 vk::VkDeviceSize m_imageMemorySize; 3634 deInt32 m_srcImageWidth; 3635 deInt32 m_srcImageHeight; 3636 vk::Move<vk::VkImage> m_srcImage; 3637 vk::Move<vk::VkDeviceMemory> m_memory; 3638 }; 3639 3640 void ImageBlitFromImage::logPrepare (TestLog& log, size_t commandIndex) const 3641 { 3642 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate source image for image to image blit." << TestLog::EndMessage; 3643 } 3644 3645 void ImageBlitFromImage::prepare (PrepareContext& context) 3646 { 3647 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 3648 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3649 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 3650 const vk::VkDevice device = context.getContext().getDevice(); 3651 const vk::VkQueue queue = context.getContext().getQueue(); 3652 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 3653 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 3654 3655 m_imageWidth = context.getImageWidth(); 3656 m_imageHeight = context.getImageHeight(); 3657 m_imageMemorySize = context.getImageMemorySize(); 3658 3659 if (m_scale == BLIT_SCALE_10) 3660 { 3661 m_srcImageWidth = m_imageWidth; 3662 m_srcImageHeight = m_imageHeight; 3663 } 3664 else if (m_scale == BLIT_SCALE_20) 3665 { 3666 m_srcImageWidth = m_imageWidth / 2; 3667 m_srcImageHeight = m_imageHeight / 2; 3668 } 3669 else 3670 DE_FATAL("Unsupported scale"); 3671 3672 { 3673 const vk::VkImageCreateInfo createInfo = 3674 { 3675 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 3676 DE_NULL, 3677 3678 0, 3679 vk::VK_IMAGE_TYPE_2D, 3680 vk::VK_FORMAT_R8G8B8A8_UNORM, 3681 { 3682 (deUint32)m_srcImageWidth, 3683 (deUint32)m_srcImageHeight, 3684 1u, 3685 }, 3686 1, 1, // mipLevels, arrayLayers 3687 vk::VK_SAMPLE_COUNT_1_BIT, 3688 3689 vk::VK_IMAGE_TILING_OPTIMAL, 3690 vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT|vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 3691 vk::VK_SHARING_MODE_EXCLUSIVE, 3692 3693 (deUint32)queueFamilies.size(), 3694 &queueFamilies[0], 3695 vk::VK_IMAGE_LAYOUT_UNDEFINED 3696 }; 3697 3698 m_srcImage = vk::createImage(vkd, device, &createInfo); 3699 } 3700 3701 m_memory = bindImageMemory(vki, vkd, physicalDevice, device, *m_srcImage, 0); 3702 3703 { 3704 const vk::Unique<vk::VkBuffer> srcBuffer (createBuffer(vkd, device, 4 * m_srcImageWidth * m_srcImageHeight, vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies)); 3705 const vk::Unique<vk::VkDeviceMemory> memory (bindBufferMemory(vki, vkd, physicalDevice, device, *srcBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); 3706 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 3707 const vk::VkImageMemoryBarrier preImageBarrier = 3708 { 3709 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 3710 DE_NULL, 3711 3712 0, 3713 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 3714 3715 vk::VK_IMAGE_LAYOUT_UNDEFINED, 3716 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 3717 3718 VK_QUEUE_FAMILY_IGNORED, 3719 VK_QUEUE_FAMILY_IGNORED, 3720 3721 *m_srcImage, 3722 { 3723 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3724 0, // Mip level 3725 1, // Mip level count 3726 0, // Layer 3727 1 // Layer count 3728 } 3729 }; 3730 const vk::VkImageMemoryBarrier postImageBarrier = 3731 { 3732 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 3733 DE_NULL, 3734 3735 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 3736 0, 3737 3738 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 3739 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 3740 3741 VK_QUEUE_FAMILY_IGNORED, 3742 VK_QUEUE_FAMILY_IGNORED, 3743 3744 *m_srcImage, 3745 { 3746 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3747 0, // Mip level 3748 1, // Mip level count 3749 0, // Layer 3750 1 // Layer count 3751 } 3752 }; 3753 const vk::VkBufferImageCopy region = 3754 { 3755 0, 3756 0, 0, 3757 { 3758 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3759 0, // mipLevel 3760 0, // arrayLayer 3761 1 // layerCount 3762 }, 3763 { 0, 0, 0 }, 3764 { 3765 (deUint32)m_srcImageWidth, 3766 (deUint32)m_srcImageHeight, 3767 1u 3768 } 3769 }; 3770 3771 { 3772 void* const ptr = mapMemory(vkd, device, *memory, 4 * m_srcImageWidth * m_srcImageHeight); 3773 de::Random rng (m_seed); 3774 3775 { 3776 deUint8* const data = (deUint8*)ptr; 3777 3778 for (size_t ndx = 0; ndx < (size_t)(4 * m_srcImageWidth * m_srcImageHeight); ndx++) 3779 data[ndx] = rng.getUint8(); 3780 } 3781 3782 vk::flushMappedMemoryRange(vkd, device, *memory, 0, 4 * m_srcImageWidth * m_srcImageHeight); 3783 vkd.unmapMemory(device, *memory); 3784 } 3785 3786 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &preImageBarrier); 3787 vkd.cmdCopyBufferToImage(*commandBuffer, *srcBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); 3788 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier); 3789 3790 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 3791 queueRun(vkd, queue, *commandBuffer); 3792 } 3793 } 3794 3795 void ImageBlitFromImage::logSubmit (TestLog& log, size_t commandIndex) const 3796 { 3797 log << TestLog::Message << commandIndex << ":" << getName() << " Blit from another image" << (m_scale == BLIT_SCALE_20 ? " scale 2x" : "") << TestLog::EndMessage; 3798 } 3799 3800 void ImageBlitFromImage::submit (SubmitContext& context) 3801 { 3802 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3803 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 3804 const vk::VkImageBlit region = 3805 { 3806 // Src 3807 { 3808 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3809 0, // mipLevel 3810 0, // arrayLayer 3811 1 // layerCount 3812 }, 3813 { 3814 { 0, 0, 0 }, 3815 { 3816 m_srcImageWidth, 3817 m_srcImageHeight, 3818 1 3819 }, 3820 }, 3821 3822 // Dst 3823 { 3824 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3825 0, // mipLevel 3826 0, // arrayLayer 3827 1 // layerCount 3828 }, 3829 { 3830 { 0, 0, 0 }, 3831 { 3832 m_imageWidth, 3833 m_imageHeight, 3834 1u 3835 } 3836 } 3837 }; 3838 vkd.cmdBlitImage(commandBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, context.getImage(), m_imageLayout, 1, ®ion, vk::VK_FILTER_NEAREST); 3839 } 3840 3841 void ImageBlitFromImage::verify (VerifyContext& context, size_t) 3842 { 3843 ReferenceMemory& reference (context.getReference()); 3844 de::Random rng (m_seed); 3845 3846 reference.setUndefined(0, (size_t)m_imageMemorySize); 3847 3848 { 3849 const PixelBufferAccess& refAccess (context.getReferenceImage().getAccess()); 3850 3851 if (m_scale == BLIT_SCALE_10) 3852 { 3853 for (deInt32 y = 0; y < m_imageHeight; y++) 3854 for (deInt32 x = 0; x < m_imageWidth; x++) 3855 { 3856 const deUint8 r8 = rng.getUint8(); 3857 const deUint8 g8 = rng.getUint8(); 3858 const deUint8 b8 = rng.getUint8(); 3859 const deUint8 a8 = rng.getUint8(); 3860 3861 refAccess.setPixel(UVec4(r8, g8, b8, a8), x, y); 3862 } 3863 } 3864 else if (m_scale == BLIT_SCALE_20) 3865 { 3866 tcu::TextureLevel source (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_srcImageWidth, m_srcImageHeight); 3867 const float xscale = ((float)m_srcImageWidth) / (float)m_imageWidth; 3868 const float yscale = ((float)m_srcImageHeight) / (float)m_imageHeight; 3869 3870 for (deInt32 y = 0; y < m_srcImageHeight; y++) 3871 for (deInt32 x = 0; x < m_srcImageWidth; x++) 3872 { 3873 const deUint8 r8 = rng.getUint8(); 3874 const deUint8 g8 = rng.getUint8(); 3875 const deUint8 b8 = rng.getUint8(); 3876 const deUint8 a8 = rng.getUint8(); 3877 3878 source.getAccess().setPixel(UVec4(r8, g8, b8, a8), x, y); 3879 } 3880 3881 for (deInt32 y = 0; y < m_imageHeight; y++) 3882 for (deInt32 x = 0; x < m_imageWidth; x++) 3883 refAccess.setPixel(source.getAccess().getPixelUint(int((float(x) + 0.5f) * xscale), int((float(y) + 0.5f) * yscale)), x, y); 3884 } 3885 else 3886 DE_FATAL("Unsupported scale"); 3887 } 3888 } 3889 3890 class ImageBlitToImage : public CmdCommand 3891 { 3892 public: 3893 ImageBlitToImage (BlitScale scale, vk::VkImageLayout imageLayout) : m_scale(scale), m_imageLayout(imageLayout) {} 3894 ~ImageBlitToImage (void) {} 3895 const char* getName (void) const { return "ImageBlitToImage"; } 3896 3897 void logPrepare (TestLog& log, size_t commandIndex) const; 3898 void prepare (PrepareContext& context); 3899 void logSubmit (TestLog& log, size_t commandIndex) const; 3900 void submit (SubmitContext& context); 3901 void verify (VerifyContext& context, size_t commandIndex); 3902 3903 private: 3904 const BlitScale m_scale; 3905 const vk::VkImageLayout m_imageLayout; 3906 deInt32 m_imageWidth; 3907 deInt32 m_imageHeight; 3908 vk::VkDeviceSize m_imageMemorySize; 3909 deInt32 m_dstImageWidth; 3910 deInt32 m_dstImageHeight; 3911 vk::Move<vk::VkImage> m_dstImage; 3912 vk::Move<vk::VkDeviceMemory> m_memory; 3913 }; 3914 3915 void ImageBlitToImage::logPrepare (TestLog& log, size_t commandIndex) const 3916 { 3917 log << TestLog::Message << commandIndex << ":" << getName() << " Allocate destination image for image to image blit." << TestLog::EndMessage; 3918 } 3919 3920 void ImageBlitToImage::prepare (PrepareContext& context) 3921 { 3922 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 3923 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 3924 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 3925 const vk::VkDevice device = context.getContext().getDevice(); 3926 const vk::VkQueue queue = context.getContext().getQueue(); 3927 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 3928 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 3929 3930 m_imageWidth = context.getImageWidth(); 3931 m_imageHeight = context.getImageHeight(); 3932 m_imageMemorySize = context.getImageMemorySize(); 3933 3934 if (m_scale == BLIT_SCALE_10) 3935 { 3936 m_dstImageWidth = context.getImageWidth(); 3937 m_dstImageHeight = context.getImageHeight(); 3938 } 3939 else if (m_scale == BLIT_SCALE_20) 3940 { 3941 m_dstImageWidth = context.getImageWidth() * 2; 3942 m_dstImageHeight = context.getImageHeight() * 2; 3943 } 3944 else 3945 DE_FATAL("Unsupportd blit scale"); 3946 3947 { 3948 const vk::VkImageCreateInfo createInfo = 3949 { 3950 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 3951 DE_NULL, 3952 3953 0, 3954 vk::VK_IMAGE_TYPE_2D, 3955 vk::VK_FORMAT_R8G8B8A8_UNORM, 3956 { 3957 (deUint32)m_dstImageWidth, 3958 (deUint32)m_dstImageHeight, 3959 1u, 3960 }, 3961 1, 1, // mipLevels, arrayLayers 3962 vk::VK_SAMPLE_COUNT_1_BIT, 3963 3964 vk::VK_IMAGE_TILING_OPTIMAL, 3965 vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT|vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 3966 vk::VK_SHARING_MODE_EXCLUSIVE, 3967 3968 (deUint32)queueFamilies.size(), 3969 &queueFamilies[0], 3970 vk::VK_IMAGE_LAYOUT_UNDEFINED 3971 }; 3972 3973 m_dstImage = vk::createImage(vkd, device, &createInfo); 3974 } 3975 3976 m_memory = bindImageMemory(vki, vkd, physicalDevice, device, *m_dstImage, 0); 3977 3978 { 3979 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 3980 const vk::VkImageMemoryBarrier barrier = 3981 { 3982 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 3983 DE_NULL, 3984 3985 0, 3986 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 3987 3988 vk::VK_IMAGE_LAYOUT_UNDEFINED, 3989 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 3990 3991 VK_QUEUE_FAMILY_IGNORED, 3992 VK_QUEUE_FAMILY_IGNORED, 3993 3994 *m_dstImage, 3995 { 3996 vk::VK_IMAGE_ASPECT_COLOR_BIT, 3997 0, // Mip level 3998 1, // Mip level count 3999 0, // Layer 4000 1 // Layer count 4001 } 4002 }; 4003 4004 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier); 4005 4006 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 4007 queueRun(vkd, queue, *commandBuffer); 4008 } 4009 } 4010 4011 void ImageBlitToImage::logSubmit (TestLog& log, size_t commandIndex) const 4012 { 4013 log << TestLog::Message << commandIndex << ":" << getName() << " Blit image to another image" << (m_scale == BLIT_SCALE_20 ? " scale 2x" : "") << TestLog::EndMessage; 4014 } 4015 4016 void ImageBlitToImage::submit (SubmitContext& context) 4017 { 4018 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 4019 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 4020 const vk::VkImageBlit region = 4021 { 4022 // Src 4023 { 4024 vk::VK_IMAGE_ASPECT_COLOR_BIT, 4025 0, // mipLevel 4026 0, // arrayLayer 4027 1 // layerCount 4028 }, 4029 { 4030 { 0, 0, 0 }, 4031 { 4032 m_imageWidth, 4033 m_imageHeight, 4034 1 4035 }, 4036 }, 4037 4038 // Dst 4039 { 4040 vk::VK_IMAGE_ASPECT_COLOR_BIT, 4041 0, // mipLevel 4042 0, // arrayLayer 4043 1 // layerCount 4044 }, 4045 { 4046 { 0, 0, 0 }, 4047 { 4048 m_dstImageWidth, 4049 m_dstImageHeight, 4050 1u 4051 } 4052 } 4053 }; 4054 vkd.cmdBlitImage(commandBuffer, context.getImage(), m_imageLayout, *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion, vk::VK_FILTER_NEAREST); 4055 } 4056 4057 void ImageBlitToImage::verify (VerifyContext& context, size_t commandIndex) 4058 { 4059 tcu::ResultCollector& resultCollector (context.getResultCollector()); 4060 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 4061 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 4062 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 4063 const vk::VkDevice device = context.getContext().getDevice(); 4064 const vk::VkQueue queue = context.getContext().getQueue(); 4065 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 4066 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 4067 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 4068 const vk::Unique<vk::VkBuffer> dstBuffer (createBuffer(vkd, device, 4 * m_dstImageWidth * m_dstImageHeight, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies)); 4069 const vk::Unique<vk::VkDeviceMemory> memory (bindBufferMemory(vki, vkd, physicalDevice, device, *dstBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); 4070 { 4071 const vk::VkImageMemoryBarrier imageBarrier = 4072 { 4073 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 4074 DE_NULL, 4075 4076 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 4077 vk::VK_ACCESS_TRANSFER_READ_BIT, 4078 4079 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 4080 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 4081 4082 VK_QUEUE_FAMILY_IGNORED, 4083 VK_QUEUE_FAMILY_IGNORED, 4084 4085 *m_dstImage, 4086 { 4087 vk::VK_IMAGE_ASPECT_COLOR_BIT, 4088 0, // Mip level 4089 1, // Mip level count 4090 0, // Layer 4091 1 // Layer count 4092 } 4093 }; 4094 const vk::VkBufferMemoryBarrier bufferBarrier = 4095 { 4096 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, 4097 DE_NULL, 4098 4099 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 4100 vk::VK_ACCESS_HOST_READ_BIT, 4101 4102 VK_QUEUE_FAMILY_IGNORED, 4103 VK_QUEUE_FAMILY_IGNORED, 4104 *dstBuffer, 4105 0, 4106 VK_WHOLE_SIZE 4107 }; 4108 const vk::VkBufferImageCopy region = 4109 { 4110 0, 4111 0, 0, 4112 { 4113 vk::VK_IMAGE_ASPECT_COLOR_BIT, 4114 0, // mipLevel 4115 0, // arrayLayer 4116 1 // layerCount 4117 }, 4118 { 0, 0, 0 }, 4119 { 4120 (deUint32)m_dstImageWidth, 4121 (deUint32)m_dstImageHeight, 4122 1 4123 } 4124 }; 4125 4126 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier); 4127 vkd.cmdCopyImageToBuffer(*commandBuffer, *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dstBuffer, 1, ®ion); 4128 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL); 4129 } 4130 4131 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 4132 queueRun(vkd, queue, *commandBuffer); 4133 4134 { 4135 void* const ptr = mapMemory(vkd, device, *memory, 4 * m_dstImageWidth * m_dstImageHeight); 4136 4137 vk::invalidateMappedMemoryRange(vkd, device, *memory, 0, 4 * m_dstImageWidth * m_dstImageHeight); 4138 4139 if (m_scale == BLIT_SCALE_10) 4140 { 4141 const deUint8* const data = (const deUint8*)ptr; 4142 const ConstPixelBufferAccess resAccess (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_dstImageWidth, m_dstImageHeight, 1, data); 4143 const ConstPixelBufferAccess& refAccess (context.getReferenceImage().getAccess()); 4144 4145 if (!tcu::intThresholdCompare(context.getLog(), (de::toString(commandIndex) + ":" + getName()).c_str(), (de::toString(commandIndex) + ":" + getName()).c_str(), refAccess, resAccess, UVec4(0), tcu::COMPARE_LOG_ON_ERROR)) 4146 resultCollector.fail(de::toString(commandIndex) + ":" + getName() + " Image comparison failed"); 4147 } 4148 else if (m_scale == BLIT_SCALE_20) 4149 { 4150 const deUint8* const data = (const deUint8*)ptr; 4151 const ConstPixelBufferAccess resAccess (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_dstImageWidth, m_dstImageHeight, 1, data); 4152 tcu::TextureLevel reference (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_dstImageWidth, m_dstImageHeight, 1); 4153 4154 { 4155 const ConstPixelBufferAccess& refAccess (context.getReferenceImage().getAccess()); 4156 4157 for (deInt32 y = 0; y < m_dstImageHeight; y++) 4158 for (deInt32 x = 0; x < m_dstImageWidth; x++) 4159 { 4160 reference.getAccess().setPixel(refAccess.getPixel(x/2, y/2), x, y); 4161 } 4162 } 4163 4164 if (!tcu::intThresholdCompare(context.getLog(), (de::toString(commandIndex) + ":" + getName()).c_str(), (de::toString(commandIndex) + ":" + getName()).c_str(), reference.getAccess(), resAccess, UVec4(0), tcu::COMPARE_LOG_ON_ERROR)) 4165 resultCollector.fail(de::toString(commandIndex) + ":" + getName() + " Image comparison failed"); 4166 } 4167 else 4168 DE_FATAL("Unknown scale"); 4169 4170 vkd.unmapMemory(device, *memory); 4171 } 4172 } 4173 4174 class PrepareRenderPassContext 4175 { 4176 public: 4177 PrepareRenderPassContext (PrepareContext& context, 4178 vk::VkRenderPass renderPass, 4179 vk::VkFramebuffer framebuffer, 4180 deInt32 targetWidth, 4181 deInt32 targetHeight) 4182 : m_context (context) 4183 , m_renderPass (renderPass) 4184 , m_framebuffer (framebuffer) 4185 , m_targetWidth (targetWidth) 4186 , m_targetHeight (targetHeight) 4187 { 4188 } 4189 4190 const Memory& getMemory (void) const { return m_context.getMemory(); } 4191 const Context& getContext (void) const { return m_context.getContext(); } 4192 const vk::BinaryCollection& getBinaryCollection (void) const { return m_context.getBinaryCollection(); } 4193 4194 vk::VkBuffer getBuffer (void) const { return m_context.getBuffer(); } 4195 vk::VkDeviceSize getBufferSize (void) const { return m_context.getBufferSize(); } 4196 4197 vk::VkImage getImage (void) const { return m_context.getImage(); } 4198 deInt32 getImageWidth (void) const { return m_context.getImageWidth(); } 4199 deInt32 getImageHeight (void) const { return m_context.getImageHeight(); } 4200 vk::VkImageLayout getImageLayout (void) const { return m_context.getImageLayout(); } 4201 4202 deInt32 getTargetWidth (void) const { return m_targetWidth; } 4203 deInt32 getTargetHeight (void) const { return m_targetHeight; } 4204 4205 vk::VkRenderPass getRenderPass (void) const { return m_renderPass; } 4206 4207 private: 4208 PrepareContext& m_context; 4209 const vk::VkRenderPass m_renderPass; 4210 const vk::VkFramebuffer m_framebuffer; 4211 const deInt32 m_targetWidth; 4212 const deInt32 m_targetHeight; 4213 }; 4214 4215 class VerifyRenderPassContext 4216 { 4217 public: 4218 VerifyRenderPassContext (VerifyContext& context, 4219 deInt32 targetWidth, 4220 deInt32 targetHeight) 4221 : m_context (context) 4222 , m_referenceTarget (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), targetWidth, targetHeight) 4223 { 4224 } 4225 4226 const Context& getContext (void) const { return m_context.getContext(); } 4227 TestLog& getLog (void) const { return m_context.getLog(); } 4228 tcu::ResultCollector& getResultCollector (void) const { return m_context.getResultCollector(); } 4229 4230 TextureLevel& getReferenceTarget (void) { return m_referenceTarget; } 4231 4232 ReferenceMemory& getReference (void) { return m_context.getReference(); } 4233 TextureLevel& getReferenceImage (void) { return m_context.getReferenceImage();} 4234 4235 private: 4236 VerifyContext& m_context; 4237 TextureLevel m_referenceTarget; 4238 }; 4239 4240 class RenderPassCommand 4241 { 4242 public: 4243 virtual ~RenderPassCommand (void) {} 4244 virtual const char* getName (void) const = 0; 4245 4246 // Log things that are done during prepare 4247 virtual void logPrepare (TestLog&, size_t) const {} 4248 // Log submitted calls etc. 4249 virtual void logSubmit (TestLog&, size_t) const {} 4250 4251 // Allocate vulkan resources and prepare for submit. 4252 virtual void prepare (PrepareRenderPassContext&) {} 4253 4254 // Submit commands to command buffer. 4255 virtual void submit (SubmitContext&) {} 4256 4257 // Verify results 4258 virtual void verify (VerifyRenderPassContext&, size_t) {} 4259 }; 4260 4261 class SubmitRenderPass : public CmdCommand 4262 { 4263 public: 4264 SubmitRenderPass (const vector<RenderPassCommand*>& commands); 4265 ~SubmitRenderPass (void); 4266 const char* getName (void) const { return "SubmitRenderPass"; } 4267 4268 void logPrepare (TestLog&, size_t) const; 4269 void logSubmit (TestLog&, size_t) const; 4270 4271 void prepare (PrepareContext&); 4272 void submit (SubmitContext&); 4273 4274 void verify (VerifyContext&, size_t); 4275 4276 private: 4277 const deInt32 m_targetWidth; 4278 const deInt32 m_targetHeight; 4279 vk::Move<vk::VkRenderPass> m_renderPass; 4280 vk::Move<vk::VkDeviceMemory> m_colorTargetMemory; 4281 de::MovePtr<vk::Allocation> m_colorTargetMemory2; 4282 vk::Move<vk::VkImage> m_colorTarget; 4283 vk::Move<vk::VkImageView> m_colorTargetView; 4284 vk::Move<vk::VkFramebuffer> m_framebuffer; 4285 vector<RenderPassCommand*> m_commands; 4286 }; 4287 4288 SubmitRenderPass::SubmitRenderPass (const vector<RenderPassCommand*>& commands) 4289 : m_targetWidth (256) 4290 , m_targetHeight (256) 4291 , m_commands (commands) 4292 { 4293 } 4294 4295 SubmitRenderPass::~SubmitRenderPass() 4296 { 4297 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 4298 delete m_commands[cmdNdx]; 4299 } 4300 4301 void SubmitRenderPass::logPrepare (TestLog& log, size_t commandIndex) const 4302 { 4303 const string sectionName (de::toString(commandIndex) + ":" + getName()); 4304 const tcu::ScopedLogSection section (log, sectionName, sectionName); 4305 4306 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 4307 { 4308 RenderPassCommand& command = *m_commands[cmdNdx]; 4309 command.logPrepare(log, cmdNdx); 4310 } 4311 } 4312 4313 void SubmitRenderPass::logSubmit (TestLog& log, size_t commandIndex) const 4314 { 4315 const string sectionName (de::toString(commandIndex) + ":" + getName()); 4316 const tcu::ScopedLogSection section (log, sectionName, sectionName); 4317 4318 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 4319 { 4320 RenderPassCommand& command = *m_commands[cmdNdx]; 4321 command.logSubmit(log, cmdNdx); 4322 } 4323 } 4324 4325 void SubmitRenderPass::prepare (PrepareContext& context) 4326 { 4327 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 4328 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 4329 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 4330 const vk::VkDevice device = context.getContext().getDevice(); 4331 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 4332 4333 const vk::VkAttachmentReference colorAttachments[] = 4334 { 4335 { 0, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL } 4336 }; 4337 const vk::VkSubpassDescription subpass = 4338 { 4339 0u, 4340 vk::VK_PIPELINE_BIND_POINT_GRAPHICS, 4341 4342 0u, 4343 DE_NULL, 4344 4345 DE_LENGTH_OF_ARRAY(colorAttachments), 4346 colorAttachments, 4347 DE_NULL, 4348 DE_NULL, 4349 0u, 4350 DE_NULL 4351 }; 4352 const vk::VkAttachmentDescription attachment = 4353 { 4354 0u, 4355 vk::VK_FORMAT_R8G8B8A8_UNORM, 4356 vk::VK_SAMPLE_COUNT_1_BIT, 4357 4358 vk::VK_ATTACHMENT_LOAD_OP_CLEAR, 4359 vk::VK_ATTACHMENT_STORE_OP_STORE, 4360 4361 vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE, 4362 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE, 4363 4364 vk::VK_IMAGE_LAYOUT_UNDEFINED, 4365 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL 4366 }; 4367 { 4368 const vk::VkImageCreateInfo createInfo = 4369 { 4370 vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, 4371 DE_NULL, 4372 0u, 4373 4374 vk::VK_IMAGE_TYPE_2D, 4375 vk::VK_FORMAT_R8G8B8A8_UNORM, 4376 { (deUint32)m_targetWidth, (deUint32)m_targetHeight, 1u }, 4377 1u, 4378 1u, 4379 vk::VK_SAMPLE_COUNT_1_BIT, 4380 vk::VK_IMAGE_TILING_OPTIMAL, 4381 vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 4382 vk::VK_SHARING_MODE_EXCLUSIVE, 4383 (deUint32)queueFamilies.size(), 4384 &queueFamilies[0], 4385 vk::VK_IMAGE_LAYOUT_UNDEFINED 4386 }; 4387 4388 m_colorTarget = vk::createImage(vkd, device, &createInfo); 4389 } 4390 4391 m_colorTargetMemory = bindImageMemory(vki, vkd, physicalDevice, device, *m_colorTarget, 0); 4392 4393 { 4394 const vk::VkImageViewCreateInfo createInfo = 4395 { 4396 vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, 4397 DE_NULL, 4398 4399 0u, 4400 *m_colorTarget, 4401 vk::VK_IMAGE_VIEW_TYPE_2D, 4402 vk::VK_FORMAT_R8G8B8A8_UNORM, 4403 { 4404 vk::VK_COMPONENT_SWIZZLE_R, 4405 vk::VK_COMPONENT_SWIZZLE_G, 4406 vk::VK_COMPONENT_SWIZZLE_B, 4407 vk::VK_COMPONENT_SWIZZLE_A 4408 }, 4409 { 4410 vk::VK_IMAGE_ASPECT_COLOR_BIT, 4411 0u, 4412 1u, 4413 0u, 4414 1u 4415 } 4416 }; 4417 4418 m_colorTargetView = vk::createImageView(vkd, device, &createInfo); 4419 } 4420 { 4421 const vk::VkRenderPassCreateInfo createInfo = 4422 { 4423 vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, 4424 DE_NULL, 4425 0u, 4426 4427 1u, 4428 &attachment, 4429 4430 1u, 4431 &subpass, 4432 4433 0, 4434 DE_NULL 4435 }; 4436 4437 m_renderPass = vk::createRenderPass(vkd, device, &createInfo); 4438 } 4439 4440 { 4441 const vk::VkImageView imageViews[] = 4442 { 4443 *m_colorTargetView 4444 }; 4445 const vk::VkFramebufferCreateInfo createInfo = 4446 { 4447 vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, 4448 DE_NULL, 4449 0u, 4450 4451 *m_renderPass, 4452 DE_LENGTH_OF_ARRAY(imageViews), 4453 imageViews, 4454 (deUint32)m_targetWidth, 4455 (deUint32)m_targetHeight, 4456 1u 4457 }; 4458 4459 m_framebuffer = vk::createFramebuffer(vkd, device, &createInfo); 4460 } 4461 4462 { 4463 PrepareRenderPassContext renderpassContext (context, *m_renderPass, *m_framebuffer, m_targetWidth, m_targetHeight); 4464 4465 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 4466 { 4467 RenderPassCommand& command = *m_commands[cmdNdx]; 4468 command.prepare(renderpassContext); 4469 } 4470 } 4471 } 4472 4473 void SubmitRenderPass::submit (SubmitContext& context) 4474 { 4475 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 4476 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 4477 const vk::VkClearValue clearValue = vk::makeClearValueColorF32(0.0f, 0.0f, 0.0f, 1.0f); 4478 4479 const vk::VkRenderPassBeginInfo beginInfo = 4480 { 4481 vk::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, 4482 DE_NULL, 4483 4484 *m_renderPass, 4485 *m_framebuffer, 4486 4487 { { 0, 0 }, { (deUint32)m_targetWidth, (deUint32)m_targetHeight } }, 4488 1u, 4489 &clearValue 4490 }; 4491 4492 vkd.cmdBeginRenderPass(commandBuffer, &beginInfo, vk::VK_SUBPASS_CONTENTS_INLINE); 4493 4494 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 4495 { 4496 RenderPassCommand& command = *m_commands[cmdNdx]; 4497 4498 command.submit(context); 4499 } 4500 4501 vkd.cmdEndRenderPass(commandBuffer); 4502 } 4503 4504 void SubmitRenderPass::verify (VerifyContext& context, size_t commandIndex) 4505 { 4506 TestLog& log (context.getLog()); 4507 tcu::ResultCollector& resultCollector (context.getResultCollector()); 4508 const string sectionName (de::toString(commandIndex) + ":" + getName()); 4509 const tcu::ScopedLogSection section (log, sectionName, sectionName); 4510 VerifyRenderPassContext verifyContext (context, m_targetWidth, m_targetHeight); 4511 4512 tcu::clear(verifyContext.getReferenceTarget().getAccess(), Vec4(0.0f, 0.0f, 0.0f, 1.0f)); 4513 4514 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 4515 { 4516 RenderPassCommand& command = *m_commands[cmdNdx]; 4517 command.verify(verifyContext, cmdNdx); 4518 } 4519 4520 { 4521 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 4522 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 4523 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 4524 const vk::VkDevice device = context.getContext().getDevice(); 4525 const vk::VkQueue queue = context.getContext().getQueue(); 4526 const vk::VkCommandPool commandPool = context.getContext().getCommandPool(); 4527 const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY)); 4528 const vector<deUint32>& queueFamilies = context.getContext().getQueueFamilies(); 4529 const vk::Unique<vk::VkBuffer> dstBuffer (createBuffer(vkd, device, 4 * m_targetWidth * m_targetHeight, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies)); 4530 const vk::Unique<vk::VkDeviceMemory> memory (bindBufferMemory(vki, vkd, physicalDevice, device, *dstBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)); 4531 { 4532 const vk::VkImageMemoryBarrier imageBarrier = 4533 { 4534 vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, 4535 DE_NULL, 4536 4537 vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 4538 vk::VK_ACCESS_TRANSFER_READ_BIT, 4539 4540 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 4541 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 4542 4543 VK_QUEUE_FAMILY_IGNORED, 4544 VK_QUEUE_FAMILY_IGNORED, 4545 4546 *m_colorTarget, 4547 { 4548 vk::VK_IMAGE_ASPECT_COLOR_BIT, 4549 0, // Mip level 4550 1, // Mip level count 4551 0, // Layer 4552 1 // Layer count 4553 } 4554 }; 4555 const vk::VkBufferMemoryBarrier bufferBarrier = 4556 { 4557 vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, 4558 DE_NULL, 4559 4560 vk::VK_ACCESS_TRANSFER_WRITE_BIT, 4561 vk::VK_ACCESS_HOST_READ_BIT, 4562 4563 VK_QUEUE_FAMILY_IGNORED, 4564 VK_QUEUE_FAMILY_IGNORED, 4565 *dstBuffer, 4566 0, 4567 VK_WHOLE_SIZE 4568 }; 4569 const vk::VkBufferImageCopy region = 4570 { 4571 0, 4572 0, 0, 4573 { 4574 vk::VK_IMAGE_ASPECT_COLOR_BIT, 4575 0, // mipLevel 4576 0, // arrayLayer 4577 1 // layerCount 4578 }, 4579 { 0, 0, 0 }, 4580 { 4581 (deUint32)m_targetWidth, 4582 (deUint32)m_targetHeight, 4583 1u 4584 } 4585 }; 4586 4587 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier); 4588 vkd.cmdCopyImageToBuffer(*commandBuffer, *m_colorTarget, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dstBuffer, 1, ®ion); 4589 vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL); 4590 } 4591 4592 VK_CHECK(vkd.endCommandBuffer(*commandBuffer)); 4593 queueRun(vkd, queue, *commandBuffer); 4594 4595 { 4596 void* const ptr = mapMemory(vkd, device, *memory, 4 * m_targetWidth * m_targetHeight); 4597 4598 vk::invalidateMappedMemoryRange(vkd, device, *memory, 0, 4 * m_targetWidth * m_targetHeight); 4599 4600 { 4601 const deUint8* const data = (const deUint8*)ptr; 4602 const ConstPixelBufferAccess resAccess (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_targetWidth, m_targetHeight, 1, data); 4603 const ConstPixelBufferAccess& refAccess (verifyContext.getReferenceTarget().getAccess()); 4604 4605 if (!tcu::intThresholdCompare(context.getLog(), (de::toString(commandIndex) + ":" + getName()).c_str(), (de::toString(commandIndex) + ":" + getName()).c_str(), refAccess, resAccess, UVec4(0), tcu::COMPARE_LOG_ON_ERROR)) 4606 resultCollector.fail(de::toString(commandIndex) + ":" + getName() + " Image comparison failed"); 4607 } 4608 4609 vkd.unmapMemory(device, *memory); 4610 } 4611 } 4612 } 4613 4614 struct PipelineResources 4615 { 4616 vk::Move<vk::VkPipeline> pipeline; 4617 vk::Move<vk::VkDescriptorSetLayout> descriptorSetLayout; 4618 vk::Move<vk::VkPipelineLayout> pipelineLayout; 4619 }; 4620 4621 void createPipelineWithResources (const vk::DeviceInterface& vkd, 4622 const vk::VkDevice device, 4623 const vk::VkRenderPass renderPass, 4624 const deUint32 subpass, 4625 const vk::VkShaderModule& vertexShaderModule, 4626 const vk::VkShaderModule& fragmentShaderModule, 4627 const deUint32 viewPortWidth, 4628 const deUint32 viewPortHeight, 4629 const vector<vk::VkVertexInputBindingDescription>& vertexBindingDescriptions, 4630 const vector<vk::VkVertexInputAttributeDescription>& vertexAttributeDescriptions, 4631 const vector<vk::VkDescriptorSetLayoutBinding>& bindings, 4632 const vk::VkPrimitiveTopology topology, 4633 deUint32 pushConstantRangeCount, 4634 const vk::VkPushConstantRange* pushConstantRanges, 4635 PipelineResources& resources) 4636 { 4637 if (!bindings.empty()) 4638 { 4639 const vk::VkDescriptorSetLayoutCreateInfo createInfo = 4640 { 4641 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, 4642 DE_NULL, 4643 4644 0u, 4645 (deUint32)bindings.size(), 4646 bindings.empty() ? DE_NULL : &bindings[0] 4647 }; 4648 4649 resources.descriptorSetLayout = vk::createDescriptorSetLayout(vkd, device, &createInfo); 4650 } 4651 4652 { 4653 const vk::VkDescriptorSetLayout descriptorSetLayout_ = *resources.descriptorSetLayout; 4654 const vk::VkPipelineLayoutCreateInfo createInfo = 4655 { 4656 vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, 4657 DE_NULL, 4658 0, 4659 4660 resources.descriptorSetLayout ? 1u : 0u, 4661 resources.descriptorSetLayout ? &descriptorSetLayout_ : DE_NULL, 4662 4663 pushConstantRangeCount, 4664 pushConstantRanges 4665 }; 4666 4667 resources.pipelineLayout = vk::createPipelineLayout(vkd, device, &createInfo); 4668 } 4669 4670 { 4671 const vk::VkPipelineShaderStageCreateInfo shaderStages[] = 4672 { 4673 { 4674 vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, 4675 DE_NULL, 4676 0, 4677 vk::VK_SHADER_STAGE_VERTEX_BIT, 4678 vertexShaderModule, 4679 "main", 4680 DE_NULL 4681 }, 4682 { 4683 vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, 4684 DE_NULL, 4685 0, 4686 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 4687 fragmentShaderModule, 4688 "main", 4689 DE_NULL 4690 } 4691 }; 4692 const vk::VkPipelineDepthStencilStateCreateInfo depthStencilState = 4693 { 4694 vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, 4695 DE_NULL, 4696 0u, 4697 DE_FALSE, 4698 DE_FALSE, 4699 vk::VK_COMPARE_OP_ALWAYS, 4700 DE_FALSE, 4701 DE_FALSE, 4702 { 4703 vk::VK_STENCIL_OP_KEEP, 4704 vk::VK_STENCIL_OP_KEEP, 4705 vk::VK_STENCIL_OP_KEEP, 4706 vk::VK_COMPARE_OP_ALWAYS, 4707 0u, 4708 0u, 4709 0u, 4710 }, 4711 { 4712 vk::VK_STENCIL_OP_KEEP, 4713 vk::VK_STENCIL_OP_KEEP, 4714 vk::VK_STENCIL_OP_KEEP, 4715 vk::VK_COMPARE_OP_ALWAYS, 4716 0u, 4717 0u, 4718 0u, 4719 }, 4720 -1.0f, 4721 +1.0f 4722 }; 4723 const vk::VkPipelineVertexInputStateCreateInfo vertexInputState = 4724 { 4725 vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, 4726 DE_NULL, 4727 0u, 4728 4729 (deUint32)vertexBindingDescriptions.size(), 4730 vertexBindingDescriptions.empty() ? DE_NULL : &vertexBindingDescriptions[0], 4731 4732 (deUint32)vertexAttributeDescriptions.size(), 4733 vertexAttributeDescriptions.empty() ? DE_NULL : &vertexAttributeDescriptions[0] 4734 }; 4735 const vk::VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = 4736 { 4737 vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, 4738 DE_NULL, 4739 0, 4740 topology, 4741 VK_FALSE 4742 }; 4743 const vk::VkViewport viewports[] = 4744 { 4745 { 0.0f, 0.0f, (float)viewPortWidth, (float)viewPortHeight, 0.0f, 1.0f } 4746 }; 4747 const vk::VkRect2D scissors[] = 4748 { 4749 { { 0, 0 }, { (deUint32)viewPortWidth, (deUint32)viewPortHeight } } 4750 }; 4751 const vk::VkPipelineViewportStateCreateInfo viewportState = 4752 { 4753 vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, 4754 DE_NULL, 4755 0, 4756 DE_LENGTH_OF_ARRAY(viewports), 4757 viewports, 4758 DE_LENGTH_OF_ARRAY(scissors), 4759 scissors 4760 }; 4761 const vk::VkPipelineRasterizationStateCreateInfo rasterState = 4762 { 4763 vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, 4764 DE_NULL, 4765 0, 4766 4767 VK_TRUE, 4768 VK_FALSE, 4769 vk::VK_POLYGON_MODE_FILL, 4770 vk::VK_CULL_MODE_NONE, 4771 vk::VK_FRONT_FACE_COUNTER_CLOCKWISE, 4772 VK_FALSE, 4773 0.0f, 4774 0.0f, 4775 0.0f, 4776 1.0f 4777 }; 4778 const vk::VkSampleMask sampleMask = ~0u; 4779 const vk::VkPipelineMultisampleStateCreateInfo multisampleState = 4780 { 4781 vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, 4782 DE_NULL, 4783 0, 4784 4785 vk::VK_SAMPLE_COUNT_1_BIT, 4786 VK_FALSE, 4787 0.0f, 4788 &sampleMask, 4789 VK_FALSE, 4790 VK_FALSE 4791 }; 4792 const vk::VkPipelineColorBlendAttachmentState attachments[] = 4793 { 4794 { 4795 VK_FALSE, 4796 vk::VK_BLEND_FACTOR_ONE, 4797 vk::VK_BLEND_FACTOR_ZERO, 4798 vk::VK_BLEND_OP_ADD, 4799 vk::VK_BLEND_FACTOR_ONE, 4800 vk::VK_BLEND_FACTOR_ZERO, 4801 vk::VK_BLEND_OP_ADD, 4802 (vk::VK_COLOR_COMPONENT_R_BIT| 4803 vk::VK_COLOR_COMPONENT_G_BIT| 4804 vk::VK_COLOR_COMPONENT_B_BIT| 4805 vk::VK_COLOR_COMPONENT_A_BIT) 4806 } 4807 }; 4808 const vk::VkPipelineColorBlendStateCreateInfo colorBlendState = 4809 { 4810 vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, 4811 DE_NULL, 4812 0, 4813 4814 VK_FALSE, 4815 vk::VK_LOGIC_OP_COPY, 4816 DE_LENGTH_OF_ARRAY(attachments), 4817 attachments, 4818 { 0.0f, 0.0f, 0.0f, 0.0f } 4819 }; 4820 const vk::VkGraphicsPipelineCreateInfo createInfo = 4821 { 4822 vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, 4823 DE_NULL, 4824 0u, 4825 4826 DE_LENGTH_OF_ARRAY(shaderStages), 4827 shaderStages, 4828 4829 &vertexInputState, 4830 &inputAssemblyState, 4831 DE_NULL, 4832 &viewportState, 4833 &rasterState, 4834 &multisampleState, 4835 &depthStencilState, 4836 &colorBlendState, 4837 DE_NULL, 4838 *resources.pipelineLayout, 4839 renderPass, 4840 subpass, 4841 0, 4842 0 4843 }; 4844 4845 resources.pipeline = vk::createGraphicsPipeline(vkd, device, 0, &createInfo); 4846 } 4847 } 4848 4849 class RenderIndexBuffer : public RenderPassCommand 4850 { 4851 public: 4852 RenderIndexBuffer (void) {} 4853 ~RenderIndexBuffer (void) {} 4854 4855 const char* getName (void) const { return "RenderIndexBuffer"; } 4856 void logPrepare (TestLog&, size_t) const; 4857 void logSubmit (TestLog&, size_t) const; 4858 void prepare (PrepareRenderPassContext&); 4859 void submit (SubmitContext& context); 4860 void verify (VerifyRenderPassContext&, size_t); 4861 4862 private: 4863 PipelineResources m_resources; 4864 vk::VkDeviceSize m_bufferSize; 4865 }; 4866 4867 void RenderIndexBuffer::logPrepare (TestLog& log, size_t commandIndex) const 4868 { 4869 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render buffer as index buffer." << TestLog::EndMessage; 4870 } 4871 4872 void RenderIndexBuffer::logSubmit (TestLog& log, size_t commandIndex) const 4873 { 4874 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as index buffer." << TestLog::EndMessage; 4875 } 4876 4877 void RenderIndexBuffer::prepare (PrepareRenderPassContext& context) 4878 { 4879 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 4880 const vk::VkDevice device = context.getContext().getDevice(); 4881 const vk::VkRenderPass renderPass = context.getRenderPass(); 4882 const deUint32 subpass = 0; 4883 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("index-buffer.vert"), 0)); 4884 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-white.frag"), 0)); 4885 4886 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 4887 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), vector<vk::VkDescriptorSetLayoutBinding>(), vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0u, DE_NULL, m_resources); 4888 m_bufferSize = context.getBufferSize(); 4889 } 4890 4891 void RenderIndexBuffer::submit (SubmitContext& context) 4892 { 4893 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 4894 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 4895 4896 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 4897 vkd.cmdBindIndexBuffer(commandBuffer, context.getBuffer(), 0, vk::VK_INDEX_TYPE_UINT16); 4898 vkd.cmdDrawIndexed(commandBuffer, (deUint32)(context.getBufferSize() / 2), 1, 0, 0, 0); 4899 } 4900 4901 void RenderIndexBuffer::verify (VerifyRenderPassContext& context, size_t) 4902 { 4903 for (size_t pos = 0; pos < (size_t)m_bufferSize / 2; pos++) 4904 { 4905 const deUint8 x = context.getReference().get(pos * 2); 4906 const deUint8 y = context.getReference().get((pos * 2) + 1); 4907 4908 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), x, y); 4909 } 4910 } 4911 4912 class RenderVertexBuffer : public RenderPassCommand 4913 { 4914 public: 4915 RenderVertexBuffer (void) {} 4916 ~RenderVertexBuffer (void) {} 4917 4918 const char* getName (void) const { return "RenderVertexBuffer"; } 4919 void logPrepare (TestLog&, size_t) const; 4920 void logSubmit (TestLog&, size_t) const; 4921 void prepare (PrepareRenderPassContext&); 4922 void submit (SubmitContext& context); 4923 void verify (VerifyRenderPassContext&, size_t); 4924 4925 private: 4926 PipelineResources m_resources; 4927 vk::VkDeviceSize m_bufferSize; 4928 }; 4929 4930 void RenderVertexBuffer::logPrepare (TestLog& log, size_t commandIndex) const 4931 { 4932 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render buffer as vertex buffer." << TestLog::EndMessage; 4933 } 4934 4935 void RenderVertexBuffer::logSubmit (TestLog& log, size_t commandIndex) const 4936 { 4937 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as vertex buffer." << TestLog::EndMessage; 4938 } 4939 4940 void RenderVertexBuffer::prepare (PrepareRenderPassContext& context) 4941 { 4942 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 4943 const vk::VkDevice device = context.getContext().getDevice(); 4944 const vk::VkRenderPass renderPass = context.getRenderPass(); 4945 const deUint32 subpass = 0; 4946 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("vertex-buffer.vert"), 0)); 4947 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-white.frag"), 0)); 4948 4949 vector<vk::VkVertexInputAttributeDescription> vertexAttributeDescriptions; 4950 vector<vk::VkVertexInputBindingDescription> vertexBindingDescriptions; 4951 4952 { 4953 const vk::VkVertexInputBindingDescription vertexBindingDescription = 4954 { 4955 0, 4956 2, 4957 vk::VK_VERTEX_INPUT_RATE_VERTEX 4958 }; 4959 4960 vertexBindingDescriptions.push_back(vertexBindingDescription); 4961 } 4962 { 4963 const vk::VkVertexInputAttributeDescription vertexAttributeDescription = 4964 { 4965 0, 4966 0, 4967 vk::VK_FORMAT_R8G8_UNORM, 4968 0 4969 }; 4970 4971 vertexAttributeDescriptions.push_back(vertexAttributeDescription); 4972 } 4973 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 4974 vertexBindingDescriptions, vertexAttributeDescriptions, vector<vk::VkDescriptorSetLayoutBinding>(), vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0u, DE_NULL, m_resources); 4975 4976 m_bufferSize = context.getBufferSize(); 4977 } 4978 4979 void RenderVertexBuffer::submit (SubmitContext& context) 4980 { 4981 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 4982 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 4983 const vk::VkDeviceSize offset = 0; 4984 const vk::VkBuffer buffer = context.getBuffer(); 4985 4986 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 4987 vkd.cmdBindVertexBuffers(commandBuffer, 0, 1, &buffer, &offset); 4988 vkd.cmdDraw(commandBuffer, (deUint32)(context.getBufferSize() / 2), 1, 0, 0); 4989 } 4990 4991 void RenderVertexBuffer::verify (VerifyRenderPassContext& context, size_t) 4992 { 4993 for (size_t pos = 0; pos < (size_t)m_bufferSize / 2; pos++) 4994 { 4995 const deUint8 x = context.getReference().get(pos * 2); 4996 const deUint8 y = context.getReference().get((pos * 2) + 1); 4997 4998 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), x, y); 4999 } 5000 } 5001 5002 class RenderVertexUniformBuffer : public RenderPassCommand 5003 { 5004 public: 5005 RenderVertexUniformBuffer (void) {} 5006 ~RenderVertexUniformBuffer (void); 5007 5008 const char* getName (void) const { return "RenderVertexUniformBuffer"; } 5009 void logPrepare (TestLog&, size_t) const; 5010 void logSubmit (TestLog&, size_t) const; 5011 void prepare (PrepareRenderPassContext&); 5012 void submit (SubmitContext& context); 5013 void verify (VerifyRenderPassContext&, size_t); 5014 5015 private: 5016 PipelineResources m_resources; 5017 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 5018 vector<vk::VkDescriptorSet> m_descriptorSets; 5019 5020 vk::VkDeviceSize m_bufferSize; 5021 }; 5022 5023 RenderVertexUniformBuffer::~RenderVertexUniformBuffer (void) 5024 { 5025 } 5026 5027 void RenderVertexUniformBuffer::logPrepare (TestLog& log, size_t commandIndex) const 5028 { 5029 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render buffer as uniform buffer." << TestLog::EndMessage; 5030 } 5031 5032 void RenderVertexUniformBuffer::logSubmit (TestLog& log, size_t commandIndex) const 5033 { 5034 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as uniform buffer." << TestLog::EndMessage; 5035 } 5036 5037 void RenderVertexUniformBuffer::prepare (PrepareRenderPassContext& context) 5038 { 5039 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5040 const vk::VkDevice device = context.getContext().getDevice(); 5041 const vk::VkRenderPass renderPass = context.getRenderPass(); 5042 const deUint32 subpass = 0; 5043 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("uniform-buffer.vert"), 0)); 5044 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-white.frag"), 0)); 5045 vector<vk::VkDescriptorSetLayoutBinding> bindings; 5046 5047 m_bufferSize = context.getBufferSize(); 5048 5049 { 5050 const vk::VkDescriptorSetLayoutBinding binding = 5051 { 5052 0u, 5053 vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 5054 1, 5055 vk::VK_SHADER_STAGE_VERTEX_BIT, 5056 DE_NULL 5057 }; 5058 5059 bindings.push_back(binding); 5060 } 5061 5062 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 5063 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0u, DE_NULL, m_resources); 5064 5065 { 5066 const deUint32 descriptorCount = (deUint32)(divRoundUp(m_bufferSize, (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE)); 5067 const vk::VkDescriptorPoolSize poolSizes = 5068 { 5069 vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 5070 descriptorCount 5071 }; 5072 const vk::VkDescriptorPoolCreateInfo createInfo = 5073 { 5074 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 5075 DE_NULL, 5076 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 5077 5078 descriptorCount, 5079 1u, 5080 &poolSizes, 5081 }; 5082 5083 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 5084 m_descriptorSets.resize(descriptorCount); 5085 } 5086 5087 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5088 { 5089 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 5090 const vk::VkDescriptorSetAllocateInfo allocateInfo = 5091 { 5092 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 5093 DE_NULL, 5094 5095 *m_descriptorPool, 5096 1, 5097 &layout 5098 }; 5099 5100 m_descriptorSets[descriptorSetNdx] = vk::allocateDescriptorSet(vkd, device, &allocateInfo).disown(); 5101 5102 { 5103 const vk::VkDescriptorBufferInfo bufferInfo = 5104 { 5105 context.getBuffer(), 5106 (vk::VkDeviceSize)(descriptorSetNdx * (size_t)MAX_UNIFORM_BUFFER_SIZE), 5107 m_bufferSize < (descriptorSetNdx + 1) * (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 5108 ? m_bufferSize - descriptorSetNdx * (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 5109 : (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 5110 }; 5111 const vk::VkWriteDescriptorSet write = 5112 { 5113 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 5114 DE_NULL, 5115 m_descriptorSets[descriptorSetNdx], 5116 0u, 5117 0u, 5118 1u, 5119 vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 5120 DE_NULL, 5121 &bufferInfo, 5122 DE_NULL, 5123 }; 5124 5125 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 5126 } 5127 } 5128 } 5129 5130 void RenderVertexUniformBuffer::submit (SubmitContext& context) 5131 { 5132 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5133 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 5134 5135 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 5136 5137 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5138 { 5139 const size_t size = (size_t)(m_bufferSize < (descriptorSetNdx + 1) * (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 5140 ? m_bufferSize - descriptorSetNdx * (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 5141 : (size_t)MAX_UNIFORM_BUFFER_SIZE); 5142 const deUint32 count = (deUint32)(size / 2); 5143 5144 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &m_descriptorSets[descriptorSetNdx], 0u, DE_NULL); 5145 vkd.cmdDraw(commandBuffer, count, 1, 0, 0); 5146 } 5147 } 5148 5149 void RenderVertexUniformBuffer::verify (VerifyRenderPassContext& context, size_t) 5150 { 5151 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5152 { 5153 const size_t offset = descriptorSetNdx * MAX_UNIFORM_BUFFER_SIZE; 5154 const size_t size = (size_t)(m_bufferSize < (descriptorSetNdx + 1) * (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 5155 ? m_bufferSize - descriptorSetNdx * (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 5156 : (size_t)MAX_UNIFORM_BUFFER_SIZE); 5157 const size_t count = size / 2; 5158 5159 for (size_t pos = 0; pos < count; pos++) 5160 { 5161 const deUint8 x = context.getReference().get(offset + pos * 2); 5162 const deUint8 y = context.getReference().get(offset + (pos * 2) + 1); 5163 5164 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), x, y); 5165 } 5166 } 5167 } 5168 5169 class RenderVertexUniformTexelBuffer : public RenderPassCommand 5170 { 5171 public: 5172 RenderVertexUniformTexelBuffer (void) {} 5173 ~RenderVertexUniformTexelBuffer (void); 5174 5175 const char* getName (void) const { return "RenderVertexUniformTexelBuffer"; } 5176 void logPrepare (TestLog&, size_t) const; 5177 void logSubmit (TestLog&, size_t) const; 5178 void prepare (PrepareRenderPassContext&); 5179 void submit (SubmitContext& context); 5180 void verify (VerifyRenderPassContext&, size_t); 5181 5182 private: 5183 PipelineResources m_resources; 5184 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 5185 vector<vk::VkDescriptorSet> m_descriptorSets; 5186 vector<vk::VkBufferView> m_bufferViews; 5187 5188 const vk::DeviceInterface* m_vkd; 5189 vk::VkDevice m_device; 5190 vk::VkDeviceSize m_bufferSize; 5191 deUint32 m_maxUniformTexelCount; 5192 }; 5193 5194 RenderVertexUniformTexelBuffer::~RenderVertexUniformTexelBuffer (void) 5195 { 5196 for (size_t bufferViewNdx = 0; bufferViewNdx < m_bufferViews.size(); bufferViewNdx++) 5197 { 5198 if (!!m_bufferViews[bufferViewNdx]) 5199 { 5200 m_vkd->destroyBufferView(m_device, m_bufferViews[bufferViewNdx], DE_NULL); 5201 m_bufferViews[bufferViewNdx] = (vk::VkBufferView)0; 5202 } 5203 } 5204 } 5205 5206 void RenderVertexUniformTexelBuffer::logPrepare (TestLog& log, size_t commandIndex) const 5207 { 5208 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render buffer as uniform buffer." << TestLog::EndMessage; 5209 } 5210 5211 void RenderVertexUniformTexelBuffer::logSubmit (TestLog& log, size_t commandIndex) const 5212 { 5213 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as uniform buffer." << TestLog::EndMessage; 5214 } 5215 5216 void RenderVertexUniformTexelBuffer::prepare (PrepareRenderPassContext& context) 5217 { 5218 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 5219 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 5220 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5221 const vk::VkDevice device = context.getContext().getDevice(); 5222 const vk::VkRenderPass renderPass = context.getRenderPass(); 5223 const deUint32 subpass = 0; 5224 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("uniform-texel-buffer.vert"), 0)); 5225 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-white.frag"), 0)); 5226 vector<vk::VkDescriptorSetLayoutBinding> bindings; 5227 5228 m_device = device; 5229 m_vkd = &vkd; 5230 m_bufferSize = context.getBufferSize(); 5231 m_maxUniformTexelCount = vk::getPhysicalDeviceProperties(vki, physicalDevice).limits.maxTexelBufferElements; 5232 5233 { 5234 const vk::VkDescriptorSetLayoutBinding binding = 5235 { 5236 0u, 5237 vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 5238 1, 5239 vk::VK_SHADER_STAGE_VERTEX_BIT, 5240 DE_NULL 5241 }; 5242 5243 bindings.push_back(binding); 5244 } 5245 5246 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 5247 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0u, DE_NULL, m_resources); 5248 5249 { 5250 const deUint32 descriptorCount = (deUint32)(divRoundUp(m_bufferSize, (vk::VkDeviceSize)m_maxUniformTexelCount * 2)); 5251 const vk::VkDescriptorPoolSize poolSizes = 5252 { 5253 vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 5254 descriptorCount 5255 }; 5256 const vk::VkDescriptorPoolCreateInfo createInfo = 5257 { 5258 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 5259 DE_NULL, 5260 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 5261 5262 descriptorCount, 5263 1u, 5264 &poolSizes, 5265 }; 5266 5267 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 5268 m_descriptorSets.resize(descriptorCount, (vk::VkDescriptorSet)0); 5269 m_bufferViews.resize(descriptorCount, (vk::VkBufferView)0); 5270 } 5271 5272 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5273 { 5274 const deUint32 count = (deUint32)(m_bufferSize < (descriptorSetNdx + 1) * m_maxUniformTexelCount * 2 5275 ? m_bufferSize - descriptorSetNdx * m_maxUniformTexelCount * 2 5276 : m_maxUniformTexelCount * 2) / 2; 5277 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 5278 const vk::VkDescriptorSetAllocateInfo allocateInfo = 5279 { 5280 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 5281 DE_NULL, 5282 5283 *m_descriptorPool, 5284 1, 5285 &layout 5286 }; 5287 5288 m_descriptorSets[descriptorSetNdx] = vk::allocateDescriptorSet(vkd, device, &allocateInfo).disown(); 5289 5290 { 5291 const vk::VkBufferViewCreateInfo createInfo = 5292 { 5293 vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, 5294 DE_NULL, 5295 0u, 5296 5297 context.getBuffer(), 5298 vk::VK_FORMAT_R16_UINT, 5299 descriptorSetNdx * m_maxUniformTexelCount * 2, 5300 count * 2 5301 }; 5302 5303 VK_CHECK(vkd.createBufferView(device, &createInfo, DE_NULL, &m_bufferViews[descriptorSetNdx])); 5304 } 5305 5306 { 5307 const vk::VkWriteDescriptorSet write = 5308 { 5309 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 5310 DE_NULL, 5311 m_descriptorSets[descriptorSetNdx], 5312 0u, 5313 0u, 5314 1u, 5315 vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 5316 DE_NULL, 5317 DE_NULL, 5318 &m_bufferViews[descriptorSetNdx] 5319 }; 5320 5321 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 5322 } 5323 } 5324 } 5325 5326 void RenderVertexUniformTexelBuffer::submit (SubmitContext& context) 5327 { 5328 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5329 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 5330 5331 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 5332 5333 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5334 { 5335 const deUint32 count = (deUint32)(m_bufferSize < (descriptorSetNdx + 1) * m_maxUniformTexelCount * 2 5336 ? m_bufferSize - descriptorSetNdx * m_maxUniformTexelCount * 2 5337 : m_maxUniformTexelCount * 2) / 2; 5338 5339 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &m_descriptorSets[descriptorSetNdx], 0u, DE_NULL); 5340 vkd.cmdDraw(commandBuffer, count, 1, 0, 0); 5341 } 5342 } 5343 5344 void RenderVertexUniformTexelBuffer::verify (VerifyRenderPassContext& context, size_t) 5345 { 5346 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5347 { 5348 const size_t offset = descriptorSetNdx * m_maxUniformTexelCount * 2; 5349 const deUint32 count = (deUint32)(m_bufferSize < (descriptorSetNdx + 1) * m_maxUniformTexelCount * 2 5350 ? m_bufferSize - descriptorSetNdx * m_maxUniformTexelCount * 2 5351 : m_maxUniformTexelCount * 2) / 2; 5352 5353 for (size_t pos = 0; pos < (size_t)count; pos++) 5354 { 5355 const deUint8 x = context.getReference().get(offset + pos * 2); 5356 const deUint8 y = context.getReference().get(offset + (pos * 2) + 1); 5357 5358 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), x, y); 5359 } 5360 } 5361 } 5362 5363 class RenderVertexStorageBuffer : public RenderPassCommand 5364 { 5365 public: 5366 RenderVertexStorageBuffer (void) {} 5367 ~RenderVertexStorageBuffer (void); 5368 5369 const char* getName (void) const { return "RenderVertexStorageBuffer"; } 5370 void logPrepare (TestLog&, size_t) const; 5371 void logSubmit (TestLog&, size_t) const; 5372 void prepare (PrepareRenderPassContext&); 5373 void submit (SubmitContext& context); 5374 void verify (VerifyRenderPassContext&, size_t); 5375 5376 private: 5377 PipelineResources m_resources; 5378 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 5379 vector<vk::VkDescriptorSet> m_descriptorSets; 5380 5381 vk::VkDeviceSize m_bufferSize; 5382 }; 5383 5384 RenderVertexStorageBuffer::~RenderVertexStorageBuffer (void) 5385 { 5386 } 5387 5388 void RenderVertexStorageBuffer::logPrepare (TestLog& log, size_t commandIndex) const 5389 { 5390 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render buffer as storage buffer." << TestLog::EndMessage; 5391 } 5392 5393 void RenderVertexStorageBuffer::logSubmit (TestLog& log, size_t commandIndex) const 5394 { 5395 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as storage buffer." << TestLog::EndMessage; 5396 } 5397 5398 void RenderVertexStorageBuffer::prepare (PrepareRenderPassContext& context) 5399 { 5400 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5401 const vk::VkDevice device = context.getContext().getDevice(); 5402 const vk::VkRenderPass renderPass = context.getRenderPass(); 5403 const deUint32 subpass = 0; 5404 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("storage-buffer.vert"), 0)); 5405 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-white.frag"), 0)); 5406 vector<vk::VkDescriptorSetLayoutBinding> bindings; 5407 5408 m_bufferSize = context.getBufferSize(); 5409 5410 { 5411 const vk::VkDescriptorSetLayoutBinding binding = 5412 { 5413 0u, 5414 vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 5415 1, 5416 vk::VK_SHADER_STAGE_VERTEX_BIT, 5417 DE_NULL 5418 }; 5419 5420 bindings.push_back(binding); 5421 } 5422 5423 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 5424 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0u, DE_NULL, m_resources); 5425 5426 { 5427 const deUint32 descriptorCount = (deUint32)(divRoundUp(m_bufferSize, (vk::VkDeviceSize)MAX_STORAGE_BUFFER_SIZE)); 5428 const vk::VkDescriptorPoolSize poolSizes = 5429 { 5430 vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 5431 descriptorCount 5432 }; 5433 const vk::VkDescriptorPoolCreateInfo createInfo = 5434 { 5435 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 5436 DE_NULL, 5437 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 5438 5439 descriptorCount, 5440 1u, 5441 &poolSizes, 5442 }; 5443 5444 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 5445 m_descriptorSets.resize(descriptorCount); 5446 } 5447 5448 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5449 { 5450 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 5451 const vk::VkDescriptorSetAllocateInfo allocateInfo = 5452 { 5453 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 5454 DE_NULL, 5455 5456 *m_descriptorPool, 5457 1, 5458 &layout 5459 }; 5460 5461 m_descriptorSets[descriptorSetNdx] = vk::allocateDescriptorSet(vkd, device, &allocateInfo).disown(); 5462 5463 { 5464 const vk::VkDescriptorBufferInfo bufferInfo = 5465 { 5466 context.getBuffer(), 5467 descriptorSetNdx * MAX_STORAGE_BUFFER_SIZE, 5468 de::min(m_bufferSize - descriptorSetNdx * MAX_STORAGE_BUFFER_SIZE, (vk::VkDeviceSize)MAX_STORAGE_BUFFER_SIZE) 5469 }; 5470 const vk::VkWriteDescriptorSet write = 5471 { 5472 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 5473 DE_NULL, 5474 m_descriptorSets[descriptorSetNdx], 5475 0u, 5476 0u, 5477 1u, 5478 vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 5479 DE_NULL, 5480 &bufferInfo, 5481 DE_NULL, 5482 }; 5483 5484 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 5485 } 5486 } 5487 } 5488 5489 void RenderVertexStorageBuffer::submit (SubmitContext& context) 5490 { 5491 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5492 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 5493 5494 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 5495 5496 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5497 { 5498 const size_t size = m_bufferSize < (descriptorSetNdx + 1) * MAX_STORAGE_BUFFER_SIZE 5499 ? (size_t)(m_bufferSize - descriptorSetNdx * MAX_STORAGE_BUFFER_SIZE) 5500 : (size_t)(MAX_STORAGE_BUFFER_SIZE); 5501 5502 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &m_descriptorSets[descriptorSetNdx], 0u, DE_NULL); 5503 vkd.cmdDraw(commandBuffer, (deUint32)(size / 2), 1, 0, 0); 5504 } 5505 } 5506 5507 void RenderVertexStorageBuffer::verify (VerifyRenderPassContext& context, size_t) 5508 { 5509 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5510 { 5511 const size_t offset = descriptorSetNdx * MAX_STORAGE_BUFFER_SIZE; 5512 const size_t size = m_bufferSize < (descriptorSetNdx + 1) * MAX_STORAGE_BUFFER_SIZE 5513 ? (size_t)(m_bufferSize - descriptorSetNdx * MAX_STORAGE_BUFFER_SIZE) 5514 : (size_t)(MAX_STORAGE_BUFFER_SIZE); 5515 5516 for (size_t pos = 0; pos < size / 2; pos++) 5517 { 5518 const deUint8 x = context.getReference().get(offset + pos * 2); 5519 const deUint8 y = context.getReference().get(offset + (pos * 2) + 1); 5520 5521 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), x, y); 5522 } 5523 } 5524 } 5525 5526 class RenderVertexStorageTexelBuffer : public RenderPassCommand 5527 { 5528 public: 5529 RenderVertexStorageTexelBuffer (void) {} 5530 ~RenderVertexStorageTexelBuffer (void); 5531 5532 const char* getName (void) const { return "RenderVertexStorageTexelBuffer"; } 5533 void logPrepare (TestLog&, size_t) const; 5534 void logSubmit (TestLog&, size_t) const; 5535 void prepare (PrepareRenderPassContext&); 5536 void submit (SubmitContext& context); 5537 void verify (VerifyRenderPassContext&, size_t); 5538 5539 private: 5540 PipelineResources m_resources; 5541 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 5542 vector<vk::VkDescriptorSet> m_descriptorSets; 5543 vector<vk::VkBufferView> m_bufferViews; 5544 5545 const vk::DeviceInterface* m_vkd; 5546 vk::VkDevice m_device; 5547 vk::VkDeviceSize m_bufferSize; 5548 deUint32 m_maxStorageTexelCount; 5549 }; 5550 5551 RenderVertexStorageTexelBuffer::~RenderVertexStorageTexelBuffer (void) 5552 { 5553 for (size_t bufferViewNdx = 0; bufferViewNdx < m_bufferViews.size(); bufferViewNdx++) 5554 { 5555 if (!!m_bufferViews[bufferViewNdx]) 5556 { 5557 m_vkd->destroyBufferView(m_device, m_bufferViews[bufferViewNdx], DE_NULL); 5558 m_bufferViews[bufferViewNdx] = (vk::VkBufferView)0; 5559 } 5560 } 5561 } 5562 5563 void RenderVertexStorageTexelBuffer::logPrepare (TestLog& log, size_t commandIndex) const 5564 { 5565 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render buffer as storage buffer." << TestLog::EndMessage; 5566 } 5567 5568 void RenderVertexStorageTexelBuffer::logSubmit (TestLog& log, size_t commandIndex) const 5569 { 5570 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as storage buffer." << TestLog::EndMessage; 5571 } 5572 5573 void RenderVertexStorageTexelBuffer::prepare (PrepareRenderPassContext& context) 5574 { 5575 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 5576 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 5577 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5578 const vk::VkDevice device = context.getContext().getDevice(); 5579 const vk::VkRenderPass renderPass = context.getRenderPass(); 5580 const deUint32 subpass = 0; 5581 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("storage-texel-buffer.vert"), 0)); 5582 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-white.frag"), 0)); 5583 vector<vk::VkDescriptorSetLayoutBinding> bindings; 5584 5585 m_device = device; 5586 m_vkd = &vkd; 5587 m_bufferSize = context.getBufferSize(); 5588 m_maxStorageTexelCount = vk::getPhysicalDeviceProperties(vki, physicalDevice).limits.maxTexelBufferElements; 5589 5590 { 5591 const vk::VkDescriptorSetLayoutBinding binding = 5592 { 5593 0u, 5594 vk::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 5595 1, 5596 vk::VK_SHADER_STAGE_VERTEX_BIT, 5597 DE_NULL 5598 }; 5599 5600 bindings.push_back(binding); 5601 } 5602 5603 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 5604 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0u, DE_NULL, m_resources); 5605 5606 { 5607 const deUint32 descriptorCount = (deUint32)(divRoundUp(m_bufferSize, (vk::VkDeviceSize)m_maxStorageTexelCount * 4)); 5608 const vk::VkDescriptorPoolSize poolSizes = 5609 { 5610 vk::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 5611 descriptorCount 5612 }; 5613 const vk::VkDescriptorPoolCreateInfo createInfo = 5614 { 5615 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 5616 DE_NULL, 5617 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 5618 5619 descriptorCount, 5620 1u, 5621 &poolSizes, 5622 }; 5623 5624 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 5625 m_descriptorSets.resize(descriptorCount, (vk::VkDescriptorSet)0); 5626 m_bufferViews.resize(descriptorCount, (vk::VkBufferView)0); 5627 } 5628 5629 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5630 { 5631 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 5632 const vk::VkDescriptorSetAllocateInfo allocateInfo = 5633 { 5634 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 5635 DE_NULL, 5636 5637 *m_descriptorPool, 5638 1, 5639 &layout 5640 }; 5641 5642 m_descriptorSets[descriptorSetNdx] = vk::allocateDescriptorSet(vkd, device, &allocateInfo).disown(); 5643 5644 { 5645 const vk::VkBufferViewCreateInfo createInfo = 5646 { 5647 vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, 5648 DE_NULL, 5649 0u, 5650 5651 context.getBuffer(), 5652 vk::VK_FORMAT_R32_UINT, 5653 descriptorSetNdx * m_maxStorageTexelCount * 4, 5654 (deUint32)de::min<vk::VkDeviceSize>(m_maxStorageTexelCount * 4, m_bufferSize - descriptorSetNdx * m_maxStorageTexelCount * 4) 5655 }; 5656 5657 VK_CHECK(vkd.createBufferView(device, &createInfo, DE_NULL, &m_bufferViews[descriptorSetNdx])); 5658 } 5659 5660 { 5661 const vk::VkWriteDescriptorSet write = 5662 { 5663 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 5664 DE_NULL, 5665 m_descriptorSets[descriptorSetNdx], 5666 0u, 5667 0u, 5668 1u, 5669 vk::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 5670 DE_NULL, 5671 DE_NULL, 5672 &m_bufferViews[descriptorSetNdx] 5673 }; 5674 5675 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 5676 } 5677 } 5678 } 5679 5680 void RenderVertexStorageTexelBuffer::submit (SubmitContext& context) 5681 { 5682 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5683 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 5684 5685 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 5686 5687 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5688 { 5689 const deUint32 count = (deUint32)(m_bufferSize < (descriptorSetNdx + 1) * m_maxStorageTexelCount * 4 5690 ? m_bufferSize - descriptorSetNdx * m_maxStorageTexelCount * 4 5691 : m_maxStorageTexelCount * 4) / 2; 5692 5693 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &m_descriptorSets[descriptorSetNdx], 0u, DE_NULL); 5694 vkd.cmdDraw(commandBuffer, count, 1, 0, 0); 5695 } 5696 } 5697 5698 void RenderVertexStorageTexelBuffer::verify (VerifyRenderPassContext& context, size_t) 5699 { 5700 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 5701 { 5702 const size_t offset = descriptorSetNdx * m_maxStorageTexelCount * 4; 5703 const deUint32 count = (deUint32)(m_bufferSize < (descriptorSetNdx + 1) * m_maxStorageTexelCount * 4 5704 ? m_bufferSize - descriptorSetNdx * m_maxStorageTexelCount * 4 5705 : m_maxStorageTexelCount * 4) / 2; 5706 5707 DE_ASSERT(context.getReference().getSize() <= 4 * m_maxStorageTexelCount * m_descriptorSets.size()); 5708 DE_ASSERT(context.getReference().getSize() > offset); 5709 DE_ASSERT(offset + count * 2 <= context.getReference().getSize()); 5710 5711 for (size_t pos = 0; pos < (size_t)count; pos++) 5712 { 5713 const deUint8 x = context.getReference().get(offset + pos * 2); 5714 const deUint8 y = context.getReference().get(offset + (pos * 2) + 1); 5715 5716 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), x, y); 5717 } 5718 } 5719 } 5720 5721 class RenderVertexStorageImage : public RenderPassCommand 5722 { 5723 public: 5724 RenderVertexStorageImage (void) {} 5725 ~RenderVertexStorageImage (void); 5726 5727 const char* getName (void) const { return "RenderVertexStorageImage"; } 5728 void logPrepare (TestLog&, size_t) const; 5729 void logSubmit (TestLog&, size_t) const; 5730 void prepare (PrepareRenderPassContext&); 5731 void submit (SubmitContext& context); 5732 void verify (VerifyRenderPassContext&, size_t); 5733 5734 private: 5735 PipelineResources m_resources; 5736 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 5737 vk::Move<vk::VkDescriptorSet> m_descriptorSet; 5738 vk::Move<vk::VkImageView> m_imageView; 5739 }; 5740 5741 RenderVertexStorageImage::~RenderVertexStorageImage (void) 5742 { 5743 } 5744 5745 void RenderVertexStorageImage::logPrepare (TestLog& log, size_t commandIndex) const 5746 { 5747 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render storage image." << TestLog::EndMessage; 5748 } 5749 5750 void RenderVertexStorageImage::logSubmit (TestLog& log, size_t commandIndex) const 5751 { 5752 log << TestLog::Message << commandIndex << ":" << getName() << " Render using storage image." << TestLog::EndMessage; 5753 } 5754 5755 void RenderVertexStorageImage::prepare (PrepareRenderPassContext& context) 5756 { 5757 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5758 const vk::VkDevice device = context.getContext().getDevice(); 5759 const vk::VkRenderPass renderPass = context.getRenderPass(); 5760 const deUint32 subpass = 0; 5761 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("storage-image.vert"), 0)); 5762 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-white.frag"), 0)); 5763 vector<vk::VkDescriptorSetLayoutBinding> bindings; 5764 5765 { 5766 const vk::VkDescriptorSetLayoutBinding binding = 5767 { 5768 0u, 5769 vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 5770 1, 5771 vk::VK_SHADER_STAGE_VERTEX_BIT, 5772 DE_NULL 5773 }; 5774 5775 bindings.push_back(binding); 5776 } 5777 5778 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 5779 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0u, DE_NULL, m_resources); 5780 5781 { 5782 const vk::VkDescriptorPoolSize poolSizes = 5783 { 5784 vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 5785 1 5786 }; 5787 const vk::VkDescriptorPoolCreateInfo createInfo = 5788 { 5789 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 5790 DE_NULL, 5791 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 5792 5793 1u, 5794 1u, 5795 &poolSizes, 5796 }; 5797 5798 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 5799 } 5800 5801 { 5802 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 5803 const vk::VkDescriptorSetAllocateInfo allocateInfo = 5804 { 5805 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 5806 DE_NULL, 5807 5808 *m_descriptorPool, 5809 1, 5810 &layout 5811 }; 5812 5813 m_descriptorSet = vk::allocateDescriptorSet(vkd, device, &allocateInfo); 5814 5815 { 5816 const vk::VkImageViewCreateInfo createInfo = 5817 { 5818 vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, 5819 DE_NULL, 5820 0u, 5821 5822 context.getImage(), 5823 vk::VK_IMAGE_VIEW_TYPE_2D, 5824 vk::VK_FORMAT_R8G8B8A8_UNORM, 5825 vk::makeComponentMappingRGBA(), 5826 { 5827 vk::VK_IMAGE_ASPECT_COLOR_BIT, 5828 0u, 5829 1u, 5830 0u, 5831 1u 5832 } 5833 }; 5834 5835 m_imageView = vk::createImageView(vkd, device, &createInfo); 5836 } 5837 5838 { 5839 const vk::VkDescriptorImageInfo imageInfo = 5840 { 5841 0, 5842 *m_imageView, 5843 context.getImageLayout() 5844 }; 5845 const vk::VkWriteDescriptorSet write = 5846 { 5847 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 5848 DE_NULL, 5849 *m_descriptorSet, 5850 0u, 5851 0u, 5852 1u, 5853 vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 5854 &imageInfo, 5855 DE_NULL, 5856 DE_NULL, 5857 }; 5858 5859 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 5860 } 5861 } 5862 } 5863 5864 void RenderVertexStorageImage::submit (SubmitContext& context) 5865 { 5866 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5867 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 5868 5869 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 5870 5871 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &(*m_descriptorSet), 0u, DE_NULL); 5872 vkd.cmdDraw(commandBuffer, context.getImageWidth() * context.getImageHeight() * 2, 1, 0, 0); 5873 } 5874 5875 void RenderVertexStorageImage::verify (VerifyRenderPassContext& context, size_t) 5876 { 5877 for (int pos = 0; pos < (int)(context.getReferenceImage().getWidth() * context.getReferenceImage().getHeight() * 2); pos++) 5878 { 5879 const tcu::IVec3 size = context.getReferenceImage().getAccess().getSize(); 5880 const tcu::UVec4 pixel = context.getReferenceImage().getAccess().getPixelUint((pos / 2) / size.x(), (pos / 2) % size.x()); 5881 5882 if (pos % 2 == 0) 5883 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), pixel.x(), pixel.y()); 5884 else 5885 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), pixel.z(), pixel.w()); 5886 } 5887 } 5888 5889 class RenderVertexSampledImage : public RenderPassCommand 5890 { 5891 public: 5892 RenderVertexSampledImage (void) {} 5893 ~RenderVertexSampledImage (void); 5894 5895 const char* getName (void) const { return "RenderVertexSampledImage"; } 5896 void logPrepare (TestLog&, size_t) const; 5897 void logSubmit (TestLog&, size_t) const; 5898 void prepare (PrepareRenderPassContext&); 5899 void submit (SubmitContext& context); 5900 void verify (VerifyRenderPassContext&, size_t); 5901 5902 private: 5903 PipelineResources m_resources; 5904 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 5905 vk::Move<vk::VkDescriptorSet> m_descriptorSet; 5906 vk::Move<vk::VkImageView> m_imageView; 5907 vk::Move<vk::VkSampler> m_sampler; 5908 }; 5909 5910 RenderVertexSampledImage::~RenderVertexSampledImage (void) 5911 { 5912 } 5913 5914 void RenderVertexSampledImage::logPrepare (TestLog& log, size_t commandIndex) const 5915 { 5916 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render sampled image." << TestLog::EndMessage; 5917 } 5918 5919 void RenderVertexSampledImage::logSubmit (TestLog& log, size_t commandIndex) const 5920 { 5921 log << TestLog::Message << commandIndex << ":" << getName() << " Render using sampled image." << TestLog::EndMessage; 5922 } 5923 5924 void RenderVertexSampledImage::prepare (PrepareRenderPassContext& context) 5925 { 5926 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 5927 const vk::VkDevice device = context.getContext().getDevice(); 5928 const vk::VkRenderPass renderPass = context.getRenderPass(); 5929 const deUint32 subpass = 0; 5930 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("sampled-image.vert"), 0)); 5931 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-white.frag"), 0)); 5932 vector<vk::VkDescriptorSetLayoutBinding> bindings; 5933 5934 { 5935 const vk::VkDescriptorSetLayoutBinding binding = 5936 { 5937 0u, 5938 vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 5939 1, 5940 vk::VK_SHADER_STAGE_VERTEX_BIT, 5941 DE_NULL 5942 }; 5943 5944 bindings.push_back(binding); 5945 } 5946 5947 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 5948 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0u, DE_NULL, m_resources); 5949 5950 { 5951 const vk::VkDescriptorPoolSize poolSizes = 5952 { 5953 vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 5954 1 5955 }; 5956 const vk::VkDescriptorPoolCreateInfo createInfo = 5957 { 5958 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 5959 DE_NULL, 5960 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 5961 5962 1u, 5963 1u, 5964 &poolSizes, 5965 }; 5966 5967 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 5968 } 5969 5970 { 5971 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 5972 const vk::VkDescriptorSetAllocateInfo allocateInfo = 5973 { 5974 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 5975 DE_NULL, 5976 5977 *m_descriptorPool, 5978 1, 5979 &layout 5980 }; 5981 5982 m_descriptorSet = vk::allocateDescriptorSet(vkd, device, &allocateInfo); 5983 5984 { 5985 const vk::VkImageViewCreateInfo createInfo = 5986 { 5987 vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, 5988 DE_NULL, 5989 0u, 5990 5991 context.getImage(), 5992 vk::VK_IMAGE_VIEW_TYPE_2D, 5993 vk::VK_FORMAT_R8G8B8A8_UNORM, 5994 vk::makeComponentMappingRGBA(), 5995 { 5996 vk::VK_IMAGE_ASPECT_COLOR_BIT, 5997 0u, 5998 1u, 5999 0u, 6000 1u 6001 } 6002 }; 6003 6004 m_imageView = vk::createImageView(vkd, device, &createInfo); 6005 } 6006 6007 { 6008 const vk::VkSamplerCreateInfo createInfo = 6009 { 6010 vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, 6011 DE_NULL, 6012 0u, 6013 6014 vk::VK_FILTER_NEAREST, 6015 vk::VK_FILTER_NEAREST, 6016 6017 vk::VK_SAMPLER_MIPMAP_MODE_LINEAR, 6018 vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, 6019 vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, 6020 vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, 6021 0.0f, 6022 VK_FALSE, 6023 1.0f, 6024 VK_FALSE, 6025 vk::VK_COMPARE_OP_ALWAYS, 6026 0.0f, 6027 0.0f, 6028 vk::VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 6029 VK_FALSE 6030 }; 6031 6032 m_sampler = vk::createSampler(vkd, device, &createInfo); 6033 } 6034 6035 { 6036 const vk::VkDescriptorImageInfo imageInfo = 6037 { 6038 *m_sampler, 6039 *m_imageView, 6040 context.getImageLayout() 6041 }; 6042 const vk::VkWriteDescriptorSet write = 6043 { 6044 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 6045 DE_NULL, 6046 *m_descriptorSet, 6047 0u, 6048 0u, 6049 1u, 6050 vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 6051 &imageInfo, 6052 DE_NULL, 6053 DE_NULL, 6054 }; 6055 6056 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 6057 } 6058 } 6059 } 6060 6061 void RenderVertexSampledImage::submit (SubmitContext& context) 6062 { 6063 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6064 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 6065 6066 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 6067 6068 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &(*m_descriptorSet), 0u, DE_NULL); 6069 vkd.cmdDraw(commandBuffer, context.getImageWidth() * context.getImageHeight() * 2, 1, 0, 0); 6070 } 6071 6072 void RenderVertexSampledImage::verify (VerifyRenderPassContext& context, size_t) 6073 { 6074 for (int pos = 0; pos < (int)(context.getReferenceImage().getWidth() * context.getReferenceImage().getHeight() * 2); pos++) 6075 { 6076 const tcu::IVec3 size = context.getReferenceImage().getAccess().getSize(); 6077 const tcu::UVec4 pixel = context.getReferenceImage().getAccess().getPixelUint((pos / 2) / size.x(), (pos / 2) % size.x()); 6078 6079 if (pos % 2 == 0) 6080 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), pixel.x(), pixel.y()); 6081 else 6082 context.getReferenceTarget().getAccess().setPixel(Vec4(1.0f, 1.0f, 1.0f, 1.0f), pixel.z(), pixel.w()); 6083 } 6084 } 6085 6086 class RenderFragmentUniformBuffer : public RenderPassCommand 6087 { 6088 public: 6089 RenderFragmentUniformBuffer (void) {} 6090 ~RenderFragmentUniformBuffer (void); 6091 6092 const char* getName (void) const { return "RenderFragmentUniformBuffer"; } 6093 void logPrepare (TestLog&, size_t) const; 6094 void logSubmit (TestLog&, size_t) const; 6095 void prepare (PrepareRenderPassContext&); 6096 void submit (SubmitContext& context); 6097 void verify (VerifyRenderPassContext&, size_t); 6098 6099 private: 6100 PipelineResources m_resources; 6101 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 6102 vector<vk::VkDescriptorSet> m_descriptorSets; 6103 6104 vk::VkDeviceSize m_bufferSize; 6105 size_t m_targetWidth; 6106 size_t m_targetHeight; 6107 }; 6108 6109 RenderFragmentUniformBuffer::~RenderFragmentUniformBuffer (void) 6110 { 6111 } 6112 6113 void RenderFragmentUniformBuffer::logPrepare (TestLog& log, size_t commandIndex) const 6114 { 6115 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render buffer as uniform buffer." << TestLog::EndMessage; 6116 } 6117 6118 void RenderFragmentUniformBuffer::logSubmit (TestLog& log, size_t commandIndex) const 6119 { 6120 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as uniform buffer." << TestLog::EndMessage; 6121 } 6122 6123 void RenderFragmentUniformBuffer::prepare (PrepareRenderPassContext& context) 6124 { 6125 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6126 const vk::VkDevice device = context.getContext().getDevice(); 6127 const vk::VkRenderPass renderPass = context.getRenderPass(); 6128 const deUint32 subpass = 0; 6129 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-quad.vert"), 0)); 6130 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("uniform-buffer.frag"), 0)); 6131 vector<vk::VkDescriptorSetLayoutBinding> bindings; 6132 6133 m_bufferSize = de::min(context.getBufferSize(), (vk::VkDeviceSize)MAX_SIZE); 6134 m_targetWidth = context.getTargetWidth(); 6135 m_targetHeight = context.getTargetHeight(); 6136 6137 { 6138 const vk::VkDescriptorSetLayoutBinding binding = 6139 { 6140 0u, 6141 vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 6142 1, 6143 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 6144 DE_NULL 6145 }; 6146 6147 bindings.push_back(binding); 6148 } 6149 const vk::VkPushConstantRange pushConstantRange = 6150 { 6151 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 6152 0u, 6153 8u 6154 }; 6155 6156 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 6157 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 1u, &pushConstantRange, m_resources); 6158 6159 { 6160 const deUint32 descriptorCount = (deUint32)(divRoundUp(m_bufferSize, (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE)); 6161 const vk::VkDescriptorPoolSize poolSizes = 6162 { 6163 vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 6164 descriptorCount 6165 }; 6166 const vk::VkDescriptorPoolCreateInfo createInfo = 6167 { 6168 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 6169 DE_NULL, 6170 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 6171 6172 descriptorCount, 6173 1u, 6174 &poolSizes, 6175 }; 6176 6177 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 6178 m_descriptorSets.resize(descriptorCount); 6179 } 6180 6181 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 6182 { 6183 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 6184 const vk::VkDescriptorSetAllocateInfo allocateInfo = 6185 { 6186 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 6187 DE_NULL, 6188 6189 *m_descriptorPool, 6190 1, 6191 &layout 6192 }; 6193 6194 m_descriptorSets[descriptorSetNdx] = vk::allocateDescriptorSet(vkd, device, &allocateInfo).disown(); 6195 6196 { 6197 const vk::VkDescriptorBufferInfo bufferInfo = 6198 { 6199 context.getBuffer(), 6200 (vk::VkDeviceSize)(descriptorSetNdx * (size_t)MAX_UNIFORM_BUFFER_SIZE), 6201 m_bufferSize < (descriptorSetNdx + 1) * (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 6202 ? m_bufferSize - descriptorSetNdx * (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 6203 : (vk::VkDeviceSize)MAX_UNIFORM_BUFFER_SIZE 6204 }; 6205 const vk::VkWriteDescriptorSet write = 6206 { 6207 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 6208 DE_NULL, 6209 m_descriptorSets[descriptorSetNdx], 6210 0u, 6211 0u, 6212 1u, 6213 vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 6214 DE_NULL, 6215 &bufferInfo, 6216 DE_NULL, 6217 }; 6218 6219 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 6220 } 6221 } 6222 } 6223 6224 void RenderFragmentUniformBuffer::submit (SubmitContext& context) 6225 { 6226 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6227 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 6228 6229 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 6230 6231 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 6232 { 6233 const struct 6234 { 6235 const deUint32 callId; 6236 const deUint32 valuesPerPixel; 6237 } callParams = 6238 { 6239 (deUint32)descriptorSetNdx, 6240 (deUint32)divRoundUp<size_t>(m_descriptorSets.size() * (MAX_UNIFORM_BUFFER_SIZE / 4), m_targetWidth * m_targetHeight) 6241 }; 6242 6243 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &m_descriptorSets[descriptorSetNdx], 0u, DE_NULL); 6244 vkd.cmdPushConstants(commandBuffer, *m_resources.pipelineLayout, vk::VK_SHADER_STAGE_FRAGMENT_BIT, 0u, (deUint32)sizeof(callParams), &callParams); 6245 vkd.cmdDraw(commandBuffer, 6, 1, 0, 0); 6246 } 6247 } 6248 6249 void RenderFragmentUniformBuffer::verify (VerifyRenderPassContext& context, size_t) 6250 { 6251 const deUint32 valuesPerPixel = (deUint32)divRoundUp<size_t>(m_descriptorSets.size() * (MAX_UNIFORM_BUFFER_SIZE / 4), m_targetWidth * m_targetHeight); 6252 const size_t arraySize = MAX_UNIFORM_BUFFER_SIZE / (sizeof(deUint32) * 4); 6253 const size_t arrayIntSize = arraySize * 4; 6254 6255 for (int y = 0; y < context.getReferenceTarget().getSize().y(); y++) 6256 for (int x = 0; x < context.getReferenceTarget().getSize().x(); x++) 6257 { 6258 const size_t firstDescriptorSetNdx = de::min<size_t>((y * 256u + x) / (arrayIntSize / valuesPerPixel), m_descriptorSets.size() - 1); 6259 6260 for (size_t descriptorSetNdx = firstDescriptorSetNdx; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 6261 { 6262 const size_t offset = descriptorSetNdx * MAX_UNIFORM_BUFFER_SIZE; 6263 const deUint32 callId = (deUint32)descriptorSetNdx; 6264 6265 const deUint32 id = callId * ((deUint32)arrayIntSize / valuesPerPixel) + (deUint32)y * 256u + (deUint32)x; 6266 6267 if (y * 256u + x < callId * (arrayIntSize / valuesPerPixel)) 6268 continue; 6269 else 6270 { 6271 deUint32 value = id; 6272 6273 for (deUint32 i = 0; i < valuesPerPixel; i++) 6274 { 6275 value = ((deUint32)context.getReference().get(offset + (value % (MAX_UNIFORM_BUFFER_SIZE / sizeof(deUint32))) * 4 + 0)) 6276 | (((deUint32)context.getReference().get(offset + (value % (MAX_UNIFORM_BUFFER_SIZE / sizeof(deUint32))) * 4 + 1)) << 8u) 6277 | (((deUint32)context.getReference().get(offset + (value % (MAX_UNIFORM_BUFFER_SIZE / sizeof(deUint32))) * 4 + 2)) << 16u) 6278 | (((deUint32)context.getReference().get(offset + (value % (MAX_UNIFORM_BUFFER_SIZE / sizeof(deUint32))) * 4 + 3)) << 24u); 6279 6280 } 6281 const UVec4 vec ((value >> 0u) & 0xFFu, 6282 (value >> 8u) & 0xFFu, 6283 (value >> 16u) & 0xFFu, 6284 (value >> 24u) & 0xFFu); 6285 6286 context.getReferenceTarget().getAccess().setPixel(vec.asFloat() / Vec4(255.0f), x, y); 6287 } 6288 } 6289 } 6290 } 6291 6292 class RenderFragmentStorageBuffer : public RenderPassCommand 6293 { 6294 public: 6295 RenderFragmentStorageBuffer (void) {} 6296 ~RenderFragmentStorageBuffer (void); 6297 6298 const char* getName (void) const { return "RenderFragmentStorageBuffer"; } 6299 void logPrepare (TestLog&, size_t) const; 6300 void logSubmit (TestLog&, size_t) const; 6301 void prepare (PrepareRenderPassContext&); 6302 void submit (SubmitContext& context); 6303 void verify (VerifyRenderPassContext&, size_t); 6304 6305 private: 6306 PipelineResources m_resources; 6307 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 6308 vk::Move<vk::VkDescriptorSet> m_descriptorSet; 6309 6310 vk::VkDeviceSize m_bufferSize; 6311 size_t m_targetWidth; 6312 size_t m_targetHeight; 6313 }; 6314 6315 RenderFragmentStorageBuffer::~RenderFragmentStorageBuffer (void) 6316 { 6317 } 6318 6319 void RenderFragmentStorageBuffer::logPrepare (TestLog& log, size_t commandIndex) const 6320 { 6321 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline to render buffer as storage buffer." << TestLog::EndMessage; 6322 } 6323 6324 void RenderFragmentStorageBuffer::logSubmit (TestLog& log, size_t commandIndex) const 6325 { 6326 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as storage buffer." << TestLog::EndMessage; 6327 } 6328 6329 void RenderFragmentStorageBuffer::prepare (PrepareRenderPassContext& context) 6330 { 6331 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6332 const vk::VkDevice device = context.getContext().getDevice(); 6333 const vk::VkRenderPass renderPass = context.getRenderPass(); 6334 const deUint32 subpass = 0; 6335 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-quad.vert"), 0)); 6336 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("storage-buffer.frag"), 0)); 6337 vector<vk::VkDescriptorSetLayoutBinding> bindings; 6338 6339 m_bufferSize = context.getBufferSize(); 6340 m_targetWidth = context.getTargetWidth(); 6341 m_targetHeight = context.getTargetHeight(); 6342 6343 { 6344 const vk::VkDescriptorSetLayoutBinding binding = 6345 { 6346 0u, 6347 vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 6348 1, 6349 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 6350 DE_NULL 6351 }; 6352 6353 bindings.push_back(binding); 6354 } 6355 const vk::VkPushConstantRange pushConstantRange = 6356 { 6357 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 6358 0u, 6359 12u 6360 }; 6361 6362 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 6363 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 1u, &pushConstantRange, m_resources); 6364 6365 { 6366 const deUint32 descriptorCount = 1; 6367 const vk::VkDescriptorPoolSize poolSizes = 6368 { 6369 vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 6370 descriptorCount 6371 }; 6372 const vk::VkDescriptorPoolCreateInfo createInfo = 6373 { 6374 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 6375 DE_NULL, 6376 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 6377 6378 descriptorCount, 6379 1u, 6380 &poolSizes, 6381 }; 6382 6383 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 6384 } 6385 6386 { 6387 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 6388 const vk::VkDescriptorSetAllocateInfo allocateInfo = 6389 { 6390 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 6391 DE_NULL, 6392 6393 *m_descriptorPool, 6394 1, 6395 &layout 6396 }; 6397 6398 m_descriptorSet = vk::allocateDescriptorSet(vkd, device, &allocateInfo); 6399 6400 { 6401 const vk::VkDescriptorBufferInfo bufferInfo = 6402 { 6403 context.getBuffer(), 6404 0u, 6405 m_bufferSize 6406 }; 6407 const vk::VkWriteDescriptorSet write = 6408 { 6409 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 6410 DE_NULL, 6411 m_descriptorSet.get(), 6412 0u, 6413 0u, 6414 1u, 6415 vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 6416 DE_NULL, 6417 &bufferInfo, 6418 DE_NULL, 6419 }; 6420 6421 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 6422 } 6423 } 6424 } 6425 6426 void RenderFragmentStorageBuffer::submit (SubmitContext& context) 6427 { 6428 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6429 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 6430 6431 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 6432 6433 const struct 6434 { 6435 const deUint32 valuesPerPixel; 6436 const deUint32 bufferSize; 6437 } callParams = 6438 { 6439 (deUint32)divRoundUp<vk::VkDeviceSize>(m_bufferSize / 4, m_targetWidth * m_targetHeight), 6440 (deUint32)m_bufferSize 6441 }; 6442 6443 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &m_descriptorSet.get(), 0u, DE_NULL); 6444 vkd.cmdPushConstants(commandBuffer, *m_resources.pipelineLayout, vk::VK_SHADER_STAGE_FRAGMENT_BIT, 0u, (deUint32)sizeof(callParams), &callParams); 6445 vkd.cmdDraw(commandBuffer, 6, 1, 0, 0); 6446 } 6447 6448 void RenderFragmentStorageBuffer::verify (VerifyRenderPassContext& context, size_t) 6449 { 6450 const deUint32 valuesPerPixel = (deUint32)divRoundUp<vk::VkDeviceSize>(m_bufferSize / 4, m_targetWidth * m_targetHeight); 6451 6452 for (int y = 0; y < context.getReferenceTarget().getSize().y(); y++) 6453 for (int x = 0; x < context.getReferenceTarget().getSize().x(); x++) 6454 { 6455 const deUint32 id = (deUint32)y * 256u + (deUint32)x; 6456 6457 deUint32 value = id; 6458 6459 for (deUint32 i = 0; i < valuesPerPixel; i++) 6460 { 6461 value = (((deUint32)context.getReference().get((size_t)(value % (m_bufferSize / sizeof(deUint32))) * 4 + 0)) << 0u) 6462 | (((deUint32)context.getReference().get((size_t)(value % (m_bufferSize / sizeof(deUint32))) * 4 + 1)) << 8u) 6463 | (((deUint32)context.getReference().get((size_t)(value % (m_bufferSize / sizeof(deUint32))) * 4 + 2)) << 16u) 6464 | (((deUint32)context.getReference().get((size_t)(value % (m_bufferSize / sizeof(deUint32))) * 4 + 3)) << 24u); 6465 6466 } 6467 const UVec4 vec ((value >> 0u) & 0xFFu, 6468 (value >> 8u) & 0xFFu, 6469 (value >> 16u) & 0xFFu, 6470 (value >> 24u) & 0xFFu); 6471 6472 context.getReferenceTarget().getAccess().setPixel(vec.asFloat() / Vec4(255.0f), x, y); 6473 } 6474 } 6475 6476 class RenderFragmentUniformTexelBuffer : public RenderPassCommand 6477 { 6478 public: 6479 RenderFragmentUniformTexelBuffer (void) {} 6480 ~RenderFragmentUniformTexelBuffer (void); 6481 6482 const char* getName (void) const { return "RenderFragmentUniformTexelBuffer"; } 6483 void logPrepare (TestLog&, size_t) const; 6484 void logSubmit (TestLog&, size_t) const; 6485 void prepare (PrepareRenderPassContext&); 6486 void submit (SubmitContext& context); 6487 void verify (VerifyRenderPassContext&, size_t); 6488 6489 private: 6490 PipelineResources m_resources; 6491 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 6492 vector<vk::VkDescriptorSet> m_descriptorSets; 6493 vector<vk::VkBufferView> m_bufferViews; 6494 6495 const vk::DeviceInterface* m_vkd; 6496 vk::VkDevice m_device; 6497 vk::VkDeviceSize m_bufferSize; 6498 deUint32 m_maxUniformTexelCount; 6499 size_t m_targetWidth; 6500 size_t m_targetHeight; 6501 }; 6502 6503 RenderFragmentUniformTexelBuffer::~RenderFragmentUniformTexelBuffer (void) 6504 { 6505 for (size_t bufferViewNdx = 0; bufferViewNdx < m_bufferViews.size(); bufferViewNdx++) 6506 { 6507 if (!!m_bufferViews[bufferViewNdx]) 6508 { 6509 m_vkd->destroyBufferView(m_device, m_bufferViews[bufferViewNdx], DE_NULL); 6510 m_bufferViews[bufferViewNdx] = (vk::VkBufferView)0; 6511 } 6512 } 6513 } 6514 6515 void RenderFragmentUniformTexelBuffer::logPrepare (TestLog& log, size_t commandIndex) const 6516 { 6517 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render buffer as uniform buffer." << TestLog::EndMessage; 6518 } 6519 6520 void RenderFragmentUniformTexelBuffer::logSubmit (TestLog& log, size_t commandIndex) const 6521 { 6522 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as uniform buffer." << TestLog::EndMessage; 6523 } 6524 6525 void RenderFragmentUniformTexelBuffer::prepare (PrepareRenderPassContext& context) 6526 { 6527 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 6528 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 6529 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6530 const vk::VkDevice device = context.getContext().getDevice(); 6531 const vk::VkRenderPass renderPass = context.getRenderPass(); 6532 const deUint32 subpass = 0; 6533 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-quad.vert"), 0)); 6534 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("uniform-texel-buffer.frag"), 0)); 6535 vector<vk::VkDescriptorSetLayoutBinding> bindings; 6536 6537 m_device = device; 6538 m_vkd = &vkd; 6539 m_bufferSize = context.getBufferSize(); 6540 m_maxUniformTexelCount = vk::getPhysicalDeviceProperties(vki, physicalDevice).limits.maxTexelBufferElements; 6541 m_targetWidth = context.getTargetWidth(); 6542 m_targetHeight = context.getTargetHeight(); 6543 6544 { 6545 const vk::VkDescriptorSetLayoutBinding binding = 6546 { 6547 0u, 6548 vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 6549 1, 6550 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 6551 DE_NULL 6552 }; 6553 6554 bindings.push_back(binding); 6555 } 6556 const vk::VkPushConstantRange pushConstantRange = 6557 { 6558 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 6559 0u, 6560 12u 6561 }; 6562 6563 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 6564 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 1u, &pushConstantRange, m_resources); 6565 6566 { 6567 const deUint32 descriptorCount = (deUint32)(divRoundUp(m_bufferSize, (vk::VkDeviceSize)m_maxUniformTexelCount * 4)); 6568 const vk::VkDescriptorPoolSize poolSizes = 6569 { 6570 vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 6571 descriptorCount 6572 }; 6573 const vk::VkDescriptorPoolCreateInfo createInfo = 6574 { 6575 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 6576 DE_NULL, 6577 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 6578 6579 descriptorCount, 6580 1u, 6581 &poolSizes, 6582 }; 6583 6584 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 6585 m_descriptorSets.resize(descriptorCount, (vk::VkDescriptorSet)0); 6586 m_bufferViews.resize(descriptorCount, (vk::VkBufferView)0); 6587 } 6588 6589 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 6590 { 6591 const deUint32 count = (deUint32)(m_bufferSize < (descriptorSetNdx + 1) * m_maxUniformTexelCount * 4 6592 ? m_bufferSize - descriptorSetNdx * m_maxUniformTexelCount * 4 6593 : m_maxUniformTexelCount * 4) / 4; 6594 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 6595 const vk::VkDescriptorSetAllocateInfo allocateInfo = 6596 { 6597 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 6598 DE_NULL, 6599 6600 *m_descriptorPool, 6601 1, 6602 &layout 6603 }; 6604 6605 m_descriptorSets[descriptorSetNdx] = vk::allocateDescriptorSet(vkd, device, &allocateInfo).disown(); 6606 6607 { 6608 const vk::VkBufferViewCreateInfo createInfo = 6609 { 6610 vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, 6611 DE_NULL, 6612 0u, 6613 6614 context.getBuffer(), 6615 vk::VK_FORMAT_R32_UINT, 6616 descriptorSetNdx * m_maxUniformTexelCount * 4, 6617 count * 4 6618 }; 6619 6620 VK_CHECK(vkd.createBufferView(device, &createInfo, DE_NULL, &m_bufferViews[descriptorSetNdx])); 6621 } 6622 6623 { 6624 const vk::VkWriteDescriptorSet write = 6625 { 6626 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 6627 DE_NULL, 6628 m_descriptorSets[descriptorSetNdx], 6629 0u, 6630 0u, 6631 1u, 6632 vk::VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 6633 DE_NULL, 6634 DE_NULL, 6635 &m_bufferViews[descriptorSetNdx] 6636 }; 6637 6638 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 6639 } 6640 } 6641 } 6642 6643 void RenderFragmentUniformTexelBuffer::submit (SubmitContext& context) 6644 { 6645 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6646 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 6647 6648 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 6649 6650 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 6651 { 6652 const struct 6653 { 6654 const deUint32 callId; 6655 const deUint32 valuesPerPixel; 6656 const deUint32 maxUniformTexelCount; 6657 } callParams = 6658 { 6659 (deUint32)descriptorSetNdx, 6660 (deUint32)divRoundUp<size_t>(m_descriptorSets.size() * de::min<size_t>((size_t)m_bufferSize / 4, m_maxUniformTexelCount), m_targetWidth * m_targetHeight), 6661 m_maxUniformTexelCount 6662 }; 6663 6664 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &m_descriptorSets[descriptorSetNdx], 0u, DE_NULL); 6665 vkd.cmdPushConstants(commandBuffer, *m_resources.pipelineLayout, vk::VK_SHADER_STAGE_FRAGMENT_BIT, 0u, (deUint32)sizeof(callParams), &callParams); 6666 vkd.cmdDraw(commandBuffer, 6, 1, 0, 0); 6667 } 6668 } 6669 6670 void RenderFragmentUniformTexelBuffer::verify (VerifyRenderPassContext& context, size_t) 6671 { 6672 const deUint32 valuesPerPixel = (deUint32)divRoundUp<size_t>(m_descriptorSets.size() * de::min<size_t>((size_t)m_bufferSize / 4, m_maxUniformTexelCount), m_targetWidth * m_targetHeight); 6673 6674 for (int y = 0; y < context.getReferenceTarget().getSize().y(); y++) 6675 for (int x = 0; x < context.getReferenceTarget().getSize().x(); x++) 6676 { 6677 const size_t firstDescriptorSetNdx = de::min<size_t>((y * 256u + x) / (m_maxUniformTexelCount / valuesPerPixel), m_descriptorSets.size() - 1); 6678 6679 for (size_t descriptorSetNdx = firstDescriptorSetNdx; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 6680 { 6681 const size_t offset = descriptorSetNdx * m_maxUniformTexelCount * 4; 6682 const deUint32 callId = (deUint32)descriptorSetNdx; 6683 6684 const deUint32 id = (deUint32)y * 256u + (deUint32)x; 6685 const deUint32 count = (deUint32)(m_bufferSize < (descriptorSetNdx + 1) * m_maxUniformTexelCount * 4 6686 ? m_bufferSize - descriptorSetNdx * m_maxUniformTexelCount * 4 6687 : m_maxUniformTexelCount * 4) / 4; 6688 6689 if (y * 256u + x < callId * (m_maxUniformTexelCount / valuesPerPixel)) 6690 continue; 6691 else 6692 { 6693 deUint32 value = id; 6694 6695 for (deUint32 i = 0; i < valuesPerPixel; i++) 6696 { 6697 value = ((deUint32)context.getReference().get( offset + (value % count) * 4 + 0)) 6698 | (((deUint32)context.getReference().get(offset + (value % count) * 4 + 1)) << 8u) 6699 | (((deUint32)context.getReference().get(offset + (value % count) * 4 + 2)) << 16u) 6700 | (((deUint32)context.getReference().get(offset + (value % count) * 4 + 3)) << 24u); 6701 6702 } 6703 const UVec4 vec ((value >> 0u) & 0xFFu, 6704 (value >> 8u) & 0xFFu, 6705 (value >> 16u) & 0xFFu, 6706 (value >> 24u) & 0xFFu); 6707 6708 context.getReferenceTarget().getAccess().setPixel(vec.asFloat() / Vec4(255.0f), x, y); 6709 } 6710 } 6711 } 6712 } 6713 6714 class RenderFragmentStorageTexelBuffer : public RenderPassCommand 6715 { 6716 public: 6717 RenderFragmentStorageTexelBuffer (void) {} 6718 ~RenderFragmentStorageTexelBuffer (void); 6719 6720 const char* getName (void) const { return "RenderFragmentStorageTexelBuffer"; } 6721 void logPrepare (TestLog&, size_t) const; 6722 void logSubmit (TestLog&, size_t) const; 6723 void prepare (PrepareRenderPassContext&); 6724 void submit (SubmitContext& context); 6725 void verify (VerifyRenderPassContext&, size_t); 6726 6727 private: 6728 PipelineResources m_resources; 6729 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 6730 vector<vk::VkDescriptorSet> m_descriptorSets; 6731 vector<vk::VkBufferView> m_bufferViews; 6732 6733 const vk::DeviceInterface* m_vkd; 6734 vk::VkDevice m_device; 6735 vk::VkDeviceSize m_bufferSize; 6736 deUint32 m_maxStorageTexelCount; 6737 size_t m_targetWidth; 6738 size_t m_targetHeight; 6739 }; 6740 6741 RenderFragmentStorageTexelBuffer::~RenderFragmentStorageTexelBuffer (void) 6742 { 6743 for (size_t bufferViewNdx = 0; bufferViewNdx < m_bufferViews.size(); bufferViewNdx++) 6744 { 6745 if (!!m_bufferViews[bufferViewNdx]) 6746 { 6747 m_vkd->destroyBufferView(m_device, m_bufferViews[bufferViewNdx], DE_NULL); 6748 m_bufferViews[bufferViewNdx] = (vk::VkBufferView)0; 6749 } 6750 } 6751 } 6752 6753 void RenderFragmentStorageTexelBuffer::logPrepare (TestLog& log, size_t commandIndex) const 6754 { 6755 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render buffer as storage buffer." << TestLog::EndMessage; 6756 } 6757 6758 void RenderFragmentStorageTexelBuffer::logSubmit (TestLog& log, size_t commandIndex) const 6759 { 6760 log << TestLog::Message << commandIndex << ":" << getName() << " Render using buffer as storage buffer." << TestLog::EndMessage; 6761 } 6762 6763 void RenderFragmentStorageTexelBuffer::prepare (PrepareRenderPassContext& context) 6764 { 6765 const vk::InstanceInterface& vki = context.getContext().getInstanceInterface(); 6766 const vk::VkPhysicalDevice physicalDevice = context.getContext().getPhysicalDevice(); 6767 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6768 const vk::VkDevice device = context.getContext().getDevice(); 6769 const vk::VkRenderPass renderPass = context.getRenderPass(); 6770 const deUint32 subpass = 0; 6771 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-quad.vert"), 0)); 6772 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("storage-texel-buffer.frag"), 0)); 6773 vector<vk::VkDescriptorSetLayoutBinding> bindings; 6774 6775 m_device = device; 6776 m_vkd = &vkd; 6777 m_bufferSize = context.getBufferSize(); 6778 m_maxStorageTexelCount = vk::getPhysicalDeviceProperties(vki, physicalDevice).limits.maxTexelBufferElements; 6779 m_targetWidth = context.getTargetWidth(); 6780 m_targetHeight = context.getTargetHeight(); 6781 6782 { 6783 const vk::VkDescriptorSetLayoutBinding binding = 6784 { 6785 0u, 6786 vk::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 6787 1, 6788 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 6789 DE_NULL 6790 }; 6791 6792 bindings.push_back(binding); 6793 } 6794 const vk::VkPushConstantRange pushConstantRange = 6795 { 6796 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 6797 0u, 6798 16u 6799 }; 6800 6801 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 6802 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 1u, &pushConstantRange, m_resources); 6803 6804 { 6805 const deUint32 descriptorCount = (deUint32)(divRoundUp(m_bufferSize, (vk::VkDeviceSize)m_maxStorageTexelCount * 4)); 6806 const vk::VkDescriptorPoolSize poolSizes = 6807 { 6808 vk::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 6809 descriptorCount 6810 }; 6811 const vk::VkDescriptorPoolCreateInfo createInfo = 6812 { 6813 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 6814 DE_NULL, 6815 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 6816 6817 descriptorCount, 6818 1u, 6819 &poolSizes, 6820 }; 6821 6822 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 6823 m_descriptorSets.resize(descriptorCount, (vk::VkDescriptorSet)0); 6824 m_bufferViews.resize(descriptorCount, (vk::VkBufferView)0); 6825 } 6826 6827 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 6828 { 6829 const deUint32 count = (deUint32)(m_bufferSize < (descriptorSetNdx + 1) * m_maxStorageTexelCount * 4 6830 ? m_bufferSize - descriptorSetNdx * m_maxStorageTexelCount * 4 6831 : m_maxStorageTexelCount * 4) / 4; 6832 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 6833 const vk::VkDescriptorSetAllocateInfo allocateInfo = 6834 { 6835 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 6836 DE_NULL, 6837 6838 *m_descriptorPool, 6839 1, 6840 &layout 6841 }; 6842 6843 m_descriptorSets[descriptorSetNdx] = vk::allocateDescriptorSet(vkd, device, &allocateInfo).disown(); 6844 6845 { 6846 const vk::VkBufferViewCreateInfo createInfo = 6847 { 6848 vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, 6849 DE_NULL, 6850 0u, 6851 6852 context.getBuffer(), 6853 vk::VK_FORMAT_R32_UINT, 6854 descriptorSetNdx * m_maxStorageTexelCount * 4, 6855 count * 4 6856 }; 6857 6858 VK_CHECK(vkd.createBufferView(device, &createInfo, DE_NULL, &m_bufferViews[descriptorSetNdx])); 6859 } 6860 6861 { 6862 const vk::VkWriteDescriptorSet write = 6863 { 6864 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 6865 DE_NULL, 6866 m_descriptorSets[descriptorSetNdx], 6867 0u, 6868 0u, 6869 1u, 6870 vk::VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 6871 DE_NULL, 6872 DE_NULL, 6873 &m_bufferViews[descriptorSetNdx] 6874 }; 6875 6876 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 6877 } 6878 } 6879 } 6880 6881 void RenderFragmentStorageTexelBuffer::submit (SubmitContext& context) 6882 { 6883 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6884 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 6885 6886 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 6887 6888 for (size_t descriptorSetNdx = 0; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 6889 { 6890 const struct 6891 { 6892 const deUint32 callId; 6893 const deUint32 valuesPerPixel; 6894 const deUint32 maxStorageTexelCount; 6895 const deUint32 width; 6896 } callParams = 6897 { 6898 (deUint32)descriptorSetNdx, 6899 (deUint32)divRoundUp<size_t>(m_descriptorSets.size() * de::min<size_t>(m_maxStorageTexelCount, (size_t)m_bufferSize / 4), m_targetWidth * m_targetHeight), 6900 m_maxStorageTexelCount, 6901 (deUint32)(m_bufferSize < (descriptorSetNdx + 1u) * m_maxStorageTexelCount * 4u 6902 ? m_bufferSize - descriptorSetNdx * m_maxStorageTexelCount * 4u 6903 : m_maxStorageTexelCount * 4u) / 4u 6904 }; 6905 6906 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &m_descriptorSets[descriptorSetNdx], 0u, DE_NULL); 6907 vkd.cmdPushConstants(commandBuffer, *m_resources.pipelineLayout, vk::VK_SHADER_STAGE_FRAGMENT_BIT, 0u, (deUint32)sizeof(callParams), &callParams); 6908 vkd.cmdDraw(commandBuffer, 6, 1, 0, 0); 6909 } 6910 } 6911 6912 void RenderFragmentStorageTexelBuffer::verify (VerifyRenderPassContext& context, size_t) 6913 { 6914 const deUint32 valuesPerPixel = (deUint32)divRoundUp<size_t>(m_descriptorSets.size() * de::min<size_t>(m_maxStorageTexelCount, (size_t)m_bufferSize / 4), m_targetWidth * m_targetHeight); 6915 6916 for (int y = 0; y < context.getReferenceTarget().getSize().y(); y++) 6917 for (int x = 0; x < context.getReferenceTarget().getSize().x(); x++) 6918 { 6919 const size_t firstDescriptorSetNdx = de::min<size_t>((y * 256u + x) / (m_maxStorageTexelCount / valuesPerPixel), m_descriptorSets.size() - 1); 6920 6921 for (size_t descriptorSetNdx = firstDescriptorSetNdx; descriptorSetNdx < m_descriptorSets.size(); descriptorSetNdx++) 6922 { 6923 const size_t offset = descriptorSetNdx * m_maxStorageTexelCount * 4; 6924 const deUint32 callId = (deUint32)descriptorSetNdx; 6925 6926 const deUint32 id = (deUint32)y * 256u + (deUint32)x; 6927 const deUint32 count = (deUint32)(m_bufferSize < (descriptorSetNdx + 1) * m_maxStorageTexelCount * 4 6928 ? m_bufferSize - descriptorSetNdx * m_maxStorageTexelCount * 4 6929 : m_maxStorageTexelCount * 4) / 4; 6930 6931 if (y * 256u + x < callId * (m_maxStorageTexelCount / valuesPerPixel)) 6932 continue; 6933 else 6934 { 6935 deUint32 value = id; 6936 6937 for (deUint32 i = 0; i < valuesPerPixel; i++) 6938 { 6939 value = ((deUint32)context.getReference().get( offset + (value % count) * 4 + 0)) 6940 | (((deUint32)context.getReference().get(offset + (value % count) * 4 + 1)) << 8u) 6941 | (((deUint32)context.getReference().get(offset + (value % count) * 4 + 2)) << 16u) 6942 | (((deUint32)context.getReference().get(offset + (value % count) * 4 + 3)) << 24u); 6943 6944 } 6945 const UVec4 vec ((value >> 0u) & 0xFFu, 6946 (value >> 8u) & 0xFFu, 6947 (value >> 16u) & 0xFFu, 6948 (value >> 24u) & 0xFFu); 6949 6950 context.getReferenceTarget().getAccess().setPixel(vec.asFloat() / Vec4(255.0f), x, y); 6951 } 6952 } 6953 } 6954 } 6955 6956 class RenderFragmentStorageImage : public RenderPassCommand 6957 { 6958 public: 6959 RenderFragmentStorageImage (void) {} 6960 ~RenderFragmentStorageImage (void); 6961 6962 const char* getName (void) const { return "RenderFragmentStorageImage"; } 6963 void logPrepare (TestLog&, size_t) const; 6964 void logSubmit (TestLog&, size_t) const; 6965 void prepare (PrepareRenderPassContext&); 6966 void submit (SubmitContext& context); 6967 void verify (VerifyRenderPassContext&, size_t); 6968 6969 private: 6970 PipelineResources m_resources; 6971 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 6972 vk::Move<vk::VkDescriptorSet> m_descriptorSet; 6973 vk::Move<vk::VkImageView> m_imageView; 6974 }; 6975 6976 RenderFragmentStorageImage::~RenderFragmentStorageImage (void) 6977 { 6978 } 6979 6980 void RenderFragmentStorageImage::logPrepare (TestLog& log, size_t commandIndex) const 6981 { 6982 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render storage image." << TestLog::EndMessage; 6983 } 6984 6985 void RenderFragmentStorageImage::logSubmit (TestLog& log, size_t commandIndex) const 6986 { 6987 log << TestLog::Message << commandIndex << ":" << getName() << " Render using storage image." << TestLog::EndMessage; 6988 } 6989 6990 void RenderFragmentStorageImage::prepare (PrepareRenderPassContext& context) 6991 { 6992 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 6993 const vk::VkDevice device = context.getContext().getDevice(); 6994 const vk::VkRenderPass renderPass = context.getRenderPass(); 6995 const deUint32 subpass = 0; 6996 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-quad.vert"), 0)); 6997 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("storage-image.frag"), 0)); 6998 vector<vk::VkDescriptorSetLayoutBinding> bindings; 6999 7000 { 7001 const vk::VkDescriptorSetLayoutBinding binding = 7002 { 7003 0u, 7004 vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 7005 1, 7006 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 7007 DE_NULL 7008 }; 7009 7010 bindings.push_back(binding); 7011 } 7012 7013 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 7014 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0u, DE_NULL, m_resources); 7015 7016 { 7017 const vk::VkDescriptorPoolSize poolSizes = 7018 { 7019 vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 7020 1 7021 }; 7022 const vk::VkDescriptorPoolCreateInfo createInfo = 7023 { 7024 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 7025 DE_NULL, 7026 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 7027 7028 1u, 7029 1u, 7030 &poolSizes, 7031 }; 7032 7033 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 7034 } 7035 7036 { 7037 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 7038 const vk::VkDescriptorSetAllocateInfo allocateInfo = 7039 { 7040 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 7041 DE_NULL, 7042 7043 *m_descriptorPool, 7044 1, 7045 &layout 7046 }; 7047 7048 m_descriptorSet = vk::allocateDescriptorSet(vkd, device, &allocateInfo); 7049 7050 { 7051 const vk::VkImageViewCreateInfo createInfo = 7052 { 7053 vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, 7054 DE_NULL, 7055 0u, 7056 7057 context.getImage(), 7058 vk::VK_IMAGE_VIEW_TYPE_2D, 7059 vk::VK_FORMAT_R8G8B8A8_UNORM, 7060 vk::makeComponentMappingRGBA(), 7061 { 7062 vk::VK_IMAGE_ASPECT_COLOR_BIT, 7063 0u, 7064 1u, 7065 0u, 7066 1u 7067 } 7068 }; 7069 7070 m_imageView = vk::createImageView(vkd, device, &createInfo); 7071 } 7072 7073 { 7074 const vk::VkDescriptorImageInfo imageInfo = 7075 { 7076 0, 7077 *m_imageView, 7078 context.getImageLayout() 7079 }; 7080 const vk::VkWriteDescriptorSet write = 7081 { 7082 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 7083 DE_NULL, 7084 *m_descriptorSet, 7085 0u, 7086 0u, 7087 1u, 7088 vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 7089 &imageInfo, 7090 DE_NULL, 7091 DE_NULL, 7092 }; 7093 7094 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 7095 } 7096 } 7097 } 7098 7099 void RenderFragmentStorageImage::submit (SubmitContext& context) 7100 { 7101 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 7102 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 7103 7104 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 7105 7106 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &(*m_descriptorSet), 0u, DE_NULL); 7107 vkd.cmdDraw(commandBuffer, 6, 1, 0, 0); 7108 } 7109 7110 void RenderFragmentStorageImage::verify (VerifyRenderPassContext& context, size_t) 7111 { 7112 const UVec2 size = UVec2(context.getReferenceImage().getWidth(), context.getReferenceImage().getHeight()); 7113 const deUint32 valuesPerPixel = de::max<deUint32>(1u, (size.x() * size.y()) / (256u * 256u)); 7114 7115 for (int y = 0; y < context.getReferenceTarget().getSize().y(); y++) 7116 for (int x = 0; x < context.getReferenceTarget().getSize().x(); x++) 7117 { 7118 UVec4 value = UVec4(x, y, 0u, 0u); 7119 7120 for (deUint32 i = 0; i < valuesPerPixel; i++) 7121 { 7122 const UVec2 pos = UVec2(value.z() * 256u + (value.x() ^ value.z()), value.w() * 256u + (value.y() ^ value.w())); 7123 const Vec4 floatValue = context.getReferenceImage().getAccess().getPixel(pos.x() % size.x(), pos.y() % size.y()); 7124 7125 value = UVec4((deUint32)(floatValue.x() * 255.0f), 7126 (deUint32)(floatValue.y() * 255.0f), 7127 (deUint32)(floatValue.z() * 255.0f), 7128 (deUint32)(floatValue.w() * 255.0f)); 7129 7130 } 7131 context.getReferenceTarget().getAccess().setPixel(value.asFloat() / Vec4(255.0f), x, y); 7132 } 7133 } 7134 7135 class RenderFragmentSampledImage : public RenderPassCommand 7136 { 7137 public: 7138 RenderFragmentSampledImage (void) {} 7139 ~RenderFragmentSampledImage (void); 7140 7141 const char* getName (void) const { return "RenderFragmentSampledImage"; } 7142 void logPrepare (TestLog&, size_t) const; 7143 void logSubmit (TestLog&, size_t) const; 7144 void prepare (PrepareRenderPassContext&); 7145 void submit (SubmitContext& context); 7146 void verify (VerifyRenderPassContext&, size_t); 7147 7148 private: 7149 PipelineResources m_resources; 7150 vk::Move<vk::VkDescriptorPool> m_descriptorPool; 7151 vk::Move<vk::VkDescriptorSet> m_descriptorSet; 7152 vk::Move<vk::VkImageView> m_imageView; 7153 vk::Move<vk::VkSampler> m_sampler; 7154 }; 7155 7156 RenderFragmentSampledImage::~RenderFragmentSampledImage (void) 7157 { 7158 } 7159 7160 void RenderFragmentSampledImage::logPrepare (TestLog& log, size_t commandIndex) const 7161 { 7162 log << TestLog::Message << commandIndex << ":" << getName() << " Create pipeline for render storage image." << TestLog::EndMessage; 7163 } 7164 7165 void RenderFragmentSampledImage::logSubmit (TestLog& log, size_t commandIndex) const 7166 { 7167 log << TestLog::Message << commandIndex << ":" << getName() << " Render using storage image." << TestLog::EndMessage; 7168 } 7169 7170 void RenderFragmentSampledImage::prepare (PrepareRenderPassContext& context) 7171 { 7172 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 7173 const vk::VkDevice device = context.getContext().getDevice(); 7174 const vk::VkRenderPass renderPass = context.getRenderPass(); 7175 const deUint32 subpass = 0; 7176 const vk::Unique<vk::VkShaderModule> vertexShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("render-quad.vert"), 0)); 7177 const vk::Unique<vk::VkShaderModule> fragmentShaderModule (vk::createShaderModule(vkd, device, context.getBinaryCollection().get("sampled-image.frag"), 0)); 7178 vector<vk::VkDescriptorSetLayoutBinding> bindings; 7179 7180 { 7181 const vk::VkDescriptorSetLayoutBinding binding = 7182 { 7183 0u, 7184 vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 7185 1, 7186 vk::VK_SHADER_STAGE_FRAGMENT_BIT, 7187 DE_NULL 7188 }; 7189 7190 bindings.push_back(binding); 7191 } 7192 7193 createPipelineWithResources(vkd, device, renderPass, subpass, *vertexShaderModule, *fragmentShaderModule, context.getTargetWidth(), context.getTargetHeight(), 7194 vector<vk::VkVertexInputBindingDescription>(), vector<vk::VkVertexInputAttributeDescription>(), bindings, vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0u, DE_NULL, m_resources); 7195 7196 { 7197 const vk::VkDescriptorPoolSize poolSizes = 7198 { 7199 vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 7200 1 7201 }; 7202 const vk::VkDescriptorPoolCreateInfo createInfo = 7203 { 7204 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, 7205 DE_NULL, 7206 vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 7207 7208 1u, 7209 1u, 7210 &poolSizes, 7211 }; 7212 7213 m_descriptorPool = vk::createDescriptorPool(vkd, device, &createInfo); 7214 } 7215 7216 { 7217 const vk::VkDescriptorSetLayout layout = *m_resources.descriptorSetLayout; 7218 const vk::VkDescriptorSetAllocateInfo allocateInfo = 7219 { 7220 vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 7221 DE_NULL, 7222 7223 *m_descriptorPool, 7224 1, 7225 &layout 7226 }; 7227 7228 m_descriptorSet = vk::allocateDescriptorSet(vkd, device, &allocateInfo); 7229 7230 { 7231 const vk::VkImageViewCreateInfo createInfo = 7232 { 7233 vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, 7234 DE_NULL, 7235 0u, 7236 7237 context.getImage(), 7238 vk::VK_IMAGE_VIEW_TYPE_2D, 7239 vk::VK_FORMAT_R8G8B8A8_UNORM, 7240 vk::makeComponentMappingRGBA(), 7241 { 7242 vk::VK_IMAGE_ASPECT_COLOR_BIT, 7243 0u, 7244 1u, 7245 0u, 7246 1u 7247 } 7248 }; 7249 7250 m_imageView = vk::createImageView(vkd, device, &createInfo); 7251 } 7252 7253 { 7254 const vk::VkSamplerCreateInfo createInfo = 7255 { 7256 vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, 7257 DE_NULL, 7258 0u, 7259 7260 vk::VK_FILTER_NEAREST, 7261 vk::VK_FILTER_NEAREST, 7262 7263 vk::VK_SAMPLER_MIPMAP_MODE_LINEAR, 7264 vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, 7265 vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, 7266 vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, 7267 0.0f, 7268 VK_FALSE, 7269 1.0f, 7270 VK_FALSE, 7271 vk::VK_COMPARE_OP_ALWAYS, 7272 0.0f, 7273 0.0f, 7274 vk::VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 7275 VK_FALSE 7276 }; 7277 7278 m_sampler = vk::createSampler(vkd, device, &createInfo); 7279 } 7280 7281 { 7282 const vk::VkDescriptorImageInfo imageInfo = 7283 { 7284 *m_sampler, 7285 *m_imageView, 7286 context.getImageLayout() 7287 }; 7288 const vk::VkWriteDescriptorSet write = 7289 { 7290 vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, 7291 DE_NULL, 7292 *m_descriptorSet, 7293 0u, 7294 0u, 7295 1u, 7296 vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 7297 &imageInfo, 7298 DE_NULL, 7299 DE_NULL, 7300 }; 7301 7302 vkd.updateDescriptorSets(device, 1u, &write, 0u, DE_NULL); 7303 } 7304 } 7305 } 7306 7307 void RenderFragmentSampledImage::submit (SubmitContext& context) 7308 { 7309 const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface(); 7310 const vk::VkCommandBuffer commandBuffer = context.getCommandBuffer(); 7311 7312 vkd.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipeline); 7313 7314 vkd.cmdBindDescriptorSets(commandBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_resources.pipelineLayout, 0u, 1u, &(*m_descriptorSet), 0u, DE_NULL); 7315 vkd.cmdDraw(commandBuffer, 6u, 1u, 0u, 0u); 7316 } 7317 7318 void RenderFragmentSampledImage::verify (VerifyRenderPassContext& context, size_t) 7319 { 7320 const UVec2 size = UVec2(context.getReferenceImage().getWidth(), context.getReferenceImage().getHeight()); 7321 const deUint32 valuesPerPixel = de::max<deUint32>(1u, (size.x() * size.y()) / (256u * 256u)); 7322 7323 for (int y = 0; y < context.getReferenceTarget().getSize().y(); y++) 7324 for (int x = 0; x < context.getReferenceTarget().getSize().x(); x++) 7325 { 7326 UVec4 value = UVec4(x, y, 0u, 0u); 7327 7328 for (deUint32 i = 0; i < valuesPerPixel; i++) 7329 { 7330 const UVec2 pos = UVec2(value.z() * 256u + (value.x() ^ value.z()), value.w() * 256u + (value.y() ^ value.w())); 7331 const Vec4 floatValue = context.getReferenceImage().getAccess().getPixel(pos.x() % size.x(), pos.y() % size.y()); 7332 7333 value = UVec4((deUint32)(floatValue.x() * 255.0f), 7334 (deUint32)(floatValue.y() * 255.0f), 7335 (deUint32)(floatValue.z() * 255.0f), 7336 (deUint32)(floatValue.w() * 255.0f)); 7337 7338 } 7339 7340 context.getReferenceTarget().getAccess().setPixel(value.asFloat() / Vec4(255.0f), x, y); 7341 } 7342 } 7343 7344 enum Op 7345 { 7346 OP_MAP, 7347 OP_UNMAP, 7348 7349 OP_MAP_FLUSH, 7350 OP_MAP_INVALIDATE, 7351 7352 OP_MAP_READ, 7353 OP_MAP_WRITE, 7354 OP_MAP_MODIFY, 7355 7356 OP_BUFFER_CREATE, 7357 OP_BUFFER_DESTROY, 7358 OP_BUFFER_BINDMEMORY, 7359 7360 OP_QUEUE_WAIT_FOR_IDLE, 7361 OP_DEVICE_WAIT_FOR_IDLE, 7362 7363 OP_COMMAND_BUFFER_BEGIN, 7364 OP_COMMAND_BUFFER_END, 7365 7366 // Buffer transfer operations 7367 OP_BUFFER_FILL, 7368 OP_BUFFER_UPDATE, 7369 7370 OP_BUFFER_COPY_TO_BUFFER, 7371 OP_BUFFER_COPY_FROM_BUFFER, 7372 7373 OP_BUFFER_COPY_TO_IMAGE, 7374 OP_BUFFER_COPY_FROM_IMAGE, 7375 7376 OP_IMAGE_CREATE, 7377 OP_IMAGE_DESTROY, 7378 OP_IMAGE_BINDMEMORY, 7379 7380 OP_IMAGE_TRANSITION_LAYOUT, 7381 7382 OP_IMAGE_COPY_TO_BUFFER, 7383 OP_IMAGE_COPY_FROM_BUFFER, 7384 7385 OP_IMAGE_COPY_TO_IMAGE, 7386 OP_IMAGE_COPY_FROM_IMAGE, 7387 7388 OP_IMAGE_BLIT_TO_IMAGE, 7389 OP_IMAGE_BLIT_FROM_IMAGE, 7390 7391 OP_IMAGE_RESOLVE, 7392 7393 OP_PIPELINE_BARRIER_GLOBAL, 7394 OP_PIPELINE_BARRIER_BUFFER, 7395 OP_PIPELINE_BARRIER_IMAGE, 7396 7397 // Renderpass operations 7398 OP_RENDERPASS_BEGIN, 7399 OP_RENDERPASS_END, 7400 7401 // Commands inside render pass 7402 OP_RENDER_VERTEX_BUFFER, 7403 OP_RENDER_INDEX_BUFFER, 7404 7405 OP_RENDER_VERTEX_UNIFORM_BUFFER, 7406 OP_RENDER_FRAGMENT_UNIFORM_BUFFER, 7407 7408 OP_RENDER_VERTEX_UNIFORM_TEXEL_BUFFER, 7409 OP_RENDER_FRAGMENT_UNIFORM_TEXEL_BUFFER, 7410 7411 OP_RENDER_VERTEX_STORAGE_BUFFER, 7412 OP_RENDER_FRAGMENT_STORAGE_BUFFER, 7413 7414 OP_RENDER_VERTEX_STORAGE_TEXEL_BUFFER, 7415 OP_RENDER_FRAGMENT_STORAGE_TEXEL_BUFFER, 7416 7417 OP_RENDER_VERTEX_STORAGE_IMAGE, 7418 OP_RENDER_FRAGMENT_STORAGE_IMAGE, 7419 7420 OP_RENDER_VERTEX_SAMPLED_IMAGE, 7421 OP_RENDER_FRAGMENT_SAMPLED_IMAGE, 7422 }; 7423 7424 enum Stage 7425 { 7426 STAGE_HOST, 7427 STAGE_COMMAND_BUFFER, 7428 7429 STAGE_RENDER_PASS 7430 }; 7431 7432 vk::VkAccessFlags getWriteAccessFlags (void) 7433 { 7434 return vk::VK_ACCESS_SHADER_WRITE_BIT 7435 | vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT 7436 | vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT 7437 | vk::VK_ACCESS_TRANSFER_WRITE_BIT 7438 | vk::VK_ACCESS_HOST_WRITE_BIT 7439 | vk::VK_ACCESS_MEMORY_WRITE_BIT; 7440 } 7441 7442 bool isWriteAccess (vk::VkAccessFlagBits access) 7443 { 7444 return (getWriteAccessFlags() & access) != 0; 7445 } 7446 7447 class CacheState 7448 { 7449 public: 7450 CacheState (vk::VkPipelineStageFlags allowedStages, vk::VkAccessFlags allowedAccesses); 7451 7452 bool isValid (vk::VkPipelineStageFlagBits stage, 7453 vk::VkAccessFlagBits access) const; 7454 7455 void perform (vk::VkPipelineStageFlagBits stage, 7456 vk::VkAccessFlagBits access); 7457 7458 void submitCommandBuffer (void); 7459 void waitForIdle (void); 7460 7461 void getFullBarrier (vk::VkPipelineStageFlags& srcStages, 7462 vk::VkAccessFlags& srcAccesses, 7463 vk::VkPipelineStageFlags& dstStages, 7464 vk::VkAccessFlags& dstAccesses) const; 7465 7466 void barrier (vk::VkPipelineStageFlags srcStages, 7467 vk::VkAccessFlags srcAccesses, 7468 vk::VkPipelineStageFlags dstStages, 7469 vk::VkAccessFlags dstAccesses); 7470 7471 void imageLayoutBarrier (vk::VkPipelineStageFlags srcStages, 7472 vk::VkAccessFlags srcAccesses, 7473 vk::VkPipelineStageFlags dstStages, 7474 vk::VkAccessFlags dstAccesses); 7475 7476 void checkImageLayoutBarrier (vk::VkPipelineStageFlags srcStages, 7477 vk::VkAccessFlags srcAccesses, 7478 vk::VkPipelineStageFlags dstStages, 7479 vk::VkAccessFlags dstAccesses); 7480 7481 // Everything is clean and there is no need for barriers 7482 bool isClean (void) const; 7483 7484 vk::VkPipelineStageFlags getAllowedStages (void) const { return m_allowedStages; } 7485 vk::VkAccessFlags getAllowedAcceses (void) const { return m_allowedAccesses; } 7486 private: 7487 // Limit which stages and accesses are used by the CacheState tracker 7488 const vk::VkPipelineStageFlags m_allowedStages; 7489 const vk::VkAccessFlags m_allowedAccesses; 7490 7491 // [dstStage][srcStage] = srcAccesses 7492 // In stage dstStage write srcAccesses from srcStage are not yet available 7493 vk::VkAccessFlags m_unavailableWriteOperations[PIPELINESTAGE_LAST][PIPELINESTAGE_LAST]; 7494 // Latest pipeline transition is not available in stage 7495 bool m_unavailableLayoutTransition[PIPELINESTAGE_LAST]; 7496 // [dstStage] = dstAccesses 7497 // In stage dstStage ops with dstAccesses are not yet visible 7498 vk::VkAccessFlags m_invisibleOperations[PIPELINESTAGE_LAST]; 7499 7500 // [dstStage] = srcStage 7501 // Memory operation in srcStage have not completed before dstStage 7502 vk::VkPipelineStageFlags m_incompleteOperations[PIPELINESTAGE_LAST]; 7503 }; 7504 7505 CacheState::CacheState (vk::VkPipelineStageFlags allowedStages, vk::VkAccessFlags allowedAccesses) 7506 : m_allowedStages (allowedStages) 7507 , m_allowedAccesses (allowedAccesses) 7508 { 7509 for (vk::VkPipelineStageFlags dstStage_ = 1; dstStage_ <= m_allowedStages; dstStage_ <<= 1) 7510 { 7511 const PipelineStage dstStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)dstStage_); 7512 7513 if ((dstStage_ & m_allowedStages) == 0) 7514 continue; 7515 7516 // All operations are initially visible 7517 m_invisibleOperations[dstStage] = 0; 7518 7519 // There are no incomplete read operations initially 7520 m_incompleteOperations[dstStage] = 0; 7521 7522 // There are no incomplete layout transitions 7523 m_unavailableLayoutTransition[dstStage] = false; 7524 7525 for (vk::VkPipelineStageFlags srcStage_ = 1; srcStage_ <= m_allowedStages; srcStage_ <<= 1) 7526 { 7527 const PipelineStage srcStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)srcStage_); 7528 7529 if ((srcStage_ & m_allowedStages) == 0) 7530 continue; 7531 7532 // There are no write operations that are not yet available 7533 // initially. 7534 m_unavailableWriteOperations[dstStage][srcStage] = 0; 7535 } 7536 } 7537 } 7538 7539 bool CacheState::isValid (vk::VkPipelineStageFlagBits stage, 7540 vk::VkAccessFlagBits access) const 7541 { 7542 DE_ASSERT((access & (~m_allowedAccesses)) == 0); 7543 DE_ASSERT((stage & (~m_allowedStages)) == 0); 7544 7545 const PipelineStage dstStage = pipelineStageFlagToPipelineStage(stage); 7546 7547 // Previous operations are not visible to access on stage 7548 if (m_unavailableLayoutTransition[dstStage] || (m_invisibleOperations[dstStage] & access) != 0) 7549 return false; 7550 7551 if (isWriteAccess(access)) 7552 { 7553 // Memory operations from other stages have not completed before 7554 // dstStage 7555 if (m_incompleteOperations[dstStage] != 0) 7556 return false; 7557 } 7558 7559 return true; 7560 } 7561 7562 void CacheState::perform (vk::VkPipelineStageFlagBits stage, 7563 vk::VkAccessFlagBits access) 7564 { 7565 DE_ASSERT((access & (~m_allowedAccesses)) == 0); 7566 DE_ASSERT((stage & (~m_allowedStages)) == 0); 7567 7568 const PipelineStage srcStage = pipelineStageFlagToPipelineStage(stage); 7569 7570 for (vk::VkPipelineStageFlags dstStage_ = 1; dstStage_ <= m_allowedStages; dstStage_ <<= 1) 7571 { 7572 const PipelineStage dstStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)dstStage_); 7573 7574 if ((dstStage_ & m_allowedStages) == 0) 7575 continue; 7576 7577 // Mark stage as incomplete for all stages 7578 m_incompleteOperations[dstStage] |= stage; 7579 7580 if (isWriteAccess(access)) 7581 { 7582 // Mark all accesses from all stages invisible 7583 m_invisibleOperations[dstStage] |= m_allowedAccesses; 7584 7585 // Mark write access from srcStage unavailable to all stages 7586 m_unavailableWriteOperations[dstStage][srcStage] |= access; 7587 } 7588 } 7589 } 7590 7591 void CacheState::submitCommandBuffer (void) 7592 { 7593 // Flush all host writes and reads 7594 barrier(m_allowedStages & vk::VK_PIPELINE_STAGE_HOST_BIT, 7595 m_allowedAccesses & (vk::VK_ACCESS_HOST_READ_BIT | vk::VK_ACCESS_HOST_WRITE_BIT), 7596 m_allowedStages, 7597 m_allowedAccesses); 7598 } 7599 7600 void CacheState::waitForIdle (void) 7601 { 7602 // Make all writes available 7603 barrier(m_allowedStages, 7604 m_allowedAccesses & getWriteAccessFlags(), 7605 m_allowedStages, 7606 0); 7607 7608 // Make all writes visible on device side 7609 barrier(m_allowedStages, 7610 0, 7611 m_allowedStages & (~vk::VK_PIPELINE_STAGE_HOST_BIT), 7612 m_allowedAccesses); 7613 } 7614 7615 void CacheState::getFullBarrier (vk::VkPipelineStageFlags& srcStages, 7616 vk::VkAccessFlags& srcAccesses, 7617 vk::VkPipelineStageFlags& dstStages, 7618 vk::VkAccessFlags& dstAccesses) const 7619 { 7620 srcStages = 0; 7621 srcAccesses = 0; 7622 dstStages = 0; 7623 dstAccesses = 0; 7624 7625 for (vk::VkPipelineStageFlags dstStage_ = 1; dstStage_ <= m_allowedStages; dstStage_ <<= 1) 7626 { 7627 const PipelineStage dstStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)dstStage_); 7628 7629 if ((dstStage_ & m_allowedStages) == 0) 7630 continue; 7631 7632 // Make sure all previous operation are complete in all stages 7633 if (m_incompleteOperations[dstStage]) 7634 { 7635 dstStages |= dstStage_; 7636 srcStages |= m_incompleteOperations[dstStage]; 7637 } 7638 7639 // Make sure all read operations are visible in dstStage 7640 if (m_invisibleOperations[dstStage]) 7641 { 7642 dstStages |= dstStage_; 7643 dstAccesses |= m_invisibleOperations[dstStage]; 7644 } 7645 7646 // Make sure all write operations fro mall stages are available 7647 for (vk::VkPipelineStageFlags srcStage_ = 1; srcStage_ <= m_allowedStages; srcStage_ <<= 1) 7648 { 7649 const PipelineStage srcStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)srcStage_); 7650 7651 if ((srcStage_ & m_allowedStages) == 0) 7652 continue; 7653 7654 if (m_unavailableWriteOperations[dstStage][srcStage]) 7655 { 7656 dstStages |= dstStage_; 7657 srcStages |= dstStage_; 7658 srcAccesses |= m_unavailableWriteOperations[dstStage][srcStage]; 7659 } 7660 7661 if (m_unavailableLayoutTransition[dstStage] && !m_unavailableLayoutTransition[srcStage]) 7662 { 7663 // Add dependency between srcStage and dstStage if layout transition has not completed in dstStage, 7664 // but has completed in srcStage. 7665 dstStages |= dstStage_; 7666 srcStages |= dstStage_; 7667 } 7668 } 7669 } 7670 7671 DE_ASSERT((srcStages & (~m_allowedStages)) == 0); 7672 DE_ASSERT((srcAccesses & (~m_allowedAccesses)) == 0); 7673 DE_ASSERT((dstStages & (~m_allowedStages)) == 0); 7674 DE_ASSERT((dstAccesses & (~m_allowedAccesses)) == 0); 7675 } 7676 7677 void CacheState::checkImageLayoutBarrier (vk::VkPipelineStageFlags srcStages, 7678 vk::VkAccessFlags srcAccesses, 7679 vk::VkPipelineStageFlags dstStages, 7680 vk::VkAccessFlags dstAccesses) 7681 { 7682 DE_ASSERT((srcStages & (~m_allowedStages)) == 0); 7683 DE_ASSERT((srcAccesses & (~m_allowedAccesses)) == 0); 7684 DE_ASSERT((dstStages & (~m_allowedStages)) == 0); 7685 DE_ASSERT((dstAccesses & (~m_allowedAccesses)) == 0); 7686 7687 DE_UNREF(srcStages); 7688 DE_UNREF(srcAccesses); 7689 7690 DE_UNREF(dstStages); 7691 DE_UNREF(dstAccesses); 7692 7693 #if defined(DE_DEBUG) 7694 // Check that all stages have completed before srcStages or are in srcStages. 7695 { 7696 vk::VkPipelineStageFlags completedStages = srcStages; 7697 7698 for (vk::VkPipelineStageFlags srcStage_ = 1; srcStage_ <= srcStages; srcStage_ <<= 1) 7699 { 7700 const PipelineStage srcStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)srcStage_); 7701 7702 if ((srcStage_ & srcStages) == 0) 7703 continue; 7704 7705 completedStages |= (~m_incompleteOperations[srcStage]); 7706 } 7707 7708 DE_ASSERT((completedStages & m_allowedStages) == m_allowedStages); 7709 } 7710 7711 // Check that any write is available at least in one stage. Since all stages are complete even single flush is enough. 7712 if ((getWriteAccessFlags() & m_allowedAccesses) != 0 && (srcAccesses & getWriteAccessFlags()) == 0) 7713 { 7714 bool anyWriteAvailable = false; 7715 7716 for (vk::VkPipelineStageFlags dstStage_ = 1; dstStage_ <= m_allowedStages; dstStage_ <<= 1) 7717 { 7718 const PipelineStage dstStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)dstStage_); 7719 7720 if ((dstStage_ & m_allowedStages) == 0) 7721 continue; 7722 7723 for (vk::VkPipelineStageFlags srcStage_ = 1; srcStage_ <= m_allowedStages; srcStage_ <<= 1) 7724 { 7725 const PipelineStage srcStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)srcStage_); 7726 7727 if ((srcStage_ & m_allowedStages) == 0) 7728 continue; 7729 7730 if (m_unavailableWriteOperations[dstStage][srcStage] != (getWriteAccessFlags() & m_allowedAccesses)) 7731 { 7732 anyWriteAvailable = true; 7733 break; 7734 } 7735 } 7736 } 7737 7738 DE_ASSERT(anyWriteAvailable); 7739 } 7740 #endif 7741 } 7742 7743 void CacheState::imageLayoutBarrier (vk::VkPipelineStageFlags srcStages, 7744 vk::VkAccessFlags srcAccesses, 7745 vk::VkPipelineStageFlags dstStages, 7746 vk::VkAccessFlags dstAccesses) 7747 { 7748 checkImageLayoutBarrier(srcStages, srcAccesses, dstStages, dstAccesses); 7749 7750 for (vk::VkPipelineStageFlags dstStage_ = 1; dstStage_ <= m_allowedStages; dstStage_ <<= 1) 7751 { 7752 const PipelineStage dstStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)dstStage_); 7753 7754 if ((dstStage_ & m_allowedStages) == 0) 7755 continue; 7756 7757 // All stages are incomplete after the barrier except each dstStage in it self. 7758 m_incompleteOperations[dstStage] = m_allowedStages & (~dstStage_); 7759 7760 // All memory operations are invisible unless they are listed in dstAccess 7761 m_invisibleOperations[dstStage] = m_allowedAccesses & (~dstAccesses); 7762 7763 // Layout transition is unavailable in stage unless it was listed in dstStages 7764 m_unavailableLayoutTransition[dstStage]= (dstStage_ & dstStages) == 0; 7765 7766 for (vk::VkPipelineStageFlags srcStage_ = 1; srcStage_ <= m_allowedStages; srcStage_ <<= 1) 7767 { 7768 const PipelineStage srcStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)srcStage_); 7769 7770 if ((srcStage_ & m_allowedStages) == 0) 7771 continue; 7772 7773 // All write operations are available after layout transition 7774 m_unavailableWriteOperations[dstStage][srcStage] = 0; 7775 } 7776 } 7777 } 7778 7779 void CacheState::barrier (vk::VkPipelineStageFlags srcStages, 7780 vk::VkAccessFlags srcAccesses, 7781 vk::VkPipelineStageFlags dstStages, 7782 vk::VkAccessFlags dstAccesses) 7783 { 7784 DE_ASSERT((srcStages & (~m_allowedStages)) == 0); 7785 DE_ASSERT((srcAccesses & (~m_allowedAccesses)) == 0); 7786 DE_ASSERT((dstStages & (~m_allowedStages)) == 0); 7787 DE_ASSERT((dstAccesses & (~m_allowedAccesses)) == 0); 7788 7789 // Transitivity 7790 { 7791 vk::VkPipelineStageFlags oldIncompleteOperations[PIPELINESTAGE_LAST]; 7792 vk::VkAccessFlags oldUnavailableWriteOperations[PIPELINESTAGE_LAST][PIPELINESTAGE_LAST]; 7793 bool oldUnavailableLayoutTransition[PIPELINESTAGE_LAST]; 7794 7795 deMemcpy(oldIncompleteOperations, m_incompleteOperations, sizeof(oldIncompleteOperations)); 7796 deMemcpy(oldUnavailableWriteOperations, m_unavailableWriteOperations, sizeof(oldUnavailableWriteOperations)); 7797 deMemcpy(oldUnavailableLayoutTransition, m_unavailableLayoutTransition, sizeof(oldUnavailableLayoutTransition)); 7798 7799 for (vk::VkPipelineStageFlags srcStage_ = 1; srcStage_ <= srcStages; srcStage_ <<= 1) 7800 { 7801 const PipelineStage srcStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)srcStage_); 7802 7803 if ((srcStage_ & srcStages) == 0) 7804 continue; 7805 7806 for (vk::VkPipelineStageFlags dstStage_ = 1; dstStage_ <= dstStages; dstStage_ <<= 1) 7807 { 7808 const PipelineStage dstStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)dstStage_); 7809 7810 if ((dstStage_ & dstStages) == 0) 7811 continue; 7812 7813 // Stages that have completed before srcStage have also completed before dstStage 7814 m_incompleteOperations[dstStage] &= oldIncompleteOperations[srcStage]; 7815 7816 // Image layout transition in srcStage are now available in dstStage 7817 m_unavailableLayoutTransition[dstStage] &= oldUnavailableLayoutTransition[srcStage]; 7818 7819 for (vk::VkPipelineStageFlags sharedStage_ = 1; sharedStage_ <= m_allowedStages; sharedStage_ <<= 1) 7820 { 7821 const PipelineStage sharedStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)sharedStage_); 7822 7823 if ((sharedStage_ & m_allowedStages) == 0) 7824 continue; 7825 7826 // Writes that are available in srcStage are also available in dstStage 7827 m_unavailableWriteOperations[dstStage][sharedStage] &= oldUnavailableWriteOperations[srcStage][sharedStage]; 7828 } 7829 } 7830 } 7831 } 7832 7833 // Barrier 7834 for (vk::VkPipelineStageFlags dstStage_ = 1; dstStage_ <= dstStages; dstStage_ <<= 1) 7835 { 7836 const PipelineStage dstStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)dstStage_); 7837 bool allWritesAvailable = true; 7838 7839 if ((dstStage_ & dstStages) == 0) 7840 continue; 7841 7842 // Operations in srcStages have completed before any stage in dstStages 7843 m_incompleteOperations[dstStage] &= ~srcStages; 7844 7845 for (vk::VkPipelineStageFlags srcStage_ = 1; srcStage_ <= m_allowedStages; srcStage_ <<= 1) 7846 { 7847 const PipelineStage srcStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)srcStage_); 7848 7849 if ((srcStage_ & m_allowedStages) == 0) 7850 continue; 7851 7852 // Make srcAccesses from srcStage available in dstStage 7853 if ((srcStage_ & srcStages) != 0) 7854 m_unavailableWriteOperations[dstStage][srcStage] &= ~srcAccesses; 7855 7856 if (m_unavailableWriteOperations[dstStage][srcStage] != 0) 7857 allWritesAvailable = false; 7858 } 7859 7860 // If all writes are available in dstStage make dstAccesses also visible 7861 if (allWritesAvailable) 7862 m_invisibleOperations[dstStage] &= ~dstAccesses; 7863 } 7864 } 7865 7866 bool CacheState::isClean (void) const 7867 { 7868 for (vk::VkPipelineStageFlags dstStage_ = 1; dstStage_ <= m_allowedStages; dstStage_ <<= 1) 7869 { 7870 const PipelineStage dstStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)dstStage_); 7871 7872 if ((dstStage_ & m_allowedStages) == 0) 7873 continue; 7874 7875 // Some operations are not visible to some stages 7876 if (m_invisibleOperations[dstStage] != 0) 7877 return false; 7878 7879 // There are operation that have not completed yet 7880 if (m_incompleteOperations[dstStage] != 0) 7881 return false; 7882 7883 // Layout transition has not completed yet 7884 if (m_unavailableLayoutTransition[dstStage]) 7885 return false; 7886 7887 for (vk::VkPipelineStageFlags srcStage_ = 1; srcStage_ <= m_allowedStages; srcStage_ <<= 1) 7888 { 7889 const PipelineStage srcStage = pipelineStageFlagToPipelineStage((vk::VkPipelineStageFlagBits)srcStage_); 7890 7891 if ((srcStage_ & m_allowedStages) == 0) 7892 continue; 7893 7894 // Some write operations are not available yet 7895 if (m_unavailableWriteOperations[dstStage][srcStage] != 0) 7896 return false; 7897 } 7898 } 7899 7900 return true; 7901 } 7902 7903 bool layoutSupportedByUsage (Usage usage, vk::VkImageLayout layout) 7904 { 7905 switch (layout) 7906 { 7907 case vk::VK_IMAGE_LAYOUT_GENERAL: 7908 return true; 7909 7910 case vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: 7911 return (usage & USAGE_COLOR_ATTACHMENT) != 0; 7912 7913 case vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: 7914 return (usage & USAGE_DEPTH_STENCIL_ATTACHMENT) != 0; 7915 7916 case vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: 7917 return (usage & USAGE_DEPTH_STENCIL_ATTACHMENT) != 0; 7918 7919 case vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: 7920 // \todo [2016-03-09 mika] Should include input attachment 7921 return (usage & USAGE_SAMPLED_IMAGE) != 0; 7922 7923 case vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: 7924 return (usage & USAGE_TRANSFER_SRC) != 0; 7925 7926 case vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: 7927 return (usage & USAGE_TRANSFER_DST) != 0; 7928 7929 case vk::VK_IMAGE_LAYOUT_PREINITIALIZED: 7930 return true; 7931 7932 default: 7933 DE_FATAL("Unknown layout"); 7934 return false; 7935 } 7936 } 7937 7938 size_t getNumberOfSupportedLayouts (Usage usage) 7939 { 7940 const vk::VkImageLayout layouts[] = 7941 { 7942 vk::VK_IMAGE_LAYOUT_GENERAL, 7943 vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 7944 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, 7945 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, 7946 vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 7947 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 7948 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 7949 }; 7950 size_t supportedLayoutCount = 0; 7951 7952 for (size_t layoutNdx = 0; layoutNdx < DE_LENGTH_OF_ARRAY(layouts); layoutNdx++) 7953 { 7954 const vk::VkImageLayout layout = layouts[layoutNdx]; 7955 7956 if (layoutSupportedByUsage(usage, layout)) 7957 supportedLayoutCount++; 7958 } 7959 7960 return supportedLayoutCount; 7961 } 7962 7963 vk::VkImageLayout getRandomNextLayout (de::Random& rng, 7964 Usage usage, 7965 vk::VkImageLayout previousLayout) 7966 { 7967 const vk::VkImageLayout layouts[] = 7968 { 7969 vk::VK_IMAGE_LAYOUT_GENERAL, 7970 vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 7971 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, 7972 vk::VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, 7973 vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 7974 vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 7975 vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 7976 }; 7977 const size_t supportedLayoutCount = getNumberOfSupportedLayouts(usage); 7978 7979 DE_ASSERT(supportedLayoutCount > 0); 7980 7981 size_t nextLayoutNdx = ((size_t)rng.getUint64()) % (previousLayout == vk::VK_IMAGE_LAYOUT_UNDEFINED 7982 ? supportedLayoutCount 7983 : supportedLayoutCount - 1); 7984 7985 for (size_t layoutNdx = 0; layoutNdx < DE_LENGTH_OF_ARRAY(layouts); layoutNdx++) 7986 { 7987 const vk::VkImageLayout layout = layouts[layoutNdx]; 7988 7989 if (layoutSupportedByUsage(usage, layout) && layout != previousLayout) 7990 { 7991 if (nextLayoutNdx == 0) 7992 return layout; 7993 else 7994 nextLayoutNdx--; 7995 } 7996 } 7997 7998 DE_FATAL("Unreachable"); 7999 return vk::VK_IMAGE_LAYOUT_UNDEFINED; 8000 } 8001 8002 struct State 8003 { 8004 State (Usage usage, deUint32 seed) 8005 : stage (STAGE_HOST) 8006 , cache (usageToStageFlags(usage), usageToAccessFlags(usage)) 8007 , rng (seed) 8008 , mapped (false) 8009 , hostInvalidated (true) 8010 , hostFlushed (true) 8011 , memoryDefined (false) 8012 , hasBuffer (false) 8013 , hasBoundBufferMemory (false) 8014 , hasImage (false) 8015 , hasBoundImageMemory (false) 8016 , imageLayout (vk::VK_IMAGE_LAYOUT_UNDEFINED) 8017 , imageDefined (false) 8018 , queueIdle (true) 8019 , deviceIdle (true) 8020 , commandBufferIsEmpty (true) 8021 , renderPassIsEmpty (true) 8022 { 8023 } 8024 8025 Stage stage; 8026 CacheState cache; 8027 de::Random rng; 8028 8029 bool mapped; 8030 bool hostInvalidated; 8031 bool hostFlushed; 8032 bool memoryDefined; 8033 8034 bool hasBuffer; 8035 bool hasBoundBufferMemory; 8036 8037 bool hasImage; 8038 bool hasBoundImageMemory; 8039 vk::VkImageLayout imageLayout; 8040 bool imageDefined; 8041 8042 bool queueIdle; 8043 bool deviceIdle; 8044 8045 bool commandBufferIsEmpty; 8046 bool renderPassIsEmpty; 8047 }; 8048 8049 void getAvailableOps (const State& state, bool supportsBuffers, bool supportsImages, Usage usage, vector<Op>& ops) 8050 { 8051 if (state.stage == STAGE_HOST) 8052 { 8053 if (usage & (USAGE_HOST_READ | USAGE_HOST_WRITE)) 8054 { 8055 // Host memory operations 8056 if (state.mapped) 8057 { 8058 ops.push_back(OP_UNMAP); 8059 8060 // Avoid flush and finish if they are not needed 8061 if (!state.hostFlushed) 8062 ops.push_back(OP_MAP_FLUSH); 8063 8064 if (!state.hostInvalidated 8065 && state.queueIdle 8066 && ((usage & USAGE_HOST_READ) == 0 8067 || state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_READ_BIT)) 8068 && ((usage & USAGE_HOST_WRITE) == 0 8069 || state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_WRITE_BIT))) 8070 { 8071 ops.push_back(OP_MAP_INVALIDATE); 8072 } 8073 8074 if (usage & USAGE_HOST_READ 8075 && usage & USAGE_HOST_WRITE 8076 && state.memoryDefined 8077 && state.hostInvalidated 8078 && state.queueIdle 8079 && state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_WRITE_BIT) 8080 && state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_READ_BIT)) 8081 { 8082 ops.push_back(OP_MAP_MODIFY); 8083 } 8084 8085 if (usage & USAGE_HOST_READ 8086 && state.memoryDefined 8087 && state.hostInvalidated 8088 && state.queueIdle 8089 && state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_READ_BIT)) 8090 { 8091 ops.push_back(OP_MAP_READ); 8092 } 8093 8094 if (usage & USAGE_HOST_WRITE 8095 && state.hostInvalidated 8096 && state.queueIdle 8097 && state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_WRITE_BIT)) 8098 { 8099 ops.push_back(OP_MAP_WRITE); 8100 } 8101 } 8102 else 8103 ops.push_back(OP_MAP); 8104 } 8105 8106 if (state.hasBoundBufferMemory && state.queueIdle) 8107 { 8108 // \note Destroy only buffers after they have been bound 8109 ops.push_back(OP_BUFFER_DESTROY); 8110 } 8111 else 8112 { 8113 if (state.hasBuffer) 8114 { 8115 if (!state.hasBoundBufferMemory) 8116 ops.push_back(OP_BUFFER_BINDMEMORY); 8117 } 8118 else if (!state.hasImage && supportsBuffers) // Avoid creating buffer if there is already image 8119 ops.push_back(OP_BUFFER_CREATE); 8120 } 8121 8122 if (state.hasBoundImageMemory && state.queueIdle) 8123 { 8124 // \note Destroy only image after they have been bound 8125 ops.push_back(OP_IMAGE_DESTROY); 8126 } 8127 else 8128 { 8129 if (state.hasImage) 8130 { 8131 if (!state.hasBoundImageMemory) 8132 ops.push_back(OP_IMAGE_BINDMEMORY); 8133 } 8134 else if (!state.hasBuffer && supportsImages) // Avoid creating image if there is already buffer 8135 ops.push_back(OP_IMAGE_CREATE); 8136 } 8137 8138 // Host writes must be flushed before GPU commands and there must be 8139 // buffer or image for GPU commands 8140 if (state.hostFlushed 8141 && (state.memoryDefined || supportsDeviceBufferWrites(usage) || state.imageDefined || supportsDeviceImageWrites(usage)) 8142 && (state.hasBoundBufferMemory || state.hasBoundImageMemory) // Avoid command buffers if there is no object to use 8143 && (usageToStageFlags(usage) & (~vk::VK_PIPELINE_STAGE_HOST_BIT)) != 0) // Don't start command buffer if there are no ways to use memory from gpu 8144 { 8145 ops.push_back(OP_COMMAND_BUFFER_BEGIN); 8146 } 8147 8148 if (!state.deviceIdle) 8149 ops.push_back(OP_DEVICE_WAIT_FOR_IDLE); 8150 8151 if (!state.queueIdle) 8152 ops.push_back(OP_QUEUE_WAIT_FOR_IDLE); 8153 } 8154 else if (state.stage == STAGE_COMMAND_BUFFER) 8155 { 8156 if (!state.cache.isClean()) 8157 { 8158 ops.push_back(OP_PIPELINE_BARRIER_GLOBAL); 8159 8160 if (state.hasImage) 8161 ops.push_back(OP_PIPELINE_BARRIER_IMAGE); 8162 8163 if (state.hasBuffer) 8164 ops.push_back(OP_PIPELINE_BARRIER_BUFFER); 8165 } 8166 8167 if (state.hasBoundBufferMemory) 8168 { 8169 if (usage & USAGE_TRANSFER_DST 8170 && state.cache.isValid(vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_ACCESS_TRANSFER_WRITE_BIT)) 8171 { 8172 ops.push_back(OP_BUFFER_FILL); 8173 ops.push_back(OP_BUFFER_UPDATE); 8174 ops.push_back(OP_BUFFER_COPY_FROM_BUFFER); 8175 ops.push_back(OP_BUFFER_COPY_FROM_IMAGE); 8176 } 8177 8178 if (usage & USAGE_TRANSFER_SRC 8179 && state.memoryDefined 8180 && state.cache.isValid(vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_ACCESS_TRANSFER_READ_BIT)) 8181 { 8182 ops.push_back(OP_BUFFER_COPY_TO_BUFFER); 8183 ops.push_back(OP_BUFFER_COPY_TO_IMAGE); 8184 } 8185 } 8186 8187 if (state.hasBoundImageMemory 8188 && (state.imageLayout == vk::VK_IMAGE_LAYOUT_UNDEFINED 8189 || getNumberOfSupportedLayouts(usage) > 1)) 8190 { 8191 ops.push_back(OP_IMAGE_TRANSITION_LAYOUT); 8192 8193 { 8194 if (usage & USAGE_TRANSFER_DST 8195 && (state.imageLayout == vk::VK_IMAGE_LAYOUT_GENERAL 8196 || state.imageLayout == vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) 8197 && state.cache.isValid(vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_ACCESS_TRANSFER_WRITE_BIT)) 8198 { 8199 ops.push_back(OP_IMAGE_COPY_FROM_BUFFER); 8200 ops.push_back(OP_IMAGE_COPY_FROM_IMAGE); 8201 ops.push_back(OP_IMAGE_BLIT_FROM_IMAGE); 8202 } 8203 8204 if (usage & USAGE_TRANSFER_SRC 8205 && (state.imageLayout == vk::VK_IMAGE_LAYOUT_GENERAL 8206 || state.imageLayout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL) 8207 && state.imageDefined 8208 && state.cache.isValid(vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_ACCESS_TRANSFER_READ_BIT)) 8209 { 8210 ops.push_back(OP_IMAGE_COPY_TO_BUFFER); 8211 ops.push_back(OP_IMAGE_COPY_TO_IMAGE); 8212 ops.push_back(OP_IMAGE_BLIT_TO_IMAGE); 8213 } 8214 } 8215 } 8216 8217 // \todo [2016-03-09 mika] Add other usages? 8218 if ((state.memoryDefined 8219 && state.hasBoundBufferMemory 8220 && (((usage & USAGE_VERTEX_BUFFER) 8221 && state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, vk::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT)) 8222 || ((usage & USAGE_INDEX_BUFFER) 8223 && state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, vk::VK_ACCESS_INDEX_READ_BIT)) 8224 || ((usage & USAGE_UNIFORM_BUFFER) 8225 && (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT) 8226 || state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT))) 8227 || ((usage & USAGE_UNIFORM_TEXEL_BUFFER) 8228 && (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT) 8229 || state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT))) 8230 || ((usage & USAGE_STORAGE_BUFFER) 8231 && (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT) 8232 || state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT))) 8233 || ((usage & USAGE_STORAGE_TEXEL_BUFFER) 8234 && state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)))) 8235 || (state.imageDefined 8236 && state.hasBoundImageMemory 8237 && (((usage & USAGE_STORAGE_IMAGE) 8238 && state.imageLayout == vk::VK_IMAGE_LAYOUT_GENERAL 8239 && (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT) 8240 || state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT))) 8241 || ((usage & USAGE_SAMPLED_IMAGE) 8242 && (state.imageLayout == vk::VK_IMAGE_LAYOUT_GENERAL 8243 || state.imageLayout == vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) 8244 && (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT) 8245 || state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)))))) 8246 { 8247 ops.push_back(OP_RENDERPASS_BEGIN); 8248 } 8249 8250 // \note This depends on previous operations and has to be always the 8251 // last command buffer operation check 8252 if (ops.empty() || !state.commandBufferIsEmpty) 8253 ops.push_back(OP_COMMAND_BUFFER_END); 8254 } 8255 else if (state.stage == STAGE_RENDER_PASS) 8256 { 8257 if ((usage & USAGE_VERTEX_BUFFER) != 0 8258 && state.memoryDefined 8259 && state.hasBoundBufferMemory 8260 && state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, vk::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT)) 8261 { 8262 ops.push_back(OP_RENDER_VERTEX_BUFFER); 8263 } 8264 8265 if ((usage & USAGE_INDEX_BUFFER) != 0 8266 && state.memoryDefined 8267 && state.hasBoundBufferMemory 8268 && state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, vk::VK_ACCESS_INDEX_READ_BIT)) 8269 { 8270 ops.push_back(OP_RENDER_INDEX_BUFFER); 8271 } 8272 8273 if ((usage & USAGE_UNIFORM_BUFFER) != 0 8274 && state.memoryDefined 8275 && state.hasBoundBufferMemory) 8276 { 8277 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT)) 8278 ops.push_back(OP_RENDER_VERTEX_UNIFORM_BUFFER); 8279 8280 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT)) 8281 ops.push_back(OP_RENDER_FRAGMENT_UNIFORM_BUFFER); 8282 } 8283 8284 if ((usage & USAGE_UNIFORM_TEXEL_BUFFER) != 0 8285 && state.memoryDefined 8286 && state.hasBoundBufferMemory) 8287 { 8288 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT)) 8289 ops.push_back(OP_RENDER_VERTEX_UNIFORM_TEXEL_BUFFER); 8290 8291 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT)) 8292 ops.push_back(OP_RENDER_FRAGMENT_UNIFORM_TEXEL_BUFFER); 8293 } 8294 8295 if ((usage & USAGE_STORAGE_BUFFER) != 0 8296 && state.memoryDefined 8297 && state.hasBoundBufferMemory) 8298 { 8299 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)) 8300 ops.push_back(OP_RENDER_VERTEX_STORAGE_BUFFER); 8301 8302 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)) 8303 ops.push_back(OP_RENDER_FRAGMENT_STORAGE_BUFFER); 8304 } 8305 8306 if ((usage & USAGE_STORAGE_TEXEL_BUFFER) != 0 8307 && state.memoryDefined 8308 && state.hasBoundBufferMemory) 8309 { 8310 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)) 8311 ops.push_back(OP_RENDER_VERTEX_STORAGE_TEXEL_BUFFER); 8312 8313 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)) 8314 ops.push_back(OP_RENDER_FRAGMENT_STORAGE_TEXEL_BUFFER); 8315 } 8316 8317 if ((usage & USAGE_STORAGE_IMAGE) != 0 8318 && state.imageDefined 8319 && state.hasBoundImageMemory 8320 && (state.imageLayout == vk::VK_IMAGE_LAYOUT_GENERAL)) 8321 { 8322 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)) 8323 ops.push_back(OP_RENDER_VERTEX_STORAGE_IMAGE); 8324 8325 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)) 8326 ops.push_back(OP_RENDER_FRAGMENT_STORAGE_IMAGE); 8327 } 8328 8329 if ((usage & USAGE_SAMPLED_IMAGE) != 0 8330 && state.imageDefined 8331 && state.hasBoundImageMemory 8332 && (state.imageLayout == vk::VK_IMAGE_LAYOUT_GENERAL 8333 || state.imageLayout == vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)) 8334 { 8335 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)) 8336 ops.push_back(OP_RENDER_VERTEX_SAMPLED_IMAGE); 8337 8338 if (state.cache.isValid(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT)) 8339 ops.push_back(OP_RENDER_FRAGMENT_SAMPLED_IMAGE); 8340 } 8341 8342 if (!state.renderPassIsEmpty) 8343 ops.push_back(OP_RENDERPASS_END); 8344 } 8345 else 8346 DE_FATAL("Unknown stage"); 8347 } 8348 8349 void removeIllegalAccessFlags (vk::VkAccessFlags& accessflags, vk::VkPipelineStageFlags stageflags) 8350 { 8351 if (!(stageflags & vk::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT)) 8352 accessflags &= ~vk::VK_ACCESS_INDIRECT_COMMAND_READ_BIT; 8353 8354 if (!(stageflags & vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT)) 8355 accessflags &= ~vk::VK_ACCESS_INDEX_READ_BIT; 8356 8357 if (!(stageflags & vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT)) 8358 accessflags &= ~vk::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT; 8359 8360 if (!(stageflags & (vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | 8361 vk::VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | 8362 vk::VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | 8363 vk::VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT | 8364 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | 8365 vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT))) 8366 accessflags &= ~vk::VK_ACCESS_UNIFORM_READ_BIT; 8367 8368 if (!(stageflags & vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT)) 8369 accessflags &= ~vk::VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; 8370 8371 if (!(stageflags & (vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | 8372 vk::VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | 8373 vk::VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | 8374 vk::VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT | 8375 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | 8376 vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT))) 8377 accessflags &= ~vk::VK_ACCESS_SHADER_READ_BIT; 8378 8379 if (!(stageflags & (vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | 8380 vk::VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | 8381 vk::VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | 8382 vk::VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT | 8383 vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | 8384 vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT))) 8385 accessflags &= ~vk::VK_ACCESS_SHADER_WRITE_BIT; 8386 8387 if (!(stageflags & vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT)) 8388 accessflags &= ~vk::VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; 8389 8390 if (!(stageflags & vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT)) 8391 accessflags &= ~vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; 8392 8393 if (!(stageflags & (vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | 8394 vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT))) 8395 accessflags &= ~vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; 8396 8397 if (!(stageflags & (vk::VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | 8398 vk::VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT))) 8399 accessflags &= ~vk::VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; 8400 8401 if (!(stageflags & vk::VK_PIPELINE_STAGE_TRANSFER_BIT)) 8402 accessflags &= ~vk::VK_ACCESS_TRANSFER_READ_BIT; 8403 8404 if (!(stageflags & vk::VK_PIPELINE_STAGE_TRANSFER_BIT)) 8405 accessflags &= ~vk::VK_ACCESS_TRANSFER_WRITE_BIT; 8406 8407 if (!(stageflags & vk::VK_PIPELINE_STAGE_HOST_BIT)) 8408 accessflags &= ~vk::VK_ACCESS_HOST_READ_BIT; 8409 8410 if (!(stageflags & vk::VK_PIPELINE_STAGE_HOST_BIT)) 8411 accessflags &= ~vk::VK_ACCESS_HOST_WRITE_BIT; 8412 } 8413 8414 void applyOp (State& state, const Memory& memory, Op op, Usage usage) 8415 { 8416 switch (op) 8417 { 8418 case OP_MAP: 8419 DE_ASSERT(state.stage == STAGE_HOST); 8420 DE_ASSERT(!state.mapped); 8421 state.mapped = true; 8422 break; 8423 8424 case OP_UNMAP: 8425 DE_ASSERT(state.stage == STAGE_HOST); 8426 DE_ASSERT(state.mapped); 8427 state.mapped = false; 8428 break; 8429 8430 case OP_MAP_FLUSH: 8431 DE_ASSERT(state.stage == STAGE_HOST); 8432 DE_ASSERT(!state.hostFlushed); 8433 state.hostFlushed = true; 8434 break; 8435 8436 case OP_MAP_INVALIDATE: 8437 DE_ASSERT(state.stage == STAGE_HOST); 8438 DE_ASSERT(!state.hostInvalidated); 8439 state.hostInvalidated = true; 8440 break; 8441 8442 case OP_MAP_READ: 8443 DE_ASSERT(state.stage == STAGE_HOST); 8444 DE_ASSERT(state.hostInvalidated); 8445 state.rng.getUint32(); 8446 break; 8447 8448 case OP_MAP_WRITE: 8449 DE_ASSERT(state.stage == STAGE_HOST); 8450 if ((memory.getMemoryType().propertyFlags & vk::VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0) 8451 state.hostFlushed = false; 8452 8453 state.memoryDefined = true; 8454 state.imageDefined = false; 8455 state.imageLayout = vk::VK_IMAGE_LAYOUT_UNDEFINED; 8456 state.rng.getUint32(); 8457 break; 8458 8459 case OP_MAP_MODIFY: 8460 DE_ASSERT(state.stage == STAGE_HOST); 8461 DE_ASSERT(state.hostInvalidated); 8462 8463 if ((memory.getMemoryType().propertyFlags & vk::VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0) 8464 state.hostFlushed = false; 8465 8466 state.rng.getUint32(); 8467 break; 8468 8469 case OP_BUFFER_CREATE: 8470 DE_ASSERT(state.stage == STAGE_HOST); 8471 DE_ASSERT(!state.hasBuffer); 8472 8473 state.hasBuffer = true; 8474 break; 8475 8476 case OP_BUFFER_DESTROY: 8477 DE_ASSERT(state.stage == STAGE_HOST); 8478 DE_ASSERT(state.hasBuffer); 8479 DE_ASSERT(state.hasBoundBufferMemory); 8480 8481 state.hasBuffer = false; 8482 state.hasBoundBufferMemory = false; 8483 break; 8484 8485 case OP_BUFFER_BINDMEMORY: 8486 DE_ASSERT(state.stage == STAGE_HOST); 8487 DE_ASSERT(state.hasBuffer); 8488 DE_ASSERT(!state.hasBoundBufferMemory); 8489 8490 state.hasBoundBufferMemory = true; 8491 break; 8492 8493 case OP_IMAGE_CREATE: 8494 DE_ASSERT(state.stage == STAGE_HOST); 8495 DE_ASSERT(!state.hasImage); 8496 DE_ASSERT(!state.hasBuffer); 8497 8498 state.hasImage = true; 8499 break; 8500 8501 case OP_IMAGE_DESTROY: 8502 DE_ASSERT(state.stage == STAGE_HOST); 8503 DE_ASSERT(state.hasImage); 8504 DE_ASSERT(state.hasBoundImageMemory); 8505 8506 state.hasImage = false; 8507 state.hasBoundImageMemory = false; 8508 state.imageLayout = vk::VK_IMAGE_LAYOUT_UNDEFINED; 8509 state.imageDefined = false; 8510 break; 8511 8512 case OP_IMAGE_BINDMEMORY: 8513 DE_ASSERT(state.stage == STAGE_HOST); 8514 DE_ASSERT(state.hasImage); 8515 DE_ASSERT(!state.hasBoundImageMemory); 8516 8517 state.hasBoundImageMemory = true; 8518 break; 8519 8520 case OP_IMAGE_TRANSITION_LAYOUT: 8521 { 8522 DE_ASSERT(state.stage == STAGE_COMMAND_BUFFER); 8523 DE_ASSERT(state.hasImage); 8524 DE_ASSERT(state.hasBoundImageMemory); 8525 8526 // \todo [2016-03-09 mika] Support linear tiling and predefined data 8527 const vk::VkImageLayout srcLayout = state.rng.getFloat() < 0.9f ? state.imageLayout : vk::VK_IMAGE_LAYOUT_UNDEFINED; 8528 const vk::VkImageLayout dstLayout = getRandomNextLayout(state.rng, usage, srcLayout); 8529 8530 vk::VkPipelineStageFlags dirtySrcStages; 8531 vk::VkAccessFlags dirtySrcAccesses; 8532 vk::VkPipelineStageFlags dirtyDstStages; 8533 vk::VkAccessFlags dirtyDstAccesses; 8534 8535 vk::VkPipelineStageFlags srcStages; 8536 vk::VkAccessFlags srcAccesses; 8537 vk::VkPipelineStageFlags dstStages; 8538 vk::VkAccessFlags dstAccesses; 8539 8540 state.cache.getFullBarrier(dirtySrcStages, dirtySrcAccesses, dirtyDstStages, dirtyDstAccesses); 8541 8542 // Try masking some random bits 8543 srcStages = dirtySrcStages; 8544 srcAccesses = dirtySrcAccesses; 8545 8546 dstStages = state.cache.getAllowedStages() & state.rng.getUint32(); 8547 dstAccesses = state.cache.getAllowedAcceses() & state.rng.getUint32(); 8548 8549 // If there are no bits in dst stage mask use all stages 8550 dstStages = dstStages ? dstStages : state.cache.getAllowedStages(); 8551 8552 if (!srcStages) 8553 srcStages = dstStages; 8554 8555 removeIllegalAccessFlags(dstAccesses, dstStages); 8556 removeIllegalAccessFlags(srcAccesses, srcStages); 8557 8558 if (srcLayout == vk::VK_IMAGE_LAYOUT_UNDEFINED) 8559 state.imageDefined = false; 8560 8561 state.commandBufferIsEmpty = false; 8562 state.imageLayout = dstLayout; 8563 state.memoryDefined = false; 8564 state.cache.imageLayoutBarrier(srcStages, srcAccesses, dstStages, dstAccesses); 8565 break; 8566 } 8567 8568 case OP_QUEUE_WAIT_FOR_IDLE: 8569 DE_ASSERT(state.stage == STAGE_HOST); 8570 DE_ASSERT(!state.queueIdle); 8571 8572 state.queueIdle = true; 8573 8574 state.cache.waitForIdle(); 8575 break; 8576 8577 case OP_DEVICE_WAIT_FOR_IDLE: 8578 DE_ASSERT(state.stage == STAGE_HOST); 8579 DE_ASSERT(!state.deviceIdle); 8580 8581 state.queueIdle = true; 8582 state.deviceIdle = true; 8583 8584 state.cache.waitForIdle(); 8585 break; 8586 8587 case OP_COMMAND_BUFFER_BEGIN: 8588 DE_ASSERT(state.stage == STAGE_HOST); 8589 state.stage = STAGE_COMMAND_BUFFER; 8590 state.commandBufferIsEmpty = true; 8591 // Makes host writes visible to command buffer 8592 state.cache.submitCommandBuffer(); 8593 break; 8594 8595 case OP_COMMAND_BUFFER_END: 8596 DE_ASSERT(state.stage == STAGE_COMMAND_BUFFER); 8597 state.stage = STAGE_HOST; 8598 state.queueIdle = false; 8599 state.deviceIdle = false; 8600 break; 8601 8602 case OP_BUFFER_COPY_FROM_BUFFER: 8603 case OP_BUFFER_COPY_FROM_IMAGE: 8604 case OP_BUFFER_UPDATE: 8605 case OP_BUFFER_FILL: 8606 state.rng.getUint32(); 8607 DE_ASSERT(state.stage == STAGE_COMMAND_BUFFER); 8608 8609 if ((memory.getMemoryType().propertyFlags & vk::VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0) 8610 state.hostInvalidated = false; 8611 8612 state.commandBufferIsEmpty = false; 8613 state.memoryDefined = true; 8614 state.imageDefined = false; 8615 state.imageLayout = vk::VK_IMAGE_LAYOUT_UNDEFINED; 8616 state.cache.perform(vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_ACCESS_TRANSFER_WRITE_BIT); 8617 break; 8618 8619 case OP_BUFFER_COPY_TO_BUFFER: 8620 case OP_BUFFER_COPY_TO_IMAGE: 8621 DE_ASSERT(state.stage == STAGE_COMMAND_BUFFER); 8622 8623 state.commandBufferIsEmpty = false; 8624 state.cache.perform(vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_ACCESS_TRANSFER_READ_BIT); 8625 break; 8626 8627 case OP_IMAGE_BLIT_FROM_IMAGE: 8628 state.rng.getBool(); 8629 // Fall through 8630 case OP_IMAGE_COPY_FROM_BUFFER: 8631 case OP_IMAGE_COPY_FROM_IMAGE: 8632 state.rng.getUint32(); 8633 DE_ASSERT(state.stage == STAGE_COMMAND_BUFFER); 8634 8635 if ((memory.getMemoryType().propertyFlags & vk::VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0) 8636 state.hostInvalidated = false; 8637 8638 state.commandBufferIsEmpty = false; 8639 state.memoryDefined = false; 8640 state.imageDefined = true; 8641 state.cache.perform(vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_ACCESS_TRANSFER_WRITE_BIT); 8642 break; 8643 8644 case OP_IMAGE_BLIT_TO_IMAGE: 8645 state.rng.getBool(); 8646 // Fall through 8647 case OP_IMAGE_COPY_TO_BUFFER: 8648 case OP_IMAGE_COPY_TO_IMAGE: 8649 DE_ASSERT(state.stage == STAGE_COMMAND_BUFFER); 8650 8651 state.commandBufferIsEmpty = false; 8652 state.cache.perform(vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_ACCESS_TRANSFER_READ_BIT); 8653 break; 8654 8655 case OP_PIPELINE_BARRIER_GLOBAL: 8656 case OP_PIPELINE_BARRIER_BUFFER: 8657 case OP_PIPELINE_BARRIER_IMAGE: 8658 { 8659 DE_ASSERT(state.stage == STAGE_COMMAND_BUFFER); 8660 8661 vk::VkPipelineStageFlags dirtySrcStages; 8662 vk::VkAccessFlags dirtySrcAccesses; 8663 vk::VkPipelineStageFlags dirtyDstStages; 8664 vk::VkAccessFlags dirtyDstAccesses; 8665 8666 vk::VkPipelineStageFlags srcStages; 8667 vk::VkAccessFlags srcAccesses; 8668 vk::VkPipelineStageFlags dstStages; 8669 vk::VkAccessFlags dstAccesses; 8670 8671 state.cache.getFullBarrier(dirtySrcStages, dirtySrcAccesses, dirtyDstStages, dirtyDstAccesses); 8672 8673 // Try masking some random bits 8674 srcStages = dirtySrcStages & state.rng.getUint32(); 8675 srcAccesses = dirtySrcAccesses & state.rng.getUint32(); 8676 8677 dstStages = dirtyDstStages & state.rng.getUint32(); 8678 dstAccesses = dirtyDstAccesses & state.rng.getUint32(); 8679 8680 // If there are no bits in stage mask use the original dirty stages 8681 srcStages = srcStages ? srcStages : dirtySrcStages; 8682 dstStages = dstStages ? dstStages : dirtyDstStages; 8683 8684 if (!srcStages) 8685 srcStages = dstStages; 8686 8687 removeIllegalAccessFlags(dstAccesses, dstStages); 8688 removeIllegalAccessFlags(srcAccesses, srcStages); 8689 8690 state.commandBufferIsEmpty = false; 8691 state.cache.barrier(srcStages, srcAccesses, dstStages, dstAccesses); 8692 break; 8693 } 8694 8695 case OP_RENDERPASS_BEGIN: 8696 { 8697 DE_ASSERT(state.stage == STAGE_COMMAND_BUFFER); 8698 8699 state.renderPassIsEmpty = true; 8700 state.stage = STAGE_RENDER_PASS; 8701 break; 8702 } 8703 8704 case OP_RENDERPASS_END: 8705 { 8706 DE_ASSERT(state.stage == STAGE_RENDER_PASS); 8707 8708 state.renderPassIsEmpty = true; 8709 state.stage = STAGE_COMMAND_BUFFER; 8710 break; 8711 } 8712 8713 case OP_RENDER_VERTEX_BUFFER: 8714 { 8715 DE_ASSERT(state.stage == STAGE_RENDER_PASS); 8716 8717 state.renderPassIsEmpty = false; 8718 state.cache.perform(vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, vk::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT); 8719 break; 8720 } 8721 8722 case OP_RENDER_INDEX_BUFFER: 8723 { 8724 DE_ASSERT(state.stage == STAGE_RENDER_PASS); 8725 8726 state.renderPassIsEmpty = false; 8727 state.cache.perform(vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, vk::VK_ACCESS_INDEX_READ_BIT); 8728 break; 8729 } 8730 8731 case OP_RENDER_VERTEX_UNIFORM_BUFFER: 8732 case OP_RENDER_VERTEX_UNIFORM_TEXEL_BUFFER: 8733 { 8734 DE_ASSERT(state.stage == STAGE_RENDER_PASS); 8735 8736 state.renderPassIsEmpty = false; 8737 state.cache.perform(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT); 8738 break; 8739 } 8740 8741 case OP_RENDER_FRAGMENT_UNIFORM_BUFFER: 8742 case OP_RENDER_FRAGMENT_UNIFORM_TEXEL_BUFFER: 8743 { 8744 DE_ASSERT(state.stage == STAGE_RENDER_PASS); 8745 8746 state.renderPassIsEmpty = false; 8747 state.cache.perform(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_UNIFORM_READ_BIT); 8748 break; 8749 } 8750 8751 case OP_RENDER_VERTEX_STORAGE_BUFFER: 8752 case OP_RENDER_VERTEX_STORAGE_TEXEL_BUFFER: 8753 { 8754 DE_ASSERT(state.stage == STAGE_RENDER_PASS); 8755 8756 state.renderPassIsEmpty = false; 8757 state.cache.perform(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT); 8758 break; 8759 } 8760 8761 case OP_RENDER_FRAGMENT_STORAGE_BUFFER: 8762 case OP_RENDER_FRAGMENT_STORAGE_TEXEL_BUFFER: 8763 { 8764 DE_ASSERT(state.stage == STAGE_RENDER_PASS); 8765 8766 state.renderPassIsEmpty = false; 8767 state.cache.perform(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT); 8768 break; 8769 } 8770 8771 case OP_RENDER_FRAGMENT_STORAGE_IMAGE: 8772 case OP_RENDER_FRAGMENT_SAMPLED_IMAGE: 8773 { 8774 DE_ASSERT(state.stage == STAGE_RENDER_PASS); 8775 8776 state.renderPassIsEmpty = false; 8777 state.cache.perform(vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT); 8778 break; 8779 } 8780 8781 case OP_RENDER_VERTEX_STORAGE_IMAGE: 8782 case OP_RENDER_VERTEX_SAMPLED_IMAGE: 8783 { 8784 DE_ASSERT(state.stage == STAGE_RENDER_PASS); 8785 8786 state.renderPassIsEmpty = false; 8787 state.cache.perform(vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, vk::VK_ACCESS_SHADER_READ_BIT); 8788 break; 8789 } 8790 8791 default: 8792 DE_FATAL("Unknown op"); 8793 } 8794 } 8795 8796 de::MovePtr<Command> createHostCommand (Op op, 8797 de::Random& rng, 8798 Usage usage, 8799 vk::VkSharingMode sharing) 8800 { 8801 switch (op) 8802 { 8803 case OP_MAP: return de::MovePtr<Command>(new Map()); 8804 case OP_UNMAP: return de::MovePtr<Command>(new UnMap()); 8805 8806 case OP_MAP_FLUSH: return de::MovePtr<Command>(new Flush()); 8807 case OP_MAP_INVALIDATE: return de::MovePtr<Command>(new Invalidate()); 8808 8809 case OP_MAP_READ: return de::MovePtr<Command>(new HostMemoryAccess(true, false, rng.getUint32())); 8810 case OP_MAP_WRITE: return de::MovePtr<Command>(new HostMemoryAccess(false, true, rng.getUint32())); 8811 case OP_MAP_MODIFY: return de::MovePtr<Command>(new HostMemoryAccess(true, true, rng.getUint32())); 8812 8813 case OP_BUFFER_CREATE: return de::MovePtr<Command>(new CreateBuffer(usageToBufferUsageFlags(usage), sharing)); 8814 case OP_BUFFER_DESTROY: return de::MovePtr<Command>(new DestroyBuffer()); 8815 case OP_BUFFER_BINDMEMORY: return de::MovePtr<Command>(new BindBufferMemory()); 8816 8817 case OP_IMAGE_CREATE: return de::MovePtr<Command>(new CreateImage(usageToImageUsageFlags(usage), sharing)); 8818 case OP_IMAGE_DESTROY: return de::MovePtr<Command>(new DestroyImage()); 8819 case OP_IMAGE_BINDMEMORY: return de::MovePtr<Command>(new BindImageMemory()); 8820 8821 case OP_QUEUE_WAIT_FOR_IDLE: return de::MovePtr<Command>(new QueueWaitIdle()); 8822 case OP_DEVICE_WAIT_FOR_IDLE: return de::MovePtr<Command>(new DeviceWaitIdle()); 8823 8824 default: 8825 DE_FATAL("Unknown op"); 8826 return de::MovePtr<Command>(DE_NULL); 8827 } 8828 } 8829 8830 de::MovePtr<CmdCommand> createCmdCommand (de::Random& rng, 8831 const State& state, 8832 Op op, 8833 Usage usage) 8834 { 8835 switch (op) 8836 { 8837 case OP_BUFFER_FILL: return de::MovePtr<CmdCommand>(new FillBuffer(rng.getUint32())); 8838 case OP_BUFFER_UPDATE: return de::MovePtr<CmdCommand>(new UpdateBuffer(rng.getUint32())); 8839 case OP_BUFFER_COPY_TO_BUFFER: return de::MovePtr<CmdCommand>(new BufferCopyToBuffer()); 8840 case OP_BUFFER_COPY_FROM_BUFFER: return de::MovePtr<CmdCommand>(new BufferCopyFromBuffer(rng.getUint32())); 8841 8842 case OP_BUFFER_COPY_TO_IMAGE: return de::MovePtr<CmdCommand>(new BufferCopyToImage()); 8843 case OP_BUFFER_COPY_FROM_IMAGE: return de::MovePtr<CmdCommand>(new BufferCopyFromImage(rng.getUint32())); 8844 8845 case OP_IMAGE_TRANSITION_LAYOUT: 8846 { 8847 DE_ASSERT(state.stage == STAGE_COMMAND_BUFFER); 8848 DE_ASSERT(state.hasImage); 8849 DE_ASSERT(state.hasBoundImageMemory); 8850 8851 const vk::VkImageLayout srcLayout = rng.getFloat() < 0.9f ? state.imageLayout : vk::VK_IMAGE_LAYOUT_UNDEFINED; 8852 const vk::VkImageLayout dstLayout = getRandomNextLayout(rng, usage, srcLayout); 8853 8854 vk::VkPipelineStageFlags dirtySrcStages; 8855 vk::VkAccessFlags dirtySrcAccesses; 8856 vk::VkPipelineStageFlags dirtyDstStages; 8857 vk::VkAccessFlags dirtyDstAccesses; 8858 8859 vk::VkPipelineStageFlags srcStages; 8860 vk::VkAccessFlags srcAccesses; 8861 vk::VkPipelineStageFlags dstStages; 8862 vk::VkAccessFlags dstAccesses; 8863 8864 state.cache.getFullBarrier(dirtySrcStages, dirtySrcAccesses, dirtyDstStages, dirtyDstAccesses); 8865 8866 // Try masking some random bits 8867 srcStages = dirtySrcStages; 8868 srcAccesses = dirtySrcAccesses; 8869 8870 dstStages = state.cache.getAllowedStages() & rng.getUint32(); 8871 dstAccesses = state.cache.getAllowedAcceses() & rng.getUint32(); 8872 8873 // If there are no bits in dst stage mask use all stages 8874 dstStages = dstStages ? dstStages : state.cache.getAllowedStages(); 8875 8876 if (!srcStages) 8877 srcStages = dstStages; 8878 8879 removeIllegalAccessFlags(dstAccesses, dstStages); 8880 removeIllegalAccessFlags(srcAccesses, srcStages); 8881 8882 return de::MovePtr<CmdCommand>(new ImageTransition(srcStages, srcAccesses, dstStages, dstAccesses, srcLayout, dstLayout)); 8883 } 8884 8885 case OP_IMAGE_COPY_TO_BUFFER: return de::MovePtr<CmdCommand>(new ImageCopyToBuffer(state.imageLayout)); 8886 case OP_IMAGE_COPY_FROM_BUFFER: return de::MovePtr<CmdCommand>(new ImageCopyFromBuffer(rng.getUint32(), state.imageLayout)); 8887 case OP_IMAGE_COPY_TO_IMAGE: return de::MovePtr<CmdCommand>(new ImageCopyToImage(state.imageLayout)); 8888 case OP_IMAGE_COPY_FROM_IMAGE: return de::MovePtr<CmdCommand>(new ImageCopyFromImage(rng.getUint32(), state.imageLayout)); 8889 case OP_IMAGE_BLIT_TO_IMAGE: 8890 { 8891 const BlitScale scale = rng.getBool() ? BLIT_SCALE_20 : BLIT_SCALE_10; 8892 return de::MovePtr<CmdCommand>(new ImageBlitToImage(scale, state.imageLayout)); 8893 } 8894 8895 case OP_IMAGE_BLIT_FROM_IMAGE: 8896 { 8897 const BlitScale scale = rng.getBool() ? BLIT_SCALE_20 : BLIT_SCALE_10; 8898 return de::MovePtr<CmdCommand>(new ImageBlitFromImage(rng.getUint32(), scale, state.imageLayout)); 8899 } 8900 8901 case OP_PIPELINE_BARRIER_GLOBAL: 8902 case OP_PIPELINE_BARRIER_BUFFER: 8903 case OP_PIPELINE_BARRIER_IMAGE: 8904 { 8905 vk::VkPipelineStageFlags dirtySrcStages; 8906 vk::VkAccessFlags dirtySrcAccesses; 8907 vk::VkPipelineStageFlags dirtyDstStages; 8908 vk::VkAccessFlags dirtyDstAccesses; 8909 8910 vk::VkPipelineStageFlags srcStages; 8911 vk::VkAccessFlags srcAccesses; 8912 vk::VkPipelineStageFlags dstStages; 8913 vk::VkAccessFlags dstAccesses; 8914 8915 state.cache.getFullBarrier(dirtySrcStages, dirtySrcAccesses, dirtyDstStages, dirtyDstAccesses); 8916 8917 // Try masking some random bits 8918 srcStages = dirtySrcStages & rng.getUint32(); 8919 srcAccesses = dirtySrcAccesses & rng.getUint32(); 8920 8921 dstStages = dirtyDstStages & rng.getUint32(); 8922 dstAccesses = dirtyDstAccesses & rng.getUint32(); 8923 8924 // If there are no bits in stage mask use the original dirty stages 8925 srcStages = srcStages ? srcStages : dirtySrcStages; 8926 dstStages = dstStages ? dstStages : dirtyDstStages; 8927 8928 if (!srcStages) 8929 srcStages = dstStages; 8930 8931 removeIllegalAccessFlags(dstAccesses, dstStages); 8932 removeIllegalAccessFlags(srcAccesses, srcStages); 8933 8934 PipelineBarrier::Type type; 8935 8936 if (op == OP_PIPELINE_BARRIER_IMAGE) 8937 type = PipelineBarrier::TYPE_IMAGE; 8938 else if (op == OP_PIPELINE_BARRIER_BUFFER) 8939 type = PipelineBarrier::TYPE_BUFFER; 8940 else if (op == OP_PIPELINE_BARRIER_GLOBAL) 8941 type = PipelineBarrier::TYPE_GLOBAL; 8942 else 8943 { 8944 type = PipelineBarrier::TYPE_LAST; 8945 DE_FATAL("Unknown op"); 8946 } 8947 8948 if (type == PipelineBarrier::TYPE_IMAGE) 8949 return de::MovePtr<CmdCommand>(new PipelineBarrier(srcStages, srcAccesses, dstStages, dstAccesses, type, tcu::just(state.imageLayout))); 8950 else 8951 return de::MovePtr<CmdCommand>(new PipelineBarrier(srcStages, srcAccesses, dstStages, dstAccesses, type, tcu::nothing<vk::VkImageLayout>())); 8952 } 8953 8954 default: 8955 DE_FATAL("Unknown op"); 8956 return de::MovePtr<CmdCommand>(DE_NULL); 8957 } 8958 } 8959 8960 de::MovePtr<RenderPassCommand> createRenderPassCommand (de::Random&, 8961 const State&, 8962 Op op) 8963 { 8964 switch (op) 8965 { 8966 case OP_RENDER_VERTEX_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderVertexBuffer()); 8967 case OP_RENDER_INDEX_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderIndexBuffer()); 8968 8969 case OP_RENDER_VERTEX_UNIFORM_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderVertexUniformBuffer()); 8970 case OP_RENDER_FRAGMENT_UNIFORM_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderFragmentUniformBuffer()); 8971 8972 case OP_RENDER_VERTEX_UNIFORM_TEXEL_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderVertexUniformTexelBuffer()); 8973 case OP_RENDER_FRAGMENT_UNIFORM_TEXEL_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderFragmentUniformTexelBuffer()); 8974 8975 case OP_RENDER_VERTEX_STORAGE_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderVertexStorageBuffer()); 8976 case OP_RENDER_FRAGMENT_STORAGE_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderFragmentStorageBuffer()); 8977 8978 case OP_RENDER_VERTEX_STORAGE_TEXEL_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderVertexStorageTexelBuffer()); 8979 case OP_RENDER_FRAGMENT_STORAGE_TEXEL_BUFFER: return de::MovePtr<RenderPassCommand>(new RenderFragmentStorageTexelBuffer()); 8980 8981 case OP_RENDER_VERTEX_STORAGE_IMAGE: return de::MovePtr<RenderPassCommand>(new RenderVertexStorageImage()); 8982 case OP_RENDER_FRAGMENT_STORAGE_IMAGE: return de::MovePtr<RenderPassCommand>(new RenderFragmentStorageImage()); 8983 8984 case OP_RENDER_VERTEX_SAMPLED_IMAGE: return de::MovePtr<RenderPassCommand>(new RenderVertexSampledImage()); 8985 case OP_RENDER_FRAGMENT_SAMPLED_IMAGE: return de::MovePtr<RenderPassCommand>(new RenderFragmentSampledImage()); 8986 8987 default: 8988 DE_FATAL("Unknown op"); 8989 return de::MovePtr<RenderPassCommand>(DE_NULL); 8990 } 8991 } 8992 8993 de::MovePtr<CmdCommand> createRenderPassCommands (const Memory& memory, 8994 de::Random& nextOpRng, 8995 State& state, 8996 Usage usage, 8997 size_t& opNdx, 8998 size_t opCount) 8999 { 9000 vector<RenderPassCommand*> commands; 9001 9002 try 9003 { 9004 for (; opNdx < opCount; opNdx++) 9005 { 9006 vector<Op> ops; 9007 9008 getAvailableOps(state, memory.getSupportBuffers(), memory.getSupportImages(), usage, ops); 9009 9010 DE_ASSERT(!ops.empty()); 9011 9012 { 9013 const Op op = nextOpRng.choose<Op>(ops.begin(), ops.end()); 9014 9015 if (op == OP_RENDERPASS_END) 9016 { 9017 break; 9018 } 9019 else 9020 { 9021 de::Random rng (state.rng); 9022 9023 commands.push_back(createRenderPassCommand(rng, state, op).release()); 9024 applyOp(state, memory, op, usage); 9025 9026 DE_ASSERT(state.rng == rng); 9027 } 9028 } 9029 } 9030 9031 applyOp(state, memory, OP_RENDERPASS_END, usage); 9032 return de::MovePtr<CmdCommand>(new SubmitRenderPass(commands)); 9033 } 9034 catch (...) 9035 { 9036 for (size_t commandNdx = 0; commandNdx < commands.size(); commandNdx++) 9037 delete commands[commandNdx]; 9038 9039 throw; 9040 } 9041 } 9042 9043 de::MovePtr<Command> createCmdCommands (const Memory& memory, 9044 de::Random& nextOpRng, 9045 State& state, 9046 Usage usage, 9047 size_t& opNdx, 9048 size_t opCount) 9049 { 9050 vector<CmdCommand*> commands; 9051 9052 try 9053 { 9054 for (; opNdx < opCount; opNdx++) 9055 { 9056 vector<Op> ops; 9057 9058 getAvailableOps(state, memory.getSupportBuffers(), memory.getSupportImages(), usage, ops); 9059 9060 DE_ASSERT(!ops.empty()); 9061 9062 { 9063 const Op op = nextOpRng.choose<Op>(ops.begin(), ops.end()); 9064 9065 if (op == OP_COMMAND_BUFFER_END) 9066 { 9067 break; 9068 } 9069 else 9070 { 9071 // \note Command needs to known the state before the operation 9072 if (op == OP_RENDERPASS_BEGIN) 9073 { 9074 applyOp(state, memory, op, usage); 9075 commands.push_back(createRenderPassCommands(memory, nextOpRng, state, usage, opNdx, opCount).release()); 9076 } 9077 else 9078 { 9079 de::Random rng (state.rng); 9080 9081 commands.push_back(createCmdCommand(rng, state, op, usage).release()); 9082 applyOp(state, memory, op, usage); 9083 9084 DE_ASSERT(state.rng == rng); 9085 } 9086 9087 } 9088 } 9089 } 9090 9091 applyOp(state, memory, OP_COMMAND_BUFFER_END, usage); 9092 return de::MovePtr<Command>(new SubmitCommandBuffer(commands)); 9093 } 9094 catch (...) 9095 { 9096 for (size_t commandNdx = 0; commandNdx < commands.size(); commandNdx++) 9097 delete commands[commandNdx]; 9098 9099 throw; 9100 } 9101 } 9102 9103 void createCommands (vector<Command*>& commands, 9104 deUint32 seed, 9105 const Memory& memory, 9106 Usage usage, 9107 vk::VkSharingMode sharingMode, 9108 size_t opCount) 9109 { 9110 State state (usage, seed); 9111 // Used to select next operation only 9112 de::Random nextOpRng (seed ^ 12930809); 9113 9114 commands.reserve(opCount); 9115 9116 for (size_t opNdx = 0; opNdx < opCount; opNdx++) 9117 { 9118 vector<Op> ops; 9119 9120 getAvailableOps(state, memory.getSupportBuffers(), memory.getSupportImages(), usage, ops); 9121 9122 DE_ASSERT(!ops.empty()); 9123 9124 { 9125 const Op op = nextOpRng.choose<Op>(ops.begin(), ops.end()); 9126 9127 if (op == OP_COMMAND_BUFFER_BEGIN) 9128 { 9129 applyOp(state, memory, op, usage); 9130 commands.push_back(createCmdCommands(memory, nextOpRng, state, usage, opNdx, opCount).release()); 9131 } 9132 else 9133 { 9134 de::Random rng (state.rng); 9135 9136 commands.push_back(createHostCommand(op, rng, usage, sharingMode).release()); 9137 applyOp(state, memory, op, usage); 9138 9139 // Make sure that random generator is in sync 9140 DE_ASSERT(state.rng == rng); 9141 } 9142 } 9143 } 9144 9145 // Clean up resources 9146 if (state.hasBuffer && state.hasImage) 9147 { 9148 if (!state.queueIdle) 9149 commands.push_back(new QueueWaitIdle()); 9150 9151 if (state.hasBuffer) 9152 commands.push_back(new DestroyBuffer()); 9153 9154 if (state.hasImage) 9155 commands.push_back(new DestroyImage()); 9156 } 9157 } 9158 9159 class MemoryTestInstance : public TestInstance 9160 { 9161 public: 9162 9163 typedef bool(MemoryTestInstance::*StageFunc)(void); 9164 9165 MemoryTestInstance (::vkt::Context& context, const TestConfig& config); 9166 ~MemoryTestInstance (void); 9167 9168 tcu::TestStatus iterate (void); 9169 9170 private: 9171 const TestConfig m_config; 9172 const size_t m_iterationCount; 9173 const size_t m_opCount; 9174 const vk::VkPhysicalDeviceMemoryProperties m_memoryProperties; 9175 deUint32 m_memoryTypeNdx; 9176 size_t m_iteration; 9177 StageFunc m_stage; 9178 tcu::ResultCollector m_resultCollector; 9179 9180 vector<Command*> m_commands; 9181 MovePtr<Memory> m_memory; 9182 MovePtr<Context> m_renderContext; 9183 MovePtr<PrepareContext> m_prepareContext; 9184 9185 bool nextIteration (void); 9186 bool nextMemoryType (void); 9187 9188 bool createCommandsAndAllocateMemory (void); 9189 bool prepare (void); 9190 bool execute (void); 9191 bool verify (void); 9192 void resetResources (void); 9193 }; 9194 9195 void MemoryTestInstance::resetResources (void) 9196 { 9197 const vk::DeviceInterface& vkd = m_context.getDeviceInterface(); 9198 const vk::VkDevice device = m_context.getDevice(); 9199 9200 VK_CHECK(vkd.deviceWaitIdle(device)); 9201 9202 for (size_t commandNdx = 0; commandNdx < m_commands.size(); commandNdx++) 9203 { 9204 delete m_commands[commandNdx]; 9205 m_commands[commandNdx] = DE_NULL; 9206 } 9207 9208 m_commands.clear(); 9209 m_prepareContext.clear(); 9210 m_memory.clear(); 9211 } 9212 9213 bool MemoryTestInstance::nextIteration (void) 9214 { 9215 m_iteration++; 9216 9217 if (m_iteration < m_iterationCount) 9218 { 9219 resetResources(); 9220 m_stage = &MemoryTestInstance::createCommandsAndAllocateMemory; 9221 return true; 9222 } 9223 else 9224 return nextMemoryType(); 9225 } 9226 9227 bool MemoryTestInstance::nextMemoryType (void) 9228 { 9229 resetResources(); 9230 9231 DE_ASSERT(m_commands.empty()); 9232 9233 m_memoryTypeNdx++; 9234 9235 if (m_memoryTypeNdx < m_memoryProperties.memoryTypeCount) 9236 { 9237 m_iteration = 0; 9238 m_stage = &MemoryTestInstance::createCommandsAndAllocateMemory; 9239 9240 return true; 9241 } 9242 else 9243 { 9244 m_stage = DE_NULL; 9245 return false; 9246 } 9247 } 9248 9249 MemoryTestInstance::MemoryTestInstance (::vkt::Context& context, const TestConfig& config) 9250 : TestInstance (context) 9251 , m_config (config) 9252 , m_iterationCount (5) 9253 , m_opCount (50) 9254 , m_memoryProperties (vk::getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice())) 9255 , m_memoryTypeNdx (0) 9256 , m_iteration (0) 9257 , m_stage (&MemoryTestInstance::createCommandsAndAllocateMemory) 9258 , m_resultCollector (context.getTestContext().getLog()) 9259 9260 , m_memory (DE_NULL) 9261 { 9262 TestLog& log = context.getTestContext().getLog(); 9263 { 9264 const tcu::ScopedLogSection section (log, "TestCaseInfo", "Test Case Info"); 9265 9266 log << TestLog::Message << "Buffer size: " << config.size << TestLog::EndMessage; 9267 log << TestLog::Message << "Sharing: " << config.sharing << TestLog::EndMessage; 9268 log << TestLog::Message << "Access: " << config.usage << TestLog::EndMessage; 9269 } 9270 9271 { 9272 const tcu::ScopedLogSection section (log, "MemoryProperties", "Memory Properties"); 9273 9274 for (deUint32 heapNdx = 0; heapNdx < m_memoryProperties.memoryHeapCount; heapNdx++) 9275 { 9276 const tcu::ScopedLogSection heapSection (log, "Heap" + de::toString(heapNdx), "Heap " + de::toString(heapNdx)); 9277 9278 log << TestLog::Message << "Size: " << m_memoryProperties.memoryHeaps[heapNdx].size << TestLog::EndMessage; 9279 log << TestLog::Message << "Flags: " << m_memoryProperties.memoryHeaps[heapNdx].flags << TestLog::EndMessage; 9280 } 9281 9282 for (deUint32 memoryTypeNdx = 0; memoryTypeNdx < m_memoryProperties.memoryTypeCount; memoryTypeNdx++) 9283 { 9284 const tcu::ScopedLogSection memoryTypeSection (log, "MemoryType" + de::toString(memoryTypeNdx), "Memory type " + de::toString(memoryTypeNdx)); 9285 9286 log << TestLog::Message << "Properties: " << m_memoryProperties.memoryTypes[memoryTypeNdx].propertyFlags << TestLog::EndMessage; 9287 log << TestLog::Message << "Heap: " << m_memoryProperties.memoryTypes[memoryTypeNdx].heapIndex << TestLog::EndMessage; 9288 } 9289 } 9290 9291 { 9292 const vk::InstanceInterface& vki = context.getInstanceInterface(); 9293 const vk::VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 9294 const vk::DeviceInterface& vkd = context.getDeviceInterface(); 9295 const vk::VkDevice device = context.getDevice(); 9296 const vk::VkQueue queue = context.getUniversalQueue(); 9297 const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex(); 9298 vector<pair<deUint32, vk::VkQueue> > queues; 9299 9300 queues.push_back(std::make_pair(queueFamilyIndex, queue)); 9301 9302 m_renderContext = MovePtr<Context>(new Context(vki, vkd, physicalDevice, device, queue, queueFamilyIndex, queues, context.getBinaryCollection())); 9303 } 9304 } 9305 9306 MemoryTestInstance::~MemoryTestInstance (void) 9307 { 9308 resetResources(); 9309 } 9310 9311 bool MemoryTestInstance::createCommandsAndAllocateMemory (void) 9312 { 9313 const vk::VkDevice device = m_context.getDevice(); 9314 TestLog& log = m_context.getTestContext().getLog(); 9315 const vk::InstanceInterface& vki = m_context.getInstanceInterface(); 9316 const vk::VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice(); 9317 const vk::DeviceInterface& vkd = m_context.getDeviceInterface(); 9318 const vk::VkPhysicalDeviceMemoryProperties memoryProperties = vk::getPhysicalDeviceMemoryProperties(vki, physicalDevice); 9319 const tcu::ScopedLogSection section (log, "MemoryType" + de::toString(m_memoryTypeNdx) + "CreateCommands" + de::toString(m_iteration), 9320 "Memory type " + de::toString(m_memoryTypeNdx) + " create commands iteration " + de::toString(m_iteration)); 9321 const vector<deUint32>& queues = m_renderContext->getQueueFamilies(); 9322 9323 DE_ASSERT(m_commands.empty()); 9324 9325 if (m_config.usage & (USAGE_HOST_READ | USAGE_HOST_WRITE) 9326 && !(memoryProperties.memoryTypes[m_memoryTypeNdx].propertyFlags & vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) 9327 { 9328 log << TestLog::Message << "Memory type not supported" << TestLog::EndMessage; 9329 9330 return nextMemoryType(); 9331 } 9332 else 9333 { 9334 try 9335 { 9336 const vk::VkBufferUsageFlags bufferUsage = usageToBufferUsageFlags(m_config.usage); 9337 const vk::VkImageUsageFlags imageUsage = usageToImageUsageFlags(m_config.usage); 9338 const vk::VkDeviceSize maxBufferSize = bufferUsage != 0 9339 ? roundBufferSizeToWxHx4(findMaxBufferSize(vkd, device, bufferUsage, m_config.sharing, queues, m_config.size, m_memoryTypeNdx)) 9340 : 0; 9341 const IVec2 maxImageSize = imageUsage != 0 9342 ? findMaxRGBA8ImageSize(vkd, device, imageUsage, m_config.sharing, queues, m_config.size, m_memoryTypeNdx) 9343 : IVec2(0, 0); 9344 9345 log << TestLog::Message << "Max buffer size: " << maxBufferSize << TestLog::EndMessage; 9346 log << TestLog::Message << "Max RGBA8 image size: " << maxImageSize << TestLog::EndMessage; 9347 9348 // Skip tests if there are no supported operations 9349 if (maxBufferSize == 0 9350 && maxImageSize[0] == 0 9351 && (m_config.usage & (USAGE_HOST_READ|USAGE_HOST_WRITE)) == 0) 9352 { 9353 log << TestLog::Message << "Skipping memory type. None of the usages are supported." << TestLog::EndMessage; 9354 9355 return nextMemoryType(); 9356 } 9357 else 9358 { 9359 const deUint32 seed = 2830980989u ^ deUint32Hash((deUint32)(m_iteration) * m_memoryProperties.memoryTypeCount + m_memoryTypeNdx); 9360 9361 m_memory = MovePtr<Memory>(new Memory(vki, vkd, physicalDevice, device, m_config.size, m_memoryTypeNdx, maxBufferSize, maxImageSize[0], maxImageSize[1])); 9362 9363 log << TestLog::Message << "Create commands" << TestLog::EndMessage; 9364 createCommands(m_commands, seed, *m_memory, m_config.usage, m_config.sharing, m_opCount); 9365 9366 m_stage = &MemoryTestInstance::prepare; 9367 return true; 9368 } 9369 } 9370 catch (const tcu::TestError& e) 9371 { 9372 m_resultCollector.fail("Failed, got exception: " + string(e.getMessage())); 9373 return nextMemoryType(); 9374 } 9375 } 9376 } 9377 9378 bool MemoryTestInstance::prepare (void) 9379 { 9380 TestLog& log = m_context.getTestContext().getLog(); 9381 const tcu::ScopedLogSection section (log, "MemoryType" + de::toString(m_memoryTypeNdx) + "Prepare" + de::toString(m_iteration), 9382 "Memory type " + de::toString(m_memoryTypeNdx) + " prepare iteration" + de::toString(m_iteration)); 9383 9384 m_prepareContext = MovePtr<PrepareContext>(new PrepareContext(*m_renderContext, *m_memory)); 9385 9386 DE_ASSERT(!m_commands.empty()); 9387 9388 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 9389 { 9390 Command& command = *m_commands[cmdNdx]; 9391 9392 try 9393 { 9394 command.prepare(*m_prepareContext); 9395 } 9396 catch (const tcu::TestError& e) 9397 { 9398 m_resultCollector.fail(de::toString(cmdNdx) + ":" + command.getName() + " failed to prepare, got exception: " + string(e.getMessage())); 9399 return nextMemoryType(); 9400 } 9401 } 9402 9403 m_stage = &MemoryTestInstance::execute; 9404 return true; 9405 } 9406 9407 bool MemoryTestInstance::execute (void) 9408 { 9409 TestLog& log = m_context.getTestContext().getLog(); 9410 const tcu::ScopedLogSection section (log, "MemoryType" + de::toString(m_memoryTypeNdx) + "Execute" + de::toString(m_iteration), 9411 "Memory type " + de::toString(m_memoryTypeNdx) + " execute iteration " + de::toString(m_iteration)); 9412 ExecuteContext executeContext (*m_renderContext); 9413 const vk::VkDevice device = m_context.getDevice(); 9414 const vk::DeviceInterface& vkd = m_context.getDeviceInterface(); 9415 9416 DE_ASSERT(!m_commands.empty()); 9417 9418 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 9419 { 9420 Command& command = *m_commands[cmdNdx]; 9421 9422 try 9423 { 9424 command.execute(executeContext); 9425 } 9426 catch (const tcu::TestError& e) 9427 { 9428 m_resultCollector.fail(de::toString(cmdNdx) + ":" + command.getName() + " failed to execute, got exception: " + string(e.getMessage())); 9429 return nextIteration(); 9430 } 9431 } 9432 9433 VK_CHECK(vkd.deviceWaitIdle(device)); 9434 9435 m_stage = &MemoryTestInstance::verify; 9436 return true; 9437 } 9438 9439 bool MemoryTestInstance::verify (void) 9440 { 9441 DE_ASSERT(!m_commands.empty()); 9442 9443 TestLog& log = m_context.getTestContext().getLog(); 9444 const tcu::ScopedLogSection section (log, "MemoryType" + de::toString(m_memoryTypeNdx) + "Verify" + de::toString(m_iteration), 9445 "Memory type " + de::toString(m_memoryTypeNdx) + " verify iteration " + de::toString(m_iteration)); 9446 VerifyContext verifyContext (log, m_resultCollector, *m_renderContext, m_config.size); 9447 9448 log << TestLog::Message << "Begin verify" << TestLog::EndMessage; 9449 9450 for (size_t cmdNdx = 0; cmdNdx < m_commands.size(); cmdNdx++) 9451 { 9452 Command& command = *m_commands[cmdNdx]; 9453 9454 try 9455 { 9456 command.verify(verifyContext, cmdNdx); 9457 } 9458 catch (const tcu::TestError& e) 9459 { 9460 m_resultCollector.fail(de::toString(cmdNdx) + ":" + command.getName() + " failed to verify, got exception: " + string(e.getMessage())); 9461 return nextIteration(); 9462 } 9463 } 9464 9465 return nextIteration(); 9466 } 9467 9468 tcu::TestStatus MemoryTestInstance::iterate (void) 9469 { 9470 if ((this->*m_stage)()) 9471 return tcu::TestStatus::incomplete(); 9472 else 9473 return tcu::TestStatus(m_resultCollector.getResult(), m_resultCollector.getMessage()); 9474 } 9475 9476 struct AddPrograms 9477 { 9478 void init (vk::SourceCollections& sources, TestConfig config) const 9479 { 9480 // Vertex buffer rendering 9481 if (config.usage & USAGE_VERTEX_BUFFER) 9482 { 9483 const char* const vertexShader = 9484 "#version 310 es\n" 9485 "layout(location = 0) in highp vec2 a_position;\n" 9486 "void main (void) {\n" 9487 "\tgl_PointSize = 1.0;\n" 9488 "\tgl_Position = vec4(1.998 * a_position - vec2(0.999), 0.0, 1.0);\n" 9489 "}\n"; 9490 9491 sources.glslSources.add("vertex-buffer.vert") 9492 << glu::VertexSource(vertexShader); 9493 } 9494 9495 // Index buffer rendering 9496 if (config.usage & USAGE_INDEX_BUFFER) 9497 { 9498 const char* const vertexShader = 9499 "#version 310 es\n" 9500 "precision highp float;\n" 9501 "void main (void) {\n" 9502 "\tgl_PointSize = 1.0;\n" 9503 "\thighp vec2 pos = vec2(gl_VertexIndex % 256, gl_VertexIndex / 256) / vec2(255.0);\n" 9504 "\tgl_Position = vec4(1.998 * pos - vec2(0.999), 0.0, 1.0);\n" 9505 "}\n"; 9506 9507 sources.glslSources.add("index-buffer.vert") 9508 << glu::VertexSource(vertexShader); 9509 } 9510 9511 if (config.usage & USAGE_UNIFORM_BUFFER) 9512 { 9513 { 9514 std::ostringstream vertexShader; 9515 9516 vertexShader << 9517 "#version 310 es\n" 9518 "precision highp float;\n" 9519 "layout(set=0, binding=0) uniform Block\n" 9520 "{\n" 9521 "\thighp uvec4 values[" << de::toString<size_t>(MAX_UNIFORM_BUFFER_SIZE / (sizeof(deUint32) * 4)) << "];\n" 9522 "} block;\n" 9523 "void main (void) {\n" 9524 "\tgl_PointSize = 1.0;\n" 9525 "\thighp uvec4 vecVal = block.values[gl_VertexIndex / 8];\n" 9526 "\thighp uint val;\n" 9527 "\tif (((gl_VertexIndex / 2) % 4 == 0))\n" 9528 "\t\tval = vecVal.x;\n" 9529 "\telse if (((gl_VertexIndex / 2) % 4 == 1))\n" 9530 "\t\tval = vecVal.y;\n" 9531 "\telse if (((gl_VertexIndex / 2) % 4 == 2))\n" 9532 "\t\tval = vecVal.z;\n" 9533 "\telse if (((gl_VertexIndex / 2) % 4 == 3))\n" 9534 "\t\tval = vecVal.w;\n" 9535 "\tif ((gl_VertexIndex % 2) == 0)\n" 9536 "\t\tval = val & 0xFFFFu;\n" 9537 "\telse\n" 9538 "\t\tval = val >> 16u;\n" 9539 "\thighp vec2 pos = vec2(val & 0xFFu, val >> 8u) / vec2(255.0);\n" 9540 "\tgl_Position = vec4(1.998 * pos - vec2(0.999), 0.0, 1.0);\n" 9541 "}\n"; 9542 9543 sources.glslSources.add("uniform-buffer.vert") 9544 << glu::VertexSource(vertexShader.str()); 9545 } 9546 9547 { 9548 const size_t arraySize = MAX_UNIFORM_BUFFER_SIZE / (sizeof(deUint32) * 4); 9549 const size_t arrayIntSize = arraySize * 4; 9550 std::ostringstream fragmentShader; 9551 9552 fragmentShader << 9553 "#version 310 es\n" 9554 "precision highp float;\n" 9555 "precision highp int;\n" 9556 "layout(location = 0) out highp vec4 o_color;\n" 9557 "layout(set=0, binding=0) uniform Block\n" 9558 "{\n" 9559 "\thighp uvec4 values[" << arraySize << "];\n" 9560 "} block;\n" 9561 "layout(push_constant) uniform PushC\n" 9562 "{\n" 9563 "\tuint callId;\n" 9564 "\tuint valuesPerPixel;\n" 9565 "} pushC;\n" 9566 "void main (void) {\n" 9567 "\thighp uint id = pushC.callId * (" << arrayIntSize << "u / pushC.valuesPerPixel) + uint(gl_FragCoord.y) * 256u + uint(gl_FragCoord.x);\n" 9568 "\tif (uint(gl_FragCoord.y) * 256u + uint(gl_FragCoord.x) < pushC.callId * (" << arrayIntSize << "u / pushC.valuesPerPixel))\n" 9569 "\t\tdiscard;\n" 9570 "\thighp uint value = id;\n" 9571 "\tfor (uint i = 0u; i < pushC.valuesPerPixel; i++)\n" 9572 "\t{\n" 9573 "\t\thighp uvec4 vecVal = block.values[(value / 4u) % " << arraySize << "u];\n" 9574 "\t\tif ((value % 4u) == 0u)\n" 9575 "\t\t\tvalue = vecVal.x;\n" 9576 "\t\telse if ((value % 4u) == 1u)\n" 9577 "\t\t\tvalue = vecVal.y;\n" 9578 "\t\telse if ((value % 4u) == 2u)\n" 9579 "\t\t\tvalue = vecVal.z;\n" 9580 "\t\telse if ((value % 4u) == 3u)\n" 9581 "\t\t\tvalue = vecVal.w;\n" 9582 "\t}\n" 9583 "\tuvec4 valueOut = uvec4(value & 0xFFu, (value >> 8u) & 0xFFu, (value >> 16u) & 0xFFu, (value >> 24u) & 0xFFu);\n" 9584 "\to_color = vec4(valueOut) / vec4(255.0);\n" 9585 "}\n"; 9586 9587 sources.glslSources.add("uniform-buffer.frag") 9588 << glu::FragmentSource(fragmentShader.str()); 9589 } 9590 } 9591 9592 if (config.usage & USAGE_STORAGE_BUFFER) 9593 { 9594 { 9595 // Vertex storage buffer rendering 9596 const char* const vertexShader = 9597 "#version 310 es\n" 9598 "precision highp float;\n" 9599 "layout(set=0, binding=0) buffer Block\n" 9600 "{\n" 9601 "\thighp uvec4 values[];\n" 9602 "} block;\n" 9603 "void main (void) {\n" 9604 "\tgl_PointSize = 1.0;\n" 9605 "\thighp uvec4 vecVal = block.values[gl_VertexIndex / 8];\n" 9606 "\thighp uint val;\n" 9607 "\tif (((gl_VertexIndex / 2) % 4 == 0))\n" 9608 "\t\tval = vecVal.x;\n" 9609 "\telse if (((gl_VertexIndex / 2) % 4 == 1))\n" 9610 "\t\tval = vecVal.y;\n" 9611 "\telse if (((gl_VertexIndex / 2) % 4 == 2))\n" 9612 "\t\tval = vecVal.z;\n" 9613 "\telse if (((gl_VertexIndex / 2) % 4 == 3))\n" 9614 "\t\tval = vecVal.w;\n" 9615 "\tif ((gl_VertexIndex % 2) == 0)\n" 9616 "\t\tval = val & 0xFFFFu;\n" 9617 "\telse\n" 9618 "\t\tval = val >> 16u;\n" 9619 "\thighp vec2 pos = vec2(val & 0xFFu, val >> 8u) / vec2(255.0);\n" 9620 "\tgl_Position = vec4(1.998 * pos - vec2(0.999), 0.0, 1.0);\n" 9621 "}\n"; 9622 9623 sources.glslSources.add("storage-buffer.vert") 9624 << glu::VertexSource(vertexShader); 9625 } 9626 9627 { 9628 std::ostringstream fragmentShader; 9629 9630 fragmentShader << 9631 "#version 310 es\n" 9632 "precision highp float;\n" 9633 "precision highp int;\n" 9634 "layout(location = 0) out highp vec4 o_color;\n" 9635 "layout(set=0, binding=0) buffer Block\n" 9636 "{\n" 9637 "\thighp uvec4 values[];\n" 9638 "} block;\n" 9639 "layout(push_constant) uniform PushC\n" 9640 "{\n" 9641 "\tuint valuesPerPixel;\n" 9642 "\tuint bufferSize;\n" 9643 "} pushC;\n" 9644 "void main (void) {\n" 9645 "\thighp uint arrayIntSize = pushC.bufferSize / 4u;\n" 9646 "\thighp uint id = uint(gl_FragCoord.y) * 256u + uint(gl_FragCoord.x);\n" 9647 "\thighp uint value = id;\n" 9648 "\tfor (uint i = 0u; i < pushC.valuesPerPixel; i++)\n" 9649 "\t{\n" 9650 "\t\thighp uvec4 vecVal = block.values[(value / 4u) % (arrayIntSize / 4u)];\n" 9651 "\t\tif ((value % 4u) == 0u)\n" 9652 "\t\t\tvalue = vecVal.x;\n" 9653 "\t\telse if ((value % 4u) == 1u)\n" 9654 "\t\t\tvalue = vecVal.y;\n" 9655 "\t\telse if ((value % 4u) == 2u)\n" 9656 "\t\t\tvalue = vecVal.z;\n" 9657 "\t\telse if ((value % 4u) == 3u)\n" 9658 "\t\t\tvalue = vecVal.w;\n" 9659 "\t}\n" 9660 "\tuvec4 valueOut = uvec4(value & 0xFFu, (value >> 8u) & 0xFFu, (value >> 16u) & 0xFFu, (value >> 24u) & 0xFFu);\n" 9661 "\to_color = vec4(valueOut) / vec4(255.0);\n" 9662 "}\n"; 9663 9664 sources.glslSources.add("storage-buffer.frag") 9665 << glu::FragmentSource(fragmentShader.str()); 9666 } 9667 } 9668 9669 if (config.usage & USAGE_UNIFORM_TEXEL_BUFFER) 9670 { 9671 { 9672 // Vertex uniform texel buffer rendering 9673 const char* const vertexShader = 9674 "#version 310 es\n" 9675 "#extension GL_EXT_texture_buffer : require\n" 9676 "precision highp float;\n" 9677 "layout(set=0, binding=0) uniform highp usamplerBuffer u_sampler;\n" 9678 "void main (void) {\n" 9679 "\tgl_PointSize = 1.0;\n" 9680 "\thighp uint val = texelFetch(u_sampler, gl_VertexIndex).x;\n" 9681 "\thighp vec2 pos = vec2(val & 0xFFu, val >> 8u) / vec2(255.0);\n" 9682 "\tgl_Position = vec4(1.998 * pos - vec2(0.999), 0.0, 1.0);\n" 9683 "}\n"; 9684 9685 sources.glslSources.add("uniform-texel-buffer.vert") 9686 << glu::VertexSource(vertexShader); 9687 } 9688 9689 { 9690 // Fragment uniform texel buffer rendering 9691 const char* const fragmentShader = 9692 "#version 310 es\n" 9693 "#extension GL_EXT_texture_buffer : require\n" 9694 "precision highp float;\n" 9695 "precision highp int;\n" 9696 "layout(set=0, binding=0) uniform highp usamplerBuffer u_sampler;\n" 9697 "layout(location = 0) out highp vec4 o_color;\n" 9698 "layout(push_constant) uniform PushC\n" 9699 "{\n" 9700 "\tuint callId;\n" 9701 "\tuint valuesPerPixel;\n" 9702 "\tuint maxTexelCount;\n" 9703 "} pushC;\n" 9704 "void main (void) {\n" 9705 "\thighp uint id = uint(gl_FragCoord.y) * 256u + uint(gl_FragCoord.x);\n" 9706 "\thighp uint value = id;\n" 9707 "\tif (uint(gl_FragCoord.y) * 256u + uint(gl_FragCoord.x) < pushC.callId * (pushC.maxTexelCount / pushC.valuesPerPixel))\n" 9708 "\t\tdiscard;\n" 9709 "\tfor (uint i = 0u; i < pushC.valuesPerPixel; i++)\n" 9710 "\t{\n" 9711 "\t\tvalue = texelFetch(u_sampler, int(value % uint(textureSize(u_sampler)))).x;\n" 9712 "\t}\n" 9713 "\tuvec4 valueOut = uvec4(value & 0xFFu, (value >> 8u) & 0xFFu, (value >> 16u) & 0xFFu, (value >> 24u) & 0xFFu);\n" 9714 "\to_color = vec4(valueOut) / vec4(255.0);\n" 9715 "}\n"; 9716 9717 sources.glslSources.add("uniform-texel-buffer.frag") 9718 << glu::FragmentSource(fragmentShader); 9719 } 9720 } 9721 9722 if (config.usage & USAGE_STORAGE_TEXEL_BUFFER) 9723 { 9724 { 9725 // Vertex storage texel buffer rendering 9726 const char* const vertexShader = 9727 "#version 450\n" 9728 "#extension GL_EXT_texture_buffer : require\n" 9729 "precision highp float;\n" 9730 "layout(set=0, binding=0, r32ui) uniform readonly highp uimageBuffer u_sampler;\n" 9731 "out gl_PerVertex {\n" 9732 "\tvec4 gl_Position;\n" 9733 "\tfloat gl_PointSize;\n" 9734 "};\n" 9735 "void main (void) {\n" 9736 "\tgl_PointSize = 1.0;\n" 9737 "\thighp uint val = imageLoad(u_sampler, gl_VertexIndex / 2).x;\n" 9738 "\tif (gl_VertexIndex % 2 == 0)\n" 9739 "\t\tval = val & 0xFFFFu;\n" 9740 "\telse\n" 9741 "\t\tval = val >> 16;\n" 9742 "\thighp vec2 pos = vec2(val & 0xFFu, val >> 8u) / vec2(255.0);\n" 9743 "\tgl_Position = vec4(1.998 * pos - vec2(0.999), 0.0, 1.0);\n" 9744 "}\n"; 9745 9746 sources.glslSources.add("storage-texel-buffer.vert") 9747 << glu::VertexSource(vertexShader); 9748 } 9749 { 9750 // Fragment storage texel buffer rendering 9751 const char* const fragmentShader = 9752 "#version 310 es\n" 9753 "#extension GL_EXT_texture_buffer : require\n" 9754 "precision highp float;\n" 9755 "precision highp int;\n" 9756 "layout(set=0, binding=0, r32ui) uniform readonly highp uimageBuffer u_sampler;\n" 9757 "layout(location = 0) out highp vec4 o_color;\n" 9758 "layout(push_constant) uniform PushC\n" 9759 "{\n" 9760 "\tuint callId;\n" 9761 "\tuint valuesPerPixel;\n" 9762 "\tuint maxTexelCount;\n" 9763 "\tuint width;\n" 9764 "} pushC;\n" 9765 "void main (void) {\n" 9766 "\thighp uint id = uint(gl_FragCoord.y) * 256u + uint(gl_FragCoord.x);\n" 9767 "\thighp uint value = id;\n" 9768 "\tif (uint(gl_FragCoord.y) * 256u + uint(gl_FragCoord.x) < pushC.callId * (pushC.maxTexelCount / pushC.valuesPerPixel))\n" 9769 "\t\tdiscard;\n" 9770 "\tfor (uint i = 0u; i < pushC.valuesPerPixel; i++)\n" 9771 "\t{\n" 9772 "\t\tvalue = imageLoad(u_sampler, int(value % pushC.width)).x;\n" 9773 "\t}\n" 9774 "\tuvec4 valueOut = uvec4(value & 0xFFu, (value >> 8u) & 0xFFu, (value >> 16u) & 0xFFu, (value >> 24u) & 0xFFu);\n" 9775 "\to_color = vec4(valueOut) / vec4(255.0);\n" 9776 "}\n"; 9777 9778 sources.glslSources.add("storage-texel-buffer.frag") 9779 << glu::FragmentSource(fragmentShader); 9780 } 9781 } 9782 9783 if (config.usage & USAGE_STORAGE_IMAGE) 9784 { 9785 { 9786 // Vertex storage image 9787 const char* const vertexShader = 9788 "#version 450\n" 9789 "precision highp float;\n" 9790 "layout(set=0, binding=0, rgba8) uniform image2D u_image;\n" 9791 "out gl_PerVertex {\n" 9792 "\tvec4 gl_Position;\n" 9793 "\tfloat gl_PointSize;\n" 9794 "};\n" 9795 "void main (void) {\n" 9796 "\tgl_PointSize = 1.0;\n" 9797 "\thighp vec4 val = imageLoad(u_image, ivec2((gl_VertexIndex / 2) / imageSize(u_image).x, (gl_VertexIndex / 2) % imageSize(u_image).x));\n" 9798 "\thighp vec2 pos;\n" 9799 "\tif (gl_VertexIndex % 2 == 0)\n" 9800 "\t\tpos = val.xy;\n" 9801 "\telse\n" 9802 "\t\tpos = val.zw;\n" 9803 "\tgl_Position = vec4(1.998 * pos - vec2(0.999), 0.0, 1.0);\n" 9804 "}\n"; 9805 9806 sources.glslSources.add("storage-image.vert") 9807 << glu::VertexSource(vertexShader); 9808 } 9809 { 9810 // Fragment storage image 9811 const char* const fragmentShader = 9812 "#version 450\n" 9813 "#extension GL_EXT_texture_buffer : require\n" 9814 "precision highp float;\n" 9815 "layout(set=0, binding=0, rgba8) uniform image2D u_image;\n" 9816 "layout(location = 0) out highp vec4 o_color;\n" 9817 "void main (void) {\n" 9818 "\thighp uvec2 size = uvec2(imageSize(u_image).x, imageSize(u_image).y);\n" 9819 "\thighp uint valuesPerPixel = max(1u, (size.x * size.y) / (256u * 256u));\n" 9820 "\thighp uvec4 value = uvec4(uint(gl_FragCoord.x), uint(gl_FragCoord.y), 0u, 0u);\n" 9821 "\tfor (uint i = 0u; i < valuesPerPixel; i++)\n" 9822 "\t{\n" 9823 "\t\thighp vec4 floatValue = imageLoad(u_image, ivec2(int((value.z * 256u + (value.x ^ value.z)) % size.x), int((value.w * 256u + (value.y ^ value.w)) % size.y)));\n" 9824 "\t\tvalue = uvec4(uint(floatValue.x * 255.0), uint(floatValue.y * 255.0), uint(floatValue.z * 255.0), uint(floatValue.w * 255.0));\n" 9825 "\t}\n" 9826 "\to_color = vec4(value) / vec4(255.0);\n" 9827 "}\n"; 9828 9829 sources.glslSources.add("storage-image.frag") 9830 << glu::FragmentSource(fragmentShader); 9831 } 9832 } 9833 9834 if (config.usage & USAGE_SAMPLED_IMAGE) 9835 { 9836 { 9837 // Vertex storage image 9838 const char* const vertexShader = 9839 "#version 450\n" 9840 "precision highp float;\n" 9841 "layout(set=0, binding=0) uniform sampler2D u_sampler;\n" 9842 "out gl_PerVertex {\n" 9843 "\tvec4 gl_Position;\n" 9844 "\tfloat gl_PointSize;\n" 9845 "};\n" 9846 "void main (void) {\n" 9847 "\tgl_PointSize = 1.0;\n" 9848 "\thighp vec4 val = texelFetch(u_sampler, ivec2((gl_VertexIndex / 2) / textureSize(u_sampler, 0).x, (gl_VertexIndex / 2) % textureSize(u_sampler, 0).x), 0);\n" 9849 "\thighp vec2 pos;\n" 9850 "\tif (gl_VertexIndex % 2 == 0)\n" 9851 "\t\tpos = val.xy;\n" 9852 "\telse\n" 9853 "\t\tpos = val.zw;\n" 9854 "\tgl_Position = vec4(1.998 * pos - vec2(0.999), 0.0, 1.0);\n" 9855 "}\n"; 9856 9857 sources.glslSources.add("sampled-image.vert") 9858 << glu::VertexSource(vertexShader); 9859 } 9860 { 9861 // Fragment storage image 9862 const char* const fragmentShader = 9863 "#version 450\n" 9864 "#extension GL_EXT_texture_buffer : require\n" 9865 "precision highp float;\n" 9866 "layout(set=0, binding=0) uniform sampler2D u_sampler;\n" 9867 "layout(location = 0) out highp vec4 o_color;\n" 9868 "void main (void) {\n" 9869 "\thighp uvec2 size = uvec2(textureSize(u_sampler, 0).x, textureSize(u_sampler, 0).y);\n" 9870 "\thighp uint valuesPerPixel = max(1u, (size.x * size.y) / (256u * 256u));\n" 9871 "\thighp uvec4 value = uvec4(uint(gl_FragCoord.x), uint(gl_FragCoord.y), 0u, 0u);\n" 9872 "\tfor (uint i = 0u; i < valuesPerPixel; i++)\n" 9873 "\t{\n" 9874 "\t\thighp vec4 floatValue = texelFetch(u_sampler, ivec2(int((value.z * 256u + (value.x ^ value.z)) % size.x), int((value.w * 256u + (value.y ^ value.w)) % size.y)), 0);\n" 9875 "\t\tvalue = uvec4(uint(floatValue.x * 255.0), uint(floatValue.y * 255.0), uint(floatValue.z * 255.0), uint(floatValue.w * 255.0));\n" 9876 "\t}\n" 9877 "\to_color = vec4(value) / vec4(255.0);\n" 9878 "}\n"; 9879 9880 sources.glslSources.add("sampled-image.frag") 9881 << glu::FragmentSource(fragmentShader); 9882 } 9883 } 9884 9885 { 9886 const char* const vertexShader = 9887 "#version 450\n" 9888 "out gl_PerVertex {\n" 9889 "\tvec4 gl_Position;\n" 9890 "};\n" 9891 "precision highp float;\n" 9892 "void main (void) {\n" 9893 "\tgl_Position = vec4(((gl_VertexIndex + 2) / 3) % 2 == 0 ? -1.0 : 1.0,\n" 9894 "\t ((gl_VertexIndex + 1) / 3) % 2 == 0 ? -1.0 : 1.0, 0.0, 1.0);\n" 9895 "}\n"; 9896 9897 sources.glslSources.add("render-quad.vert") 9898 << glu::VertexSource(vertexShader); 9899 } 9900 9901 { 9902 const char* const fragmentShader = 9903 "#version 310 es\n" 9904 "layout(location = 0) out highp vec4 o_color;\n" 9905 "void main (void) {\n" 9906 "\to_color = vec4(1.0);\n" 9907 "}\n"; 9908 9909 sources.glslSources.add("render-white.frag") 9910 << glu::FragmentSource(fragmentShader); 9911 } 9912 } 9913 }; 9914 9915 } // anonymous 9916 9917 tcu::TestCaseGroup* createPipelineBarrierTests (tcu::TestContext& testCtx) 9918 { 9919 de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "pipeline_barrier", "Pipeline barrier tests.")); 9920 const vk::VkDeviceSize sizes[] = 9921 { 9922 1024, // 1K 9923 8*1024, // 8K 9924 64*1024, // 64K 9925 1024*1024, // 1M 9926 }; 9927 const Usage usages[] = 9928 { 9929 USAGE_HOST_READ, 9930 USAGE_HOST_WRITE, 9931 USAGE_TRANSFER_SRC, 9932 USAGE_TRANSFER_DST, 9933 USAGE_VERTEX_BUFFER, 9934 USAGE_INDEX_BUFFER, 9935 USAGE_UNIFORM_BUFFER, 9936 USAGE_UNIFORM_TEXEL_BUFFER, 9937 USAGE_STORAGE_BUFFER, 9938 USAGE_STORAGE_TEXEL_BUFFER, 9939 USAGE_STORAGE_IMAGE, 9940 USAGE_SAMPLED_IMAGE 9941 }; 9942 const Usage readUsages[] = 9943 { 9944 USAGE_HOST_READ, 9945 USAGE_TRANSFER_SRC, 9946 USAGE_VERTEX_BUFFER, 9947 USAGE_INDEX_BUFFER, 9948 USAGE_UNIFORM_BUFFER, 9949 USAGE_UNIFORM_TEXEL_BUFFER, 9950 USAGE_STORAGE_BUFFER, 9951 USAGE_STORAGE_TEXEL_BUFFER, 9952 USAGE_STORAGE_IMAGE, 9953 USAGE_SAMPLED_IMAGE 9954 }; 9955 9956 const Usage writeUsages[] = 9957 { 9958 USAGE_HOST_WRITE, 9959 USAGE_TRANSFER_DST 9960 }; 9961 9962 for (size_t writeUsageNdx = 0; writeUsageNdx < DE_LENGTH_OF_ARRAY(writeUsages); writeUsageNdx++) 9963 { 9964 const Usage writeUsage = writeUsages[writeUsageNdx]; 9965 9966 for (size_t readUsageNdx = 0; readUsageNdx < DE_LENGTH_OF_ARRAY(readUsages); readUsageNdx++) 9967 { 9968 const Usage readUsage = readUsages[readUsageNdx]; 9969 const Usage usage = writeUsage | readUsage; 9970 const string usageGroupName (usageToName(usage)); 9971 de::MovePtr<tcu::TestCaseGroup> usageGroup (new tcu::TestCaseGroup(testCtx, usageGroupName.c_str(), usageGroupName.c_str())); 9972 9973 for (size_t sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); sizeNdx++) 9974 { 9975 const vk::VkDeviceSize size = sizes[sizeNdx]; 9976 const string testName (de::toString((deUint64)(size))); 9977 const TestConfig config = 9978 { 9979 usage, 9980 size, 9981 vk::VK_SHARING_MODE_EXCLUSIVE 9982 }; 9983 9984 usageGroup->addChild(new InstanceFactory1<MemoryTestInstance, TestConfig, AddPrograms>(testCtx,tcu::NODETYPE_SELF_VALIDATE, testName, testName, AddPrograms(), config)); 9985 } 9986 9987 group->addChild(usageGroup.get()); 9988 usageGroup.release(); 9989 } 9990 } 9991 9992 { 9993 Usage all = (Usage)0; 9994 9995 for (size_t usageNdx = 0; usageNdx < DE_LENGTH_OF_ARRAY(usages); usageNdx++) 9996 all = all | usages[usageNdx]; 9997 9998 { 9999 const string usageGroupName ("all"); 10000 de::MovePtr<tcu::TestCaseGroup> usageGroup (new tcu::TestCaseGroup(testCtx, usageGroupName.c_str(), usageGroupName.c_str())); 10001 10002 for (size_t sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); sizeNdx++) 10003 { 10004 const vk::VkDeviceSize size = sizes[sizeNdx]; 10005 const string testName (de::toString((deUint64)(size))); 10006 const TestConfig config = 10007 { 10008 all, 10009 size, 10010 vk::VK_SHARING_MODE_EXCLUSIVE 10011 }; 10012 10013 usageGroup->addChild(new InstanceFactory1<MemoryTestInstance, TestConfig, AddPrograms>(testCtx,tcu::NODETYPE_SELF_VALIDATE, testName, testName, AddPrograms(), config)); 10014 } 10015 10016 group->addChild(usageGroup.get()); 10017 usageGroup.release(); 10018 } 10019 10020 { 10021 const string usageGroupName ("all_device"); 10022 de::MovePtr<tcu::TestCaseGroup> usageGroup (new tcu::TestCaseGroup(testCtx, usageGroupName.c_str(), usageGroupName.c_str())); 10023 10024 for (size_t sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); sizeNdx++) 10025 { 10026 const vk::VkDeviceSize size = sizes[sizeNdx]; 10027 const string testName (de::toString((deUint64)(size))); 10028 const TestConfig config = 10029 { 10030 (Usage)(all & (~(USAGE_HOST_READ|USAGE_HOST_WRITE))), 10031 size, 10032 vk::VK_SHARING_MODE_EXCLUSIVE 10033 }; 10034 10035 usageGroup->addChild(new InstanceFactory1<MemoryTestInstance, TestConfig, AddPrograms>(testCtx,tcu::NODETYPE_SELF_VALIDATE, testName, testName, AddPrograms(), config)); 10036 } 10037 10038 group->addChild(usageGroup.get()); 10039 usageGroup.release(); 10040 } 10041 } 10042 10043 return group.release(); 10044 } 10045 10046 } // memory 10047 } // vkt 10048
