Commit 23f8ca0c authored by Dave Airlie's avatar Dave Airlie Committed by Marge Bot
Browse files

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's avatarJason Ekstrand <jason@jlekstrand.net>
Reviewed-by: Samuel Pitoiset's avatarSamuel Pitoiset <samuel.pitoiset@gmail.com>
Reviewed-by: Bas Nieuwenhuizen's avatarBas Nieuwenhuizen <bas@basnieuwenhuizen.nl>
Part-of: <mesa/mesa!8676>
parent 7d166212
......@@ -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(
......
......@@ -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,
......
This diff is collapsed.
......@@ -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')
......@@ -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 =
......
......@@ -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,
......
......@@ -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;
......
......@@ -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
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment