diff --git a/src/amd/vulkan/meson.build b/src/amd/vulkan/meson.build index 67ebd0321db..8d3646ad49c 100644 --- a/src/amd/vulkan/meson.build +++ b/src/amd/vulkan/meson.build @@ -19,14 +19,14 @@ # SOFTWARE. radv_entrypoints = custom_target( - 'radv_entrypoints.[ch]', - input : ['radv_entrypoints_gen.py', vk_api_xml], + 'radv_entrypoints', + input : [vk_entrypoints_gen, vk_api_xml], output : ['radv_entrypoints.h', 'radv_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', 'radv', + '--device-prefix', 'sqtt', ], - depend_files : files('radv_extensions.py'), ) radv_extensions_c = custom_target( diff --git a/src/amd/vulkan/radv_device.c b/src/amd/vulkan/radv_device.c index df38aeff197..41f64e400fc 100644 --- a/src/amd/vulkan/radv_device.c +++ b/src/amd/vulkan/radv_device.c @@ -347,8 +347,12 @@ radv_physical_device_try_create(struct radv_instance *instance, goto fail_fd; } + struct vk_physical_device_dispatch_table dispatch_table; + vk_physical_device_dispatch_table_from_entrypoints( + &dispatch_table, &radv_physical_device_entrypoints, true); + result = vk_physical_device_init(&device->vk, &instance->vk, NULL, - NULL); + &dispatch_table); if (result != VK_SUCCESS) { goto fail_alloc; } @@ -373,7 +377,7 @@ radv_physical_device_try_create(struct radv_instance *instance, } #ifndef _WIN32 - if (drm_device && instance->enabled_extensions.KHR_display) { + if (drm_device && instance->vk.enabled_extensions.KHR_display) { master_fd = open(drm_device->nodes[DRM_NODE_PRIMARY], O_RDWR | O_CLOEXEC); if (master_fd >= 0) { uint32_t accel_working = 0; @@ -458,7 +462,7 @@ radv_physical_device_try_create(struct radv_instance *instance, radv_physical_device_init_mem_types(device); radv_physical_device_get_supported_extensions(device, - &device->supported_extensions); + &device->vk.supported_extensions); #ifndef _WIN32 if (drm_device) @@ -709,8 +713,12 @@ VkResult radv_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, &radv_instance_entrypoints, true); result = vk_instance_init(&instance->vk, - NULL, NULL, + &radv_instance_extensions_supported, + &dispatch_table, pCreateInfo, pAllocator); if (result != VK_SUCCESS) { vk_free(pAllocator, instance); @@ -744,63 +752,6 @@ VkResult radv_CreateInstance( if (instance->debug_flags & RADV_DEBUG_STARTUP) radv_logi("Created an instance"); - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - int idx; - for (idx = 0; idx < RADV_INSTANCE_EXTENSION_COUNT; idx++) { - if (!strcmp(pCreateInfo->ppEnabledExtensionNames[i], - radv_instance_extensions[idx].extensionName)) - break; - } - - if (idx >= RADV_INSTANCE_EXTENSION_COUNT || - !radv_instance_extensions_supported.extensions[idx]) { - vk_instance_finish(&instance->vk); - vk_free2(&default_alloc, pAllocator, instance); - return vk_error(instance, VK_ERROR_EXTENSION_NOT_PRESENT); - } - - instance->enabled_extensions.extensions[idx] = true; - } - - 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 (!radv_instance_entrypoint_is_enabled(i, instance->vk.app_info.api_version, - &instance->enabled_extensions)) { - instance->dispatch.entrypoints[i] = NULL; - } else { - instance->dispatch.entrypoints[i] = - radv_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 (!radv_physical_device_entrypoint_is_enabled(i, instance->vk.app_info.api_version, - &instance->enabled_extensions)) { - instance->physical_device_dispatch.entrypoints[i] = NULL; - } else { - instance->physical_device_dispatch.entrypoints[i] = - radv_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 (!radv_device_entrypoint_is_enabled(i, instance->vk.app_info.api_version, - &instance->enabled_extensions, NULL)) { - instance->device_dispatch.entrypoints[i] = NULL; - } else { - instance->device_dispatch.entrypoints[i] = - radv_device_dispatch_table.entrypoints[i]; - } - } - instance->physical_devices_enumerated = false; list_inithead(&instance->physical_devices); @@ -2574,15 +2525,6 @@ radv_device_init_gs_info(struct radv_device *device) device->physical_device->rad_info.family); } -static int radv_get_device_extension_index(const char *name) -{ - for (unsigned i = 0; i < RADV_DEVICE_EXTENSION_COUNT; ++i) { - if (strcmp(name, radv_device_extensions[i].extensionName) == 0) - return i; - } - return -1; -} - static int radv_get_int_debug_option(const char *name, int default_value) { @@ -2611,36 +2553,6 @@ static bool radv_thread_trace_enabled() getenv("RADV_THREAD_TRACE_TRIGGER"); } -static void -radv_device_init_dispatch(struct radv_device *device) -{ - const struct radv_instance *instance = device->physical_device->instance; - const struct radv_device_dispatch_table *dispatch_table_layer = NULL; - - if (radv_thread_trace_enabled()) { - /* Use device entrypoints from the SQTT layer if enabled. */ - dispatch_table_layer = &sqtt_device_dispatch_table; - } - - 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 (!radv_device_entrypoint_is_enabled(i, instance->vk.app_info.api_version, - &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] = - radv_device_dispatch_table.entrypoints[i]; - } - } -} - static VkResult check_physical_device_features(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceFeatures *features) @@ -2787,7 +2699,19 @@ VkResult radv_CreateDevice( if (!device) return vk_error(physical_device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); - result = vk_device_init(&device->vk, NULL, NULL, pCreateInfo, + struct vk_device_dispatch_table dispatch_table; + + if (radv_thread_trace_enabled()) { + vk_device_dispatch_table_from_entrypoints(&dispatch_table, + &sqtt_device_entrypoints, true); + vk_device_dispatch_table_from_entrypoints(&dispatch_table, + &radv_device_entrypoints, false); + } else { + vk_device_dispatch_table_from_entrypoints(&dispatch_table, + &radv_device_entrypoints, true); + } + + result = vk_device_init(&device->vk, &physical_device->vk, &dispatch_table, pCreateInfo, &physical_device->instance->vk.alloc, pAllocator); if (result != VK_SUCCESS) { vk_free(&device->vk.alloc, device); @@ -2799,36 +2723,22 @@ VkResult radv_CreateDevice( device->ws = physical_device->ws; - for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { - const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i]; - int index = radv_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(physical_device->instance, VK_ERROR_EXTENSION_NOT_PRESENT); - } - - device->enabled_extensions.extensions[index] = true; - } - - radv_device_init_dispatch(device); - - keep_shader_info = device->enabled_extensions.AMD_shader_info; + keep_shader_info = device->vk.enabled_extensions.AMD_shader_info; /* With update after bind we can't attach bo's to the command buffer * from the descriptor set anymore, so we have to use a global BO list. */ device->use_global_bo_list = (device->instance->perftest_flags & RADV_PERFTEST_BO_LIST) || - device->enabled_extensions.EXT_descriptor_indexing || - device->enabled_extensions.EXT_buffer_device_address || - device->enabled_extensions.KHR_buffer_device_address; + device->vk.enabled_extensions.EXT_descriptor_indexing || + device->vk.enabled_extensions.EXT_buffer_device_address || + device->vk.enabled_extensions.KHR_buffer_device_address; device->robust_buffer_access = robust_buffer_access || robust_buffer_access2; device->robust_buffer_access2 = robust_buffer_access2; device->adjust_frag_coord_z = (vrs_enabled || - device->enabled_extensions.KHR_fragment_shading_rate) && + device->vk.enabled_extensions.KHR_fragment_shading_rate) && (device->physical_device->rad_info.family == CHIP_SIENNA_CICHLID || device->physical_device->rad_info.family == CHIP_NAVY_FLOUNDER || device->physical_device->rad_info.family == CHIP_VANGOGH); @@ -5203,31 +5113,10 @@ VkResult radv_EnumerateInstanceExtensionProperties( VK_OUTARRAY_MAKE_TYPED(VkExtensionProperties, out, pProperties, pPropertyCount); - for (int i = 0; i < RADV_INSTANCE_EXTENSION_COUNT; i++) { + for (int i = 0; i < VK_INSTANCE_EXTENSION_COUNT; i++) { if (radv_instance_extensions_supported.extensions[i]) { vk_outarray_append_typed(VkExtensionProperties, &out, prop) { - *prop = radv_instance_extensions[i]; - } - } - } - - return vk_outarray_status(&out); -} - -VkResult radv_EnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) -{ - RADV_FROM_HANDLE(radv_physical_device, device, physicalDevice); - VK_OUTARRAY_MAKE_TYPED(VkExtensionProperties, out, pProperties, - pPropertyCount); - - for (int i = 0; i < RADV_DEVICE_EXTENSION_COUNT; i++) { - if (device->supported_extensions.extensions[i]) { - vk_outarray_append_typed(VkExtensionProperties, &out, prop) { - *prop = radv_device_extensions[i]; + *prop = vk_instance_extensions[i]; } } } @@ -5267,19 +5156,9 @@ PFN_vkVoidFunction radv_GetInstanceProcAddr( if (instance == NULL) return NULL; - int idx = radv_get_instance_entrypoint_index(pName); - if (idx >= 0) - return instance->dispatch.entrypoints[idx]; - - idx = radv_get_physical_device_entrypoint_index(pName); - if (idx >= 0) - return instance->physical_device_dispatch.entrypoints[idx]; - - idx = radv_get_device_entrypoint_index(pName); - if (idx >= 0) - return instance->device_dispatch.entrypoints[idx]; - - return NULL; + return vk_instance_get_proc_addr(&instance->vk, + &radv_instance_entrypoints, + pName); } /* The loader wants us to expose a second GetInstanceProcAddr function @@ -5299,31 +5178,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr( const char* pName) { RADV_FROM_HANDLE(radv_instance, instance, _instance); - - if (!pName || !instance) - return NULL; - - int idx = radv_get_physical_device_entrypoint_index(pName); - if (idx < 0) - return NULL; - - return instance->physical_device_dispatch.entrypoints[idx]; -} - -PFN_vkVoidFunction radv_GetDeviceProcAddr( - VkDevice _device, - const char* pName) -{ - RADV_FROM_HANDLE(radv_device, device, _device); - - if (!device || !pName) - return NULL; - - int idx = radv_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); } bool radv_get_memory_fd(struct radv_device *device, diff --git a/src/amd/vulkan/radv_entrypoints_gen.py b/src/amd/vulkan/radv_entrypoints_gen.py deleted file mode 100644 index 6a3b3959a30..00000000000 --- a/src/amd/vulkan/radv_entrypoints_gen.py +++ /dev/null @@ -1,847 +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 radv_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. - -LAYERS = [ - 'radv', - 'sqtt' -] - -TEMPLATE_H = Template("""\ -/* This file generated from ${filename}, don't edit directly. */ - -struct radv_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 radv_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 radv_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 radv_instance_dispatch_table radv_instance_dispatch_table; -%for layer in LAYERS: -extern const struct radv_physical_device_dispatch_table ${layer}_physical_device_dispatch_table; -%endfor -%for layer in LAYERS: -extern const struct radv_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('radv')}(${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 "radv_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 reloctions 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 -#ifdef _MSC_VER - #pragma comment(linker, "/alternatename:${e.prefixed_name('radv')}_Weak=${e.prefixed_name('radv')}_Null") - #pragma comment(linker, "/alternatename:${e.prefixed_name('radv')}=${e.prefixed_name('radv')}_Weak") - ${e.return_type} (*${e.prefixed_name('radv')}_Null)(${e.decl_params()}) = 0; - ${e.return_type} ${e.prefixed_name('radv')}_Weak(${e.decl_params()}); -#else - ${e.return_type} ${e.prefixed_name('radv')}(${e.decl_params()}) __attribute__ ((weak)); -#endif - % if e.guard is not None: -#endif // ${e.guard} - % endif -% endfor - -const struct radv_instance_dispatch_table radv_instance_dispatch_table = { -% for e in instance_entrypoints: - % if e.guard is not None: -#ifdef ${e.guard} - % endif - .${e.name} = ${e.prefixed_name('radv')}, - % 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 -#ifdef _MSC_VER - #pragma comment(linker, "/alternatename:${e.prefixed_name('radv')}_Weak=${e.prefixed_name('radv')}_Null") - #pragma comment(linker, "/alternatename:${e.prefixed_name('radv')}=${e.prefixed_name('radv')}_Weak") - ${e.return_type} (*${e.prefixed_name('radv')}_Null)(${e.decl_params()}) = 0; - ${e.return_type} ${e.prefixed_name('radv')}_Weak(${e.decl_params()}); -#else - ${e.return_type} ${e.prefixed_name('radv')}(${e.decl_params()}) __attribute__ ((weak)); -#endif - % if e.guard is not None: -#endif // ${e.guard} - % endif -% endfor - -const struct radv_physical_device_dispatch_table radv_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('radv')}, - % 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 == 'radv': -#ifdef _MSC_VER - #pragma comment(linker, "/alternatename:${e.prefixed_name('radv')}=${e.prefixed_name('radv')}_Weak") - ${e.return_type} - ${e.prefixed_name('radv')}_Weak(${e.decl_params()}) -#else - ${e.return_type} __attribute__ ((weak)) - ${e.prefixed_name('radv')}(${e.decl_params()}) -#endif - { - % if e.params[0].type == 'VkDevice': - RADV_FROM_HANDLE(radv_device, radv_device, ${e.params[0].name}); - ${'' if e.return_type == 'void' else 'return '}radv_device->dispatch.${e.name}(${e.call_params()}); - % elif e.params[0].type == 'VkCommandBuffer': - RADV_FROM_HANDLE(radv_cmd_buffer, radv_cmd_buffer, ${e.params[0].name}); - ${'' if e.return_type == 'void' else 'return '}radv_cmd_buffer->device->dispatch.${e.name}(${e.call_params()}); - % elif e.params[0].type == 'VkQueue': - RADV_FROM_HANDLE(radv_queue, radv_queue, ${e.params[0].name}); - ${'' if e.return_type == 'void' else 'return '}radv_queue->device->dispatch.${e.name}(${e.call_params()}); - % else: - assert(!"Unhandled device child trampoline case: ${e.params[0].type}"); - % endif - } - % else: -#ifdef _MSC_VER - #pragma comment(linker, "/alternatename:${e.prefixed_name(layer)}_Weak=${e.prefixed_name(layer)}_Null") - #pragma comment(linker, "/alternatename:${e.prefixed_name(layer)}=${e.prefixed_name(layer)}_Weak") - ${e.return_type} (*${e.prefixed_name(layer)}_Null)(${e.decl_params()}) = 0; - ${e.return_type} ${e.prefixed_name(layer)}_Weak(${e.decl_params()}); -#else - ${e.return_type} ${e.prefixed_name(layer)}(${e.decl_params()}) __attribute__ ((weak)); -#endif - % endif - % if e.guard is not None: -#endif // ${e.guard} - % endif - % endfor - - const struct radv_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 -radv_instance_entrypoint_is_enabled(int index, uint32_t core_version, - const struct radv_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 -radv_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct radv_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 -radv_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct radv_instance_extension_table *instance, - const struct radv_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 -radv_get_instance_entrypoint_index(const char *name) -{ - return instance_string_map_lookup(name); -} - -int -radv_get_physical_device_entrypoint_index(const char *name) -{ - return physical_device_string_map_lookup(name); -} - -int -radv_get_device_entrypoint_index(const char *name) -{ - return device_string_map_lookup(name); -} - -const char * -radv_get_instance_entry_name(int index) -{ - return instance_entry_name(index); -} - -const char * -radv_get_physical_device_entry_name(int index) -{ - return physical_device_entry_name(index); -} - -const char * -radv_get_device_entry_name(int index) -{ - return device_entry_name(index); -} - -#ifdef _MSC_VER -__declspec(noinline) static void * -#else -static void * __attribute__ ((noinline)) -#endif -radv_resolve_device_entrypoint(uint32_t index) -{ - return radv_device_dispatch_table.entrypoints[index]; -} - -void * -radv_lookup_entrypoint(const char *name) -{ - int idx = radv_get_instance_entrypoint_index(name); - if (idx >= 0) - return radv_instance_dispatch_table.entrypoints[idx]; - - idx = radv_get_physical_device_entrypoint_index(name); - if (idx >= 0) - return radv_physical_device_dispatch_table.entrypoints[idx]; - - idx = radv_get_device_entrypoint_index(name); - if (idx >= 0) - return radv_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 radv_EntryPoint() prototype - # per entry point. - try: - with open(os.path.join(args.outdir, 'radv_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, 'radv_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/amd/vulkan/radv_extensions.py b/src/amd/vulkan/radv_extensions.py index ddc92784f25..2159123ff0b 100644 --- a/src/amd/vulkan/radv_extensions.py +++ b/src/amd/vulkan/radv_extensions.py @@ -233,4 +233,5 @@ if __name__ == '__main__': dest='xml_files') args = parser.parse_args() - gen_extensions('radv', args.xml_files, API_VERSIONS, MAX_API_VERSION, EXTENSIONS, args.out_c, args.out_h) + gen_extensions('radv', args.xml_files, API_VERSIONS, MAX_API_VERSION, + EXTENSIONS, args.out_c, args.out_h, type_prefix='vk') diff --git a/src/amd/vulkan/radv_formats.c b/src/amd/vulkan/radv_formats.c index 9ad2033a7b5..25d147adfe3 100644 --- a/src/amd/vulkan/radv_formats.c +++ b/src/amd/vulkan/radv_formats.c @@ -1375,7 +1375,7 @@ get_external_image_format_properties(struct radv_physical_device *physical_devic } break; case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID: - if (!physical_device->supported_extensions.ANDROID_external_memory_android_hardware_buffer) + if (!physical_device->vk.supported_extensions.ANDROID_external_memory_android_hardware_buffer) break; if (!radv_android_gralloc_supports_format(pImageFormatInfo->format, @@ -1460,7 +1460,7 @@ VkResult radv_GetPhysicalDeviceImageFormatProperties2( } } - bool ahb_supported = physical_device->supported_extensions.ANDROID_external_memory_android_hardware_buffer; + bool ahb_supported = physical_device->vk.supported_extensions.ANDROID_external_memory_android_hardware_buffer; if (android_usage && ahb_supported) { #if RADV_SUPPORT_ANDROID_HARDWARE_BUFFER android_usage->androidHardwareBufferUsage = diff --git a/src/amd/vulkan/radv_meta_clear.c b/src/amd/vulkan/radv_meta_clear.c index 5c221479a28..7401666a78f 100644 --- a/src/amd/vulkan/radv_meta_clear.c +++ b/src/amd/vulkan/radv_meta_clear.c @@ -722,7 +722,7 @@ pick_depthstencil_pipeline(struct radv_cmd_buffer *cmd_buffer, { bool fast = depth_view_can_fast_clear(cmd_buffer, iview, aspects, layout, in_render_loop, clear_rect, clear_value); - bool unrestricted = cmd_buffer->device->enabled_extensions.EXT_depth_range_unrestricted; + bool unrestricted = cmd_buffer->device->vk.enabled_extensions.EXT_depth_range_unrestricted; int index = DEPTH_CLEAR_SLOW; VkPipeline *pipeline; @@ -807,7 +807,7 @@ emit_depthstencil_clear(struct radv_cmd_buffer *cmd_buffer, if (!(aspects & VK_IMAGE_ASPECT_DEPTH_BIT)) clear_value.depth = 1.0f; - if (cmd_buffer->device->enabled_extensions.EXT_depth_range_unrestricted) { + if (cmd_buffer->device->vk.enabled_extensions.EXT_depth_range_unrestricted) { radv_CmdPushConstants(radv_cmd_buffer_to_handle(cmd_buffer), device->meta_state.clear_depth_unrestricted_p_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, 4, diff --git a/src/amd/vulkan/radv_private.h b/src/amd/vulkan/radv_private.h index c29780ad110..7d852b418b1 100644 --- a/src/amd/vulkan/radv_private.h +++ b/src/amd/vulkan/radv_private.h @@ -262,16 +262,6 @@ const char *radv_get_instance_entry_name(int index); const char *radv_get_physical_device_entry_name(int index); const char *radv_get_device_entry_name(int index); -bool radv_instance_entrypoint_is_enabled(int index, uint32_t core_version, - const struct radv_instance_extension_table *instance); -bool radv_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct radv_instance_extension_table *instance); -bool radv_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct radv_instance_extension_table *instance, - const struct radv_device_extension_table *device); - -void *radv_lookup_entrypoint(const char *name); - struct radv_physical_device { struct vk_physical_device vk; @@ -323,8 +313,6 @@ struct radv_physical_device { #ifndef _WIN32 drmPciBusInfo bus_info; #endif - - struct radv_device_extension_table supported_extensions; }; struct radv_instance { @@ -337,11 +325,6 @@ struct radv_instance { struct vk_debug_report_instance debug_report_callbacks; - struct radv_instance_extension_table enabled_extensions; - struct radv_instance_dispatch_table dispatch; - struct radv_physical_device_dispatch_table physical_device_dispatch; - struct radv_device_dispatch_table device_dispatch; - bool physical_devices_enumerated; struct list_head physical_devices; @@ -357,11 +340,7 @@ struct radv_instance { VkResult radv_init_wsi(struct radv_physical_device *physical_device); void radv_finish_wsi(struct radv_physical_device *physical_device); - -bool radv_instance_extension_supported(const char *name); uint32_t radv_physical_device_api_version(struct radv_physical_device *dev); -bool radv_physical_device_extension_supported(struct radv_physical_device *dev, - const char *name); struct cache_entry; @@ -815,9 +794,6 @@ struct radv_device { /* For detecting VM faults reported by dmesg. */ uint64_t dmesg_timestamp; - struct radv_device_extension_table enabled_extensions; - struct radv_device_dispatch_table dispatch; - /* Whether the app has enabled the robustBufferAccess/robustBufferAccess2 features. */ bool robust_buffer_access; bool robust_buffer_access2; diff --git a/src/amd/vulkan/radv_wsi.c b/src/amd/vulkan/radv_wsi.c index 39714dea5ba..c4f592cca35 100644 --- a/src/amd/vulkan/radv_wsi.c +++ b/src/amd/vulkan/radv_wsi.c @@ -32,7 +32,8 @@ static PFN_vkVoidFunction radv_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName) { - return radv_lookup_entrypoint(pName); + RADV_FROM_HANDLE(radv_physical_device, pdevice, physicalDevice); + return vk_instance_get_proc_addr_unchecked(&pdevice->instance->vk, pName); } static void