| // Copyright 2018 The SwiftShader Authors. All Rights Reserved. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "VkDeviceMemory.hpp" | |
| #include "VkBuffer.hpp" | |
| #include "VkDevice.hpp" | |
| #include "VkImage.hpp" | |
| #include "VkStringify.hpp" | |
| #include "VkConfig.hpp" | |
| // Host-allocated memory and host-mapped foreign memory | |
| class ExternalMemoryHost : public vk::DeviceMemory, public vk::ObjectBase<ExternalMemoryHost, VkDeviceMemory> | |
| { | |
| public: | |
| struct AllocateInfo | |
| { | |
| bool supported = false; | |
| void *hostPointer = nullptr; | |
| AllocateInfo() = default; | |
| AllocateInfo(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo) | |
| { | |
| if(extendedAllocationInfo.importMemoryHostPointerInfo) | |
| { | |
| if((extendedAllocationInfo.importMemoryHostPointerInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT) && | |
| (extendedAllocationInfo.importMemoryHostPointerInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT)) | |
| { | |
| UNSUPPORTED("extendedAllocationInfo.importMemoryHostPointerInfo->handleType, %d", | |
| int(extendedAllocationInfo.importMemoryHostPointerInfo->handleType)); | |
| } | |
| hostPointer = extendedAllocationInfo.importMemoryHostPointerInfo->pHostPointer; | |
| supported = true; | |
| } | |
| } | |
| }; | |
| static const VkExternalMemoryHandleTypeFlagBits typeFlagBit = (VkExternalMemoryHandleTypeFlagBits)(VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT | VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT); | |
| static bool SupportsAllocateInfo(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo) | |
| { | |
| AllocateInfo info(extendedAllocationInfo); | |
| return info.supported; | |
| } | |
| explicit ExternalMemoryHost(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, vk::Device *pDevice) | |
| : vk::DeviceMemory(pCreateInfo, pDevice) | |
| , allocateInfo(extendedAllocationInfo) | |
| {} | |
| VkResult allocate(size_t size, void **pBuffer) override | |
| { | |
| if(allocateInfo.supported) | |
| { | |
| *pBuffer = allocateInfo.hostPointer; | |
| return VK_SUCCESS; | |
| } | |
| return VK_ERROR_INVALID_EXTERNAL_HANDLE; | |
| } | |
| void deallocate(void *buffer, size_t size) override | |
| {} | |
| VkExternalMemoryHandleTypeFlagBits getFlagBit() const override | |
| { | |
| return typeFlagBit; | |
| } | |
| private: | |
| AllocateInfo allocateInfo; | |
| }; | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD | |
| // Helper struct which reads the parsed allocation info and | |
| // extracts relevant information related to the handle type | |
| // supported by this DeviceMemory subclass. | |
| struct OpaqueFdAllocateInfo | |
| { | |
| bool importFd = false; | |
| bool exportFd = false; | |
| int fd = -1; | |
| OpaqueFdAllocateInfo() = default; | |
| // Read the parsed allocation info to initialize an OpaqueFdAllocateInfo. | |
| OpaqueFdAllocateInfo(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo) | |
| { | |
| if(extendedAllocationInfo.importMemoryFdInfo) | |
| { | |
| if(extendedAllocationInfo.importMemoryFdInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT) | |
| { | |
| UNSUPPORTED("VkImportMemoryFdInfoKHR::handleType %d", int(extendedAllocationInfo.importMemoryFdInfo->handleType)); | |
| } | |
| importFd = true; | |
| fd = extendedAllocationInfo.importMemoryFdInfo->fd; | |
| } | |
| if(extendedAllocationInfo.exportMemoryAllocateInfo) | |
| { | |
| if(extendedAllocationInfo.exportMemoryAllocateInfo->handleTypes != VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT) | |
| { | |
| UNSUPPORTED("VkExportMemoryAllocateInfo::handleTypes %d", int(extendedAllocationInfo.exportMemoryAllocateInfo->handleTypes)); | |
| } | |
| exportFd = true; | |
| } | |
| } | |
| }; | |
| # if defined(__APPLE__) | |
| # include "VkDeviceMemoryExternalMac.hpp" | |
| # elif defined(__linux__) && !defined(__ANDROID__) | |
| # include "VkDeviceMemoryExternalLinux.hpp" | |
| # else | |
| # error "Missing VK_KHR_external_memory_fd implementation for this platform!" | |
| # endif | |
| #endif | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER | |
| # if defined(__ANDROID__) | |
| # include "VkDeviceMemoryExternalAndroid.hpp" | |
| # else | |
| # error "Missing VK_ANDROID_external_memory_android_hardware_buffer implementation for this platform!" | |
| # endif | |
| #endif | |
| #if VK_USE_PLATFORM_FUCHSIA | |
| # include "VkDeviceMemoryExternalFuchsia.hpp" | |
| #endif | |
| namespace vk { | |
| VkResult DeviceMemory::Allocate(const VkAllocationCallbacks *pAllocator, const VkMemoryAllocateInfo *pAllocateInfo, VkDeviceMemory *pMemory, Device *device) | |
| { | |
| *pMemory = VK_NULL_HANDLE; | |
| vk::DeviceMemory::ExtendedAllocationInfo extendedAllocationInfo = {}; | |
| VkResult result = vk::DeviceMemory::ParseAllocationInfo(pAllocateInfo, &extendedAllocationInfo); | |
| if(result != VK_SUCCESS) | |
| { | |
| return result; | |
| } | |
| result = Allocate(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device); | |
| if(result != VK_SUCCESS) | |
| { | |
| return result; | |
| } | |
| // Make sure the memory allocation is done now so that OOM errors can be checked now | |
| return vk::Cast(*pMemory)->allocate(); | |
| } | |
| VkResult DeviceMemory::Allocate(const VkAllocationCallbacks *pAllocator, const VkMemoryAllocateInfo *pAllocateInfo, VkDeviceMemory *pMemory, | |
| const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, Device *device) | |
| { | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER | |
| if(AHardwareBufferExternalMemory::SupportsAllocateInfo(extendedAllocationInfo)) | |
| { | |
| return AHardwareBufferExternalMemory::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device); | |
| } | |
| #endif | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD | |
| if(OpaqueFdExternalMemory::SupportsAllocateInfo(extendedAllocationInfo)) | |
| { | |
| return OpaqueFdExternalMemory::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device); | |
| } | |
| #endif | |
| #if VK_USE_PLATFORM_FUCHSIA | |
| if(zircon::VmoExternalMemory::SupportsAllocateInfo(extendedAllocationInfo)) | |
| { | |
| return zircon::VmoExternalMemory::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device); | |
| } | |
| #endif | |
| if(ExternalMemoryHost::SupportsAllocateInfo(extendedAllocationInfo)) | |
| { | |
| return ExternalMemoryHost::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device); | |
| } | |
| return vk::DeviceMemoryInternal::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device); | |
| } | |
| DeviceMemory::DeviceMemory(const VkMemoryAllocateInfo *pAllocateInfo, Device *pDevice) | |
| : size(pAllocateInfo->allocationSize) | |
| , memoryTypeIndex(pAllocateInfo->memoryTypeIndex) | |
| , device(pDevice) | |
| { | |
| ASSERT(size); | |
| } | |
| void DeviceMemory::destroy(const VkAllocationCallbacks *pAllocator) | |
| { | |
| #ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT | |
| device->emitDeviceMemoryReport(isImport() ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT, getMemoryObjectId(), 0 /* size */, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)(void *)VkDeviceMemory(*this)); | |
| #endif // SWIFTSHADER_DEVICE_MEMORY_REPORT | |
| if(buffer) | |
| { | |
| deallocate(buffer, size); | |
| buffer = nullptr; | |
| } | |
| } | |
| size_t DeviceMemory::ComputeRequiredAllocationSize(const VkMemoryAllocateInfo *pAllocateInfo) | |
| { | |
| return 0; | |
| } | |
| VkResult DeviceMemory::ParseAllocationInfo(const VkMemoryAllocateInfo *pAllocateInfo, DeviceMemory::ExtendedAllocationInfo *extendedAllocationInfo) | |
| { | |
| const VkBaseInStructure *allocationInfo = reinterpret_cast<const VkBaseInStructure *>(pAllocateInfo->pNext); | |
| while(allocationInfo) | |
| { | |
| switch(allocationInfo->sType) | |
| { | |
| case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: | |
| // This can safely be ignored on most platforms, as the Vulkan spec mentions: | |
| // "If the pNext chain includes a VkMemoryDedicatedAllocateInfo structure, then that structure | |
| // includes a handle of the sole buffer or image resource that the memory *can* be bound to." | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER | |
| extendedAllocationInfo->dedicatedAllocateInfo = reinterpret_cast<const VkMemoryDedicatedAllocateInfo *>(allocationInfo); | |
| #endif | |
| break; | |
| case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: | |
| // This extension controls on which physical devices the memory gets allocated. | |
| // SwiftShader only has a single physical device, so this extension does nothing in this case. | |
| break; | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD | |
| case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: | |
| extendedAllocationInfo->importMemoryFdInfo = reinterpret_cast<const VkImportMemoryFdInfoKHR *>(allocationInfo); | |
| if(extendedAllocationInfo->importMemoryFdInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT) | |
| { | |
| UNSUPPORTED("extendedAllocationInfo->importMemoryFdInfo->handleType %u", extendedAllocationInfo->importMemoryFdInfo->handleType); | |
| return VK_ERROR_INVALID_EXTERNAL_HANDLE; | |
| } | |
| break; | |
| #endif // SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD | |
| case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: | |
| extendedAllocationInfo->exportMemoryAllocateInfo = reinterpret_cast<const VkExportMemoryAllocateInfo *>(allocationInfo); | |
| switch(extendedAllocationInfo->exportMemoryAllocateInfo->handleTypes) | |
| { | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD | |
| case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: | |
| break; | |
| #endif | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER | |
| case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID: | |
| break; | |
| #endif | |
| #if VK_USE_PLATFORM_FUCHSIA | |
| case VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA: | |
| break; | |
| #endif | |
| default: | |
| UNSUPPORTED("extendedAllocationInfo->exportMemoryAllocateInfo->handleTypes %u", extendedAllocationInfo->exportMemoryAllocateInfo->handleTypes); | |
| return VK_ERROR_INVALID_EXTERNAL_HANDLE; | |
| } | |
| break; | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER | |
| case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: | |
| extendedAllocationInfo->importAndroidHardwareBufferInfo = reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID *>(allocationInfo); | |
| break; | |
| #endif // SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER | |
| case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: | |
| extendedAllocationInfo->importMemoryHostPointerInfo = reinterpret_cast<const VkImportMemoryHostPointerInfoEXT *>(allocationInfo); | |
| if((extendedAllocationInfo->importMemoryHostPointerInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT) && | |
| (extendedAllocationInfo->importMemoryHostPointerInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT)) | |
| { | |
| UNSUPPORTED("extendedAllocationInfo->importMemoryHostPointerInfo->handleType %u", extendedAllocationInfo->importMemoryHostPointerInfo->handleType); | |
| return VK_ERROR_INVALID_EXTERNAL_HANDLE; | |
| } | |
| break; | |
| #if VK_USE_PLATFORM_FUCHSIA | |
| case VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: | |
| extendedAllocationInfo->importMemoryZirconHandleInfo = reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(allocationInfo); | |
| if(extendedAllocationInfo->importMemoryZirconHandleInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA) | |
| { | |
| UNSUPPORTED("extendedAllocationInfo->importMemoryZirconHandleInfo->handleType %u", extendedAllocationInfo->importMemoryZirconHandleInfo->handleType); | |
| return VK_ERROR_INVALID_EXTERNAL_HANDLE; | |
| } | |
| break; | |
| #endif // VK_USE_PLATFORM_FUCHSIA | |
| default: | |
| LOG_TRAP("pAllocateInfo->pNext sType = %s", vk::Stringify(allocationInfo->sType).c_str()); | |
| break; | |
| } | |
| allocationInfo = allocationInfo->pNext; | |
| } | |
| return VK_SUCCESS; | |
| } | |
| VkResult DeviceMemory::allocate() | |
| { | |
| if(size > MAX_MEMORY_ALLOCATION_SIZE) | |
| { | |
| #ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT | |
| device->emitDeviceMemoryReport(VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT, 0 /* memoryObjectId */, size, VK_OBJECT_TYPE_DEVICE_MEMORY, 0 /* objectHandle */); | |
| #endif // SWIFTSHADER_DEVICE_MEMORY_REPORT | |
| return VK_ERROR_OUT_OF_DEVICE_MEMORY; | |
| } | |
| VkResult result = VK_SUCCESS; | |
| if(!buffer) | |
| { | |
| result = allocate(size, &buffer); | |
| } | |
| #ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT | |
| if(result == VK_SUCCESS) | |
| { | |
| device->emitDeviceMemoryReport(isImport() ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT, getMemoryObjectId(), size, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)(void *)VkDeviceMemory(*this)); | |
| } | |
| else | |
| { | |
| device->emitDeviceMemoryReport(VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT, 0 /* memoryObjectId */, size, VK_OBJECT_TYPE_DEVICE_MEMORY, 0 /* objectHandle */); | |
| } | |
| #endif // SWIFTSHADER_DEVICE_MEMORY_REPORT | |
| return result; | |
| } | |
| VkResult DeviceMemory::map(VkDeviceSize pOffset, VkDeviceSize pSize, void **ppData) | |
| { | |
| *ppData = getOffsetPointer(pOffset); | |
| return VK_SUCCESS; | |
| } | |
| VkDeviceSize DeviceMemory::getCommittedMemoryInBytes() const | |
| { | |
| return size; | |
| } | |
| void *DeviceMemory::getOffsetPointer(VkDeviceSize pOffset) const | |
| { | |
| ASSERT(buffer); | |
| return reinterpret_cast<char *>(buffer) + pOffset; | |
| } | |
| bool DeviceMemory::checkExternalMemoryHandleType( | |
| VkExternalMemoryHandleTypeFlags supportedHandleTypes) const | |
| { | |
| if(!supportedHandleTypes) | |
| { | |
| // This image or buffer does not need to be stored on external | |
| // memory, so this check should always pass. | |
| return true; | |
| } | |
| VkExternalMemoryHandleTypeFlagBits handle_type_bit = getFlagBit(); | |
| if(!handle_type_bit) | |
| { | |
| // This device memory is not external and can accommodate | |
| // any image or buffer as well. | |
| return true; | |
| } | |
| // Return true only if the external memory type is compatible with the | |
| // one specified during VkCreate{Image,Buffer}(), through a | |
| // VkExternalMemory{Image,Buffer}AllocateInfo struct. | |
| return (supportedHandleTypes & handle_type_bit) != 0; | |
| } | |
| // Allocate the memory according to |size|. On success return VK_SUCCESS | |
| // and sets |*pBuffer|. | |
| VkResult DeviceMemory::allocate(size_t size, void **pBuffer) | |
| { | |
| buffer = vk::allocate(size, REQUIRED_MEMORY_ALIGNMENT, DEVICE_MEMORY); | |
| if(!buffer) | |
| { | |
| return VK_ERROR_OUT_OF_DEVICE_MEMORY; | |
| } | |
| *pBuffer = buffer; | |
| return VK_SUCCESS; | |
| } | |
| // Deallocate previously allocated memory at |buffer|. | |
| void DeviceMemory::deallocate(void *buffer, size_t size) | |
| { | |
| vk::deallocate(buffer, DEVICE_MEMORY); | |
| buffer = nullptr; | |
| } | |
| // Return the handle type flag bit supported by this implementation. | |
| // A value of 0 corresponds to non-external memory. | |
| VkExternalMemoryHandleTypeFlagBits DeviceMemory::getFlagBit() const | |
| { | |
| // Does not support any external memory type at all. | |
| static const VkExternalMemoryHandleTypeFlagBits typeFlagBit = (VkExternalMemoryHandleTypeFlagBits)0; | |
| return typeFlagBit; | |
| } | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD | |
| VkResult DeviceMemory::exportFd(int *pFd) const | |
| { | |
| return VK_ERROR_INVALID_EXTERNAL_HANDLE; | |
| } | |
| #endif | |
| #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER | |
| VkResult DeviceMemory::exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const | |
| { | |
| return VK_ERROR_OUT_OF_HOST_MEMORY; | |
| } | |
| VkResult DeviceMemory::GetAndroidHardwareBufferProperties(VkDevice &ahbDevice, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties) | |
| { | |
| return AHardwareBufferExternalMemory::GetAndroidHardwareBufferProperties(ahbDevice, buffer, pProperties); | |
| } | |
| #endif | |
| #if VK_USE_PLATFORM_FUCHSIA | |
| VkResult DeviceMemory::exportHandle(zx_handle_t *pHandle) const | |
| { | |
| return VK_ERROR_INVALID_EXTERNAL_HANDLE; | |
| } | |
| #endif | |
| } // namespace vk |