From d555794f3032594dbef3623052103900138d2356 Mon Sep 17 00:00:00 2001 From: Samuel Pitoiset Date: Mon, 24 Feb 2020 17:24:03 +0100 Subject: [PATCH] radv: update entrypoints generation from ANV It's a massive rework loosely based on ANV. This introduces separate dispatch tables for the instance, physical device and device objects. This will help for implementing internal driver layers for SQTT. Signed-off-by: Samuel Pitoiset Reviewed-by: Bas Nieuwenhuizen Tested-by: Marge Bot Part-of: --- src/amd/vulkan/radv_device.c | 139 ++++++- src/amd/vulkan/radv_entrypoints_gen.py | 546 ++++++++++++++++++------- src/amd/vulkan/radv_private.h | 29 +- src/amd/vulkan/radv_wsi.c | 2 +- 4 files changed, 545 insertions(+), 171 deletions(-) diff --git a/src/amd/vulkan/radv_device.c b/src/amd/vulkan/radv_device.c index 0a5db57e715..aa7b1b06835 100644 --- a/src/amd/vulkan/radv_device.c +++ b/src/amd/vulkan/radv_device.c @@ -708,6 +708,50 @@ VkResult radv_CreateInstance( instance->enabled_extensions.extensions[index] = true; } + bool unchecked = instance->debug_flags & RADV_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 && + !radv_instance_entrypoint_is_enabled(i, instance->apiVersion, + &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 (!unchecked && + !radv_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] = + 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 (!unchecked && + !radv_device_entrypoint_is_enabled(i, instance->apiVersion, + &instance->enabled_extensions, NULL)) { + instance->device_dispatch.entrypoints[i] = NULL; + } else { + instance->device_dispatch.entrypoints[i] = + radv_device_dispatch_table.entrypoints[i]; + } + } + result = vk_debug_report_instance_init(&instance->debug_report_callbacks); if (result != VK_SUCCESS) { vk_free2(&default_alloc, pAllocator, instance); @@ -2795,6 +2839,28 @@ static VkResult fork_secure_compile_idle_device(struct radv_device *device) return VK_SUCCESS; } +static void +radv_device_init_dispatch(struct radv_device *device) +{ + const struct radv_instance *instance = device->physical_device->instance; + bool unchecked = instance->debug_flags & RADV_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 && + !radv_device_entrypoint_is_enabled(i, instance->apiVersion, + &instance->enabled_extensions, + &device->enabled_extensions)) { + device->dispatch.entrypoints[i] = NULL; + } else { + device->dispatch.entrypoints[i] = + radv_device_dispatch_table.entrypoints[i]; + } + } +} + static VkResult radv_create_pthread_cond(pthread_cond_t *cond) { @@ -2867,6 +2933,8 @@ VkResult radv_CreateDevice( device->enabled_extensions.extensions[index] = true; } + radv_device_init_dispatch(device); + keep_shader_info = device->enabled_extensions.AMD_shader_info; /* With update after bind we can't attach bo's to the command buffer @@ -4843,16 +4911,41 @@ PFN_vkVoidFunction radv_GetInstanceProcAddr( const char* pName) { RADV_FROM_HANDLE(radv_instance, instance, _instance); - bool unchecked = instance ? instance->debug_flags & RADV_DEBUG_ALL_ENTRYPOINTS : false; - if (unchecked) { - return radv_lookup_entrypoint_unchecked(pName); - } else { - return radv_lookup_entrypoint_checked(pName, - instance ? instance->apiVersion : 0, - instance ? &instance->enabled_extensions : NULL, - NULL); - } + /* 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_RADV_ENTRYPOINT(entrypoint) \ + if (strcmp(pName, "vk" #entrypoint) == 0) \ + return (PFN_vkVoidFunction)radv_##entrypoint + + LOOKUP_RADV_ENTRYPOINT(EnumerateInstanceExtensionProperties); + LOOKUP_RADV_ENTRYPOINT(EnumerateInstanceLayerProperties); + LOOKUP_RADV_ENTRYPOINT(EnumerateInstanceVersion); + LOOKUP_RADV_ENTRYPOINT(CreateInstance); + +#undef LOOKUP_RADV_ENTRYPOINT + + 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; } /* The loader wants us to expose a second GetInstanceProcAddr function @@ -4883,9 +4976,14 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr( { RADV_FROM_HANDLE(radv_instance, instance, _instance); - return radv_lookup_physical_device_entrypoint_checked(pName, - instance ? instance->apiVersion : 0, - instance ? &instance->enabled_extensions : NULL); + 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( @@ -4893,16 +4991,15 @@ PFN_vkVoidFunction radv_GetDeviceProcAddr( const char* pName) { RADV_FROM_HANDLE(radv_device, device, _device); - bool unchecked = device ? device->instance->debug_flags & RADV_DEBUG_ALL_ENTRYPOINTS : false; - if (unchecked) { - return radv_lookup_entrypoint_unchecked(pName); - } else { - return radv_lookup_entrypoint_checked(pName, - device->instance->apiVersion, - &device->instance->enabled_extensions, - &device->enabled_extensions); - } + if (!device || !pName) + return NULL; + + int idx = radv_get_device_entrypoint_index(pName); + if (idx < 0) + return NULL; + + return device->dispatch.entrypoints[idx]; } 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 index b64f2d93e8a..b964a379338 100644 --- a/src/amd/vulkan/radv_entrypoints_gen.py +++ b/src/amd/vulkan/radv_entrypoints_gen.py @@ -47,11 +47,11 @@ LAYERS = [ TEMPLATE_H = Template("""\ /* This file generated from ${filename}, don't edit directly. */ -struct radv_dispatch_table { +struct radv_instance_dispatch_table { union { - void *entrypoints[${len(entrypoints)}]; + void *entrypoints[${len(instance_entrypoints)}]; struct { - % for e in entrypoints: + % for e in instance_entrypoints: % if e.guard is not None: #ifdef ${e.guard} PFN_${e.name} ${e.name}; @@ -66,7 +66,66 @@ struct radv_dispatch_table { }; }; -% for e in entrypoints: +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 @@ -80,6 +139,21 @@ struct radv_dispatch_table { #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"""\ @@ -110,24 +184,27 @@ TEMPLATE_C = Template(u"""\ #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 relocations from the entry +/* 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. */ -static const char strings[] = +<%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 string_map_entries[] = { +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 @@ -142,33 +219,146 @@ static const struct string_map_entry string_map_entries[] = { */ #define none 0xffff -static const uint16_t string_map[${strmap.hash_size}] = { +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('radv')}(${e.decl_params()}) __attribute__ ((weak)); + % 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 + ${e.return_type} ${e.prefixed_name('radv')}(${e.decl_params()}) __attribute__ ((weak)); + % 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 entrypoints: - % if e.alias: + % for e in 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(layer)}(${e.decl_params()}) __attribute__ ((weak)); + % if layer == 'radv': + ${e.return_type} __attribute__ ((weak)) + ${e.prefixed_name('radv')}(${e.decl_params()}) + { + % if e.params[0].type == 'VkDevice': + RADV_FROM_HANDLE(radv_device, radv_device, ${e.params[0].name}); + 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}); + 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}); + return radv_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 radv_dispatch_table ${layer}_layer = { - % for e in entrypoints: + 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 @@ -180,46 +370,34 @@ static const uint16_t string_map[${strmap.hash_size}] = { }; % endfor -static void * __attribute__ ((noinline)) -radv_resolve_entrypoint(uint32_t index) -{ - return radv_layer.entrypoints[index]; -} /** Return true if the core version or extension in which the given entrypoint * is defined is enabled. * - * If instance is NULL, we only allow the 3 commands explicitly allowed by the vk - * spec. - * * If device is NULL, all device extensions are considered enabled. */ -static bool -radv_entrypoint_is_enabled(int index, uint32_t core_version, - const struct radv_instance_extension_table *instance, - const struct radv_device_extension_table *device) +bool +radv_instance_entrypoint_is_enabled(int index, uint32_t core_version, + const struct radv_instance_extension_table *instance) { switch (index) { -% for e in entrypoints: +% for e in instance_entrypoints: case ${e.num}: - % if not e.device_command: - if (device) return false; - % endif - % if e.name == 'vkCreateInstance' or e.name == 'vkEnumerateInstanceExtensionProperties' or e.name == 'vkEnumerateInstanceLayerProperties' or e.name == 'vkEnumerateInstanceVersion': - return !device; - % elif e.core_version: - return instance && ${e.core_version.c_vk_version()} <= core_version; + /* ${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 && instance->${ext.name[3:]}) return true; - % else: - if (instance && (!device || device->${ext.name[3:]})) return true; - % endif - %endfor + % 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 instance; + return true; % endif % endfor default: @@ -227,96 +405,133 @@ radv_entrypoint_is_enabled(int index, uint32_t core_version, } } -static bool -radv_entrypoint_is_enabled_physical_device(int index, uint32_t core_version, - const struct radv_instance_extension_table *instance) +/** 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 entrypoints: - %if e.physical_device_command: +% for e in physical_device_entrypoints: case ${e.num}: + /* ${e.name} */ % if e.core_version: - return instance && ${e.core_version.c_vk_version()} <= 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 && instance->${ext.name[3:]}) return true; - % else: + % 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 + % endif + % endfor return false; % else: - return instance; + return true; % endif - %endif % endfor default: return false; } } -static int -radv_lookup_entrypoint(const char *name) +/** 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) { - 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 = name; *p; p++) - hash = hash * prime_factor + *p; - - h = hash; - while (1) { - i = string_map[h & ${strmap.hash_mask}]; - if (i == none) - return -1; - e = &string_map_entries[i]; - if (e->hash == hash && strcmp(name, strings + e->name) == 0) - return e->num; - h += prime_step; + 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; } +} - return -1; +int +radv_get_instance_entrypoint_index(const char *name) +{ + return instance_string_map_lookup(name); } -void * -radv_lookup_entrypoint_unchecked(const char *name) +int +radv_get_physical_device_entrypoint_index(const char *name) { - int index = radv_lookup_entrypoint(name); - if (index < 0) - return NULL; - return radv_resolve_entrypoint(index); + return physical_device_string_map_lookup(name); } -void * -radv_lookup_entrypoint_checked(const char *name, - uint32_t core_version, - const struct radv_instance_extension_table *instance, - const struct radv_device_extension_table *device) +int +radv_get_device_entrypoint_index(const char *name) { - int index = radv_lookup_entrypoint(name); - if (index < 0 || !radv_entrypoint_is_enabled(index, core_version, instance, device)) - return NULL; - return radv_resolve_entrypoint(index); + return device_string_map_lookup(name); } -void * -radv_lookup_physical_device_entrypoint_checked(const char *name, - uint32_t core_version, - const struct radv_instance_extension_table *instance) +const char * +radv_get_instance_entry_name(int index) { - int index = radv_lookup_entrypoint(name); - if (index < 0 || !radv_entrypoint_is_enabled_physical_device(index, core_version, instance)) - return NULL; - return radv_resolve_entrypoint(index); + return instance_entry_name(index); } -""", output_encoding='utf-8') +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); +} + +static void * __attribute__ ((noinline)) +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 @@ -388,18 +603,22 @@ class EntrypointBase(object): 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 - self.device_command = len(params) > 0 and (params[0].type == 'VkDevice' or params[0].type == 'VkQueue' or params[0].type == 'VkCommandBuffer') - self.physical_device_command = len(params) > 0 and params[0].type == 'VkPhysicalDevice' - def prefixed_name(self, prefix): - assert self.name.startswith('vk') - return prefix + '_' + self.name[2:] + 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) @@ -411,13 +630,33 @@ class EntrypointAlias(EntrypointBase): def __init__(self, name, entrypoint): super(EntrypointAlias, self).__init__(name) self.alias = entrypoint - self.device_command = entrypoint.device_command - self.physical_device_command = entrypoint.physical_device_command + + 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): - return self.alias.prefixed_name(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, start_index): +def get_entrypoints(doc, entrypoints_to_defines): """Extract the entry points from the registry.""" entrypoints = OrderedDict() @@ -481,13 +720,6 @@ def get_entrypoints_defines(doc): """Maps entry points to extension defines.""" entrypoints_to_defines = {} - for extension in doc.findall('./extensions/extension[@protect]'): - define = extension.attrib['protect'] - - for entrypoint in extension.findall('./require/command'): - fullname = entrypoint.attrib['name'] - entrypoints_to_defines[fullname] = define - platform_define = {} for platform in doc.findall('./platforms/platform'): name = platform.attrib['name'] @@ -504,20 +736,6 @@ def get_entrypoints_defines(doc): return entrypoints_to_defines - -def gen_code(entrypoints): - """Generate the C code.""" - strmap = StringIntMap() - for e in entrypoints: - strmap.add_string(e.name, e.num) - strmap.bake() - - return TEMPLATE_C.render(entrypoints=entrypoints, - LAYERS=LAYERS, - strmap=strmap, - filename=os.path.basename(__file__)) - - def main(): parser = argparse.ArgumentParser() parser.add_argument('--outdir', help='Where to write the files.', @@ -533,20 +751,66 @@ def main(): for filename in args.xml_files: doc = et.parse(filename) - entrypoints += get_entrypoints(doc, get_entrypoints_defines(doc), - start_index=len(entrypoints)) + 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() - for num, e in enumerate(entrypoints): + 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. - with open(os.path.join(args.outdir, 'radv_entrypoints.h'), 'wb') as f: - f.write(TEMPLATE_H.render(entrypoints=entrypoints, - LAYERS=LAYERS, - filename=os.path.basename(__file__))) - with open(os.path.join(args.outdir, 'radv_entrypoints.c'), 'wb') as f: - f.write(gen_code(entrypoints)) + 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__': diff --git a/src/amd/vulkan/radv_private.h b/src/amd/vulkan/radv_private.h index f9efa5b0a81..a9e711a0b51 100644 --- a/src/amd/vulkan/radv_private.h +++ b/src/amd/vulkan/radv_private.h @@ -285,14 +285,23 @@ void radv_logi_v(const char *format, va_list va); return; \ } while (0) -void *radv_lookup_entrypoint_unchecked(const char *name); -void *radv_lookup_entrypoint_checked(const char *name, - uint32_t core_version, - const struct radv_instance_extension_table *instance, - const struct radv_device_extension_table *device); -void *radv_lookup_physical_device_entrypoint_checked(const char *name, - uint32_t core_version, - const struct radv_instance_extension_table *instance); +int radv_get_instance_entrypoint_index(const char *name); +int radv_get_device_entrypoint_index(const char *name); +int radv_get_physical_device_entrypoint_index(const char *name); + +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 { VK_LOADER_DATA _loader_data; @@ -364,6 +373,9 @@ 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; struct driOptionCache dri_options; struct driOptionCache available_dri_options; @@ -835,6 +847,7 @@ struct radv_device { uint64_t dmesg_timestamp; struct radv_device_extension_table enabled_extensions; + struct radv_device_dispatch_table dispatch; /* Whether the app has enabled the robustBufferAccess feature. */ bool robust_buffer_access; diff --git a/src/amd/vulkan/radv_wsi.c b/src/amd/vulkan/radv_wsi.c index 2da2049feb4..66a8d002f85 100644 --- a/src/amd/vulkan/radv_wsi.c +++ b/src/amd/vulkan/radv_wsi.c @@ -32,7 +32,7 @@ static PFN_vkVoidFunction radv_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName) { - return radv_lookup_entrypoint_unchecked(pName); + return radv_lookup_entrypoint(pName); } VkResult -- 2.30.2