Add baseline VK_EXT_device_memory_report support

src/Android.bp

@@ -634,6 +634,7 @@ cc_defaults {
         "-DLOG_TAG=\"swiftshader\"",
         "-DSWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER",
         "-DSWIFTSHADER_ENABLE_ASTC",  // TODO(b/150130101)
+        //"-DSWIFTSHADER_DEVICE_MEMORY_REPORT",
     ],
 
     srcs: [

src/Vulkan/CMakeLists.txt

@@ -46,7 +46,6 @@ set(VULKAN_SRC_FILES
     VkDevice.hpp
     VkDeviceMemory.cpp
     VkDeviceMemory.hpp
-    VkDeviceMemoryExternalAndroid.hpp
     VkDeviceMemoryExternalLinux.hpp
     VkEvent.hpp
     VkFence.hpp

src/Vulkan/VkDevice.cpp

@@ -146,6 +146,22 @@ Device::Device(const VkDeviceCreateInfo *pCreateInfo, void *mem, PhysicalDevice
 		debugger.server = vk::dbg::Server::create(debugger.context, atoi(port));
 	}
 #endif  // ENABLE_VK_DEBUGGER
+
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	const VkBaseInStructure *extensionCreateInfo = reinterpret_cast<const VkBaseInStructure *>(pCreateInfo->pNext);
+	while(extensionCreateInfo)
+	{
+		if(extensionCreateInfo->sType == VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT)
+		{
+			auto deviceMemoryReportCreateInfo = reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT *>(pCreateInfo->pNext);
+			if(deviceMemoryReportCreateInfo->pfnUserCallback != nullptr)
+			{
+				deviceMemoryReportCallbacks.emplace_back(deviceMemoryReportCreateInfo->pfnUserCallback, deviceMemoryReportCreateInfo->pUserData);
+			}
+		}
+		extensionCreateInfo = extensionCreateInfo->pNext;
+	}
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
 }
 
 void Device::destroy(const VkAllocationCallbacks *pAllocator)
@@ -375,4 +391,27 @@ void Device::contentsChanged(ImageView *imageView)
 	}
 }
 
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+void Device::emitDeviceMemoryReport(VkDeviceMemoryReportEventTypeEXT type, uint64_t memoryObjectId, VkDeviceSize size, VkObjectType objectType, uint64_t objectHandle, uint32_t heapIndex)
+{
+	if(deviceMemoryReportCallbacks.empty()) return;
+
+	const VkDeviceMemoryReportCallbackDataEXT callbackData = {
+		VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT,  // sType
+		nullptr,                                                   // pNext
+		0,                                                         // flags
+		type,                                                      // type
+		memoryObjectId,                                            // memoryObjectId
+		size,                                                      // size
+		objectType,                                                // objectType
+		objectHandle,                                              // objectHandle
+		heapIndex,                                                 // heapIndex
+	};
+	for(const auto &callback : deviceMemoryReportCallbacks)
+	{
+		callback.first(&callbackData, callback.second);
+	}
+}
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
+
 }  // namespace vk

src/Vulkan/VkDevice.hpp

@@ -169,6 +169,10 @@ public:
 	VkResult setDebugUtilsObjectName(const VkDebugUtilsObjectNameInfoEXT *pNameInfo);
 	VkResult setDebugUtilsObjectTag(const VkDebugUtilsObjectTagInfoEXT *pTagInfo);
 
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	void emitDeviceMemoryReport(VkDeviceMemoryReportEventTypeEXT type, uint64_t memoryObjectId, VkDeviceSize size, VkObjectType objectType, uint64_t objectHandle, uint32_t heapIndex = 0);
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
+
 private:
 	PhysicalDevice *const physicalDevice = nullptr;
 	Queue *const queues = nullptr;
@@ -193,6 +197,10 @@ private:
 		std::shared_ptr<vk::dbg::Server> server;
 	} debugger;
 #endif  // ENABLE_VK_DEBUGGER
+
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	std::vector<std::pair<PFN_vkDeviceMemoryReportCallbackEXT, void *>> deviceMemoryReportCallbacks;
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
 };
 
 using DispatchableDevice = DispatchableObject<Device, VkDevice>;

src/Vulkan/VkDeviceMemory.cpp

@@ -73,7 +73,7 @@ public:
 
 	VkResult allocate(size_t size, void **pBuffer) override
 	{
-		void *buffer = vk::allocate(size, REQUIRED_MEMORY_ALIGNMENT, DEVICE_MEMORY);
+		buffer = vk::allocate(size, REQUIRED_MEMORY_ALIGNMENT, DEVICE_MEMORY);
 		if(!buffer)
 		{
 			return VK_ERROR_OUT_OF_DEVICE_MEMORY;
@@ -83,15 +83,26 @@ public:
 		return VK_SUCCESS;
 	}
 
-	void deallocate(void *buffer, size_t size) override
+	void deallocate(void * /* buffer */, size_t size) override
 	{
 		vk::deallocate(buffer, DEVICE_MEMORY);
+		buffer = nullptr;
 	}
 
 	VkExternalMemoryHandleTypeFlagBits getFlagBit() const override
 	{
 		return typeFlagBit;
 	}
+
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	uint64_t getMemoryObjectId() const override
+	{
+		return (uint64_t)buffer;
+	}
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
+
+private:
+	void *buffer = nullptr;
 };
 
 }  // namespace vk
@@ -235,6 +246,9 @@ DeviceMemory::DeviceMemory(const VkMemoryAllocateInfo *pAllocateInfo, void *mem,
 
 void DeviceMemory::destroy(const VkAllocationCallbacks *pAllocator)
 {
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	device->emitDeviceMemoryReport(external->isImport() ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT, external->getMemoryObjectId(), 0 /* size */, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)(void *)VkDeviceMemory(*this));
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
 	if(buffer)
 	{
 		external->deallocate(buffer, size);
@@ -255,6 +269,9 @@ 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;
 	}
 
@@ -263,6 +280,16 @@ VkResult DeviceMemory::allocate()
 	{
 		result = external->allocate(size, &buffer);
 	}
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	if(result == VK_SUCCESS)
+	{
+		device->emitDeviceMemoryReport(external->isImport() ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT, external->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;
 }
 

src/Vulkan/VkDeviceMemoryExternalAndroid.cpp

@@ -12,19 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
+#include "VkDeviceMemoryExternalAndroid.hpp"
 
-#	include "VkDeviceMemoryExternalAndroid.hpp"
-
-#	include "System/Debug.hpp"
-#	include "VkDestroy.hpp"
-#	include "VkFormat.hpp"
-#	include "VkObject.hpp"
-#	include "VkPhysicalDevice.hpp"
-#	include "VkStringify.hpp"
-
-#	include <android/hardware_buffer.h>
-#	include <vndk/hardware_buffer.h>
+#include "VkDestroy.hpp"
+#include "VkFormat.hpp"
+#include "VkObject.hpp"
+#include "VkPhysicalDevice.hpp"
+#include "VkStringify.hpp"
+#include "System/Debug.hpp"
 
 namespace {
 
@@ -323,7 +318,7 @@ void AHardwareBufferExternalMemory::deallocate(void *buffer, size_t size)
 	}
 }
 
-VkResult AHardwareBufferExternalMemory::importAndroidHardwareBuffer(struct AHardwareBuffer *buffer, void **pBuffer)
+VkResult AHardwareBufferExternalMemory::importAndroidHardwareBuffer(AHardwareBuffer *buffer, void **pBuffer)
 {
 	ahb = buffer;
 
@@ -410,7 +405,7 @@ VkResult AHardwareBufferExternalMemory::unlockAndroidHardwareBuffer()
 	return VK_SUCCESS;
 }
 
-VkResult AHardwareBufferExternalMemory::exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const
+VkResult AHardwareBufferExternalMemory::exportAndroidHardwareBuffer(AHardwareBuffer **pAhb) const
 {
 	// Each call to vkGetMemoryAndroidHardwareBufferANDROID *must* return an Android hardware buffer with a new reference
 	// acquired in addition to the reference held by the VkDeviceMemory. To avoid leaking resources, the application *must*
@@ -436,7 +431,7 @@ VkResult AHardwareBufferExternalMemory::GetAndroidHardwareBufferFormatProperties
 	return VK_SUCCESS;
 }
 
-VkResult AHardwareBufferExternalMemory::GetAndroidHardwareBufferProperties(VkDevice &device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
+VkResult AHardwareBufferExternalMemory::GetAndroidHardwareBufferProperties(VkDevice &device, const AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
 {
 	VkResult result = VK_SUCCESS;
 
@@ -496,4 +491,12 @@ int AHardwareBufferExternalMemory::externalImageRowPitchBytes() const
 	return GetBytesFromAHBFormat(ahbDesc.format) * ahbDesc.stride;
 }
 
-#endif  // SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+uint64_t AHardwareBufferExternalMemory::getMemoryObjectId() const
+{
+	uint64_t id = 0;
+	int ret = AHardwareBuffer_getId(ahb, &id);
+	ASSERT(ret == 0);
+	return id;
+}
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT

src/Vulkan/VkDeviceMemoryExternalAndroid.hpp

@@ -15,15 +15,13 @@
 #ifndef VK_DEVICE_MEMORY_EXTERNAL_ANDROID_HPP_
 #define VK_DEVICE_MEMORY_EXTERNAL_ANDROID_HPP_
 
-#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
+#include "VkBuffer.hpp"
+#include "VkDevice.hpp"
+#include "VkDeviceMemory.hpp"
+#include "VkDeviceMemoryExternalBase.hpp"
+#include "VkImage.hpp"
 
-#	include "VkBuffer.hpp"
-#	include "VkDevice.hpp"
-#	include "VkDeviceMemory.hpp"
-#	include "VkDeviceMemoryExternalBase.hpp"
-#	include "VkImage.hpp"
-
-#	include <android/hardware_buffer.h>
+#include <vndk/hardware_buffer.h>
 
 class AHardwareBufferExternalMemory : public vk::DeviceMemory::ExternalBase
 {
@@ -35,7 +33,7 @@ public:
 	{
 		bool importAhb = false;
 		bool exportAhb = false;
-		struct AHardwareBuffer *ahb = nullptr;
+		AHardwareBuffer *ahb = nullptr;
 		vk::Image *imageHandle = nullptr;
 		vk::Buffer *bufferHandle = nullptr;
 
@@ -61,28 +59,35 @@ public:
 
 	VkExternalMemoryHandleTypeFlagBits getFlagBit() const override { return typeFlagBit; }
 
-	VkResult exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const override;
+	VkResult exportAndroidHardwareBuffer(AHardwareBuffer **pAhb) const override;
 
 	void setDevicePtr(vk::Device *pDevice) override { device = pDevice; }
 	bool isAndroidHardwareBuffer() override { return true; }
 
 	static VkResult GetAndroidHardwareBufferFormatProperties(const AHardwareBuffer_Desc &ahbDesc, VkAndroidHardwareBufferFormatPropertiesANDROID *pFormat);
-	static VkResult GetAndroidHardwareBufferProperties(VkDevice &device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties);
+	static VkResult GetAndroidHardwareBufferProperties(VkDevice &device, const AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties);
 
 	bool hasExternalImageProperties() const override final { return true; }
 	int externalImageRowPitchBytes() const override final;
 
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	bool isImport() const override
+	{
+		return allocateInfo.importAhb;
+	}
+	uint64_t getMemoryObjectId() const override;
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
+
 private:
-	VkResult importAndroidHardwareBuffer(struct AHardwareBuffer *buffer, void **pBuffer);
+	VkResult importAndroidHardwareBuffer(AHardwareBuffer *buffer, void **pBuffer);
 	VkResult allocateAndroidHardwareBuffer(void **pBuffer);
 	VkResult lockAndroidHardwareBuffer(void **pBuffer);
 	VkResult unlockAndroidHardwareBuffer();
 
-	struct AHardwareBuffer *ahb = nullptr;
+	AHardwareBuffer *ahb = nullptr;
 	AHardwareBuffer_Desc ahbDesc = {};
 	vk::Device *device = nullptr;
 	AllocateInfo allocateInfo;
 };
 
-#endif  // SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
 #endif  // VK_DEVICE_MEMORY_EXTERNAL_ANDROID_HPP_

src/Vulkan/VkDeviceMemoryExternalBase.hpp

@@ -62,6 +62,18 @@ public:
 	virtual bool hasExternalImageProperties() const { return false; }
 	virtual int externalImageRowPitchBytes() const { return 0; }
 
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	virtual bool isImport() const
+	{
+		return false;
+	}
+
+	virtual uint64_t getMemoryObjectId() const
+	{
+		return 0;
+	}
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
+
 protected:
 	ExternalBase() = default;
 };

src/Vulkan/VkPhysicalDevice.cpp

@@ -217,6 +217,14 @@ static void getPhysicalDeviceShaderSubgroupExtendedTypesFeatures(T *features)
 	features->shaderSubgroupExtendedTypes = VK_TRUE;
 }
 
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+template<typename T>
+static void getPhysicalDeviceDeviceMemoryReportFeaturesEXT(T *features)
+{
+	features->deviceMemoryReport = VK_TRUE;
+}
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
+
 template<typename T>
 static void getPhysicalDeviceVulkan12Features(T *features)
 {
@@ -320,6 +328,11 @@ void PhysicalDevice::getFeatures2(VkPhysicalDeviceFeatures2 *features) const
 			case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR:
 				getPhysicalDeviceShaderSubgroupExtendedTypesFeatures(reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(curExtension));
 				break;
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+			case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
+				getPhysicalDeviceDeviceMemoryReportFeaturesEXT(reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(curExtension));
+				break;
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
 			default:
 				LOG_TRAP("curExtension->pNext->sType = %s", vk::Stringify(curExtension->sType).c_str());
 				break;

src/Vulkan/libVulkan.cpp

@@ -389,6 +389,9 @@ static const VkExtensionProperties deviceExtensionProperties[] = {
 	{ VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME, VK_EXT_PROVOKING_VERTEX_SPEC_VERSION },
 	{ VK_GOOGLE_SAMPLER_FILTERING_PRECISION_EXTENSION_NAME, VK_GOOGLE_SAMPLER_FILTERING_PRECISION_SPEC_VERSION },
 	{ VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME, VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION },
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	{ VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME, VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION },
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
 	// Vulkan 1.2 promoted extensions
 	{ VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION },
 	{ VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION },
@@ -765,6 +768,14 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, c
 				(void)imagelessFramebufferFeatures->imagelessFramebuffer;
 			}
 			break;
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+			case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
+			{
+				const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *deviceMemoryReportFeatures = reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(extensionCreateInfo);
+				(void)deviceMemoryReportFeatures->deviceMemoryReport;
+			}
+			break;
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
 			default:
 				// "the [driver] must skip over, without processing (other than reading the sType and pNext members) any structures in the chain with sType values not defined by [supported extenions]"
 				LOG_TRAP("pCreateInfo->pNext sType = %s", vk::Stringify(extensionCreateInfo->sType).c_str());