From a1de4b2dffb98222ca59f4a70c301d22bb4c089e Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Fri, 8 Jan 2016 12:18:43 -0700 Subject: loader: implement new layer init method New layer init method requires the construction of Link information for CreateInstance and CreateDevice that is accessible to layers via the CreateInfo.pNext pointer. The layer can then use the Get*ProcAddr from the Link structure to initialize their dispatch table if the call down the chain returns successfully. This removes the need to do special initialization work at Get*ProcAddr time. Layer Get*ProcAddr now return their internal function pointers regardless of the value of instance or device. Only need to have valid instance & device when looking up extensions or when passing the request down the chain. This mechanism allows us to remove object wrapping used by the loader previously. Also simplifies the dispatch table setup. Conflicts: layers/device_limits.cpp layers/draw_state.cpp loader/loader.c loader/trampoline.c --- layers/vk_layer_table.cpp | 59 +++++++++++++++++++++++------------------------ 1 file changed, 29 insertions(+), 30 deletions(-) (limited to 'layers/vk_layer_table.cpp') diff --git a/layers/vk_layer_table.cpp b/layers/vk_layer_table.cpp index 93d2fbf4..b06fb312 100644 --- a/layers/vk_layer_table.cpp +++ b/layers/vk_layer_table.cpp @@ -100,9 +100,9 @@ VkLayerDispatchTable *get_dispatch_table(device_table_map &map, void* object) device_table_map::const_iterator it = map.find((void *) key); #if DISPATCH_MAP_DEBUG if (it != map.end()) { - fprintf(stderr, "instance_dispatch_table: map: %p, object: %p, key: %p, table: %p\n", &tableInstanceMap, object, key, it->second); + fprintf(stderr, "device_dispatch_table: map: %p, object: %p, key: %p, table: %p\n", &tableInstanceMap, object, key, it->second); } else { - fprintf(stderr, "instance_dispatch_table: map: %p, object: %p, key: %p, table: UNKNOWN\n", &tableInstanceMap, object, key); + fprintf(stderr, "device_dispatch_table: map: %p, object: %p, key: %p, table: UNKNOWN\n", &tableInstanceMap, object, key); } #endif assert(it != map.end() && "Not able to find device dispatch entry"); @@ -125,20 +125,22 @@ VkLayerInstanceDispatchTable *get_dispatch_table(instance_table_map &map, void* return it->second; } -VkLayerInstanceCreateInfo *get_chain_info(const VkInstanceCreateInfo *pCreateInfo) +VkLayerInstanceCreateInfo *get_chain_info(const VkInstanceCreateInfo *pCreateInfo, VkLayerFunction func) { VkLayerInstanceCreateInfo *chain_info = (VkLayerInstanceCreateInfo *) pCreateInfo->pNext; - while (chain_info && chain_info->sType != VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO) { + while (chain_info && !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO + && chain_info->function == func)) { chain_info = (VkLayerInstanceCreateInfo *) chain_info->pNext; } assert(chain_info != NULL); return chain_info; } -VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo) +VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo, VkLayerFunction func) { VkLayerDeviceCreateInfo *chain_info = (VkLayerDeviceCreateInfo *) pCreateInfo->pNext; - while (chain_info && chain_info->sType != VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO) { + while (chain_info && !(chain_info->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO + && chain_info->function == func)) { chain_info = (VkLayerDeviceCreateInfo *) chain_info->pNext; } assert(chain_info != NULL); @@ -152,67 +154,64 @@ VkLayerDeviceCreateInfo *get_chain_info(const VkDeviceCreateInfo *pCreateInfo) * Device -> CommandBuffer or Queue * If use the object themselves as key to map then implies Create entrypoints have to be intercepted * and a new key inserted into map */ -VkLayerInstanceDispatchTable * initInstanceTable(instance_table_map &map, const VkBaseLayerObject *instancew) +VkLayerInstanceDispatchTable * initInstanceTable(VkInstance instance, const PFN_vkGetInstanceProcAddr gpa, instance_table_map &map) { VkLayerInstanceDispatchTable *pTable; - assert(instancew); - VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) instancew->baseObject; + dispatch_key key = get_dispatch_key(instance); + instance_table_map::const_iterator it = map.find((void *) key); - std::unordered_map::const_iterator it = map.find((void *) *ppDisp); if (it == map.end()) { pTable = new VkLayerInstanceDispatchTable; - map[(void *) *ppDisp] = pTable; + map[(void *) key] = pTable; #if DISPATCH_MAP_DEBUG - fprintf(stderr, "New, Instance: map: %p, base object: %p, key: %p, table: %p\n", &map, instancew, *ppDisp, pTable); + fprintf(stderr, "New, Instance: map: %p, key: %p, table: %p\n", &map, key, pTable); #endif } else { #if DISPATCH_MAP_DEBUG - fprintf(stderr, "Instance: map: %p, base object: %p, key: %p, table: %p\n", &map, instancew, *ppDisp, it->second); + fprintf(stderr, "Instance: map: %p, key: %p, table: %p\n", &map, key, it->second); #endif return it->second; } - layer_init_instance_dispatch_table(pTable, instancew); + layer_init_instance_dispatch_table(instance, pTable, gpa); return pTable; } -VkLayerInstanceDispatchTable * initInstanceTable(const VkBaseLayerObject *instancew) +VkLayerInstanceDispatchTable * initInstanceTable(VkInstance instance, const PFN_vkGetInstanceProcAddr gpa) { - return initInstanceTable(tableInstanceMap, instancew); + return initInstanceTable(instance, gpa, tableInstanceMap); } -VkLayerDispatchTable * initDeviceTable(device_table_map &map, const VkBaseLayerObject *devw) +VkLayerDispatchTable * initDeviceTable(VkDevice device, const PFN_vkGetDeviceProcAddr gpa, device_table_map &map) { - VkLayerDispatchTable *layer_device_table = NULL; - assert(devw); - VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) (devw->baseObject); - VkLayerDispatchTable *base_device_table = *ppDisp; + VkLayerDispatchTable *pTable; + dispatch_key key = get_dispatch_key(device); + device_table_map::const_iterator it = map.find((void *) key); - std::unordered_map::const_iterator it = map.find((void *) base_device_table); if (it == map.end()) { - layer_device_table = new VkLayerDispatchTable; - map[(void *) base_device_table] = layer_device_table; + pTable = new VkLayerDispatchTable; + map[(void *) key] = pTable; #if DISPATCH_MAP_DEBUG - fprintf(stderr, "New, Device: map: %p, base object: %p, key: %p, table: %p\n", &map, devw, *ppDisp, layer_device_table); + fprintf(stderr, "New, Device: map: %p, key: %p, table: %p\n", &map, key, pTable); #endif } else { #if DISPATCH_MAP_DEBUG - fprintf(stderr, "Device: map: %p, base object: %p, key: %p, table: %p\n", &map, devw, *ppDisp, it->second); + fprintf(stderr, "Device: map: %p, key: %p, table: %p\n", &map, key, it->second); #endif return it->second; } - layer_initialize_dispatch_table(layer_device_table, devw); + layer_init_device_dispatch_table(device, pTable, gpa); - return layer_device_table; + return pTable; } -VkLayerDispatchTable * initDeviceTable(const VkBaseLayerObject *devw) +VkLayerDispatchTable * initDeviceTable(VkDevice device, const PFN_vkGetDeviceProcAddr gpa) { - return initDeviceTable(tableMap, devw); + return initDeviceTable(device, gpa, tableMap); } -- cgit v1.2.3