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) {
 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     if (features) {
 277         dev_info.pEnabledFeatures = features;
 278     } else {
 279         // request all supportable features enabled
 280         all_features = phy().features();
 281         dev_info.pEnabledFeatures = &all_features;
 282     }
 283
 284     init(dev_info);
 285 }
 286
 287 void Device::init(const VkDeviceCreateInfo &info) {
 288     VkDevice dev;
 289
 290     if (EXPECT(vkCreateDevice(phy_.handle(), &info, NULL, &dev) == VK_SUCCESS)) Handle::init(dev);
 291
 292     init_queues();
 293     init_formats();
 294 }
 295
 296 void Device::init_queues() {
 297     uint32_t queue_node_count;
 298
 299     // Call with NULL data to get count
 300     vkGetPhysicalDeviceQueueFamilyProperties(phy_.handle(), &queue_node_count, NULL);
 301     EXPECT(queue_node_count >= 1);
 302
 303     VkQueueFamilyProperties *queue_props = new VkQueueFamilyProperties[queue_node_count];
 304
 305     vkGetPhysicalDeviceQueueFamilyProperties(phy_.handle(), &queue_node_count, queue_props);
 306
 307     queue_families_.resize(queue_node_count);
 308     for (uint32_t i = 0; i < queue_node_count; i++) {
 309         VkQueue queue;
 310
 311         QueueFamilyQueues &queue_storage = queue_families_[i];
 312         queue_storage.reserve(queue_props[i].queueCount);
 313         for (uint32_t j = 0; j < queue_props[i].queueCount; j++) {
 314             // TODO: Need to add support for separate MEMMGR and work queues,
 315             // including synchronization
 316             vkGetDeviceQueue(handle(), i, j, &queue);
 317
 318             // Store single copy of the queue object that will self destruct
 319             queue_storage.emplace_back(new Queue(queue, i));
 320
 321             if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
 322                 queues_[GRAPHICS].push_back(queue_storage.back().get());
 323             }
 324
 325             if (queue_props[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
 326                 queues_[COMPUTE].push_back(queue_storage.back().get());
 327             }
 328
 329             if (queue_props[i].queueFlags & VK_QUEUE_TRANSFER_BIT) {
 330                 queues_[DMA].push_back(queue_storage.back().get());
 331             }
 332         }
 333     }
 334
 335     delete[] queue_props;
 336
 337     EXPECT(!queues_[GRAPHICS].empty() || !queues_[COMPUTE].empty());
 338 }
 339 const Device::QueueFamilyQueues &Device::queue_family_queues(uint32_t queue_family) const {
 340     assert(queue_family < queue_families_.size());
 341     return queue_families_[queue_family];
 342 }
 343
 344 void Device::init_formats() {
 345     for (int f = VK_FORMAT_BEGIN_RANGE; f <= VK_FORMAT_END_RANGE; f++) {
 346         const VkFormat fmt = static_cast<VkFormat>(f);
 347         const VkFormatProperties props = format_properties(fmt);
 348
 349         if (props.linearTilingFeatures) {
 350             const Format tmp = {fmt, VK_IMAGE_TILING_LINEAR, props.linearTilingFeatures};
 351             formats_.push_back(tmp);
 352         }
 353
 354         if (props.optimalTilingFeatures) {
 355             const Format tmp = {fmt, VK_IMAGE_TILING_OPTIMAL, props.optimalTilingFeatures};
 356             formats_.push_back(tmp);
 357         }
 358     }
 359
 360     EXPECT(!formats_.empty());
 361 }
 362
 363 bool Device::IsEnbledExtension(const char *extension) {
 364     const auto is_x = [&extension](const char *enabled_extension) { return strcmp(extension, enabled_extension) == 0; };
 365     return std::any_of(enabled_extensions_.begin(), enabled_extensions_.end(), is_x);
 366 }
 367
 368 VkFormatProperties Device::format_properties(VkFormat format) {
 369     VkFormatProperties data;
 370     vkGetPhysicalDeviceFormatProperties(phy().handle(), format, &data);
 371
 372     return data;
 373 }
 374
 375 void Device::wait() { EXPECT(vkDeviceWaitIdle(handle()) == VK_SUCCESS); }
 376
 377 VkResult Device::wait(const std::vector<const Fence *> &fences, bool wait_all, uint64_t timeout) {
 378     const std::vector<VkFence> fence_handles = MakeVkHandles<VkFence>(fences);
 379     VkResult err = vkWaitForFences(handle(), fence_handles.size(), fence_handles.data(), wait_all, timeout);
 380     EXPECT(err == VK_SUCCESS || err == VK_TIMEOUT);
 381
 382     return err;
 383 }
 384
 385 void Device::update_descriptor_sets(const std::vector<VkWriteDescriptorSet> &writes,
 386                                     const std::vector<VkCopyDescriptorSet> &copies) {
 387     vkUpdateDescriptorSets(handle(), writes.size(), writes.data(), copies.size(), copies.data());
 388 }
 389
 390 VkResult Queue::submit(const std::vector<const CommandBuffer *> &cmds, const Fence &fence, bool expect_success) {
 391     const std::vector<VkCommandBuffer> cmd_handles = MakeVkHandles<VkCommandBuffer>(cmds);
 392     VkSubmitInfo submit_info;
 393     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 394     submit_info.pNext = NULL;
 395     submit_info.waitSemaphoreCount = 0;
 396     submit_info.pWaitSemaphores = NULL;
 397     submit_info.pWaitDstStageMask = NULL;
 398     submit_info.commandBufferCount = (uint32_t)cmd_handles.size();
 399     submit_info.pCommandBuffers = cmd_handles.data();
 400     submit_info.signalSemaphoreCount = 0;
 401     submit_info.pSignalSemaphores = NULL;
 402
 403     VkResult result = vkQueueSubmit(handle(), 1, &submit_info, fence.handle());
 404     if (expect_success) EXPECT(result == VK_SUCCESS);
 405     return result;
 406 }
 407
 408 VkResult Queue::submit(const CommandBuffer &cmd, const Fence &fence, bool expect_success) {
 409     return submit(std::vector<const CommandBuffer *>(1, &cmd), fence, expect_success);
 410 }
 411
 412 VkResult Queue::submit(const CommandBuffer &cmd, bool expect_success) {
 413     Fence fence;
 414     return submit(cmd, fence);
 415 }
 416
 417 VkResult Queue::wait() {
 418     VkResult result = vkQueueWaitIdle(handle());
 419     EXPECT(result == VK_SUCCESS);
 420     return result;
 421 }
 422
 423 DeviceMemory::~DeviceMemory() {
 424     if (initialized()) vkFreeMemory(device(), handle(), NULL);
 425 }
 426
 427 void DeviceMemory::init(const Device &dev, const VkMemoryAllocateInfo &info) {
 428     NON_DISPATCHABLE_HANDLE_INIT(vkAllocateMemory, dev, &info);
 429 }
 430
 431 const void *DeviceMemory::map(VkFlags flags) const {
 432     void *data;
 433     if (!EXPECT(vkMapMemory(device(), handle(), 0, VK_WHOLE_SIZE, flags, &data) == VK_SUCCESS)) data = NULL;
 434
 435     return data;
 436 }
 437
 438 void *DeviceMemory::map(VkFlags flags) {
 439     void *data;
 440     if (!EXPECT(vkMapMemory(device(), handle(), 0, VK_WHOLE_SIZE, flags, &data) == VK_SUCCESS)) data = NULL;
 441
 442     return data;
 443 }
 444
 445 void DeviceMemory::unmap() const { vkUnmapMemory(device(), handle()); }
 446
 447 VkMemoryAllocateInfo DeviceMemory::get_resource_alloc_info(const Device &dev, const VkMemoryRequirements &reqs,
 448                                                            VkMemoryPropertyFlags mem_props) {
 449     // Find appropriate memory type for given reqs
 450     VkPhysicalDeviceMemoryProperties dev_mem_props = dev.phy().memory_properties();
 451     uint32_t mem_type_index = 0;
 452     for (mem_type_index = 0; mem_type_index < dev_mem_props.memoryTypeCount; ++mem_type_index) {
 453         if (mem_props == (mem_props & dev_mem_props.memoryTypes[mem_type_index].propertyFlags)) break;
 454     }
 455     // If we exceeded types, then this device doesn't have the memory we need
 456     assert(mem_type_index < dev_mem_props.memoryTypeCount);
 457     VkMemoryAllocateInfo info = alloc_info(reqs.size, mem_type_index);
 458     EXPECT(dev.phy().set_memory_type(reqs.memoryTypeBits, &info, mem_props));
 459     return info;
 460 }
 461
 462 NON_DISPATCHABLE_HANDLE_DTOR(Fence, vkDestroyFence)
 463
 464 void Fence::init(const Device &dev, const VkFenceCreateInfo &info) { NON_DISPATCHABLE_HANDLE_INIT(vkCreateFence, dev, &info); }
 465
 466 VkResult Fence::wait(VkBool32 wait_all, uint64_t timeout) const {
 467     VkFence fence = handle();
 468     return vkWaitForFences(device(), 1, &fence, wait_all, timeout);
 469 }
 470
 471 NON_DISPATCHABLE_HANDLE_DTOR(Semaphore, vkDestroySemaphore)
 472
 473 void Semaphore::init(const Device &dev, const VkSemaphoreCreateInfo &info) {
 474     NON_DISPATCHABLE_HANDLE_INIT(vkCreateSemaphore, dev, &info);
 475 }
 476
 477 NON_DISPATCHABLE_HANDLE_DTOR(Event, vkDestroyEvent)
 478
 479 void Event::init(const Device &dev, const VkEventCreateInfo &info) { NON_DISPATCHABLE_HANDLE_INIT(vkCreateEvent, dev, &info); }
 480
 481 void Event::set() { EXPECT(vkSetEvent(device(), handle()) == VK_SUCCESS); }
 482
 483 void Event::reset() { EXPECT(vkResetEvent(device(), handle()) == VK_SUCCESS); }
 484
 485 NON_DISPATCHABLE_HANDLE_DTOR(QueryPool, vkDestroyQueryPool)
 486
 487 void QueryPool::init(const Device &dev, const VkQueryPoolCreateInfo &info) {
 488     NON_DISPATCHABLE_HANDLE_INIT(vkCreateQueryPool, dev, &info);
 489 }
 490
 491 VkResult QueryPool::results(uint32_t first, uint32_t count, size_t size, void *data, size_t stride) {
 492     VkResult err = vkGetQueryPoolResults(device(), handle(), first, count, size, data, stride, 0);
 493     EXPECT(err == VK_SUCCESS || err == VK_NOT_READY);
 494
 495     return err;
 496 }
 497
 498 NON_DISPATCHABLE_HANDLE_DTOR(Buffer, vkDestroyBuffer)
 499
 500 void Buffer::init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags mem_props) {
 501     init_no_mem(dev, info);
 502
 503     internal_mem_.init(dev, DeviceMemory::get_resource_alloc_info(dev, memory_requirements(), mem_props));
 504     bind_memory(internal_mem_, 0);
 505 }
 506
 507 void Buffer::init_no_mem(const Device &dev, const VkBufferCreateInfo &info) {
 508     NON_DISPATCHABLE_HANDLE_INIT(vkCreateBuffer, dev, &info);
 509     create_info_ = info;
 510 }
 511
 512 VkMemoryRequirements Buffer::memory_requirements() const {
 513     VkMemoryRequirements reqs;
 514
 515     vkGetBufferMemoryRequirements(device(), handle(), &reqs);
 516
 517     return reqs;
 518 }
 519
 520 void Buffer::bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset) {
 521     EXPECT(vkBindBufferMemory(device(), handle(), mem.handle(), mem_offset) == VK_SUCCESS);
 522 }
 523
 524 NON_DISPATCHABLE_HANDLE_DTOR(BufferView, vkDestroyBufferView)
 525
 526 void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info) {
 527     NON_DISPATCHABLE_HANDLE_INIT(vkCreateBufferView, dev, &info);
 528 }
 529
 530 NON_DISPATCHABLE_HANDLE_DTOR(Image, vkDestroyImage)
 531
 532 void Image::init(const Device &dev, const VkImageCreateInfo &info, VkMemoryPropertyFlags mem_props) {
 533     init_no_mem(dev, info);
 534
 535     if (initialized()) {
 536         internal_mem_.init(dev, DeviceMemory::get_resource_alloc_info(dev, memory_requirements(), mem_props));
 537         bind_memory(internal_mem_, 0);
 538     }
 539 }
 540
 541 void Image::init_no_mem(const Device &dev, const VkImageCreateInfo &info) {
 542     NON_DISPATCHABLE_HANDLE_INIT(vkCreateImage, dev, &info);
 543     if (initialized()) {
 544         init_info(dev, info);
 545     }
 546 }
 547
 548 void Image::init_info(const Device &dev, const VkImageCreateInfo &info) {
 549     create_info_ = info;
 550
 551     for (std::vector<Device::Format>::const_iterator it = dev.formats().begin(); it != dev.formats().end(); it++) {
 552         if (memcmp(&it->format, &create_info_.format, sizeof(it->format)) == 0 && it->tiling == create_info_.tiling) {
 553             format_features_ = it->features;
 554             break;
 555         }
 556     }
 557 }
 558
 559 VkMemoryRequirements Image::memory_requirements() const {
 560     VkMemoryRequirements reqs;
 561
 562     vkGetImageMemoryRequirements(device(), handle(), &reqs);
 563
 564     return reqs;
 565 }
 566
 567 void Image::bind_memory(const DeviceMemory &mem, VkDeviceSize mem_offset) {
 568     EXPECT(vkBindImageMemory(device(), handle(), mem.handle(), mem_offset) == VK_SUCCESS);
 569 }
 570
 571 VkSubresourceLayout Image::subresource_layout(const VkImageSubresource &subres) const {
 572     VkSubresourceLayout data;
 573     size_t size = sizeof(data);
 574     vkGetImageSubresourceLayout(device(), handle(), &subres, &data);
 575     if (size != sizeof(data)) memset(&data, 0, sizeof(data));
 576
 577     return data;
 578 }
 579
 580 VkSubresourceLayout Image::subresource_layout(const VkImageSubresourceLayers &subrescopy) const {
 581     VkSubresourceLayout data;
 582     VkImageSubresource subres = subresource(subrescopy.aspectMask, subrescopy.mipLevel, subrescopy.baseArrayLayer);
 583     size_t size = sizeof(data);
 584     vkGetImageSubresourceLayout(device(), handle(), &subres, &data);
 585     if (size != sizeof(data)) memset(&data, 0, sizeof(data));
 586
 587     return data;
 588 }
 589
 590 bool Image::transparent() const {
 591     return (create_info_.tiling == VK_IMAGE_TILING_LINEAR && create_info_.samples == VK_SAMPLE_COUNT_1_BIT &&
 592             !(create_info_.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)));
 593 }
 594
 595 NON_DISPATCHABLE_HANDLE_DTOR(ImageView, vkDestroyImageView)
 596
 597 void ImageView::init(const Device &dev, const VkImageViewCreateInfo &info) {
 598     NON_DISPATCHABLE_HANDLE_INIT(vkCreateImageView, dev, &info);
 599 }
 600
 601 NON_DISPATCHABLE_HANDLE_DTOR(ShaderModule, vkDestroyShaderModule)
 602
 603 void ShaderModule::init(const Device &dev, const VkShaderModuleCreateInfo &info) {
 604     NON_DISPATCHABLE_HANDLE_INIT(vkCreateShaderModule, dev, &info);
 605 }
 606
 607 VkResult ShaderModule::init_try(const Device &dev, const VkShaderModuleCreateInfo &info) {
 608     VkShaderModule mod;
 609
 610     VkResult err = vkCreateShaderModule(dev.handle(), &info, NULL, &mod);
 611     if (err == VK_SUCCESS) NonDispHandle::init(dev.handle(), mod);
 612
 613     return err;
 614 }
 615
 616 NON_DISPATCHABLE_HANDLE_DTOR(Pipeline, vkDestroyPipeline)
 617
 618 void Pipeline::init(const Device &dev, const VkGraphicsPipelineCreateInfo &info) {
 619     VkPipelineCache cache;
 620     VkPipelineCacheCreateInfo ci;
 621     memset((void *)&ci, 0, sizeof(VkPipelineCacheCreateInfo));
 622     ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 623     VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
 624     if (err == VK_SUCCESS) {
 625         NON_DISPATCHABLE_HANDLE_INIT(vkCreateGraphicsPipelines, dev, cache, 1, &info);
 626         vkDestroyPipelineCache(dev.handle(), cache, NULL);
 627     }
 628 }
 629
 630 VkResult Pipeline::init_try(const Device &dev, const VkGraphicsPipelineCreateInfo &info) {
 631     VkPipeline pipe;
 632     VkPipelineCache cache;
 633     VkPipelineCacheCreateInfo ci;
 634     memset((void *)&ci, 0, sizeof(VkPipelineCacheCreateInfo));
 635     ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 636     VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
 637     EXPECT(err == VK_SUCCESS);
 638     if (err == VK_SUCCESS) {
 639         err = vkCreateGraphicsPipelines(dev.handle(), cache, 1, &info, NULL, &pipe);
 640         if (err == VK_SUCCESS) {
 641             NonDispHandle::init(dev.handle(), pipe);
 642         }
 643         vkDestroyPipelineCache(dev.handle(), cache, NULL);
 644     }
 645
 646     return err;
 647 }
 648
 649 void Pipeline::init(const Device &dev, const VkComputePipelineCreateInfo &info) {
 650     VkPipelineCache cache;
 651     VkPipelineCacheCreateInfo ci;
 652     memset((void *)&ci, 0, sizeof(VkPipelineCacheCreateInfo));
 653     ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 654     VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
 655     if (err == VK_SUCCESS) {
 656         NON_DISPATCHABLE_HANDLE_INIT(vkCreateComputePipelines, dev, cache, 1, &info);
 657         vkDestroyPipelineCache(dev.handle(), cache, NULL);
 658     }
 659 }
 660
 661 NON_DISPATCHABLE_HANDLE_DTOR(PipelineLayout, vkDestroyPipelineLayout)
 662
 663 void PipelineLayout::init(const Device &dev, VkPipelineLayoutCreateInfo &info,
 664                           const std::vector<const DescriptorSetLayout *> &layouts) {
 665     const std::vector<VkDescriptorSetLayout> layout_handles = MakeVkHandles<VkDescriptorSetLayout>(layouts);
 666     info.setLayoutCount = layout_handles.size();
 667     info.pSetLayouts = layout_handles.data();
 668
 669     NON_DISPATCHABLE_HANDLE_INIT(vkCreatePipelineLayout, dev, &info);
 670 }
 671
 672 NON_DISPATCHABLE_HANDLE_DTOR(Sampler, vkDestroySampler)
 673
 674 void Sampler::init(const Device &dev, const VkSamplerCreateInfo &info) {
 675     NON_DISPATCHABLE_HANDLE_INIT(vkCreateSampler, dev, &info);
 676 }
 677
 678 NON_DISPATCHABLE_HANDLE_DTOR(DescriptorSetLayout, vkDestroyDescriptorSetLayout)
 679
 680 void DescriptorSetLayout::init(const Device &dev, const VkDescriptorSetLayoutCreateInfo &info) {
 681     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDescriptorSetLayout, dev, &info);
 682 }
 683
 684 NON_DISPATCHABLE_HANDLE_DTOR(DescriptorPool, vkDestroyDescriptorPool)
 685
 686 void DescriptorPool::init(const Device &dev, const VkDescriptorPoolCreateInfo &info) {
 687     setDynamicUsage(info.flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT);
 688     NON_DISPATCHABLE_HANDLE_INIT(vkCreateDescriptorPool, dev, &info);
 689 }
 690
 691 void DescriptorPool::reset() { EXPECT(vkResetDescriptorPool(device(), handle(), 0) == VK_SUCCESS); }
 692
 693 std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev,
 694                                                         const std::vector<const DescriptorSetLayout *> &layouts) {
 695     const std::vector<VkDescriptorSetLayout> layout_handles = MakeVkHandles<VkDescriptorSetLayout>(layouts);
 696
 697     std::vector<VkDescriptorSet> set_handles;
 698     set_handles.resize(layout_handles.size());
 699
 700     VkDescriptorSetAllocateInfo alloc_info = {};
 701     alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
 702     alloc_info.descriptorSetCount = layout_handles.size();
 703     alloc_info.descriptorPool = handle();
 704     alloc_info.pSetLayouts = layout_handles.data();
 705     VkResult err = vkAllocateDescriptorSets(device(), &alloc_info, set_handles.data());
 706     EXPECT(err == VK_SUCCESS);
 707
 708     std::vector<DescriptorSet *> sets;
 709     for (std::vector<VkDescriptorSet>::const_iterator it = set_handles.begin(); it != set_handles.end(); it++) {
 710         // do descriptor sets need memories bound?
 711         DescriptorSet *descriptorSet = new DescriptorSet(dev, this, *it);
 712         sets.push_back(descriptorSet);
 713     }
 714     return sets;
 715 }
 716
 717 std::vector<DescriptorSet *> DescriptorPool::alloc_sets(const Device &dev, const DescriptorSetLayout &layout, uint32_t count) {
 718     return alloc_sets(dev, std::vector<const DescriptorSetLayout *>(count, &layout));
 719 }
 720
 721 DescriptorSet *DescriptorPool::alloc_sets(const Device &dev, const DescriptorSetLayout &layout) {
 722     std::vector<DescriptorSet *> set = alloc_sets(dev, layout, 1);
 723     return (set.empty()) ? NULL : set[0];
 724 }
 725
 726 DescriptorSet::~DescriptorSet() {
 727     if (initialized()) {
 728         // Only call vkFree* on sets allocated from pool with usage *_DYNAMIC
 729         if (containing_pool_->getDynamicUsage()) {
 730             VkDescriptorSet sets[1] = {handle()};
 731             EXPECT(vkFreeDescriptorSets(device(), containing_pool_->GetObj(), 1, sets) == VK_SUCCESS);
 732         }
 733     }
 734 }
 735
 736 NON_DISPATCHABLE_HANDLE_DTOR(CommandPool, vkDestroyCommandPool)
 737
 738 void CommandPool::init(const Device &dev, const VkCommandPoolCreateInfo &info) {
 739     NON_DISPATCHABLE_HANDLE_INIT(vkCreateCommandPool, dev, &info);
 740 }
 741
 742 CommandBuffer::~CommandBuffer() {
 743     if (initialized()) {
 744         VkCommandBuffer cmds[] = {handle()};
 745         vkFreeCommandBuffers(dev_handle_, cmd_pool_, 1, cmds);
 746     }
 747 }
 748
 749 void CommandBuffer::init(const Device &dev, const VkCommandBufferAllocateInfo &info) {
 750     VkCommandBuffer cmd;
 751
 752     // Make sure commandPool is set
 753     assert(info.commandPool);
 754
 755     if (EXPECT(vkAllocateCommandBuffers(dev.handle(), &info, &cmd) == VK_SUCCESS)) {
 756         Handle::init(cmd);
 757         dev_handle_ = dev.handle();
 758         cmd_pool_ = info.commandPool;
 759     }
 760 }
 761
 762 void CommandBuffer::begin(const VkCommandBufferBeginInfo *info) { EXPECT(vkBeginCommandBuffer(handle(), info) == VK_SUCCESS); }
 763
 764 void CommandBuffer::begin() {
 765     VkCommandBufferBeginInfo info = {};
 766     VkCommandBufferInheritanceInfo hinfo = {};
 767     info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
 768     info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 769     info.pInheritanceInfo = &hinfo;
 770     hinfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
 771     hinfo.pNext = NULL;
 772     hinfo.renderPass = VK_NULL_HANDLE;
 773     hinfo.subpass = 0;
 774     hinfo.framebuffer = VK_NULL_HANDLE;
 775     hinfo.occlusionQueryEnable = VK_FALSE;
 776     hinfo.queryFlags = 0;
 777     hinfo.pipelineStatistics = 0;
 778
 779     begin(&info);
 780 }
 781
 782 void CommandBuffer::end() { EXPECT(vkEndCommandBuffer(handle()) == VK_SUCCESS); }
 783
 784 void CommandBuffer::reset(VkCommandBufferResetFlags flags) { EXPECT(vkResetCommandBuffer(handle(), flags) == VK_SUCCESS); }
 785
 786 }  // namespace vk_testing