blob: 1c83f2c3b7e0a0d42a2b2d36e72a3d93687b6d1e [file] [log] [blame]
// 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.
#ifndef VK_DEVICE_MEMORY_HPP_
#define VK_DEVICE_MEMORY_HPP_
#include "VkConfig.hpp"
#include "VkObject.hpp"
namespace vk {
class Device;
class DeviceMemory
{
public:
struct ExtendedAllocationInfo
{
VkDeviceSize allocationSize = 0;
uint32_t memoryTypeIndex = 0;
const VkExportMemoryAllocateInfo *exportMemoryAllocateInfo = nullptr;
const VkImportMemoryHostPointerInfoEXT *importMemoryHostPointerInfo = nullptr;
#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
const VkImportMemoryFdInfoKHR *importMemoryFdInfo = nullptr;
#endif
#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
const VkImportAndroidHardwareBufferInfoANDROID *importAndroidHardwareBufferInfo = nullptr;
const VkMemoryDedicatedAllocateInfo *dedicatedAllocateInfo = nullptr;
#endif
#if VK_USE_PLATFORM_FUCHSIA
const VkImportMemoryZirconHandleInfoFUCHSIA *importMemoryZirconHandleInfo = nullptr;
#endif
};
protected:
DeviceMemory(const VkMemoryAllocateInfo *pCreateInfo, Device *pDevice);
public:
virtual ~DeviceMemory() {}
static VkResult Allocate(const VkAllocationCallbacks *pAllocator, const VkMemoryAllocateInfo *pAllocateInfo, VkDeviceMemory *pMemory, Device *device);
operator VkDeviceMemory()
{
return vk::TtoVkT<DeviceMemory, VkDeviceMemory>(this);
}
static inline DeviceMemory *Cast(VkDeviceMemory object)
{
return vk::VkTtoT<DeviceMemory, VkDeviceMemory>(object);
}
static size_t ComputeRequiredAllocationSize(const VkMemoryAllocateInfo *pCreateInfo);
#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
virtual VkResult exportFd(int *pFd) const;
#endif
#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
virtual VkResult exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const;
static VkResult GetAndroidHardwareBufferProperties(VkDevice &device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties);
#endif
#if VK_USE_PLATFORM_FUCHSIA
virtual VkResult exportHandle(zx_handle_t *pHandle) const;
#endif
void destroy(const VkAllocationCallbacks *pAllocator);
VkResult allocate();
VkResult map(VkDeviceSize offset, VkDeviceSize size, void **ppData);
VkDeviceSize getCommittedMemoryInBytes() const;
void *getOffsetPointer(VkDeviceSize pOffset) const;
uint32_t getMemoryTypeIndex() const { return memoryTypeIndex; }
// If this is external memory, return true iff its handle type matches the bitmask
// provided by |supportedExternalHandleTypes|. Otherwise, always return true.
bool checkExternalMemoryHandleType(
VkExternalMemoryHandleTypeFlags supportedExternalMemoryHandleType) const;
// Some external device memories, such as Android hardware buffers, represent
// specific images with requirements.
virtual bool hasExternalImageProperties() const { return false; }
virtual int externalImageRowPitchBytes(VkImageAspectFlagBits aspect) const { return 0; }
virtual VkDeviceSize externalImageMemoryOffset(VkImageAspectFlagBits aspect) const { return 0; }
protected:
// Allocate the memory according to `allocationSize`. On success return VK_SUCCESS and sets `buffer`.
virtual VkResult allocateBuffer();
// Free previously allocated memory at `buffer`.
virtual void freeBuffer();
// Return the handle type flag bit supported by this implementation.
// A value of 0 corresponds to non-external memory.
virtual VkExternalMemoryHandleTypeFlagBits getFlagBit() const;
#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
virtual bool isImport() const
{
return false;
}
virtual uint64_t getMemoryObjectId() const
{
return (uint64_t)buffer;
}
#endif // SWIFTSHADER_DEVICE_MEMORY_REPORT
void *buffer = nullptr;
const VkDeviceSize allocationSize;
const uint32_t memoryTypeIndex;
Device *const device;
private:
static VkResult ParseAllocationInfo(const VkMemoryAllocateInfo *pAllocateInfo, DeviceMemory::ExtendedAllocationInfo *extendedAllocationInfo);
static VkResult Allocate(const VkAllocationCallbacks *pAllocator, const VkMemoryAllocateInfo *pAllocateInfo, VkDeviceMemory *pMemory,
const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, Device *device);
};
// This class represents a DeviceMemory object with no external memory
class DeviceMemoryInternal : public DeviceMemory, public ObjectBase<DeviceMemoryInternal, VkDeviceMemory>
{
public:
DeviceMemoryInternal(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, Device *pDevice)
: DeviceMemory(pCreateInfo, pDevice)
{}
};
static inline DeviceMemory *Cast(VkDeviceMemory object)
{
return DeviceMemory::Cast(object);
}
} // namespace vk
#endif // VK_DEVICE_MEMORY_HPP_