diff --git a/src/gallium/frontends/lavapipe/lvp_device.c b/src/gallium/frontends/lavapipe/lvp_device.c index dacc4d52eae..2a2e2613cb2 100644 --- a/src/gallium/frontends/lavapipe/lvp_device.c +++ b/src/gallium/frontends/lavapipe/lvp_device.c @@ -45,8 +45,11 @@ lvp_physical_device_init(struct lvp_physical_device *device, { VkResult result; + struct vk_physical_device_dispatch_table dispatch_table; + vk_physical_device_dispatch_table_from_entrypoints( + &dispatch_table, &lvp_physical_device_entrypoints, true); result = vk_physical_device_init(&device->vk, &instance->vk, - NULL, NULL); + NULL, &dispatch_table); if (result != VK_SUCCESS) { vk_error(instance, result); goto fail; @@ -58,7 +61,7 @@ lvp_physical_device_init(struct lvp_physical_device *device, return vk_error(instance, VK_ERROR_OUT_OF_HOST_MEMORY); device->max_images = device->pscreen->get_shader_param(device->pscreen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_SHADER_IMAGES); - lvp_physical_device_get_supported_extensions(device, &device->supported_extensions); + lvp_physical_device_get_supported_extensions(device, &device->vk.supported_extensions); result = lvp_init_wsi(device); if (result != VK_SUCCESS) { vk_physical_device_finish(&device->vk); @@ -132,9 +135,13 @@ VkResult lvp_CreateInstance( if (!instance) return vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY); + struct vk_instance_dispatch_table dispatch_table; + vk_instance_dispatch_table_from_entrypoints( + &dispatch_table, &lvp_instance_entrypoints, true); result = vk_instance_init(&instance->vk, - NULL, NULL, + &lvp_instance_extensions_supported, + &dispatch_table, pCreateInfo, pAllocator); if (result != VK_SUCCESS) { @@ -145,65 +152,6 @@ VkResult lvp_CreateInstance( instance->apiVersion = client_version; instance->physicalDeviceCount = -1; - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - int idx; - for (idx = 0; idx < LVP_INSTANCE_EXTENSION_COUNT; idx++) { - if (!strcmp(pCreateInfo->ppEnabledExtensionNames[i], - lvp_instance_extensions[idx].extensionName)) - break; - } - - if (idx >= LVP_INSTANCE_EXTENSION_COUNT || - !lvp_instance_extensions_supported.extensions[idx]) { - vk_free2(&default_alloc, pAllocator, instance); - return vk_error(instance, VK_ERROR_EXTENSION_NOT_PRESENT); - } - instance->enabled_extensions.extensions[idx] = true; - } - - bool unchecked = instance->debug_flags & LVP_DEBUG_ALL_ENTRYPOINTS; - for (unsigned i = 0; i < ARRAY_SIZE(instance->dispatch.entrypoints); i++) { - /* Vulkan requires that entrypoints for extensions which have - * not been enabled must not be advertised. - */ - if (!unchecked && - !lvp_instance_entrypoint_is_enabled(i, instance->apiVersion, - &instance->enabled_extensions)) { - instance->dispatch.entrypoints[i] = NULL; - } else { - instance->dispatch.entrypoints[i] = - lvp_instance_dispatch_table.entrypoints[i]; - } - } - - for (unsigned i = 0; i < ARRAY_SIZE(instance->physical_device_dispatch.entrypoints); i++) { - /* Vulkan requires that entrypoints for extensions which have - * not been enabled must not be advertised. - */ - if (!unchecked && - !lvp_physical_device_entrypoint_is_enabled(i, instance->apiVersion, - &instance->enabled_extensions)) { - instance->physical_device_dispatch.entrypoints[i] = NULL; - } else { - instance->physical_device_dispatch.entrypoints[i] = - lvp_physical_device_dispatch_table.entrypoints[i]; - } - } - - for (unsigned i = 0; i < ARRAY_SIZE(instance->device_dispatch.entrypoints); i++) { - /* Vulkan requires that entrypoints for extensions which have - * not been enabled must not be advertised. - */ - if (!unchecked && - !lvp_device_entrypoint_is_enabled(i, instance->apiVersion, - &instance->enabled_extensions, NULL)) { - instance->device_dispatch.entrypoints[i] = NULL; - } else { - instance->device_dispatch.entrypoints[i] = - lvp_device_dispatch_table.entrypoints[i]; - } - } - // _mesa_locale_init(); glsl_type_singleton_init_or_ref(); // VG(VALGRIND_CREATE_MEMPOOL(instance, 0, false)); @@ -725,46 +673,9 @@ PFN_vkVoidFunction lvp_GetInstanceProcAddr( const char* pName) { LVP_FROM_HANDLE(lvp_instance, instance, _instance); - - /* The Vulkan 1.0 spec for vkGetInstanceProcAddr has a table of exactly - * when we have to return valid function pointers, NULL, or it's left - * undefined. See the table for exact details. - */ - if (pName == NULL) - return NULL; - -#define LOOKUP_LVP_ENTRYPOINT(entrypoint) \ - if (strcmp(pName, "vk" #entrypoint) == 0) \ - return (PFN_vkVoidFunction)lvp_##entrypoint - - LOOKUP_LVP_ENTRYPOINT(EnumerateInstanceExtensionProperties); - LOOKUP_LVP_ENTRYPOINT(EnumerateInstanceLayerProperties); - LOOKUP_LVP_ENTRYPOINT(EnumerateInstanceVersion); - LOOKUP_LVP_ENTRYPOINT(CreateInstance); - - /* GetInstanceProcAddr() can also be called with a NULL instance. - * See https://gitlab.khronos.org/vulkan/vulkan/issues/2057 - */ - LOOKUP_LVP_ENTRYPOINT(GetInstanceProcAddr); - -#undef LOOKUP_LVP_ENTRYPOINT - - if (instance == NULL) - return NULL; - - int idx = lvp_get_instance_entrypoint_index(pName); - if (idx >= 0) - return instance->dispatch.entrypoints[idx]; - - idx = lvp_get_physical_device_entrypoint_index(pName); - if (idx >= 0) - return instance->physical_device_dispatch.entrypoints[idx]; - - idx = lvp_get_device_entrypoint_index(pName); - if (idx >= 0) - return instance->device_dispatch.entrypoints[idx]; - - return NULL; + return vk_instance_get_proc_addr(&instance->vk, + &lvp_instance_entrypoints, + pName); } /* The loader wants us to expose a second GetInstanceProcAddr function @@ -794,30 +705,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr( const char* pName) { LVP_FROM_HANDLE(lvp_instance, instance, _instance); - - if (!pName || !instance) - return NULL; - - int idx = lvp_get_physical_device_entrypoint_index(pName); - if (idx < 0) - return NULL; - - return instance->physical_device_dispatch.entrypoints[idx]; -} - -PFN_vkVoidFunction lvp_GetDeviceProcAddr( - VkDevice _device, - const char* pName) -{ - LVP_FROM_HANDLE(lvp_device, device, _device); - if (!device || !pName) - return NULL; - - int idx = lvp_get_device_entrypoint_index(pName); - if (idx < 0) - return NULL; - - return device->dispatch.entrypoints[idx]; + return vk_instance_get_physical_device_proc_addr(&instance->vk, pName); } static int queue_thread(void *data) @@ -883,42 +771,6 @@ lvp_queue_finish(struct lvp_queue *queue) queue->ctx->destroy(queue->ctx); } -static int lvp_get_device_extension_index(const char *name) -{ - for (unsigned i = 0; i < LVP_DEVICE_EXTENSION_COUNT; ++i) { - if (strcmp(name, lvp_device_extensions[i].extensionName) == 0) - return i; - } - return -1; -} - -static void -lvp_device_init_dispatch(struct lvp_device *device) -{ - const struct lvp_instance *instance = (struct lvp_instance *)device->physical_device->vk.instance; - const struct lvp_device_dispatch_table *dispatch_table_layer = NULL; - bool unchecked = instance->debug_flags & LVP_DEBUG_ALL_ENTRYPOINTS; - - for (unsigned i = 0; i < ARRAY_SIZE(device->dispatch.entrypoints); i++) { - /* Vulkan requires that entrypoints for extensions which have not been - * enabled must not be advertised. - */ - if (!unchecked && - !lvp_device_entrypoint_is_enabled(i, instance->apiVersion, - &instance->enabled_extensions, - &device->enabled_extensions)) { - device->dispatch.entrypoints[i] = NULL; - } else if (dispatch_table_layer && - dispatch_table_layer->entrypoints[i]) { - device->dispatch.entrypoints[i] = - dispatch_table_layer->entrypoints[i]; - } else { - device->dispatch.entrypoints[i] = - lvp_device_dispatch_table.entrypoints[i]; - } - } -} - VkResult lvp_CreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, @@ -952,7 +804,12 @@ VkResult lvp_CreateDevice( if (!device) return vk_error(instance, VK_ERROR_OUT_OF_HOST_MEMORY); - VkResult result = vk_device_init(&device->vk, NULL, NULL, pCreateInfo, + struct vk_device_dispatch_table dispatch_table; + vk_device_dispatch_table_from_entrypoints(&dispatch_table, + &lvp_device_entrypoints, true); + VkResult result = vk_device_init(&device->vk, + &physical_device->vk, + &dispatch_table, pCreateInfo, &physical_device->vk.instance->alloc, pAllocator); if (result != VK_SUCCESS) { @@ -963,19 +820,6 @@ VkResult lvp_CreateDevice( device->instance = (struct lvp_instance *)physical_device->vk.instance; device->physical_device = physical_device; - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i]; - int index = lvp_get_device_extension_index(ext_name); - if (index < 0 || !physical_device->supported_extensions.extensions[index]) { - vk_device_finish(&device->vk); - vk_free(&device->vk.alloc, device); - return vk_error(instance, VK_ERROR_EXTENSION_NOT_PRESENT); - } - - device->enabled_extensions.extensions[index] = true; - } - lvp_device_init_dispatch(device); - mtx_init(&device->fence_lock, mtx_plain); device->pscreen = physical_device->pscreen; @@ -1005,10 +849,10 @@ VkResult lvp_EnumerateInstanceExtensionProperties( { VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount); - for (int i = 0; i < LVP_INSTANCE_EXTENSION_COUNT; i++) { + for (int i = 0; i < VK_INSTANCE_EXTENSION_COUNT; i++) { if (lvp_instance_extensions_supported.extensions[i]) { vk_outarray_append(&out, prop) { - *prop = lvp_instance_extensions[i]; + *prop = vk_instance_extensions[i]; } } } @@ -1016,25 +860,6 @@ VkResult lvp_EnumerateInstanceExtensionProperties( return vk_outarray_status(&out); } -VkResult lvp_EnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) -{ - LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); - VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount); - - for (int i = 0; i < LVP_DEVICE_EXTENSION_COUNT; i++) { - if (device->supported_extensions.extensions[i]) { - vk_outarray_append(&out, prop) { - *prop = lvp_device_extensions[i]; - } - } - } - return vk_outarray_status(&out); -} - VkResult lvp_EnumerateInstanceLayerProperties( uint32_t* pPropertyCount, VkLayerProperties* pProperties) diff --git a/src/gallium/frontends/lavapipe/lvp_entrypoints_gen.py b/src/gallium/frontends/lavapipe/lvp_entrypoints_gen.py deleted file mode 100644 index 84ccd906478..00000000000 --- a/src/gallium/frontends/lavapipe/lvp_entrypoints_gen.py +++ /dev/null @@ -1,816 +0,0 @@ -# coding=utf-8 -# -# Copyright © 2015, 2017 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. -# - -import argparse -import functools -import math -import os -import xml.etree.ElementTree as et - -from collections import OrderedDict, namedtuple -from mako.template import Template - -from lvp_extensions import * - -# We generate a static hash table for entry point lookup -# (vkGetProcAddress). We use a linear congruential generator for our hash -# function and a power-of-two size table. The prime numbers are determined -# experimentally. - -# We currently don't use layers in lvp, but keeping the ability for anv -# anyways, so we can use it for device groups. -LAYERS = [ - 'lvp' -] - -TEMPLATE_H = Template("""\ -/* This file generated from ${filename}, don't edit directly. */ - -struct lvp_instance_dispatch_table { - union { - void *entrypoints[${len(instance_entrypoints)}]; - struct { - % for e in instance_entrypoints: - % if e.guard is not None: -#ifdef ${e.guard} - PFN_${e.name} ${e.name}; -#else - void *${e.name}; -# endif - % else: - PFN_${e.name} ${e.name}; - % endif - % endfor - }; - }; -}; - -struct lvp_physical_device_dispatch_table { - union { - void *entrypoints[${len(physical_device_entrypoints)}]; - struct { - % for e in physical_device_entrypoints: - % if e.guard is not None: -#ifdef ${e.guard} - PFN_${e.name} ${e.name}; -#else - void *${e.name}; -# endif - % else: - PFN_${e.name} ${e.name}; - % endif - % endfor - }; - }; -}; - -struct lvp_device_dispatch_table { - union { - void *entrypoints[${len(device_entrypoints)}]; - struct { - % for e in device_entrypoints: - % if e.guard is not None: -#ifdef ${e.guard} - PFN_${e.name} ${e.name}; -#else - void *${e.name}; -# endif - % else: - PFN_${e.name} ${e.name}; - % endif - % endfor - }; - }; -}; - -extern const struct lvp_instance_dispatch_table lvp_instance_dispatch_table; -%for layer in LAYERS: -extern const struct lvp_physical_device_dispatch_table ${layer}_physical_device_dispatch_table; -%endfor -%for layer in LAYERS: -extern const struct lvp_device_dispatch_table ${layer}_device_dispatch_table; -%endfor - -% for e in instance_entrypoints: - % if e.alias and e.alias.enabled: - <% continue %> - % endif - % if e.guard is not None: -#ifdef ${e.guard} - % endif - ${e.return_type} ${e.prefixed_name('lvp')}(${e.decl_params()}); - % if e.guard is not None: -#endif // ${e.guard} - % endif -% endfor - -% for e in physical_device_entrypoints: - % if e.alias: - <% continue %> - % endif - % if e.guard is not None: -#ifdef ${e.guard} - % endif - % for layer in LAYERS: - ${e.return_type} ${e.prefixed_name(layer)}(${e.decl_params()}); - % endfor - % if e.guard is not None: -#endif // ${e.guard} - % endif -% endfor - -% for e in device_entrypoints: - % if e.alias and e.alias.enabled: - <% continue %> - % endif - % if e.guard is not None: -#ifdef ${e.guard} - % endif - % for layer in LAYERS: - ${e.return_type} ${e.prefixed_name(layer)}(${e.decl_params()}); - % endfor - % if e.guard is not None: -#endif // ${e.guard} - % endif -% endfor -""", output_encoding='utf-8') - -TEMPLATE_C = Template(u"""\ -/* - * Copyright © 2015 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. - */ - -/* This file generated from ${filename}, don't edit directly. */ - -#include "lvp_private.h" - -#include "util/macros.h" -struct string_map_entry { - uint32_t name; - uint32_t hash; - uint32_t num; -}; - -/* We use a big string constant to avoid lots of relocations from the entry - * point table to lots of little strings. The entries in the entry point table - * store the index into this big string. - */ - -<%def name="strmap(strmap, prefix)"> -static const char ${prefix}_strings[] = -% for s in strmap.sorted_strings: - "${s.string}\\0" -% endfor -; - -static const struct string_map_entry ${prefix}_string_map_entries[] = { -% for s in strmap.sorted_strings: - { ${s.offset}, ${'{:0=#8x}'.format(s.hash)}, ${s.num} }, /* ${s.string} */ -% endfor -}; - -/* Hash table stats: - * size ${len(strmap.sorted_strings)} entries - * collisions entries: -% for i in range(10): - * ${i}${'+' if i == 9 else ' '} ${strmap.collisions[i]} -% endfor - */ - -#define none 0xffff -static const uint16_t ${prefix}_string_map[${strmap.hash_size}] = { -% for e in strmap.mapping: - ${ '{:0=#6x}'.format(e) if e >= 0 else 'none' }, -% endfor -}; - -static int -${prefix}_string_map_lookup(const char *str) -{ - static const uint32_t prime_factor = ${strmap.prime_factor}; - static const uint32_t prime_step = ${strmap.prime_step}; - const struct string_map_entry *e; - uint32_t hash, h; - uint16_t i; - const char *p; - - hash = 0; - for (p = str; *p; p++) - hash = hash * prime_factor + *p; - - h = hash; - while (1) { - i = ${prefix}_string_map[h & ${strmap.hash_mask}]; - if (i == none) - return -1; - e = &${prefix}_string_map_entries[i]; - if (e->hash == hash && strcmp(str, ${prefix}_strings + e->name) == 0) - return e->num; - h += prime_step; - } - - return -1; -} - -static const char * -${prefix}_entry_name(int num) -{ - for (int i = 0; i < ARRAY_SIZE(${prefix}_string_map_entries); i++) { - if (${prefix}_string_map_entries[i].num == num) - return &${prefix}_strings[${prefix}_string_map_entries[i].name]; - } - return NULL; -} - - -${strmap(instance_strmap, 'instance')} -${strmap(physical_device_strmap, 'physical_device')} -${strmap(device_strmap, 'device')} - -/* Weak aliases for all potential implementations. These will resolve to - * NULL if they're not defined, which lets the resolve_entrypoint() function - * either pick the correct entry point. - */ - -% for e in instance_entrypoints: - % if e.alias and e.alias.enabled: - <% continue %> - % endif - % if e.guard is not None: -#ifdef ${e.guard} - % endif - ${e.return_type} ${e.prefixed_name('lvp')}(${e.decl_params()}) __attribute__ ((weak)); - % if e.guard is not None: -#endif // ${e.guard} - % endif -% endfor - -const struct lvp_instance_dispatch_table lvp_instance_dispatch_table = { -% for e in instance_entrypoints: - % if e.guard is not None: -#ifdef ${e.guard} - % endif - .${e.name} = ${e.prefixed_name('lvp')}, - % if e.guard is not None: -#endif // ${e.guard} - % endif -% endfor -}; - -% for e in physical_device_entrypoints: - % if e.alias and e.alias.enabled: - <% continue %> - % endif - % if e.guard is not None: -#ifdef ${e.guard} - % endif - ${e.return_type} ${e.prefixed_name('lvp')}(${e.decl_params()}) __attribute__ ((weak)); - % if e.guard is not None: -#endif // ${e.guard} - % endif -% endfor - -const struct lvp_physical_device_dispatch_table lvp_physical_device_dispatch_table = { -% for e in physical_device_entrypoints: - % if e.guard is not None: -#ifdef ${e.guard} - % endif - .${e.name} = ${e.prefixed_name('lvp')}, - % if e.guard is not None: -#endif // ${e.guard} - % endif -% endfor -}; - - -% for layer in LAYERS: - % for e in device_entrypoints: - % if e.alias and e.alias.enabled: - <% continue %> - % endif - % if e.guard is not None: -#ifdef ${e.guard} - % endif - % if layer == 'lvp': - ${e.return_type} __attribute__ ((weak)) - ${e.prefixed_name('lvp')}(${e.decl_params()}) - { - % if e.params[0].type == 'VkDevice': - LVP_FROM_HANDLE(lvp_device, lvp_device, ${e.params[0].name}); - return lvp_device->dispatch.${e.name}(${e.call_params()}); - % elif e.params[0].type == 'VkCommandBuffer': - LVP_FROM_HANDLE(lvp_cmd_buffer, lvp_cmd_buffer, ${e.params[0].name}); - return lvp_cmd_buffer->device->dispatch.${e.name}(${e.call_params()}); - % elif e.params[0].type == 'VkQueue': - LVP_FROM_HANDLE(lvp_queue, lvp_queue, ${e.params[0].name}); - return lvp_queue->device->dispatch.${e.name}(${e.call_params()}); - % else: - assert(!"Unhandled device child trampoline case: ${e.params[0].type}"); - % endif - } - % else: - ${e.return_type} ${e.prefixed_name(layer)}(${e.decl_params()}) __attribute__ ((weak)); - % endif - % if e.guard is not None: -#endif // ${e.guard} - % endif - % endfor - - const struct lvp_device_dispatch_table ${layer}_device_dispatch_table = { - % for e in device_entrypoints: - % if e.guard is not None: -#ifdef ${e.guard} - % endif - .${e.name} = ${e.prefixed_name(layer)}, - % if e.guard is not None: -#endif // ${e.guard} - % endif - % endfor - }; -% endfor - - -/** Return true if the core version or extension in which the given entrypoint - * is defined is enabled. - * - * If device is NULL, all device extensions are considered enabled. - */ -bool -lvp_instance_entrypoint_is_enabled(int index, uint32_t core_version, - const struct lvp_instance_extension_table *instance) -{ - switch (index) { -% for e in instance_entrypoints: - case ${e.num}: - /* ${e.name} */ - % if e.core_version: - return ${e.core_version.c_vk_version()} <= core_version; - % elif e.extensions: - % for ext in e.extensions: - % if ext.type == 'instance': - if (instance->${ext.name[3:]}) return true; - % else: - /* All device extensions are considered enabled at the instance level */ - return true; - % endif - % endfor - return false; - % else: - return true; - % endif -% endfor - default: - return false; - } -} - -/** Return true if the core version or extension in which the given entrypoint - * is defined is enabled. - * - * If device is NULL, all device extensions are considered enabled. - */ -bool -lvp_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct lvp_instance_extension_table *instance) -{ - switch (index) { -% for e in physical_device_entrypoints: - case ${e.num}: - /* ${e.name} */ - % if e.core_version: - return ${e.core_version.c_vk_version()} <= core_version; - % elif e.extensions: - % for ext in e.extensions: - % if ext.type == 'instance': - if (instance->${ext.name[3:]}) return true; - % else: - /* All device extensions are considered enabled at the instance level */ - return true; - % endif - % endfor - return false; - % else: - return true; - % endif -% endfor - default: - return false; - } -} - -/** Return true if the core version or extension in which the given entrypoint - * is defined is enabled. - * - * If device is NULL, all device extensions are considered enabled. - */ -bool -lvp_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct lvp_instance_extension_table *instance, - const struct lvp_device_extension_table *device) -{ - switch (index) { -% for e in device_entrypoints: - case ${e.num}: - /* ${e.name} */ - % if e.core_version: - return ${e.core_version.c_vk_version()} <= core_version; - % elif e.extensions: - % for ext in e.extensions: - % if ext.type == 'instance': - <% assert False %> - % else: - if (!device || device->${ext.name[3:]}) return true; - % endif - % endfor - return false; - % else: - return true; - % endif -% endfor - default: - return false; - } -} - -int -lvp_get_instance_entrypoint_index(const char *name) -{ - return instance_string_map_lookup(name); -} - -int -lvp_get_physical_device_entrypoint_index(const char *name) -{ - return physical_device_string_map_lookup(name); -} - -int -lvp_get_device_entrypoint_index(const char *name) -{ - return device_string_map_lookup(name); -} - -const char * -lvp_get_instance_entry_name(int index) -{ - return instance_entry_name(index); -} - -const char * -lvp_get_physical_device_entry_name(int index) -{ - return physical_device_entry_name(index); -} - -const char * -lvp_get_device_entry_name(int index) -{ - return device_entry_name(index); -} - -static void * __attribute__ ((noinline)) -lvp_resolve_device_entrypoint(uint32_t index) -{ - return lvp_device_dispatch_table.entrypoints[index]; -} - -void * -lvp_lookup_entrypoint(const char *name) -{ - int idx = lvp_get_instance_entrypoint_index(name); - if (idx >= 0) - return lvp_instance_dispatch_table.entrypoints[idx]; - - idx = lvp_get_physical_device_entrypoint_index(name); - if (idx >= 0) - return lvp_physical_device_dispatch_table.entrypoints[idx]; - - idx = lvp_get_device_entrypoint_index(name); - if (idx >= 0) - return lvp_resolve_device_entrypoint(idx); - - return NULL; -}""", output_encoding='utf-8') - -U32_MASK = 2**32 - 1 - -PRIME_FACTOR = 5024183 -PRIME_STEP = 19 - -def round_to_pow2(x): - return 2**int(math.ceil(math.log(x, 2))) - -class StringIntMapEntry(object): - def __init__(self, string, num): - self.string = string - self.num = num - - # Calculate the same hash value that we will calculate in C. - h = 0 - for c in string: - h = ((h * PRIME_FACTOR) + ord(c)) & U32_MASK - self.hash = h - - self.offset = None - -class StringIntMap(object): - def __init__(self): - self.baked = False - self.strings = dict() - - def add_string(self, string, num): - assert not self.baked - assert string not in self.strings - assert num >= 0 and num < 2**31 - self.strings[string] = StringIntMapEntry(string, num) - - def bake(self): - self.sorted_strings = \ - sorted(self.strings.values(), key=lambda x: x.string) - offset = 0 - for entry in self.sorted_strings: - entry.offset = offset - offset += len(entry.string) + 1 - - # Save off some values that we'll need in C - self.hash_size = round_to_pow2(len(self.strings) * 1.25) - self.hash_mask = self.hash_size - 1 - self.prime_factor = PRIME_FACTOR - self.prime_step = PRIME_STEP - - self.mapping = [-1] * self.hash_size - self.collisions = [0] * 10 - for idx, s in enumerate(self.sorted_strings): - level = 0 - h = s.hash - while self.mapping[h & self.hash_mask] >= 0: - h = h + PRIME_STEP - level = level + 1 - self.collisions[min(level, 9)] += 1 - self.mapping[h & self.hash_mask] = idx - -EntrypointParam = namedtuple('EntrypointParam', 'type name decl') - -class EntrypointBase(object): - def __init__(self, name): - self.name = name - self.alias = None - self.guard = None - self.enabled = False - self.num = None - # Extensions which require this entrypoint - self.core_version = None - self.extensions = [] - - def prefixed_name(self, prefix): - assert self.name.startswith('vk') - return prefix + '_' + self.name[2:] - -class Entrypoint(EntrypointBase): - def __init__(self, name, return_type, params, guard = None): - super(Entrypoint, self).__init__(name) - self.return_type = return_type - self.params = params - self.guard = guard - - def is_physical_device_entrypoint(self): - return self.params[0].type in ('VkPhysicalDevice', ) - - def is_device_entrypoint(self): - return self.params[0].type in ('VkDevice', 'VkCommandBuffer', 'VkQueue') - - def decl_params(self): - return ', '.join(p.decl for p in self.params) - - def call_params(self): - return ', '.join(p.name for p in self.params) - -class EntrypointAlias(EntrypointBase): - def __init__(self, name, entrypoint): - super(EntrypointAlias, self).__init__(name) - self.alias = entrypoint - - def is_physical_device_entrypoint(self): - return self.alias.is_physical_device_entrypoint() - - def is_device_entrypoint(self): - return self.alias.is_device_entrypoint() - - def prefixed_name(self, prefix): - if self.alias.enabled: - return self.alias.prefixed_name(prefix) - return super(EntrypointAlias, self).prefixed_name(prefix) - - @property - def params(self): - return self.alias.params - - @property - def return_type(self): - return self.alias.return_type - - def decl_params(self): - return self.alias.decl_params() - - def call_params(self): - return self.alias.call_params() - -def get_entrypoints(doc, entrypoints_to_defines): - """Extract the entry points from the registry.""" - entrypoints = OrderedDict() - - for command in doc.findall('./commands/command'): - if 'alias' in command.attrib: - alias = command.attrib['name'] - target = command.attrib['alias'] - entrypoints[alias] = EntrypointAlias(alias, entrypoints[target]) - else: - name = command.find('./proto/name').text - ret_type = command.find('./proto/type').text - params = [EntrypointParam( - type = p.find('./type').text, - name = p.find('./name').text, - decl = ''.join(p.itertext()) - ) for p in command.findall('./param')] - guard = entrypoints_to_defines.get(name) - # They really need to be unique - assert name not in entrypoints - entrypoints[name] = Entrypoint(name, ret_type, params, guard) - - for feature in doc.findall('./feature'): - assert feature.attrib['api'] == 'vulkan' - version = VkVersion(feature.attrib['number']) - if version > MAX_API_VERSION: - continue - - for command in feature.findall('./require/command'): - e = entrypoints[command.attrib['name']] - e.enabled = True - assert e.core_version is None - e.core_version = version - - supported_exts = dict((ext.name, ext) for ext in EXTENSIONS) - for extension in doc.findall('.extensions/extension'): - ext_name = extension.attrib['name'] - if ext_name not in supported_exts: - continue - - ext = supported_exts[ext_name] - ext.type = extension.attrib['type'] - - for command in extension.findall('./require/command'): - e = entrypoints[command.attrib['name']] - e.enabled = True - assert e.core_version is None - e.extensions.append(ext) - - # if the base command is not supported by the driver yet, don't alias aliases - for e in entrypoints.values(): - if e.alias and not e.alias.enabled: - e_clone = copy.deepcopy(e.alias) - e_clone.enabled = True - e_clone.name = e.name - entrypoints[e.name] = e_clone - - return [e for e in entrypoints.values() if e.enabled] - - -def get_entrypoints_defines(doc): - """Maps entry points to extension defines.""" - entrypoints_to_defines = {} - - platform_define = {} - for platform in doc.findall('./platforms/platform'): - name = platform.attrib['name'] - define = platform.attrib['protect'] - platform_define[name] = define - - for extension in doc.findall('./extensions/extension[@platform]'): - platform = extension.attrib['platform'] - define = platform_define[platform] - - for entrypoint in extension.findall('./require/command'): - fullname = entrypoint.attrib['name'] - entrypoints_to_defines[fullname] = define - - return entrypoints_to_defines - -def main(): - parser = argparse.ArgumentParser() - parser.add_argument('--outdir', help='Where to write the files.', - required=True) - parser.add_argument('--xml', - help='Vulkan API XML file.', - required=True, - action='append', - dest='xml_files') - args = parser.parse_args() - - entrypoints = [] - - for filename in args.xml_files: - doc = et.parse(filename) - entrypoints += get_entrypoints(doc, get_entrypoints_defines(doc)) - - device_entrypoints = [] - physical_device_entrypoints = [] - instance_entrypoints = [] - for e in entrypoints: - if e.is_device_entrypoint(): - device_entrypoints.append(e) - elif e.is_physical_device_entrypoint(): - physical_device_entrypoints.append(e) - else: - instance_entrypoints.append(e) - - device_strmap = StringIntMap() - for num, e in enumerate(device_entrypoints): - device_strmap.add_string(e.name, num) - e.num = num - device_strmap.bake() - - physical_device_strmap = StringIntMap() - for num, e in enumerate(physical_device_entrypoints): - physical_device_strmap.add_string(e.name, num) - e.num = num - physical_device_strmap.bake() - - instance_strmap = StringIntMap() - for num, e in enumerate(instance_entrypoints): - instance_strmap.add_string(e.name, num) - e.num = num - instance_strmap.bake() - - # For outputting entrypoints.h we generate a lvp_EntryPoint() prototype - # per entry point. - try: - with open(os.path.join(args.outdir, 'lvp_entrypoints.h'), 'wb') as f: - f.write(TEMPLATE_H.render(instance_entrypoints=instance_entrypoints, - physical_device_entrypoints=physical_device_entrypoints, - device_entrypoints=device_entrypoints, - LAYERS=LAYERS, - filename=os.path.basename(__file__))) - with open(os.path.join(args.outdir, 'lvp_entrypoints.c'), 'wb') as f: - f.write(TEMPLATE_C.render(instance_entrypoints=instance_entrypoints, - physical_device_entrypoints=physical_device_entrypoints, - device_entrypoints=device_entrypoints, - LAYERS=LAYERS, - instance_strmap=instance_strmap, - physical_device_strmap=physical_device_strmap, - device_strmap=device_strmap, - filename=os.path.basename(__file__))) - except Exception: - # In the event there's an error, this imports some helpers from mako - # to print a useful stack trace and prints it, then exits with - # status 1, if python is run with debug; otherwise it just raises - # the exception - if __debug__: - import sys - from mako import exceptions - sys.stderr.write(exceptions.text_error_template().render() + '\n') - sys.exit(1) - raise - - -if __name__ == '__main__': - main() diff --git a/src/gallium/frontends/lavapipe/lvp_extensions.py b/src/gallium/frontends/lavapipe/lvp_extensions.py index 33035b8d335..349a6ea7ea0 100644 --- a/src/gallium/frontends/lavapipe/lvp_extensions.py +++ b/src/gallium/frontends/lavapipe/lvp_extensions.py @@ -183,4 +183,5 @@ if __name__ == '__main__': dest='xml_files') args = parser.parse_args() - gen_extensions('lvp', args.xml_files, API_VERSIONS, MAX_API_VERSION, EXTENSIONS, args.out_c, args.out_h) + gen_extensions('lvp', args.xml_files, API_VERSIONS, MAX_API_VERSION, + EXTENSIONS, args.out_c, args.out_h, type_prefix='vk') diff --git a/src/gallium/frontends/lavapipe/lvp_private.h b/src/gallium/frontends/lavapipe/lvp_private.h index a73141a473f..9439859ddb2 100644 --- a/src/gallium/frontends/lavapipe/lvp_private.h +++ b/src/gallium/frontends/lavapipe/lvp_private.h @@ -78,14 +78,12 @@ const char *lvp_get_physical_device_entry_name(int index); const char *lvp_get_device_entry_name(int index); bool lvp_instance_entrypoint_is_enabled(int index, uint32_t core_version, - const struct lvp_instance_extension_table *instance); + const struct vk_instance_extension_table *instance); bool lvp_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct lvp_instance_extension_table *instance); + const struct vk_instance_extension_table *instance); bool lvp_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct lvp_instance_extension_table *instance, - const struct lvp_device_extension_table *device); - -void *lvp_lookup_entrypoint(const char *name); + const struct vk_instance_extension_table *instance, + const struct vk_device_extension_table *device); #define LVP_DEFINE_HANDLE_CASTS(__lvp_type, __VkType) \ \ @@ -211,7 +209,6 @@ struct lvp_physical_device { uint32_t max_images; struct wsi_device wsi_device; - struct lvp_device_extension_table supported_extensions; }; struct lvp_instance { @@ -225,17 +222,12 @@ struct lvp_instance { struct pipe_loader_device *devs; int num_devices; - - struct lvp_instance_extension_table enabled_extensions; - struct lvp_instance_dispatch_table dispatch; - struct lvp_physical_device_dispatch_table physical_device_dispatch; - struct lvp_device_dispatch_table device_dispatch; }; VkResult lvp_init_wsi(struct lvp_physical_device *physical_device); void lvp_finish_wsi(struct lvp_physical_device *physical_device); -bool lvp_instance_extension_supported(const char *name); +extern const struct vk_instance_extension_table lvp_instance_extensions_supported; uint32_t lvp_physical_device_api_version(struct lvp_physical_device *dev); bool lvp_physical_device_extension_supported(struct lvp_physical_device *dev, const char *name); @@ -275,8 +267,6 @@ struct lvp_device { struct pipe_screen *pscreen; mtx_t fence_lock; - struct lvp_device_extension_table enabled_extensions; - struct lvp_device_dispatch_table dispatch; }; void lvp_device_get_cache_uuid(void *uuid); diff --git a/src/gallium/frontends/lavapipe/lvp_wsi.c b/src/gallium/frontends/lavapipe/lvp_wsi.c index a58bf0dedaf..661e5466436 100644 --- a/src/gallium/frontends/lavapipe/lvp_wsi.c +++ b/src/gallium/frontends/lavapipe/lvp_wsi.c @@ -26,7 +26,18 @@ static PFN_vkVoidFunction lvp_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName) { - return lvp_lookup_entrypoint(pName); + LVP_FROM_HANDLE(lvp_physical_device, pdevice, physicalDevice); + PFN_vkVoidFunction func; + + func = vk_instance_dispatch_table_get(&pdevice->vk.instance->dispatch_table, pName); + if (func != NULL) + return func; + + func = vk_physical_device_dispatch_table_get(&pdevice->vk.dispatch_table, pName); + if (func != NULL) + return func; + + return vk_device_dispatch_table_get(&vk_device_trampolines, pName); } VkResult diff --git a/src/gallium/frontends/lavapipe/meson.build b/src/gallium/frontends/lavapipe/meson.build index 6cfaff61639..40cd4c6b27d 100644 --- a/src/gallium/frontends/lavapipe/meson.build +++ b/src/gallium/frontends/lavapipe/meson.build @@ -1,13 +1,12 @@ lvp_entrypoints = custom_target( - 'lvp_entrypoints.[ch]', - input : ['lvp_entrypoints_gen.py', vk_api_xml], + 'lvp_entrypoints', + input : [vk_entrypoints_gen, vk_api_xml], output : ['lvp_entrypoints.h', 'lvp_entrypoints.c'], command : [ - prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--outdir', - meson.current_build_dir() + prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--proto', '--weak', + '--out-h', '@OUTPUT0@', '--out-c', '@OUTPUT1@', '--prefix', 'lvp', ], - depend_files : files('lvp_extensions.py'), ) lvp_extensions_c = custom_target(