1 /*------------------------------------------------------------------------- 2 * Vulkan CTS Framework 3 * -------------------- 4 * 5 * Copyright (c) 2015 Google Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Null (dummy) Vulkan implementation. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "vkNullDriver.hpp" 25 #include "vkPlatform.hpp" 26 #include "vkImageUtil.hpp" 27 #include "tcuFunctionLibrary.hpp" 28 #include "deMemory.h" 29 30 #include <stdexcept> 31 #include <algorithm> 32 33 namespace vk 34 { 35 36 namespace 37 { 38 39 using std::vector; 40 41 // Memory management 42 43 template<typename T> 44 void* allocateSystemMem (const VkAllocationCallbacks* pAllocator, VkSystemAllocationScope scope) 45 { 46 void* ptr = pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(T), sizeof(void*), scope); 47 if (!ptr) 48 throw std::bad_alloc(); 49 return ptr; 50 } 51 52 void freeSystemMem (const VkAllocationCallbacks* pAllocator, void* mem) 53 { 54 pAllocator->pfnFree(pAllocator->pUserData, mem); 55 } 56 57 template<typename Object, typename Handle, typename Parent, typename CreateInfo> 58 Handle allocateHandle (Parent parent, const CreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator) 59 { 60 Object* obj = DE_NULL; 61 62 if (pAllocator) 63 { 64 void* mem = allocateSystemMem<Object>(pAllocator, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); 65 try 66 { 67 obj = new (mem) Object(parent, pCreateInfo); 68 DE_ASSERT(obj == mem); 69 } 70 catch (...) 71 { 72 pAllocator->pfnFree(pAllocator->pUserData, mem); 73 throw; 74 } 75 } 76 else 77 obj = new Object(parent, pCreateInfo); 78 79 return reinterpret_cast<Handle>(obj); 80 } 81 82 template<typename Object, typename Handle, typename CreateInfo> 83 Handle allocateHandle (const CreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator) 84 { 85 Object* obj = DE_NULL; 86 87 if (pAllocator) 88 { 89 void* mem = allocateSystemMem<Object>(pAllocator, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); 90 try 91 { 92 obj = new (mem) Object(pCreateInfo); 93 DE_ASSERT(obj == mem); 94 } 95 catch (...) 96 { 97 pAllocator->pfnFree(pAllocator->pUserData, mem); 98 throw; 99 } 100 } 101 else 102 obj = new Object(pCreateInfo); 103 104 return reinterpret_cast<Handle>(obj); 105 } 106 107 template<typename Object, typename Handle> 108 void freeHandle (Handle handle, const VkAllocationCallbacks* pAllocator) 109 { 110 Object* obj = reinterpret_cast<Object*>(handle); 111 112 if (pAllocator) 113 { 114 obj->~Object(); 115 freeSystemMem(pAllocator, reinterpret_cast<void*>(obj)); 116 } 117 else 118 delete obj; 119 } 120 121 template<typename Object, typename Handle, typename Parent, typename CreateInfo> 122 Handle allocateNonDispHandle (Parent parent, const CreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator) 123 { 124 Object* const obj = allocateHandle<Object, Object*>(parent, pCreateInfo, pAllocator); 125 return Handle((deUint64)(deUintptr)obj); 126 } 127 128 template<typename Object, typename Handle> 129 void freeNonDispHandle (Handle handle, const VkAllocationCallbacks* pAllocator) 130 { 131 freeHandle<Object>(reinterpret_cast<Object*>((deUintptr)handle.getInternal()), pAllocator); 132 } 133 134 // Object definitions 135 136 #define VK_NULL_RETURN(STMT) \ 137 do { \ 138 try { \ 139 STMT; \ 140 return VK_SUCCESS; \ 141 } catch (const std::bad_alloc&) { \ 142 return VK_ERROR_OUT_OF_HOST_MEMORY; \ 143 } catch (VkResult res) { \ 144 return res; \ 145 } \ 146 } while (deGetFalse()) 147 148 // \todo [2015-07-14 pyry] Check FUNC type by checkedCastToPtr<T>() or similar 149 #define VK_NULL_FUNC_ENTRY(NAME, FUNC) { #NAME, (deFunctionPtr)FUNC } 150 151 #define VK_NULL_DEFINE_DEVICE_OBJ(NAME) \ 152 struct NAME \ 153 { \ 154 NAME (VkDevice, const Vk##NAME##CreateInfo*) {} \ 155 } 156 157 VK_NULL_DEFINE_DEVICE_OBJ(Fence); 158 VK_NULL_DEFINE_DEVICE_OBJ(Semaphore); 159 VK_NULL_DEFINE_DEVICE_OBJ(Event); 160 VK_NULL_DEFINE_DEVICE_OBJ(QueryPool); 161 VK_NULL_DEFINE_DEVICE_OBJ(BufferView); 162 VK_NULL_DEFINE_DEVICE_OBJ(ImageView); 163 VK_NULL_DEFINE_DEVICE_OBJ(ShaderModule); 164 VK_NULL_DEFINE_DEVICE_OBJ(PipelineCache); 165 VK_NULL_DEFINE_DEVICE_OBJ(PipelineLayout); 166 VK_NULL_DEFINE_DEVICE_OBJ(RenderPass); 167 VK_NULL_DEFINE_DEVICE_OBJ(DescriptorSetLayout); 168 VK_NULL_DEFINE_DEVICE_OBJ(Sampler); 169 VK_NULL_DEFINE_DEVICE_OBJ(Framebuffer); 170 VK_NULL_DEFINE_DEVICE_OBJ(CommandPool); 171 172 class Instance 173 { 174 public: 175 Instance (const VkInstanceCreateInfo* instanceInfo); 176 ~Instance (void) {} 177 178 PFN_vkVoidFunction getProcAddr (const char* name) const { return (PFN_vkVoidFunction)m_functions.getFunction(name); } 179 180 private: 181 const tcu::StaticFunctionLibrary m_functions; 182 }; 183 184 class SurfaceKHR 185 { 186 public: 187 SurfaceKHR (VkInstance, const VkXlibSurfaceCreateInfoKHR*) {} 188 SurfaceKHR (VkInstance, const VkXcbSurfaceCreateInfoKHR*) {} 189 SurfaceKHR (VkInstance, const VkWaylandSurfaceCreateInfoKHR*) {} 190 SurfaceKHR (VkInstance, const VkMirSurfaceCreateInfoKHR*) {} 191 SurfaceKHR (VkInstance, const VkAndroidSurfaceCreateInfoKHR*) {} 192 SurfaceKHR (VkInstance, const VkWin32SurfaceCreateInfoKHR*) {} 193 SurfaceKHR (VkInstance, const VkDisplaySurfaceCreateInfoKHR*) {} 194 ~SurfaceKHR (void) {} 195 }; 196 197 class DisplayModeKHR 198 { 199 public: 200 DisplayModeKHR (VkDisplayKHR, const VkDisplayModeCreateInfoKHR*) {} 201 ~DisplayModeKHR (void) {} 202 }; 203 204 class DebugReportCallbackEXT 205 { 206 public: 207 DebugReportCallbackEXT (VkInstance, const VkDebugReportCallbackCreateInfoEXT*) {} 208 ~DebugReportCallbackEXT (void) {} 209 }; 210 211 class Device 212 { 213 public: 214 Device (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* deviceInfo); 215 ~Device (void) {} 216 217 PFN_vkVoidFunction getProcAddr (const char* name) const { return (PFN_vkVoidFunction)m_functions.getFunction(name); } 218 219 private: 220 const tcu::StaticFunctionLibrary m_functions; 221 }; 222 223 class Pipeline 224 { 225 public: 226 Pipeline (VkDevice, const VkGraphicsPipelineCreateInfo*) {} 227 Pipeline (VkDevice, const VkComputePipelineCreateInfo*) {} 228 }; 229 230 class SwapchainKHR 231 { 232 public: 233 SwapchainKHR (VkDevice, const VkSwapchainCreateInfoKHR*) {} 234 ~SwapchainKHR (void) {} 235 }; 236 237 void* allocateHeap (const VkMemoryAllocateInfo* pAllocInfo) 238 { 239 // \todo [2015-12-03 pyry] Alignment requirements? 240 // \todo [2015-12-03 pyry] Empty allocations okay? 241 if (pAllocInfo->allocationSize > 0) 242 { 243 void* const heapPtr = deMalloc((size_t)pAllocInfo->allocationSize); 244 if (!heapPtr) 245 throw std::bad_alloc(); 246 return heapPtr; 247 } 248 else 249 return DE_NULL; 250 } 251 252 void freeHeap (void* ptr) 253 { 254 deFree(ptr); 255 } 256 257 class DeviceMemory 258 { 259 public: 260 DeviceMemory (VkDevice, const VkMemoryAllocateInfo* pAllocInfo) 261 : m_memory(allocateHeap(pAllocInfo)) 262 { 263 } 264 ~DeviceMemory (void) 265 { 266 freeHeap(m_memory); 267 } 268 269 void* getPtr (void) const { return m_memory; } 270 271 private: 272 void* const m_memory; 273 }; 274 275 class Buffer 276 { 277 public: 278 Buffer (VkDevice, const VkBufferCreateInfo* pCreateInfo) 279 : m_size(pCreateInfo->size) 280 {} 281 282 VkDeviceSize getSize (void) const { return m_size; } 283 284 private: 285 const VkDeviceSize m_size; 286 }; 287 288 class Image 289 { 290 public: 291 Image (VkDevice, const VkImageCreateInfo* pCreateInfo) 292 : m_imageType (pCreateInfo->imageType) 293 , m_format (pCreateInfo->format) 294 , m_extent (pCreateInfo->extent) 295 , m_samples (pCreateInfo->samples) 296 {} 297 298 VkImageType getImageType (void) const { return m_imageType; } 299 VkFormat getFormat (void) const { return m_format; } 300 VkExtent3D getExtent (void) const { return m_extent; } 301 VkSampleCountFlagBits getSamples (void) const { return m_samples; } 302 303 private: 304 const VkImageType m_imageType; 305 const VkFormat m_format; 306 const VkExtent3D m_extent; 307 const VkSampleCountFlagBits m_samples; 308 }; 309 310 class CommandBuffer 311 { 312 public: 313 CommandBuffer(VkDevice, VkCommandPool, VkCommandBufferLevel) 314 {} 315 }; 316 317 class DescriptorSet 318 { 319 public: 320 DescriptorSet (VkDevice, VkDescriptorPool, VkDescriptorSetLayout) {} 321 }; 322 323 class DescriptorPool 324 { 325 public: 326 DescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo) 327 : m_device (device) 328 , m_flags (pCreateInfo->flags) 329 {} 330 ~DescriptorPool (void) 331 { 332 reset(); 333 } 334 335 VkDescriptorSet allocate (VkDescriptorSetLayout setLayout); 336 void free (VkDescriptorSet set); 337 338 void reset (void); 339 340 private: 341 const VkDevice m_device; 342 const VkDescriptorPoolCreateFlags m_flags; 343 344 vector<DescriptorSet*> m_managedSets; 345 }; 346 347 VkDescriptorSet DescriptorPool::allocate (VkDescriptorSetLayout setLayout) 348 { 349 DescriptorSet* const impl = new DescriptorSet(m_device, VkDescriptorPool(reinterpret_cast<deUintptr>(this)), setLayout); 350 351 try 352 { 353 m_managedSets.push_back(impl); 354 } 355 catch (...) 356 { 357 delete impl; 358 throw; 359 } 360 361 return VkDescriptorSet(reinterpret_cast<deUintptr>(impl)); 362 } 363 364 void DescriptorPool::free (VkDescriptorSet set) 365 { 366 DescriptorSet* const impl = reinterpret_cast<DescriptorSet*>((deUintptr)set.getInternal()); 367 368 DE_ASSERT(m_flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT); 369 370 delete impl; 371 372 for (size_t ndx = 0; ndx < m_managedSets.size(); ++ndx) 373 { 374 if (m_managedSets[ndx] == impl) 375 { 376 std::swap(m_managedSets[ndx], m_managedSets.back()); 377 m_managedSets.pop_back(); 378 return; 379 } 380 } 381 382 DE_FATAL("VkDescriptorSet not owned by VkDescriptorPool"); 383 } 384 385 void DescriptorPool::reset (void) 386 { 387 for (size_t ndx = 0; ndx < m_managedSets.size(); ++ndx) 388 delete m_managedSets[ndx]; 389 m_managedSets.clear(); 390 } 391 392 // API implementation 393 394 extern "C" 395 { 396 397 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL getInstanceProcAddr (VkInstance instance, const char* pName) 398 { 399 return reinterpret_cast<Instance*>(instance)->getProcAddr(pName); 400 } 401 402 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL getDeviceProcAddr (VkDevice device, const char* pName) 403 { 404 return reinterpret_cast<Device*>(device)->getProcAddr(pName); 405 } 406 407 VKAPI_ATTR VkResult VKAPI_CALL createGraphicsPipelines (VkDevice device, VkPipelineCache, deUint32 count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) 408 { 409 deUint32 allocNdx; 410 try 411 { 412 for (allocNdx = 0; allocNdx < count; allocNdx++) 413 pPipelines[allocNdx] = allocateNonDispHandle<Pipeline, VkPipeline>(device, pCreateInfos+allocNdx, pAllocator); 414 415 return VK_SUCCESS; 416 } 417 catch (const std::bad_alloc&) 418 { 419 for (deUint32 freeNdx = 0; freeNdx < allocNdx; freeNdx++) 420 freeNonDispHandle<Pipeline, VkPipeline>(pPipelines[freeNdx], pAllocator); 421 422 return VK_ERROR_OUT_OF_HOST_MEMORY; 423 } 424 catch (VkResult err) 425 { 426 for (deUint32 freeNdx = 0; freeNdx < allocNdx; freeNdx++) 427 freeNonDispHandle<Pipeline, VkPipeline>(pPipelines[freeNdx], pAllocator); 428 429 return err; 430 } 431 } 432 433 VKAPI_ATTR VkResult VKAPI_CALL createComputePipelines (VkDevice device, VkPipelineCache, deUint32 count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) 434 { 435 deUint32 allocNdx; 436 try 437 { 438 for (allocNdx = 0; allocNdx < count; allocNdx++) 439 pPipelines[allocNdx] = allocateNonDispHandle<Pipeline, VkPipeline>(device, pCreateInfos+allocNdx, pAllocator); 440 441 return VK_SUCCESS; 442 } 443 catch (const std::bad_alloc&) 444 { 445 for (deUint32 freeNdx = 0; freeNdx < allocNdx; freeNdx++) 446 freeNonDispHandle<Pipeline, VkPipeline>(pPipelines[freeNdx], pAllocator); 447 448 return VK_ERROR_OUT_OF_HOST_MEMORY; 449 } 450 catch (VkResult err) 451 { 452 for (deUint32 freeNdx = 0; freeNdx < allocNdx; freeNdx++) 453 freeNonDispHandle<Pipeline, VkPipeline>(pPipelines[freeNdx], pAllocator); 454 455 return err; 456 } 457 } 458 459 VKAPI_ATTR VkResult VKAPI_CALL enumeratePhysicalDevices (VkInstance, deUint32* pPhysicalDeviceCount, VkPhysicalDevice* pDevices) 460 { 461 if (pDevices && *pPhysicalDeviceCount >= 1u) 462 *pDevices = reinterpret_cast<VkPhysicalDevice>((void*)(deUintptr)1u); 463 464 *pPhysicalDeviceCount = 1; 465 466 return VK_SUCCESS; 467 } 468 469 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties (VkPhysicalDevice, VkPhysicalDeviceProperties* props) 470 { 471 deMemset(props, 0, sizeof(VkPhysicalDeviceProperties)); 472 473 props->apiVersion = VK_API_VERSION; 474 props->driverVersion = 1u; 475 props->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER; 476 477 deMemcpy(props->deviceName, "null", 5); 478 479 // \todo [2015-09-25 pyry] Fill in reasonable limits 480 props->limits.maxTexelBufferElements = 8096; 481 } 482 483 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice, deUint32* count, VkQueueFamilyProperties* props) 484 { 485 if (props && *count >= 1u) 486 { 487 deMemset(props, 0, sizeof(VkQueueFamilyProperties)); 488 489 props->queueCount = 1u; 490 props->queueFlags = VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT; 491 props->timestampValidBits = 64; 492 } 493 494 *count = 1u; 495 } 496 497 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMemoryProperties (VkPhysicalDevice, VkPhysicalDeviceMemoryProperties* props) 498 { 499 deMemset(props, 0, sizeof(VkPhysicalDeviceMemoryProperties)); 500 501 props->memoryTypeCount = 1u; 502 props->memoryTypes[0].heapIndex = 0u; 503 props->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; 504 505 props->memoryHeapCount = 1u; 506 props->memoryHeaps[0].size = 1ull << 31; 507 props->memoryHeaps[0].flags = 0u; 508 } 509 510 VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFormatProperties (VkPhysicalDevice, VkFormat, VkFormatProperties* pFormatProperties) 511 { 512 const VkFormatFeatureFlags allFeatures = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT 513 | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT 514 | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT 515 | VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT 516 | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT 517 | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT 518 | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT 519 | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT 520 | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT 521 | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT 522 | VK_FORMAT_FEATURE_BLIT_SRC_BIT 523 | VK_FORMAT_FEATURE_BLIT_DST_BIT; 524 525 pFormatProperties->linearTilingFeatures = allFeatures; 526 pFormatProperties->optimalTilingFeatures = allFeatures; 527 pFormatProperties->bufferFeatures = allFeatures; 528 } 529 530 VKAPI_ATTR void VKAPI_CALL getBufferMemoryRequirements (VkDevice, VkBuffer bufferHandle, VkMemoryRequirements* requirements) 531 { 532 const Buffer* buffer = reinterpret_cast<const Buffer*>(bufferHandle.getInternal()); 533 534 requirements->memoryTypeBits = 1u; 535 requirements->size = buffer->getSize(); 536 requirements->alignment = (VkDeviceSize)1u; 537 } 538 539 VkDeviceSize getPackedImageDataSize (VkFormat format, VkExtent3D extent, VkSampleCountFlagBits samples) 540 { 541 return (VkDeviceSize)getPixelSize(mapVkFormat(format)) 542 * (VkDeviceSize)extent.width 543 * (VkDeviceSize)extent.height 544 * (VkDeviceSize)extent.depth 545 * (VkDeviceSize)samples; 546 } 547 548 VkDeviceSize getCompressedImageDataSize (VkFormat format, VkExtent3D extent) 549 { 550 try 551 { 552 const tcu::CompressedTexFormat tcuFormat = mapVkCompressedFormat(format); 553 const size_t blockSize = tcu::getBlockSize(tcuFormat); 554 const tcu::IVec3 blockPixelSize = tcu::getBlockPixelSize(tcuFormat); 555 const int numBlocksX = deDivRoundUp32((int)extent.width, blockPixelSize.x()); 556 const int numBlocksY = deDivRoundUp32((int)extent.height, blockPixelSize.y()); 557 const int numBlocksZ = deDivRoundUp32((int)extent.depth, blockPixelSize.z()); 558 559 return blockSize*numBlocksX*numBlocksY*numBlocksZ; 560 } 561 catch (...) 562 { 563 return 0; // Unsupported compressed format 564 } 565 } 566 567 VKAPI_ATTR void VKAPI_CALL getImageMemoryRequirements (VkDevice, VkImage imageHandle, VkMemoryRequirements* requirements) 568 { 569 const Image* image = reinterpret_cast<const Image*>(imageHandle.getInternal()); 570 571 requirements->memoryTypeBits = 1u; 572 requirements->alignment = 16u; 573 574 if (isCompressedFormat(image->getFormat())) 575 requirements->size = getCompressedImageDataSize(image->getFormat(), image->getExtent()); 576 else 577 requirements->size = getPackedImageDataSize(image->getFormat(), image->getExtent(), image->getSamples()); 578 } 579 580 VKAPI_ATTR VkResult VKAPI_CALL mapMemory (VkDevice, VkDeviceMemory memHandle, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) 581 { 582 const DeviceMemory* memory = reinterpret_cast<DeviceMemory*>(memHandle.getInternal()); 583 584 DE_UNREF(size); 585 DE_UNREF(flags); 586 587 *ppData = (deUint8*)memory->getPtr() + offset; 588 589 return VK_SUCCESS; 590 } 591 592 VKAPI_ATTR VkResult VKAPI_CALL allocateDescriptorSets (VkDevice, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) 593 { 594 DescriptorPool* const poolImpl = reinterpret_cast<DescriptorPool*>((deUintptr)pAllocateInfo->descriptorPool.getInternal()); 595 596 for (deUint32 ndx = 0; ndx < pAllocateInfo->descriptorSetCount; ++ndx) 597 { 598 try 599 { 600 pDescriptorSets[ndx] = poolImpl->allocate(pAllocateInfo->pSetLayouts[ndx]); 601 } 602 catch (const std::bad_alloc&) 603 { 604 for (deUint32 freeNdx = 0; freeNdx < ndx; freeNdx++) 605 delete reinterpret_cast<DescriptorSet*>((deUintptr)pDescriptorSets[freeNdx].getInternal()); 606 607 return VK_ERROR_OUT_OF_HOST_MEMORY; 608 } 609 catch (VkResult res) 610 { 611 for (deUint32 freeNdx = 0; freeNdx < ndx; freeNdx++) 612 delete reinterpret_cast<DescriptorSet*>((deUintptr)pDescriptorSets[freeNdx].getInternal()); 613 614 return res; 615 } 616 } 617 618 return VK_SUCCESS; 619 } 620 621 VKAPI_ATTR void VKAPI_CALL freeDescriptorSets (VkDevice, VkDescriptorPool descriptorPool, deUint32 count, const VkDescriptorSet* pDescriptorSets) 622 { 623 DescriptorPool* const poolImpl = reinterpret_cast<DescriptorPool*>((deUintptr)descriptorPool.getInternal()); 624 625 for (deUint32 ndx = 0; ndx < count; ++ndx) 626 poolImpl->free(pDescriptorSets[ndx]); 627 } 628 629 VKAPI_ATTR VkResult VKAPI_CALL resetDescriptorPool (VkDevice, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags) 630 { 631 DescriptorPool* const poolImpl = reinterpret_cast<DescriptorPool*>((deUintptr)descriptorPool.getInternal()); 632 633 poolImpl->reset(); 634 635 return VK_SUCCESS; 636 } 637 638 VKAPI_ATTR VkResult VKAPI_CALL allocateCommandBuffers (VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) 639 { 640 if (pAllocateInfo && pCommandBuffers) 641 { 642 for (deUint32 ndx = 0; ndx < pAllocateInfo->commandBufferCount; ++ndx) 643 { 644 pCommandBuffers[ndx] = reinterpret_cast<VkCommandBuffer>(new CommandBuffer(device, pAllocateInfo->commandPool, pAllocateInfo->level)); 645 } 646 } 647 648 return VK_SUCCESS; 649 } 650 651 VKAPI_ATTR void VKAPI_CALL freeCommandBuffers (VkDevice device, VkCommandPool commandPool, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers) 652 { 653 DE_UNREF(device); 654 DE_UNREF(commandPool); 655 656 for (deUint32 ndx = 0; ndx < commandBufferCount; ++ndx) 657 delete reinterpret_cast<CommandBuffer*>(pCommandBuffers[ndx]); 658 } 659 660 661 VKAPI_ATTR VkResult VKAPI_CALL createDisplayModeKHR (VkPhysicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) 662 { 663 DE_UNREF(pAllocator); 664 VK_NULL_RETURN((*pMode = allocateNonDispHandle<DisplayModeKHR, VkDisplayModeKHR>(display, pCreateInfo, pAllocator))); 665 } 666 667 VKAPI_ATTR VkResult VKAPI_CALL createSharedSwapchainsKHR (VkDevice device, deUint32 swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) 668 { 669 for (deUint32 ndx = 0; ndx < swapchainCount; ++ndx) 670 { 671 pSwapchains[ndx] = allocateNonDispHandle<SwapchainKHR, VkSwapchainKHR>(device, pCreateInfos+ndx, pAllocator); 672 } 673 674 return VK_SUCCESS; 675 } 676 677 #include "vkNullDriverImpl.inl" 678 679 } // extern "C" 680 681 Instance::Instance (const VkInstanceCreateInfo*) 682 : m_functions(s_instanceFunctions, DE_LENGTH_OF_ARRAY(s_instanceFunctions)) 683 { 684 } 685 686 Device::Device (VkPhysicalDevice, const VkDeviceCreateInfo*) 687 : m_functions(s_deviceFunctions, DE_LENGTH_OF_ARRAY(s_deviceFunctions)) 688 { 689 } 690 691 class NullDriverLibrary : public Library 692 { 693 public: 694 NullDriverLibrary (void) 695 : m_library (s_platformFunctions, DE_LENGTH_OF_ARRAY(s_platformFunctions)) 696 , m_driver (m_library) 697 {} 698 699 const PlatformInterface& getPlatformInterface (void) const { return m_driver; } 700 701 private: 702 const tcu::StaticFunctionLibrary m_library; 703 const PlatformDriver m_driver; 704 }; 705 706 } // anonymous 707 708 Library* createNullDriver (void) 709 { 710 return new NullDriverLibrary(); 711 } 712 713 } // vk 714
