turnip: Use the common dispatch framework
Acked-by: Jonathan Marek <jonathan@marek.ca> Reviewed-by: Bas Nieuwenhuizen <bas@basnieuwenhuizen.nl> Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/8676>
This commit is contained in:
parent
ed9e75950b
commit
59d70c47c7
|
@ -19,14 +19,13 @@
|
|||
# SOFTWARE.
|
||||
|
||||
tu_entrypoints = custom_target(
|
||||
'tu_entrypoints.[ch]',
|
||||
input : ['tu_entrypoints_gen.py', vk_api_xml],
|
||||
'tu_entrypoints',
|
||||
input : [vk_entrypoints_gen, vk_api_xml],
|
||||
output : ['tu_entrypoints.h', 'tu_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', 'tu',
|
||||
],
|
||||
depend_files : files('tu_extensions.py'),
|
||||
)
|
||||
|
||||
tu_extensions_c = custom_target(
|
||||
|
|
|
@ -87,12 +87,12 @@ tu_physical_device_init(struct tu_physical_device *device,
|
|||
default:
|
||||
result = vk_startup_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
|
||||
"device %s is unsupported", device->name);
|
||||
goto fail;
|
||||
goto fail_fds;
|
||||
}
|
||||
if (tu_device_get_cache_uuid(device->gpu_id, device->cache_uuid)) {
|
||||
result = vk_startup_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
|
||||
"cannot generate UUID");
|
||||
goto fail;
|
||||
goto fail_fds;
|
||||
}
|
||||
|
||||
/* The gpu id is already embedded in the uuid so we just pass "tu"
|
||||
|
@ -108,19 +108,32 @@ tu_physical_device_init(struct tu_physical_device *device,
|
|||
fd_get_driver_uuid(device->driver_uuid);
|
||||
fd_get_device_uuid(device->device_uuid, device->gpu_id);
|
||||
|
||||
tu_physical_device_get_supported_extensions(device, &device->supported_extensions);
|
||||
struct vk_device_extension_table supported_extensions;
|
||||
tu_physical_device_get_supported_extensions(device, &supported_extensions);
|
||||
|
||||
struct vk_physical_device_dispatch_table dispatch_table;
|
||||
vk_physical_device_dispatch_table_from_entrypoints(
|
||||
&dispatch_table, &tu_physical_device_entrypoints, true);
|
||||
|
||||
result = vk_physical_device_init(&device->vk, &instance->vk,
|
||||
&supported_extensions,
|
||||
&dispatch_table);
|
||||
if (result != VK_SUCCESS)
|
||||
goto fail_fds;
|
||||
|
||||
#if TU_HAS_SURFACE
|
||||
result = tu_wsi_init(device);
|
||||
if (result != VK_SUCCESS) {
|
||||
vk_startup_errorf(instance, result, "WSI init failure");
|
||||
goto fail;
|
||||
goto fail_vk_pd_init;
|
||||
}
|
||||
#endif
|
||||
|
||||
return VK_SUCCESS;
|
||||
|
||||
fail:
|
||||
fail_vk_pd_init:
|
||||
vk_physical_device_finish(&device->vk);
|
||||
fail_fds:
|
||||
close(device->local_fd);
|
||||
if (device->master_fd != -1)
|
||||
close(device->master_fd);
|
||||
|
@ -139,7 +152,7 @@ tu_physical_device_finish(struct tu_physical_device *device)
|
|||
if (device->master_fd != -1)
|
||||
close(device->master_fd);
|
||||
|
||||
vk_object_base_finish(&device->base);
|
||||
vk_physical_device_finish(&device->vk);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void *
|
||||
|
@ -195,16 +208,6 @@ tu_get_debug_option_name(int id)
|
|||
return tu_debug_options[id].string;
|
||||
}
|
||||
|
||||
static int
|
||||
tu_get_instance_extension_index(const char *name)
|
||||
{
|
||||
for (unsigned i = 0; i < TU_INSTANCE_EXTENSION_COUNT; ++i) {
|
||||
if (strcmp(name, tu_instance_extensions[i].extensionName) == 0)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
VkResult
|
||||
tu_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
|
||||
const VkAllocationCallbacks *pAllocator,
|
||||
|
@ -215,28 +218,28 @@ tu_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
|
|||
|
||||
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
|
||||
|
||||
uint32_t client_version;
|
||||
if (pCreateInfo->pApplicationInfo &&
|
||||
pCreateInfo->pApplicationInfo->apiVersion != 0) {
|
||||
client_version = pCreateInfo->pApplicationInfo->apiVersion;
|
||||
} else {
|
||||
tu_EnumerateInstanceVersion(&client_version);
|
||||
}
|
||||
if (pAllocator == NULL)
|
||||
pAllocator = &default_alloc;
|
||||
|
||||
instance = vk_zalloc2(&default_alloc, pAllocator, sizeof(*instance), 8,
|
||||
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
|
||||
instance = vk_zalloc(pAllocator, sizeof(*instance), 8,
|
||||
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
|
||||
|
||||
if (!instance)
|
||||
return vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
|
||||
|
||||
vk_object_base_init(NULL, &instance->base, VK_OBJECT_TYPE_INSTANCE);
|
||||
struct vk_instance_dispatch_table dispatch_table;
|
||||
vk_instance_dispatch_table_from_entrypoints(
|
||||
&dispatch_table, &tu_instance_entrypoints, true);
|
||||
|
||||
if (pAllocator)
|
||||
instance->alloc = *pAllocator;
|
||||
else
|
||||
instance->alloc = default_alloc;
|
||||
result = vk_instance_init(&instance->vk,
|
||||
&tu_instance_extensions_supported,
|
||||
&dispatch_table,
|
||||
pCreateInfo, pAllocator);
|
||||
if (result != VK_SUCCESS) {
|
||||
vk_free(pAllocator, instance);
|
||||
return vk_error(NULL, result);
|
||||
}
|
||||
|
||||
instance->api_version = client_version;
|
||||
instance->physical_device_count = -1;
|
||||
|
||||
instance->debug_flags =
|
||||
|
@ -253,24 +256,10 @@ tu_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
|
|||
if (instance->debug_flags & TU_DEBUG_STARTUP)
|
||||
mesa_logi("Created an instance");
|
||||
|
||||
for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
|
||||
const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i];
|
||||
int index = tu_get_instance_extension_index(ext_name);
|
||||
|
||||
if (index < 0 || !tu_instance_extensions_supported.extensions[index]) {
|
||||
vk_object_base_finish(&instance->base);
|
||||
vk_free2(&default_alloc, pAllocator, instance);
|
||||
return vk_startup_errorf(instance, VK_ERROR_EXTENSION_NOT_PRESENT,
|
||||
"Missing %s", ext_name);
|
||||
}
|
||||
|
||||
instance->enabled_extensions.extensions[index] = true;
|
||||
}
|
||||
|
||||
result = vk_debug_report_instance_init(&instance->debug_report_callbacks);
|
||||
if (result != VK_SUCCESS) {
|
||||
vk_object_base_finish(&instance->base);
|
||||
vk_free2(&default_alloc, pAllocator, instance);
|
||||
vk_instance_finish(&instance->vk);
|
||||
vk_free(pAllocator, instance);
|
||||
return vk_startup_errorf(instance, result, "debug_report setup failure");
|
||||
}
|
||||
|
||||
|
@ -302,8 +291,8 @@ tu_DestroyInstance(VkInstance _instance,
|
|||
|
||||
vk_debug_report_instance_destroy(&instance->debug_report_callbacks);
|
||||
|
||||
vk_object_base_finish(&instance->base);
|
||||
vk_free(&instance->alloc, instance);
|
||||
vk_instance_finish(&instance->vk);
|
||||
vk_free(&instance->vk.alloc, instance);
|
||||
}
|
||||
|
||||
VkResult
|
||||
|
@ -827,7 +816,7 @@ tu_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
|
|||
VkPhysicalDeviceSampleLocationsPropertiesEXT *properties =
|
||||
(VkPhysicalDeviceSampleLocationsPropertiesEXT *)ext;
|
||||
properties->sampleLocationSampleCounts = 0;
|
||||
if (pdevice->supported_extensions.EXT_sample_locations) {
|
||||
if (pdevice->vk.supported_extensions.EXT_sample_locations) {
|
||||
properties->sampleLocationSampleCounts =
|
||||
VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT;
|
||||
}
|
||||
|
@ -980,16 +969,6 @@ tu_queue_finish(struct tu_queue *queue)
|
|||
tu_drm_submitqueue_close(queue->device, queue->msm_queue_id);
|
||||
}
|
||||
|
||||
static int
|
||||
tu_get_device_extension_index(const char *name)
|
||||
{
|
||||
for (unsigned i = 0; i < TU_DEVICE_EXTENSION_COUNT; ++i) {
|
||||
if (strcmp(name, tu_device_extensions[i].extensionName) == 0)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
VkResult
|
||||
tu_CreateDevice(VkPhysicalDevice physicalDevice,
|
||||
const VkDeviceCreateInfo *pCreateInfo,
|
||||
|
@ -1036,13 +1015,19 @@ tu_CreateDevice(VkPhysicalDevice physicalDevice,
|
|||
}
|
||||
}
|
||||
|
||||
device = vk_zalloc2(&physical_device->instance->alloc, pAllocator,
|
||||
device = vk_zalloc2(&physical_device->instance->vk.alloc, pAllocator,
|
||||
sizeof(*device), 8, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
|
||||
if (!device)
|
||||
return vk_startup_errorf(physical_device->instance, VK_ERROR_OUT_OF_HOST_MEMORY, "OOM");
|
||||
|
||||
result = vk_device_init(&device->vk, NULL, NULL, pCreateInfo,
|
||||
&physical_device->instance->alloc, pAllocator);
|
||||
struct vk_device_dispatch_table dispatch_table;
|
||||
vk_device_dispatch_table_from_entrypoints(
|
||||
&dispatch_table, &tu_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);
|
||||
return vk_startup_errorf(physical_device->instance, result,
|
||||
|
@ -1056,21 +1041,6 @@ tu_CreateDevice(VkPhysicalDevice physicalDevice,
|
|||
|
||||
mtx_init(&device->bo_mutex, mtx_plain);
|
||||
|
||||
for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
|
||||
const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i];
|
||||
int index = tu_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_startup_errorf(physical_device->instance,
|
||||
VK_ERROR_EXTENSION_NOT_PRESENT,
|
||||
"Missing device extension '%s'", ext_name);
|
||||
}
|
||||
|
||||
device->enabled_extensions.extensions[index] = true;
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < pCreateInfo->queueCreateInfoCount; i++) {
|
||||
const VkDeviceQueueCreateInfo *queue_create =
|
||||
&pCreateInfo->pQueueCreateInfos[i];
|
||||
|
@ -1347,15 +1317,6 @@ tu_EnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
|
|||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
VkResult
|
||||
tu_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
|
||||
uint32_t *pPropertyCount,
|
||||
VkLayerProperties *pProperties)
|
||||
{
|
||||
*pPropertyCount = 0;
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
void
|
||||
tu_GetDeviceQueue2(VkDevice _device,
|
||||
const VkDeviceQueueInfo2 *pQueueInfo,
|
||||
|
@ -1434,32 +1395,9 @@ tu_EnumerateInstanceExtensionProperties(const char *pLayerName,
|
|||
if (pLayerName)
|
||||
return vk_error(NULL, VK_ERROR_LAYER_NOT_PRESENT);
|
||||
|
||||
for (int i = 0; i < TU_INSTANCE_EXTENSION_COUNT; i++) {
|
||||
for (int i = 0; i < VK_INSTANCE_EXTENSION_COUNT; i++) {
|
||||
if (tu_instance_extensions_supported.extensions[i]) {
|
||||
vk_outarray_append(&out, prop) { *prop = tu_instance_extensions[i]; }
|
||||
}
|
||||
}
|
||||
|
||||
return vk_outarray_status(&out);
|
||||
}
|
||||
|
||||
VkResult
|
||||
tu_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
|
||||
const char *pLayerName,
|
||||
uint32_t *pPropertyCount,
|
||||
VkExtensionProperties *pProperties)
|
||||
{
|
||||
/* We spport no lyaers */
|
||||
TU_FROM_HANDLE(tu_physical_device, device, physicalDevice);
|
||||
VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount);
|
||||
|
||||
/* We spport no lyaers */
|
||||
if (pLayerName)
|
||||
return vk_error(NULL, VK_ERROR_LAYER_NOT_PRESENT);
|
||||
|
||||
for (int i = 0; i < TU_DEVICE_EXTENSION_COUNT; i++) {
|
||||
if (device->supported_extensions.extensions[i]) {
|
||||
vk_outarray_append(&out, prop) { *prop = tu_device_extensions[i]; }
|
||||
vk_outarray_append(&out, prop) { *prop = vk_instance_extensions[i]; }
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1470,10 +1408,9 @@ PFN_vkVoidFunction
|
|||
tu_GetInstanceProcAddr(VkInstance _instance, const char *pName)
|
||||
{
|
||||
TU_FROM_HANDLE(tu_instance, instance, _instance);
|
||||
|
||||
return tu_lookup_entrypoint_checked(
|
||||
pName, instance ? instance->api_version : 0,
|
||||
instance ? &instance->enabled_extensions : NULL, NULL);
|
||||
return vk_instance_get_proc_addr(&instance->vk,
|
||||
&tu_instance_entrypoints,
|
||||
pName);
|
||||
}
|
||||
|
||||
/* The loader wants us to expose a second GetInstanceProcAddr function
|
||||
|
@ -1490,16 +1427,6 @@ vk_icdGetInstanceProcAddr(VkInstance instance, const char *pName)
|
|||
return tu_GetInstanceProcAddr(instance, pName);
|
||||
}
|
||||
|
||||
PFN_vkVoidFunction
|
||||
tu_GetDeviceProcAddr(VkDevice _device, const char *pName)
|
||||
{
|
||||
TU_FROM_HANDLE(tu_device, device, _device);
|
||||
|
||||
return tu_lookup_entrypoint_checked(pName, device->instance->api_version,
|
||||
&device->instance->enabled_extensions,
|
||||
&device->enabled_extensions);
|
||||
}
|
||||
|
||||
VkResult
|
||||
tu_AllocateMemory(VkDevice _device,
|
||||
const VkMemoryAllocateInfo *pAllocateInfo,
|
||||
|
@ -2154,7 +2081,7 @@ void tu_GetPhysicalDeviceMultisamplePropertiesEXT(
|
|||
{
|
||||
TU_FROM_HANDLE(tu_physical_device, pdevice, physicalDevice);
|
||||
|
||||
if (samples <= VK_SAMPLE_COUNT_4_BIT && pdevice->supported_extensions.EXT_sample_locations)
|
||||
if (samples <= VK_SAMPLE_COUNT_4_BIT && pdevice->vk.supported_extensions.EXT_sample_locations)
|
||||
pMultisampleProperties->maxSampleLocationGridSize = (VkExtent2D){ 1, 1 };
|
||||
else
|
||||
pMultisampleProperties->maxSampleLocationGridSize = (VkExtent2D){ 0, 0 };
|
||||
|
|
|
@ -356,10 +356,9 @@ tu_drm_device_init(struct tu_physical_device *device,
|
|||
if (instance->debug_flags & TU_DEBUG_STARTUP)
|
||||
mesa_logi("Found compatible device '%s'.", path);
|
||||
|
||||
vk_object_base_init(NULL, &device->base, VK_OBJECT_TYPE_PHYSICAL_DEVICE);
|
||||
device->instance = instance;
|
||||
|
||||
if (instance->enabled_extensions.KHR_display) {
|
||||
if (instance->vk.enabled_extensions.KHR_display) {
|
||||
master_fd =
|
||||
open(drm_device->nodes[DRM_NODE_PRIMARY], O_RDWR | O_CLOEXEC);
|
||||
if (master_fd >= 0) {
|
||||
|
|
|
@ -1,510 +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 copy
|
||||
import functools
|
||||
import math
|
||||
import os
|
||||
import xml.etree.ElementTree as et
|
||||
|
||||
from collections import OrderedDict, namedtuple
|
||||
from mako.template import Template
|
||||
|
||||
from tu_extensions import VkVersion, MAX_API_VERSION, EXTENSIONS
|
||||
|
||||
# We generate a static hash table for entry point lookup
|
||||
# (vkGetProcAddress). We use a linear congruential generator for our hash
|
||||
# function and a power-of-two size table. The prime numbers are determined
|
||||
# experimentally.
|
||||
|
||||
# We currently don't use layers in tu, but keeping the ability for anv
|
||||
# anyways, so we can use it for device groups.
|
||||
LAYERS = [
|
||||
'tu'
|
||||
]
|
||||
|
||||
TEMPLATE_H = Template("""\
|
||||
/* This file generated from ${filename}, don't edit directly. */
|
||||
|
||||
struct tu_dispatch_table {
|
||||
union {
|
||||
void *entrypoints[${len(entrypoints)}];
|
||||
struct {
|
||||
% for e in 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
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
% for e in entrypoints:
|
||||
% if e.alias:
|
||||
<% continue %>
|
||||
% endif
|
||||
% if e.guard is not None:
|
||||
#ifdef ${e.guard}
|
||||
% endif
|
||||
% for layer in LAYERS:
|
||||
VKAPI_ATTR ${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 "tu_private.h"
|
||||
|
||||
struct string_map_entry {
|
||||
uint32_t name;
|
||||
uint32_t hash;
|
||||
uint32_t num;
|
||||
};
|
||||
|
||||
/* We use a big string constant to avoid lots of relocations from the entry
|
||||
* point table to lots of little strings. The entries in the entry point table
|
||||
* store the index into this big string.
|
||||
*/
|
||||
|
||||
static const char strings[] =
|
||||
% for s in strmap.sorted_strings:
|
||||
"${s.string}\\0"
|
||||
% endfor
|
||||
;
|
||||
|
||||
static const struct string_map_entry 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 string_map[${strmap.hash_size}] = {
|
||||
% for e in strmap.mapping:
|
||||
${ '{:0=#6x}'.format(e) if e >= 0 else 'none' },
|
||||
% endfor
|
||||
};
|
||||
|
||||
/* 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 layer in LAYERS:
|
||||
% for e in entrypoints:
|
||||
% if e.alias:
|
||||
<% 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 e.guard is not None:
|
||||
#endif // ${e.guard}
|
||||
% endif
|
||||
% endfor
|
||||
|
||||
const struct tu_dispatch_table ${layer}_layer = {
|
||||
% for e in 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
|
||||
|
||||
static void * __attribute__ ((noinline))
|
||||
tu_resolve_entrypoint(uint32_t index)
|
||||
{
|
||||
return tu_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
|
||||
tu_entrypoint_is_enabled(int index, uint32_t core_version,
|
||||
const struct tu_instance_extension_table *instance,
|
||||
const struct tu_device_extension_table *device)
|
||||
{
|
||||
switch (index) {
|
||||
% for e in entrypoints:
|
||||
case ${e.num}:
|
||||
% if not e.device_command:
|
||||
if (device) return false;
|
||||
% endif
|
||||
% if e.name == 'vkGetInstanceProcAddr' or 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;
|
||||
% 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
|
||||
return false;
|
||||
% else:
|
||||
return instance;
|
||||
% endif
|
||||
% endfor
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
tu_lookup_entrypoint(const char *name)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
void *
|
||||
tu_lookup_entrypoint_unchecked(const char *name)
|
||||
{
|
||||
int index = tu_lookup_entrypoint(name);
|
||||
if (index < 0)
|
||||
return NULL;
|
||||
return tu_resolve_entrypoint(index);
|
||||
}
|
||||
|
||||
void *
|
||||
tu_lookup_entrypoint_checked(const char *name,
|
||||
uint32_t core_version,
|
||||
const struct tu_instance_extension_table *instance,
|
||||
const struct tu_device_extension_table *device)
|
||||
{
|
||||
int index = tu_lookup_entrypoint(name);
|
||||
if (index < 0 || !tu_entrypoint_is_enabled(index, core_version, instance, device))
|
||||
return NULL;
|
||||
return tu_resolve_entrypoint(index);
|
||||
}""", 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 = []
|
||||
|
||||
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')
|
||||
|
||||
def prefixed_name(self, prefix):
|
||||
assert self.name.startswith('vk')
|
||||
return prefix + '_' + self.name[2:]
|
||||
|
||||
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
|
||||
self.device_command = entrypoint.device_command
|
||||
|
||||
def prefixed_name(self, prefix):
|
||||
return self.alias.prefixed_name(prefix)
|
||||
|
||||
def get_entrypoints(doc, entrypoints_to_defines, start_index):
|
||||
"""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 = {}
|
||||
|
||||
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']
|
||||
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 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.',
|
||||
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),
|
||||
start_index=len(entrypoints))
|
||||
|
||||
for num, e in enumerate(entrypoints):
|
||||
e.num = num
|
||||
|
||||
# For outputting entrypoints.h we generate a tu_EntryPoint() prototype
|
||||
# per entry point.
|
||||
with open(os.path.join(args.outdir, 'tu_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, 'tu_entrypoints.c'), 'wb') as f:
|
||||
f.write(gen_code(entrypoints))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
|
@ -118,4 +118,5 @@ if __name__ == '__main__':
|
|||
dest='xml_files')
|
||||
args = parser.parse_args()
|
||||
|
||||
gen_extensions('tu', args.xml_files, API_VERSIONS, MAX_API_VERSION, EXTENSIONS, args.out_c, args.out_h)
|
||||
gen_extensions('tu', args.xml_files, API_VERSIONS, MAX_API_VERSION,
|
||||
EXTENSIONS, args.out_c, args.out_h, type_prefix='vk')
|
||||
|
|
|
@ -401,7 +401,7 @@ tu_physical_device_get_format_properties(
|
|||
if (desc->layout != UTIL_FORMAT_LAYOUT_SUBSAMPLED)
|
||||
optimal |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
|
||||
|
||||
if (physical_device->supported_extensions.EXT_filter_cubic)
|
||||
if (physical_device->vk.supported_extensions.EXT_filter_cubic)
|
||||
optimal |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
|
||||
}
|
||||
|
||||
|
|
|
@ -54,6 +54,10 @@
|
|||
#include "vk_alloc.h"
|
||||
#include "vk_debug_report.h"
|
||||
#include "vk_device.h"
|
||||
#include "vk_dispatch_table.h"
|
||||
#include "vk_extensions.h"
|
||||
#include "vk_instance.h"
|
||||
#include "vk_physical_device.h"
|
||||
#include "wsi_common.h"
|
||||
|
||||
#include "ir3/ir3_compiler.h"
|
||||
|
@ -170,18 +174,9 @@ __tu_finishme(const char *file, int line, const char *format, ...)
|
|||
tu_finishme("stub %s", __func__); \
|
||||
} while (0)
|
||||
|
||||
void *
|
||||
tu_lookup_entrypoint_unchecked(const char *name);
|
||||
void *
|
||||
tu_lookup_entrypoint_checked(
|
||||
const char *name,
|
||||
uint32_t core_version,
|
||||
const struct tu_instance_extension_table *instance,
|
||||
const struct tu_device_extension_table *device);
|
||||
|
||||
struct tu_physical_device
|
||||
{
|
||||
struct vk_object_base base;
|
||||
struct vk_physical_device vk;
|
||||
|
||||
struct tu_instance *instance;
|
||||
|
||||
|
@ -208,8 +203,6 @@ struct tu_physical_device
|
|||
* the pipeline cache defined by apps.
|
||||
*/
|
||||
struct disk_cache *disk_cache;
|
||||
|
||||
struct tu_device_extension_table supported_extensions;
|
||||
};
|
||||
|
||||
enum tu_debug_flags
|
||||
|
@ -228,9 +221,7 @@ enum tu_debug_flags
|
|||
|
||||
struct tu_instance
|
||||
{
|
||||
struct vk_object_base base;
|
||||
|
||||
VkAllocationCallbacks alloc;
|
||||
struct vk_instance vk;
|
||||
|
||||
uint32_t api_version;
|
||||
int physical_device_count;
|
||||
|
@ -239,8 +230,6 @@ struct tu_instance
|
|||
enum tu_debug_flags debug_flags;
|
||||
|
||||
struct vk_debug_report_instance debug_report_callbacks;
|
||||
|
||||
struct tu_instance_extension_table enabled_extensions;
|
||||
};
|
||||
|
||||
VkResult
|
||||
|
@ -382,8 +371,6 @@ struct tu_device
|
|||
|
||||
struct tu_bo global_bo;
|
||||
|
||||
struct tu_device_extension_table enabled_extensions;
|
||||
|
||||
uint32_t vsc_draw_strm_pitch;
|
||||
uint32_t vsc_prim_strm_pitch;
|
||||
BITSET_DECLARE(custom_border_color, TU_BORDER_COLOR_COUNT);
|
||||
|
|
|
@ -32,7 +32,8 @@
|
|||
static VKAPI_PTR PFN_vkVoidFunction
|
||||
tu_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName)
|
||||
{
|
||||
return tu_lookup_entrypoint_unchecked(pName);
|
||||
TU_FROM_HANDLE(tu_physical_device, pdevice, physicalDevice);
|
||||
return vk_instance_get_proc_addr_unchecked(&pdevice->instance->vk, pName);
|
||||
}
|
||||
|
||||
VkResult
|
||||
|
@ -43,7 +44,7 @@ tu_wsi_init(struct tu_physical_device *physical_device)
|
|||
result = wsi_device_init(&physical_device->wsi_device,
|
||||
tu_physical_device_to_handle(physical_device),
|
||||
tu_wsi_proc_addr,
|
||||
&physical_device->instance->alloc,
|
||||
&physical_device->instance->vk.alloc,
|
||||
physical_device->master_fd, NULL,
|
||||
false);
|
||||
if (result != VK_SUCCESS)
|
||||
|
@ -58,7 +59,7 @@ void
|
|||
tu_wsi_finish(struct tu_physical_device *physical_device)
|
||||
{
|
||||
wsi_device_finish(&physical_device->wsi_device,
|
||||
&physical_device->instance->alloc);
|
||||
&physical_device->instance->vk.alloc);
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -69,7 +70,7 @@ tu_DestroySurfaceKHR(VkInstance _instance,
|
|||
TU_FROM_HANDLE(tu_instance, instance, _instance);
|
||||
ICD_FROM_HANDLE(VkIcdSurfaceBase, surface, _surface);
|
||||
|
||||
vk_free2(&instance->alloc, pAllocator, surface);
|
||||
vk_free2(&instance->vk.alloc, pAllocator, surface);
|
||||
}
|
||||
|
||||
VkResult
|
||||
|
|
|
@ -197,7 +197,7 @@ tu_CreateDisplayPlaneSurfaceKHR(
|
|||
if (allocator)
|
||||
alloc = allocator;
|
||||
else
|
||||
alloc = &instance->alloc;
|
||||
alloc = &instance->vk.alloc;
|
||||
|
||||
return wsi_create_display_surface(_instance, alloc,
|
||||
create_info, surface);
|
||||
|
|
|
@ -53,7 +53,7 @@ tu_CreateWaylandSurfaceKHR(VkInstance _instance,
|
|||
if (pAllocator)
|
||||
alloc = pAllocator;
|
||||
else
|
||||
alloc = &instance->alloc;
|
||||
alloc = &instance->vk.alloc;
|
||||
|
||||
return wsi_create_wl_surface(alloc, pCreateInfo, pSurface);
|
||||
}
|
||||
|
|
|
@ -75,7 +75,7 @@ VkResult tu_CreateXcbSurfaceKHR(
|
|||
if (pAllocator)
|
||||
alloc = pAllocator;
|
||||
else
|
||||
alloc = &instance->alloc;
|
||||
alloc = &instance->vk.alloc;
|
||||
|
||||
return wsi_create_xcb_surface(alloc, pCreateInfo, pSurface);
|
||||
}
|
||||
|
@ -94,7 +94,7 @@ VkResult tu_CreateXlibSurfaceKHR(
|
|||
if (pAllocator)
|
||||
alloc = pAllocator;
|
||||
else
|
||||
alloc = &instance->alloc;
|
||||
alloc = &instance->vk.alloc;
|
||||
|
||||
return wsi_create_xlib_surface(alloc, pCreateInfo, pSurface);
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue