tests/vktestbinding.cpp

   1 /*
   2  * Copyright (c) 2015-2016 The Khronos Group Inc.
   3  * Copyright (c) 2015-2016 Valve Corporation
   4  * Copyright (c) 2015-2016 LunarG, Inc.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
  19  * Author: Tony Barbour <tony@LunarG.com>
  20  */
  21
  22 #include "test_common.h"    // NOEXCEPT macro (must precede vktestbinding.h)
  23 #include "vktestbinding.h"  // Left for clarity, no harm, already included via test_common.h
  24 #include <algorithm>
  25 #include <assert.h>
  26 #include <iostream>
  27 #include <stdarg.h>
  28 #include <string.h>  // memset(), memcmp()
  29
  30 namespace {
  31
  32 #define NON_DISPATCHABLE_HANDLE_INIT(create_func, dev, ...)                              \
  33     do {                                                                                 \
  34         handle_type handle;                                                              \
  35         if (EXPECT(create_func(dev.handle(), __VA_ARGS__, NULL, &handle) == VK_SUCCESS)) \
  36             NonDispHandle::init(dev.handle(), handle);                                   \
  37     } while (0)
  38
  39 #define NON_DISPATCHABLE_HANDLE_DTOR(cls, destroy_func)            \
  40     cls::~cls() {                                                  \
  41         if (initialized()) destroy_func(device(), handle(), NULL); \
  42     }
  43
  44 #define STRINGIFY(x) #x
  45 #define EXPECT(expr) ((expr) ? true : expect_failure(STRINGIFY(expr), __FILE__, __LINE__, __FUNCTION__))
  46
  47 vk_testing::ErrorCallback error_callback;
  48
  49 bool expect_failure(const char *expr, const char *file, unsigned int line, const char *function) {
  50     if (error_callback) {
  51         error_callback(expr, file, line, function);
  52     } else {
  53         std::cerr << file << ":" << line << ": " << function << ": Expectation `" << expr << "' failed.\n";
  54     }
  55
  56     return false;
  57 }
  58
  59 }  // namespace
  60
  61 namespace vk_testing {
  62
  63 void set_error_callback(ErrorCallback callback) { error_callback = callback; }
  64
  65 VkPhysicalDeviceProperties PhysicalDevice::properties() const {
  66     VkPhysicalDeviceProperties info;
  67
  68     vkGetPhysicalDeviceProperties(handle(), &info);
  69
  70     return info;
  71 }
  72
  73 std::vector<VkQueueFamilyProperties> PhysicalDevice::queue_properties() const {
  74     std::vector<VkQueueFamilyProperties> info;
  75     uint32_t count;
  76
  77     // Call once with NULL data to receive count
  78     vkGetPhysicalDeviceQueueFamilyProperties(handle(), &count, NULL);
  79     info.resize(count);
  80     vkGetPhysicalDeviceQueueFamilyProperties(handle(), &count, info.data());
  81
  82     return info;
  83 }
  84
  85 VkPhysicalDeviceMemoryProperties PhysicalDevice::memory_properties() const {
  86     VkPhysicalDeviceMemoryProperties info;
  87
  88     vkGetPhysicalDeviceMemoryProperties(handle(), &info);
  89
  90     return info;
  91 }
  92
  93 VkPhysicalDeviceFeatures PhysicalDevice::features() const {
  94     VkPhysicalDeviceFeatures features;
  95     vkGetPhysicalDeviceFeatures(handle(), &features);
  96     return features;
  97 }
  98
  99 /*
 100  * Return list of Global layers available
 101  */
 102 std::vector<VkLayerProperties> GetGlobalLayers() {
 103     VkResult err;
 104     std::vector<VkLayerProperties> layers;
 105     uint32_t layer_count;
 106
 107     do {
 108         layer_count = 0;
 109         err = vkEnumerateInstanceLayerProperties(&layer_count, NULL);
 110
 111         if (err == VK_SUCCESS) {
 112             layers.reserve(layer_count);
 113             err = vkEnumerateInstanceLayerProperties(&layer_count, layers.data());
 114         }
 115     } while (err == VK_INCOMPLETE);
 116
 117     assert(err == VK_SUCCESS);
 118
 119     return layers;
 120 }
 121
 122 /*
 123  * Return list of Global extensions provided by the ICD / Loader
 124  */
 125 std::vector<VkExtensionProperties> GetGlobalExtensions() { return GetGlobalExtensions(NULL); }
 126
 127 /*
 128  * Return list of Global extensions provided by the specified layer
 129  * If pLayerName is NULL, will return extensions implemented by the loader /
 130  * ICDs
 131  */
 132 std::vector<VkExtensionProperties> GetGlobalExtensions(const char *pLayerName) {
 133     std::vector<VkExtensionProperties> exts;
 134     uint32_t ext_count;
 135     VkResult err;
 136
 137     do {
 138         ext_count = 0;
 139         err = vkEnumerateInstanceExtensionProperties(pLayerName, &ext_count, NULL);
 140
 141         if (err == VK_SUCCESS) {
 142             exts.resize(ext_count);
 143             err = vkEnumerateInstanceExtensionProperties(pLayerName, &ext_count, exts.data());
 144         }
 145     } while (err == VK_INCOMPLETE);
 146
 147     assert(err == VK_SUCCESS);
 148
 149     return exts;
 150 }
 151
 152 /*
 153  * Return list of PhysicalDevice extensions provided by the ICD / Loader
 154  */
 155 std::vector<VkExtensionProperties> PhysicalDevice::extensions() const { return extensions(NULL); }
 156
 157 /*
 158  * Return list of PhysicalDevice extensions provided by the specified layer
 159  * If pLayerName is NULL, will return extensions for ICD / loader.
 160  */
 161 std::vector<VkExtensionProperties> PhysicalDevice::extensions(const char *pLayerName) const {
 162     std::vector<VkExtensionProperties> exts;
 163     VkResult err;
 164
 165     do {
 166         uint32_t extCount = 0;
 167         err = vkEnumerateDeviceExtensionProperties(handle(), pLayerName, &extCount, NULL);
 168
 169         if (err == VK_SUCCESS) {
 170             exts.resize(extCount);
 171             err = vkEnumerateDeviceExtensionProperties(handle(), pLayerName, &extCount, exts.data());
 172         }
 173     } while (err == VK_INCOMPLETE);
 174
 175     assert(err == VK_SUCCESS);
 176
 177     return exts;
 178 }
 179
 180 bool PhysicalDevice::set_memory_type(const uint32_t type_bits, VkMemoryAllocateInfo *info, const VkFlags properties,
 181                                      const VkFlags forbid) const {
 182     uint32_t type_mask = type_bits;
 183     // Search memtypes to find first index with those properties
 184     for (uint32_t i = 0; i < memory_properties_.memoryTypeCount; i++) {
 185         if ((type_mask & 1) == 1) {
 186             // Type is available, does it match user properties?
 187             if ((memory_properties_.memoryTypes[i].propertyFlags & properties) == properties &&
 188                 (memory_properties_.memoryTypes[i].propertyFlags & forbid) == 0) {
 189                 info->memoryTypeIndex = i;
 190                 return true;
 191             }
 192         }
 193         type_mask >>= 1;
 194     }
 195     // No memory types matched, return failure
 196     return false;
 197 }
 198
 199 /*
 200  * Return list of PhysicalDevice layers
 201  */
 202 std::vector<VkLayerProperties> PhysicalDevice::layers() const {
 203     std::vector<VkLayerProperties> layer_props;
 204     VkResult err;
 205
 206     do {
 207         uint32_t layer_count = 0;
 208         err = vkEnumerateDeviceLayerProperties(handle(), &layer_count, NULL);
 209
 210         if (err == VK_SUCCESS) {
 211             layer_props.reserve(layer_count);
 212             err = vkEnumerateDeviceLayerProperties(handle(), &layer_count, layer_props.data());
 213         }
 214     } while (err == VK_INCOMPLETE);
 215
 216     assert(err == VK_SUCCESS);
 217
 218     return layer_props;
 219 }
 220
 221 QueueCreateInfoArray::QueueCreateInfoArray(const std::vector<VkQueueFamilyProperties> &queue_props)
 222     : queue_info_(), queue_priorities_() {
 223     queue_info_.reserve(queue_props.size());
 224
 225     for (uint32_t i = 0; i < (uint32_t)queue_props.size(); ++i) {
 226         if (queue_props[i].queueCount > 0) {
 227             VkDeviceQueueCreateInfo qi = {};
 228             qi.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
 229             qi.pNext = NULL;
 230             qi.queueFamilyIndex = i;
 231             qi.queueCount = queue_props[i].queueCount;
 232             queue_priorities_.emplace_back(qi.queueCount, 0.0f);
 233             qi.pQueuePriorities = queue_priorities_[i].data();
 234             queue_info_.push_back(qi);
 235         }
 236     }
 237 }
 238
 239 Device::~Device() {
 240     if (!initialized()) return;
 241
 242     vkDestroyDevice(handle(), NULL);
 243 }
 244
 245 void Device::init(std::vector<const char *> &extensions, VkPhysicalDeviceFeatures *features, VkPhysicalDeviceFeatures2 *features2) {
 246     // request all queues
 247     const std::vector<VkQueueFamilyProperties> queue_props = phy_.queue_properties();
 248     QueueCreateInfoArray queue_info(phy_.queue_properties());
 249     for (uint32_t i = 0; i < (uint32_t)queue_props.size(); i++) {
 250         if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
 251             graphics_queue_node_index_ = i;
 252         }
 253     }
 254     // Only request creation with queuefamilies that have at least one queue
 255     std::vector<VkDeviceQueueCreateInfo> create_queue_infos;
 256     auto qci = queue_info.data();
 257     for (uint32_t j = 0; j < queue_info.size(); ++j) {
 258         if (qci[j].queueCount) {
 259             create_queue_infos.push_back(qci[j]);
 260         }
 261     }
 262
 263     enabled_extensions_ = extensions;
 264
 265     VkDeviceCreateInfo dev_info = {};
 266     dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
 267     dev_info.pNext = NULL;
 268     dev_info.queueCreateInfoCount = create_queue_infos.size();
 269     dev_info.pQueueCreateInfos = create_queue_infos.data();
 270     dev_info.enabledLayerCount = 0;
 271     dev_info.ppEnabledLayerNames = NULL;
 272     dev_info.enabledExtensionCount = extensions.size();
 273     dev_info.ppEnabledExtensionNames = extensions.data();
 274
 275     VkPhysicalDeviceFeatures all_features;
 276     // Let VkPhysicalDeviceFeatures2 take priority over VkPhysicalDeviceFeatures,
 277     // since it supports extensions
 278     if (features2) {
 279         dev_info.pNext = features2;
 280     } else if (features) {
 281         dev_info.pEnabledFeatures = features;
 282     } else {
 283         // request all supportable features enabled
 284         all_features = phy().features();
 285         dev_info.pEnabledFeatures = &all_features;
 286     }
 287
 288     init(dev_info);
 289 }
 290
 291 void Device::init(const VkDeviceCreateInfo &info) {
 292     VkDevice dev;
 293
 294     if (EXPECT(vkCreateDevice(phy_.handle(), &info, NULL, &dev) == VK_SUCCESS)) Handle::init(dev);
 295
 296     init_queues();
 297     init_formats();
 298 }
 299
 300 void Device::init_queues() {
 301     uint32_t queue_node_count;
 302
 303     // Call with NULL data to get count
 304     vkGetPhysicalDeviceQueueFamilyProperties(phy_.handle(), &queue_node_count, NULL);
 305     EXPECT(queue_node_count >= 1);
 306
 307     VkQueueFamilyProperties *queue_props = new VkQueueFamilyProperties[queue_node_count];
 308
 309     vkGetPhysicalDeviceQueueFamilyProperties(phy_.handle(), &queue_node_count, queue_props);
 310
 311     queue_families_.resize(queue_node_count);
 312     for (uint32_t i = 0; i < queue_node_count; i++) {
 313         VkQueue queue;
 314
 315         QueueFamilyQueues &queue_storage = queue_families_[i];
 316         queue_storage.reserve(queue_props[i].queueCount);
 317         for (uint32_t j = 0; j < queue_props[i].queueCount; j++) {
 318             // TODO: Need to add support for separate MEMMGR and work queues,
 319             // including synchronization
 320             vkGetDeviceQueue(handle(), i, j, &queue);
 321
 322             // Store single copy of the queue object that will self destruct
 323             queue_storage.emplace_back(new Queue(queue, i));
 324
 325             if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
 326                 queues_[GRAPHICS].push_back(queue_storage.back().get());
 327             }
 328
 329             if (queue_props[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
 330                 queues_[COMPUTE].push_back(queue_storage.back().get());
 331             }
 332
 333             if (queue_props[i].queueFlags & VK_QUEUE_TRANSFER_BIT) {
 334                 queues_[DMA].push_back(queue_storage.back().get());
 335             }
 336         }
 337     }
 338
 339     delete[] queue_props;
 340
 341     EXPECT(!queues_[GRAPHICS].empty() || !queues_[COMPUTE].empty());
 342 }
 343 const Device::QueueFamilyQueues &Device::queue_family_queues(uint32_t queue_family) const {
 344     assert(queue_family < queue_families_.size());
 345     return queue_families_[queue_family];
 346 }
 347
 348 void Device::init_formats() {
 349     for (int f = VK_FORMAT_BEGIN_RANGE; f <= VK_FORMAT_END_RANGE; f++) {
 350         const VkFormat fmt = static_cast<VkFormat>(f);
 351         const VkFormatProperties props = format_properties(fmt);
 352
 353         if (props.linearTilingFeatures) {
 354             const Format tmp = {fmt, VK_IMAGE_TILING_LINEAR, props.linearTilingFeatures};
 355             formats_.push_back(tmp);
 356         }
 357
 358         if (props.optimalTilingFeatures) {
 359             const Format tmp = {fmt, VK_IMAGE_TILING_OPTIMAL, props.optimalTilingFeatures};
 360             formats_.push_back(tmp);
 361         }
 362     }
 363
 364     EXPECT(!formats_.empty());
 365 }
 366
 367 bool Device::IsEnbledExtension(const char *extension) {
 368     const auto is_x = [&extension](const char *enabled_extension) { return strcmp(extension, enabled_extension) == 0; };
 369     return std::any_of(enabled_extensions_.begin(), enabled_extensions_.end(), is_x);
 370 }
 371
 372 VkFormatProperties Device::format_properties(VkFormat format) {
 373     VkFormatProperties data;
 374     vkGetPhysicalDeviceFormatProperties(phy().handle(), format, &data);
 375
 376     return data;
 377 }
 378
 379 void Device::wait() { EXPECT(vkDeviceWaitIdle(handle()) == VK_SUCCESS); }
 380
 381 VkResult Device::wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout) {
 382     const std::vector<VkFence> fence_handles = MakeVkHandles<VkFence>(fences);
 383     VkResult err = vkWaitForFences(handle(), fence_handles.size(), fence_handles.data(), wait_all, timeout);
 384     EXPECT(err == VK_SUCCESS || err == VK_TIMEOUT);
 385
 386     return err;
 387 }
 388
 389 void Device::update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes,
 390                                     const std::vector<VkCopyDescriptorSet> &copies) {
 391     vkUpdateDescriptorSets(handle(), writes.size(), writes.data(), copies.size(), copies.data());
 392 }
 393
 394 VkResult Queue::submit(const std::vector<const CommandBuffer *> &cmds, const Fence &fence, bool expect_success) {
 395     const std::vector<VkCommandBuffer> cmd_handles = MakeVkHandles<VkCommandBuffer>(cmds);
 396     VkSubmitInfo submit_info;
 397     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 398     submit_info.pNext = NULL;
 399     submit_info.waitSemaphoreCount = 0;
 400     submit_info.pWaitSemaphores = NULL;
 401     submit_info.pWaitDstStageMask = NULL;
 402     submit_info.commandBufferCount = (uint32_t)cmd_handles.size();
 403     submit_info.pCommandBuffers = cmd_handles.data();
 404     submit_info.signalSemaphoreCount = 0;
 405     submit_info.pSignalSemaphores = NULL;
 406
 407     VkResult result = vkQueueSubmit(handle(), 1, &submit_info, fence.handle());
 408     if (expect_success) EXPECT(result == VK_SUCCESS);
 409     return result;
 410 }
 411
 412 VkResult Queue::submit(const CommandBuffer &cmd, const Fence &fence, bool expect_success) {
 413     return submit(std::vector<const CommandBuffer *>(1, &cmd), fence, expect_success);
 414 }
 415
 416 VkResult Queue::submit(const CommandBuffer &cmd, bool expect_success) {
 417     Fence fence;
 418     return submit(cmd, fence);
 419 }
 420
 421 VkResult Queue::wait() {
 422     VkResult result = vkQueueWaitIdle(handle());
 423     EXPECT(result == VK_SUCCESS);
 424     return result;
 425 }
 426
 427 DeviceMemory::~DeviceMemory() {
 428     if (initialized()) vkFreeMemory(device(), handle(), NULL);
 429 }
 430
 431 void DeviceMemory::init(const Device &dev, const VkMemoryAllocateInfo &info) {
 432     NON_DISPATCHABLE_HANDLE_INIT(vkAllocateMemory, dev, &info);
 433 }
 434
 435 const void *DeviceMemory::map(VkFlags flags) const {
 436     void *data;
 437     if (!EXPECT(vkMapMemory(device(), handle(), 0, VK_WHOLE_SIZE, flags, &data) == VK_SUCCESS)) data = NULL;
 438
 439     return data;
 440 }
 441
 442 void *DeviceMemory::map(VkFlags flags) {
 443     void *data;
 444     if (!EXPECT(vkMapMemory(device(), handle(), 0, VK_WHOLE_SIZE, flags, &data) == VK_SUCCESS)) data = NULL;
 445
 446     return data;
 447 }
 448
 449 void DeviceMemory::unmap() const { vkUnmapMemory(device(), handle()); }
 450
 451 VkMemoryAllocateInfo DeviceMemory::get_resource_alloc_info(const Device &dev, const VkMemoryRequirements &reqs,
 452                                                            VkMemoryPropertyFlags mem_props) {
 453     // Find appropriate memory type for given reqs
 454     VkPhysicalDeviceMemoryProperties dev_mem_props = dev.phy().memory_properties();
 455     uint32_t mem_type_index = 0;
 456     for (mem_type_index = 0; mem_type_index < dev_mem_props.memoryTypeCount; ++mem_type_index) {
 457         if (mem_props == (mem_props & dev_mem_props.memoryTypes[mem_type_index].propertyFlags)) break;
 458     }
 459     // If we exceeded types, then this device doesn't have the memory we need
 460     assert(mem_type_index < dev_mem_props.memoryTypeCount);
 461     VkMemoryAllocateInfo info = alloc_info(reqs.size, mem_type_index);
 462     EXPECT(dev.phy().set_memory_type(reqs.memoryTypeBits, &info, mem_props));
 463     return info;
 464 }
 465
 466 NON_DISPATCHABLE_HANDLE_DTOR(Fence, vkDestroyFence)
 467
 468 void Fence::init(const Device &dev, const VkFenceCreateInfo &info) { NON_DISPATCHABLE_HANDLE_INIT(vkCreateFence, dev, &info); }
 469
 470 VkResult Fence::wait(VkBool32 wait_all, uint64_t timeout) const {
 471     VkFence fence = handle();
 472     return vkWaitForFences(device(), 1, &fence, wait_all, timeout);
 473 }
 474
 475 NON_DISPATCHABLE_HANDLE_DTOR(Semaphore, vkDestroySemaphore)
 476
 477 void Semaphore::init(const Device &dev, const VkSemaphoreCreateInfo &info) {
 478     NON_DISPATCHABLE_HANDLE_INIT(vkCreateSemaphore, dev, &info);
 479 }
 480
 481 NON_DISPATCHABLE_HANDLE_DTOR(Event, vkDestroyEvent)
 482
 483 void Event::init(const Device &dev, const VkEventCreateInfo &info) { NON_DISPATCHABLE_HANDLE_INIT(vkCreateEvent, dev, &info); }
 484
 485 void Event::set() { EXPECT(vkSetEvent(device(), handle()) == VK_SUCCESS); }
 486
 487 void Event::reset() { EXPECT(vkResetEvent(device(), handle()) == VK_SUCCESS); }
 488
 489 NON_DISPATCHABLE_HANDLE_DTOR(QueryPool, vkDestroyQueryPool)
 490
 491 void QueryPool::init(const Device &dev, const VkQueryPoolCreateInfo &info) {
 492     NON_DISPATCHABLE_HANDLE_INIT(vkCreateQueryPool, dev, &info);
 493 }
 494
 495 VkResult QueryPool::results(uint32_t first, uint32_t count, size_t size, void *data, size_t stride) {
 496     VkResult err = vkGetQueryPoolResults(device(), handle(), first, count, size, data, stride, 0);
 497     EXPECT(err == VK_SUCCESS || err == VK_NOT_READY);
 498
 499     return err;
 500 }
 501
 502 NON_DISPATCHABLE_HANDLE_DTOR(Buffer, vkDestroyBuffer)
 503
 504 void Buffer::init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags mem_props) {
 505     init_no_mem(dev, info);
 506
 507     internal_mem_.init(dev, DeviceMemory::get_resource_alloc_info(dev, memory_requirements(), mem_props));
 508     bind_memory(internal_mem_, 0);
 509 }
 510
 511 void Buffer::init_no_mem(const Device &dev, const VkBufferCreateInfo &info) {
 512     NON_DISPATCHABLE_HANDLE_INIT(vkCreateBuffer, dev, &info);
 513     create_info_ = info;
 514 }
 515
 516 VkMemoryRequirements Buffer::memory_requirements() const {
 517     VkMemoryRequirements reqs;
 518
 519     vkGetBufferMemoryRequirements(device(), handle(), &reqs);
 520
 521     return reqs;
 522 }
 523
 524 void Buffer::bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset) {
 525     EXPECT(vkBindBufferMemory(device(), handle(), mem.handle(), mem_offset) == VK_SUCCESS);
 526 }
 527
 528 NON_DISPATCHABLE_HANDLE_DTOR(BufferView, vkDestroyBufferView)
 529
 530 void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info) {
 531     NON_DISPATCHABLE_HANDLE_INIT(vkCreateBufferView, dev, &info);
 532 }
 533
 534 NON_DISPATCHABLE_HANDLE_DTOR(Image, vkDestroyImage)
 535
 536 void Image::init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags mem_props) {
 537     init_no_mem(dev, info);
 538
 539     if (initialized()) {
 540         internal_mem_.init(dev, DeviceMemory::get_resource_alloc_info(dev, memory_requirements(), mem_props));
 541         bind_memory(internal_mem_, 0);
 542     }
 543 }
 544
 545 void Image::init_no_mem(const Device &dev, const VkImageCreateInfo &info) {
 546     NON_DISPATCHABLE_HANDLE_INIT(vkCreateImage, dev, &info);
 547     if (initialized()) {
 548         init_info(dev, info);
 549     }
 550 }
 551
 552 void Image::init_info(const Device &dev, const VkImageCreateInfo &info) {
 553     create_info_ = info;
 554
 555     for (std::vector<Device::Format>::const_iterator it = dev.formats().begin(); it != dev.formats().end(); it++) {
 556         if (memcmp(&it->format, &create_info_.format, sizeof(it->format)) == 0 && it->tiling == create_info_.tiling) {
 557             format_features_ = it->features;
 558             break;
 559         }
 560     }
 561 }
 562
 563 VkMemoryRequirements Image::memory_requirements() const {
 564     VkMemoryRequirements reqs;
 565
 566     vkGetImageMemoryRequirements(device(), handle(), &reqs);
 567
 568     return reqs;
 569 }
 570
 571 void Image::bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset) {
 572     EXPECT(vkBindImageMemory(device(), handle(), mem.handle(), mem_offset) == VK_SUCCESS);
 573 }
 574
 575 VkSubresourceLayout Image::subresource_layout(const VkImageSubresource &subres) const {
 576     VkSubresourceLayout data;
 577     size_t size = sizeof(data);
 578     vkGetImageSubresourceLayout(device(), handle(), &subres, &data);
 579     if (size != sizeof(data)) memset(&data, 0, sizeof(data));
 580
 581     return data;
 582 }
 583
 584 VkSubresourceLayout Image::subresource_layout(const VkImageSubresourceLayers &subrescopy) const {
 585     VkSubresourceLayout data;
 586     VkImageSubresource subres = subresource(subrescopy.aspectMask, subrescopy.mipLevel, subrescopy.baseArrayLayer);
 587     size_t size = sizeof(data);
 588     vkGetImageSubresourceLayout(device(), handle(), &subres, &data);
 589     if (size != sizeof(data)) memset(&data, 0, sizeof(data));
 590
 591     return data;
 592 }
 593
 594 bool Image::transparent() const {
 595     return (create_info_.tiling == VK_IMAGE_TILING_LINEAR && create_info_.samples == VK_SAMPLE_COUNT_1_BIT &&
 596             !(create_info_.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)));
 597 }
 598
 599 NON_DISPATCHABLE_HANDLE_DTOR(ImageView, vkDestroyImageView)
 600
 601 void ImageView::init(const Device &dev, const VkImageViewCreateInfo &info) {
 602     NON_DISPATCHABLE_HANDLE_INIT(vkCreateImageView, dev, &info);
 603 }
 604
 605 NON_DISPATCHABLE_HANDLE_DTOR(ShaderModule, vkDestroyShaderModule)
 606
 607 void ShaderModule::init(const Device &dev, const VkShaderModuleCreateInfo &info) {
 608     NON_DISPATCHABLE_HANDLE_INIT(vkCreateShaderModule, dev, &info);
 609 }
 610
 611 VkResult ShaderModule::init_try(const Device &dev, const VkShaderModuleCreateInfo &info) {
 612     VkShaderModule mod;
 613
 614     VkResult err = vkCreateShaderModule(dev.handle(), &info, NULL, &mod);
 615     if (err == VK_SUCCESS) NonDispHandle::init(dev.handle(), mod);
 616
 617     return err;
 618 }
 619
 620 NON_DISPATCHABLE_HANDLE_DTOR(Pipeline, vkDestroyPipeline)
 621
 622 void Pipeline::init(const Device &dev, const VkGraphicsPipelineCreateInfo &info) {
 623     VkPipelineCache cache;
 624     VkPipelineCacheCreateInfo ci;
 625     memset((void *)&ci, 0, sizeof(VkPipelineCacheCreateInfo));
 626     ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 627     VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
 628     if (err == VK_SUCCESS) {
 629         NON_DISPATCHABLE_HANDLE_INIT(vkCreateGraphicsPipelines, dev, cache, 1, &info);
 630         vkDestroyPipelineCache(dev.handle(), cache, NULL);
 631     }
 632 }
 633
 634 VkResult Pipeline::init_try(const Device &dev, const VkGraphicsPipelineCreateInfo &info) {
 635     VkPipeline pipe;
 636     VkPipelineCache cache;
 637     VkPipelineCacheCreateInfo ci;
 638     memset((void *)&ci, 0, sizeof(VkPipelineCacheCreateInfo));
 639     ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 640     VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
 641     EXPECT(err == VK_SUCCESS);
 642     if (err == VK_SUCCESS) {
 643         err = vkCreateGraphicsPipelines(dev.handle(), cache, 1, &info, NULL, &pipe);
 644         if (err == VK_SUCCESS) {
 645             NonDispHandle::init(dev.handle(), pipe);
 646         }
 647         vkDestroyPipelineCache(dev.handle(), cache, NULL);
 648     }
 649
 650     return err;
 651 }
 652
 653 void Pipeline::init(const Device &dev, const VkComputePipelineCreateInfo &info) {
 654     VkPipelineCache cache;
 655     VkPipelineCacheCreateInfo ci;
 656     memset((void *)&ci, 0, sizeof(VkPipelineCacheCreateInfo));
 657     ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 658     VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
 659     if (err == VK_SUCCESS) {
 660         NON_DISPATCHABLE_HANDLE_INIT(vkCreateComputePipelines, dev, cache, 1, &info);
 661         vkDestroyPipelineCache(dev.handle(), cache, NULL);
 662     }
 663 }
 664
 665 NON_DISPATCHABLE_HANDLE_DTOR(PipelineLayout, vkDestroyPipelineLayout)
 666
 667 void PipelineLayout::init(const Device &dev, VkPipelineLayoutCreateInfo &info,
 668                           const std::vector<const DescriptorSetLayout *> &layouts) {
 669     const std::vector<VkDescriptorSetLayout> layout_handles = MakeVkHandles<VkDescriptorSetLayout>(layouts);
 670     info.setLayoutCount = layout_handles.size();
 671     info.pSetLayouts = layout_handles.data();
 672
 673     NON_DISPATCHABLE_HANDLE_INIT(vkCreatePipelineLayout, dev, &info);
 674 }
 675
 676 NON_DISPATCHABLE_HANDLE_DTOR(Sampler, vkDestroySampler)
 677
 678 void Sampler::init(const Device &dev, const VkSamplerCreateInfo &info) {
 679     NON_DISPATCHABLE_HANDLE_INIT(vkCreateSampler, dev, &info);
 680 }
 681
 682 NON_DISPATCHABLE_HANDLE_DTOR(DescriptorSetLayout, vkDestroyDescriptorSetLayout)
 683
 684 void DescriptorSetLayout::init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info) {
 685     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDescriptorSetLayout, dev, &info);
 686 }
 687
 688 NON_DISPATCHABLE_HANDLE_DTOR(DescriptorPool, vkDestroyDescriptorPool)
 689
 690 void DescriptorPool::init(const Device &dev, const VkDescriptorPoolCreateInfo &info) {
 691     setDynamicUsage(info.flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT);
 692     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDescriptorPool, dev, &info);
 693 }
 694
 695 void DescriptorPool::reset() { EXPECT(vkResetDescriptorPool(device(), handle(), 0) == VK_SUCCESS); }
 696
 697 std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev,
 698                                                         const std::vector<const DescriptorSetLayout *> &layouts) {
 699     const std::vector<VkDescriptorSetLayout> layout_handles = MakeVkHandles<VkDescriptorSetLayout>(layouts);
 700
 701     std::vector<VkDescriptorSet> set_handles;
 702     set_handles.resize(layout_handles.size());
 703
 704     VkDescriptorSetAllocateInfo alloc_info = {};
 705     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
 706     alloc_info.descriptorSetCount = layout_handles.size();
 707     alloc_info.descriptorPool = handle();
 708     alloc_info.pSetLayouts = layout_handles.data();
 709     VkResult err = vkAllocateDescriptorSets(device(), &alloc_info, set_handles.data());
 710     EXPECT(err == VK_SUCCESS);
 711
 712     std::vector<DescriptorSet *> sets;
 713     for (std::vector<VkDescriptorSet>::const_iterator it = set_handles.begin(); it != set_handles.end(); it++) {
 714         // do descriptor sets need memories bound?
 715         DescriptorSet *descriptorSet = new DescriptorSet(dev, this, *it);
 716         sets.push_back(descriptorSet);
 717     }
 718     return sets;
 719 }
 720
 721 std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, const DescriptorSetLayout &layout, uint32_t count) {
 722     return alloc_sets(dev, std::vector<const DescriptorSetLayout *>(count, &layout));
 723 }
 724
 725 DescriptorSet *DescriptorPool::alloc_sets(const Device &dev, const DescriptorSetLayout &layout) {
 726     std::vector<DescriptorSet *> set = alloc_sets(dev, layout, 1);
 727     return (set.empty()) ? NULL : set[0];
 728 }
 729
 730 DescriptorSet::~DescriptorSet() {
 731     if (initialized()) {
 732         // Only call vkFree* on sets allocated from pool with usage *_DYNAMIC
 733         if (containing_pool_->getDynamicUsage()) {
 734             VkDescriptorSet sets[1] = {handle()};
 735             EXPECT(vkFreeDescriptorSets(device(), containing_pool_->GetObj(), 1, sets) == VK_SUCCESS);
 736         }
 737     }
 738 }
 739
 740 NON_DISPATCHABLE_HANDLE_DTOR(CommandPool, vkDestroyCommandPool)
 741
 742 void CommandPool::init(const Device &dev, const VkCommandPoolCreateInfo &info) {
 743     NON_DISPATCHABLE_HANDLE_INIT(vkCreateCommandPool, dev, &info);
 744 }
 745
 746 CommandBuffer::~CommandBuffer() {
 747     if (initialized()) {
 748         VkCommandBuffer cmds[] = {handle()};
 749         vkFreeCommandBuffers(dev_handle_, cmd_pool_, 1, cmds);
 750     }
 751 }
 752
 753 void CommandBuffer::init(const Device &dev, const VkCommandBufferAllocateInfo &info) {
 754     VkCommandBuffer cmd;
 755
 756     // Make sure commandPool is set
 757     assert(info.commandPool);
 758
 759     if (EXPECT(vkAllocateCommandBuffers(dev.handle(), &info, &cmd) == VK_SUCCESS)) {
 760         Handle::init(cmd);
 761         dev_handle_ = dev.handle();
 762         cmd_pool_ = info.commandPool;
 763     }
 764 }
 765
 766 void CommandBuffer::begin(const VkCommandBufferBeginInfo *info) { EXPECT(vkBeginCommandBuffer(handle(), info) == VK_SUCCESS); }
 767
 768 void CommandBuffer::begin() {
 769     VkCommandBufferBeginInfo info = {};
 770     VkCommandBufferInheritanceInfo hinfo = {};
 771     info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 772     info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 773     info.pInheritanceInfo = &hinfo;
 774     hinfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
 775     hinfo.pNext = NULL;
 776     hinfo.renderPass = VK_NULL_HANDLE;
 777     hinfo.subpass = 0;
 778     hinfo.framebuffer = VK_NULL_HANDLE;
 779     hinfo.occlusionQueryEnable = VK_FALSE;
 780     hinfo.queryFlags = 0;
 781     hinfo.pipelineStatistics = 0;
 782
 783     begin(&info);
 784 }
 785
 786 void CommandBuffer::end() { EXPECT(vkEndCommandBuffer(handle()) == VK_SUCCESS); }
 787
 788 void CommandBuffer::reset(VkCommandBufferResetFlags flags) { EXPECT(vkResetCommandBuffer(handle(), flags) == VK_SUCCESS); }
 789
 790 }  // namespace vk_testing