1 /*------------------------------------------------------------------------ 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2016 The Khronos Group 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 Synchronization internally synchronized objects tests 22 *//*--------------------------------------------------------------------*/ 23 24 #include "vktSynchronizationInternallySynchronizedObjectsTests.hpp" 25 #include "vktTestCaseUtil.hpp" 26 #include "vktSynchronizationUtil.hpp" 27 28 #include "vkRef.hpp" 29 #include "tcuDefs.hpp" 30 #include "vkTypeUtil.hpp" 31 #include "vkPlatform.hpp" 32 #include "vkBuilderUtil.hpp" 33 #include "vkImageUtil.hpp" 34 35 #include "tcuResultCollector.hpp" 36 37 #include "deThread.hpp" 38 #include "deMutex.hpp" 39 #include "deSharedPtr.hpp" 40 41 42 #include <limits> 43 #include <iterator> 44 45 namespace vkt 46 { 47 namespace synchronization 48 { 49 namespace 50 { 51 using namespace vk; 52 53 using std::vector; 54 using std::string; 55 using std::map; 56 using std::exception; 57 using std::ostringstream; 58 59 using tcu::TestStatus; 60 using tcu::TestContext; 61 using tcu::ResultCollector; 62 using tcu::TestException; 63 64 using de::UniquePtr; 65 using de::MovePtr; 66 using de::SharedPtr; 67 using de::Mutex; 68 using de::Thread; 69 using de::clamp; 70 71 enum {EXECUTION_PER_THREAD = 100, BUFFER_ELEMENT_COUNT = 16, BUFFER_SIZE = BUFFER_ELEMENT_COUNT*4 }; 72 73 class MultiQueues 74 { 75 typedef struct QueueType 76 { 77 vector<VkQueue> queues; 78 vector<bool> available; 79 } Queues; 80 81 public: 82 83 inline void addQueueFamilyIndex (const deUint32& queueFamilyIndex, const deUint32& count) 84 { 85 Queues temp; 86 vector<bool>::iterator it; 87 it = temp.available.begin(); 88 temp.available.insert(it, count, false); 89 90 temp.queues.resize(count); 91 m_queues[queueFamilyIndex] = temp; 92 } 93 94 const deUint32& getQueueFamilyIndex (const int index) 95 { 96 map<deUint32,Queues>::iterator it = m_queues.begin(); 97 advance (it, index); 98 return it->first; 99 } 100 101 inline size_t countQueueFamilyIndex (void) 102 { 103 return m_queues.size(); 104 } 105 106 Queues & getQueues (const int index) 107 { 108 map<deUint32,Queues>::iterator it = m_queues.begin(); 109 advance (it, index); 110 return it->second; 111 } 112 113 bool getFreeQueue (deUint32& returnQueueFamilyIndex, VkQueue& returnQueues, int& returnQueueIndex) 114 { 115 for (int queueFamilyIndexNdx = 0 ; queueFamilyIndexNdx < static_cast<int>(m_queues.size()); ++queueFamilyIndexNdx) 116 { 117 Queues& queue = m_queues[getQueueFamilyIndex(queueFamilyIndexNdx)]; 118 for (int queueNdx = 0; queueNdx < static_cast<int>(queue.queues.size()); ++queueNdx) 119 { 120 m_mutex.lock(); 121 if (queue.available[queueNdx]) 122 { 123 queue.available[queueNdx] = false; 124 returnQueueFamilyIndex = getQueueFamilyIndex(queueFamilyIndexNdx); 125 returnQueues = queue.queues[queueNdx]; 126 returnQueueIndex = queueNdx; 127 m_mutex.unlock(); 128 return true; 129 } 130 m_mutex.unlock(); 131 } 132 } 133 return false; 134 } 135 136 void releaseQueue (const deUint32& queueFamilyIndex, const int& queueIndex) 137 { 138 m_mutex.lock(); 139 m_queues[queueFamilyIndex].available[queueIndex] = true; 140 m_mutex.unlock(); 141 } 142 143 inline void setDevice (Move<VkDevice> device) 144 { 145 m_logicalDevice = device; 146 } 147 148 inline VkDevice getDevice (void) 149 { 150 return *m_logicalDevice; 151 } 152 153 MovePtr<Allocator> m_allocator; 154 protected: 155 Move<VkDevice> m_logicalDevice; 156 map<deUint32,Queues> m_queues; 157 Mutex m_mutex; 158 159 }; 160 161 MovePtr<Allocator> createAllocator (const Context& context, const VkDevice& device) 162 { 163 const DeviceInterface& deviceInterface = context.getDeviceInterface(); 164 const InstanceInterface& instance = context.getInstanceInterface(); 165 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 166 const VkPhysicalDeviceMemoryProperties deviceMemoryProperties = getPhysicalDeviceMemoryProperties(instance, physicalDevice); 167 168 // Create memory allocator for device 169 return MovePtr<Allocator> (new SimpleAllocator(deviceInterface, device, deviceMemoryProperties)); 170 } 171 172 bool checkQueueFlags (const VkQueueFlags& availableFlag, const VkQueueFlags& neededFlag) 173 { 174 if (VK_QUEUE_TRANSFER_BIT == neededFlag) 175 { 176 if ( (availableFlag & VK_QUEUE_GRAPHICS_BIT) == VK_QUEUE_GRAPHICS_BIT || 177 (availableFlag & VK_QUEUE_COMPUTE_BIT) == VK_QUEUE_COMPUTE_BIT || 178 (availableFlag & VK_QUEUE_TRANSFER_BIT) == VK_QUEUE_TRANSFER_BIT 179 ) 180 return true; 181 } 182 else if ((availableFlag & neededFlag) == neededFlag) 183 { 184 return true; 185 } 186 return false; 187 } 188 189 MovePtr<MultiQueues> createQueues (const Context& context, const VkQueueFlags& queueFlag) 190 { 191 const DeviceInterface& vk = context.getDeviceInterface(); 192 const InstanceInterface& instance = context.getInstanceInterface(); 193 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 194 MovePtr<MultiQueues> moveQueues (new MultiQueues()); 195 MultiQueues& queues = *moveQueues; 196 VkDeviceCreateInfo deviceInfo; 197 VkPhysicalDeviceFeatures deviceFeatures; 198 vector<VkQueueFamilyProperties> queueFamilyProperties; 199 vector<float> queuePriorities; 200 vector<VkDeviceQueueCreateInfo> queueInfos; 201 202 queueFamilyProperties = getPhysicalDeviceQueueFamilyProperties(instance, physicalDevice); 203 204 for (deUint32 queuePropertiesNdx = 0; queuePropertiesNdx < queueFamilyProperties.size(); ++queuePropertiesNdx) 205 { 206 if (checkQueueFlags(queueFamilyProperties[queuePropertiesNdx].queueFlags, queueFlag)) 207 { 208 queues.addQueueFamilyIndex(queuePropertiesNdx, queueFamilyProperties[queuePropertiesNdx].queueCount); 209 } 210 } 211 212 if (queues.countQueueFamilyIndex() == 0) 213 { 214 TCU_THROW(NotSupportedError, "Queue not found"); 215 } 216 217 { 218 vector<float>::iterator it = queuePriorities.begin(); 219 unsigned int maxQueueCount = 0; 220 for (int queueFamilyIndexNdx = 0; queueFamilyIndexNdx < static_cast<int>(queues.countQueueFamilyIndex()); ++queueFamilyIndexNdx) 221 { 222 if (queues.getQueues(queueFamilyIndexNdx).queues.size() > maxQueueCount) 223 maxQueueCount = static_cast<unsigned int>(queues.getQueues(queueFamilyIndexNdx).queues.size()); 224 } 225 queuePriorities.insert(it, maxQueueCount, 1.0); 226 } 227 228 for (int queueFamilyIndexNdx = 0; queueFamilyIndexNdx < static_cast<int>(queues.countQueueFamilyIndex()); ++queueFamilyIndexNdx) 229 { 230 VkDeviceQueueCreateInfo queueInfo; 231 const deUint32 queueCount = static_cast<deUint32>(queues.getQueues(queueFamilyIndexNdx).queues.size()); 232 233 deMemset(&queueInfo, 0, sizeof(queueInfo)); 234 235 queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; 236 queueInfo.pNext = DE_NULL; 237 queueInfo.flags = (VkDeviceQueueCreateFlags)0u; 238 queueInfo.queueFamilyIndex = queues.getQueueFamilyIndex(queueFamilyIndexNdx); 239 queueInfo.queueCount = queueCount; 240 queueInfo.pQueuePriorities = &queuePriorities[0]; 241 242 queueInfos.push_back(queueInfo); 243 } 244 245 deMemset(&deviceInfo, 0, sizeof(deviceInfo)); 246 instance.getPhysicalDeviceFeatures(physicalDevice, &deviceFeatures); 247 248 deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; 249 deviceInfo.pNext = DE_NULL; 250 deviceInfo.enabledExtensionCount = 0u; 251 deviceInfo.ppEnabledExtensionNames = DE_NULL; 252 deviceInfo.enabledLayerCount = 0u; 253 deviceInfo.ppEnabledLayerNames = DE_NULL; 254 deviceInfo.pEnabledFeatures = &deviceFeatures; 255 deviceInfo.queueCreateInfoCount = static_cast<deUint32>(queues.countQueueFamilyIndex()); 256 deviceInfo.pQueueCreateInfos = &queueInfos[0]; 257 258 queues.setDevice(createDevice(instance, physicalDevice, &deviceInfo)); 259 260 for (deUint32 queueFamilyIndex = 0; queueFamilyIndex < queues.countQueueFamilyIndex(); ++queueFamilyIndex) 261 { 262 for (deUint32 queueReqNdx = 0; queueReqNdx < queues.getQueues(queueFamilyIndex).queues.size(); ++queueReqNdx) 263 { 264 vk.getDeviceQueue(queues.getDevice(), queues.getQueueFamilyIndex(queueFamilyIndex), queueReqNdx, &queues.getQueues(queueFamilyIndex).queues[queueReqNdx]); 265 queues.getQueues(queueFamilyIndex).available[queueReqNdx]=true; 266 } 267 } 268 269 queues.m_allocator = createAllocator(context, queues.getDevice()); 270 return moveQueues; 271 } 272 273 Move<VkRenderPass> createRenderPass (const Context& context, const VkDevice& device, const VkFormat& colorFormat) 274 { 275 const DeviceInterface& vk = context.getDeviceInterface(); 276 const VkAttachmentDescription colorAttachmentDescription = 277 { 278 0u, // VkAttachmentDescriptionFlags flags; 279 colorFormat, // VkFormat format; 280 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples; 281 VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp; 282 VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp; 283 VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp; 284 VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp; 285 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout; 286 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout finalLayout; 287 }; 288 const VkAttachmentReference colorAttachmentReference = 289 { 290 0u, // deUint32 attachment; 291 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout; 292 }; 293 const VkSubpassDescription subpassDescription = 294 { 295 0u, // VkSubpassDescriptionFlags flags; 296 VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint; 297 0u, // deUint32 inputAttachmentCount; 298 DE_NULL, // const VkAttachmentReference* pInputAttachments; 299 1u, // deUint32 colorAttachmentCount; 300 &colorAttachmentReference, // const VkAttachmentReference* pColorAttachments; 301 DE_NULL, // const VkAttachmentReference* pResolveAttachments; 302 DE_NULL, // const VkAttachmentReference* pDepthStencilAttachment; 303 0u, // deUint32 preserveAttachmentCount; 304 DE_NULL // const VkAttachmentReference* pPreserveAttachments; 305 }; 306 const VkRenderPassCreateInfo renderPassParams = 307 { 308 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType; 309 DE_NULL, // const void* pNext; 310 0u, // VkRenderPassCreateFlags flags; 311 1u, // deUint32 attachmentCount; 312 &colorAttachmentDescription, // const VkAttachmentDescription* pAttachments; 313 1u, // deUint32 subpassCount; 314 &subpassDescription, // const VkSubpassDescription* pSubpasses; 315 0u, // deUint32 dependencyCount; 316 DE_NULL // const VkSubpassDependency* pDependencies; 317 }; 318 return createRenderPass(vk, device, &renderPassParams); 319 } 320 321 TestStatus executeComputePipeline (const Context& context, const VkPipeline& pipeline, const VkPipelineLayout& pipelineLayout, 322 const VkDescriptorSetLayout& descriptorSetLayout, MultiQueues& queues, const deUint32& shadersExecutions) 323 { 324 const DeviceInterface& vk = context.getDeviceInterface(); 325 const VkDevice device = queues.getDevice(); 326 deUint32 queueFamilyIndex; 327 VkQueue queue; 328 int queueIndex; 329 while(!queues.getFreeQueue(queueFamilyIndex, queue, queueIndex)){} 330 331 { 332 const Unique<VkDescriptorPool> descriptorPool (DescriptorPoolBuilder() 333 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) 334 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u)); 335 Buffer resultBuffer (vk, device, *queues.m_allocator, makeBufferCreateInfo(BUFFER_SIZE, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible); 336 const VkBufferMemoryBarrier bufferBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *resultBuffer, 0ull, BUFFER_SIZE); 337 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex)); 338 const Unique<VkCommandBuffer> cmdBuffer (makeCommandBuffer(vk, device, *cmdPool)); 339 340 { 341 const Allocation& alloc = resultBuffer.getAllocation(); 342 deMemset(alloc.getHostPtr(), 0, BUFFER_SIZE); 343 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), BUFFER_SIZE); 344 } 345 346 // Start recording commands 347 beginCommandBuffer(vk, *cmdBuffer); 348 349 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline); 350 351 // Create descriptor set 352 const Unique<VkDescriptorSet> descriptorSet(makeDescriptorSet(vk, device, *descriptorPool, descriptorSetLayout)); 353 354 const VkDescriptorBufferInfo resultDescriptorInfo = makeDescriptorBufferInfo(*resultBuffer, 0ull, BUFFER_SIZE); 355 356 DescriptorSetUpdateBuilder() 357 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultDescriptorInfo) 358 .update(vk, device); 359 360 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL); 361 362 // Dispatch indirect compute command 363 vk.cmdDispatch(*cmdBuffer, shadersExecutions, 1u, 1u); 364 365 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 366 0, (const VkMemoryBarrier*)DE_NULL, 367 1, &bufferBarrier, 368 0, (const VkImageMemoryBarrier*)DE_NULL); 369 370 // End recording commands 371 endCommandBuffer(vk, *cmdBuffer); 372 373 // Wait for command buffer execution finish 374 submitCommandsAndWait(vk, device, queue, *cmdBuffer); 375 queues.releaseQueue(queueFamilyIndex, queueIndex); 376 377 { 378 const Allocation& resultAlloc = resultBuffer.getAllocation(); 379 invalidateMappedMemoryRange(vk, device, resultAlloc.getMemory(), resultAlloc.getOffset(), BUFFER_SIZE); 380 381 const deInt32* ptr = reinterpret_cast<deInt32*>(resultAlloc.getHostPtr()); 382 for (deInt32 ndx = 0; ndx < BUFFER_ELEMENT_COUNT; ++ndx) 383 { 384 if (ptr[ndx] != ndx) 385 { 386 return TestStatus::fail("The data don't match"); 387 } 388 } 389 } 390 return TestStatus::pass("Passed"); 391 } 392 } 393 394 395 TestStatus executeGraphicPipeline (const Context& context, const VkPipeline& pipeline, const VkPipelineLayout& pipelineLayout, 396 const VkDescriptorSetLayout& descriptorSetLayout, MultiQueues& queues, const VkRenderPass& renderPass, const deUint32 shadersExecutions) 397 { 398 const DeviceInterface& vk = context.getDeviceInterface(); 399 const VkDevice device = queues.getDevice(); 400 deUint32 queueFamilyIndex; 401 VkQueue queue; 402 int queueIndex; 403 while(!queues.getFreeQueue(queueFamilyIndex, queue, queueIndex)){} 404 405 { 406 const Unique<VkDescriptorPool> descriptorPool (DescriptorPoolBuilder() 407 .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) 408 .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u)); 409 Move<VkDescriptorSet> descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, descriptorSetLayout); 410 Buffer resultBuffer (vk, device, *queues.m_allocator, makeBufferCreateInfo(BUFFER_SIZE, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible); 411 const VkBufferMemoryBarrier bufferBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *resultBuffer, 0ull, BUFFER_SIZE); 412 const VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM; 413 const VkExtent3D colorImageExtent = makeExtent3D(1u, 1u, 1u); 414 const VkImageSubresourceRange colorImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u); 415 de::MovePtr<Image> colorAttachmentImage = de::MovePtr<Image>(new Image(vk, device, *queues.m_allocator, 416 makeImageCreateInfo(VK_IMAGE_TYPE_2D, colorImageExtent, colorFormat, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT), 417 MemoryRequirement::Any)); 418 Move<VkImageView> colorAttachmentView = makeImageView(vk, device, **colorAttachmentImage, VK_IMAGE_VIEW_TYPE_2D, colorFormat, colorImageSubresourceRange); 419 Move<VkFramebuffer> framebuffer = makeFramebuffer(vk, device, renderPass, *colorAttachmentView, colorImageExtent.width, colorImageExtent.height, 1u); 420 const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex)); 421 const Unique<VkCommandBuffer> cmdBuffer (makeCommandBuffer(vk, device, *cmdPool)); 422 const VkDescriptorBufferInfo outputBufferDescriptorInfo = makeDescriptorBufferInfo(*resultBuffer, 0ull, BUFFER_SIZE); 423 424 DescriptorSetUpdateBuilder() 425 .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &outputBufferDescriptorInfo) 426 .update (vk, device); 427 428 { 429 const Allocation& alloc = resultBuffer.getAllocation(); 430 deMemset(alloc.getHostPtr(), 0, BUFFER_SIZE); 431 flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), BUFFER_SIZE); 432 } 433 434 // Start recording commands 435 beginCommandBuffer(vk, *cmdBuffer); 436 // Change color attachment image layout 437 { 438 const VkImageMemoryBarrier colorAttachmentLayoutBarrier = makeImageMemoryBarrier( 439 (VkAccessFlags)0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 440 VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 441 **colorAttachmentImage, colorImageSubresourceRange); 442 443 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 444 0u, DE_NULL, 0u, DE_NULL, 1u, &colorAttachmentLayoutBarrier); 445 } 446 447 { 448 const VkRect2D renderArea = 449 { 450 makeOffset2D(0, 0), 451 makeExtent2D(1, 1), 452 }; 453 const tcu::Vec4 clearColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); 454 beginRenderPass(vk, *cmdBuffer, renderPass, *framebuffer, renderArea, clearColor); 455 } 456 457 vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); 458 vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL); 459 460 vk.cmdDraw(*cmdBuffer, shadersExecutions, 1u, 0u, 0u); 461 endRenderPass(vk, *cmdBuffer); 462 463 vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 464 0, (const VkMemoryBarrier*)DE_NULL, 465 1, &bufferBarrier, 466 0, (const VkImageMemoryBarrier*)DE_NULL); 467 468 // End recording commands 469 endCommandBuffer(vk, *cmdBuffer); 470 471 // Wait for command buffer execution finish 472 submitCommandsAndWait(vk, device, queue, *cmdBuffer); 473 queues.releaseQueue(queueFamilyIndex, queueIndex); 474 475 { 476 const Allocation& resultAlloc = resultBuffer.getAllocation(); 477 invalidateMappedMemoryRange(vk, device, resultAlloc.getMemory(), resultAlloc.getOffset(), BUFFER_SIZE); 478 479 const deInt32* ptr = reinterpret_cast<deInt32*>(resultAlloc.getHostPtr()); 480 for (deInt32 ndx = 0; ndx < BUFFER_ELEMENT_COUNT; ++ndx) 481 { 482 if (ptr[ndx] != ndx) 483 { 484 return TestStatus::fail("The data don't match"); 485 } 486 } 487 } 488 return TestStatus::pass("Passed"); 489 } 490 } 491 492 493 class ThreadGroupThread : private Thread 494 { 495 public: 496 ThreadGroupThread (const Context& context, VkPipelineCache pipelineCache, const VkPipelineLayout& pipelineLayout, 497 const VkDescriptorSetLayout& descriptorSetLayout, MultiQueues& queues, const vector<deUint32>& shadersExecutions) 498 : m_context (context) 499 , m_pipelineCache (pipelineCache) 500 , m_pipelineLayout (pipelineLayout) 501 , m_descriptorSetLayout (descriptorSetLayout) 502 , m_queues (queues) 503 , m_shadersExecutions (shadersExecutions) 504 { 505 } 506 507 virtual ~ThreadGroupThread (void) 508 { 509 } 510 511 ResultCollector& getResultCollector (void) 512 { 513 return m_resultCollector; 514 } 515 516 using Thread::start; 517 using Thread::join; 518 519 protected: 520 virtual TestStatus runThread () = 0; 521 const Context& m_context; 522 VkPipelineCache m_pipelineCache; 523 const VkPipelineLayout& m_pipelineLayout; 524 const VkDescriptorSetLayout& m_descriptorSetLayout; 525 MultiQueues& m_queues; 526 const vector<deUint32>& m_shadersExecutions; 527 528 private: 529 ThreadGroupThread (const ThreadGroupThread&); 530 ThreadGroupThread& operator= (const ThreadGroupThread&); 531 532 void run (void) 533 { 534 try 535 { 536 TestStatus result = runThread(); 537 m_resultCollector.addResult(result.getCode(), result.getDescription()); 538 } 539 catch (const TestException& e) 540 { 541 m_resultCollector.addResult(e.getTestResult(), e.getMessage()); 542 } 543 catch (const exception& e) 544 { 545 m_resultCollector.addResult(QP_TEST_RESULT_FAIL, e.what()); 546 } 547 catch (...) 548 { 549 m_resultCollector.addResult(QP_TEST_RESULT_FAIL, "Exception"); 550 } 551 } 552 553 ResultCollector m_resultCollector; 554 }; 555 556 class ThreadGroup 557 { 558 typedef vector<SharedPtr<ThreadGroupThread> > ThreadVector; 559 public: 560 ThreadGroup (void) 561 { 562 } 563 ~ThreadGroup (void) 564 { 565 } 566 567 void add (MovePtr<ThreadGroupThread> thread) 568 { 569 m_threads.push_back(SharedPtr<ThreadGroupThread>(thread.release())); 570 } 571 572 TestStatus run (void) 573 { 574 ResultCollector resultCollector; 575 576 for (ThreadVector::iterator threadIter = m_threads.begin(); threadIter != m_threads.end(); ++threadIter) 577 (*threadIter)->start(); 578 579 for (ThreadVector::iterator threadIter = m_threads.begin(); threadIter != m_threads.end(); ++threadIter) 580 { 581 ResultCollector& threadResult = (*threadIter)->getResultCollector(); 582 (*threadIter)->join(); 583 resultCollector.addResult(threadResult.getResult(), threadResult.getMessage()); 584 } 585 586 return TestStatus(resultCollector.getResult(), resultCollector.getMessage()); 587 } 588 589 private: 590 ThreadVector m_threads; 591 }; 592 593 594 class CreateComputeThread : public ThreadGroupThread 595 { 596 public: 597 CreateComputeThread (const Context& context, VkPipelineCache pipelineCache, vector<VkComputePipelineCreateInfo>& pipelineInfo, 598 const VkPipelineLayout& pipelineLayout, const VkDescriptorSetLayout& descriptorSetLayout, 599 MultiQueues& queues, const vector<deUint32>& shadersExecutions) 600 : ThreadGroupThread (context, pipelineCache, pipelineLayout, descriptorSetLayout, queues, shadersExecutions) 601 , m_pipelineInfo (pipelineInfo) 602 { 603 } 604 605 TestStatus runThread (void) 606 { 607 ResultCollector resultCollector; 608 for (int executionNdx = 0; executionNdx < EXECUTION_PER_THREAD; ++executionNdx) 609 { 610 const int shaderNdx = executionNdx % (int)m_pipelineInfo.size(); 611 const DeviceInterface& vk = m_context.getDeviceInterface(); 612 const VkDevice device = m_queues.getDevice(); 613 Move<VkPipeline> pipeline = createComputePipeline(vk,device,m_pipelineCache, &m_pipelineInfo[shaderNdx]); 614 615 TestStatus result = executeComputePipeline(m_context, *pipeline, m_pipelineLayout, m_descriptorSetLayout, m_queues, m_shadersExecutions[shaderNdx]); 616 resultCollector.addResult(result.getCode(), result.getDescription()); 617 } 618 return TestStatus(resultCollector.getResult(), resultCollector.getMessage()); 619 } 620 private: 621 vector<VkComputePipelineCreateInfo>& m_pipelineInfo; 622 }; 623 624 class CreateGraphicThread : public ThreadGroupThread 625 { 626 public: 627 CreateGraphicThread (const Context& context, VkPipelineCache pipelineCache, vector<VkGraphicsPipelineCreateInfo>& pipelineInfo, 628 const VkPipelineLayout& pipelineLayout, const VkDescriptorSetLayout& descriptorSetLayout, 629 MultiQueues& queues, const VkRenderPass& renderPass, const vector<deUint32>& shadersExecutions) 630 : ThreadGroupThread (context, pipelineCache, pipelineLayout, descriptorSetLayout, queues, shadersExecutions) 631 , m_pipelineInfo (pipelineInfo) 632 , m_renderPass (renderPass) 633 {} 634 635 TestStatus runThread (void) 636 { 637 ResultCollector resultCollector; 638 for (int executionNdx = 0; executionNdx < EXECUTION_PER_THREAD; ++executionNdx) 639 { 640 const int shaderNdx = executionNdx % (int)m_pipelineInfo.size(); 641 const DeviceInterface& vk = m_context.getDeviceInterface(); 642 const VkDevice device = m_queues.getDevice(); 643 Move<VkPipeline> pipeline = createGraphicsPipeline(vk,device, m_pipelineCache, &m_pipelineInfo[shaderNdx]); 644 645 TestStatus result = executeGraphicPipeline(m_context, *pipeline, m_pipelineLayout, m_descriptorSetLayout, m_queues, m_renderPass, m_shadersExecutions[shaderNdx]); 646 resultCollector.addResult(result.getCode(), result.getDescription()); 647 } 648 return TestStatus(resultCollector.getResult(), resultCollector.getMessage()); 649 } 650 651 private: 652 vector<VkGraphicsPipelineCreateInfo>& m_pipelineInfo; 653 const VkRenderPass& m_renderPass; 654 }; 655 656 class PipelineCacheComputeTestInstance : public TestInstance 657 { 658 typedef vector<SharedPtr<Unique<VkShaderModule> > > ShaderModuleVector; 659 public: 660 PipelineCacheComputeTestInstance (Context& context, const vector<deUint32>& shadersExecutions) 661 : TestInstance (context) 662 , m_shadersExecutions (shadersExecutions) 663 664 { 665 } 666 667 TestStatus iterate (void) 668 { 669 const DeviceInterface& vk = m_context.getDeviceInterface(); 670 MovePtr<MultiQueues> queues = createQueues(m_context, VK_QUEUE_COMPUTE_BIT); 671 const VkDevice device = queues->getDevice(); 672 ShaderModuleVector shaderCompModules = addShaderModules(device); 673 Buffer resultBuffer (vk, device, *queues->m_allocator, makeBufferCreateInfo(BUFFER_SIZE, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible); 674 const Move<VkDescriptorSetLayout> descriptorSetLayout (DescriptorSetLayoutBuilder() 675 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT) 676 .build(vk, device)); 677 const Move<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout)); 678 vector<VkPipelineShaderStageCreateInfo> shaderStageInfos = addShaderStageInfo(shaderCompModules); 679 vector<VkComputePipelineCreateInfo> pipelineInfo = addPipelineInfo(*pipelineLayout, shaderStageInfos); 680 const VkPipelineCacheCreateInfo pipelineCacheInfo = 681 { 682 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType; 683 DE_NULL, // const void* pNext; 684 0u, // VkPipelineCacheCreateFlags flags; 685 0u, // deUintptr initialDataSize; 686 DE_NULL, // const void* pInitialData; 687 }; 688 Move<VkPipelineCache> pipelineCache = createPipelineCache(vk, device, &pipelineCacheInfo); 689 Move<VkPipeline> pipeline = createComputePipeline(vk, device, *pipelineCache, &pipelineInfo[0]); 690 const deUint32 numThreads = clamp(deGetNumAvailableLogicalCores(), 4u, 32u); 691 ThreadGroup threads; 692 693 executeComputePipeline(m_context, *pipeline, *pipelineLayout, *descriptorSetLayout, *queues, m_shadersExecutions[0]); 694 695 for (deUint32 ndx = 0; ndx < numThreads; ++ndx) 696 threads.add(MovePtr<ThreadGroupThread>(new CreateComputeThread( 697 m_context, *pipelineCache, pipelineInfo, *pipelineLayout, *descriptorSetLayout, *queues, m_shadersExecutions))); 698 699 { 700 TestStatus thread_result = threads.run(); 701 if(thread_result.getCode()) 702 { 703 return thread_result; 704 } 705 } 706 return TestStatus::pass("Passed"); 707 } 708 709 private: 710 ShaderModuleVector addShaderModules (const VkDevice& device) 711 { 712 const DeviceInterface& vk = m_context.getDeviceInterface(); 713 ShaderModuleVector shaderCompModules; 714 shaderCompModules.resize(m_shadersExecutions.size()); 715 for (int shaderNdx = 0; shaderNdx < static_cast<int>(m_shadersExecutions.size()); ++shaderNdx) 716 { 717 ostringstream shaderName; 718 shaderName<<"compute_"<<shaderNdx; 719 shaderCompModules[shaderNdx] = SharedPtr<Unique<VkShaderModule> > (new Unique<VkShaderModule>(createShaderModule(vk, device, m_context.getBinaryCollection().get(shaderName.str()), (VkShaderModuleCreateFlags)0))); 720 } 721 return shaderCompModules; 722 } 723 724 vector<VkPipelineShaderStageCreateInfo> addShaderStageInfo (const ShaderModuleVector& shaderCompModules) 725 { 726 VkPipelineShaderStageCreateInfo shaderStageInfo; 727 vector<VkPipelineShaderStageCreateInfo> shaderStageInfos; 728 shaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; 729 shaderStageInfo.pNext = DE_NULL; 730 shaderStageInfo.flags = (VkPipelineShaderStageCreateFlags)0; 731 shaderStageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT; 732 shaderStageInfo.pName = "main"; 733 shaderStageInfo.pSpecializationInfo = DE_NULL; 734 735 for (int shaderNdx = 0; shaderNdx < static_cast<int>(m_shadersExecutions.size()); ++shaderNdx) 736 { 737 shaderStageInfo.module = *(*shaderCompModules[shaderNdx]); 738 shaderStageInfos.push_back(shaderStageInfo); 739 } 740 return shaderStageInfos; 741 } 742 743 vector<VkComputePipelineCreateInfo> addPipelineInfo (VkPipelineLayout pipelineLayout, const vector<VkPipelineShaderStageCreateInfo>& shaderStageInfos) 744 { 745 vector<VkComputePipelineCreateInfo> pipelineInfos; 746 VkComputePipelineCreateInfo computePipelineInfo; 747 computePipelineInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; 748 computePipelineInfo.pNext = DE_NULL; 749 computePipelineInfo.flags = (VkPipelineCreateFlags)0; 750 computePipelineInfo.layout = pipelineLayout; 751 computePipelineInfo.basePipelineHandle = DE_NULL; 752 computePipelineInfo.basePipelineIndex = 0; 753 754 for (int shaderNdx = 0; shaderNdx < static_cast<int>(m_shadersExecutions.size()); ++shaderNdx) 755 { 756 computePipelineInfo.stage = shaderStageInfos[shaderNdx]; 757 pipelineInfos.push_back(computePipelineInfo); 758 } 759 return pipelineInfos; 760 } 761 762 const vector<deUint32> m_shadersExecutions; 763 }; 764 765 class PipelineCacheGraphicTestInstance : public TestInstance 766 { 767 typedef vector<SharedPtr<Unique<VkShaderModule> > > ShaderModuleVector; 768 public: 769 PipelineCacheGraphicTestInstance (Context& context, const vector<deUint32>& shadersExecutions) 770 : TestInstance (context) 771 , m_shadersExecutions (shadersExecutions) 772 773 { 774 } 775 776 TestStatus iterate (void) 777 { 778 requireFeatures(m_context.getInstanceInterface(), m_context.getPhysicalDevice(), FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS); 779 780 const DeviceInterface& vk = m_context.getDeviceInterface(); 781 MovePtr<MultiQueues> queues = createQueues (m_context, VK_QUEUE_GRAPHICS_BIT); 782 const VkDevice device = queues->getDevice(); 783 VkFormat colorFormat = VK_FORMAT_R8G8B8A8_UNORM; 784 Move<VkRenderPass> renderPass = createRenderPass(m_context, device, colorFormat); 785 const Move<VkDescriptorSetLayout> descriptorSetLayout (DescriptorSetLayoutBuilder() 786 .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_VERTEX_BIT) 787 .build(vk, device)); 788 ShaderModuleVector shaderGraphicModules = addShaderModules(device); 789 const Move<VkPipelineLayout> pipelineLayout (makePipelineLayout(vk, device, *descriptorSetLayout)); 790 vector<VkPipelineShaderStageCreateInfo> shaderStageInfos = addShaderStageInfo(shaderGraphicModules); 791 vector<VkGraphicsPipelineCreateInfo> pipelineInfo = addPipelineInfo(*pipelineLayout, shaderStageInfos, *renderPass); 792 const VkPipelineCacheCreateInfo pipelineCacheInfo = 793 { 794 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, // VkStructureType sType; 795 DE_NULL, // const void* pNext; 796 0u, // VkPipelineCacheCreateFlags flags; 797 0u, // deUintptr initialDataSize; 798 DE_NULL, // const void* pInitialData; 799 }; 800 Move<VkPipelineCache> pipelineCache = createPipelineCache(vk, device, &pipelineCacheInfo); 801 Move<VkPipeline> pipeline = createGraphicsPipeline(vk, device, *pipelineCache, &pipelineInfo[0]); 802 const deUint32 numThreads = clamp(deGetNumAvailableLogicalCores(), 4u, 32u); 803 ThreadGroup threads; 804 805 executeGraphicPipeline(m_context, *pipeline, *pipelineLayout, *descriptorSetLayout, *queues, *renderPass, m_shadersExecutions[0]); 806 807 for (deUint32 ndx = 0; ndx < numThreads; ++ndx) 808 threads.add(MovePtr<ThreadGroupThread>(new CreateGraphicThread( 809 m_context, *pipelineCache, pipelineInfo, *pipelineLayout, *descriptorSetLayout, *queues, *renderPass, m_shadersExecutions))); 810 811 { 812 TestStatus thread_result = threads.run(); 813 if(thread_result.getCode()) 814 { 815 return thread_result; 816 } 817 } 818 return TestStatus::pass("Passed"); 819 } 820 821 private: 822 ShaderModuleVector addShaderModules (const VkDevice& device) 823 { 824 const DeviceInterface& vk = m_context.getDeviceInterface(); 825 ShaderModuleVector shaderModules; 826 shaderModules.resize(m_shadersExecutions.size() + 1); 827 for (int shaderNdx = 0; shaderNdx < static_cast<int>(m_shadersExecutions.size()); ++shaderNdx) 828 { 829 ostringstream shaderName; 830 shaderName<<"vert_"<<shaderNdx; 831 shaderModules[shaderNdx] = SharedPtr<Unique<VkShaderModule> > (new Unique<VkShaderModule>(createShaderModule(vk, device, m_context.getBinaryCollection().get(shaderName.str()), (VkShaderModuleCreateFlags)0))); 832 } 833 shaderModules[m_shadersExecutions.size()] = SharedPtr<Unique<VkShaderModule> > (new Unique<VkShaderModule>(createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), (VkShaderModuleCreateFlags)0))); 834 return shaderModules; 835 } 836 837 vector<VkPipelineShaderStageCreateInfo> addShaderStageInfo (const ShaderModuleVector& shaderCompModules) 838 { 839 VkPipelineShaderStageCreateInfo shaderStageInfo; 840 vector<VkPipelineShaderStageCreateInfo> shaderStageInfos; 841 shaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; 842 shaderStageInfo.pNext = DE_NULL; 843 shaderStageInfo.flags = (VkPipelineShaderStageCreateFlags)0; 844 shaderStageInfo.pName = "main"; 845 shaderStageInfo.pSpecializationInfo = DE_NULL; 846 847 for (int shaderNdx = 0; shaderNdx < static_cast<int>(m_shadersExecutions.size()); ++shaderNdx) 848 { 849 shaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT; 850 shaderStageInfo.module = *(*shaderCompModules[shaderNdx]); 851 shaderStageInfos.push_back(shaderStageInfo); 852 853 shaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT; 854 shaderStageInfo.module = *(*shaderCompModules[m_shadersExecutions.size()]); 855 shaderStageInfos.push_back(shaderStageInfo); 856 } 857 return shaderStageInfos; 858 } 859 860 vector<VkGraphicsPipelineCreateInfo> addPipelineInfo (VkPipelineLayout pipelineLayout, const vector<VkPipelineShaderStageCreateInfo>& shaderStageInfos, const VkRenderPass& renderPass) 861 { 862 VkExtent3D colorImageExtent = makeExtent3D(1u, 1u, 1u); 863 vector<VkGraphicsPipelineCreateInfo> pipelineInfo; 864 865 m_vertexInputStateParams.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; 866 m_vertexInputStateParams.pNext = DE_NULL; 867 m_vertexInputStateParams.flags = 0u; 868 m_vertexInputStateParams.vertexBindingDescriptionCount = 0u; 869 m_vertexInputStateParams.pVertexBindingDescriptions = DE_NULL; 870 m_vertexInputStateParams.vertexAttributeDescriptionCount = 0u; 871 m_vertexInputStateParams.pVertexAttributeDescriptions = DE_NULL; 872 873 m_inputAssemblyStateParams.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; 874 m_inputAssemblyStateParams.pNext = DE_NULL; 875 m_inputAssemblyStateParams.flags = 0u; 876 m_inputAssemblyStateParams.topology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST; 877 m_inputAssemblyStateParams.primitiveRestartEnable = VK_FALSE; 878 879 m_viewport.x = 0.0f; 880 m_viewport.y = 0.0f; 881 m_viewport.width = (float)colorImageExtent.width; 882 m_viewport.height = (float)colorImageExtent.height; 883 m_viewport.minDepth = 0.0f; 884 m_viewport.maxDepth = 1.0f; 885 886 //TODO 887 m_scissor.offset.x = 0; 888 m_scissor.offset.y = 0; 889 m_scissor.extent.width = colorImageExtent.width; 890 m_scissor.extent.height = colorImageExtent.height; 891 892 m_viewportStateParams.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; 893 m_viewportStateParams.pNext = DE_NULL; 894 m_viewportStateParams.flags = 0u; 895 m_viewportStateParams.viewportCount = 1u; 896 m_viewportStateParams.pViewports = &m_viewport; 897 m_viewportStateParams.scissorCount = 1u; 898 m_viewportStateParams.pScissors = &m_scissor; 899 900 m_rasterStateParams.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; 901 m_rasterStateParams.pNext = DE_NULL; 902 m_rasterStateParams.flags = 0u; 903 m_rasterStateParams.depthClampEnable = VK_FALSE; 904 m_rasterStateParams.rasterizerDiscardEnable = VK_FALSE; 905 m_rasterStateParams.polygonMode = VK_POLYGON_MODE_FILL; 906 m_rasterStateParams.cullMode = VK_CULL_MODE_NONE; 907 m_rasterStateParams.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE; 908 m_rasterStateParams.depthBiasEnable = VK_FALSE; 909 m_rasterStateParams.depthBiasConstantFactor = 0.0f; 910 m_rasterStateParams.depthBiasClamp = 0.0f; 911 m_rasterStateParams.depthBiasSlopeFactor = 0.0f; 912 m_rasterStateParams.lineWidth = 1.0f; 913 914 m_colorBlendAttachmentState.blendEnable = VK_FALSE; 915 m_colorBlendAttachmentState.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; 916 m_colorBlendAttachmentState.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; 917 m_colorBlendAttachmentState.colorBlendOp = VK_BLEND_OP_ADD; 918 m_colorBlendAttachmentState.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; 919 m_colorBlendAttachmentState.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; 920 m_colorBlendAttachmentState.alphaBlendOp = VK_BLEND_OP_ADD; 921 m_colorBlendAttachmentState.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | 922 VK_COLOR_COMPONENT_G_BIT | 923 VK_COLOR_COMPONENT_B_BIT | 924 VK_COLOR_COMPONENT_A_BIT; 925 926 m_colorBlendStateParams.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; 927 m_colorBlendStateParams.pNext = DE_NULL; 928 m_colorBlendStateParams.flags = 0u; 929 m_colorBlendStateParams.logicOpEnable = VK_FALSE; 930 m_colorBlendStateParams.logicOp = VK_LOGIC_OP_COPY; 931 m_colorBlendStateParams.attachmentCount = 1u; 932 m_colorBlendStateParams.pAttachments = &m_colorBlendAttachmentState; 933 m_colorBlendStateParams.blendConstants[0] = 0.0f; 934 m_colorBlendStateParams.blendConstants[1] = 0.0f; 935 m_colorBlendStateParams.blendConstants[2] = 0.0f; 936 m_colorBlendStateParams.blendConstants[3] = 0.0f; 937 938 m_multisampleStateParams.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; 939 m_multisampleStateParams.pNext = DE_NULL; 940 m_multisampleStateParams.flags = 0u; 941 m_multisampleStateParams.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; 942 m_multisampleStateParams.sampleShadingEnable = VK_FALSE; 943 m_multisampleStateParams.minSampleShading = 0.0f; 944 m_multisampleStateParams.pSampleMask = DE_NULL; 945 m_multisampleStateParams.alphaToCoverageEnable = VK_FALSE; 946 m_multisampleStateParams.alphaToOneEnable = VK_FALSE; 947 948 m_depthStencilStateParams.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; 949 m_depthStencilStateParams.pNext = DE_NULL; 950 m_depthStencilStateParams.flags = 0u; 951 m_depthStencilStateParams.depthTestEnable = VK_TRUE; 952 m_depthStencilStateParams.depthWriteEnable = VK_TRUE; 953 m_depthStencilStateParams.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL; 954 m_depthStencilStateParams.depthBoundsTestEnable = VK_FALSE; 955 m_depthStencilStateParams.stencilTestEnable = VK_FALSE; 956 m_depthStencilStateParams.front.failOp = VK_STENCIL_OP_KEEP; 957 m_depthStencilStateParams.front.passOp = VK_STENCIL_OP_KEEP; 958 m_depthStencilStateParams.front.depthFailOp = VK_STENCIL_OP_KEEP; 959 m_depthStencilStateParams.front.compareOp = VK_COMPARE_OP_NEVER; 960 m_depthStencilStateParams.front.compareMask = 0u; 961 m_depthStencilStateParams.front.writeMask = 0u; 962 m_depthStencilStateParams.front.reference = 0u; 963 m_depthStencilStateParams.back.failOp = VK_STENCIL_OP_KEEP; 964 m_depthStencilStateParams.back.passOp = VK_STENCIL_OP_KEEP; 965 m_depthStencilStateParams.back.depthFailOp = VK_STENCIL_OP_KEEP; 966 m_depthStencilStateParams.back.compareOp = VK_COMPARE_OP_NEVER; 967 m_depthStencilStateParams.back.compareMask = 0u; 968 m_depthStencilStateParams.back.writeMask = 0u; 969 m_depthStencilStateParams.back.reference = 0u; 970 m_depthStencilStateParams.minDepthBounds = 0.0f; 971 m_depthStencilStateParams.maxDepthBounds = 1.0f; 972 973 VkGraphicsPipelineCreateInfo graphicsPipelineParams = 974 { 975 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType; 976 DE_NULL, // const void* pNext; 977 0u, // VkPipelineCreateFlags flags; 978 2u, // deUint32 stageCount; 979 DE_NULL, // const VkPipelineShaderStageCreateInfo* pStages; 980 &m_vertexInputStateParams, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState; 981 &m_inputAssemblyStateParams, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; 982 DE_NULL, // const VkPipelineTessellationStateCreateInfo* pTessellationState; 983 &m_viewportStateParams, // const VkPipelineViewportStateCreateInfo* pViewportState; 984 &m_rasterStateParams, // const VkPipelineRasterizationStateCreateInfo* pRasterState; 985 &m_multisampleStateParams, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState; 986 &m_depthStencilStateParams, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; 987 &m_colorBlendStateParams, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState; 988 (const VkPipelineDynamicStateCreateInfo*)DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState; 989 pipelineLayout, // VkPipelineLayout layout; 990 renderPass, // VkRenderPass renderPass; 991 0u, // deUint32 subpass; 992 DE_NULL, // VkPipeline basePipelineHandle; 993 0, // deInt32 basePipelineIndex; 994 }; 995 for (int shaderNdx = 0; shaderNdx < static_cast<int>(m_shadersExecutions.size()) * 2; shaderNdx+=2) 996 { 997 graphicsPipelineParams.pStages = &shaderStageInfos[shaderNdx]; 998 pipelineInfo.push_back(graphicsPipelineParams); 999 } 1000 return pipelineInfo; 1001 } 1002 1003 const vector<deUint32> m_shadersExecutions; 1004 VkPipelineVertexInputStateCreateInfo m_vertexInputStateParams; 1005 VkPipelineInputAssemblyStateCreateInfo m_inputAssemblyStateParams; 1006 VkViewport m_viewport; 1007 VkRect2D m_scissor; 1008 VkPipelineViewportStateCreateInfo m_viewportStateParams; 1009 VkPipelineRasterizationStateCreateInfo m_rasterStateParams; 1010 VkPipelineColorBlendAttachmentState m_colorBlendAttachmentState; 1011 VkPipelineColorBlendStateCreateInfo m_colorBlendStateParams; 1012 VkPipelineMultisampleStateCreateInfo m_multisampleStateParams; 1013 VkPipelineDepthStencilStateCreateInfo m_depthStencilStateParams; 1014 }; 1015 1016 class PipelineCacheComputeTest : public TestCase 1017 { 1018 public: 1019 PipelineCacheComputeTest (TestContext& testCtx, 1020 const string& name, 1021 const string& description) 1022 :TestCase (testCtx, name, description) 1023 { 1024 } 1025 1026 void initPrograms (SourceCollections& programCollection) const 1027 { 1028 ostringstream buffer; 1029 buffer << "layout(set = 0, binding = 0, std430) buffer Output\n" 1030 << "{\n" 1031 << " int result[];\n" 1032 << "} sb_out;\n"; 1033 { 1034 ostringstream src; 1035 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 1036 << "\n" 1037 << "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 1038 << "\n" 1039 << buffer.str() 1040 << "void main (void)\n" 1041 << "{\n" 1042 << " highp uint ndx = gl_GlobalInvocationID.x;\n" 1043 << " sb_out.result[ndx] = int(ndx);\n" 1044 << "}\n"; 1045 programCollection.glslSources.add("compute_0") << glu::ComputeSource(src.str()); 1046 } 1047 { 1048 ostringstream src; 1049 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 1050 << "\n" 1051 << "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n" 1052 << "\n" 1053 << buffer.str() 1054 << "void main (void)\n" 1055 << "{\n" 1056 << " for (highp uint ndx = 0u; ndx < "<<BUFFER_ELEMENT_COUNT<<"u; ndx++)\n" 1057 << " {\n" 1058 << " sb_out.result[ndx] = int(ndx);\n" 1059 << " }\n" 1060 << "}\n"; 1061 programCollection.glslSources.add("compute_1") << glu::ComputeSource(src.str()); 1062 } 1063 { 1064 ostringstream src; 1065 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES) << "\n" 1066 << "\n" 1067 << "layout(local_size_x = "<<BUFFER_ELEMENT_COUNT<<", local_size_y = 1, local_size_z = 1) in;\n" 1068 << "\n" 1069 << buffer.str() 1070 << "void main (void)\n" 1071 << "{\n" 1072 << " highp uint ndx = gl_LocalInvocationID.x;\n" 1073 << " sb_out.result[ndx] = int(ndx);\n" 1074 << "}\n"; 1075 programCollection.glslSources.add("compute_2") << glu::ComputeSource(src.str()); 1076 } 1077 } 1078 1079 TestInstance* createInstance (Context& context) const 1080 { 1081 vector<deUint32> shadersExecutions; 1082 shadersExecutions.push_back(16u); //compute_0 1083 shadersExecutions.push_back(1u); //compute_1 1084 shadersExecutions.push_back(1u); //compute_2 1085 return new PipelineCacheComputeTestInstance(context, shadersExecutions); 1086 } 1087 }; 1088 1089 class PipelineCacheGraphicTest : public TestCase 1090 { 1091 public: 1092 PipelineCacheGraphicTest (TestContext& testCtx, 1093 const string& name, 1094 const string& description) 1095 :TestCase (testCtx, name, description) 1096 { 1097 1098 } 1099 1100 void initPrograms (SourceCollections& programCollection) const 1101 { 1102 ostringstream buffer; 1103 buffer << "layout(set = 0, binding = 0, std430) buffer Output\n" 1104 << "{\n" 1105 << " int result[];\n" 1106 << "} sb_out;\n"; 1107 1108 // Vertex 1109 { 1110 std::ostringstream src; 1111 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n" 1112 << "\n" 1113 << buffer.str() 1114 << "\n" 1115 << "void main (void)\n" 1116 << "{\n" 1117 << " sb_out.result[gl_VertexIndex] = int(gl_VertexIndex);\n" 1118 << "}\n"; 1119 programCollection.glslSources.add("vert_0") << glu::VertexSource(src.str()); 1120 } 1121 // Vertex 1122 { 1123 std::ostringstream src; 1124 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n" 1125 << "\n" 1126 << buffer.str() 1127 << "\n" 1128 << "void main (void)\n" 1129 << "{\n" 1130 << " for (highp uint ndx = 0u; ndx < "<<BUFFER_ELEMENT_COUNT<<"u; ndx++)\n" 1131 << " {\n" 1132 << " sb_out.result[ndx] = int(ndx);\n" 1133 << " }\n" 1134 << "}\n"; 1135 programCollection.glslSources.add("vert_1") << glu::VertexSource(src.str()); 1136 } 1137 // Vertex 1138 { 1139 std::ostringstream src; 1140 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n" 1141 << "\n" 1142 << buffer.str() 1143 << "\n" 1144 << "void main (void)\n" 1145 << "{\n" 1146 << " for (int ndx = "<<BUFFER_ELEMENT_COUNT-1<<"; ndx >= 0; ndx--)\n" 1147 << " {\n" 1148 << " sb_out.result[uint(ndx)] = ndx;\n" 1149 << " }\n" 1150 << "}\n"; 1151 programCollection.glslSources.add("vert_2") << glu::VertexSource(src.str()); 1152 } 1153 // Fragment 1154 { 1155 std::ostringstream src; 1156 src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_440) << "\n" 1157 << "\n" 1158 << "layout(location = 0) out vec4 o_color;\n" 1159 << "\n" 1160 << "void main (void)\n" 1161 << "{\n" 1162 << " o_color = vec4(1.0);\n" 1163 << "}\n"; 1164 programCollection.glslSources.add("frag") << glu::FragmentSource(src.str()); 1165 } 1166 } 1167 1168 TestInstance* createInstance (Context& context) const 1169 { 1170 vector<deUint32> shadersExecutions; 1171 shadersExecutions.push_back(16u); //vert_0 1172 shadersExecutions.push_back(1u); //vert_1 1173 shadersExecutions.push_back(1u); //vert_2 1174 return new PipelineCacheGraphicTestInstance(context, shadersExecutions); 1175 } 1176 }; 1177 1178 1179 } // anonymous 1180 1181 tcu::TestCaseGroup* createInternallySynchronizedObjects (tcu::TestContext& testCtx) 1182 { 1183 de::MovePtr<tcu::TestCaseGroup> tests(new tcu::TestCaseGroup(testCtx, "internally_synchronized_objects", "Internally synchronized objects")); 1184 tests->addChild(new PipelineCacheComputeTest(testCtx, "pipeline_cache_compute", "Internally synchronized object VkPipelineCache for compute pipeline is tested")); 1185 tests->addChild(new PipelineCacheGraphicTest(testCtx, "pipeline_cache_graphics", "Internally synchronized object VkPipelineCache for graphics pipeline is tested")); 1186 return tests.release(); 1187 } 1188 1189 } // synchronization 1190 } // vkt 1191
