external/vulkancts/modules/vulkan/synchronization/vktSynchronizationCrossInstanceSharingTests.cpp

   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 tests for resources shared between instances.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktSynchronizationCrossInstanceSharingTests.hpp"
  25
  26 #include "vkDeviceUtil.hpp"
  27 #include "vkPlatform.hpp"
  28
  29 #include "vktTestCaseUtil.hpp"
  30
  31 #include "vktSynchronizationUtil.hpp"
  32 #include "vktSynchronizationOperation.hpp"
  33 #include "vktSynchronizationOperationTestData.hpp"
  34 #include "vktSynchronizationOperationResources.hpp"
  35 #include "vktExternalMemoryUtil.hpp"
  36
  37 #include "tcuResultCollector.hpp"
  38 #include "tcuTestLog.hpp"
  39
  40 using tcu::TestLog;
  41 using namespace vkt::ExternalMemoryUtil;
  42
  43 namespace vkt
  44 {
  45 namespace synchronization
  46 {
  47 namespace
  48 {
  49
  50 struct TestConfig
  51 {
  52                                                                 TestConfig              (const ResourceDescription&                                             resource_,
  53                                                                                                  OperationName                                                                  writeOp_,
  54                                                                                                  OperationName                                                                  readOp_,
  55                                                                                                  vk::VkExternalMemoryHandleTypeFlagBitsKHR              memoryHandleType_,
  56                                                                                                  vk::VkExternalSemaphoreHandleTypeFlagBitsKHR   semaphoreHandleType_,
  57                                                                                                  bool                                                                                   dedicated_)
  58                 : resource                              (resource_)
  59                 , writeOp                               (writeOp_)
  60                 , readOp                                (readOp_)
  61                 , memoryHandleType              (memoryHandleType_)
  62                 , semaphoreHandleType   (semaphoreHandleType_)
  63                 , dedicated                             (dedicated_)
  64         {
  65         }
  66
  67         const ResourceDescription                                                       resource;
  68         const OperationName                                                                     writeOp;
  69         const OperationName                                                                     readOp;
  70         const vk::VkExternalMemoryHandleTypeFlagBitsKHR         memoryHandleType;
  71         const vk::VkExternalSemaphoreHandleTypeFlagBitsKHR      semaphoreHandleType;
  72         const bool                                                                                      dedicated;
  73 };
  74
  75 bool checkQueueFlags (vk::VkQueueFlags availableFlags, const vk::VkQueueFlags neededFlags)
  76 {
  77         if ((availableFlags & (vk::VK_QUEUE_GRAPHICS_BIT | vk::VK_QUEUE_COMPUTE_BIT)) != 0)
  78                 availableFlags |= vk::VK_QUEUE_TRANSFER_BIT;
  79
  80         return (availableFlags & neededFlags) != 0;
  81 }
  82
  83 class SimpleAllocation : public vk::Allocation
  84 {
  85 public:
  86                                                                 SimpleAllocation        (const vk::DeviceInterface&     vkd,
  87                                                                                                          vk::VkDevice                           device,
  88                                                                                                          const vk::VkDeviceMemory       memory);
  89                                                                 ~SimpleAllocation       (void);
  90
  91 private:
  92         const vk::DeviceInterface&      m_vkd;
  93         const vk::VkDevice                      m_device;
  94 };
  95
  96 SimpleAllocation::SimpleAllocation (const vk::DeviceInterface&  vkd,
  97                                                                         vk::VkDevice                            device,
  98                                                                         const vk::VkDeviceMemory        memory)
  99         : Allocation    (memory, 0, DE_NULL)
 100         , m_vkd                 (vkd)
 101         , m_device              (device)
 102 {
 103 }
 104
 105 SimpleAllocation::~SimpleAllocation (void)
 106 {
 107         m_vkd.freeMemory(m_device, getMemory(), DE_NULL);
 108 }
 109
 110 class DeviceId
 111 {
 112 public:
 113                                         DeviceId                (deUint32               vendorId,
 114                                                                          deUint32               driverVersion,
 115                                                                          const deUint8  driverUUID[VK_UUID_SIZE],
 116                                                                          const deUint8  deviceUUID[VK_UUID_SIZE]);
 117
 118         bool                    operator==              (const DeviceId& other) const;
 119         bool                    operator|=              (const DeviceId& other) const;
 120
 121 private:
 122         const deUint32  m_vendorId;
 123         const deUint32  m_driverVersion;
 124         deUint8                 m_driverUUID[VK_UUID_SIZE];
 125         deUint8                 m_deviceUUID[VK_UUID_SIZE];
 126 };
 127
 128 DeviceId::DeviceId (deUint32            vendorId,
 129                                         deUint32                driverVersion,
 130                                         const deUint8   driverUUID[VK_UUID_SIZE],
 131                                         const deUint8   deviceUUID[VK_UUID_SIZE])
 132         : m_vendorId            (vendorId)
 133         , m_driverVersion       (driverVersion)
 134 {
 135         deMemcpy(m_driverUUID, driverUUID, sizeof(m_driverUUID));
 136         deMemcpy(m_deviceUUID, deviceUUID, sizeof(m_deviceUUID));
 137 }
 138
 139 bool DeviceId::operator== (const DeviceId& other) const
 140 {
 141         if (this == &other)
 142                 return true;
 143
 144         if (m_vendorId != other.m_vendorId)
 145                 return false;
 146
 147         if (m_driverVersion != other.m_driverVersion)
 148                 return false;
 149
 150         if (deMemCmp(m_driverUUID, other.m_driverUUID, sizeof(m_driverUUID)) != 0)
 151                 return false;
 152
 153         return deMemCmp(m_deviceUUID, other.m_deviceUUID, sizeof(m_deviceUUID)) == 0;
 154 }
 155
 156 DeviceId getDeviceId (const vk::InstanceInterface&      vki,
 157                                           vk::VkPhysicalDevice                  physicalDevice)
 158 {
 159         vk::VkPhysicalDeviceIDPropertiesKHR                     propertiesId;
 160         vk::VkPhysicalDeviceProperties2KHR                      properties;
 161
 162         deMemset(&properties, 0, sizeof(properties));
 163         deMemset(&propertiesId, 0, sizeof(propertiesId));
 164
 165         propertiesId.sType      = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR;
 166
 167         properties.sType        = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
 168         properties.pNext        = &propertiesId;
 169
 170         vki.getPhysicalDeviceProperties2KHR(physicalDevice, &properties);
 171
 172         return DeviceId(properties.properties.vendorID, properties.properties.driverVersion, propertiesId.driverUUID, propertiesId.deviceUUID);
 173 }
 174
 175 vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp)
 176 {
 177         try
 178         {
 179                 std::vector<std::string> extensions;
 180
 181                 extensions.push_back("VK_KHR_get_physical_device_properties2");
 182
 183                 extensions.push_back("VK_KHR_external_semaphore_capabilities");
 184                 extensions.push_back("VK_KHR_external_memory_capabilities");
 185
 186                 return vk::createDefaultInstance(vkp, std::vector<std::string>(), extensions);
 187         }
 188         catch (const vk::Error& error)
 189         {
 190                 if (error.getError() == vk::VK_ERROR_EXTENSION_NOT_PRESENT)
 191                         TCU_THROW(NotSupportedError, "Required external memory extensions not supported by the instance");
 192                 else
 193                         throw;
 194         }
 195 }
 196
 197 vk::VkPhysicalDevice getPhysicalDevice (const vk::InstanceInterface&    vki,
 198                                                                                 vk::VkInstance                                  instance,
 199                                                                                 const tcu::CommandLine&                 cmdLine)
 200 {
 201         return vk::chooseDevice(vki, instance, cmdLine);
 202 }
 203
 204 vk::VkPhysicalDevice getPhysicalDevice (const vk::InstanceInterface& vki, vk::VkInstance instance, const DeviceId& deviceId)
 205 {
 206         const std::vector<vk::VkPhysicalDevice> devices (vk::enumeratePhysicalDevices(vki, instance));
 207
 208         for (size_t deviceNdx = 0; deviceNdx < devices.size(); deviceNdx++)
 209         {
 210                 if (deviceId == getDeviceId(vki, devices[deviceNdx]))
 211                         return devices[deviceNdx];
 212         }
 213
 214         TCU_FAIL("No matching device found");
 215
 216         return (vk::VkPhysicalDevice)0;
 217 }
 218
 219 vk::Move<vk::VkDevice> createDevice (const vk::InstanceInterface&                                       vki,
 220                                                                          vk::VkPhysicalDevice                                                   physicalDevice,
 221                                                                          vk::VkExternalMemoryHandleTypeFlagBitsKHR              memoryHandleType,
 222                                                                          vk::VkExternalSemaphoreHandleTypeFlagBitsKHR   semaphoreHandleType,
 223                                                                          bool                                                                                   dedicated,
 224                                                                          bool                                                                               khrMemReqSupported)
 225 {
 226         const float                                                                             priority                                = 0.0f;
 227         const std::vector<vk::VkQueueFamilyProperties>  queueFamilyProperties   = vk::getPhysicalDeviceQueueFamilyProperties(vki, physicalDevice);
 228         std::vector<deUint32>                                                   queueFamilyIndices              (queueFamilyProperties.size(), 0xFFFFFFFFu);
 229         std::vector<const char*>                                                extensions;
 230
 231         if (dedicated)
 232                 extensions.push_back("VK_KHR_dedicated_allocation");
 233
 234         if (khrMemReqSupported)
 235                 extensions.push_back("VK_KHR_get_memory_requirements2");
 236
 237         extensions.push_back("VK_KHR_external_semaphore");
 238         extensions.push_back("VK_KHR_external_memory");
 239
 240         if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR
 241                 || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
 242                 || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
 243         {
 244                 extensions.push_back("VK_KHR_external_semaphore_fd");
 245                 extensions.push_back("VK_KHR_external_memory_fd");
 246         }
 247
 248         if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
 249                 || memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR
 250                 || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
 251                 || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
 252         {
 253                 extensions.push_back("VK_KHR_external_semaphore_win32");
 254                 extensions.push_back("VK_KHR_external_memory_win32");
 255         }
 256
 257         try
 258         {
 259                 std::vector<vk::VkDeviceQueueCreateInfo>        queues;
 260
 261                 for (size_t ndx = 0; ndx < queueFamilyProperties.size(); ndx++)
 262                 {
 263                         const vk::VkDeviceQueueCreateInfo       createInfo      =
 264                         {
 265                                 vk::VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
 266                                 DE_NULL,
 267                                 0u,
 268
 269                                 (deUint32)ndx,
 270                                 1u,
 271                                 &priority
 272                         };
 273
 274                         queues.push_back(createInfo);
 275                 }
 276
 277                 const vk::VkDeviceCreateInfo            createInfo                      =
 278                 {
 279                         vk::VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
 280                         DE_NULL,
 281                         0u,
 282
 283                         (deUint32)queues.size(),
 284                         &queues[0],
 285
 286                         0u,
 287                         DE_NULL,
 288
 289                         (deUint32)extensions.size(),
 290                         extensions.empty() ? DE_NULL : &extensions[0],
 291                         0u
 292                 };
 293
 294                 return vk::createDevice(vki, physicalDevice, &createInfo);
 295         }
 296         catch (const vk::Error& error)
 297         {
 298                 if (error.getError() == vk::VK_ERROR_EXTENSION_NOT_PRESENT)
 299                         TCU_THROW(NotSupportedError, "Required extensions not supported");
 300                 else
 301                         throw;
 302         }
 303 }
 304
 305 vk::VkQueue getQueue (const vk::DeviceInterface&        vkd,
 306                                           const vk::VkDevice                    device,
 307                                           deUint32                                              familyIndex)
 308 {
 309         vk::VkQueue queue;
 310
 311         vkd.getDeviceQueue(device, familyIndex, 0u, &queue);
 312
 313         return queue;
 314 }
 315
 316 vk::Move<vk::VkCommandPool> createCommandPool (const vk::DeviceInterface&       vkd,
 317                                                                                            vk::VkDevice                                 device,
 318                                                                                            deUint32                                             queueFamilyIndex)
 319 {
 320         const vk::VkCommandPoolCreateInfo       createInfo                      =
 321         {
 322                 vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
 323                 DE_NULL,
 324
 325                 0u,
 326                 queueFamilyIndex
 327         };
 328
 329         return vk::createCommandPool(vkd, device, &createInfo);
 330 }
 331
 332 vk::Move<vk::VkCommandBuffer> createCommandBuffer (const vk::DeviceInterface&   vkd,
 333                                                                                                    vk::VkDevice                                 device,
 334                                                                                                    vk::VkCommandPool                    commandPool)
 335 {
 336         const vk::VkCommandBufferLevel                  level                   = vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY;
 337         const vk::VkCommandBufferAllocateInfo   allocateInfo    =
 338         {
 339                 vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
 340                 DE_NULL,
 341
 342                 commandPool,
 343                 level,
 344                 1u
 345         };
 346
 347         return vk::allocateCommandBuffer(vkd, device, &allocateInfo);
 348 }
 349
 350 de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface&                                   vkd,
 351                                                                                                    vk::VkDevice                                                                 device,
 352                                                                                                    vk::VkBuffer                                                                 buffer,
 353                                                                                                    vk::VkExternalMemoryHandleTypeFlagBitsKHR    externalType,
 354                                                                                                    bool                                                                                 dedicated,
 355                                                                                                    bool                                                                                 getMemReq2Supported)
 356 {
 357         vk::VkMemoryRequirements memoryRequirements = { 0u, 0u, 0u, };
 358
 359         if (getMemReq2Supported)
 360         {
 361                 const vk::VkBufferMemoryRequirementsInfo2KHR    requirementInfo =
 362                 {
 363                         vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR,
 364                         DE_NULL,
 365                         buffer
 366                 };
 367                 vk::VkMemoryDedicatedRequirementsKHR                    dedicatedRequirements =
 368                 {
 369                         vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
 370                         DE_NULL,
 371                         VK_FALSE,
 372                         VK_FALSE
 373                 };
 374                 vk::VkMemoryRequirements2KHR                                    requirements =
 375                 {
 376                         vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
 377                         &dedicatedRequirements,
 378                         { 0u, 0u, 0u, }
 379                 };
 380                 vkd.getBufferMemoryRequirements2KHR(device, &requirementInfo, &requirements);
 381
 382                 if (!dedicated && dedicatedRequirements.requiresDedicatedAllocation)
 383                         TCU_THROW(NotSupportedError, "Memory requires dedicated allocation");
 384
 385                 memoryRequirements = requirements.memoryRequirements;
 386         }
 387         else
 388         {
 389                 vkd.getBufferMemoryRequirements(device, buffer, &memoryRequirements);
 390         }
 391
 392
 393         vk::Move<vk::VkDeviceMemory> memory = allocateExportableMemory(vkd, device, memoryRequirements, externalType, dedicated ? buffer : (vk::VkBuffer)0);
 394         VK_CHECK(vkd.bindBufferMemory(device, buffer, *memory, 0u));
 395
 396         return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
 397 }
 398
 399 de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface&                                   vkd,
 400                                                                                                    vk::VkDevice                                                                 device,
 401                                                                                                    vk::VkImage                                                                  image,
 402                                                                                                    vk::VkExternalMemoryHandleTypeFlagBitsKHR    externalType,
 403                                                                                                    bool                                                                                 dedicated,
 404                                                                                                    bool                                                                                 getMemReq2Supported)
 405 {
 406         vk::VkMemoryRequirements memoryRequirements = { 0u, 0u, 0u, };
 407
 408         if (getMemReq2Supported)
 409         {
 410                 const vk::VkImageMemoryRequirementsInfo2KHR     requirementInfo =
 411                 {
 412                         vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
 413                         DE_NULL,
 414                         image
 415                 };
 416                 vk::VkMemoryDedicatedRequirementsKHR                    dedicatedRequirements =
 417                 {
 418                         vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
 419                         DE_NULL,
 420                         VK_FALSE,
 421                         VK_FALSE
 422                 };
 423                 vk::VkMemoryRequirements2KHR                                    requirements =
 424                 {
 425                         vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
 426                         &dedicatedRequirements,
 427                         { 0u, 0u, 0u, }
 428                 };
 429                 vkd.getImageMemoryRequirements2KHR(device, &requirementInfo, &requirements);
 430
 431                 if (!dedicated && dedicatedRequirements.requiresDedicatedAllocation)
 432                         TCU_THROW(NotSupportedError, "Memory requires dedicated allocation");
 433         }
 434         else
 435         {
 436                 vkd.getImageMemoryRequirements(device, image, &memoryRequirements);
 437         }
 438
 439         vk::Move<vk::VkDeviceMemory> memory = allocateExportableMemory(vkd, device, memoryRequirements, externalType, dedicated ? image : (vk::VkImage)0);
 440         VK_CHECK(vkd.bindImageMemory(device, image, *memory, 0u));
 441
 442         return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
 443 }
 444
 445 de::MovePtr<Resource> createResource (const vk::DeviceInterface&                                vkd,
 446                                                                           vk::VkDevice                                                          device,
 447                                                                           const ResourceDescription&                            resourceDesc,
 448                                                                           const std::vector<deUint32>&                          queueFamilyIndices,
 449                                                                           const OperationSupport&                                       readOp,
 450                                                                           const OperationSupport&                                       writeOp,
 451                                                                           vk::VkExternalMemoryHandleTypeFlagBitsKHR     externalType,
 452                                                                           bool                                                                          dedicated,
 453                                                                           bool                                                                          getMemReq2Supported)
 454 {
 455         if (resourceDesc.type == RESOURCE_TYPE_IMAGE)
 456         {
 457                 const vk::VkExtent3D                            extent                                  =
 458                 {
 459                         (deUint32)resourceDesc.size.x(),
 460                         de::max(1u, (deUint32)resourceDesc.size.y()),
 461                         de::max(1u, (deUint32)resourceDesc.size.z())
 462                 };
 463                 const vk::VkImageSubresourceRange       subresourceRange                =
 464                 {
 465                         resourceDesc.imageAspect,
 466                         0u,
 467                         1u,
 468                         0u,
 469                         1u
 470                 };
 471                 const vk::VkImageSubresourceLayers      subresourceLayers               =
 472                 {
 473                         resourceDesc.imageAspect,
 474                         0u,
 475                         0u,
 476                         1u
 477                 };
 478                 const vk::VkExternalMemoryImageCreateInfoKHR externalInfo =
 479                 {
 480                         vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
 481                         DE_NULL,
 482                         (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
 483                 };
 484                 const vk::VkImageCreateInfo                     createInfo                              =
 485                 {
 486                         vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
 487                         &externalInfo,
 488                         0u,
 489
 490                         resourceDesc.imageType,
 491                         resourceDesc.imageFormat,
 492                         extent,
 493                         1u,
 494                         1u,
 495                         vk::VK_SAMPLE_COUNT_1_BIT,
 496                         vk::VK_IMAGE_TILING_OPTIMAL,
 497                         readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags(),
 498                         vk::VK_SHARING_MODE_EXCLUSIVE,
 499
 500                         (deUint32)queueFamilyIndices.size(),
 501                         &queueFamilyIndices[0],
 502                         vk::VK_IMAGE_LAYOUT_UNDEFINED
 503                 };
 504
 505                 vk::Move<vk::VkImage>                   image           = vk::createImage(vkd, device, &createInfo);
 506                 de::MovePtr<vk::Allocation>             allocation      = allocateAndBindMemory(vkd, device, *image, externalType, dedicated, getMemReq2Supported);
 507
 508                 return de::MovePtr<Resource>(new Resource(image, allocation, extent, resourceDesc.imageType, resourceDesc.imageFormat, subresourceRange, subresourceLayers));
 509         }
 510         else
 511         {
 512                 const vk::VkDeviceSize                                                  offset                  = 0u;
 513                 const vk::VkDeviceSize                                                  size                    = static_cast<vk::VkDeviceSize>(resourceDesc.size.x());
 514                 const vk::VkBufferUsageFlags                                    usage                   = readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags();
 515                 const vk:: VkExternalMemoryBufferCreateInfoKHR  externalInfo    =
 516                 {
 517                         vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
 518                         DE_NULL,
 519                         (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
 520                 };
 521                 const vk::VkBufferCreateInfo                                    createInfo              =
 522                 {
 523                         vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
 524                         &externalInfo,
 525                         0u,
 526
 527                         size,
 528                         usage,
 529                         vk::VK_SHARING_MODE_EXCLUSIVE,
 530                         (deUint32)queueFamilyIndices.size(),
 531                         &queueFamilyIndices[0]
 532                 };
 533                 vk::Move<vk::VkBuffer>          buffer          = vk::createBuffer(vkd, device, &createInfo);
 534                 de::MovePtr<vk::Allocation>     allocation      = allocateAndBindMemory(vkd, device, *buffer, externalType, dedicated, getMemReq2Supported);
 535
 536                 return de::MovePtr<Resource>(new Resource(resourceDesc.type, buffer, allocation, offset, size));
 537         }
 538 }
 539
 540 de::MovePtr<vk::Allocation> importAndBindMemory (const vk::DeviceInterface&                                     vkd,
 541                                                                                                  vk::VkDevice                                                           device,
 542                                                                                                  vk::VkBuffer                                                           buffer,
 543                                                                                                  NativeHandle&                                                          nativeHandle,
 544                                                                                                  vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
 545                                                                                                  bool                                                                           dedicated)
 546 {
 547         const vk::VkMemoryRequirements  requirements    = vk::getBufferMemoryRequirements(vkd, device, buffer);
 548         vk::Move<vk::VkDeviceMemory>    memory                  = dedicated
 549                                                                                                         ? importDedicatedMemory(vkd, device, buffer, requirements, externalType, nativeHandle)
 550                                                                                                         : importMemory(vkd, device, requirements, externalType, nativeHandle);
 551
 552         VK_CHECK(vkd.bindBufferMemory(device, buffer, *memory, 0u));
 553
 554         return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
 555 }
 556
 557 de::MovePtr<vk::Allocation> importAndBindMemory (const vk::DeviceInterface&                                     vkd,
 558                                                                                                  vk::VkDevice                                                           device,
 559                                                                                                  vk::VkImage                                                            image,
 560                                                                                                  NativeHandle&                                                          nativeHandle,
 561                                                                                                  vk::VkExternalMemoryHandleTypeFlagBitsKHR      externalType,
 562                                                                                                  bool                                                                           dedicated)
 563 {
 564         const vk::VkMemoryRequirements  requirements    = vk::getImageMemoryRequirements(vkd, device, image);
 565         vk::Move<vk::VkDeviceMemory>    memory                  = dedicated
 566                                                                                                         ? importDedicatedMemory(vkd, device, image, requirements, externalType, nativeHandle)
 567                                                                                                         : importMemory(vkd, device, requirements, externalType, nativeHandle);
 568         VK_CHECK(vkd.bindImageMemory(device, image, *memory, 0u));
 569
 570         return de::MovePtr<vk::Allocation>(new SimpleAllocation(vkd, device, memory.disown()));
 571 }
 572
 573 de::MovePtr<Resource> importResource (const vk::DeviceInterface&                                vkd,
 574                                                                           vk::VkDevice                                                          device,
 575                                                                           const ResourceDescription&                            resourceDesc,
 576                                                                           const std::vector<deUint32>&                          queueFamilyIndices,
 577                                                                           const OperationSupport&                                       readOp,
 578                                                                           const OperationSupport&                                       writeOp,
 579                                                                           NativeHandle&                                                         nativeHandle,
 580                                                                           vk::VkExternalMemoryHandleTypeFlagBitsKHR     externalType,
 581                                                                           bool                                                                          dedicated)
 582 {
 583         if (resourceDesc.type == RESOURCE_TYPE_IMAGE)
 584         {
 585                 const vk::VkExtent3D                            extent                                  =
 586                 {
 587                         (deUint32)resourceDesc.size.x(),
 588                         de::max(1u, (deUint32)resourceDesc.size.y()),
 589                         de::max(1u, (deUint32)resourceDesc.size.z())
 590                 };
 591                 const vk::VkImageSubresourceRange       subresourceRange                =
 592                 {
 593                         resourceDesc.imageAspect,
 594                         0u,
 595                         1u,
 596                         0u,
 597                         1u
 598                 };
 599                 const vk::VkImageSubresourceLayers      subresourceLayers               =
 600                 {
 601                         resourceDesc.imageAspect,
 602                         0u,
 603                         0u,
 604                         1u
 605                 };
 606                 const vk:: VkExternalMemoryImageCreateInfoKHR externalInfo =
 607                 {
 608                         vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
 609                         DE_NULL,
 610                         (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
 611                 };
 612                 const vk::VkImageCreateInfo                     createInfo                              =
 613                 {
 614                         vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
 615                         &externalInfo,
 616                         0u,
 617
 618                         resourceDesc.imageType,
 619                         resourceDesc.imageFormat,
 620                         extent,
 621                         1u,
 622                         1u,
 623                         vk::VK_SAMPLE_COUNT_1_BIT,
 624                         vk::VK_IMAGE_TILING_OPTIMAL,
 625                         readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags(),
 626                         vk::VK_SHARING_MODE_EXCLUSIVE,
 627
 628                         (deUint32)queueFamilyIndices.size(),
 629                         &queueFamilyIndices[0],
 630                         vk::VK_IMAGE_LAYOUT_UNDEFINED
 631                 };
 632
 633                 vk::Move<vk::VkImage>                   image           = vk::createImage(vkd, device, &createInfo);
 634                 de::MovePtr<vk::Allocation>             allocation      = importAndBindMemory(vkd, device, *image, nativeHandle, externalType, dedicated);
 635
 636                 return de::MovePtr<Resource>(new Resource(image, allocation, extent, resourceDesc.imageType, resourceDesc.imageFormat, subresourceRange, subresourceLayers));
 637         }
 638         else
 639         {
 640                 const vk::VkDeviceSize                                                  offset                  = 0u;
 641                 const vk::VkDeviceSize                                                  size                    = static_cast<vk::VkDeviceSize>(resourceDesc.size.x());
 642                 const vk::VkBufferUsageFlags                                    usage                   = readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags();
 643                 const vk:: VkExternalMemoryBufferCreateInfoKHR  externalInfo    =
 644                 {
 645                         vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
 646                         DE_NULL,
 647                         (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
 648                 };
 649                 const vk::VkBufferCreateInfo                                    createInfo              =
 650                 {
 651                         vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
 652                         &externalInfo,
 653                         0u,
 654
 655                         size,
 656                         usage,
 657                         vk::VK_SHARING_MODE_EXCLUSIVE,
 658                         (deUint32)queueFamilyIndices.size(),
 659                         &queueFamilyIndices[0]
 660                 };
 661                 vk::Move<vk::VkBuffer>          buffer          = vk::createBuffer(vkd, device, &createInfo);
 662                 de::MovePtr<vk::Allocation>     allocation      = importAndBindMemory(vkd, device, *buffer, nativeHandle, externalType, dedicated);
 663
 664                 return de::MovePtr<Resource>(new Resource(resourceDesc.type, buffer, allocation, offset, size));
 665         }
 666 }
 667
 668 void recordWriteBarrier (const vk::DeviceInterface&     vkd,
 669                                                  vk::VkCommandBuffer            commandBuffer,
 670                                                  const Resource&                        resource,
 671                                                  const SyncInfo&                        writeSync,
 672                                                  deUint32                                       writeQueueFamilyIndex,
 673                                                  const SyncInfo&                        readSync)
 674 {
 675         const vk::VkPipelineStageFlags  srcStageMask            = writeSync.stageMask;
 676         const vk::VkAccessFlags                 srcAccessMask           = writeSync.accessMask;
 677
 678         const vk::VkPipelineStageFlags  dstStageMask            = readSync.stageMask;
 679         const vk::VkAccessFlags                 dstAccessMask           = readSync.accessMask;
 680
 681         const vk::VkDependencyFlags             dependencyFlags         = 0;
 682
 683         if (resource.getType() == RESOURCE_TYPE_IMAGE)
 684         {
 685                 const vk::VkImageMemoryBarrier  barrier                         =
 686                 {
 687                         vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 688                         DE_NULL,
 689
 690                         srcAccessMask,
 691                         dstAccessMask,
 692
 693                         writeSync.imageLayout,
 694                         readSync.imageLayout,
 695
 696                         writeQueueFamilyIndex,
 697                         VK_QUEUE_FAMILY_EXTERNAL_KHR,
 698
 699                         resource.getImage().handle,
 700                         resource.getImage().subresourceRange
 701                 };
 702
 703                 vkd.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, 0u, (const vk::VkMemoryBarrier*)DE_NULL, 0u, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1u, (const vk::VkImageMemoryBarrier*)&barrier);
 704         }
 705         else
 706         {
 707                 const vk::VkBufferMemoryBarrier barrier                         =
 708                 {
 709                         vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
 710                         DE_NULL,
 711
 712                         srcAccessMask,
 713                         dstAccessMask,
 714
 715                         writeQueueFamilyIndex,
 716                         VK_QUEUE_FAMILY_EXTERNAL_KHR,
 717
 718                         resource.getBuffer().handle,
 719                         0u,
 720                         VK_WHOLE_SIZE
 721                 };
 722
 723                 vkd.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, 0u, (const vk::VkMemoryBarrier*)DE_NULL, 1u, (const vk::VkBufferMemoryBarrier*)&barrier, 0u, (const vk::VkImageMemoryBarrier*)DE_NULL);
 724         }
 725 }
 726
 727 void recordReadBarrier (const vk::DeviceInterface&      vkd,
 728                                                 vk::VkCommandBuffer                     commandBuffer,
 729                                                 const Resource&                         resource,
 730                                                 const SyncInfo&                         writeSync,
 731                                                 const SyncInfo&                         readSync,
 732                                                 deUint32                                        readQueueFamilyIndex)
 733 {
 734         const vk::VkPipelineStageFlags  srcStageMask            = readSync.stageMask;
 735         const vk::VkAccessFlags                 srcAccessMask           = readSync.accessMask;
 736
 737         const vk::VkPipelineStageFlags  dstStageMask            = readSync.stageMask;
 738         const vk::VkAccessFlags                 dstAccessMask           = readSync.accessMask;
 739
 740         const vk::VkDependencyFlags             dependencyFlags         = 0;
 741
 742         if (resource.getType() == RESOURCE_TYPE_IMAGE)
 743         {
 744                 const vk::VkImageMemoryBarrier  barrier                         =
 745                 {
 746                         vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 747                         DE_NULL,
 748
 749                         srcAccessMask,
 750                         dstAccessMask,
 751
 752                         writeSync.imageLayout,
 753                         readSync.imageLayout,
 754
 755                         VK_QUEUE_FAMILY_EXTERNAL_KHR,
 756                         readQueueFamilyIndex,
 757
 758                         resource.getImage().handle,
 759                         resource.getImage().subresourceRange
 760                 };
 761
 762                 vkd.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, 0u, (const vk::VkMemoryBarrier*)DE_NULL, 0u, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1u, (const vk::VkImageMemoryBarrier*)&barrier);
 763         }
 764         else
 765         {
 766                 const vk::VkBufferMemoryBarrier barrier                         =
 767                 {
 768                         vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
 769                         DE_NULL,
 770
 771                         srcAccessMask,
 772                         dstAccessMask,
 773
 774                         VK_QUEUE_FAMILY_EXTERNAL_KHR,
 775                         readQueueFamilyIndex,
 776
 777                         resource.getBuffer().handle,
 778                         0u,
 779                         VK_WHOLE_SIZE
 780                 };
 781
 782                 vkd.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, 0u, (const vk::VkMemoryBarrier*)DE_NULL, 1u, (const vk::VkBufferMemoryBarrier*)&barrier, 0u, (const vk::VkImageMemoryBarrier*)DE_NULL);
 783         }
 784 }
 785
 786 std::vector<deUint32> getFamilyIndices (const std::vector<vk::VkQueueFamilyProperties>& properties)
 787 {
 788         std::vector<deUint32> indices (properties.size(), 0);
 789
 790         for (deUint32 ndx = 0; ndx < properties.size(); ndx++)
 791                 indices[ndx] = ndx;
 792
 793         return indices;
 794 }
 795
 796 class SharingTestInstance : public TestInstance
 797 {
 798 public:
 799                                                                                                                 SharingTestInstance             (Context&       context,
 800                                                                                                                                                                  TestConfig     config);
 801
 802         virtual tcu::TestStatus                                                         iterate                                 (void);
 803
 804 private:
 805         const TestConfig                                                                        m_config;
 806         const de::UniquePtr<OperationSupport>                           m_supportWriteOp;
 807         const de::UniquePtr<OperationSupport>                           m_supportReadOp;
 808
 809         const vk::Unique<vk::VkInstance>                                        m_instanceA;
 810
 811         const vk::InstanceDriver                                                        m_vkiA;
 812         const vk::VkPhysicalDevice                                                      m_physicalDeviceA;
 813         const std::vector<vk::VkQueueFamilyProperties>          m_queueFamiliesA;
 814         const std::vector<deUint32>                                                     m_queueFamilyIndicesA;
 815
 816         const bool                                                                                      m_getMemReq2Supported;
 817
 818         const vk::Unique<vk::VkDevice>                                          m_deviceA;
 819         const vk::DeviceDriver                                                          m_vkdA;
 820
 821         const vk::Unique<vk::VkInstance>                                        m_instanceB;
 822         const vk::InstanceDriver                                                        m_vkiB;
 823         const vk::VkPhysicalDevice                                                      m_physicalDeviceB;
 824         const std::vector<vk::VkQueueFamilyProperties>          m_queueFamiliesB;
 825         const std::vector<deUint32>                                                     m_queueFamilyIndicesB;
 826         const vk::Unique<vk::VkDevice>                                          m_deviceB;
 827         const vk::DeviceDriver                                                          m_vkdB;
 828
 829         const vk::VkExternalSemaphoreHandleTypeFlagBitsKHR      m_semaphoreHandleType;
 830         const vk::VkExternalMemoryHandleTypeFlagBitsKHR         m_memoryHandleType;
 831
 832         // \todo Should this be moved to the group same way as in the other tests?
 833         PipelineCacheData                                                                       m_pipelineCacheData;
 834         tcu::ResultCollector                                                            m_resultCollector;
 835         size_t                                                                                          m_queueANdx;
 836         size_t                                                                                          m_queueBNdx;
 837 };
 838
 839 SharingTestInstance::SharingTestInstance (Context&              context,
 840                                                                                   TestConfig    config)
 841         : TestInstance                          (context)
 842         , m_config                                      (config)
 843         , m_supportWriteOp                      (makeOperationSupport(config.writeOp, config.resource))
 844         , m_supportReadOp                       (makeOperationSupport(config.readOp, config.resource))
 845
 846         , m_instanceA                           (createInstance(context.getPlatformInterface()))
 847
 848         , m_vkiA                                        (context.getPlatformInterface(), *m_instanceA)
 849         , m_physicalDeviceA                     (getPhysicalDevice(m_vkiA, *m_instanceA, context.getTestContext().getCommandLine()))
 850         , m_queueFamiliesA                      (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiA, m_physicalDeviceA))
 851         , m_queueFamilyIndicesA         (getFamilyIndices(m_queueFamiliesA))
 852         , m_getMemReq2Supported         (de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_KHR_get_memory_requirements2"))
 853         , m_deviceA                                     (createDevice(m_vkiA, m_physicalDeviceA, m_config.memoryHandleType, m_config.semaphoreHandleType, m_config.dedicated, m_getMemReq2Supported))
 854         , m_vkdA                                        (m_vkiA, *m_deviceA)
 855
 856         , m_instanceB                           (createInstance(context.getPlatformInterface()))
 857
 858         , m_vkiB                                        (context.getPlatformInterface(), *m_instanceB)
 859         , m_physicalDeviceB                     (getPhysicalDevice(m_vkiB, *m_instanceB, getDeviceId(m_vkiA, m_physicalDeviceA)))
 860         , m_queueFamiliesB                      (vk::getPhysicalDeviceQueueFamilyProperties(m_vkiB, m_physicalDeviceB))
 861         , m_queueFamilyIndicesB         (getFamilyIndices(m_queueFamiliesB))
 862         , m_deviceB                                     (createDevice(m_vkiB, m_physicalDeviceB, m_config.memoryHandleType, m_config.semaphoreHandleType, m_config.dedicated, m_getMemReq2Supported))
 863         , m_vkdB                                        (m_vkiB, *m_deviceB)
 864
 865         , m_semaphoreHandleType         (m_config.semaphoreHandleType)
 866         , m_memoryHandleType            (m_config.memoryHandleType)
 867
 868         , m_resultCollector                     (context.getTestContext().getLog())
 869         , m_queueANdx                           (0)
 870         , m_queueBNdx                           (0)
 871 {
 872         TestLog& log = m_context.getTestContext().getLog();
 873
 874         // Check resource support
 875         if (m_config.resource.type == RESOURCE_TYPE_IMAGE)
 876         {
 877                 const vk::VkPhysicalDeviceExternalImageFormatInfoKHR    externalInfo            =
 878                 {
 879                         vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
 880                         DE_NULL,
 881                         m_memoryHandleType
 882                 };
 883                 const vk::VkPhysicalDeviceImageFormatInfo2KHR   imageFormatInfo         =
 884                 {
 885                         vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
 886                         &externalInfo,
 887                         m_config.resource.imageFormat,
 888                         m_config.resource.imageType,
 889                         vk::VK_IMAGE_TILING_OPTIMAL,
 890                         m_supportReadOp->getResourceUsageFlags() | m_supportWriteOp->getResourceUsageFlags(),
 891                         0u
 892                 };
 893                 vk::VkExternalImageFormatPropertiesKHR                  externalProperties      =
 894                 {
 895                         vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
 896                         DE_NULL,
 897                         { 0u, 0u, 0u }
 898                 };
 899                 vk::VkImageFormatProperties2KHR                                 formatProperties        =
 900                 {
 901                         vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
 902                         &externalProperties,
 903                         {
 904                                 { 0u, 0u, 0u },
 905                                 0u,
 906                                 0u,
 907                                 0u,
 908                                 0u,
 909                         }
 910                 };
 911
 912                 {
 913                         const vk::VkResult res = m_vkiA.getPhysicalDeviceImageFormatProperties2KHR(m_physicalDeviceA, &imageFormatInfo, &formatProperties);
 914
 915                         if (res == vk::VK_ERROR_FORMAT_NOT_SUPPORTED)
 916                                 TCU_THROW(NotSupportedError, "Image format not supported");
 917
 918                         VK_CHECK(res); // Check other errors
 919                 }
 920
 921                 log << TestLog::Message << "External image format properties: " << imageFormatInfo << "\n"<< externalProperties << TestLog::EndMessage;
 922
 923                 if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0)
 924                         TCU_THROW(NotSupportedError, "Exporting image resource not supported");
 925
 926                 if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
 927                         TCU_THROW(NotSupportedError, "Importing image resource not supported");
 928         }
 929         else
 930         {
 931                 const vk::VkPhysicalDeviceExternalBufferInfoKHR info    =
 932                 {
 933                         vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
 934                         DE_NULL,
 935
 936                         0u,
 937                         m_supportReadOp->getResourceUsageFlags() | m_supportWriteOp->getResourceUsageFlags(),
 938                         m_memoryHandleType
 939                 };
 940                 vk::VkExternalBufferPropertiesKHR                               properties                      =
 941                 {
 942                         vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
 943                         DE_NULL,
 944                         { 0u, 0u, 0u}
 945                 };
 946                 m_vkiA.getPhysicalDeviceExternalBufferPropertiesKHR(m_physicalDeviceA, &info, &properties);
 947
 948                 log << TestLog::Message << "External buffer properties: " << info << "\n" << properties << TestLog::EndMessage;
 949
 950                 if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0
 951                                 || (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
 952                         TCU_THROW(NotSupportedError, "Exporting and importing memory type not supported");
 953         }
 954
 955         // Check semaphore support
 956         {
 957                 const vk::VkPhysicalDeviceExternalSemaphoreInfoKHR      info            =
 958                 {
 959                         vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
 960                         DE_NULL,
 961                         m_semaphoreHandleType
 962                 };
 963                 vk::VkExternalSemaphorePropertiesKHR                            properties;
 964
 965                 m_vkiA.getPhysicalDeviceExternalSemaphorePropertiesKHR(m_physicalDeviceA, &info, &properties);
 966
 967                 log << TestLog::Message << info << "\n" << properties << TestLog::EndMessage;
 968
 969                 if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR) == 0
 970                                 || (properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR) == 0)
 971                         TCU_THROW(NotSupportedError, "Exporting and importing semaphore type not supported");
 972         }
 973 }
 974
 975 tcu::TestStatus SharingTestInstance::iterate (void)
 976 {
 977         TestLog&                                                                log                                     (m_context.getTestContext().getLog());
 978
 979         const deUint32                                                  queueFamilyA            = (deUint32)m_queueANdx;
 980         const deUint32                                                  queueFamilyB            = (deUint32)m_queueBNdx;
 981
 982         const tcu::ScopedLogSection                             queuePairSection        (log,
 983                                                                                                                                         "WriteQueue-" + de::toString(queueFamilyA) + "-ReadQueue-" + de::toString(queueFamilyB),
 984                                                                                                                                         "WriteQueue-" + de::toString(queueFamilyA) + "-ReadQueue-" + de::toString(queueFamilyB));
 985
 986         const vk::Unique<vk::VkSemaphore>               semaphoreA                      (createExportableSemaphore(m_vkdA, *m_deviceA, m_semaphoreHandleType));
 987         const vk::Unique<vk::VkSemaphore>               semaphoreB                      (createSemaphore(m_vkdB, *m_deviceB));
 988
 989         const de::UniquePtr<Resource>                   resourceA                       (createResource(m_vkdA, *m_deviceA, m_config.resource, m_queueFamilyIndicesA, *m_supportReadOp, *m_supportWriteOp, m_memoryHandleType, m_config.dedicated, m_getMemReq2Supported));
 990
 991         NativeHandle                                                    nativeMemoryHandle;
 992         getMemoryNative(m_vkdA, *m_deviceA, resourceA->getMemory(), m_memoryHandleType, nativeMemoryHandle);
 993
 994         const de::UniquePtr<Resource>                   resourceB                       (importResource(m_vkdB, *m_deviceB, m_config.resource, m_queueFamilyIndicesB, *m_supportReadOp, *m_supportWriteOp, nativeMemoryHandle, m_memoryHandleType, m_config.dedicated));
 995
 996         try
 997         {
 998                 const vk::VkQueue                                               queueA                          (getQueue(m_vkdA, *m_deviceA, queueFamilyA));
 999                 const vk::Unique<vk::VkCommandPool>             commandPoolA            (createCommandPool(m_vkdA, *m_deviceA, queueFamilyA));
1000                 const vk::Unique<vk::VkCommandBuffer>   commandBufferA          (createCommandBuffer(m_vkdA, *m_deviceA, *commandPoolA));
1001                 vk::SimpleAllocator                                             allocatorA                      (m_vkdA, *m_deviceA, vk::getPhysicalDeviceMemoryProperties(m_vkiA, m_physicalDeviceA));
1002                 const std::vector<std::string>                  deviceExtensionsA;
1003                 OperationContext                                                operationContextA       (m_vkiA, m_vkdA, m_physicalDeviceA, *m_deviceA, allocatorA, deviceExtensionsA, m_context.getBinaryCollection(), m_pipelineCacheData);
1004
1005                 if (!checkQueueFlags(m_queueFamiliesA[m_queueANdx].queueFlags , m_supportWriteOp->getQueueFlags(operationContextA)))
1006                         TCU_THROW(NotSupportedError, "Operation not supported by the source queue");
1007
1008                 const vk::VkQueue                                               queueB                          (getQueue(m_vkdB, *m_deviceB, queueFamilyB));
1009                 const vk::Unique<vk::VkCommandPool>             commandPoolB            (createCommandPool(m_vkdB, *m_deviceB, queueFamilyB));
1010                 const vk::Unique<vk::VkCommandBuffer>   commandBufferB          (createCommandBuffer(m_vkdB, *m_deviceB, *commandPoolB));
1011                 vk::SimpleAllocator                                             allocatorB                      (m_vkdB, *m_deviceB, vk::getPhysicalDeviceMemoryProperties(m_vkiB, m_physicalDeviceB));
1012                 const std::vector<std::string>                  deviceExtensionsB;
1013                 OperationContext                                                operationContextB       (m_vkiB, m_vkdB, m_physicalDeviceB, *m_deviceB, allocatorB, deviceExtensionsB, m_context.getBinaryCollection(), m_pipelineCacheData);
1014
1015                 if (!checkQueueFlags(m_queueFamiliesB[m_queueBNdx].queueFlags , m_supportReadOp->getQueueFlags(operationContextB)))
1016                         TCU_THROW(NotSupportedError, "Operation not supported by the destination queue");
1017
1018                 const de::UniquePtr<Operation>                  writeOp                         (m_supportWriteOp->build(operationContextA, *resourceA));
1019                 const de::UniquePtr<Operation>                  readOp                          (m_supportReadOp->build(operationContextB, *resourceB));
1020
1021                 const SyncInfo                                                  writeSync                       = writeOp->getSyncInfo();
1022                 const SyncInfo                                                  readSync                        = readOp->getSyncInfo();
1023
1024                 beginCommandBuffer(m_vkdA, *commandBufferA);
1025                 writeOp->recordCommands(*commandBufferA);
1026                 recordWriteBarrier(m_vkdA, *commandBufferA, *resourceA, writeSync, queueFamilyA, readSync);
1027                 endCommandBuffer(m_vkdA, *commandBufferA);
1028
1029                 beginCommandBuffer(m_vkdB, *commandBufferB);
1030                 recordReadBarrier(m_vkdB, *commandBufferB, *resourceB, writeSync, readSync, queueFamilyB);
1031                 readOp->recordCommands(*commandBufferB);
1032                 endCommandBuffer(m_vkdB, *commandBufferB);
1033
1034                 {
1035                         const vk::VkCommandBuffer       commandBuffer   = *commandBufferA;
1036                         const vk::VkSemaphore           semaphore               = *semaphoreA;
1037                         const vk::VkSubmitInfo          submitInfo              =
1038                         {
1039                                 vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
1040                                 DE_NULL,
1041
1042                                 0u,
1043                                 DE_NULL,
1044                                 DE_NULL,
1045
1046                                 1u,
1047                                 &commandBuffer,
1048                                 1u,
1049                                 &semaphore
1050                         };
1051
1052                         VK_CHECK(m_vkdA.queueSubmit(queueA, 1u, &submitInfo, DE_NULL));
1053
1054                         {
1055                                 NativeHandle    nativeSemaphoreHandle;
1056
1057                                 getSemaphoreNative(m_vkdA, *m_deviceA, *semaphoreA, m_semaphoreHandleType, nativeSemaphoreHandle);
1058                                 importSemaphore(m_vkdB, *m_deviceB, *semaphoreB, m_semaphoreHandleType, nativeSemaphoreHandle, 0u);
1059                         }
1060                 }
1061                 {
1062                         const vk::VkCommandBuffer               commandBuffer   = *commandBufferB;
1063                         const vk::VkSemaphore                   semaphore               = *semaphoreB;
1064                         const vk::VkPipelineStageFlags  dstStage                = readSync.stageMask;
1065                         const vk::VkSubmitInfo                  submitInfo              =
1066                         {
1067                                 vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
1068                                 DE_NULL,
1069
1070                                 1u,
1071                                 &semaphore,
1072                                 &dstStage,
1073
1074                                 1u,
1075                                 &commandBuffer,
1076                                 0u,
1077                                 DE_NULL,
1078                         };
1079
1080                         VK_CHECK(m_vkdB.queueSubmit(queueB, 1u, &submitInfo, DE_NULL));
1081                 }
1082
1083                 VK_CHECK(m_vkdA.queueWaitIdle(queueA));
1084                 VK_CHECK(m_vkdB.queueWaitIdle(queueB));
1085
1086                 {
1087                         const Data      expected        = writeOp->getData();
1088                         const Data      actual          = readOp->getData();
1089
1090                         DE_ASSERT(expected.size == actual.size);
1091
1092                         if (0 != deMemCmp(expected.data, actual.data, expected.size))
1093                         {
1094                                 const size_t            maxBytesLogged  = 256;
1095                                 std::ostringstream      expectedData;
1096                                 std::ostringstream      actualData;
1097                                 size_t                          byteNdx                 = 0;
1098
1099                                 // Find first byte difference
1100                                 for (; actual.data[byteNdx] == expected.data[byteNdx]; byteNdx++)
1101                                 {
1102                                         // Nothing
1103                                 }
1104
1105                                 log << TestLog::Message << "First different byte at offset: " << byteNdx << TestLog::EndMessage;
1106
1107                                 // Log 8 previous bytes before the first incorrect byte
1108                                 if (byteNdx > 8)
1109                                 {
1110                                         expectedData << "... ";
1111                                         actualData << "... ";
1112
1113                                         byteNdx -= 8;
1114                                 }
1115                                 else
1116                                         byteNdx = 0;
1117
1118                                 for (size_t i = 0; i < maxBytesLogged && byteNdx < expected.size; i++, byteNdx++)
1119                                 {
1120                                         expectedData << (i > 0 ? ", " : "") << (deUint32)expected.data[byteNdx];
1121                                         actualData << (i > 0 ? ", " : "") << (deUint32)actual.data[byteNdx];
1122                                 }
1123
1124                                 if (expected.size > byteNdx)
1125                                 {
1126                                         expectedData << "...";
1127                                         actualData << "...";
1128                                 }
1129
1130                                 log << TestLog::Message << "Expected data: (" << expectedData.str() << ")" << TestLog::EndMessage;
1131                                 log << TestLog::Message << "Actual data: (" << actualData.str() << ")" << TestLog::EndMessage;
1132
1133                                 m_resultCollector.fail("Memory contents don't match");
1134                         }
1135                 }
1136         }
1137         catch (const tcu::NotSupportedError& error)
1138         {
1139                 log << TestLog::Message << "Not supported: " << error.getMessage() << TestLog::EndMessage;
1140         }
1141         catch (const tcu::TestError& error)
1142         {
1143                 m_resultCollector.fail(std::string("Exception: ") + error.getMessage());
1144         }
1145
1146         // Move to next queue
1147         {
1148                 m_queueBNdx++;
1149
1150                 if (m_queueBNdx >= m_queueFamiliesB.size())
1151                 {
1152                         m_queueANdx++;
1153
1154                         if (m_queueANdx >= m_queueFamiliesA.size())
1155                         {
1156                                 return tcu::TestStatus(m_resultCollector.getResult(), m_resultCollector.getMessage());
1157                         }
1158                         else
1159                         {
1160                                 m_queueBNdx = 0;
1161
1162                                 return tcu::TestStatus::incomplete();
1163                         }
1164                 }
1165                 else
1166                         return tcu::TestStatus::incomplete();
1167         }
1168 }
1169
1170 struct Progs
1171 {
1172         void init (vk::SourceCollections& dst, TestConfig config) const
1173         {
1174                 const de::UniquePtr<OperationSupport>   readOp  (makeOperationSupport(config.readOp, config.resource));
1175                 const de::UniquePtr<OperationSupport>   writeOp (makeOperationSupport(config.writeOp, config.resource));
1176
1177                 readOp->initPrograms(dst);
1178                 writeOp->initPrograms(dst);
1179         }
1180 };
1181
1182 } // anonymous
1183
1184 tcu::TestCaseGroup* createCrossInstanceSharingTest (tcu::TestContext& testCtx)
1185 {
1186         const struct
1187         {
1188                 vk::VkExternalMemoryHandleTypeFlagBitsKHR               memoryType;
1189                 vk::VkExternalSemaphoreHandleTypeFlagBitsKHR    semaphoreType;
1190                 const char*                                                                             nameSuffix;
1191         } cases[] =
1192         {
1193                 {
1194                         vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
1195                         vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
1196                         "_fd"
1197                 },
1198                 {
1199                         vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
1200                         vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR,
1201                         "_fence_fd"
1202                 },
1203                 {
1204                         vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
1205                         vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
1206                         "_win32_kmt"
1207                 },
1208                 {
1209                         vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
1210                         vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
1211                         "_win32"
1212                 },
1213         };
1214         de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "cross_instance", ""));
1215
1216         for (size_t dedicatedNdx = 0; dedicatedNdx < 2; dedicatedNdx++)
1217         {
1218                 const bool                                              dedicated               (dedicatedNdx == 1);
1219                 de::MovePtr<tcu::TestCaseGroup> dedicatedGroup  (new tcu::TestCaseGroup(testCtx, dedicated ? "dedicated" : "suballocated", ""));
1220
1221                 for (size_t writeOpNdx = 0; writeOpNdx < DE_LENGTH_OF_ARRAY(s_writeOps); ++writeOpNdx)
1222                 for (size_t readOpNdx = 0; readOpNdx < DE_LENGTH_OF_ARRAY(s_readOps); ++readOpNdx)
1223                 {
1224                         const OperationName     writeOp         = s_writeOps[writeOpNdx];
1225                         const OperationName     readOp          = s_readOps[readOpNdx];
1226                         const std::string       opGroupName     = getOperationName(writeOp) + "_" + getOperationName(readOp);
1227                         bool                            empty           = true;
1228
1229                         de::MovePtr<tcu::TestCaseGroup> opGroup (new tcu::TestCaseGroup(testCtx, opGroupName.c_str(), ""));
1230
1231                         for (size_t resourceNdx = 0; resourceNdx < DE_LENGTH_OF_ARRAY(s_resources); ++resourceNdx)
1232                         {
1233                                 const ResourceDescription&      resource        = s_resources[resourceNdx];
1234
1235                                 for (size_t caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++)
1236                                 {
1237                                         std::string     name= getResourceName(resource) + cases[caseNdx].nameSuffix;
1238
1239                                         if (isResourceSupported(writeOp, resource) && isResourceSupported(readOp, resource))
1240                                         {
1241                                                 const TestConfig config (resource, writeOp, readOp, cases[caseNdx].memoryType, cases[caseNdx].semaphoreType, dedicated);
1242
1243                                                 opGroup->addChild(new InstanceFactory1<SharingTestInstance, TestConfig, Progs>(testCtx, tcu::NODETYPE_SELF_VALIDATE,  name, "", Progs(), config));
1244                                                 empty = false;
1245                                         }
1246                                 }
1247                         }
1248
1249                         if (!empty)
1250                                 dedicatedGroup->addChild(opGroup.release());
1251                 }
1252
1253                 group->addChild(dedicatedGroup.release());
1254         }
1255
1256         return group.release();
1257 }
1258
1259 } // synchronization
1260 } // vkt