src/intel/nullhw-layer/intel_nullhw.c - platform/external/mesa3d - Git at Google

 /*
  * Copyright © 2019 Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
  */

 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>

 #include <vulkan/vulkan.h>
 #include <vulkan/vk_layer.h>

 #include "util/u_debug.h"
 #include "util/hash_table.h"
 #include "util/macros.h"
 #include "util/simple_mtx.h"

 #include "vk_dispatch_table.h"
 #include "vk_enum_to_str.h"
 #include "vk_util.h"

 struct instance_data {
    struct vk_instance_dispatch_table vtable;
    VkInstance instance;
 };

 struct device_data {
    struct instance_data *instance;

    PFN_vkSetDeviceLoaderData set_device_loader_data;

    struct vk_device_dispatch_table vtable;
    VkPhysicalDevice physical_device;
    VkDevice device;
 };

 static struct hash_table_u64 *vk_object_to_data = NULL;
 static simple_mtx_t vk_object_to_data_mutex = SIMPLE_MTX_INITIALIZER;

 static inline void ensure_vk_object_map(void)
 {
    if (!vk_object_to_data)
       vk_object_to_data = _mesa_hash_table_u64_create(NULL);
 }

 #define HKEY(obj) ((uintptr_t)(obj))
 #define FIND(type, obj) ((type *)find_object_data(HKEY(obj)))

 static void *find_object_data(uint64_t obj)
 {
    simple_mtx_lock(&vk_object_to_data_mutex);
    ensure_vk_object_map();
    void *data = _mesa_hash_table_u64_search(vk_object_to_data, obj);
    simple_mtx_unlock(&vk_object_to_data_mutex);
    return data;
 }

 static void map_object(uint64_t obj, void *data)
 {
    simple_mtx_lock(&vk_object_to_data_mutex);
    ensure_vk_object_map();
    _mesa_hash_table_u64_insert(vk_object_to_data, obj, data);
    simple_mtx_unlock(&vk_object_to_data_mutex);
 }

 static void unmap_object(uint64_t obj)
 {
    simple_mtx_lock(&vk_object_to_data_mutex);
    _mesa_hash_table_u64_remove(vk_object_to_data, obj);
    simple_mtx_unlock(&vk_object_to_data_mutex);
 }

 /**/

 #define VK_CHECK(expr) \
    do { \
       VkResult __result = (expr); \
       if (__result != VK_SUCCESS) { \
          fprintf(stderr, "'%s' line %i failed with %s\n", \
                  #expr, __LINE__, vk_Result_to_str(__result)); \
       } \
    } while (0)

 /**/

 static void override_queue(struct device_data *device_data,
                            VkDevice device,
                            uint32_t queue_family_index,
                            VkQueue queue)
 {
    VkCommandPoolCreateInfo cmd_buffer_pool_info = {
       .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
       .queueFamilyIndex = queue_family_index,
    };
    VkCommandPool cmd_pool;
    VK_CHECK(device_data->vtable.CreateCommandPool(device,
                                                   &cmd_buffer_pool_info,
                                                   NULL, &cmd_pool));


    VkCommandBufferAllocateInfo cmd_buffer_info = {
       .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
       .commandPool = cmd_pool,
       .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
       .commandBufferCount = 1,
    };
    VkCommandBuffer cmd_buffer;
    VK_CHECK(device_data->vtable.AllocateCommandBuffers(device,
                                                        &cmd_buffer_info,
                                                        &cmd_buffer));
    VK_CHECK(device_data->set_device_loader_data(device, cmd_buffer));

    VkCommandBufferBeginInfo buffer_begin_info = {
       .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
    };
    device_data->vtable.BeginCommandBuffer(cmd_buffer, &buffer_begin_info);

    VkPerformanceOverrideInfoINTEL override_info = {
       .sType = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL,
       .type = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL,
       .enable = VK_TRUE,
    };
    device_data->vtable.CmdSetPerformanceOverrideINTEL(cmd_buffer, &override_info);

    device_data->vtable.EndCommandBuffer(cmd_buffer);

    VkSubmitInfo submit_info = {
       .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
       .commandBufferCount = 1,
       .pCommandBuffers = &cmd_buffer,
    };
    VK_CHECK(device_data->vtable.QueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE));

    VK_CHECK(device_data->vtable.QueueWaitIdle(queue));

    device_data->vtable.DestroyCommandPool(device, cmd_pool, NULL);
 }

 static void device_override_queues(struct device_data *device_data,
                                    const VkDeviceCreateInfo *pCreateInfo)
 {
    for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; i++) {
       for (uint32_t j = 0; j < pCreateInfo->pQueueCreateInfos[i].queueCount; j++) {
          VkQueue queue;
          device_data->vtable.GetDeviceQueue(device_data->device,
                                             pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex,
                                             j, &queue);

          VK_CHECK(device_data->set_device_loader_data(device_data->device, queue));

          override_queue(device_data, device_data->device,
                         pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex, queue);
       }
    }
 }

 static VkLayerDeviceCreateInfo *get_device_chain_info(const VkDeviceCreateInfo *pCreateInfo,
                                                       VkLayerFunction func)
 {
    vk_foreach_struct_const(item, pCreateInfo->pNext) {
       if (item->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO &&
           ((VkLayerDeviceCreateInfo *) item)->function == func)
          return (VkLayerDeviceCreateInfo *)item;
    }
    unreachable("device chain info not found");
    return NULL;
 }

 static struct device_data *new_device_data(VkDevice device, struct instance_data *instance)
 {
    struct device_data *data = calloc(1, sizeof(*data));
    data->instance = instance;
    data->device = device;
    map_object(HKEY(data->device), data);
    return data;
 }

 static void destroy_device_data(struct device_data *data)
 {
    unmap_object(HKEY(data->device));
    free(data);
 }

 static VkResult nullhw_CreateDevice(
     VkPhysicalDevice                            physicalDevice,
     const VkDeviceCreateInfo*                   pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkDevice*                                   pDevice)
 {
    VkLayerDeviceCreateInfo *chain_info =
       get_device_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);

    assert(chain_info->u.pLayerInfo);
    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
    PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
    PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice");
    if (fpCreateDevice == NULL) {
       return VK_ERROR_INITIALIZATION_FAILED;
    }

    // Advance the link info for the next element on the chain
    chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;

    VkDeviceCreateInfo device_info = *pCreateInfo;
    const char **extensions = calloc(device_info.enabledExtensionCount + 1, sizeof(*extensions));
    bool found = false;
    for (uint32_t i = 0; i < device_info.enabledExtensionCount; i++) {
       if (!strcmp(device_info.ppEnabledExtensionNames[i], "VK_INTEL_performance_query")) {
          found = true;
          break;
       }
    }
    if (!found) {
       memcpy(extensions, device_info.ppEnabledExtensionNames,
              sizeof(*extensions) * device_info.enabledExtensionCount);
       extensions[device_info.enabledExtensionCount++] = "VK_INTEL_performance_query";
       device_info.ppEnabledExtensionNames = extensions;
    }

    VkResult result = fpCreateDevice(physicalDevice, &device_info, pAllocator, pDevice);
    free(extensions);
    if (result != VK_SUCCESS) return result;

    struct instance_data *instance_data = FIND(struct instance_data, physicalDevice);
    struct device_data *device_data = new_device_data(*pDevice, instance_data);
    device_data->physical_device = physicalDevice;
    vk_device_dispatch_table_load(&device_data->vtable, fpGetDeviceProcAddr, *pDevice);

    VkLayerDeviceCreateInfo *load_data_info =
       get_device_chain_info(pCreateInfo, VK_LOADER_DATA_CALLBACK);
    device_data->set_device_loader_data = load_data_info->u.pfnSetDeviceLoaderData;

    device_override_queues(device_data, pCreateInfo);

    return result;
 }

 static void nullhw_DestroyDevice(
     VkDevice                                    device,
     const VkAllocationCallbacks*                pAllocator)
 {
    struct device_data *device_data = FIND(struct device_data, device);
    device_data->vtable.DestroyDevice(device, pAllocator);
    destroy_device_data(device_data);
 }

 static struct instance_data *new_instance_data(VkInstance instance)
 {
    struct instance_data *data = calloc(1, sizeof(*data));
    data->instance = instance;
    map_object(HKEY(data->instance), data);
    return data;
 }

 static void destroy_instance_data(struct instance_data *data)
 {
    unmap_object(HKEY(data->instance));
    free(data);
 }

 static VkLayerInstanceCreateInfo *get_instance_chain_info(const VkInstanceCreateInfo *pCreateInfo,
                                                           VkLayerFunction func)
 {
    vk_foreach_struct_const(item, pCreateInfo->pNext) {
       if (item->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO &&
           ((VkLayerInstanceCreateInfo *) item)->function == func)
          return (VkLayerInstanceCreateInfo *) item;
    }
    unreachable("instance chain info not found");
    return NULL;
 }

 static VkResult nullhw_CreateInstance(
     const VkInstanceCreateInfo*                 pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkInstance*                                 pInstance)
 {
    VkLayerInstanceCreateInfo *chain_info =
       get_instance_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);

    assert(chain_info->u.pLayerInfo);
    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
       chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
    PFN_vkCreateInstance fpCreateInstance =
       (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance");
    if (fpCreateInstance == NULL) {
       return VK_ERROR_INITIALIZATION_FAILED;
    }

    // Advance the link info for the next element on the chain
    chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;

    VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
    if (result != VK_SUCCESS) return result;

    struct instance_data *instance_data = new_instance_data(*pInstance);
    vk_instance_dispatch_table_load(&instance_data->vtable,
                                    fpGetInstanceProcAddr,
                                    instance_data->instance);

    return result;
 }

 static void nullhw_DestroyInstance(
     VkInstance                                  instance,
     const VkAllocationCallbacks*                pAllocator)
 {
    struct instance_data *instance_data = FIND(struct instance_data, instance);
    instance_data->vtable.DestroyInstance(instance, pAllocator);
    destroy_instance_data(instance_data);
 }

 static const struct {
    const char *name;
    void *ptr;
 } name_to_funcptr_map[] = {
    { "vkGetDeviceProcAddr", (void *) vkGetDeviceProcAddr },
 #define ADD_HOOK(fn) { "vk" # fn, (void *) nullhw_ ## fn }
    ADD_HOOK(CreateInstance),
    ADD_HOOK(DestroyInstance),
    ADD_HOOK(CreateDevice),
    ADD_HOOK(DestroyDevice),
 };

 static void *find_ptr(const char *name)
 {
    for (uint32_t i = 0; i < ARRAY_SIZE(name_to_funcptr_map); i++) {
       if (strcmp(name, name_to_funcptr_map[i].name) == 0)
          return name_to_funcptr_map[i].ptr;
    }

    return NULL;
 }

 PUBLIC VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev,
                                                                     const char *funcName)
 {
    void *ptr = find_ptr(funcName);
    if (ptr) return (PFN_vkVoidFunction)(ptr);

    if (dev == NULL) return NULL;

    struct device_data *device_data = FIND(struct device_data, dev);
    if (device_data->vtable.GetDeviceProcAddr == NULL) return NULL;
    return device_data->vtable.GetDeviceProcAddr(dev, funcName);
 }

 PUBLIC VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance,
                                                                       const char *funcName)
 {
    void *ptr = find_ptr(funcName);
    if (ptr) return (PFN_vkVoidFunction) ptr;

    struct instance_data *instance_data = FIND(struct instance_data, instance);
    if (instance_data->vtable.GetInstanceProcAddr == NULL) return NULL;
    return instance_data->vtable.GetInstanceProcAddr(instance, funcName);
 }
	/*
	* Copyright © 2019 Intel Corporation
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice (including the next
	* paragraph) shall be included in all copies or substantial portions of the
	* Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	* IN THE SOFTWARE.
	*/

	#include <string.h>
	#include <stdlib.h>
	#include <assert.h>
	#include <stdio.h>

	#include <vulkan/vulkan.h>
	#include <vulkan/vk_layer.h>

	#include "util/u_debug.h"
	#include "util/hash_table.h"
	#include "util/macros.h"
	#include "util/simple_mtx.h"

	#include "vk_dispatch_table.h"
	#include "vk_enum_to_str.h"
	#include "vk_util.h"

	struct instance_data {
	struct vk_instance_dispatch_table vtable;
	VkInstance instance;
	};

	struct device_data {
	struct instance_data *instance;

	PFN_vkSetDeviceLoaderData set_device_loader_data;

	struct vk_device_dispatch_table vtable;
	VkPhysicalDevice physical_device;
	VkDevice device;
	};

	static struct hash_table_u64 *vk_object_to_data = NULL;
	static simple_mtx_t vk_object_to_data_mutex = SIMPLE_MTX_INITIALIZER;

	static inline void ensure_vk_object_map(void)
	{
	if (!vk_object_to_data)
	vk_object_to_data = _mesa_hash_table_u64_create(NULL);
	}

	#define HKEY(obj) ((uintptr_t)(obj))
	#define FIND(type, obj) ((type *)find_object_data(HKEY(obj)))

	static void *find_object_data(uint64_t obj)
	{
	simple_mtx_lock(&vk_object_to_data_mutex);
	ensure_vk_object_map();
	void *data = _mesa_hash_table_u64_search(vk_object_to_data, obj);
	simple_mtx_unlock(&vk_object_to_data_mutex);
	return data;
	}

	static void map_object(uint64_t obj, void *data)
	{
	simple_mtx_lock(&vk_object_to_data_mutex);
	ensure_vk_object_map();
	_mesa_hash_table_u64_insert(vk_object_to_data, obj, data);
	simple_mtx_unlock(&vk_object_to_data_mutex);
	}

	static void unmap_object(uint64_t obj)
	{
	simple_mtx_lock(&vk_object_to_data_mutex);
	_mesa_hash_table_u64_remove(vk_object_to_data, obj);
	simple_mtx_unlock(&vk_object_to_data_mutex);
	}

	/**/

	#define VK_CHECK(expr) \
	do { \
	VkResult __result = (expr); \
	if (__result != VK_SUCCESS) { \
	fprintf(stderr, "'%s' line %i failed with %s\n", \
	#expr, __LINE__, vk_Result_to_str(__result)); \
	} \
	} while (0)

	/**/

	static void override_queue(struct device_data *device_data,
	VkDevice device,
	uint32_t queue_family_index,
	VkQueue queue)
	{
	VkCommandPoolCreateInfo cmd_buffer_pool_info = {
	.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
	.queueFamilyIndex = queue_family_index,
	};
	VkCommandPool cmd_pool;
	VK_CHECK(device_data->vtable.CreateCommandPool(device,
	&cmd_buffer_pool_info,
	NULL, &cmd_pool));


	VkCommandBufferAllocateInfo cmd_buffer_info = {
	.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
	.commandPool = cmd_pool,
	.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
	.commandBufferCount = 1,
	};
	VkCommandBuffer cmd_buffer;
	VK_CHECK(device_data->vtable.AllocateCommandBuffers(device,
	&cmd_buffer_info,
	&cmd_buffer));
	VK_CHECK(device_data->set_device_loader_data(device, cmd_buffer));

	VkCommandBufferBeginInfo buffer_begin_info = {
	.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
	};
	device_data->vtable.BeginCommandBuffer(cmd_buffer, &buffer_begin_info);

	VkPerformanceOverrideInfoINTEL override_info = {
	.sType = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL,
	.type = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL,
	.enable = VK_TRUE,
	};
	device_data->vtable.CmdSetPerformanceOverrideINTEL(cmd_buffer, &override_info);

	device_data->vtable.EndCommandBuffer(cmd_buffer);

	VkSubmitInfo submit_info = {
	.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
	.commandBufferCount = 1,
	.pCommandBuffers = &cmd_buffer,
	};
	VK_CHECK(device_data->vtable.QueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE));

	VK_CHECK(device_data->vtable.QueueWaitIdle(queue));

	device_data->vtable.DestroyCommandPool(device, cmd_pool, NULL);
	}

	static void device_override_queues(struct device_data *device_data,
	const VkDeviceCreateInfo *pCreateInfo)
	{
	for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; i++) {
	for (uint32_t j = 0; j < pCreateInfo->pQueueCreateInfos[i].queueCount; j++) {
	VkQueue queue;
	device_data->vtable.GetDeviceQueue(device_data->device,
	pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex,
	j, &queue);

	VK_CHECK(device_data->set_device_loader_data(device_data->device, queue));

	override_queue(device_data, device_data->device,
	pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex, queue);
	}
	}
	}

	static VkLayerDeviceCreateInfo get_device_chain_info(const VkDeviceCreateInfo pCreateInfo,
	VkLayerFunction func)
	{
	vk_foreach_struct_const(item, pCreateInfo->pNext) {
	if (item->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO &&
	((VkLayerDeviceCreateInfo *) item)->function == func)
	return (VkLayerDeviceCreateInfo *)item;
	}
	unreachable("device chain info not found");
	return NULL;
	}

	static struct device_data new_device_data(VkDevice device, struct instance_data instance)
	{
	struct device_data data = calloc(1, sizeof(data));
	data->instance = instance;
	data->device = device;
	map_object(HKEY(data->device), data);
	return data;
	}

	static void destroy_device_data(struct device_data *data)
	{
	unmap_object(HKEY(data->device));
	free(data);
	}

	static VkResult nullhw_CreateDevice(
	VkPhysicalDevice physicalDevice,
	const VkDeviceCreateInfo* pCreateInfo,
	const VkAllocationCallbacks* pAllocator,
	VkDevice* pDevice)
	{
	VkLayerDeviceCreateInfo *chain_info =
	get_device_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);

	assert(chain_info->u.pLayerInfo);
	PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
	PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
	PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice");
	if (fpCreateDevice == NULL) {
	return VK_ERROR_INITIALIZATION_FAILED;
	}

	// Advance the link info for the next element on the chain
	chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;

	VkDeviceCreateInfo device_info = *pCreateInfo;
	const char *extensions = calloc(device_info.enabledExtensionCount + 1, sizeof(extensions));
	bool found = false;
	for (uint32_t i = 0; i < device_info.enabledExtensionCount; i++) {
	if (!strcmp(device_info.ppEnabledExtensionNames[i], "VK_INTEL_performance_query")) {
	found = true;
	break;
	}
	}
	if (!found) {
	memcpy(extensions, device_info.ppEnabledExtensionNames,
	sizeof(extensions) device_info.enabledExtensionCount);
	extensions[device_info.enabledExtensionCount++] = "VK_INTEL_performance_query";
	device_info.ppEnabledExtensionNames = extensions;
	}

	VkResult result = fpCreateDevice(physicalDevice, &device_info, pAllocator, pDevice);
	free(extensions);
	if (result != VK_SUCCESS) return result;

	struct instance_data *instance_data = FIND(struct instance_data, physicalDevice);
	struct device_data device_data = new_device_data(pDevice, instance_data);
	device_data->physical_device = physicalDevice;
	vk_device_dispatch_table_load(&device_data->vtable, fpGetDeviceProcAddr, *pDevice);

	VkLayerDeviceCreateInfo *load_data_info =
	get_device_chain_info(pCreateInfo, VK_LOADER_DATA_CALLBACK);
	device_data->set_device_loader_data = load_data_info->u.pfnSetDeviceLoaderData;

	device_override_queues(device_data, pCreateInfo);

	return result;
	}

	static void nullhw_DestroyDevice(
	VkDevice device,
	const VkAllocationCallbacks* pAllocator)
	{
	struct device_data *device_data = FIND(struct device_data, device);
	device_data->vtable.DestroyDevice(device, pAllocator);
	destroy_device_data(device_data);
	}

	static struct instance_data *new_instance_data(VkInstance instance)
	{
	struct instance_data data = calloc(1, sizeof(data));
	data->instance = instance;
	map_object(HKEY(data->instance), data);
	return data;
	}

	static void destroy_instance_data(struct instance_data *data)
	{
	unmap_object(HKEY(data->instance));
	free(data);
	}

	static VkLayerInstanceCreateInfo get_instance_chain_info(const VkInstanceCreateInfo pCreateInfo,
	VkLayerFunction func)
	{
	vk_foreach_struct_const(item, pCreateInfo->pNext) {
	if (item->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO &&
	((VkLayerInstanceCreateInfo *) item)->function == func)
	return (VkLayerInstanceCreateInfo *) item;
	}
	unreachable("instance chain info not found");
	return NULL;
	}

	static VkResult nullhw_CreateInstance(
	const VkInstanceCreateInfo* pCreateInfo,
	const VkAllocationCallbacks* pAllocator,
	VkInstance* pInstance)
	{
	VkLayerInstanceCreateInfo *chain_info =
	get_instance_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);

	assert(chain_info->u.pLayerInfo);
	PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
	chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
	PFN_vkCreateInstance fpCreateInstance =
	(PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance");
	if (fpCreateInstance == NULL) {
	return VK_ERROR_INITIALIZATION_FAILED;
	}

	// Advance the link info for the next element on the chain
	chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;

	VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
	if (result != VK_SUCCESS) return result;

	struct instance_data instance_data = new_instance_data(pInstance);
	vk_instance_dispatch_table_load(&instance_data->vtable,
	fpGetInstanceProcAddr,
	instance_data->instance);

	return result;
	}

	static void nullhw_DestroyInstance(
	VkInstance instance,
	const VkAllocationCallbacks* pAllocator)
	{
	struct instance_data *instance_data = FIND(struct instance_data, instance);
	instance_data->vtable.DestroyInstance(instance, pAllocator);
	destroy_instance_data(instance_data);
	}

	static const struct {
	const char *name;
	void *ptr;
	} name_to_funcptr_map[] = {
	{ "vkGetDeviceProcAddr", (void *) vkGetDeviceProcAddr },
	#define ADD_HOOK(fn) { "vk" # fn, (void *) nullhw_ ## fn }
	ADD_HOOK(CreateInstance),
	ADD_HOOK(DestroyInstance),
	ADD_HOOK(CreateDevice),
	ADD_HOOK(DestroyDevice),
	};

	static void find_ptr(const char name)
	{
	for (uint32_t i = 0; i < ARRAY_SIZE(name_to_funcptr_map); i++) {
	if (strcmp(name, name_to_funcptr_map[i].name) == 0)
	return name_to_funcptr_map[i].ptr;
	}

	return NULL;
	}

	PUBLIC VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev,
	const char *funcName)
	{
	void *ptr = find_ptr(funcName);
	if (ptr) return (PFN_vkVoidFunction)(ptr);

	if (dev == NULL) return NULL;

	struct device_data *device_data = FIND(struct device_data, dev);
	if (device_data->vtable.GetDeviceProcAddr == NULL) return NULL;
	return device_data->vtable.GetDeviceProcAddr(dev, funcName);
	}

	PUBLIC VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance,
	const char *funcName)
	{
	void *ptr = find_ptr(funcName);
	if (ptr) return (PFN_vkVoidFunction) ptr;

	struct instance_data *instance_data = FIND(struct instance_data, instance);
	if (instance_data->vtable.GetInstanceProcAddr == NULL) return NULL;
	return instance_data->vtable.GetInstanceProcAddr(instance, funcName);
	}