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