radv_extensions.py 15.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
COPYRIGHT = """\
/*
 * Copyright 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, sub license, 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 NON-INFRINGEMENT.
 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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 re
import xml.etree.cElementTree as et

from mako.template import Template

34
MAX_API_VERSION = '1.1.90'
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

class Extension:
    def __init__(self, name, ext_version, enable):
        self.name = name
        self.ext_version = int(ext_version)
        if enable is True:
            self.enable = 'true';
        elif enable is False:
            self.enable = 'false';
        else:
            self.enable = enable;

# On Android, we disable all surface and swapchain extensions. Android's Vulkan
# loader implements VK_KHR_surface and VK_KHR_swapchain, and applications
# cannot access the driver's implementation. Moreoever, if the driver exposes
# the those extension strings, then tests dEQP-VK.api.info.instance.extensions
# and dEQP-VK.api.info.device fail due to the duplicated strings.
EXTENSIONS = [
53
    Extension('VK_ANDROID_native_buffer',                 5, 'ANDROID && device->rad_info.has_syncobj_wait_for_submit'),
54
    Extension('VK_KHR_16bit_storage',                     1, True),
55
    Extension('VK_KHR_bind_memory2',                      1, True),
56
    Extension('VK_KHR_create_renderpass2',                1, True),
57
58
    Extension('VK_KHR_dedicated_allocation',              1, True),
    Extension('VK_KHR_descriptor_update_template',        1, True),
59
60
    Extension('VK_KHR_device_group',                      1, True),
    Extension('VK_KHR_device_group_creation',             1, True),
61
    Extension('VK_KHR_draw_indirect_count',               1, True),
62
    Extension('VK_KHR_driver_properties',                 1, True),
63
    Extension('VK_KHR_external_fence',                    1, 'device->rad_info.has_syncobj_wait_for_submit'),
64
    Extension('VK_KHR_external_fence_capabilities',       1, True),
65
    Extension('VK_KHR_external_fence_fd',                 1, 'device->rad_info.has_syncobj_wait_for_submit'),
66
67
68
69
70
71
    Extension('VK_KHR_external_memory',                   1, True),
    Extension('VK_KHR_external_memory_capabilities',      1, True),
    Extension('VK_KHR_external_memory_fd',                1, True),
    Extension('VK_KHR_external_semaphore',                1, 'device->rad_info.has_syncobj'),
    Extension('VK_KHR_external_semaphore_capabilities',   1, True),
    Extension('VK_KHR_external_semaphore_fd',             1, 'device->rad_info.has_syncobj'),
72
    Extension('VK_KHR_get_display_properties2',           1, 'VK_USE_PLATFORM_DISPLAY_KHR'),
73
74
    Extension('VK_KHR_get_memory_requirements2',          1, True),
    Extension('VK_KHR_get_physical_device_properties2',   1, True),
75
    Extension('VK_KHR_get_surface_capabilities2',         1, 'RADV_HAS_SURFACE'),
76
    Extension('VK_KHR_image_format_list',                 1, True),
77
    Extension('VK_KHR_incremental_present',               1, 'RADV_HAS_SURFACE'),
78
79
    Extension('VK_KHR_maintenance1',                      1, True),
    Extension('VK_KHR_maintenance2',                      1, True),
80
    Extension('VK_KHR_maintenance3',                      1, True),
81
82
83
    Extension('VK_KHR_push_descriptor',                   1, True),
    Extension('VK_KHR_relaxed_block_layout',              1, True),
    Extension('VK_KHR_sampler_mirror_clamp_to_edge',      1, True),
84
    Extension('VK_KHR_sampler_ycbcr_conversion',          1, True),
85
    Extension('VK_KHR_shader_atomic_int64',               1, False),
86
    Extension('VK_KHR_shader_draw_parameters',            1, True),
87
    Extension('VK_KHR_shader_float16_int8',               1, True),
88
89
    Extension('VK_KHR_storage_buffer_storage_class',      1, True),
    Extension('VK_KHR_surface',                          25, 'RADV_HAS_SURFACE'),
90
    Extension('VK_KHR_surface_protected_capabilities',    1, 'RADV_HAS_SURFACE'),
91
92
93
94
95
    Extension('VK_KHR_swapchain',                        68, 'RADV_HAS_SURFACE'),
    Extension('VK_KHR_variable_pointers',                 1, True),
    Extension('VK_KHR_wayland_surface',                   6, 'VK_USE_PLATFORM_WAYLAND_KHR'),
    Extension('VK_KHR_xcb_surface',                       6, 'VK_USE_PLATFORM_XCB_KHR'),
    Extension('VK_KHR_xlib_surface',                      6, 'VK_USE_PLATFORM_XLIB_KHR'),
96
    Extension('VK_KHR_multiview',                         1, True),
97
    Extension('VK_KHR_display',                          23, 'VK_USE_PLATFORM_DISPLAY_KHR'),
Rhys Perry's avatar
Rhys Perry committed
98
    Extension('VK_KHR_8bit_storage',                      1, 'device->rad_info.chip_class >= VI'),
99
    Extension('VK_EXT_direct_mode_display',               1, 'VK_USE_PLATFORM_DISPLAY_KHR'),
100
    Extension('VK_EXT_acquire_xlib_display',              1, 'VK_USE_PLATFORM_XLIB_XRANDR_EXT'),
101
    Extension('VK_EXT_buffer_device_address',             1, True),
102
    Extension('VK_EXT_calibrated_timestamps',             1, True),
103
    Extension('VK_EXT_conditional_rendering',             1, True),
104
    Extension('VK_EXT_conservative_rasterization',        1, 'device->rad_info.chip_class >= GFX9'),
105
    Extension('VK_EXT_display_surface_counter',           1, 'VK_USE_PLATFORM_DISPLAY_KHR'),
106
    Extension('VK_EXT_display_control',                   1, 'VK_USE_PLATFORM_DISPLAY_KHR'),
107
    Extension('VK_EXT_debug_report',                      9, True),
108
    Extension('VK_EXT_depth_clip_enable',                 1, True),
109
    Extension('VK_EXT_depth_range_unrestricted',          1, True),
110
    Extension('VK_EXT_descriptor_indexing',               2, True),
111
    Extension('VK_EXT_discard_rectangles',                1, True),
112
    Extension('VK_EXT_external_memory_dma_buf',           1, True),
113
    Extension('VK_EXT_external_memory_host',              1, 'device->rad_info.has_userptr'),
114
    Extension('VK_EXT_global_priority',                   1, 'device->rad_info.has_ctx_priority'),
115
    Extension('VK_EXT_host_query_reset',                  1, True),
116
    Extension('VK_EXT_inline_uniform_block',              1, True),
117
    Extension('VK_EXT_memory_budget',                     1, True),
118
    Extension('VK_EXT_memory_priority',                   1, True),
119
    Extension('VK_EXT_pci_bus_info',                      2, True),
120
    Extension('VK_EXT_pipeline_creation_feedback',        1, True),
121
    Extension('VK_EXT_sampler_filter_minmax',             1, 'device->rad_info.chip_class >= CIK'),
122
    Extension('VK_EXT_scalar_block_layout',               1, 'device->rad_info.chip_class >= CIK'),
123
    Extension('VK_EXT_shader_viewport_index_layer',       1, True),
124
    Extension('VK_EXT_shader_stencil_export',             1, True),
125
    Extension('VK_EXT_transform_feedback',                1, True),
126
    Extension('VK_EXT_vertex_attribute_divisor',          3, True),
127
    Extension('VK_EXT_ycbcr_image_arrays',                1, True),
128
    Extension('VK_AMD_draw_indirect_count',               1, True),
129
    Extension('VK_AMD_gcn_shader',                        1, True),
130
    Extension('VK_AMD_gpu_shader_half_float',             1, 'device->rad_info.chip_class >= VI && HAVE_LLVM >= 0x0800'),
131
    Extension('VK_AMD_gpu_shader_int16',                  1, 'device->rad_info.chip_class >= VI'),
132
    Extension('VK_AMD_rasterization_order',               1, 'device->has_out_of_order_rast'),
133
    Extension('VK_AMD_shader_core_properties',            1, True),
134
    Extension('VK_AMD_shader_info',                       1, True),
135
    Extension('VK_AMD_shader_trinary_minmax',             1, True),
136
137
    Extension('VK_GOOGLE_decorate_string',                1, True),
    Extension('VK_GOOGLE_hlsl_functionality1',            1, True),
138
    Extension('VK_NV_compute_shader_derivatives',         1, 'device->rad_info.chip_class >= VI'),
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
]

class VkVersion:
    def __init__(self, string):
        split = string.split('.')
        self.major = int(split[0])
        self.minor = int(split[1])
        if len(split) > 2:
            assert len(split) == 3
            self.patch = int(split[2])
        else:
            self.patch = None

        # Sanity check.  The range bits are required by the definition of the
        # VK_MAKE_VERSION macro
        assert self.major < 1024 and self.minor < 1024
        assert self.patch is None or self.patch < 4096
        assert(str(self) == string)

    def __str__(self):
        ver_list = [str(self.major), str(self.minor)]
        if self.patch is not None:
            ver_list.append(str(self.patch))
        return '.'.join(ver_list)

    def c_vk_version(self):
165
166
        patch = self.patch if self.patch is not None else 0
        ver_list = [str(self.major), str(self.minor), str(patch)]
167
168
169
170
171
172
173
        return 'VK_MAKE_VERSION(' + ', '.join(ver_list) + ')'

    def __int_ver(self):
        # This is just an expansion of VK_VERSION
        patch = self.patch if self.patch is not None else 0
        return (self.major << 22) | (self.minor << 12) | patch

Mathieu Bridon's avatar
Mathieu Bridon committed
174
    def __gt__(self, other):
175
176
177
178
179
180
        # If only one of them has a patch version, "ignore" it by making
        # other's patch version match self.
        if (self.patch is None) != (other.patch is None):
            other = copy.copy(other)
            other.patch = self.patch

Mathieu Bridon's avatar
Mathieu Bridon committed
181
182
        return self.__int_ver() > other.__int_ver()

183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

MAX_API_VERSION = VkVersion(MAX_API_VERSION)

def _init_exts_from_xml(xml):
    """ Walk the Vulkan XML and fill out extra extension information. """

    xml = et.parse(xml)

    ext_name_map = {}
    for ext in EXTENSIONS:
        ext_name_map[ext.name] = ext

    for ext_elem in xml.findall('.extensions/extension'):
        ext_name = ext_elem.attrib['name']
        if ext_name not in ext_name_map:
            continue

        ext = ext_name_map[ext_name]
201
        ext.type = ext_elem.attrib['type']
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
        ext.promotedto = ext_elem.attrib.get('promotedto', None)
        try:
            ext.requires = ext_elem.attrib['requires'].split(',')
        except KeyError:
            ext.requires = []

    def extra_deps(ext):
        if ext.type == 'instance':
            check = 'instance->enabled_extensions.{}'.format(ext.name[3:])
            if ext.promotedto is not None:
                # the xml contains values like VK_VERSION_1_1, but we need to
                # translate them to VK_API_VERSION_1_1 for the apiVersion check
                api_ver = ext.promotedto.replace('VK_VER', 'VK_API_VER')
                check = '({} || instance->apiVersion >= {})'.format(check, api_ver)
            return set([check])

        deps = set()
        for dep in ext.requires:
            deps |= extra_deps(ext_name_map[dep])

        return deps

    for ext in EXTENSIONS:
        if ext.type == 'device':
            for dep in extra_deps(ext):
                ext.enable += ' && ' + dep
228

229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
_TEMPLATE_H = Template(COPYRIGHT + """
#ifndef RADV_EXTENSIONS_H
#define RADV_EXTENSIONS_H

enum {
   RADV_INSTANCE_EXTENSION_COUNT = ${len(instance_extensions)},
   RADV_DEVICE_EXTENSION_COUNT = ${len(device_extensions)},
};

struct radv_instance_extension_table {
   union {
      bool extensions[RADV_INSTANCE_EXTENSION_COUNT];
      struct {
%for ext in instance_extensions:
        bool ${ext.name[3:]};
%endfor
      };
   };
};

struct radv_device_extension_table {
   union {
      bool extensions[RADV_DEVICE_EXTENSION_COUNT];
      struct {
%for ext in device_extensions:
        bool ${ext.name[3:]};
%endfor
      };
   };
};

260
261
262
extern const VkExtensionProperties radv_instance_extensions[RADV_INSTANCE_EXTENSION_COUNT];
extern const VkExtensionProperties radv_device_extensions[RADV_DEVICE_EXTENSION_COUNT];
extern const struct radv_instance_extension_table radv_supported_instance_extensions;
263
264
265
266
267
268
269
270
271
272


struct radv_physical_device;

void radv_fill_device_extension_table(const struct radv_physical_device *device,
                                      struct radv_device_extension_table* table);
#endif
""")

_TEMPLATE_C = Template(COPYRIGHT + """
273
274
275
276
277
#include "radv_private.h"

#include "vk_util.h"

/* Convert the VK_USE_PLATFORM_* defines to booleans */
278
279
280
281
%for platform in ['ANDROID_KHR', 'WAYLAND_KHR', 'XCB_KHR', 'XLIB_KHR', 'DISPLAY_KHR', 'XLIB_XRANDR_EXT']:
#ifdef VK_USE_PLATFORM_${platform}
#   undef VK_USE_PLATFORM_${platform}
#   define VK_USE_PLATFORM_${platform} true
282
#else
283
#   define VK_USE_PLATFORM_${platform} false
284
285
286
287
288
289
290
291
292
293
294
295
296
#endif
%endfor

/* And ANDROID too */
#ifdef ANDROID
#   undef ANDROID
#   define ANDROID true
#else
#   define ANDROID false
#endif

#define RADV_HAS_SURFACE (VK_USE_PLATFORM_WAYLAND_KHR || \\
                         VK_USE_PLATFORM_XCB_KHR || \\
297
298
299
                         VK_USE_PLATFORM_XLIB_KHR || \\
                         VK_USE_PLATFORM_DISPLAY_KHR)

300

301
const VkExtensionProperties radv_instance_extensions[RADV_INSTANCE_EXTENSION_COUNT] = {
302
%for ext in instance_extensions:
303
   {"${ext.name}", ${ext.ext_version}},
304
%endfor
305
};
306

307
308
309
310
311
const VkExtensionProperties radv_device_extensions[RADV_DEVICE_EXTENSION_COUNT] = {
%for ext in device_extensions:
   {"${ext.name}", ${ext.ext_version}},
%endfor
};
312

313
const struct radv_instance_extension_table radv_supported_instance_extensions = {
314
%for ext in instance_extensions:
315
   .${ext.name[3:]} = ${ext.enable},
316
%endfor
317
};
318

319
320
void radv_fill_device_extension_table(const struct radv_physical_device *device,
                                      struct radv_device_extension_table* table)
321
{
322
   const struct radv_instance *instance = device->instance;
323
%for ext in device_extensions:
324
   table->${ext.name[3:]} = ${ext.enable};
325
326
327
%endfor
}

328
329
330
331
332
333
334
VkResult radv_EnumerateInstanceVersion(
    uint32_t*                                   pApiVersion)
{
    *pApiVersion = ${MAX_API_VERSION.c_vk_version()};
    return VK_SUCCESS;
}

335
336
uint32_t
radv_physical_device_api_version(struct radv_physical_device *dev)
337
{
338
339
    uint32_t override = vk_get_version_override();
    uint32_t version = VK_MAKE_VERSION(1, 0, 68);
340
    if (dev->rad_info.has_syncobj_wait_for_submit)
341
342
343
        version = ${MAX_API_VERSION.c_vk_version()};

    return override ? MIN2(override, version) : version;
344
345
346
347
348
}
""")

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
349
350
    parser.add_argument('--out-c', help='Output C file.', required=True)
    parser.add_argument('--out-h', help='Output H file.', required=True)
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
    parser.add_argument('--xml',
                        help='Vulkan API XML file.',
                        required=True,
                        action='append',
                        dest='xml_files')
    args = parser.parse_args()

    for filename in args.xml_files:
        _init_exts_from_xml(filename)

    for ext in EXTENSIONS:
        assert ext.type == 'instance' or ext.type == 'device'

    template_env = {
        'MAX_API_VERSION': MAX_API_VERSION,
        'instance_extensions': [e for e in EXTENSIONS if e.type == 'instance'],
        'device_extensions': [e for e in EXTENSIONS if e.type == 'device'],
    }

370
371
372
373
    with open(args.out_c, 'w') as f:
        f.write(_TEMPLATE_C.render(**template_env))
    with open(args.out_h, 'w') as f:
        f.write(_TEMPLATE_H.render(**template_env))