radv: port to using common dispatch code.
I think this has the SQTT layer hooked in correctly, would be good if somebody could confirm this. Reviewed-by: Jason Ekstrand <jason@jlekstrand.net> Reviewed-by: Samuel Pitoiset <samuel.pitoiset@gmail.com> Reviewed-by: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl> Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/8676>
This commit is contained in:
parent
7d16621281
commit
23f8ca0c9d
|
@ -19,14 +19,14 @@
|
||||||
# SOFTWARE.
|
# SOFTWARE.
|
||||||
|
|
||||||
radv_entrypoints = custom_target(
|
radv_entrypoints = custom_target(
|
||||||
'radv_entrypoints.[ch]',
|
'radv_entrypoints',
|
||||||
input : ['radv_entrypoints_gen.py', vk_api_xml],
|
input : [vk_entrypoints_gen, vk_api_xml],
|
||||||
output : ['radv_entrypoints.h', 'radv_entrypoints.c'],
|
output : ['radv_entrypoints.h', 'radv_entrypoints.c'],
|
||||||
command : [
|
command : [
|
||||||
prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--outdir',
|
prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--proto', '--weak',
|
||||||
meson.current_build_dir()
|
'--out-h', '@OUTPUT0@', '--out-c', '@OUTPUT1@', '--prefix', 'radv',
|
||||||
|
'--device-prefix', 'sqtt',
|
||||||
],
|
],
|
||||||
depend_files : files('radv_extensions.py'),
|
|
||||||
)
|
)
|
||||||
|
|
||||||
radv_extensions_c = custom_target(
|
radv_extensions_c = custom_target(
|
||||||
|
|
|
@ -347,8 +347,12 @@ radv_physical_device_try_create(struct radv_instance *instance,
|
||||||
goto fail_fd;
|
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,
|
result = vk_physical_device_init(&device->vk, &instance->vk, NULL,
|
||||||
NULL);
|
&dispatch_table);
|
||||||
if (result != VK_SUCCESS) {
|
if (result != VK_SUCCESS) {
|
||||||
goto fail_alloc;
|
goto fail_alloc;
|
||||||
}
|
}
|
||||||
|
@ -373,7 +377,7 @@ radv_physical_device_try_create(struct radv_instance *instance,
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifndef _WIN32
|
#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);
|
master_fd = open(drm_device->nodes[DRM_NODE_PRIMARY], O_RDWR | O_CLOEXEC);
|
||||||
if (master_fd >= 0) {
|
if (master_fd >= 0) {
|
||||||
uint32_t accel_working = 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_init_mem_types(device);
|
||||||
|
|
||||||
radv_physical_device_get_supported_extensions(device,
|
radv_physical_device_get_supported_extensions(device,
|
||||||
&device->supported_extensions);
|
&device->vk.supported_extensions);
|
||||||
|
|
||||||
#ifndef _WIN32
|
#ifndef _WIN32
|
||||||
if (drm_device)
|
if (drm_device)
|
||||||
|
@ -709,8 +713,12 @@ VkResult radv_CreateInstance(
|
||||||
if (!instance)
|
if (!instance)
|
||||||
return vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
|
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,
|
result = vk_instance_init(&instance->vk,
|
||||||
NULL, NULL,
|
&radv_instance_extensions_supported,
|
||||||
|
&dispatch_table,
|
||||||
pCreateInfo, pAllocator);
|
pCreateInfo, pAllocator);
|
||||||
if (result != VK_SUCCESS) {
|
if (result != VK_SUCCESS) {
|
||||||
vk_free(pAllocator, instance);
|
vk_free(pAllocator, instance);
|
||||||
|
@ -744,63 +752,6 @@ VkResult radv_CreateInstance(
|
||||||
if (instance->debug_flags & RADV_DEBUG_STARTUP)
|
if (instance->debug_flags & RADV_DEBUG_STARTUP)
|
||||||
radv_logi("Created an instance");
|
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;
|
instance->physical_devices_enumerated = false;
|
||||||
list_inithead(&instance->physical_devices);
|
list_inithead(&instance->physical_devices);
|
||||||
|
|
||||||
|
@ -2574,15 +2525,6 @@ radv_device_init_gs_info(struct radv_device *device)
|
||||||
device->physical_device->rad_info.family);
|
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
|
static int
|
||||||
radv_get_int_debug_option(const char *name, int default_value)
|
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");
|
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
|
static VkResult
|
||||||
check_physical_device_features(VkPhysicalDevice physicalDevice,
|
check_physical_device_features(VkPhysicalDevice physicalDevice,
|
||||||
const VkPhysicalDeviceFeatures *features)
|
const VkPhysicalDeviceFeatures *features)
|
||||||
|
@ -2787,7 +2699,19 @@ VkResult radv_CreateDevice(
|
||||||
if (!device)
|
if (!device)
|
||||||
return vk_error(physical_device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
|
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);
|
&physical_device->instance->vk.alloc, pAllocator);
|
||||||
if (result != VK_SUCCESS) {
|
if (result != VK_SUCCESS) {
|
||||||
vk_free(&device->vk.alloc, device);
|
vk_free(&device->vk.alloc, device);
|
||||||
|
@ -2799,36 +2723,22 @@ VkResult radv_CreateDevice(
|
||||||
|
|
||||||
device->ws = physical_device->ws;
|
device->ws = physical_device->ws;
|
||||||
|
|
||||||
for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
|
keep_shader_info = device->vk.enabled_extensions.AMD_shader_info;
|
||||||
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;
|
|
||||||
|
|
||||||
/* With update after bind we can't attach bo's to the command buffer
|
/* 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.
|
* from the descriptor set anymore, so we have to use a global BO list.
|
||||||
*/
|
*/
|
||||||
device->use_global_bo_list =
|
device->use_global_bo_list =
|
||||||
(device->instance->perftest_flags & RADV_PERFTEST_BO_LIST) ||
|
(device->instance->perftest_flags & RADV_PERFTEST_BO_LIST) ||
|
||||||
device->enabled_extensions.EXT_descriptor_indexing ||
|
device->vk.enabled_extensions.EXT_descriptor_indexing ||
|
||||||
device->enabled_extensions.EXT_buffer_device_address ||
|
device->vk.enabled_extensions.EXT_buffer_device_address ||
|
||||||
device->enabled_extensions.KHR_buffer_device_address;
|
device->vk.enabled_extensions.KHR_buffer_device_address;
|
||||||
|
|
||||||
device->robust_buffer_access = robust_buffer_access || robust_buffer_access2;
|
device->robust_buffer_access = robust_buffer_access || robust_buffer_access2;
|
||||||
device->robust_buffer_access2 = robust_buffer_access2;
|
device->robust_buffer_access2 = robust_buffer_access2;
|
||||||
|
|
||||||
device->adjust_frag_coord_z = (vrs_enabled ||
|
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_SIENNA_CICHLID ||
|
||||||
device->physical_device->rad_info.family == CHIP_NAVY_FLOUNDER ||
|
device->physical_device->rad_info.family == CHIP_NAVY_FLOUNDER ||
|
||||||
device->physical_device->rad_info.family == CHIP_VANGOGH);
|
device->physical_device->rad_info.family == CHIP_VANGOGH);
|
||||||
|
@ -5203,31 +5113,10 @@ VkResult radv_EnumerateInstanceExtensionProperties(
|
||||||
VK_OUTARRAY_MAKE_TYPED(VkExtensionProperties, out, pProperties,
|
VK_OUTARRAY_MAKE_TYPED(VkExtensionProperties, out, pProperties,
|
||||||
pPropertyCount);
|
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]) {
|
if (radv_instance_extensions_supported.extensions[i]) {
|
||||||
vk_outarray_append_typed(VkExtensionProperties, &out, prop) {
|
vk_outarray_append_typed(VkExtensionProperties, &out, prop) {
|
||||||
*prop = radv_instance_extensions[i];
|
*prop = vk_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];
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -5267,19 +5156,9 @@ PFN_vkVoidFunction radv_GetInstanceProcAddr(
|
||||||
if (instance == NULL)
|
if (instance == NULL)
|
||||||
return NULL;
|
return NULL;
|
||||||
|
|
||||||
int idx = radv_get_instance_entrypoint_index(pName);
|
return vk_instance_get_proc_addr(&instance->vk,
|
||||||
if (idx >= 0)
|
&radv_instance_entrypoints,
|
||||||
return instance->dispatch.entrypoints[idx];
|
pName);
|
||||||
|
|
||||||
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
|
/* 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)
|
const char* pName)
|
||||||
{
|
{
|
||||||
RADV_FROM_HANDLE(radv_instance, instance, _instance);
|
RADV_FROM_HANDLE(radv_instance, instance, _instance);
|
||||||
|
return vk_instance_get_physical_device_proc_addr(&instance->vk, pName);
|
||||||
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];
|
|
||||||
}
|
}
|
||||||
|
|
||||||
bool radv_get_memory_fd(struct radv_device *device,
|
bool radv_get_memory_fd(struct radv_device *device,
|
||||||
|
|
|
@ -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;
|
|
||||||
}
|
|
||||||
</%def>
|
|
||||||
|
|
||||||
${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()
|
|
|
@ -233,4 +233,5 @@ if __name__ == '__main__':
|
||||||
dest='xml_files')
|
dest='xml_files')
|
||||||
args = parser.parse_args()
|
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')
|
||||||
|
|
|
@ -1375,7 +1375,7 @@ get_external_image_format_properties(struct radv_physical_device *physical_devic
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
|
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;
|
break;
|
||||||
|
|
||||||
if (!radv_android_gralloc_supports_format(pImageFormatInfo->format,
|
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 (android_usage && ahb_supported) {
|
||||||
#if RADV_SUPPORT_ANDROID_HARDWARE_BUFFER
|
#if RADV_SUPPORT_ANDROID_HARDWARE_BUFFER
|
||||||
android_usage->androidHardwareBufferUsage =
|
android_usage->androidHardwareBufferUsage =
|
||||||
|
|
|
@ -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,
|
bool fast = depth_view_can_fast_clear(cmd_buffer, iview, aspects, layout,
|
||||||
in_render_loop, clear_rect, clear_value);
|
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;
|
int index = DEPTH_CLEAR_SLOW;
|
||||||
VkPipeline *pipeline;
|
VkPipeline *pipeline;
|
||||||
|
|
||||||
|
@ -807,7 +807,7 @@ emit_depthstencil_clear(struct radv_cmd_buffer *cmd_buffer,
|
||||||
if (!(aspects & VK_IMAGE_ASPECT_DEPTH_BIT))
|
if (!(aspects & VK_IMAGE_ASPECT_DEPTH_BIT))
|
||||||
clear_value.depth = 1.0f;
|
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),
|
radv_CmdPushConstants(radv_cmd_buffer_to_handle(cmd_buffer),
|
||||||
device->meta_state.clear_depth_unrestricted_p_layout,
|
device->meta_state.clear_depth_unrestricted_p_layout,
|
||||||
VK_SHADER_STAGE_FRAGMENT_BIT, 0, 4,
|
VK_SHADER_STAGE_FRAGMENT_BIT, 0, 4,
|
||||||
|
|
|
@ -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_physical_device_entry_name(int index);
|
||||||
const char *radv_get_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 radv_physical_device {
|
||||||
struct vk_physical_device vk;
|
struct vk_physical_device vk;
|
||||||
|
|
||||||
|
@ -323,8 +313,6 @@ struct radv_physical_device {
|
||||||
#ifndef _WIN32
|
#ifndef _WIN32
|
||||||
drmPciBusInfo bus_info;
|
drmPciBusInfo bus_info;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
struct radv_device_extension_table supported_extensions;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
struct radv_instance {
|
struct radv_instance {
|
||||||
|
@ -337,11 +325,6 @@ struct radv_instance {
|
||||||
|
|
||||||
struct vk_debug_report_instance debug_report_callbacks;
|
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;
|
bool physical_devices_enumerated;
|
||||||
struct list_head physical_devices;
|
struct list_head physical_devices;
|
||||||
|
|
||||||
|
@ -357,11 +340,7 @@ struct radv_instance {
|
||||||
|
|
||||||
VkResult radv_init_wsi(struct radv_physical_device *physical_device);
|
VkResult radv_init_wsi(struct radv_physical_device *physical_device);
|
||||||
void radv_finish_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);
|
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;
|
struct cache_entry;
|
||||||
|
|
||||||
|
@ -815,9 +794,6 @@ struct radv_device {
|
||||||
/* For detecting VM faults reported by dmesg. */
|
/* For detecting VM faults reported by dmesg. */
|
||||||
uint64_t dmesg_timestamp;
|
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. */
|
/* Whether the app has enabled the robustBufferAccess/robustBufferAccess2 features. */
|
||||||
bool robust_buffer_access;
|
bool robust_buffer_access;
|
||||||
bool robust_buffer_access2;
|
bool robust_buffer_access2;
|
||||||
|
|
|
@ -32,7 +32,8 @@
|
||||||
static PFN_vkVoidFunction
|
static PFN_vkVoidFunction
|
||||||
radv_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName)
|
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
|
static void
|
||||||
|
|
Loading…
Reference in New Issue