fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-04 16:18:06 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

zink: generate extension infrastructure using a python script

Browse source 
Reviewed-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Reviewed-by: Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/6789>
This commit is contained in:
Hoe Hao Cheng 2020-09-19 04:39:19 +08:00 • committed by Marge Bot
parent 39098a2053
commit f1432fd3e2
1 changed files with 299 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

299
src/gallium/drivers/zink/zink_device_info.py Normal file
View file

@ -0,0 +1,299 @@
# Copyright © 2020 Hoe Hao Cheng
#
# 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.
#
# Authors:
# Hoe Hao Cheng <haochengho12907@gmail.com>
#
from mako.template import Template
from os import path
import re
import sys
# constructor: Extensions(name, alias="", required=False, properties=False, feature=None)
# The attributes:
# - required: the generated code debug_prints "ZINK: {name} required!" and
# returns NULL if the extension is unavailable.
#
# - properties: enable the detection of extension properties in a physical
# device in the generated code using vkGetPhysicalDeviceProperties2(),
# and store the returned properties struct inside
# `zink_device_info.{alias}_props`.
# Example: the properties for `VK_EXT_transform_feedback`, is stored in
# `VkPhysicalDeviceTransformFeedbackPropertiesEXT tf_props`.
#
# - feature: enable the fine-grained detection of extension features in a
# device. Similar to `properties`, this stores the features
# struct inside `zink_device_info.{alias}_feats`.
# It sets `zink_device_info.have_{name} = true` only if
# `{alias}_feats.{feature}` is true.
# If feature is None, `have_{extension_name}` is true when the extensions
# given by vkEnumerateDeviceExtensionProperties() include the extension.
# Furthermore, `zink_device_info.{extension_alias}_feats` is unavailable.
def EXTENSIONS():
return [
Extension("VK_KHR_maintenance1", required=True),
Extension("VK_KHR_external_memory", required=True),
Extension("VK_KHR_external_memory_fd"),
Extension("VK_EXT_conditional_rendering", alias="cond_render", feature="conditionalRendering"),
Extension("VK_EXT_transform_feedback", alias="tf", properties=True, feature="transformFeedback"),
Extension("VK_EXT_index_type_uint8", alias="index_uint8", feature="indexTypeUint8"),
Extension("VK_EXT_robustness2", alias="rb2", properties=True, feature="nullDescriptor"),
Extension("VK_EXT_vertex_attribute_divisor", alias="vdiv", properties=True, feature="vertexAttributeInstanceRateDivisor"),
Extension("VK_EXT_calibrated_timestamps"),
]
# There exists some inconsistencies regarding the enum constants, fix them.
# This is basically generated_code.replace(key, value).
def REPLACEMENTS():
return {
"ROBUSTNESS2": "ROBUSTNESS_2"
}
header_code = """
#ifndef ZINK_DEVICE_INFO_H
#define ZINK_DEVICE_INFO_H
#include "util/u_memory.h"
#include <vulkan/vulkan.h>
struct zink_screen;
struct zink_device_info {
%for ext in extensions:
bool have_${ext.name_with_vendor()};
%endfor
VkPhysicalDeviceFeatures2 feats;
VkPhysicalDeviceProperties props;
VkPhysicalDeviceMemoryProperties mem_props;
%for ext in extensions:
%if ext.feature_field is not None:
VkPhysicalDevice${ext.name_in_camel_case()}Features${ext.vendor()} ${ext.field("feats")};
%endif
%if ext.has_properties:
VkPhysicalDevice${ext.name_in_camel_case()}Properties${ext.vendor()} ${ext.field("props")};
%endif
%endfor
const char *extensions[${len(extensions)}];
uint32_t num_extensions;
};
bool
zink_get_physical_device_info(struct zink_screen *screen);
#endif
"""
impl_code = """
#include "zink_device_info.h"
#include "zink_screen.h"
bool
zink_get_physical_device_info(struct zink_screen *screen)
{
struct zink_device_info *info = &screen->info;
%for ext in extensions:
bool support_${ext.name_with_vendor()} = false;
%endfor
uint32_t num_extensions = 0;
vkGetPhysicalDeviceMemoryProperties(screen->pdev, &info->mem_props);
// enumerate device supported extensions
if (vkEnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, NULL) == VK_SUCCESS) {
if (num_extensions > 0) {
VkExtensionProperties *extensions = MALLOC(sizeof(VkExtensionProperties) * num_extensions);
if (!extensions) goto fail;
vkEnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, extensions);
for (uint32_t i = 0; i < num_extensions; ++i) {
%for ext in extensions:
if (!strcmp(extensions[i].extensionName, "${ext.name}")) {
support_${ext.name_with_vendor()} = true;
}
%endfor
}
FREE(extensions);
}
}
// check for device extension features
info->feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
%for ext in extensions:
%if ext.feature_field is not None:
if (support_${ext.name_with_vendor()}) {
info->${ext.field("feats")}.sType = ${ext.stype("FEATURES")};
info->${ext.field("feats")}.pNext = info->feats.pNext;
info->feats.pNext = &info->${ext.field("feats")};
}
%endif
%endfor
vkGetPhysicalDeviceFeatures2(screen->pdev, &info->feats);
%for ext in extensions:
%if ext.feature_field is None:
info->have_${ext.name_with_vendor()} = support_${ext.name_with_vendor()};
%else:
if (support_${ext.name_with_vendor()} && info->${ext.field("feats")}.${ext.feature_field}) {
info->have_${ext.name_with_vendor()} = true;
}
%endif
%endfor
// check for device properties
VkPhysicalDeviceProperties2 props = {};
props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
%for ext in extensions:
%if ext.has_properties:
if (info->have_${ext.name_with_vendor()}) {
info->${ext.field("props")}.sType = ${ext.stype("PROPERTIES")};
info->${ext.field("props")}.pNext = props.pNext;
props.pNext = &info->${ext.field("props")};
}
%endif
%endfor
vkGetPhysicalDeviceProperties2(screen->pdev, &props);
memcpy(&info->props, &props.properties, sizeof(info->props));
// generate extension list
num_extensions = 0;
%for ext in extensions:
if (info->have_${ext.name_with_vendor()}) {
info->extensions[num_extensions++] = "${ext.name}";
%if ext.is_required:
} else {
debug_printf("ZINK: ${ext.name} required!\\n");
goto fail;
%endif
}
%endfor
info->num_extensions = num_extensions;
return true;
fail:
return false;
}
"""
class Extension:
name : str = None
alias : str = None
is_required : bool = False
has_properties : bool = False
feature_field : str = None
def __init__(self, name, alias="", required=False, properties=False, feature=None):
self.name = name
self.alias = alias
self.is_required = required
self.has_properties = properties
self.feature_field = feature
if alias == "" and (properties == True or feature is not None):
raise RuntimeError("alias must be available when properties/feature is used")
# e.g.: "VK_EXT_robustness2" -> "robustness2"
def pure_name(self):
return '_'.join(self.name.split('_')[2:])
# e.g.: "VK_EXT_robustness2" -> "EXT_robustness2"
def name_with_vendor(self):
return self.name[3:]
# e.g.: "VK_EXT_robustness2" -> "Robustness2"
def name_in_camel_case(self):
return "".join([x.title() for x in self.name.split('_')[2:]])
# e.g.: "VK_EXT_robustness2" -> "VK_EXT_ROBUSTNESS2_EXTENSION_NAME"
# do note that inconsistencies exist, i.e. we have
# VK_EXT_ROBUSTNESS_2_EXTENSION_NAME defined in the headers, but then
# we also have VK_KHR_MAINTENANCE1_EXTENSION_NAME
def extension_name(self):
return self.name.upper() + "_EXTENSION_NAME"
# generate a C string literal for the extension
def extension_name_literal(self):
return '"' + self.name + '"'
# get the field in zink_device_info that refers to the extension's
# feature/properties struct
# e.g. rb2_<suffix> for VK_EXT_robustness2
def field(self, suffix: str):
return self.alias + '_' + suffix
# the sType of the extension's struct
# e.g. VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT
# for VK_EXT_transform_feedback and struct="FEATURES"
def stype(self, struct: str):
return ("VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_"
+ self.pure_name().upper()
+ '_' + struct + '_'
+ self.vendor())
# e.g. EXT in VK_EXT_robustness2
def vendor(self):
return self.name.split('_')[1]
def replace_code(code: str, replacement: dict):
for (k, v) in replacement.items():
code = code.replace(k, v)
return code
if __name__ == "__main__":
try:
header_path = sys.argv[1]
impl_path = sys.argv[2]
header_path = path.abspath(header_path)
impl_path = path.abspath(impl_path)
except:
print("usage: %s <path to .h> <path to .c>" % sys.argv[0])
exit(1)
extensions = EXTENSIONS()
replacement = REPLACEMENTS()
with open(header_path, "w") as header_file:
header = Template(header_code).render(extensions=extensions).strip()
header = replace_code(header, replacement)
print(header, file=header_file)
with open(impl_path, "w") as impl_file:
impl = Template(impl_code).render(extensions=extensions).strip()
impl = replace_code(impl, replacement)
print(impl, file=impl_file)