<div dir="ltr"><div dir="auto"> On Mon, Feb 27, 2017 at 5:38 PM, Lionel Landwerlin <<a href="mailto:lionel.g.landwerlin@intel.com" target="_blank">lionel.g.landwerlin@intel.com</a>> wrote: > Hey Rob, > > Your series look pretty good. Just a tiny nit on this patch below. > > As we've discussed in the office, I think it would be nice to have part of > this work factored out in src/intel. > But that can be done later on. > > Also, I found it a bit disturbing to have the equations in polish notation. > I've given a try at using a more C-like style to it. The result is here : > > <a href="https://github.com/djdeath/mesa/commit/ebfaf7aee8efe79dc814bc7bfdcb9d74cec09d3c" target="_blank">https://github.com/djdeath/mesa/commit/ebfaf7aee8efe79dc814bc7bfdcb9d74cec09d3c</a> > > It's a tiny bit less python (~20 lines) but adds a dependency on > python-parsley. > I also have a script to convert expression from your format to the new one. Thanks for prototyping this it interesting to compare. We talked at length offline but putting my thoughts down here too: Tbh I'm not sure whether this would be a good direction, considering pros and cons... Currently Mesa isn't the only project doing codegen based on these expression, and the codegen in gputop is probably a bit more involved than Mesa's where it also generates MathML for the expressions to have something readable in the UI. We also have an internal 'MDAPI' library which generate a class/structure based description of these configs. At least considering that we have fairly decent support for rendering equations in gputop it could be good compare implementation details e.g. with regards to avoiding redundant braces considering the precedence of operators if we wanted to go in this direction. (details can be found in gputop/scripts/gputop-oa-codegen.py if curious). <div dir="auto"> The use of RPN wasn't really a choice by me given that the internal MDAPI XML files that these XML files are generated from themselves have RPN based equations. There are some minor differences to how raw A/B/C counters are read but generally I see some value in minimizing divergence from what VPG maintains internally considering the effort involved in maintaining the conversion script itself and the risk that it becomes hard to compare the two where we're seeing problems with particular counters and want to cross reference what we're doing with what's VPG's driver does on Windows. For reference; probably the best place to consider maintaining any code to convert the expression format would be as a patch to gputop/scripts/mdapi-xml-convert.py, but it should be considered that these files are shared so I'd have to update these other generators if we made a backwards-incompatible change: </div><div dir="auto">- kernel config descriptors</div><div dir="auto">- gputop normalization code (almost identical to Mesa)</div><div dir="auto">- gputop MathML equation descriptions</div><div dir="auto">- MDAPI class based description of counters</div><div dir="auto"> To my mind RPN is so simple to 'parse' for codegen that I can barely bring myself to call it parsing - you just tokenize based on spaces and you're done and then you traverse the operators by pushing tokens/operands to a stack, when you hit an operator you pop the operands and push the result. With RPN there's no precedence ambiguity to consider and with the explicitly typed operations like UDIV vs FDIV there's no operand type ambiguity either. I'd certainly be nervous of squashing these both into a single '/' operator and relying on C type conversion rules. The risk that there are some corner cases where the results won't match the original equations without more explicit type casting seems quite high with the current prototype. The primary use for these expressions is for codegen and so I think machine readability and lack of ambiguity is much more important than human readability within the XML files.</div><div dir="auto"> </div><div dir="auto">RPN seems very well suited here once you're familiar with evaluating RPN as a series of operand pushes and pops for operations. </div><div dir="auto"> </div><div dir="auto">For human readability then I think what gputop does is a pretty decent starting point, being careful with bracketing and supporting mouse overlay descriptions of the different variables, and nice typography and layouting.</div><div dir="auto"> </div><div dir="auto">It's subjective to say which is more readable to handle in code but personally I find embedding a formal grammar for expressions, introducing the need for operator precedence and type conversion rules to be more of a mental load. The comparison of line count imho doesn't account for the density of the grammar being embedded which needs to understood and maintained across the different codegen scripts. The previous code effectively duplicated the traversal of the RPN expressions since it barely seemed worth factoring out the push and pop of tokens that form the parsing loop. There was also lots of white space between the operator methods. </div><div dir="auto">For now I think it's nice to see this alternative to compare, but don't think it's the best trade-off to prioritize human readability of the equations in the xml files over over, unambiguous, machine readability. Considering the complexity of some of the equations there's just no way they will ever be practically readable within the xml files and don't really see much alternative to using a typesetting library like mathjax to render the equations e.g. for a UI. </div><div>Definitely thanks for doing this experiment though! </div><div>Br, </div><div>- Robert </div><div dir="auto"> > > Regardless, this series is : > > Reviewed-by: Lionel Landwerlin <<a href="mailto:lionel.g.landwerlin@intel.com" target="_blank">lionel.g.landwerlin@intel.com</a>> > > Thanks! > > - > Lionel > > > On 24/02/17 13:58, Robert Bragg wrote: >> >> Avoiding lots of error prone boilerplate and easing our ability to add + >> maintain support for multiple OA performance counter queries for each >> generation: >> >> This adds a python script to generate code for building up >> performance_queries from the metric sets and counters described in >> brw_oa_hsw.xml as well as functions to normalize each counter based on >> the RPN expressions given. >> >> Although the XML file currently only includes a single metric set, the >> code generated assumes there could be many sets. >> >> The metrics as described in XML get translated into C structures >> which are registered in a brw->perfquery.oa_metrics_table hash table >> keyed by the GUID of the metric set in XML. >> >> Signed-off-by: Robert Bragg <<a href="mailto:robert@sixbynine.org" target="_blank">robert@sixbynine.org</a>> >> --- >> src/mesa/drivers/dri/i965/Makefile.am | 15 +- >> src/mesa/drivers/dri/i965/Makefile.sources | 2 + >> src/mesa/drivers/dri/i965/brw_oa.py | 543 >> +++++++++++++++++++++++++++++ >> 3 files changed, 559 insertions(+), 1 deletion(-) >> create mode 100644 src/mesa/drivers/dri/i965/brw_oa.py >> >> diff --git a/src/mesa/drivers/dri/i965/Makefile.am >> b/src/mesa/drivers/dri/i965/Makefile.am >> index f87fa67ef8..0130afff5f 100644 >> --- a/src/mesa/drivers/dri/i965/Makefile.am >> +++ b/src/mesa/drivers/dri/i965/Makefile.am >> @@ -93,7 +93,9 @@ BUILT_SOURCES = $(i965_compiler_GENERATED_FILES) >> CLEANFILES = $(BUILT_SOURCES) >> EXTRA_DIST = \ >> - brw_nir_trig_workarounds.py >> + brw_nir_trig_workarounds.py \ >> + brw_oa_hsw.xml \ >> + brw_oa.py >> TEST_LIBS = \ >> <a href="http://libi965_compiler.la" target="_blank">libi965_compiler.la</a> \ >> @@ -169,3 +171,14 @@ test_eu_validate_SOURCES = \ >> test_eu_validate_LDADD = \ >> $(top_builddir)/src/gtest/<a href="http://libgtest.la" target="_blank">libgtest.la</a> \ >> $(TEST_LIBS) >> + >> +BUILT_SOURCES = \ >> + brw_oa_hsw.h \ >> + brw_oa_hsw.c >> + >> +brw_oa_hsw.h brw_oa_hsw.c: brw_oa_hsw.xml brw_oa.py Makefile >> + $(PYTHON2) $(PYTHON_FLAGS) $(srcdir)/brw_oa.py \ >> + --header=$(builddir)/brw_oa_hsw.h \ >> + --code=$(builddir)/brw_oa_hsw.c \ >> + --chipset="hsw" \ >> + $(srcdir)/brw_oa_hsw.xml >> diff --git a/src/mesa/drivers/dri/i965/Makefile.sources >> b/src/mesa/drivers/dri/i965/Makefile.sources >> index 5278e86339..60acd15d41 100644 >> --- a/src/mesa/drivers/dri/i965/Makefile.sources >> +++ b/src/mesa/drivers/dri/i965/Makefile.sources >> @@ -135,6 +135,8 @@ i965_FILES = \ >> brw_nir_uniforms.cpp \ >> brw_object_purgeable.c \ >> brw_pipe_control.c \ >> + brw_oa_hsw.h \ >> + brw_oa_hsw.c \ >> brw_performance_query.h \ >> brw_performance_query.c \ >> brw_program.c \ >> diff --git a/src/mesa/drivers/dri/i965/brw_oa.py >> b/src/mesa/drivers/dri/i965/brw_oa.py >> new file mode 100644 >> index 0000000000..2c622531af >> --- /dev/null >> +++ b/src/mesa/drivers/dri/i965/brw_oa.py >> @@ -0,0 +1,543 @@ >> +#!/usr/bin/env python2 >> +# >> +# Copyright (c) 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. >> + >> +import xml.etree.ElementTree as ET >> +import argparse >> +import sys >> + >> +def print_err(*args): >> + sys.stderr.write(' '.join(map(str,args)) + '\n') >> + >> +c_file = None >> +_c_indent = 0 >> + >> +def c(*args): >> + if c_file: >> + code = ' '.join(map(str,args)) >> + for line in code.splitlines(): >> + text = ''.rjust(_c_indent) + line >> + c_file.write(text.rstrip() + "\n") >> + >> +# indented, but no trailing newline... >> +def c_line_start(code): >> + if c_file: >> + c_file.write(''.rjust(_c_indent) + code) >> +def c_raw(code): >> + if c_file: >> + c_file.write(code) >> + >> +def c_indent(n): >> + global _c_indent >> + _c_indent = _c_indent + n >> +def c_outdent(n): >> + global _c_indent >> + _c_indent = _c_indent - n >> + >> +header_file = None >> +_h_indent = 0 >> + >> +def h(*args): >> + if header_file: >> + code = ' '.join(map(str,args)) >> + for line in code.splitlines(): >> + text = ''.rjust(_h_indent) + line >> + header_file.write(text.rstrip() + "\n") >> + >> +def h_indent(n): >> + global _c_indent >> + _h_indent = _h_indent + n >> +def h_outdent(n): >> + global _c_indent >> + _h_indent = _h_indent - n >> + >> + >> +def emit_fadd(tmp_id, args): >> + c("double tmp" + str(tmp_id) +" = " + args[1] + " + " + args[0] + >> ";") >> + return tmp_id + 1 >> + >> +# Be careful to check for divide by zero... >> +def emit_fdiv(tmp_id, args): >> + c("double tmp" + str(tmp_id) +" = " + args[1] + ";") >> + c("double tmp" + str(tmp_id + 1) +" = " + args[0] + ";") >> + c("double tmp" + str(tmp_id + 2) +" = tmp" + str(tmp_id + 1) + " ? >> tmp" + str(tmp_id) + " / tmp" + str(tmp_id + 1) + " : 0;") >> + return tmp_id + 3 >> + >> +def emit_fmax(tmp_id, args): >> + c("double tmp" + str(tmp_id) +" = " + args[1] + ";") >> + c("double tmp" + str(tmp_id + 1) +" = " + args[0] + ";") >> + c("double tmp" + str(tmp_id + 2) +" = MAX(tmp" + str(tmp_id) + ", >> tmp" + str(tmp_id + 1) + ");") >> + return tmp_id + 3 >> + >> +def emit_fmul(tmp_id, args): >> + c("double tmp" + str(tmp_id) +" = " + args[1] + " * " + args[0] + >> ";") >> + return tmp_id + 1 >> + >> +def emit_fsub(tmp_id, args): >> + c("double tmp" + str(tmp_id) +" = " + args[1] + " - " + args[0] + >> ";") >> + return tmp_id + 1 >> + >> +def emit_read(tmp_id, args): >> + type = args[1].lower() >> + c("uint64_t tmp" + str(tmp_id) + " = accumulator[query->" + type + >> "_offset + " + args[0] + "];") >> + return tmp_id + 1 >> + >> +def emit_uadd(tmp_id, args): >> + c("uint64_t tmp" + str(tmp_id) +" = " + args[1] + " + " + args[0] + >> ";") >> + return tmp_id + 1 >> + >> +# Be careful to check for divide by zero... >> +def emit_udiv(tmp_id, args): >> + c("uint64_t tmp" + str(tmp_id) +" = " + args[1] + ";") >> + c("uint64_t tmp" + str(tmp_id + 1) +" = " + args[0] + ";") >> + c("uint64_t tmp" + str(tmp_id + 2) +" = tmp" + str(tmp_id + 1) + " ? >> tmp" + str(tmp_id) + " / tmp" + str(tmp_id + 1) + " : 0;") >> + return tmp_id + 3 >> + >> +def emit_umul(tmp_id, args): >> + c("uint64_t tmp" + str(tmp_id) +" = " + args[1] + " * " + args[0] + >> ";") >> + return tmp_id + 1 >> + >> +def emit_usub(tmp_id, args): >> + c("uint64_t tmp" + str(tmp_id) +" = " + args[1] + " - " + args[0] + >> ";") >> + return tmp_id + 1 >> + >> +def emit_umin(tmp_id, args): >> + c("uint64_t tmp" + str(tmp_id) +" = MIN(" + args[1] + ", " + args[0] >> + ");") >> + return tmp_id + 1 >> + >> +ops = {} >> +# (n operands, emitter) >> +ops["FADD"] = (2, emit_fadd) >> +ops["FDIV"] = (2, emit_fdiv) >> +ops["FMAX"] = (2, emit_fmax) >> +ops["FMUL"] = (2, emit_fmul) >> +ops["FSUB"] = (2, emit_fsub) >> +ops["READ"] = (2, emit_read) >> +ops["UADD"] = (2, emit_uadd) >> +ops["UDIV"] = (2, emit_udiv) >> +ops["UMUL"] = (2, emit_umul) >> +ops["USUB"] = (2, emit_usub) >> +ops["UMIN"] = (2, emit_umin) >> + >> +def brkt(subexp): >> + if " " in subexp: >> + return "(" + subexp + ")" >> + else: >> + return subexp >> + >> +def splice_bitwise_and(args): >> + return brkt(args[1]) + " & " + brkt(args[0]) >> + >> +def splice_logical_and(args): >> + return brkt(args[1]) + " && " + brkt(args[0]) >> + >> +def splice_ult(args): >> + return brkt(args[1]) + " < " + brkt(args[0]) >> + >> +def splice_ugte(args): >> + return brkt(args[1]) + " >= " + brkt(args[0]) >> + >> +exp_ops = {} >> +# (n operands, splicer) >> +exp_ops["AND"] = (2, splice_bitwise_and) >> +exp_ops["UGTE"] = (2, splice_ugte) >> +exp_ops["ULT"] = (2, splice_ult) >> +exp_ops["&&"] = (2, splice_logical_and) >> + >> + >> +hw_vars = {} >> +hw_vars["$EuCoresTotalCount"] = "brw->perfquery.sys_vars.n_eus" >> +hw_vars["$EuSlicesTotalCount"] = "brw->perfquery.sys_vars.n_eu_slices" >> +hw_vars["$EuSubslicesTotalCount"] = >> "brw->perfquery.sys_vars.n_eu_sub_slices" >> +hw_vars["$EuThreadsCount"] = "brw->perfquery.sys_vars.eu_threads_count" >> +hw_vars["$SliceMask"] = "brw->perfquery.sys_vars.slice_mask" >> +hw_vars["$SubsliceMask"] = "brw->perfquery.sys_vars.subslice_mask" >> +hw_vars["$GpuTimestampFrequency"] = >> "brw->perfquery.sys_vars.timestamp_frequency" >> +hw_vars["$GpuMinFrequency"] = "brw->perfquery.sys_vars.gt_min_freq" >> +hw_vars["$GpuMaxFrequency"] = "brw->perfquery.sys_vars.gt_max_freq" >> + >> +counter_vars = {} > > > I guess you can remove this counter_vars as it's given as an argument to the > following functions. > > >> + >> +def output_rpn_equation_code(set, counter, equation, counter_vars): >> + c("/* RPN equation: " + equation + " */") >> + tokens = equation.split() >> + stack = [] >> + tmp_id = 0 >> + tmp = None >> + >> + for token in tokens: >> + stack.append(token) >> + while stack and stack[-1] in ops: >> + op = stack.pop() >> + argc, callback = ops[op] >> + args = [] >> + for i in range(0, argc): >> + operand = stack.pop() >> + if operand[0] == "$": >> + if operand in hw_vars: >> + operand = hw_vars[operand] >> + elif operand in counter_vars: >> + reference = counter_vars[operand] >> + operand = read_funcs[operand[1:]] + "(brw, query, >> accumulator)" >> + else: >> + raise Exception("Failed to resolve variable " + >> operand + " in equation " + equation + " for " + set.get('name') + " :: " + >> counter.get('name')); >> + args.append(operand) >> + >> + tmp_id = callback(tmp_id, args) >> + >> + tmp = "tmp" + str(tmp_id - 1) >> + stack.append(tmp) >> + >> + if len(stack) != 1: >> + raise Exception("Spurious empty rpn code for " + set.get('name') >> + " :: " + >> + counter.get('name') + ".\nThis is probably due to some >> unhandled RPN function, in the equation \"" + >> + equation + "\"") >> + >> + value = stack.pop() >> + >> + if value in hw_vars: >> + value = hw_vars[value]; >> + >> + c("\nreturn " + value + ";") >> + >> +def splice_rpn_expression(set, counter, expression): >> + tokens = expression.split() >> + stack = [] >> + >> + for token in tokens: >> + stack.append(token) >> + while stack and stack[-1] in exp_ops: >> + op = stack.pop() >> + argc, callback = exp_ops[op] >> + args = [] >> + for i in range(0, argc): >> + operand = stack.pop() >> + if operand[0] == "$": >> + if operand in hw_vars: >> + operand = hw_vars[operand] >> + else: >> + raise Exception("Failed to resolve variable " + >> operand + " in expression " + expression + " for " + set.get('name') + " :: >> " + counter.get('name')); >> + args.append(operand) >> + >> + subexp = callback(args) >> + >> + stack.append(subexp) >> + >> + if len(stack) != 1: >> + raise Exception("Spurious empty rpn expression for " + >> set.get('name') + " :: " + >> + counter.get('name') + ".\nThis is probably due to some >> unhandled RPN operation, in the expression \"" + >> + expression + "\"") >> + >> + return stack.pop() >> + >> +def output_counter_read(set, counter, counter_vars): >> + c("\n") >> + c("/* " + set.get('name') + " :: " + counter.get('name') + " */") >> + ret_type = counter.get('data_type') >> + if ret_type == "uint64": >> + ret_type = "uint64_t" >> + >> + c("static " + ret_type) >> + read_sym = set.get('chipset').lower() + "__" + >> set.get('underscore_name') + "__" + counter.get('underscore_name') + >> "__read" >> + c(read_sym + "(struct brw_context *brw,\n") >> + c_indent(len(read_sym) + 1) >> + c("const struct brw_perf_query_info *query,\n") >> + c("uint64_t *accumulator)\n") >> + c_outdent(len(read_sym) + 1) >> + >> + c("{") >> + c_indent(3) >> + >> + output_rpn_equation_code(set, counter, counter.get('equation'), >> counter_vars) >> + >> + c_outdent(3) >> + c("}") >> + >> + return read_sym >> + >> +def output_counter_max(set, counter, counter_vars): >> + max_eq = counter.get('max_equation') >> + >> + if not max_eq: >> + return "0; /* undefined */" >> + >> + try: >> + val = float(max_eq) >> + return max_eq + ";" >> + except: >> + pass >> + >> + # We can only report constant maximum values via >> INTEL_performance_query >> + for token in max_eq.split(): >> + if token[0] == '$' and token not in hw_vars: >> + return "0; /* unsupported (varies over time) */" >> + >> + c("\n") >> + c("/* " + set.get('name') + " :: " + counter.get('name') + " */") >> + ret_type = counter.get('data_type') >> + if ret_type == "uint64": >> + ret_type = "uint64_t" >> + >> + c("static " + ret_type) >> + max_sym = set.get('chipset').lower() + "__" + >> set.get('underscore_name') + "__" + counter.get('underscore_name') + "__max" >> + c(max_sym + "(struct brw_context *brw)\n") >> + >> + c("{") >> + c_indent(3) >> + >> + output_rpn_equation_code(set, counter, max_eq, counter_vars) >> + >> + c_outdent(3) >> + c("}") >> + >> + return max_sym + "(brw);" >> + >> +c_type_sizes = { "uint32_t": 4, "uint64_t": 8, "float": 4, "double": 8, >> "bool": 4 } >> +def sizeof(c_type): >> + return c_type_sizes[c_type] >> + >> +def pot_align(base, pot_alignment): >> + return (base + pot_alignment - 1) & ~(pot_alignment - 1); >> + >> +semantic_type_map = { >> + "duration": "raw", >> + "ratio": "event" >> + } >> + >> +def output_counter_report(set, counter, current_offset): >> + data_type = counter.get('data_type') >> + data_type_uc = data_type.upper() >> + c_type = data_type >> + >> + if "uint" in c_type: >> + c_type = c_type + "_t" >> + >> + semantic_type = counter.get('semantic_type') >> + if semantic_type in semantic_type_map: >> + semantic_type = semantic_type_map[semantic_type] >> + >> + semantic_type_uc = semantic_type.upper() >> + >> + c("\n") >> + >> + availability = counter.get('availability') >> + if availability: >> + expression = splice_rpn_expression(set, counter, availability) >> + lines = expression.split(' && ') >> + n_lines = len(lines) >> + if n_lines == 1: >> + c("if (" + lines[0] + ") {") >> + else: >> + c("if (" + lines[0] + " &&") >> + c_indent(4) >> + for i in range(1, (n_lines - 1)): >> + c(lines[i] + " &&") >> + c(lines[(n_lines - 1)] + ") {") >> + c_outdent(4) >> + c_indent(3) >> + >> + c("counter = &query->counters[query->n_counters++];\n") >> + c("counter->oa_counter_read_" + data_type + " = " + >> read_funcs[counter.get('symbol_name')] + ";\n") >> + c("counter->name = \"" + counter.get('name') + "\";\n") >> + c("counter->desc = \"" + counter.get('description') + "\";\n") >> + c("counter->type = GL_PERFQUERY_COUNTER_" + semantic_type_uc + >> "_INTEL;\n") >> + c("counter->data_type = GL_PERFQUERY_COUNTER_DATA_" + data_type_uc + >> "_INTEL;\n") >> + c("counter->raw_max = " + max_values[counter.get('symbol_name')] + >> "\n") >> + >> + current_offset = pot_align(current_offset, sizeof(c_type)) >> + c("counter->offset = " + str(current_offset) + ";\n") >> + c("counter->size = sizeof(" + c_type + ");\n") >> + >> + if availability: >> + c_outdent(3); >> + c("}") >> + >> + return current_offset + sizeof(c_type) >> + >> +parser = argparse.ArgumentParser() >> +parser.add_argument("xml", help="XML description of metrics") >> +parser.add_argument("--header", help="Header file to write") >> +parser.add_argument("--code", help="C file to write") >> +parser.add_argument("--chipset", help="Chipset to generate code for") >> + >> +args = parser.parse_args() >> + >> +chipset = args.chipset.lower() >> + >> +if args.header: >> + header_file = open(args.header, 'w') >> + >> +if args.code: >> + c_file = open(args.code, 'w') >> + >> +tree = ET.parse(args.xml) >> + >> + >> +copyright = """/* Autogenerated file, DO NOT EDIT manually! >> + * >> + * Copyright (c) 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. >> + */ >> + >> +""" >> + >> +h(copyright) >> +h("""#pragma once >> + >> +struct brw_context; >> + >> +""") >> + >> +c(copyright) >> +c( >> +""" >> +#include <stdint.h> >> +#include <stdbool.h> >> + >> +#include "util/hash_table.h" >> + >> +""") >> + >> +c("#include \"brw_oa_" + chipset + ".h\"") >> + >> +c( >> +""" >> +#include "brw_context.h" >> +#include "brw_performance_query.h" >> + >> + >> +#define MIN(a, b) ((a < b) ? (a) : (b)) >> +#define MAX(a, b) ((a > b) ? (a) : (b)) >> + >> +""") >> + >> +for set in tree.findall(".//set"): >> + max_values = {} >> + read_funcs = {} >> + counter_vars = {} >> + counters = set.findall("counter") >> + >> + assert set.get('chipset').lower() == chipset >> + >> + for counter in counters: >> + empty_vars = {} >> + read_funcs[counter.get('symbol_name')] = output_counter_read(set, >> counter, counter_vars) >> + max_values[counter.get('symbol_name')] = output_counter_max(set, >> counter, empty_vars) >> + counter_vars["$" + counter.get('symbol_name')] = counter >> + >> + >> + c("\nstatic struct brw_perf_query_counter " + chipset + "_" + >> set.get('underscore_name') + "_query_counters[" + str(len(counters)) + >> "];\n") >> + c("static struct brw_perf_query_info " + chipset + "_" + >> set.get('underscore_name') + "_query = {\n") >> + c_indent(3) >> + >> + c(".kind = OA_COUNTERS,\n") >> + c(".name = \"" + set.get('name') + "\",\n") >> + c(".guid = \"" + set.get('hw_config_guid') + "\",\n") >> + >> + c(".counters = " + chipset + "_" + set.get('underscore_name') + >> "_query_counters,") >> + c(".n_counters = 0,") >> + c(".oa_metrics_set_id = 0, /* determined at runtime, via sysfs */") >> + >> + if chipset == "hsw": >> + c(""".oa_format = I915_OA_FORMAT_A45_B8_C8, >> + >> +/* Accumulation buffer offsets... */ >> +.gpu_time_offset = 0, >> +.a_offset = 1, >> +.b_offset = 46, >> +.c_offset = 54, >> +""") >> + else: >> + c(""".oa_format = I915_OA_FORMAT_A32u40_A4u32_B8_C8, >> + >> +/* Accumulation buffer offsets... */ >> +.gpu_time_offset = 0, >> +.gpu_clock_offset = 1, >> +.a_offset = 2, >> +.b_offset = 38, >> +.c_offset = 46, >> +""") >> + >> + c_outdent(3) >> + c("};\n") >> + >> + c("\nstatic void\n") >> + c("register_" + set.get('underscore_name') + "_counter_query(struct >> brw_context *brw)\n") >> + c("{\n") >> + c_indent(3) >> + >> + c("static struct brw_perf_query_info *query = &" + chipset + "_" + >> set.get('underscore_name') + "_query;\n") >> + c("struct brw_perf_query_counter *counter;\n") >> + >> + c("\n") >> + c("/* Note: we're assuming there can't be any variation in the >> definition ") >> + c(" * of a query between contexts so it's ok to describe a query >> within a ") >> + c(" * global variable which only needs to be initialized once... */") >> + c("\nif (!query->data_size) {") >> + c_indent(3) >> + >> + offset = 0 >> + for counter in counters: >> + offset = output_counter_report(set, counter, offset) >> + >> + >> + c("\nquery->data_size = counter->offset + counter->size;\n") >> + >> + c_outdent(3) >> + c("}"); >> + >> + c("\n_mesa_hash_table_insert(brw->perfquery.oa_metrics_table, >> query->guid, query);") >> + >> + c_outdent(3) >> + c("}\n") >> + >> +h("void brw_oa_register_queries_" + chipset + "(struct brw_context >> *brw);\n") >> + >> +c("\nvoid") >> +c("brw_oa_register_queries_" + chipset + "(struct brw_context *brw)") >> +c("{") >> +c_indent(3) >> + >> +for set in tree.findall(".//set"): >> + c("register_" + set.get('underscore_name') + "_counter_query(brw);") >> + >> +c_outdent(3) >> +c("}") >> + > > ></div></div> </div>