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