AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lavapipe: use common dispatch layer.

Browse Source 
This moves lavapipe over to using the new common dispatch layer code.

v2 (Jason Ekstrand):
 - Less pointless messing around with python and meson

Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/8676>
This commit is contained in:
Dave Airlie
2021-01-25 09:50:29 +10:00
committed by Marge Bot
parent ae895d308a
commit ed9e75950b
6 changed files with 45 additions and 1035 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gallium/frontends/lavapipe/lvp_device.c
+22 -197
View File
@@ -45,8 +45,11 @@ lvp_physical_device_init(struct lvp_physical_device *device,
{
VkResult result;
struct vk_physical_device_dispatch_table dispatch_table;
vk_physical_device_dispatch_table_from_entrypoints(
&dispatch_table, &lvp_physical_device_entrypoints, true);
result = vk_physical_device_init(&device->vk, &instance->vk,
NULL, NULL);
NULL, &dispatch_table);
if (result != VK_SUCCESS) {
vk_error(instance, result);
goto fail;
@@ -58,7 +61,7 @@ lvp_physical_device_init(struct lvp_physical_device *device,
return vk_error(instance, VK_ERROR_OUT_OF_HOST_MEMORY);
device->max_images = device->pscreen->get_shader_param(device->pscreen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_SHADER_IMAGES);
lvp_physical_device_get_supported_extensions(device, &device->supported_extensions);
lvp_physical_device_get_supported_extensions(device, &device->vk.supported_extensions);
result = lvp_init_wsi(device);
if (result != VK_SUCCESS) {
vk_physical_device_finish(&device->vk);
@@ -132,9 +135,13 @@ VkResult lvp_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, &lvp_instance_entrypoints, true);
result = vk_instance_init(&instance->vk,
NULL, NULL,
&lvp_instance_extensions_supported,
&dispatch_table,
pCreateInfo,
pAllocator);
if (result != VK_SUCCESS) {
@@ -145,65 +152,6 @@ VkResult lvp_CreateInstance(
instance->apiVersion = client_version;
instance->physicalDeviceCount = -1;
for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
int idx;
for (idx = 0; idx < LVP_INSTANCE_EXTENSION_COUNT; idx++) {
if (!strcmp(pCreateInfo->ppEnabledExtensionNames[i],
lvp_instance_extensions[idx].extensionName))
break;
}
if (idx >= LVP_INSTANCE_EXTENSION_COUNT ||
!lvp_instance_extensions_supported.extensions[idx]) {
vk_free2(&default_alloc, pAllocator, instance);
return vk_error(instance, VK_ERROR_EXTENSION_NOT_PRESENT);
}
instance->enabled_extensions.extensions[idx] = true;
}
bool unchecked = instance->debug_flags & LVP_DEBUG_ALL_ENTRYPOINTS;
for (unsigned i = 0; i < ARRAY_SIZE(instance->dispatch.entrypoints); i++) {
/* Vulkan requires that entrypoints for extensions which have
* not been enabled must not be advertised.
*/
if (!unchecked &&
!lvp_instance_entrypoint_is_enabled(i, instance->apiVersion,
&instance->enabled_extensions)) {
instance->dispatch.entrypoints[i] = NULL;
} else {
instance->dispatch.entrypoints[i] =
lvp_instance_dispatch_table.entrypoints[i];
}
}
for (unsigned i = 0; i < ARRAY_SIZE(instance->physical_device_dispatch.entrypoints); i++) {
/* Vulkan requires that entrypoints for extensions which have
* not been enabled must not be advertised.
*/
if (!unchecked &&
!lvp_physical_device_entrypoint_is_enabled(i, instance->apiVersion,
&instance->enabled_extensions)) {
instance->physical_device_dispatch.entrypoints[i] = NULL;
} else {
instance->physical_device_dispatch.entrypoints[i] =
lvp_physical_device_dispatch_table.entrypoints[i];
}
}
for (unsigned i = 0; i < ARRAY_SIZE(instance->device_dispatch.entrypoints); i++) {
/* Vulkan requires that entrypoints for extensions which have
* not been enabled must not be advertised.
*/
if (!unchecked &&
!lvp_device_entrypoint_is_enabled(i, instance->apiVersion,
&instance->enabled_extensions, NULL)) {
instance->device_dispatch.entrypoints[i] = NULL;
} else {
instance->device_dispatch.entrypoints[i] =
lvp_device_dispatch_table.entrypoints[i];
}
}
// _mesa_locale_init();
glsl_type_singleton_init_or_ref();
// VG(VALGRIND_CREATE_MEMPOOL(instance, 0, false));
@@ -725,46 +673,9 @@ PFN_vkVoidFunction lvp_GetInstanceProcAddr(
const char* pName)
{
LVP_FROM_HANDLE(lvp_instance, instance, _instance);
/* The Vulkan 1.0 spec for vkGetInstanceProcAddr has a table of exactly
* when we have to return valid function pointers, NULL, or it's left
* undefined. See the table for exact details.
*/
if (pName == NULL)
return NULL;
#define LOOKUP_LVP_ENTRYPOINT(entrypoint) \
if (strcmp(pName, "vk" #entrypoint) == 0) \
return (PFN_vkVoidFunction)lvp_##entrypoint
LOOKUP_LVP_ENTRYPOINT(EnumerateInstanceExtensionProperties);
LOOKUP_LVP_ENTRYPOINT(EnumerateInstanceLayerProperties);
LOOKUP_LVP_ENTRYPOINT(EnumerateInstanceVersion);
LOOKUP_LVP_ENTRYPOINT(CreateInstance);
/* GetInstanceProcAddr() can also be called with a NULL instance.
* See https://gitlab.khronos.org/vulkan/vulkan/issues/2057
*/
LOOKUP_LVP_ENTRYPOINT(GetInstanceProcAddr);
#undef LOOKUP_LVP_ENTRYPOINT
if (instance == NULL)
return NULL;
int idx = lvp_get_instance_entrypoint_index(pName);
if (idx >= 0)
return instance->dispatch.entrypoints[idx];
idx = lvp_get_physical_device_entrypoint_index(pName);
if (idx >= 0)
return instance->physical_device_dispatch.entrypoints[idx];
idx = lvp_get_device_entrypoint_index(pName);
if (idx >= 0)
return instance->device_dispatch.entrypoints[idx];
return NULL;
return vk_instance_get_proc_addr(&instance->vk,
&lvp_instance_entrypoints,
pName);
}
/* The loader wants us to expose a second GetInstanceProcAddr function
@@ -794,30 +705,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(
const char* pName)
{
LVP_FROM_HANDLE(lvp_instance, instance, _instance);
if (!pName || !instance)
return NULL;
int idx = lvp_get_physical_device_entrypoint_index(pName);
if (idx < 0)
return NULL;
return instance->physical_device_dispatch.entrypoints[idx];
}
PFN_vkVoidFunction lvp_GetDeviceProcAddr(
VkDevice _device,
const char* pName)
{
LVP_FROM_HANDLE(lvp_device, device, _device);
if (!device || !pName)
return NULL;
int idx = lvp_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);
}
static int queue_thread(void *data)
@@ -883,42 +771,6 @@ lvp_queue_finish(struct lvp_queue *queue)
queue->ctx->destroy(queue->ctx);
}
static int lvp_get_device_extension_index(const char *name)
{
for (unsigned i = 0; i < LVP_DEVICE_EXTENSION_COUNT; ++i) {
if (strcmp(name, lvp_device_extensions[i].extensionName) == 0)
return i;
}
return -1;
}
static void
lvp_device_init_dispatch(struct lvp_device *device)
{
const struct lvp_instance *instance = (struct lvp_instance *)device->physical_device->vk.instance;
const struct lvp_device_dispatch_table *dispatch_table_layer = NULL;
bool unchecked = instance->debug_flags & LVP_DEBUG_ALL_ENTRYPOINTS;
for (unsigned i = 0; i < ARRAY_SIZE(device->dispatch.entrypoints); i++) {
/* Vulkan requires that entrypoints for extensions which have not been
* enabled must not be advertised.
*/
if (!unchecked &&
!lvp_device_entrypoint_is_enabled(i, instance->apiVersion,
&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] =
lvp_device_dispatch_table.entrypoints[i];
}
}
}
VkResult lvp_CreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
@@ -952,7 +804,12 @@ VkResult lvp_CreateDevice(
if (!device)
return vk_error(instance, VK_ERROR_OUT_OF_HOST_MEMORY);
VkResult result = vk_device_init(&device->vk, NULL, NULL, pCreateInfo,
struct vk_device_dispatch_table dispatch_table;
vk_device_dispatch_table_from_entrypoints(&dispatch_table,
&lvp_device_entrypoints, true);
VkResult result = vk_device_init(&device->vk,
&physical_device->vk,
&dispatch_table, pCreateInfo,
&physical_device->vk.instance->alloc,
pAllocator);
if (result != VK_SUCCESS) {
@@ -963,19 +820,6 @@ VkResult lvp_CreateDevice(
device->instance = (struct lvp_instance *)physical_device->vk.instance;
device->physical_device = physical_device;
for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i];
int index = lvp_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(instance, VK_ERROR_EXTENSION_NOT_PRESENT);
}
device->enabled_extensions.extensions[index] = true;
}
lvp_device_init_dispatch(device);
mtx_init(&device->fence_lock, mtx_plain);
device->pscreen = physical_device->pscreen;
@@ -1005,10 +849,10 @@ VkResult lvp_EnumerateInstanceExtensionProperties(
{
VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount);
for (int i = 0; i < LVP_INSTANCE_EXTENSION_COUNT; i++) {
for (int i = 0; i < VK_INSTANCE_EXTENSION_COUNT; i++) {
if (lvp_instance_extensions_supported.extensions[i]) {
vk_outarray_append(&out, prop) {
*prop = lvp_instance_extensions[i];
*prop = vk_instance_extensions[i];
}
}
}
@@ -1016,25 +860,6 @@ VkResult lvp_EnumerateInstanceExtensionProperties(
return vk_outarray_status(&out);
}
VkResult lvp_EnumerateDeviceExtensionProperties(
VkPhysicalDevice physicalDevice,
const char* pLayerName,
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties)
{
LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice);
VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount);
for (int i = 0; i < LVP_DEVICE_EXTENSION_COUNT; i++) {
if (device->supported_extensions.extensions[i]) {
vk_outarray_append(&out, prop) {
*prop = lvp_device_extensions[i];
}
}
}
return vk_outarray_status(&out);
}
VkResult lvp_EnumerateInstanceLayerProperties(
uint32_t* pPropertyCount,
VkLayerProperties* pProperties)
src/gallium/frontends/lavapipe/lvp_entrypoints_gen.py
-816
View File
@@ -1,816 +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 lvp_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.
# We currently don't use layers in lvp, but keeping the ability for anv
# anyways, so we can use it for device groups.
LAYERS = [
'lvp'
]
TEMPLATE_H = Template("""\
/* This file generated from ${filename}, don't edit directly. */
struct lvp_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 lvp_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 lvp_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 lvp_instance_dispatch_table lvp_instance_dispatch_table;
%for layer in LAYERS:
extern const struct lvp_physical_device_dispatch_table ${layer}_physical_device_dispatch_table;
%endfor
%for layer in LAYERS:
extern const struct lvp_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('lvp')}(${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 "lvp_private.h"
#include "util/macros.h"
struct string_map_entry {
uint32_t name;
uint32_t hash;
uint32_t num;
};
/* We use a big string constant to avoid lots of relocations from the entry
* 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
${e.return_type} ${e.prefixed_name('lvp')}(${e.decl_params()}) __attribute__ ((weak));
% if e.guard is not None:
#endif // ${e.guard}
% endif
% endfor
const struct lvp_instance_dispatch_table lvp_instance_dispatch_table = {
% for e in instance_entrypoints:
% if e.guard is not None:
#ifdef ${e.guard}
% endif
.${e.name} = ${e.prefixed_name('lvp')},
% if e.guard is not None:
#endif // ${e.guard}
% endif
% endfor
};
% for e in physical_device_entrypoints:
% if e.alias and e.alias.enabled:
<% continue %>
% endif
% if e.guard is not None:
#ifdef ${e.guard}
% endif
${e.return_type} ${e.prefixed_name('lvp')}(${e.decl_params()}) __attribute__ ((weak));
% if e.guard is not None:
#endif // ${e.guard}
% endif
% endfor
const struct lvp_physical_device_dispatch_table lvp_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('lvp')},
% 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 == 'lvp':
${e.return_type} __attribute__ ((weak))
${e.prefixed_name('lvp')}(${e.decl_params()})
{
% if e.params[0].type == 'VkDevice':
LVP_FROM_HANDLE(lvp_device, lvp_device, ${e.params[0].name});
return lvp_device->dispatch.${e.name}(${e.call_params()});
% elif e.params[0].type == 'VkCommandBuffer':
LVP_FROM_HANDLE(lvp_cmd_buffer, lvp_cmd_buffer, ${e.params[0].name});
return lvp_cmd_buffer->device->dispatch.${e.name}(${e.call_params()});
% elif e.params[0].type == 'VkQueue':
LVP_FROM_HANDLE(lvp_queue, lvp_queue, ${e.params[0].name});
return lvp_queue->device->dispatch.${e.name}(${e.call_params()});
% else:
assert(!"Unhandled device child trampoline case: ${e.params[0].type}");
% endif
}
% else:
${e.return_type} ${e.prefixed_name(layer)}(${e.decl_params()}) __attribute__ ((weak));
% endif
% if e.guard is not None:
#endif // ${e.guard}
% endif
% endfor
const struct lvp_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
lvp_instance_entrypoint_is_enabled(int index, uint32_t core_version,
const struct lvp_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
lvp_physical_device_entrypoint_is_enabled(int index, uint32_t core_version,
const struct lvp_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
lvp_device_entrypoint_is_enabled(int index, uint32_t core_version,
const struct lvp_instance_extension_table *instance,
const struct lvp_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
lvp_get_instance_entrypoint_index(const char *name)
{
return instance_string_map_lookup(name);
}
int
lvp_get_physical_device_entrypoint_index(const char *name)
{
return physical_device_string_map_lookup(name);
}
int
lvp_get_device_entrypoint_index(const char *name)
{
return device_string_map_lookup(name);
}
const char *
lvp_get_instance_entry_name(int index)
{
return instance_entry_name(index);
}
const char *
lvp_get_physical_device_entry_name(int index)
{
return physical_device_entry_name(index);
}
const char *
lvp_get_device_entry_name(int index)
{
return device_entry_name(index);
}
static void * __attribute__ ((noinline))
lvp_resolve_device_entrypoint(uint32_t index)
{
return lvp_device_dispatch_table.entrypoints[index];
}
void *
lvp_lookup_entrypoint(const char *name)
{
int idx = lvp_get_instance_entrypoint_index(name);
if (idx >= 0)
return lvp_instance_dispatch_table.entrypoints[idx];
idx = lvp_get_physical_device_entrypoint_index(name);
if (idx >= 0)
return lvp_physical_device_dispatch_table.entrypoints[idx];
idx = lvp_get_device_entrypoint_index(name);
if (idx >= 0)
return lvp_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 lvp_EntryPoint() prototype
# per entry point.
try:
with open(os.path.join(args.outdir, 'lvp_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, 'lvp_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()
src/gallium/frontends/lavapipe/lvp_extensions.py
+2 -1
View File
@@ -183,4 +183,5 @@ if __name__ == '__main__':
dest='xml_files')
args = parser.parse_args()
gen_extensions('lvp', args.xml_files, API_VERSIONS, MAX_API_VERSION, EXTENSIONS, args.out_c, args.out_h)
gen_extensions('lvp', args.xml_files, API_VERSIONS, MAX_API_VERSION,
EXTENSIONS, args.out_c, args.out_h, type_prefix='vk')
src/gallium/frontends/lavapipe/lvp_private.h
+5 -15
View File
@@ -78,14 +78,12 @@ const char *lvp_get_physical_device_entry_name(int index);
const char *lvp_get_device_entry_name(int index);
bool lvp_instance_entrypoint_is_enabled(int index, uint32_t core_version,
const struct lvp_instance_extension_table *instance);
const struct vk_instance_extension_table *instance);
bool lvp_physical_device_entrypoint_is_enabled(int index, uint32_t core_version,
const struct lvp_instance_extension_table *instance);
const struct vk_instance_extension_table *instance);
bool lvp_device_entrypoint_is_enabled(int index, uint32_t core_version,
const struct lvp_instance_extension_table *instance,
const struct lvp_device_extension_table *device);
void *lvp_lookup_entrypoint(const char *name);
const struct vk_instance_extension_table *instance,
const struct vk_device_extension_table *device);
#define LVP_DEFINE_HANDLE_CASTS(__lvp_type, __VkType) \
\
@@ -211,7 +209,6 @@ struct lvp_physical_device {
uint32_t max_images;
struct wsi_device wsi_device;
struct lvp_device_extension_table supported_extensions;
};
struct lvp_instance {
@@ -225,17 +222,12 @@ struct lvp_instance {
struct pipe_loader_device *devs;
int num_devices;
struct lvp_instance_extension_table enabled_extensions;
struct lvp_instance_dispatch_table dispatch;
struct lvp_physical_device_dispatch_table physical_device_dispatch;
struct lvp_device_dispatch_table device_dispatch;
};
VkResult lvp_init_wsi(struct lvp_physical_device *physical_device);
void lvp_finish_wsi(struct lvp_physical_device *physical_device);
bool lvp_instance_extension_supported(const char *name);
extern const struct vk_instance_extension_table lvp_instance_extensions_supported;
uint32_t lvp_physical_device_api_version(struct lvp_physical_device *dev);
bool lvp_physical_device_extension_supported(struct lvp_physical_device *dev,
const char *name);
@@ -275,8 +267,6 @@ struct lvp_device {
struct pipe_screen *pscreen;
mtx_t fence_lock;
struct lvp_device_extension_table enabled_extensions;
struct lvp_device_dispatch_table dispatch;
};
void lvp_device_get_cache_uuid(void *uuid);
src/gallium/frontends/lavapipe/lvp_wsi.c
+12 -1
View File
@@ -26,7 +26,18 @@
static PFN_vkVoidFunction
lvp_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName)
{
return lvp_lookup_entrypoint(pName);
LVP_FROM_HANDLE(lvp_physical_device, pdevice, physicalDevice);
PFN_vkVoidFunction func;
func = vk_instance_dispatch_table_get(&pdevice->vk.instance->dispatch_table, pName);
if (func != NULL)
return func;
func = vk_physical_device_dispatch_table_get(&pdevice->vk.dispatch_table, pName);
if (func != NULL)
return func;
return vk_device_dispatch_table_get(&vk_device_trampolines, pName);
}
VkResult
src/gallium/frontends/lavapipe/meson.build
+4 -5
View File
@@ -1,13 +1,12 @@
lvp_entrypoints = custom_target(
'lvp_entrypoints.[ch]',
input : ['lvp_entrypoints_gen.py', vk_api_xml],
'lvp_entrypoints',
input : [vk_entrypoints_gen, vk_api_xml],
output : ['lvp_entrypoints.h', 'lvp_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', 'lvp',
],
depend_files : files('lvp_extensions.py'),
)
lvp_extensions_c = custom_target(