system/vulkan_enc/ResourceTracker.cpp - device/generic/goldfish-opengl - Git at Google

 // Copyright (C) 2018 The Android Open Source Project
 // Copyright (C) 2018 Google Inc.
 //
 // 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 "ResourceTracker.h"

 #include "Resources.h"
 #include "VkEncoder.h"

 #include "android/base/AlignedBuf.h"
 #include "android/base/synchronization/AndroidLock.h"

 #include "gralloc_cb.h"
 #include "goldfish_vk_private_defs.h"

 #include <unordered_map>

 #include <log/log.h>
 #include <stdlib.h>
 #include <sync/sync.h>

 #define RESOURCE_TRACKER_DEBUG 0

 #if RESOURCE_TRACKER_DEBUG
 #define D(fmt,...) ALOGD("%s: " fmt, __func__, ##__VA_ARGS__);
 #else
 #ifndef D
 #define D(fmt,...)
 #endif
 #endif

 using android::aligned_buf_alloc;
 using android::aligned_buf_free;
 using android::base::guest::AutoLock;
 using android::base::guest::Lock;

 namespace goldfish_vk {

 #define MAKE_HANDLE_MAPPING_FOREACH(type_name, map_impl, map_to_u64_impl, map_from_u64_impl) \
     void mapHandles_##type_name(type_name* handles, size_t count) override { \
         for (size_t i = 0; i < count; ++i) { \
             map_impl; \
         } \
     } \
     void mapHandles_##type_name##_u64(const type_name* handles, uint64_t* handle_u64s, size_t count) override { \
         for (size_t i = 0; i < count; ++i) { \
             map_to_u64_impl; \
         } \
     } \
     void mapHandles_u64_##type_name(const uint64_t* handle_u64s, type_name* handles, size_t count) override { \
         for (size_t i = 0; i < count; ++i) { \
             map_from_u64_impl; \
         } \
     } \

 #define DEFINE_RESOURCE_TRACKING_CLASS(class_name, impl) \
 class class_name : public VulkanHandleMapping { \
 public: \
     virtual ~class_name() { } \
     GOLDFISH_VK_LIST_HANDLE_TYPES(impl) \
 }; \

 #define CREATE_MAPPING_IMPL_FOR_TYPE(type_name) \
     MAKE_HANDLE_MAPPING_FOREACH(type_name, \
         handles[i] = new_from_host_##type_name(handles[i]); ResourceTracker::get()->register_##type_name(handles[i]);, \
         handle_u64s[i] = (uint64_t)new_from_host_##type_name(handles[i]), \
         handles[i] = (type_name)new_from_host_u64_##type_name(handle_u64s[i]); ResourceTracker::get()->register_##type_name(handles[i]);)

 #define UNWRAP_MAPPING_IMPL_FOR_TYPE(type_name) \
     MAKE_HANDLE_MAPPING_FOREACH(type_name, \
         handles[i] = get_host_##type_name(handles[i]), \
         handle_u64s[i] = (uint64_t)get_host_u64_##type_name(handles[i]), \
         handles[i] = (type_name)get_host_##type_name((type_name)handle_u64s[i]))

 #define DESTROY_MAPPING_IMPL_FOR_TYPE(type_name) \
     MAKE_HANDLE_MAPPING_FOREACH(type_name, \
         ResourceTracker::get()->unregister_##type_name(handles[i]); delete_goldfish_##type_name(handles[i]), \
         (void)handle_u64s[i]; delete_goldfish_##type_name(handles[i]), \
         (void)handles[i]; delete_goldfish_##type_name((type_name)handle_u64s[i]))

 DEFINE_RESOURCE_TRACKING_CLASS(CreateMapping, CREATE_MAPPING_IMPL_FOR_TYPE)
 DEFINE_RESOURCE_TRACKING_CLASS(UnwrapMapping, UNWRAP_MAPPING_IMPL_FOR_TYPE)
 DEFINE_RESOURCE_TRACKING_CLASS(DestroyMapping, DESTROY_MAPPING_IMPL_FOR_TYPE)

 class ResourceTracker::Impl {
 public:
     Impl() = default;
     CreateMapping createMapping;
     UnwrapMapping unwrapMapping;
     DestroyMapping destroyMapping;
     DefaultHandleMapping defaultMapping;

 #define HANDLE_DEFINE_TRIVIAL_INFO_STRUCT(type) \
     struct type##_Info { \
         uint32_t unused; \
     }; \

     GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(HANDLE_DEFINE_TRIVIAL_INFO_STRUCT)

     struct VkDevice_Info {
         VkPhysicalDevice physdev;
         VkPhysicalDeviceProperties props;
         VkPhysicalDeviceMemoryProperties memProps;
     };

     struct VkDeviceMemory_Info {
         VkDeviceSize allocationSize = 0;
         VkDeviceSize mappedSize = 0;
         uint8_t* mappedPtr = nullptr;
         uint32_t memoryTypeIndex = 0;
     };

 #define HANDLE_REGISTER_IMPL_IMPL(type) \
     std::unordered_map<type, type##_Info> info_##type; \
     void register_##type(type obj) { \
         AutoLock lock(mLock); \
         info_##type[obj] = type##_Info(); \
     } \

 #define HANDLE_UNREGISTER_IMPL_IMPL(type) \
     void unregister_##type(type obj) { \
         AutoLock lock(mLock); \
         info_##type.erase(obj); \
     } \

     GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_IMPL_IMPL)
     GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(HANDLE_UNREGISTER_IMPL_IMPL)

     void unregister_VkDevice(VkDevice device) {
         AutoLock lock(mLock);
         info_VkDevice.erase(device);
     }

     void unregister_VkDeviceMemory(VkDeviceMemory mem) {
         AutoLock lock(mLock);
         auto it = info_VkDeviceMemory.find(mem);
         if (it == info_VkDeviceMemory.end()) return;

         auto& memInfo = it->second;
         if (memInfo.mappedPtr) {
             aligned_buf_free(memInfo.mappedPtr);
         }
     }

     void setDeviceInfo(VkDevice device,
                        VkPhysicalDevice physdev,
                        VkPhysicalDeviceProperties props,
                        VkPhysicalDeviceMemoryProperties memProps) {
         AutoLock lock(mLock);
         auto& info = info_VkDevice[device];
         info.physdev = physdev;
         info.props = props;
         info.memProps = memProps;
     }

     void setDeviceMemoryInfo(VkDeviceMemory memory,
                              VkDeviceSize allocationSize,
                              VkDeviceSize mappedSize,
                              uint8_t* ptr,
                              uint32_t memoryTypeIndex) {
         AutoLock lock(mLock);
         auto& info = info_VkDeviceMemory[memory];
         info.allocationSize = allocationSize;
         info.mappedSize = mappedSize;
         info.mappedPtr = ptr;
         info.memoryTypeIndex = memoryTypeIndex;
     }

     bool isMemoryTypeHostVisible(VkDevice device, uint32_t typeIndex) const {
         AutoLock lock(mLock);
         const auto it = info_VkDevice.find(device);

         if (it == info_VkDevice.end()) return false;

         const auto& info = it->second;
         return info.memProps.memoryTypes[typeIndex].propertyFlags &
                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
     }

     uint8_t* getMappedPointer(VkDeviceMemory memory) {
         AutoLock lock(mLock);
         const auto it = info_VkDeviceMemory.find(memory);
         if (it == info_VkDeviceMemory.end()) return nullptr;

         const auto& info = it->second;
         return info.mappedPtr;
     }

     VkDeviceSize getMappedSize(VkDeviceMemory memory) {
         AutoLock lock(mLock);
         const auto it = info_VkDeviceMemory.find(memory);
         if (it == info_VkDeviceMemory.end()) return 0;

         const auto& info = it->second;
         return info.mappedSize;
     }

     VkDeviceSize getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
         AutoLock lock(mLock);
         const auto it = info_VkDevice.find(device);
         if (it == info_VkDevice.end()) return basicSize;
         const auto& info = it->second;

         VkDeviceSize nonCoherentAtomSize =
             info.props.limits.nonCoherentAtomSize;
         VkDeviceSize atoms =
             (basicSize + nonCoherentAtomSize - 1) / nonCoherentAtomSize;
         return atoms * nonCoherentAtomSize;
     }

     bool isValidMemoryRange(const VkMappedMemoryRange& range) const {
         AutoLock lock(mLock);
         const auto it = info_VkDeviceMemory.find(range.memory);
         if (it == info_VkDeviceMemory.end()) return false;
         const auto& info = it->second;

         if (!info.mappedPtr) return false;

         VkDeviceSize offset = range.offset;
         VkDeviceSize size = range.size;

         if (size == VK_WHOLE_SIZE) {
             return offset <= info.mappedSize;
         }

         return offset + size <= info.mappedSize;
     }

     VkResult on_vkEnumerateInstanceVersion(
         void*,
         VkResult,
         uint32_t* apiVersion) {
         if (apiVersion) {
             *apiVersion = VK_MAKE_VERSION(1, 0, 0);
         }
         return VK_SUCCESS;
     }

     VkResult on_vkEnumerateDeviceExtensionProperties(
         void*,
         VkResult,
         VkPhysicalDevice,
         const char*,
         uint32_t* pPropertyCount,
         VkExtensionProperties*) {
         *pPropertyCount = 0;
         return VK_SUCCESS;
     }

     void on_vkGetPhysicalDeviceProperties2(
         void*,
         VkPhysicalDevice,
         VkPhysicalDeviceProperties2*) {
         // no-op
     }

     VkResult on_vkCreateDevice(
         void* context,
         VkResult input_result,
         VkPhysicalDevice physicalDevice,
         const VkDeviceCreateInfo*,
         const VkAllocationCallbacks*,
         VkDevice* pDevice) {

         if (input_result != VK_SUCCESS) return input_result;

         VkEncoder* enc = (VkEncoder*)context;

         VkPhysicalDeviceProperties props;
         VkPhysicalDeviceMemoryProperties memProps;
         enc->vkGetPhysicalDeviceProperties(physicalDevice, &props);
         enc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProps);

         setDeviceInfo(*pDevice, physicalDevice, props, memProps);

         return input_result;
     }

     VkResult on_vkAllocateMemory(
         void*,
         VkResult input_result,
         VkDevice device,
         const VkMemoryAllocateInfo* pAllocateInfo,
         const VkAllocationCallbacks*,
         VkDeviceMemory* pMemory) {

         if (input_result != VK_SUCCESS) return input_result;

         VkDeviceSize allocationSize = pAllocateInfo->allocationSize;
         VkDeviceSize mappedSize = getNonCoherentExtendedSize(device, allocationSize);
         uint8_t* mappedPtr = nullptr;

         if (isMemoryTypeHostVisible(device, pAllocateInfo->memoryTypeIndex)) {
             mappedPtr = (uint8_t*)aligned_buf_alloc(4096, mappedSize);
             D("host visible alloc: size 0x%llx host ptr %p mapped size 0x%llx",
               (unsigned long long)size, mem->ptr,
               (unsigned long long)mem->mappedSize);
         }

         setDeviceMemoryInfo(
             *pMemory, allocationSize, mappedSize, mappedPtr,
             pAllocateInfo->memoryTypeIndex);

         return input_result;
     }

     VkResult on_vkMapMemory(
         void*,
         VkResult host_result,
         VkDevice,
         VkDeviceMemory memory,
         VkDeviceSize offset,
         VkDeviceSize size,
         VkMemoryMapFlags,
         void** ppData) {

         if (host_result != VK_SUCCESS) return host_result;

         AutoLock lock(mLock);

         auto it = info_VkDeviceMemory.find(memory);
         if (it == info_VkDeviceMemory.end()) return VK_ERROR_MEMORY_MAP_FAILED;

         auto& info = it->second;

         if (!info.mappedPtr) return VK_ERROR_MEMORY_MAP_FAILED;

         if (size != VK_WHOLE_SIZE &&
             (info.mappedPtr + offset + size > info.mappedPtr + info.allocationSize)) {
             return VK_ERROR_MEMORY_MAP_FAILED;
         }

         *ppData = info.mappedPtr + offset;

         return host_result;
     }

     void on_vkUnmapMemory(
         void*,
         VkDevice,
         VkDeviceMemory) {
         // no-op
     }

     void unwrap_VkNativeBufferANDROID(
         const VkImageCreateInfo* pCreateInfo,
         VkImageCreateInfo* local_pCreateInfo) {

         if (!pCreateInfo->pNext) return;

         const VkNativeBufferANDROID* nativeInfo =
             reinterpret_cast<const VkNativeBufferANDROID*>(pCreateInfo->pNext);

         if (VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID != nativeInfo->sType) {
             return;
         }

         const cb_handle_t* cb_handle =
             reinterpret_cast<const cb_handle_t*>(nativeInfo->handle);

         if (!cb_handle) return;

         VkNativeBufferANDROID* nativeInfoOut =
             reinterpret_cast<VkNativeBufferANDROID*>(
                 const_cast<void*>(
                     local_pCreateInfo->pNext));

         if (!nativeInfoOut->handle) {
             ALOGE("FATAL: Local native buffer info not properly allocated!");
             abort();
         }

         *(uint32_t*)(nativeInfoOut->handle) = cb_handle->hostHandle;
     }

     void unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int*) {
         if (fd != -1) {
             sync_wait(fd, 3000);
         }
     }

 private:
     mutable Lock mLock;

 };
 ResourceTracker::ResourceTracker() : mImpl(new ResourceTracker::Impl()) { }
 ResourceTracker::~ResourceTracker() { }
 VulkanHandleMapping* ResourceTracker::createMapping() {
     return &mImpl->createMapping;
 }
 VulkanHandleMapping* ResourceTracker::unwrapMapping() {
     return &mImpl->unwrapMapping;
 }
 VulkanHandleMapping* ResourceTracker::destroyMapping() {
     return &mImpl->destroyMapping;
 }
 VulkanHandleMapping* ResourceTracker::defaultMapping() {
     return &mImpl->defaultMapping;
 }
 static ResourceTracker* sTracker = nullptr;
 // static
 ResourceTracker* ResourceTracker::get() {
     if (!sTracker) {
         // To be initialized once on vulkan device open.
         sTracker = new ResourceTracker;
     }
     return sTracker;
 }

 #define HANDLE_REGISTER_IMPL(type) \
     void ResourceTracker::register_##type(type obj) { \
         mImpl->register_##type(obj); \
     } \
     void ResourceTracker::unregister_##type(type obj) { \
         mImpl->unregister_##type(obj); \
     } \

 GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_IMPL)

 void ResourceTracker::setDeviceInfo(
     VkDevice device,
     VkPhysicalDevice physdev,
     VkPhysicalDeviceProperties props,
     VkPhysicalDeviceMemoryProperties memProps) {
     mImpl->setDeviceInfo(device, physdev, props, memProps);
 }

 bool ResourceTracker::isMemoryTypeHostVisible(
     VkDevice device, uint32_t typeIndex) const {
     return mImpl->isMemoryTypeHostVisible(device, typeIndex);
 }

 uint8_t* ResourceTracker::getMappedPointer(VkDeviceMemory memory) {
     return mImpl->getMappedPointer(memory);
 }

 VkDeviceSize ResourceTracker::getMappedSize(VkDeviceMemory memory) {
     return mImpl->getMappedSize(memory);
 }

 VkDeviceSize ResourceTracker::getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
     return mImpl->getNonCoherentExtendedSize(device, basicSize);
 }

 bool ResourceTracker::isValidMemoryRange(const VkMappedMemoryRange& range) const {
     return mImpl->isValidMemoryRange(range);
 }

 VkResult ResourceTracker::on_vkEnumerateInstanceVersion(
     void* context,
     VkResult input_result,
     uint32_t* apiVersion) {
     return mImpl->on_vkEnumerateInstanceVersion(context, input_result, apiVersion);
 }

 VkResult ResourceTracker::on_vkEnumerateDeviceExtensionProperties(
     void* context,
     VkResult input_result,
     VkPhysicalDevice physicalDevice,
     const char* pLayerName,
     uint32_t* pPropertyCount,
     VkExtensionProperties* pProperties) {
     return mImpl->on_vkEnumerateDeviceExtensionProperties(
         context, input_result, physicalDevice, pLayerName, pPropertyCount, pProperties);
 }

 void ResourceTracker::on_vkGetPhysicalDeviceProperties2(
     void* context,
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceProperties2* pProperties) {
     mImpl->on_vkGetPhysicalDeviceProperties2(context, physicalDevice, pProperties);
 }

 VkResult ResourceTracker::on_vkCreateDevice(
     void* context,
     VkResult input_result,
     VkPhysicalDevice physicalDevice,
     const VkDeviceCreateInfo* pCreateInfo,
     const VkAllocationCallbacks* pAllocator,
     VkDevice* pDevice) {
     return mImpl->on_vkCreateDevice(
         context, input_result, physicalDevice, pCreateInfo, pAllocator, pDevice);
 }

 VkResult ResourceTracker::on_vkAllocateMemory(
     void* context,
     VkResult input_result,
     VkDevice device,
     const VkMemoryAllocateInfo* pAllocateInfo,
     const VkAllocationCallbacks* pAllocator,
     VkDeviceMemory* pMemory) {
     return mImpl->on_vkAllocateMemory(
         context, input_result, device, pAllocateInfo, pAllocator, pMemory);
 }

 VkResult ResourceTracker::on_vkMapMemory(
     void* context,
     VkResult input_result,
     VkDevice device,
     VkDeviceMemory memory,
     VkDeviceSize offset,
     VkDeviceSize size,
     VkMemoryMapFlags flags,
     void** ppData) {
     return mImpl->on_vkMapMemory(
         context, input_result, device, memory, offset, size, flags, ppData);
 }

 void ResourceTracker::on_vkUnmapMemory(
     void* context,
     VkDevice device,
     VkDeviceMemory memory) {
     mImpl->on_vkUnmapMemory(context, device, memory);
 }

 void ResourceTracker::unwrap_VkNativeBufferANDROID(
     const VkImageCreateInfo* pCreateInfo,
     VkImageCreateInfo* local_pCreateInfo) {
     mImpl->unwrap_VkNativeBufferANDROID(pCreateInfo, local_pCreateInfo);
 }

 void ResourceTracker::unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int* fd_out) {
     mImpl->unwrap_vkAcquireImageANDROID_nativeFenceFd(fd, fd_out);
 }

 } // namespace goldfish_vk
	// Copyright (C) 2018 The Android Open Source Project
	// Copyright (C) 2018 Google Inc.
	//
	// 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 "ResourceTracker.h"

	#include "Resources.h"
	#include "VkEncoder.h"

	#include "android/base/AlignedBuf.h"
	#include "android/base/synchronization/AndroidLock.h"

	#include "gralloc_cb.h"
	#include "goldfish_vk_private_defs.h"

	#include <unordered_map>

	#include <log/log.h>
	#include <stdlib.h>
	#include <sync/sync.h>

	#define RESOURCE_TRACKER_DEBUG 0

	#if RESOURCE_TRACKER_DEBUG
	#define D(fmt,...) ALOGD("%s: " fmt, __func__, ##__VA_ARGS__);
	#else
	#ifndef D
	#define D(fmt,...)
	#endif
	#endif

	using android::aligned_buf_alloc;
	using android::aligned_buf_free;
	using android::base::guest::AutoLock;
	using android::base::guest::Lock;

	namespace goldfish_vk {

	#define MAKE_HANDLE_MAPPING_FOREACH(type_name, map_impl, map_to_u64_impl, map_from_u64_impl) \
	void mapHandles_##type_name(type_name* handles, size_t count) override { \
	for (size_t i = 0; i < count; ++i) { \
	map_impl; \
	} \
	} \
	void mapHandles_##type_name##_u64(const type_name* handles, uint64_t* handle_u64s, size_t count) override { \
	for (size_t i = 0; i < count; ++i) { \
	map_to_u64_impl; \
	} \
	} \
	void mapHandles_u64_##type_name(const uint64_t* handle_u64s, type_name* handles, size_t count) override { \
	for (size_t i = 0; i < count; ++i) { \
	map_from_u64_impl; \
	} \
	} \

	#define DEFINE_RESOURCE_TRACKING_CLASS(class_name, impl) \
	class class_name : public VulkanHandleMapping { \
	public: \
	virtual ~class_name() { } \
	GOLDFISH_VK_LIST_HANDLE_TYPES(impl) \
	}; \

	#define CREATE_MAPPING_IMPL_FOR_TYPE(type_name) \
	MAKE_HANDLE_MAPPING_FOREACH(type_name, \
	handles[i] = new_from_host_##type_name(handles[i]); ResourceTracker::get()->register_##type_name(handles[i]);, \
	handle_u64s[i] = (uint64_t)new_from_host_##type_name(handles[i]), \
	handles[i] = (type_name)new_from_host_u64_##type_name(handle_u64s[i]); ResourceTracker::get()->register_##type_name(handles[i]);)

	#define UNWRAP_MAPPING_IMPL_FOR_TYPE(type_name) \
	MAKE_HANDLE_MAPPING_FOREACH(type_name, \
	handles[i] = get_host_##type_name(handles[i]), \
	handle_u64s[i] = (uint64_t)get_host_u64_##type_name(handles[i]), \
	handles[i] = (type_name)get_host_##type_name((type_name)handle_u64s[i]))

	#define DESTROY_MAPPING_IMPL_FOR_TYPE(type_name) \
	MAKE_HANDLE_MAPPING_FOREACH(type_name, \
	ResourceTracker::get()->unregister_##type_name(handles[i]); delete_goldfish_##type_name(handles[i]), \
	(void)handle_u64s[i]; delete_goldfish_##type_name(handles[i]), \
	(void)handles[i]; delete_goldfish_##type_name((type_name)handle_u64s[i]))

	DEFINE_RESOURCE_TRACKING_CLASS(CreateMapping, CREATE_MAPPING_IMPL_FOR_TYPE)
	DEFINE_RESOURCE_TRACKING_CLASS(UnwrapMapping, UNWRAP_MAPPING_IMPL_FOR_TYPE)
	DEFINE_RESOURCE_TRACKING_CLASS(DestroyMapping, DESTROY_MAPPING_IMPL_FOR_TYPE)

	class ResourceTracker::Impl {
	public:
	Impl() = default;
	CreateMapping createMapping;
	UnwrapMapping unwrapMapping;
	DestroyMapping destroyMapping;
	DefaultHandleMapping defaultMapping;

	#define HANDLE_DEFINE_TRIVIAL_INFO_STRUCT(type) \
	struct type##_Info { \
	uint32_t unused; \
	}; \

	GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(HANDLE_DEFINE_TRIVIAL_INFO_STRUCT)

	struct VkDevice_Info {
	VkPhysicalDevice physdev;
	VkPhysicalDeviceProperties props;
	VkPhysicalDeviceMemoryProperties memProps;
	};

	struct VkDeviceMemory_Info {
	VkDeviceSize allocationSize = 0;
	VkDeviceSize mappedSize = 0;
	uint8_t* mappedPtr = nullptr;
	uint32_t memoryTypeIndex = 0;
	};

	#define HANDLE_REGISTER_IMPL_IMPL(type) \
	std::unordered_map<type, type##_Info> info_##type; \
	void register_##type(type obj) { \
	AutoLock lock(mLock); \
	info_##type[obj] = type##_Info(); \
	} \

	#define HANDLE_UNREGISTER_IMPL_IMPL(type) \
	void unregister_##type(type obj) { \
	AutoLock lock(mLock); \
	info_##type.erase(obj); \
	} \

	GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_IMPL_IMPL)
	GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(HANDLE_UNREGISTER_IMPL_IMPL)

	void unregister_VkDevice(VkDevice device) {
	AutoLock lock(mLock);
	info_VkDevice.erase(device);
	}

	void unregister_VkDeviceMemory(VkDeviceMemory mem) {
	AutoLock lock(mLock);
	auto it = info_VkDeviceMemory.find(mem);
	if (it == info_VkDeviceMemory.end()) return;

	auto& memInfo = it->second;
	if (memInfo.mappedPtr) {
	aligned_buf_free(memInfo.mappedPtr);
	}
	}

	void setDeviceInfo(VkDevice device,
	VkPhysicalDevice physdev,
	VkPhysicalDeviceProperties props,
	VkPhysicalDeviceMemoryProperties memProps) {
	AutoLock lock(mLock);
	auto& info = info_VkDevice[device];
	info.physdev = physdev;
	info.props = props;
	info.memProps = memProps;
	}

	void setDeviceMemoryInfo(VkDeviceMemory memory,
	VkDeviceSize allocationSize,
	VkDeviceSize mappedSize,
	uint8_t* ptr,
	uint32_t memoryTypeIndex) {
	AutoLock lock(mLock);
	auto& info = info_VkDeviceMemory[memory];
	info.allocationSize = allocationSize;
	info.mappedSize = mappedSize;
	info.mappedPtr = ptr;
	info.memoryTypeIndex = memoryTypeIndex;
	}

	bool isMemoryTypeHostVisible(VkDevice device, uint32_t typeIndex) const {
	AutoLock lock(mLock);
	const auto it = info_VkDevice.find(device);

	if (it == info_VkDevice.end()) return false;

	const auto& info = it->second;
	return info.memProps.memoryTypes[typeIndex].propertyFlags &
	VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
	}

	uint8_t* getMappedPointer(VkDeviceMemory memory) {
	AutoLock lock(mLock);
	const auto it = info_VkDeviceMemory.find(memory);
	if (it == info_VkDeviceMemory.end()) return nullptr;

	const auto& info = it->second;
	return info.mappedPtr;
	}

	VkDeviceSize getMappedSize(VkDeviceMemory memory) {
	AutoLock lock(mLock);
	const auto it = info_VkDeviceMemory.find(memory);
	if (it == info_VkDeviceMemory.end()) return 0;

	const auto& info = it->second;
	return info.mappedSize;
	}

	VkDeviceSize getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
	AutoLock lock(mLock);
	const auto it = info_VkDevice.find(device);
	if (it == info_VkDevice.end()) return basicSize;
	const auto& info = it->second;

	VkDeviceSize nonCoherentAtomSize =
	info.props.limits.nonCoherentAtomSize;
	VkDeviceSize atoms =
	(basicSize + nonCoherentAtomSize - 1) / nonCoherentAtomSize;
	return atoms * nonCoherentAtomSize;
	}

	bool isValidMemoryRange(const VkMappedMemoryRange& range) const {
	AutoLock lock(mLock);
	const auto it = info_VkDeviceMemory.find(range.memory);
	if (it == info_VkDeviceMemory.end()) return false;
	const auto& info = it->second;

	if (!info.mappedPtr) return false;

	VkDeviceSize offset = range.offset;
	VkDeviceSize size = range.size;

	if (size == VK_WHOLE_SIZE) {
	return offset <= info.mappedSize;
	}

	return offset + size <= info.mappedSize;
	}

	VkResult on_vkEnumerateInstanceVersion(
	void*,
	VkResult,
	uint32_t* apiVersion) {
	if (apiVersion) {
	*apiVersion = VK_MAKE_VERSION(1, 0, 0);
	}
	return VK_SUCCESS;
	}

	VkResult on_vkEnumerateDeviceExtensionProperties(
	void*,
	VkResult,
	VkPhysicalDevice,
	const char*,
	uint32_t* pPropertyCount,
	VkExtensionProperties*) {
	*pPropertyCount = 0;
	return VK_SUCCESS;
	}

	void on_vkGetPhysicalDeviceProperties2(
	void*,
	VkPhysicalDevice,
	VkPhysicalDeviceProperties2*) {
	// no-op
	}

	VkResult on_vkCreateDevice(
	void* context,
	VkResult input_result,
	VkPhysicalDevice physicalDevice,
	const VkDeviceCreateInfo*,
	const VkAllocationCallbacks*,
	VkDevice* pDevice) {

	if (input_result != VK_SUCCESS) return input_result;

	VkEncoder* enc = (VkEncoder*)context;

	VkPhysicalDeviceProperties props;
	VkPhysicalDeviceMemoryProperties memProps;
	enc->vkGetPhysicalDeviceProperties(physicalDevice, &props);
	enc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProps);

	setDeviceInfo(*pDevice, physicalDevice, props, memProps);

	return input_result;
	}

	VkResult on_vkAllocateMemory(
	void*,
	VkResult input_result,
	VkDevice device,
	const VkMemoryAllocateInfo* pAllocateInfo,
	const VkAllocationCallbacks*,
	VkDeviceMemory* pMemory) {

	if (input_result != VK_SUCCESS) return input_result;

	VkDeviceSize allocationSize = pAllocateInfo->allocationSize;
	VkDeviceSize mappedSize = getNonCoherentExtendedSize(device, allocationSize);
	uint8_t* mappedPtr = nullptr;

	if (isMemoryTypeHostVisible(device, pAllocateInfo->memoryTypeIndex)) {
	mappedPtr = (uint8_t*)aligned_buf_alloc(4096, mappedSize);
	D("host visible alloc: size 0x%llx host ptr %p mapped size 0x%llx",
	(unsigned long long)size, mem->ptr,
	(unsigned long long)mem->mappedSize);
	}

	setDeviceMemoryInfo(
	*pMemory, allocationSize, mappedSize, mappedPtr,
	pAllocateInfo->memoryTypeIndex);

	return input_result;
	}

	VkResult on_vkMapMemory(
	void*,
	VkResult host_result,
	VkDevice,
	VkDeviceMemory memory,
	VkDeviceSize offset,
	VkDeviceSize size,
	VkMemoryMapFlags,
	void** ppData) {

	if (host_result != VK_SUCCESS) return host_result;

	AutoLock lock(mLock);

	auto it = info_VkDeviceMemory.find(memory);
	if (it == info_VkDeviceMemory.end()) return VK_ERROR_MEMORY_MAP_FAILED;

	auto& info = it->second;

	if (!info.mappedPtr) return VK_ERROR_MEMORY_MAP_FAILED;

	if (size != VK_WHOLE_SIZE &&
	(info.mappedPtr + offset + size > info.mappedPtr + info.allocationSize)) {
	return VK_ERROR_MEMORY_MAP_FAILED;
	}

	*ppData = info.mappedPtr + offset;

	return host_result;
	}

	void on_vkUnmapMemory(
	void*,
	VkDevice,
	VkDeviceMemory) {
	// no-op
	}

	void unwrap_VkNativeBufferANDROID(
	const VkImageCreateInfo* pCreateInfo,
	VkImageCreateInfo* local_pCreateInfo) {

	if (!pCreateInfo->pNext) return;

	const VkNativeBufferANDROID* nativeInfo =
	reinterpret_cast<const VkNativeBufferANDROID*>(pCreateInfo->pNext);

	if (VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID != nativeInfo->sType) {
	return;
	}

	const cb_handle_t* cb_handle =
	reinterpret_cast<const cb_handle_t*>(nativeInfo->handle);

	if (!cb_handle) return;

	VkNativeBufferANDROID* nativeInfoOut =
	reinterpret_cast<VkNativeBufferANDROID*>(
	const_cast<void*>(
	local_pCreateInfo->pNext));

	if (!nativeInfoOut->handle) {
	ALOGE("FATAL: Local native buffer info not properly allocated!");
	abort();
	}

	(uint32_t)(nativeInfoOut->handle) = cb_handle->hostHandle;
	}

	void unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int*) {
	if (fd != -1) {
	sync_wait(fd, 3000);
	}
	}

	private:
	mutable Lock mLock;

	};
	ResourceTracker::ResourceTracker() : mImpl(new ResourceTracker::Impl()) { }
	ResourceTracker::~ResourceTracker() { }
	VulkanHandleMapping* ResourceTracker::createMapping() {
	return &mImpl->createMapping;
	}
	VulkanHandleMapping* ResourceTracker::unwrapMapping() {
	return &mImpl->unwrapMapping;
	}
	VulkanHandleMapping* ResourceTracker::destroyMapping() {
	return &mImpl->destroyMapping;
	}
	VulkanHandleMapping* ResourceTracker::defaultMapping() {
	return &mImpl->defaultMapping;
	}
	static ResourceTracker* sTracker = nullptr;
	// static
	ResourceTracker* ResourceTracker::get() {
	if (!sTracker) {
	// To be initialized once on vulkan device open.
	sTracker = new ResourceTracker;
	}
	return sTracker;
	}

	#define HANDLE_REGISTER_IMPL(type) \
	void ResourceTracker::register_##type(type obj) { \
	mImpl->register_##type(obj); \
	} \
	void ResourceTracker::unregister_##type(type obj) { \
	mImpl->unregister_##type(obj); \
	} \

	GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_IMPL)

	void ResourceTracker::setDeviceInfo(
	VkDevice device,
	VkPhysicalDevice physdev,
	VkPhysicalDeviceProperties props,
	VkPhysicalDeviceMemoryProperties memProps) {
	mImpl->setDeviceInfo(device, physdev, props, memProps);
	}

	bool ResourceTracker::isMemoryTypeHostVisible(
	VkDevice device, uint32_t typeIndex) const {
	return mImpl->isMemoryTypeHostVisible(device, typeIndex);
	}

	uint8_t* ResourceTracker::getMappedPointer(VkDeviceMemory memory) {
	return mImpl->getMappedPointer(memory);
	}

	VkDeviceSize ResourceTracker::getMappedSize(VkDeviceMemory memory) {
	return mImpl->getMappedSize(memory);
	}

	VkDeviceSize ResourceTracker::getNonCoherentExtendedSize(VkDevice device, VkDeviceSize basicSize) const {
	return mImpl->getNonCoherentExtendedSize(device, basicSize);
	}

	bool ResourceTracker::isValidMemoryRange(const VkMappedMemoryRange& range) const {
	return mImpl->isValidMemoryRange(range);
	}

	VkResult ResourceTracker::on_vkEnumerateInstanceVersion(
	void* context,
	VkResult input_result,
	uint32_t* apiVersion) {
	return mImpl->on_vkEnumerateInstanceVersion(context, input_result, apiVersion);
	}

	VkResult ResourceTracker::on_vkEnumerateDeviceExtensionProperties(
	void* context,
	VkResult input_result,
	VkPhysicalDevice physicalDevice,
	const char* pLayerName,
	uint32_t* pPropertyCount,
	VkExtensionProperties* pProperties) {
	return mImpl->on_vkEnumerateDeviceExtensionProperties(
	context, input_result, physicalDevice, pLayerName, pPropertyCount, pProperties);
	}

	void ResourceTracker::on_vkGetPhysicalDeviceProperties2(
	void* context,
	VkPhysicalDevice physicalDevice,
	VkPhysicalDeviceProperties2* pProperties) {
	mImpl->on_vkGetPhysicalDeviceProperties2(context, physicalDevice, pProperties);
	}

	VkResult ResourceTracker::on_vkCreateDevice(
	void* context,
	VkResult input_result,
	VkPhysicalDevice physicalDevice,
	const VkDeviceCreateInfo* pCreateInfo,
	const VkAllocationCallbacks* pAllocator,
	VkDevice* pDevice) {
	return mImpl->on_vkCreateDevice(
	context, input_result, physicalDevice, pCreateInfo, pAllocator, pDevice);
	}

	VkResult ResourceTracker::on_vkAllocateMemory(
	void* context,
	VkResult input_result,
	VkDevice device,
	const VkMemoryAllocateInfo* pAllocateInfo,
	const VkAllocationCallbacks* pAllocator,
	VkDeviceMemory* pMemory) {
	return mImpl->on_vkAllocateMemory(
	context, input_result, device, pAllocateInfo, pAllocator, pMemory);
	}

	VkResult ResourceTracker::on_vkMapMemory(
	void* context,
	VkResult input_result,
	VkDevice device,
	VkDeviceMemory memory,
	VkDeviceSize offset,
	VkDeviceSize size,
	VkMemoryMapFlags flags,
	void** ppData) {
	return mImpl->on_vkMapMemory(
	context, input_result, device, memory, offset, size, flags, ppData);
	}

	void ResourceTracker::on_vkUnmapMemory(
	void* context,
	VkDevice device,
	VkDeviceMemory memory) {
	mImpl->on_vkUnmapMemory(context, device, memory);
	}

	void ResourceTracker::unwrap_VkNativeBufferANDROID(
	const VkImageCreateInfo* pCreateInfo,
	VkImageCreateInfo* local_pCreateInfo) {
	mImpl->unwrap_VkNativeBufferANDROID(pCreateInfo, local_pCreateInfo);
	}

	void ResourceTracker::unwrap_vkAcquireImageANDROID_nativeFenceFd(int fd, int* fd_out) {
	mImpl->unwrap_vkAcquireImageANDROID_nativeFenceFd(fd, fd_out);
	}

	} // namespace goldfish_vk