null_driver.cpp revision d02edcbb40d476b6d3b5ae279a6ccef786be8848 
1/*
2 * Copyright 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <hardware/hwvulkan.h>
18
19#include <array>
20#include <algorithm>
21#include <inttypes.h>
22#include <string.h>
23
24// #define LOG_NDEBUG 0
25#include <log/log.h>
26#include <utils/Errors.h>
27
28#include "null_driver.h"
29
30using namespace null_driver;
31
32struct VkPhysicalDevice_T {
33    hwvulkan_dispatch_t dispatch;
34};
35
36struct VkInstance_T {
37    hwvulkan_dispatch_t dispatch;
38    const VkAllocCallbacks* alloc;
39    VkPhysicalDevice_T physical_device;
40};
41
42struct VkQueue_T {
43    hwvulkan_dispatch_t dispatch;
44};
45
46struct VkCmdBuffer_T {
47    hwvulkan_dispatch_t dispatch;
48};
49
50namespace {
51// Handles for non-dispatchable objects are either pointers, or arbitrary
52// 64-bit non-zero values. We only use pointers when we need to keep state for
53// the object even in a null driver. For the rest, we form a handle as:
54//   [63:63] = 1 to distinguish from pointer handles*
55//   [62:56] = non-zero handle type enum value
56//   [55: 0] = per-handle-type incrementing counter
57// * This works because virtual addresses with the high bit set are reserved
58// for kernel data in all ABIs we run on.
59//
60// We never reclaim handles on vkDestroy*. It's not even necessary for us to
61// have distinct handles for live objects, and practically speaking we won't
62// ever create 2^56 objects of the same type from a single VkDevice in a null
63// driver.
64//
65// Using a namespace here instead of 'enum class' since we want scoped
66// constants but also want implicit conversions to integral types.
67namespace HandleType {
68enum Enum {
69    kAttachmentView,
70    kBufferView,
71    kCmdPool,
72    kDescriptorPool,
73    kDescriptorSet,
74    kDescriptorSetLayout,
75    kDynamicColorBlendState,
76    kDynamicDepthStencilState,
77    kDynamicRasterState,
78    kDynamicViewportState,
79    kEvent,
80    kFence,
81    kFramebuffer,
82    kImageView,
83    kPipeline,
84    kPipelineCache,
85    kPipelineLayout,
86    kQueryPool,
87    kRenderPass,
88    kSampler,
89    kSemaphore,
90    kShader,
91    kShaderModule,
92
93    kNumTypes
94};
95}  // namespace HandleType
96uint64_t AllocHandle(VkDevice device, HandleType::Enum type);
97
98const VkDeviceSize kMaxDeviceMemory = VkDeviceSize(INTPTR_MAX) + 1;
99
100}  // anonymous namespace
101
102struct VkDevice_T {
103    hwvulkan_dispatch_t dispatch;
104    VkInstance_T* instance;
105    VkQueue_T queue;
106    std::array<uint64_t, HandleType::kNumTypes> next_handle;
107};
108
109// -----------------------------------------------------------------------------
110// Declare HAL_MODULE_INFO_SYM early so it can be referenced by nulldrv_device
111// later.
112
113namespace {
114int OpenDevice(const hw_module_t* module, const char* id, hw_device_t** device);
115hw_module_methods_t nulldrv_module_methods = {.open = OpenDevice};
116}  // namespace
117
118#pragma clang diagnostic push
119#pragma clang diagnostic ignored "-Wmissing-variable-declarations"
120__attribute__((visibility("default"))) hwvulkan_module_t HAL_MODULE_INFO_SYM = {
121    .common =
122        {
123         .tag = HARDWARE_MODULE_TAG,
124         .module_api_version = HWVULKAN_MODULE_API_VERSION_0_1,
125         .hal_api_version = HARDWARE_HAL_API_VERSION,
126         .id = HWVULKAN_HARDWARE_MODULE_ID,
127         .name = "Null Vulkan Driver",
128         .author = "The Android Open Source Project",
129         .methods = &nulldrv_module_methods,
130        },
131};
132#pragma clang diagnostic pop
133
134// -----------------------------------------------------------------------------
135
136namespace {
137
138VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
139                        VkInstance* out_instance) {
140    VkInstance_T* instance =
141        static_cast<VkInstance_T*>(create_info->pAllocCb->pfnAlloc(
142            create_info->pAllocCb->pUserData, sizeof(VkInstance_T),
143            alignof(VkInstance_T), VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
144    if (!instance)
145        return VK_ERROR_OUT_OF_HOST_MEMORY;
146
147    instance->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
148    instance->alloc = create_info->pAllocCb;
149    instance->physical_device.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
150
151    *out_instance = instance;
152    return VK_SUCCESS;
153}
154
155int CloseDevice(struct hw_device_t* /*device*/) {
156    // nothing to do - opening a device doesn't allocate any resources
157    return 0;
158}
159
160hwvulkan_device_t nulldrv_device = {
161    .common =
162        {
163         .tag = HARDWARE_DEVICE_TAG,
164         .version = HWVULKAN_DEVICE_API_VERSION_0_1,
165         .module = &HAL_MODULE_INFO_SYM.common,
166         .close = CloseDevice,
167        },
168    .GetGlobalExtensionProperties = GetGlobalExtensionProperties,
169    .CreateInstance = CreateInstance,
170    .GetInstanceProcAddr = GetInstanceProcAddr};
171
172int OpenDevice(const hw_module_t* /*module*/,
173               const char* id,
174               hw_device_t** device) {
175    if (strcmp(id, HWVULKAN_DEVICE_0) == 0) {
176        *device = &nulldrv_device.common;
177        return 0;
178    }
179    return -ENOENT;
180}
181
182VkInstance_T* GetInstanceFromPhysicalDevice(
183    VkPhysicalDevice_T* physical_device) {
184    return reinterpret_cast<VkInstance_T*>(
185        reinterpret_cast<uintptr_t>(physical_device) -
186        offsetof(VkInstance_T, physical_device));
187}
188
189uint64_t AllocHandle(VkDevice device, HandleType::Enum type) {
190    const uint64_t kHandleMask = (UINT64_C(1) << 56) - 1;
191    ALOGE_IF(device->next_handle[type] == kHandleMask,
192             "non-dispatchable handles of type=%u are about to overflow", type);
193    return (UINT64_C(1) << 63) | ((uint64_t(type) & 0x7) << 56) |
194           (device->next_handle[type]++ & kHandleMask);
195}
196
197}  // namespace
198
199namespace null_driver {
200
201template <typename HandleT>
202struct HandleTraits {};
203
204template <typename HandleT>
205typename HandleTraits<HandleT>::PointerType GetObjectFromHandle(
206    const HandleT& h) {
207    return reinterpret_cast<typename HandleTraits<HandleT>::PointerType>(
208        uintptr_t(h.handle));
209}
210
211template <typename T>
212typename T::HandleType GetHandleToObject(const T* obj) {
213    return typename T::HandleType(reinterpret_cast<uintptr_t>(obj));
214}
215
216// -----------------------------------------------------------------------------
217// Global
218
219VkResult GetGlobalExtensionProperties(const char*,
220                                      uint32_t* count,
221                                      VkExtensionProperties*) {
222    *count = 0;
223    return VK_SUCCESS;
224}
225
226PFN_vkVoidFunction GetInstanceProcAddr(VkInstance, const char* name) {
227    PFN_vkVoidFunction proc = LookupInstanceProcAddr(name);
228    if (!proc && strcmp(name, "vkGetDeviceProcAddr") == 0)
229        proc = reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr);
230    return proc;
231}
232
233PFN_vkVoidFunction GetDeviceProcAddr(VkDevice, const char* name) {
234    return LookupDeviceProcAddr(name);
235}
236
237// -----------------------------------------------------------------------------
238// Instance
239
240VkResult DestroyInstance(VkInstance instance) {
241    instance->alloc->pfnFree(instance->alloc->pUserData, instance);
242    return VK_SUCCESS;
243}
244
245// -----------------------------------------------------------------------------
246// PhysicalDevice
247
248VkResult EnumeratePhysicalDevices(VkInstance instance,
249                                  uint32_t* physical_device_count,
250                                  VkPhysicalDevice* physical_devices) {
251    if (physical_devices && *physical_device_count >= 1)
252        physical_devices[0] = &instance->physical_device;
253    *physical_device_count = 1;
254    return VK_SUCCESS;
255}
256
257VkResult GetPhysicalDeviceProperties(VkPhysicalDevice,
258                                     VkPhysicalDeviceProperties* properties) {
259    properties->apiVersion = VK_API_VERSION;
260    properties->driverVersion = VK_MAKE_VERSION(0, 0, 1);
261    properties->vendorId = 0xC0DE;
262    properties->deviceId = 0xCAFE;
263    properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER;
264    strcpy(properties->deviceName, "Android Vulkan Null Driver");
265    memset(properties->pipelineCacheUUID, 0,
266           sizeof(properties->pipelineCacheUUID));
267    return VK_SUCCESS;
268}
269
270VkResult GetPhysicalDeviceMemoryProperties(
271    VkPhysicalDevice,
272    VkPhysicalDeviceMemoryProperties* properties) {
273    properties->memoryTypeCount = 1;
274    properties->memoryTypes[0].propertyFlags =
275        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
276    properties->memoryTypes[0].heapIndex = 0;
277    properties->memoryHeapCount = 1;
278    properties->memoryHeaps[0].size = kMaxDeviceMemory;
279    properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_HOST_LOCAL;
280    return VK_SUCCESS;
281}
282
283// -----------------------------------------------------------------------------
284// Device
285
286VkResult CreateDevice(VkPhysicalDevice physical_device,
287                      const VkDeviceCreateInfo*,
288                      VkDevice* out_device) {
289    VkInstance_T* instance = GetInstanceFromPhysicalDevice(physical_device);
290    VkDevice_T* device = static_cast<VkDevice_T*>(instance->alloc->pfnAlloc(
291        instance->alloc->pUserData, sizeof(VkDevice_T), alignof(VkDevice_T),
292        VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
293    if (!device)
294        return VK_ERROR_OUT_OF_HOST_MEMORY;
295
296    device->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
297    device->instance = instance;
298    device->queue.dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
299    std::fill(device->next_handle.begin(), device->next_handle.end(),
300              UINT64_C(0));
301
302    *out_device = device;
303    return VK_SUCCESS;
304}
305
306VkResult DestroyDevice(VkDevice device) {
307    if (!device)
308        return VK_SUCCESS;
309    const VkAllocCallbacks* alloc = device->instance->alloc;
310    alloc->pfnFree(alloc->pUserData, device);
311    return VK_SUCCESS;
312}
313
314VkResult GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
315    *queue = &device->queue;
316    return VK_SUCCESS;
317}
318
319// -----------------------------------------------------------------------------
320// CmdBuffer
321
322VkResult CreateCommandBuffer(VkDevice device,
323                             const VkCmdBufferCreateInfo*,
324                             VkCmdBuffer* out_cmdbuf) {
325    const VkAllocCallbacks* alloc = device->instance->alloc;
326    VkCmdBuffer_T* cmdbuf = static_cast<VkCmdBuffer_T*>(alloc->pfnAlloc(
327        alloc->pUserData, sizeof(VkCmdBuffer_T), alignof(VkCmdBuffer_T),
328        VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
329    if (!cmdbuf)
330        return VK_ERROR_OUT_OF_HOST_MEMORY;
331    cmdbuf->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
332    *out_cmdbuf = cmdbuf;
333    return VK_SUCCESS;
334}
335
336VkResult DestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdbuf) {
337    const VkAllocCallbacks* alloc = device->instance->alloc;
338    alloc->pfnFree(alloc->pUserData, cmdbuf);
339    return VK_SUCCESS;
340}
341
342// -----------------------------------------------------------------------------
343// DeviceMemory
344
345struct DeviceMemory {
346    typedef VkDeviceMemory HandleType;
347    VkDeviceSize size;
348    alignas(16) uint8_t data[0];
349};
350template <>
351struct HandleTraits<VkDeviceMemory> {
352    typedef DeviceMemory* PointerType;
353};
354
355VkResult AllocMemory(VkDevice device,
356                     const VkMemoryAllocInfo* alloc_info,
357                     VkDeviceMemory* mem_handle) {
358    if (SIZE_MAX - sizeof(DeviceMemory) <= alloc_info->allocationSize)
359        return VK_ERROR_OUT_OF_HOST_MEMORY;
360
361    const VkAllocCallbacks* alloc = device->instance->alloc;
362    size_t size = sizeof(DeviceMemory) + size_t(alloc_info->allocationSize);
363    DeviceMemory* mem = static_cast<DeviceMemory*>(
364        alloc->pfnAlloc(alloc->pUserData, size, alignof(DeviceMemory),
365                        VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
366    if (!mem)
367        return VK_ERROR_OUT_OF_HOST_MEMORY;
368    mem->size = size;
369    *mem_handle = GetHandleToObject(mem);
370    return VK_SUCCESS;
371}
372
373VkResult FreeMemory(VkDevice device, VkDeviceMemory mem_handle) {
374    const VkAllocCallbacks* alloc = device->instance->alloc;
375    DeviceMemory* mem = GetObjectFromHandle(mem_handle);
376    alloc->pfnFree(alloc->pUserData, mem);
377    return VK_SUCCESS;
378}
379
380VkResult MapMemory(VkDevice,
381                   VkDeviceMemory mem_handle,
382                   VkDeviceSize offset,
383                   VkDeviceSize,
384                   VkMemoryMapFlags,
385                   void** out_ptr) {
386    DeviceMemory* mem = GetObjectFromHandle(mem_handle);
387    *out_ptr = &mem->data[0] + offset;
388    return VK_SUCCESS;
389}
390
391// -----------------------------------------------------------------------------
392// Buffer
393
394struct Buffer {
395    typedef VkBuffer HandleType;
396    VkDeviceSize size;
397};
398template <>
399struct HandleTraits<VkBuffer> {
400    typedef Buffer* PointerType;
401};
402
403VkResult CreateBuffer(VkDevice device,
404                      const VkBufferCreateInfo* create_info,
405                      VkBuffer* buffer_handle) {
406    ALOGW_IF(create_info->size > kMaxDeviceMemory,
407             "CreateBuffer: requested size 0x%" PRIx64
408             " exceeds max device memory size 0x%" PRIx64,
409             create_info->size, kMaxDeviceMemory);
410
411    const VkAllocCallbacks* alloc = device->instance->alloc;
412    Buffer* buffer = static_cast<Buffer*>(
413        alloc->pfnAlloc(alloc->pUserData, sizeof(Buffer), alignof(Buffer),
414                        VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
415    if (!buffer)
416        return VK_ERROR_OUT_OF_HOST_MEMORY;
417    buffer->size = create_info->size;
418    *buffer_handle = GetHandleToObject(buffer);
419    return VK_SUCCESS;
420}
421
422VkResult GetBufferMemoryRequirements(VkDevice,
423                                     VkBuffer buffer_handle,
424                                     VkMemoryRequirements* requirements) {
425    Buffer* buffer = GetObjectFromHandle(buffer_handle);
426    requirements->size = buffer->size;
427    requirements->alignment = 16;  // allow fast Neon/SSE memcpy
428    requirements->memoryTypeBits = 0x1;
429    return VK_SUCCESS;
430}
431
432VkResult DestroyBuffer(VkDevice device, VkBuffer buffer_handle) {
433    const VkAllocCallbacks* alloc = device->instance->alloc;
434    Buffer* buffer = GetObjectFromHandle(buffer_handle);
435    alloc->pfnFree(alloc->pUserData, buffer);
436    return VK_SUCCESS;
437}
438
439// -----------------------------------------------------------------------------
440// Image
441
442struct Image {
443    typedef VkImage HandleType;
444    VkDeviceSize size;
445};
446template <>
447struct HandleTraits<VkImage> {
448    typedef Image* PointerType;
449};
450
451VkResult CreateImage(VkDevice device,
452                     const VkImageCreateInfo* create_info,
453                     VkImage* image_handle) {
454    if (create_info->imageType != VK_IMAGE_TYPE_2D ||
455        create_info->format != VK_FORMAT_R8G8B8A8_UNORM ||
456        create_info->mipLevels != 1) {
457        ALOGE("CreateImage: not yet implemented: type=%d format=%d mips=%u",
458              create_info->imageType, create_info->format,
459              create_info->mipLevels);
460        return VK_ERROR_UNAVAILABLE;
461    }
462
463    VkDeviceSize size =
464        VkDeviceSize(create_info->extent.width * create_info->extent.height) *
465        create_info->arraySize * create_info->samples * 4u;
466    ALOGW_IF(size > kMaxDeviceMemory,
467             "CreateImage: image size 0x%" PRIx64
468             " exceeds max device memory size 0x%" PRIx64,
469             size, kMaxDeviceMemory);
470
471    const VkAllocCallbacks* alloc = device->instance->alloc;
472    Image* image = static_cast<Image*>(
473        alloc->pfnAlloc(alloc->pUserData, sizeof(Image), alignof(Image),
474                        VK_SYSTEM_ALLOC_TYPE_API_OBJECT));
475    if (!image)
476        return VK_ERROR_OUT_OF_HOST_MEMORY;
477    image->size = size;
478    *image_handle = GetHandleToObject(image);
479    return VK_SUCCESS;
480}
481
482VkResult GetImageMemoryRequirements(VkDevice,
483                                    VkImage image_handle,
484                                    VkMemoryRequirements* requirements) {
485    Image* image = GetObjectFromHandle(image_handle);
486    requirements->size = image->size;
487    requirements->alignment = 16;  // allow fast Neon/SSE memcpy
488    requirements->memoryTypeBits = 0x1;
489    return VK_SUCCESS;
490}
491
492VkResult DestroyImage(VkDevice device, VkImage image_handle) {
493    const VkAllocCallbacks* alloc = device->instance->alloc;
494    Image* image = GetObjectFromHandle(image_handle);
495    alloc->pfnFree(alloc->pUserData, image);
496    return VK_SUCCESS;
497}
498
499// -----------------------------------------------------------------------------
500// No-op types
501
502VkResult CreateAttachmentView(VkDevice device,
503                              const VkAttachmentViewCreateInfo*,
504                              VkAttachmentView* view) {
505    *view = AllocHandle(device, HandleType::kAttachmentView);
506    return VK_SUCCESS;
507}
508
509VkResult CreateBufferView(VkDevice device,
510                          const VkBufferViewCreateInfo*,
511                          VkBufferView* view) {
512    *view = AllocHandle(device, HandleType::kBufferView);
513    return VK_SUCCESS;
514}
515
516VkResult CreateCommandPool(VkDevice device,
517                           const VkCmdPoolCreateInfo*,
518                           VkCmdPool* pool) {
519    *pool = AllocHandle(device, HandleType::kCmdPool);
520    return VK_SUCCESS;
521}
522
523VkResult CreateDescriptorPool(VkDevice device,
524                              VkDescriptorPoolUsage,
525                              uint32_t,
526                              const VkDescriptorPoolCreateInfo*,
527                              VkDescriptorPool* pool) {
528    *pool = AllocHandle(device, HandleType::kDescriptorPool);
529    return VK_SUCCESS;
530}
531
532VkResult AllocDescriptorSets(VkDevice device,
533                             VkDescriptorPool,
534                             VkDescriptorSetUsage,
535                             uint32_t count,
536                             const VkDescriptorSetLayout*,
537                             VkDescriptorSet* sets,
538                             uint32_t* out_count) {
539    for (uint32_t i = 0; i < count; i++)
540        sets[i] = AllocHandle(device, HandleType::kDescriptorSet);
541    *out_count = count;
542    return VK_SUCCESS;
543}
544
545VkResult CreateDescriptorSetLayout(VkDevice device,
546                                   const VkDescriptorSetLayoutCreateInfo*,
547                                   VkDescriptorSetLayout* layout) {
548    *layout = AllocHandle(device, HandleType::kDescriptorSetLayout);
549    return VK_SUCCESS;
550}
551
552VkResult CreateDynamicColorBlendState(VkDevice device,
553                                      const VkDynamicColorBlendStateCreateInfo*,
554                                      VkDynamicColorBlendState* state) {
555    *state = AllocHandle(device, HandleType::kDynamicColorBlendState);
556    return VK_SUCCESS;
557}
558
559VkResult CreateDynamicDepthStencilState(
560    VkDevice device,
561    const VkDynamicDepthStencilStateCreateInfo*,
562    VkDynamicDepthStencilState* state) {
563    *state = AllocHandle(device, HandleType::kDynamicDepthStencilState);
564    return VK_SUCCESS;
565}
566
567VkResult CreateDynamicRasterState(VkDevice device,
568                                  const VkDynamicRasterStateCreateInfo*,
569                                  VkDynamicRasterState* state) {
570    *state = AllocHandle(device, HandleType::kDynamicRasterState);
571    return VK_SUCCESS;
572}
573
574VkResult CreateDynamicViewportState(VkDevice device,
575                                    const VkDynamicViewportStateCreateInfo*,
576                                    VkDynamicViewportState* state) {
577    *state = AllocHandle(device, HandleType::kDynamicViewportState);
578    return VK_SUCCESS;
579}
580
581VkResult CreateEvent(VkDevice device,
582                     const VkEventCreateInfo*,
583                     VkEvent* event) {
584    *event = AllocHandle(device, HandleType::kEvent);
585    return VK_SUCCESS;
586}
587
588VkResult CreateFence(VkDevice device,
589                     const VkFenceCreateInfo*,
590                     VkFence* fence) {
591    *fence = AllocHandle(device, HandleType::kFence);
592    return VK_SUCCESS;
593}
594
595VkResult CreateFramebuffer(VkDevice device,
596                           const VkFramebufferCreateInfo*,
597                           VkFramebuffer* framebuffer) {
598    *framebuffer = AllocHandle(device, HandleType::kFramebuffer);
599    return VK_SUCCESS;
600}
601
602VkResult CreateImageView(VkDevice device,
603                         const VkImageViewCreateInfo*,
604                         VkImageView* view) {
605    *view = AllocHandle(device, HandleType::kImageView);
606    return VK_SUCCESS;
607}
608
609VkResult CreateGraphicsPipelines(VkDevice device,
610                                 VkPipelineCache,
611                                 uint32_t count,
612                                 const VkGraphicsPipelineCreateInfo*,
613                                 VkPipeline* pipelines) {
614    for (uint32_t i = 0; i < count; i++)
615        pipelines[i] = AllocHandle(device, HandleType::kPipeline);
616    return VK_SUCCESS;
617}
618
619VkResult CreateComputePipelines(VkDevice device,
620                                VkPipelineCache,
621                                uint32_t count,
622                                const VkComputePipelineCreateInfo*,
623                                VkPipeline* pipelines) {
624    for (uint32_t i = 0; i < count; i++)
625        pipelines[i] = AllocHandle(device, HandleType::kPipeline);
626    return VK_SUCCESS;
627}
628
629VkResult CreatePipelineCache(VkDevice device,
630                             const VkPipelineCacheCreateInfo*,
631                             VkPipelineCache* cache) {
632    *cache = AllocHandle(device, HandleType::kPipelineCache);
633    return VK_SUCCESS;
634}
635
636VkResult CreatePipelineLayout(VkDevice device,
637                              const VkPipelineLayoutCreateInfo*,
638                              VkPipelineLayout* layout) {
639    *layout = AllocHandle(device, HandleType::kPipelineLayout);
640    return VK_SUCCESS;
641}
642
643VkResult CreateQueryPool(VkDevice device,
644                         const VkQueryPoolCreateInfo*,
645                         VkQueryPool* pool) {
646    *pool = AllocHandle(device, HandleType::kQueryPool);
647    return VK_SUCCESS;
648}
649
650VkResult CreateRenderPass(VkDevice device,
651                          const VkRenderPassCreateInfo*,
652                          VkRenderPass* renderpass) {
653    *renderpass = AllocHandle(device, HandleType::kRenderPass);
654    return VK_SUCCESS;
655}
656
657VkResult CreateSampler(VkDevice device,
658                       const VkSamplerCreateInfo*,
659                       VkSampler* sampler) {
660    *sampler = AllocHandle(device, HandleType::kSampler);
661    return VK_SUCCESS;
662}
663
664VkResult CreateSemaphore(VkDevice device,
665                         const VkSemaphoreCreateInfo*,
666                         VkSemaphore* semaphore) {
667    *semaphore = AllocHandle(device, HandleType::kSemaphore);
668    return VK_SUCCESS;
669}
670
671VkResult CreateShader(VkDevice device,
672                      const VkShaderCreateInfo*,
673                      VkShader* shader) {
674    *shader = AllocHandle(device, HandleType::kShader);
675    return VK_SUCCESS;
676}
677
678VkResult CreateShaderModule(VkDevice device,
679                            const VkShaderModuleCreateInfo*,
680                            VkShaderModule* module) {
681    *module = AllocHandle(device, HandleType::kShaderModule);
682    return VK_SUCCESS;
683}
684
685// -----------------------------------------------------------------------------
686// No-op entrypoints
687
688// clang-format off
689#pragma clang diagnostic push
690#pragma clang diagnostic ignored "-Wunused-parameter"
691
692VkResult GetPhysicalDeviceQueueCount(VkPhysicalDevice physicalDevice, uint32_t* pCount) {
693    ALOGV("TODO: vk%s", __FUNCTION__);
694    return VK_SUCCESS;
695}
696
697VkResult GetPhysicalDeviceQueueProperties(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties) {
698    ALOGV("TODO: vk%s", __FUNCTION__);
699    return VK_SUCCESS;
700}
701
702VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
703    ALOGV("TODO: vk%s", __FUNCTION__);
704    return VK_SUCCESS;
705}
706
707VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
708    ALOGV("TODO: vk%s", __FUNCTION__);
709    return VK_SUCCESS;
710}
711
712VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) {
713    ALOGV("TODO: vk%s", __FUNCTION__);
714    return VK_SUCCESS;
715}
716
717VkResult GetPhysicalDeviceLimits(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) {
718    ALOGV("TODO: vk%s", __FUNCTION__);
719    return VK_SUCCESS;
720}
721
722VkResult GetGlobalLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
723    ALOGV("TODO: vk%s", __FUNCTION__);
724    return VK_SUCCESS;
725}
726
727VkResult GetPhysicalDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties) {
728    ALOGV("TODO: vk%s", __FUNCTION__);
729    return VK_SUCCESS;
730}
731
732VkResult GetPhysicalDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) {
733    ALOGV("TODO: vk%s", __FUNCTION__);
734    return VK_SUCCESS;
735}
736
737VkResult QueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) {
738    return VK_SUCCESS;
739}
740
741VkResult QueueWaitIdle(VkQueue queue) {
742    ALOGV("TODO: vk%s", __FUNCTION__);
743    return VK_SUCCESS;
744}
745
746VkResult DeviceWaitIdle(VkDevice device) {
747    ALOGV("TODO: vk%s", __FUNCTION__);
748    return VK_SUCCESS;
749}
750
751VkResult UnmapMemory(VkDevice device, VkDeviceMemory mem) {
752    return VK_SUCCESS;
753}
754
755VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
756    ALOGV("TODO: vk%s", __FUNCTION__);
757    return VK_SUCCESS;
758}
759
760VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
761    ALOGV("TODO: vk%s", __FUNCTION__);
762    return VK_SUCCESS;
763}
764
765VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
766    ALOGV("TODO: vk%s", __FUNCTION__);
767    return VK_SUCCESS;
768}
769
770VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) {
771    return VK_SUCCESS;
772}
773
774VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) {
775    ALOGV("TODO: vk%s", __FUNCTION__);
776    return VK_SUCCESS;
777}
778
779VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
780    ALOGV("TODO: vk%s", __FUNCTION__);
781    return VK_SUCCESS;
782}
783
784VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
785    ALOGV("TODO: vk%s", __FUNCTION__);
786    return VK_SUCCESS;
787}
788
789VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
790    ALOGV("TODO: vk%s", __FUNCTION__);
791    return VK_SUCCESS;
792}
793
794VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
795    ALOGV("TODO: vk%s", __FUNCTION__);
796    return VK_SUCCESS;
797}
798
799VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) {
800    ALOGV("TODO: vk%s", __FUNCTION__);
801    return VK_SUCCESS;
802}
803
804VkResult DestroyFence(VkDevice device, VkFence fence) {
805    return VK_SUCCESS;
806}
807
808VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
809    return VK_SUCCESS;
810}
811
812VkResult GetFenceStatus(VkDevice device, VkFence fence) {
813    ALOGV("TODO: vk%s", __FUNCTION__);
814    return VK_SUCCESS;
815}
816
817VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
818    return VK_SUCCESS;
819}
820
821VkResult DestroySemaphore(VkDevice device, VkSemaphore semaphore) {
822    return VK_SUCCESS;
823}
824
825VkResult QueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) {
826    ALOGV("TODO: vk%s", __FUNCTION__);
827    return VK_SUCCESS;
828}
829
830VkResult QueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) {
831    ALOGV("TODO: vk%s", __FUNCTION__);
832    return VK_SUCCESS;
833}
834
835VkResult DestroyEvent(VkDevice device, VkEvent event) {
836    return VK_SUCCESS;
837}
838
839VkResult GetEventStatus(VkDevice device, VkEvent event) {
840    ALOGV("TODO: vk%s", __FUNCTION__);
841    return VK_SUCCESS;
842}
843
844VkResult SetEvent(VkDevice device, VkEvent event) {
845    ALOGV("TODO: vk%s", __FUNCTION__);
846    return VK_SUCCESS;
847}
848
849VkResult ResetEvent(VkDevice device, VkEvent event) {
850    ALOGV("TODO: vk%s", __FUNCTION__);
851    return VK_SUCCESS;
852}
853
854VkResult DestroyQueryPool(VkDevice device, VkQueryPool queryPool) {
855    return VK_SUCCESS;
856}
857
858VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) {
859    ALOGV("TODO: vk%s", __FUNCTION__);
860    return VK_SUCCESS;
861}
862
863VkResult DestroyBufferView(VkDevice device, VkBufferView bufferView) {
864    return VK_SUCCESS;
865}
866
867VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
868    ALOGV("TODO: vk%s", __FUNCTION__);
869    return VK_SUCCESS;
870}
871
872VkResult DestroyImageView(VkDevice device, VkImageView imageView) {
873    return VK_SUCCESS;
874}
875
876VkResult DestroyAttachmentView(VkDevice device, VkAttachmentView attachmentView) {
877    return VK_SUCCESS;
878}
879
880VkResult DestroyShaderModule(VkDevice device, VkShaderModule shaderModule) {
881    return VK_SUCCESS;
882}
883
884VkResult DestroyShader(VkDevice device, VkShader shader) {
885    return VK_SUCCESS;
886}
887
888VkResult DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) {
889    return VK_SUCCESS;
890}
891
892size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache) {
893    ALOGV("TODO: vk%s", __FUNCTION__);
894    return VK_SUCCESS;
895}
896
897VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData) {
898    ALOGV("TODO: vk%s", __FUNCTION__);
899    return VK_SUCCESS;
900}
901
902VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
903    ALOGV("TODO: vk%s", __FUNCTION__);
904    return VK_SUCCESS;
905}
906
907VkResult DestroyPipeline(VkDevice device, VkPipeline pipeline) {
908    return VK_SUCCESS;
909}
910
911VkResult DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout) {
912    return VK_SUCCESS;
913}
914
915VkResult DestroySampler(VkDevice device, VkSampler sampler) {
916    return VK_SUCCESS;
917}
918
919VkResult DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) {
920    return VK_SUCCESS;
921}
922
923VkResult DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
924    return VK_SUCCESS;
925}
926
927VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
928    ALOGV("TODO: vk%s", __FUNCTION__);
929    return VK_SUCCESS;
930}
931
932VkResult UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) {
933    ALOGV("TODO: vk%s", __FUNCTION__);
934    return VK_SUCCESS;
935}
936
937VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) {
938    ALOGV("TODO: vk%s", __FUNCTION__);
939    return VK_SUCCESS;
940}
941
942VkResult DestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState) {
943    return VK_SUCCESS;
944}
945
946VkResult DestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState) {
947    return VK_SUCCESS;
948}
949
950VkResult DestroyDynamicColorBlendState(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState) {
951    return VK_SUCCESS;
952}
953
954VkResult DestroyDynamicDepthStencilState(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState) {
955    return VK_SUCCESS;
956}
957
958VkResult DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer) {
959    return VK_SUCCESS;
960}
961
962VkResult DestroyRenderPass(VkDevice device, VkRenderPass renderPass) {
963    return VK_SUCCESS;
964}
965
966VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
967    ALOGV("TODO: vk%s", __FUNCTION__);
968    return VK_SUCCESS;
969}
970
971VkResult DestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {
972    return VK_SUCCESS;
973}
974
975VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) {
976    ALOGV("TODO: vk%s", __FUNCTION__);
977    return VK_SUCCESS;
978}
979
980VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) {
981    return VK_SUCCESS;
982}
983
984VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer) {
985    return VK_SUCCESS;
986}
987
988VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) {
989    ALOGV("TODO: vk%s", __FUNCTION__);
990    return VK_SUCCESS;
991}
992
993void CmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
994}
995
996void CmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) {
997}
998
999void CmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) {
1000}
1001
1002void CmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) {
1003}
1004
1005void CmdBindDynamicDepthStencilState(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) {
1006}
1007
1008void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
1009}
1010
1011void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
1012}
1013
1014void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
1015}
1016
1017void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) {
1018}
1019
1020void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) {
1021}
1022
1023void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
1024}
1025
1026void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
1027}
1028
1029void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
1030}
1031
1032void CmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
1033}
1034
1035void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
1036}
1037
1038void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
1039}
1040
1041void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter) {
1042}
1043
1044void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
1045}
1046
1047void CmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
1048}
1049
1050void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
1051}
1052
1053void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
1054}
1055
1056void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
1057}
1058
1059void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
1060}
1061
1062void CmdClearColorAttachment(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects) {
1063}
1064
1065void CmdClearDepthStencilAttachment(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects) {
1066}
1067
1068void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
1069}
1070
1071void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
1072}
1073
1074void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
1075}
1076
1077void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
1078}
1079
1080void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
1081}
1082
1083void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
1084}
1085
1086void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
1087}
1088
1089void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
1090}
1091
1092void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) {
1093}
1094
1095void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
1096}
1097
1098void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
1099}
1100
1101void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
1102}
1103
1104void CmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents) {
1105}
1106
1107void CmdEndRenderPass(VkCmdBuffer cmdBuffer) {
1108}
1109
1110void CmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) {
1111}
1112
1113#pragma clang diagnostic pop
1114// clang-format on
1115
1116}  // namespace null_driver
1117