[Mesa-dev] [PATCH 5/8] i965: Add script to gen code for OA counter queries
Robert Bragg
robert at sixbynine.org
Wed Mar 1 15:57:57 UTC 2017
On Mon, Feb 27, 2017 at 8:01 PM, Dylan Baker <dylan at pnwbakers.com> wrote:
> I have some comments below, some of them are a bit of work, some of them should
> be pretty easy.
>
> Dylan
>
> Quoting Robert Bragg (2017-02-24 05:58:00)
>> --- /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
>
> use cElementTree, and please import as "et" instead of "ET", ET suggests to me
> as a pythonista that this is a class not a module. (I know ElementTree is
> capitalized, but that's a legacy thing, modern python style is modules are lower
> case with _, classes are CamelCase)
Using cElementTree sounds good.
If I grep Mesa I see for 6 different uses of ElementTree with 5 out of
6 importing as ET. Really I just copied the style/name from other
examples I found including the reference manual:
https://docs.python.org/2/library/xml.etree.elementtree.html and ET
does seem to be the common abbreviation used with ElementTree. I don't
really have a strong oppinion here though and can just make the
change.
>
>> +import argparse
>> +import sys
>
> Also, please sort the imports
okey, can do; the python style guide says:
"Imports should be grouped in the following order:
1. standard library imports
2. related third party imports
3. local application/library specific imports
You should put a blank line between each group of imports. "
I'm not actually sure if mesa's general style of alphanumerically
sorting everything should override, but luckily my only third party
import begins with x.
>
>> +
>> +def print_err(*args):
>> + sys.stderr.write(' '.join(map(str,args)) + '\n')
>
> unused function
ah yup, can remove; just copied from another codegen script based on
the same data.
>
>> +
>> +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] + ";")
>
> "double tmp {tmp_id} = {args[1]} + {ags[0]};".format(tmp_id=tmp_id, args=args)
>
> This avoids the need to explicitly convert to str, and is much more readable.
> I'd really recommend taking this approach for the rest of the file too, as it
> will make things much more readable.
hmm, that seems like quite a bit more typing with some variables being
written out three times this way :-/
maybe we could go with a variation like: "double tmp {0} = {1} +
{2};".format(tmp_id, args[1], args[0])
I've updated the emit_XYZ funcs to use .format() which seems more
readable but I've still left quite a few uses of + based concatenation
in places that I was less sure that it was more readable to use
.format(). There was also at least once case that was made awkard
since the string contains an open brace so I left it with + based
concatenation.
>
>> + 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 = {}
>> +
>> +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):
>
> Use xrange instead of range
okey, can do.
>
>> + 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()
>
> You probably don't want to use stack.pop(), it's going to mutate the list before
> returning, if you just return stack[-1] you avoid the list mutation
ah, yup, sounds good.
>
>> +
>> +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:
>
> Be explicit about what exception you expect please, I assume you're looking for
> ValueError
ok, can do
>
>> + 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)
>> +
>
> wrap this up in a main() function, and add this to the bottom of the file:
> if __name__ == '__main__':
> main()
>
> this allows the module to be imported without executing the code below, which is
> extremely helpful for debugging, and is just good practice.
ok, can do.
>
>> +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()
>
> argparse will do this for you, add this to the chipset line:
> type=lambda c: c.lower()
>
>> +
>> +if args.header:
>> + header_file = open(args.header, 'w')
>> +
>> +if args.code:
>> + c_file = open(args.code, 'w')
>
> If you wrap this up in main() you have two choices, use the global keyword for
> header_file and c_file or re-architect to not have these as globals. Since the
> second sounds pretty onerous feel free to just use global.
yeah went with globals for now.
>
>> +
>> +tree = ET.parse(args.xml)
>> +
>> +
>> +copyright = """/* Autogenerated file, DO NOT EDIT manually!
>
> copyright = """\
> /* Autogenerated file, DO NOT EDIT manually! generated by: {}
>
>> + *
>> + * 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.
>> + */
>> +
>> +"""
>
> """.format(os.path.basename(__file__))
>
> Which, with the above change, whill put the name of your file in the
> autogeneration line, which is rather handy for figuring out which generator to
> edit :)
looks good, thanks
>
>> +
>> +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,
>> +""")
>
> textwrap.dedent is your friend for readability here.
yep, especially with this code further indented within a main() function
Okey, I've got these changes made and working locally so I'll send out
an update soon - thanks for the comments!
Br,
- Robert
>
>> + 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("}")
>> +
>> --
>> 2.11.1
>>
>> _______________________________________________
>> mesa-dev mailing list
>> mesa-dev at lists.freedesktop.org
>> https://lists.freedesktop.org/mailman/listinfo/mesa-dev
More information about the mesa-dev
mailing list