| # Copyright (c) 2015-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, 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 argparse |
| import os |
| import sys |
| import textwrap |
| |
| import xml.etree.cElementTree as et |
| |
| hashed_funcs = {} |
| |
| c_file = None |
| _c_indent = 0 |
| |
| def c(*args): |
| 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): |
| c_file.write(''.rjust(_c_indent) + code) |
| def c_raw(code): |
| 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): |
| 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{0} = {1} + {2};".format(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{0} = {1};".format(tmp_id, args[1])) |
| c("double tmp{0} = {1};".format(tmp_id + 1, args[0])) |
| c("double tmp{0} = tmp{1} ? tmp{2} / tmp{1} : 0;".format(tmp_id + 2, tmp_id + 1, tmp_id)) |
| return tmp_id + 3 |
| |
| def emit_fmax(tmp_id, args): |
| c("double tmp{0} = {1};".format(tmp_id, args[1])) |
| c("double tmp{0} = {1};".format(tmp_id + 1, args[0])) |
| c("double tmp{0} = MAX(tmp{1}, tmp{2});".format(tmp_id + 2, tmp_id, tmp_id + 1)) |
| return tmp_id + 3 |
| |
| def emit_fmul(tmp_id, args): |
| c("double tmp{0} = {1} * {2};".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_fsub(tmp_id, args): |
| c("double tmp{0} = {1} - {2};".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_read(tmp_id, args): |
| type = args[1].lower() |
| c("uint64_t tmp{0} = accumulator[query->{1}_offset + {2}];".format(tmp_id, type, args[0])) |
| return tmp_id + 1 |
| |
| def emit_uadd(tmp_id, args): |
| c("uint64_t tmp{0} = {1} + {2};".format(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{0} = {1};".format(tmp_id, args[1])) |
| c("uint64_t tmp{0} = {1};".format(tmp_id + 1, args[0])) |
| c("uint64_t tmp{0} = tmp{1} ? tmp{2} / tmp{1} : 0;".format(tmp_id + 2, tmp_id + 1, tmp_id)) |
| return tmp_id + 3 |
| |
| def emit_umul(tmp_id, args): |
| c("uint64_t tmp{0} = {1} * {2};".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_usub(tmp_id, args): |
| c("uint64_t tmp{0} = {1} - {2};".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_umin(tmp_id, args): |
| c("uint64_t tmp{0} = MIN({1}, {2});".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_lshft(tmp_id, args): |
| c("uint64_t tmp{0} = {1} << {2};".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_rshft(tmp_id, args): |
| c("uint64_t tmp{0} = {1} >> {2};".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_and(tmp_id, args): |
| c("uint64_t tmp{0} = {1} & {2};".format(tmp_id, 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) |
| ops["<<"] = (2, emit_lshft) |
| ops[">>"] = (2, emit_rshft) |
| ops["AND"] = (2, emit_and) |
| |
| 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" |
| hw_vars["$SkuRevisionId"] = "brw->perfquery.sys_vars.revision" |
| |
| def output_rpn_equation_code(set, counter, equation): |
| 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 set.counter_vars: |
| reference = set.counter_vars[operand] |
| operand = set.read_funcs[operand[1:]] + "(brw, query, accumulator)" |
| else: |
| raise Exception("Failed to resolve variable " + operand + " in equation " + equation + " for " + set.name + " :: " + counter.get('name')); |
| args.append(operand) |
| |
| tmp_id = callback(tmp_id, args) |
| |
| tmp = "tmp{0}".format(tmp_id - 1) |
| stack.append(tmp) |
| |
| if len(stack) != 1: |
| raise Exception("Spurious empty rpn code for " + set.name + " :: " + |
| counter.get('name') + ".\nThis is probably due to some unhandled RPN function, in the equation \"" + |
| equation + "\"") |
| |
| value = stack[-1] |
| |
| if value in hw_vars: |
| value = hw_vars[value] |
| if value in set.counter_vars: |
| value = set.read_funcs[value[1:]] + "(brw, query, accumulator)" |
| |
| 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.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.name + " :: " + |
| counter.get('name') + ".\nThis is probably due to some unhandled RPN operation, in the expression \"" + |
| expression + "\"") |
| |
| return stack[-1] |
| |
| def output_counter_read(gen, set, counter): |
| c("\n") |
| c("/* {0} :: {1} */".format(set.name, counter.get('name'))) |
| |
| if counter.read_hash in hashed_funcs: |
| c("#define %s \\" % counter.read_sym) |
| c_indent(3) |
| c("%s" % hashed_funcs[counter.read_hash]) |
| c_outdent(3) |
| else: |
| ret_type = counter.get('data_type') |
| if ret_type == "uint64": |
| ret_type = "uint64_t" |
| |
| read_eq = counter.get('equation') |
| |
| c("static " + ret_type) |
| c(counter.read_sym + "(MAYBE_UNUSED struct brw_context *brw,\n") |
| c_indent(len(counter.read_sym) + 1) |
| c("const struct brw_perf_query_info *query,\n") |
| c("uint64_t *accumulator)\n") |
| c_outdent(len(counter.read_sym) + 1) |
| |
| c("{") |
| c_indent(3) |
| output_rpn_equation_code(set, counter, read_eq) |
| c_outdent(3) |
| c("}") |
| |
| hashed_funcs[counter.read_hash] = counter.read_sym |
| |
| |
| def output_counter_max(gen, set, counter): |
| max_eq = counter.get('max_equation') |
| |
| if not counter.has_max_func(): |
| return |
| |
| c("\n") |
| c("/* {0} :: {1} */".format(set.name, counter.get('name'))) |
| |
| if counter.max_hash in hashed_funcs: |
| c("#define %s \\" % counter.max_sym()) |
| c_indent(3) |
| c("%s" % hashed_funcs[counter.max_hash]) |
| c_outdent(3) |
| else: |
| ret_type = counter.get('data_type') |
| if ret_type == "uint64": |
| ret_type = "uint64_t" |
| |
| c("static " + ret_type) |
| c(counter.max_sym() + "(struct brw_context *brw)\n") |
| c("{") |
| c_indent(3) |
| output_rpn_equation_code(set, counter, max_eq) |
| c_outdent(3) |
| c("}") |
| |
| hashed_funcs[counter.max_hash] = counter.max_sym() |
| |
| |
| 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_availability(set, availability, counter_name): |
| expression = splice_rpn_expression(set, counter_name, 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) |
| |
| |
| 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: |
| output_availability(set, availability, counter.get('name')) |
| c_indent(3) |
| |
| c("counter = &query->counters[query->n_counters++];\n") |
| c("counter->oa_counter_read_" + data_type + " = " + set.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 = " + set.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) |
| |
| |
| register_types = { |
| 'FLEX': 'flex_regs', |
| 'NOA': 'mux_regs', |
| 'OA': 'b_counter_regs', |
| } |
| |
| def compute_register_lengths(set): |
| register_lengths = {} |
| register_configs = set.findall('register_config') |
| for register_config in register_configs: |
| t = register_types[register_config.get('type')] |
| if t not in register_lengths: |
| register_lengths[t] = len(register_config.findall('register')) |
| else: |
| register_lengths[t] += len(register_config.findall('register')) |
| |
| return register_lengths |
| |
| |
| def generate_register_configs(set): |
| register_configs = set.findall('register_config') |
| for register_config in register_configs: |
| t = register_types[register_config.get('type')] |
| |
| availability = register_config.get('availability') |
| if availability: |
| output_availability(set, availability, register_config.get('type') + ' register config') |
| c_indent(3) |
| |
| for register in register_config.findall('register'): |
| c("query->%s[query->n_%s++] = (struct brw_perf_query_register_prog) { .reg = %s, .val = %s };" % |
| (t, t, register.get('address'), register.get('value'))) |
| |
| if availability: |
| c_outdent(3) |
| c("}") |
| c("\n") |
| |
| |
| # Wraps a <counter> element from the brw_oa_*.xml files. |
| class Counter: |
| def __init__(self, set, xml): |
| self.xml = xml |
| self.set = set |
| self.read_hash = None |
| self.max_hash = None |
| |
| self.read_sym = "{0}__{1}__{2}__read".format(self.set.gen.chipset, |
| self.set.underscore_name, |
| self.xml.get('underscore_name')) |
| |
| def get(self, prop): |
| return self.xml.get(prop) |
| |
| # Compute the hash of a counter's equation by expanding (including all the |
| # sub-equations it depends on) |
| def compute_hashes(self): |
| if self.read_hash is not None: |
| return |
| |
| def replace_token(token): |
| if token[0] != "$": |
| return token |
| if token not in self.set.counter_vars: |
| return token |
| self.set.counter_vars[token].compute_hashes() |
| return self.set.counter_vars[token].read_hash |
| |
| read_eq = self.xml.get('equation') |
| self.read_hash = ' '.join(map(replace_token, read_eq.split())) |
| |
| max_eq = self.xml.get('max_equation') |
| if max_eq: |
| self.max_hash = ' '.join(map(replace_token, max_eq.split())) |
| |
| def has_max_func(self): |
| max_eq = self.xml.get('max_equation') |
| if not max_eq: |
| return False |
| |
| try: |
| val = float(max_eq) |
| return False |
| except ValueError: |
| pass |
| |
| for token in max_eq.split(): |
| if token[0] == '$' and token not in hw_vars: |
| return False |
| return True |
| |
| def max_sym(self): |
| assert self.has_max_func() |
| return "{0}__{1}__{2}__max".format(self.set.gen.chipset, |
| self.set.underscore_name, |
| self.xml.get('underscore_name')) |
| |
| def max_value(self): |
| max_eq = self.xml.get('max_equation') |
| if not max_eq: |
| return "0 /* undefined */" |
| |
| try: |
| return "{0}".format(float(max_eq)) |
| except ValueError: |
| pass |
| |
| for token in max_eq.split(): |
| if token[0] == '$' and token not in hw_vars: |
| return "0 /* unsupported (varies over time) */" |
| |
| return "{0}__{1}__{2}__max(brw)".format(self.set.gen.chipset, |
| self.set.underscore_name, |
| self.xml.get('underscore_name')) |
| |
| # Wraps a <set> element from the brw_oa_*.xml files. |
| class Set: |
| def __init__(self, gen, xml): |
| self.gen = gen |
| self.xml = xml |
| |
| self.counter_vars = {} |
| self.max_values = {} |
| self.read_funcs = {} |
| |
| xml_counters = self.xml.findall("counter") |
| self.counters = [] |
| for xml_counter in xml_counters: |
| counter = Counter(self, xml_counter) |
| self.counters.append(counter) |
| self.counter_vars["$" + counter.get('symbol_name')] = counter |
| self.read_funcs[counter.get('symbol_name')] = counter.read_sym |
| self.max_values[counter.get('symbol_name')] = counter.max_value() |
| |
| for counter in self.counters: |
| counter.compute_hashes() |
| |
| @property |
| def hw_config_guid(self): |
| return self.xml.get('hw_config_guid') |
| |
| @property |
| def name(self): |
| return self.xml.get('name') |
| |
| @property |
| def symbol_name(self): |
| return self.xml.get('symbol_name') |
| |
| @property |
| def underscore_name(self): |
| return self.xml.get('underscore_name') |
| |
| def findall(self, path): |
| return self.xml.findall(path) |
| |
| def find(self, path): |
| return self.xml.find(path) |
| |
| |
| # Wraps an entire brw_oa_*.xml file. |
| class Gen: |
| def __init__(self, filename): |
| self.filename = filename |
| self.xml = et.parse(self.filename) |
| self.chipset = self.xml.find('.//set').get('chipset').lower() |
| self.sets = [] |
| |
| for xml_set in self.xml.findall(".//set"): |
| self.sets.append(Set(self, xml_set)) |
| |
| |
| def main(): |
| global c_file |
| global header_file |
| |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--header", help="Header file to write", required=True) |
| parser.add_argument("--code", help="C file to write", required=True) |
| parser.add_argument("xml_files", nargs='+', help="List of xml metrics files to process") |
| |
| args = parser.parse_args() |
| |
| header_file = open(args.header, 'w') |
| c_file = open(args.code, 'w') |
| |
| gens = [] |
| for xml_file in args.xml_files: |
| gens.append(Gen(xml_file)) |
| |
| |
| copyright = textwrap.dedent("""\ |
| /* 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__)) |
| |
| h(copyright) |
| h(textwrap.dedent("""\ |
| #pragma once |
| |
| struct brw_context; |
| |
| """)) |
| |
| c(copyright) |
| c(textwrap.dedent("""\ |
| #include <stdint.h> |
| #include <stdbool.h> |
| |
| #include "util/hash_table.h" |
| |
| """)) |
| |
| c("#include \"" + os.path.basename(args.header) + "\"") |
| |
| c(textwrap.dedent("""\ |
| #include "brw_context.h" |
| #include "brw_performance_query_metrics.h" |
| |
| |
| #define MIN(a, b) ((a < b) ? (a) : (b)) |
| #define MAX(a, b) ((a > b) ? (a) : (b)) |
| |
| |
| """)) |
| |
| # Print out all equation functions. |
| for gen in gens: |
| for set in gen.sets: |
| for counter in set.counters: |
| output_counter_read(gen, set, counter) |
| output_counter_max(gen, set, counter) |
| |
| # Print out all metric sets registration functions for each set in each |
| # generation. |
| for gen in gens: |
| for set in gen.sets: |
| counters = set.counters |
| |
| c("\n") |
| register_lengths = compute_register_lengths(set); |
| for reg_type, reg_length in register_lengths.items(): |
| c("static struct brw_perf_query_register_prog {0}_{1}_{2}[{3}];".format(gen.chipset, |
| set.underscore_name, |
| reg_type, reg_length)) |
| |
| c("\nstatic struct brw_perf_query_counter {0}_{1}_query_counters[{2}];\n".format(gen.chipset, set.underscore_name, len(counters))) |
| c("static struct brw_perf_query_info " + gen.chipset + "_" + set.underscore_name + "_query = {\n") |
| c_indent(3) |
| |
| c(".kind = OA_COUNTERS,\n") |
| c(".name = \"" + set.name + "\",\n") |
| c(".guid = \"" + set.hw_config_guid + "\",\n") |
| |
| c(".counters = {0}_{1}_query_counters,".format(gen.chipset, set.underscore_name)) |
| c(".n_counters = 0,") |
| c(".oa_metrics_set_id = 0, /* determined at runtime, via sysfs */") |
| |
| if gen.chipset == "hsw": |
| c(textwrap.dedent("""\ |
| .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(textwrap.dedent("""\ |
| .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, |
| """)) |
| |
| for reg_type, reg_length in register_lengths.items(): |
| c(".{0} = {1}_{2}_{3},".format(reg_type, gen.chipset, set.underscore_name, reg_type)) |
| c(".n_{0} = 0, /* Determined at runtime */".format(reg_type)) |
| |
| c_outdent(3) |
| c("};\n") |
| |
| c("\nstatic void\n") |
| c("{0}_register_{1}_counter_query(struct brw_context *brw)\n".format(gen.chipset, set.underscore_name)) |
| c("{\n") |
| c_indent(3) |
| |
| c("static struct brw_perf_query_info *query = &" + gen.chipset + "_" + set.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) |
| |
| generate_register_configs(set) |
| |
| 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_" + gen.chipset + "(struct brw_context *brw);\n") |
| |
| c("\nvoid") |
| c("brw_oa_register_queries_" + gen.chipset + "(struct brw_context *brw)") |
| c("{") |
| c_indent(3) |
| |
| for set in gen.sets: |
| c("{0}_register_{1}_counter_query(brw);".format(gen.chipset, set.underscore_name)) |
| |
| c_outdent(3) |
| c("}") |
| |
| |
| if __name__ == '__main__': |
| main() |
