dawn-cmake/generator/dawn_gpu_info_generator.py

229 lines
8.1 KiB
Python
Raw Normal View History

#!/usr/bin/env python3
# Copyright 2022 The Dawn Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json, os, sys
from collections import namedtuple
from generator_lib import Generator, run_generator, FileRender
def parse_mask(mask):
if mask:
return int(mask, 0)
return 0xffffffff
class Name:
def __init__(self, name):
self.name = name
self.chunks = name.split(' ')
def get(self):
return self.name
def CamelChunk(self, chunk):
return chunk[0].upper() + chunk[1:]
def canonical_case(self):
return (' '.join(self.chunks)).lower()
def concatcase(self):
return ''.join(self.chunks)
def camelCase(self):
return self.chunks[0] + ''.join(
[self.CamelChunk(chunk) for chunk in self.chunks[1:]])
def CamelCase(self):
return ''.join([self.CamelChunk(chunk) for chunk in self.chunks])
def SNAKE_CASE(self):
return '_'.join([chunk.upper() for chunk in self.chunks])
def snake_case(self):
return '_'.join(self.chunks)
def js_enum_case(self):
result = self.chunks[0].lower()
for chunk in self.chunks[1:]:
if not result[-1].isdigit():
result += '-'
result += chunk.lower()
return result
class Architecture:
def __init__(self, name, json_data, mask):
self.name = Name(name)
self.devices = []
mask_num = parse_mask(mask)
for device in json_data:
device_num = int(device, 0)
# Don't allow duplicate entries
assert device not in self.devices, 'Architecture "{}" contained duplicate deviceID "{}"'.format(
self.name.get(), device)
# Ensure that all device IDs don't contain bits outside the mask
assert device_num & mask_num == device_num, 'Architecture "{}" contained deviceID "{}" which doesn\'t match the given mask of "{}"'.format(
self.name.get(), device, mask)
self.devices.append(device)
class DeviceSet:
def __init__(self, json_data):
self.mask = None
self.internal = False
if 'mask' in json_data:
self.mask = json_data['mask']
if 'internal' in json_data:
self.internal = json_data['internal']
self.architectures = []
if 'architecture' in json_data:
for (arch_name, arch_data) in json_data['architecture'].items():
# Skip any entries that start with an underscore. Used for comments.
if arch_name[0] == '_':
continue
architecture = Architecture(arch_name, arch_data, self.mask)
# Validate that deviceIDs are only allowed to be in one Architecture at a time
for other_architecture in self.architectures:
for device in architecture.devices:
assert device not in other_architecture.devices, 'Architectures "{}" and "{}" both contain deviceID "{}"'.format(
architecture.name.get(),
other_architecture.name.get(), device)
self.architectures.append(architecture)
def validate_devices(self, other_devices, other_mask):
combined_mask = parse_mask(self.mask) & parse_mask(other_mask)
for other_device in other_devices:
other_device_num = int(other_device, 0) & combined_mask
for architecture in self.architectures:
for device in architecture.devices:
device_num = int(device, 0) & combined_mask
assert device_num != other_device_num, 'DeviceID "{}" & mask "{}" conflicts with deviceId "{}" & mask "{}" in architecture "{}"'.format(
other_device, other_mask, device, self.mask,
architecture.name.get())
def maskDeviceId(self):
if not self.mask:
return ''
return ' & ' + self.mask
class Vendor:
def __init__(self, name, json_data):
self.name = Name(name)
self.id = json_data['id']
architecture_dict = {}
internal_architecture_dict = {}
self.device_sets = []
if 'devices' in json_data:
for device_data in json_data['devices']:
device_set = DeviceSet(device_data)
for architecture in device_set.architectures:
# Validate that deviceIDs are unique across device sets
for other_device_set in self.device_sets:
# Only validate device IDs between internal and public device sets.
if other_device_set.internal == device_set.internal:
assert device_set.mask != other_device_set.mask, 'Vendor "{}" contained duplicate device masks "{}"'.format(
self.name.get(), device_set.mask)
other_device_set.validate_devices(
architecture.devices, device_set.mask)
# Validate that architecture names are unique between internal and public device sets.
else:
for other_architecture in other_device_set.architectures:
assert architecture.name.canonical_case(
) != other_architecture.name.canonical_case(
), '"{}" is defined as both an internal and public architecture'.format(
architecture.name.get())
if device_set.internal:
internal_architecture_dict[
architecture.name.canonical_case(
)] = architecture.name
else:
architecture_dict[architecture.name.canonical_case(
)] = architecture.name
self.device_sets.append(device_set)
# List of unique architecture names under this vendor
self.architecture_names = architecture_dict.values()
self.internal_architecture_names = internal_architecture_dict.values()
def parse_json(json):
vendors = []
internal_architecture_count = 0
for (vendor_name, vendor_data) in json['vendors'].items():
# Skip vendors that have a leading underscore. Those are intended to be "comments".
if vendor_name[0] == '_':
continue
vendor = Vendor(vendor_name, vendor_data)
vendors.append(vendor)
internal_architecture_count += len(vendor.internal_architecture_names)
return {
'vendors': vendors,
'has_internal': internal_architecture_count > 0
}
class DawnGpuInfoGenerator(Generator):
def get_description(self):
return "Generates GPU Info Dawn code."
def add_commandline_arguments(self, parser):
parser.add_argument('--gpu-info-json',
required=True,
type=str,
help='The GPU Info JSON definition to use.')
def get_dependencies(self, args):
return [os.path.abspath(args.gpu_info_json)]
def get_file_renders(self, args):
with open(args.gpu_info_json) as f:
loaded_json = json.loads(f.read())
params = parse_json(loaded_json)
return [
FileRender("dawn/common/GPUInfo.h",
"src/dawn/common/GPUInfo_autogen.h", [params]),
FileRender("dawn/common/GPUInfo.cpp",
"src/dawn/common/GPUInfo_autogen.cpp", [params]),
]
if __name__ == "__main__":
sys.exit(run_generator(DawnGpuInfoGenerator()))