From 775df73e1d1a4f216b531e9f11c109fe32266801 Mon Sep 17 00:00:00 2001 From: Mark Lobodzinski Date: Fri, 18 Nov 2016 14:44:37 -0700 Subject: build: Move codegen scripts into scripts dir - Set SCRIPTS_DIR in root CMakeLists.txt - Update android-generate.bat and android-generate.sh - Updated layer/loader/tests CMakeLists.txt files for new path - Updated test layer doc scripts for new location Change-Id: I2d519ec40883ebeec4e9daab8641ad65515bb08c --- scripts/vk_layer_documentation_generate.py | 406 +++++++++++++++++++++++++++++ 1 file changed, 406 insertions(+) create mode 100755 scripts/vk_layer_documentation_generate.py (limited to 'scripts/vk_layer_documentation_generate.py') diff --git a/scripts/vk_layer_documentation_generate.py b/scripts/vk_layer_documentation_generate.py new file mode 100755 index 00000000..25f572b6 --- /dev/null +++ b/scripts/vk_layer_documentation_generate.py @@ -0,0 +1,406 @@ +#!/usr/bin/env python3 +# Copyright (c) 2015-2016 The Khronos Group Inc. +# Copyright (c) 2015-2016 Valve Corporation +# Copyright (c) 2015-2016 LunarG, Inc. +# Copyright (c) 2015-2016 Google Inc. +# +# 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. +# +# Author: Tobin Ehlis + +import argparse +import os +import sys +import vulkan +import platform + +# vk_layer_documentation_generate.py overview +# This script is intended to generate documentation based on vulkan layers +# It parses known validation layer headers for details of the validation checks +# It parses validation layer source files for specific code where checks are implemented +# structs in a human-readable txt format, as well as utility functions +# to print enum values as strings + +# NOTE : Initially the script is performing validation of a hand-written document +# Right now it does 3 checks: +# 1. Verify ENUM codes declared in source are documented +# 2. Verify ENUM codes in document are declared in source +# 3. Verify API function names in document are in the actual API header (vulkan.py) +# Currently script will flag errors in all of these cases + +# TODO : Need a formal specification of the syntax for doc generation +# Initially, these are the basics: +# 1. Validation checks have unique ENUM values defined in validation layer header +# 2. ENUM includes comments for 1-line overview of check and more detailed description +# 3. Actual code implementing checks includes ENUM value in callback +# 4. Code to test checks should include reference to ENUM + + +# TODO : Need list of known validation layers to use as default input +# Just a couple of flat lists right now, but may need to make this input file +# or at least a more dynamic data structure +layer_inputs = { 'draw_state' : {'header' : 'layers/core_validation_error_enums.h', + 'source' : 'layers/core_validation.cpp', + 'generated' : False, + 'error_enum' : 'DRAW_STATE_ERROR'}, + 'shader_checker' : {'header' : 'layers/core_validation_error_enums.h', + 'source' : 'layers/core_validation.cpp', + 'generated' : False, + 'error_enum' : 'SHADER_CHECKER_ERROR'}, + 'mem_tracker' : {'header' : 'layers/core_validation_error_enums.h', + 'source' : 'layers/core_validation.cpp', + 'generated' : False, + 'error_enum' : 'MEM_TRACK_ERROR'}, + 'device_limits' : {'header' : 'layers/core_validation_error_enums.h', + 'source' : 'layers/core_validation.cpp', + 'generated' : False, + 'error_enum' : 'DEV_LIMITS_ERROR',}, + 'object_tracker' : {'header' : 'layers/object_tracker.h', + 'source' : 'layers/object_tracker.cpp', + 'generated' : False, + 'error_enum' : 'OBJECT_TRACK_ERROR',}, + 'threading' : {'header' : 'layers/threading.h', + 'source' : 'dbuild/layers/threading.cpp', + 'generated' : True, + 'error_enum' : 'THREADING_CHECKER_ERROR'}, + 'image' : {'header' : 'layers/image.h', + 'source' : 'layers/image.cpp', + 'generated' : False, + 'error_enum' : 'IMAGE_ERROR',}, + 'swapchain' : {'header' : 'layers/swapchain.h', + 'source' : 'layers/swapchain.cpp', + 'generated' : False, + 'error_enum' : 'SWAPCHAIN_ERROR',}, + 'parameter_validation' : {'header' : 'layers/parameter_validation_utils.h', + 'source' : 'layers/parameter_validation.cpp', + 'generated' : False, + 'error_enum' : 'ErrorCode',}, + } + +builtin_headers = [layer_inputs[ln]['header'] for ln in layer_inputs] +builtin_source = [layer_inputs[ln]['source'] for ln in layer_inputs] +builtin_tests = ['tests/layer_validation_tests.cpp', ] + +# List of extensions in layers that are included in documentation, but not in vulkan.py API set +layer_extension_functions = ['objTrackGetObjects', 'objTrackGetObjectsOfType'] + +def handle_args(): + parser = argparse.ArgumentParser(description='Generate layer documenation from source.') + parser.add_argument('--in_headers', required=False, default=builtin_headers, help='The input layer header files from which code will be generated.') + parser.add_argument('--in_source', required=False, default=builtin_source, help='The input layer source files from which code will be generated.') + parser.add_argument('--test_source', required=False, default=builtin_tests, help='The input test source files from which code will be generated.') + parser.add_argument('--layer_doc', required=False, default='layers/vk_validation_layer_details.md', help='Existing layer document to be validated against actual layers.') + parser.add_argument('--validate', action='store_true', default=False, help='Validate that there are no mismatches between layer documentation and source. This includes cross-checking the validation checks, and making sure documented Vulkan API calls exist.') + parser.add_argument('--print_structs', action='store_true', default=False, help='Primarily a debug option that prints out internal data structs used to generate layer docs.') + parser.add_argument('--print_doc_checks', action='store_true', default=False, help='Primarily a debug option that prints out all of the checks that are documented.') + return parser.parse_args() + +# Little helper class for coloring cmd line output +class bcolors: + + def __init__(self): + self.GREEN = '\033[0;32m' + self.RED = '\033[0;31m' + self.YELLOW = '\033[1;33m' + self.ENDC = '\033[0m' + if 'Linux' != platform.system(): + self.GREEN = '' + self.RED = '' + self.YELLOW = '' + self.ENDC = '' + + def green(self): + return self.GREEN + + def red(self): + return self.RED + + def yellow(self): + return self.YELLOW + + def endc(self): + return self.ENDC + +# Class to parse the validation layer test source and store testnames +class TestParser: + def __init__(self, test_file_list, test_group_name=['VkLayerTest', 'VkPositiveLayerTest', 'VkWsiEnabledLayerTest']): + self.test_files = test_file_list + self.tests_set = set() + self.test_trigger_txt_list = [] + for tg in test_group_name: + self.test_trigger_txt_list.append('TEST_F(%s' % tg) + #print('Test trigger test list: %s' % (self.test_trigger_txt_list)) + + # Parse test files into internal data struct + def parse(self): + # For each test file, parse test names into set + grab_next_line = False # handle testname on separate line than wildcard + for test_file in self.test_files: + with open(test_file) as tf: + for line in tf: + if True in [line.strip().startswith(comment) for comment in ['//', '/*']]: + continue + + if True in [ttt in line for ttt in self.test_trigger_txt_list]: + #print('Test wildcard in line: %s' % (line)) + testname = line.split(',')[-1] + testname = testname.strip().strip(' {)') + #print('Inserting test: "%s"' % (testname)) + if ('' == testname): + grab_next_line = True + continue + self.tests_set.add(testname) + if grab_next_line: # test name on its own line + grab_next_line = False + testname = testname.strip().strip(' {)') + self.tests_set.add(testname) + +# Class to parse the layer source code and store details in internal data structs +class LayerParser: + def __init__(self, header_file_list, source_file_list): + self.header_files = header_file_list + self.source_files = source_file_list + self.layer_dict = {} + self.api_dict = {} + + # Parse layer header files into internal dict data structs + def parse(self): + # For each header file, parse details into dicts + # TODO : Should have a global dict element to track overall list of checks + store_enum = False + for layer_name in layer_inputs: + hf = layer_inputs[layer_name]['header'] + self.layer_dict[layer_name] = {} # initialize a new dict for this layer + self.layer_dict[layer_name]['CHECKS'] = [] # enum of checks is stored in a list + #print('Parsing header file %s as layer name %s' % (hf, layer_name)) + with open(hf) as f: + for line in f: + if True in [line.strip().startswith(comment) for comment in ['//', '/*']]: + #print("Skipping comment line: %s" % line) + # For now skipping lines starting w/ comment, may use these to capture + # documentation in the future + continue + # Find enums + if store_enum: + if '}' in line: # we're done with enum definition + store_enum = False + continue + # grab the enum name as a unique check + if ',' in line: + # TODO : When documentation for a check is contained in the source, + # this is where we should also capture that documentation so that + # it can then be transformed into desired doc format + enum_name = line.split(',')[0].strip() + # Flag an error if we have already seen this enum + if enum_name in self.layer_dict[layer_name]['CHECKS']: + print('ERROR : % layer has duplicate error enum: %s' % (layer_name, enum_name)) + self.layer_dict[layer_name]['CHECKS'].append(enum_name) + # If the line includes 'enum' and the expected enum name, start capturing enums + if False not in [ex in line for ex in ['enum', layer_inputs[layer_name]['error_enum']]]: + store_enum = True + + # For each source file, parse into dicts + for sf in self.source_files: + #print('Parsing source file %s' % sf) + pass + # TODO : In the source file we want to see where checks actually occur + # Need to build function tree of checks so that we know all of the + # checks that occur under a top-level Vulkan API call + # Eventually in the validation we can flag ENUMs that aren't being + # used in the source, and we can document source code lines as well + # as Vulkan API calls where each specific ENUM check is made + + def print_structs(self): + print('This is where I print the data structs') + for layer in self.layer_dict: + print('Layer %s has %i checks:\n%s' % (layer, len(self.layer_dict[layer]['CHECKS'])-1, "\n\t".join(self.layer_dict[layer]['CHECKS']))) + +# Class to parse hand-written md layer documentation into a dict and then validate its contents +class LayerDoc: + def __init__(self, source_file): + self.layer_doc_filename = source_file + self.txt_color = bcolors() + # Main data struct to store info from layer doc + self.layer_doc_dict = {} + # Comprehensive list of all validation checks recorded in doc + self.enum_list = [] + + # Parse the contents of doc into data struct + def parse(self): + layer_name = 'INIT' + parse_layer_details = False + detail_trigger = '| Check | ' + parse_pending_work = False + pending_trigger = ' Pending Work' + parse_overview = False + overview_trigger = ' Overview' + enum_prefix = '' + + with open(self.layer_doc_filename) as f: + for line in f: + if parse_pending_work: + if '.' in line and line.strip()[0].isdigit(): + todo_item = line.split('.')[1].strip() + self.layer_doc_dict[layer_name]['pending'].append(todo_item) + if pending_trigger in line and '##' in line: + parse_layer_details = False + parse_pending_work = True + parse_overview = False + self.layer_doc_dict[layer_name]['pending'] = [] + if parse_layer_details: + # Grab details but skip the fomat line with a bunch of '-' chars + if '|' in line and line.count('-') < 20: + detail_sections = line.split('|') + #print("Details elements from line %s: %s" % (line, detail_sections)) + check_name = '%s%s' % (enum_prefix, detail_sections[3].strip()) + + self.enum_list.append(check_name) + self.layer_doc_dict[layer_name][check_name] = {} + self.layer_doc_dict[layer_name][check_name]['summary_txt'] = detail_sections[1].strip() + self.layer_doc_dict[layer_name][check_name]['details_txt'] = detail_sections[2].strip() + self.layer_doc_dict[layer_name][check_name]['api_list'] = detail_sections[4].split() + self.layer_doc_dict[layer_name][check_name]['tests'] = detail_sections[5].split() + self.layer_doc_dict[layer_name][check_name]['notes'] = detail_sections[6].strip() + # strip any unwanted commas from api and test names + self.layer_doc_dict[layer_name][check_name]['api_list'] = [a.strip(',') for a in self.layer_doc_dict[layer_name][check_name]['api_list']] + test_list = [a.strip(',') for a in self.layer_doc_dict[layer_name][check_name]['tests']] + self.layer_doc_dict[layer_name][check_name]['tests'] = [a.split('.')[-1] for a in test_list] + # Trigger details parsing when we have table header + if detail_trigger in line: + parse_layer_details = True + parse_pending_work = False + parse_overview = False + enum_txt = line.split('|')[3] + if '*' in enum_txt: + enum_prefix = enum_txt.split()[-1].strip('*').strip() + #print('prefix: %s' % enum_prefix) + if parse_overview: + self.layer_doc_dict[layer_name]['overview'] += line + if overview_trigger in line and '##' in line: + parse_layer_details = False + parse_pending_work = False + parse_overview = True + layer_name = line.split()[1] + self.layer_doc_dict[layer_name] = {} + self.layer_doc_dict[layer_name]['overview'] = '' + + # Verify that checks, tests and api references in layer doc match reality + # Report API calls from doc that are not found in API + # Report checks from doc that are not in actual layers + # Report checks from layers that are not captured in doc + # Report checks from doc that do not have a valid test + def validate(self, layer_dict, tests_set): + #print("tests_set: %s" % (tests_set)) + # Count number of errors found and return it + errors_found = 0 + warnings_found = 0 + # A few checks that are allowed to not have tests + no_test_checks = ['DRAWSTATE_INTERNAL_ERROR', 'DRAWSTATE_OUT_OF_MEMORY', 'MEMTRACK_INTERNAL_ERROR', 'OBJTRACK_INTERNAL_ERROR'] + # First we'll go through the doc datastructures and flag any issues + for chk in self.enum_list: + doc_layer_found = False + for real_layer in layer_dict: + if chk in layer_dict[real_layer]['CHECKS']: + #print('Found actual layer check %s in doc' % (chk)) + doc_layer_found = True + continue + if not doc_layer_found: + print(self.txt_color.red() + 'Actual layers do not contain documented check: %s' % (chk) + self.txt_color.endc()) + errors_found += 1 + + # Now go through API names in doc and verify they're real + # First we're going to transform proto names from vulkan.py into single list + core_api_names = [p.name for p in vulkan.VK_VERSION_1_0.protos] + wsi_s_names = [p.name for p in vulkan.VK_KHR_surface.protos] + wsi_ds_names = [p.name for p in vulkan.VK_KHR_swapchain.protos] + dbg_rpt_names = [p.name for p in vulkan.VK_EXT_debug_report.protos] + api_names = core_api_names + wsi_s_names + wsi_ds_names + dbg_rpt_names + for ln in self.layer_doc_dict: + for chk in self.layer_doc_dict[ln]: + if chk in ['overview', 'pending']: + continue + for api in self.layer_doc_dict[ln][chk]['api_list']: + if api[2:] not in api_names and api not in layer_extension_functions: + print(self.txt_color.red() + 'Doc references invalid function: %s' % (api) + self.txt_color.endc()) + errors_found += 1 + # For now warn on missing or invalid tests + for test in self.layer_doc_dict[ln][chk]['tests']: + if '*' in test: + # naive way to handle wildcards, just make sure we have matches on parts + test_parts = test.split('*') + for part in test_parts: + part_found = False + for t in tests_set: + if part in t: + part_found = True + break + if not part_found: + print(self.txt_color.red() + 'Validation check %s has missing or invalid test : %s' % (chk, test)) + errors_found += 1 + break + elif test not in tests_set and not chk.endswith('_NONE'): + if test == 'TODO': + if chk not in no_test_checks: + warnings_found += 1 + else: + print(self.txt_color.red() + 'Validation check %s has missing or invalid test : %s' % (chk, test)) + errors_found += 1 + # Now go through all of the actual checks in the layers and make sure they're covered in the doc + for ln in layer_dict: + for chk in layer_dict[ln]['CHECKS']: + if chk not in self.enum_list: + print(self.txt_color.red() + 'Doc is missing check: %s' % (chk) + self.txt_color.endc()) + errors_found += 1 + + return (errors_found, warnings_found) + + # Print all of the checks captured in the doc + def print_checks(self): + print('Checks captured in doc:\n%s' % ('\n\t'.join(self.enum_list))) + +def main(argv=None): + # Parse args + opts = handle_args() + # Create parser for layer files + layer_parser = LayerParser(opts.in_headers, opts.in_source) + # Parse files into internal data structs + layer_parser.parse() + # Parse test files + test_parser = TestParser(opts.test_source) + test_parser.parse() + + # Generate requested types of output + if opts.print_structs: # Print details of internal data structs + layer_parser.print_structs() + + layer_doc = LayerDoc(opts.layer_doc) + layer_doc.parse() + if opts.print_doc_checks: + layer_doc.print_checks() + + if opts.validate: + (num_errors, num_warnings) = layer_doc.validate(layer_parser.layer_dict, test_parser.tests_set) + txt_color = bcolors() + if (0 == num_warnings): + print(txt_color.green() + 'No warning cases found between %s and implementation' % (os.path.basename(opts.layer_doc)) + txt_color.endc()) + else: + print(txt_color.yellow() + 'Found %s warnings due to missing tests. Missing tests are labeled as "TODO" in "%s."' % (num_warnings, opts.layer_doc)) + if (0 == num_errors): + print(txt_color.green() + 'No mismatches found between %s and implementation' % (os.path.basename(opts.layer_doc)) + txt_color.endc()) + else: + return num_errors + return 0 + +if __name__ == "__main__": + sys.exit(main()) + -- cgit v1.2.3