| # 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 builtins |
| import collections |
| import os |
| import re |
| import sys |
| import textwrap |
| |
| import xml.etree.ElementTree 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} = results->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])) |
| if args[0].isdigit(): |
| assert int(args[0]) > 0 |
| c("uint64_t tmp{0} = tmp{2} / tmp{1};".format(tmp_id + 2, tmp_id + 1, tmp_id)) |
| else: |
| 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 |
| |
| def emit_ulte(tmp_id, args): |
| c("uint64_t tmp{0} = {1} <= {2};".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_ult(tmp_id, args): |
| c("uint64_t tmp{0} = {1} < {2};".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_ugte(tmp_id, args): |
| c("uint64_t tmp{0} = {1} >= {2};".format(tmp_id, args[1], args[0])) |
| return tmp_id + 1 |
| |
| def emit_ugt(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) |
| ops["UGTE"] = (2, emit_ugte) |
| ops["UGT"] = (2, emit_ugt) |
| ops["ULTE"] = (2, emit_ulte) |
| ops["ULT"] = (2, emit_ult) |
| |
| |
| 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_bitwise_or(args): |
| return brkt(args[1]) + " | " + brkt(args[0]) |
| |
| def splice_logical_and(args): |
| return brkt(args[1]) + " && " + brkt(args[0]) |
| |
| def splice_umul(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]) |
| |
| def splice_ulte(args): |
| return brkt(args[1]) + " <= " + brkt(args[0]) |
| |
| def splice_ugt(args): |
| return brkt(args[1]) + " > " + brkt(args[0]) |
| |
| def splice_lshft(args): |
| return brkt(args[1]) + " << " + brkt(args[0]) |
| |
| def splice_equal(args): |
| return brkt(args[1]) + " == " + brkt(args[0]) |
| |
| exp_ops = {} |
| # (n operands, splicer) |
| exp_ops["AND"] = (2, splice_bitwise_and) |
| exp_ops["OR"] = (2, splice_bitwise_or) |
| exp_ops["UGTE"] = (2, splice_ugte) |
| exp_ops["ULT"] = (2, splice_ult) |
| exp_ops["&&"] = (2, splice_logical_and) |
| exp_ops["UMUL"] = (2, splice_umul) |
| exp_ops["<<"] = (2, splice_lshft) |
| exp_ops["=="] = (2, splice_equal) |
| |
| |
| hw_vars = {} |
| hw_vars["$EuCoresTotalCount"] = "perf->sys_vars.n_eus" |
| hw_vars["$VectorEngineTotalCount"] = "perf->sys_vars.n_eus" |
| hw_vars["$EuSlicesTotalCount"] = "perf->sys_vars.n_eu_slices" |
| hw_vars["$EuSubslicesTotalCount"] = "perf->sys_vars.n_eu_sub_slices" |
| hw_vars["$XeCoreTotalCount"] = "perf->sys_vars.n_eu_sub_slices" |
| hw_vars["$EuDualSubslicesTotalCount"] = "perf->sys_vars.n_eu_sub_slices" |
| hw_vars["$EuDualSubslicesSlice0123Count"] = "perf->sys_vars.n_eu_slice0123" |
| hw_vars["$EuThreadsCount"] = "perf->devinfo->num_thread_per_eu" |
| hw_vars["$VectorEngineThreadsCount"] = "perf->devinfo->num_thread_per_eu" |
| hw_vars["$SliceMask"] = "perf->sys_vars.slice_mask" |
| hw_vars["$SliceTotalCount"] = "perf->sys_vars.n_eu_slices" |
| # subslice_mask is interchangeable with subslice/dual-subslice since Gfx12+ |
| # only has dual subslices which can be assimilated with 16EUs subslices. |
| hw_vars["$SubsliceMask"] = "perf->sys_vars.subslice_mask" |
| hw_vars["$DualSubsliceMask"] = "perf->sys_vars.subslice_mask" |
| hw_vars["$XeCoreMask"] = "perf->sys_vars.subslice_mask" |
| hw_vars["$GpuTimestampFrequency"] = "perf->devinfo->timestamp_frequency" |
| hw_vars["$GpuMinFrequency"] = "perf->sys_vars.gt_min_freq" |
| hw_vars["$GpuMaxFrequency"] = "perf->sys_vars.gt_max_freq" |
| hw_vars["$SkuRevisionId"] = "perf->devinfo->revision" |
| hw_vars["$QueryMode"] = "perf->sys_vars.query_mode" |
| hw_vars["$ComputeEngineTotalCount"] = "perf->devinfo->engine_class_supported_count[INTEL_ENGINE_CLASS_COMPUTE]" |
| hw_vars["$CopyEngineTotalCount"] = "perf->devinfo->engine_class_supported_count[INTEL_ENGINE_CLASS_COPY]" |
| hw_vars["$L3BankTotalCount"] = "perf->sys_vars.n_l3_banks" |
| hw_vars["$L3BankMaxCount"] = "perf->sys_vars.n_l3_banks" |
| hw_vars["$L3NodeTotalCount"] = "perf->sys_vars.n_l3_nodes" |
| hw_vars["$SqidiTotalCount"] = "perf->sys_vars.n_sq_idis" |
| |
| def resolve_variable(name, set, allow_counters): |
| if name in hw_vars: |
| return hw_vars[name] |
| m = re.search(r'\$GtSlice([0-9]+)$', name) |
| if m: |
| return 'intel_device_info_slice_available(perf->devinfo, {0})'.format(m.group(1)) |
| m = re.search(r'\$GtSlice([0-9]+)XeCore([0-9]+)$', name) |
| if m: |
| return 'intel_device_info_subslice_available(perf->devinfo, {0}, {1})'.format(m.group(1), m.group(2)) |
| m = re.search(r'\$GtXeCore([0-9]+)$', name) |
| if m: |
| n = m.group(1) |
| return ( |
| 'intel_device_info_subslice_available(perf->devinfo, ' |
| '{n} / perf->devinfo->subslice_slice_stride, ' |
| '{n} % perf->devinfo->subslice_slice_stride)' |
| ).format(n=n) |
| if allow_counters and name in set.counter_vars: |
| return set.read_funcs[name[1:]] + "(perf, query, results)" |
| return None |
| |
| 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] == "$": |
| resolved_variable = resolve_variable(operand, set, True) |
| if resolved_variable == None: |
| raise Exception("Failed to resolve variable " + operand + " in equation " + equation + " for " + set.name + " :: " + counter.get('name')); |
| operand = resolved_variable |
| 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[0] == "$": |
| resolved_variable = resolve_variable(value, set, True) |
| if resolved_variable == None: |
| raise Exception("Failed to resolve variable " + operand + " in equation " + equation + " for " + set.name + " :: " + counter.get('name')); |
| value = resolved_variable |
| |
| c("\nreturn " + value + ";") |
| |
| def splice_rpn_expression(set, counter_name, 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] == "$": |
| resolved_variable = resolve_variable(operand, set, False) |
| if resolved_variable == None: |
| raise Exception("Failed to resolve variable " + operand + " in expression " + expression + " for " + set.name + " :: " + counter_name) |
| operand = resolved_variable |
| args.append(operand) |
| |
| subexp = callback(args) |
| |
| stack.append(subexp) |
| |
| if len(stack) != 1: |
| raise Exception("Spurious empty rpn expression for " + set.name + " :: " + |
| counter_name + ".\nThis is probably due to some unhandled RPN operation, in the expression \"" + |
| expression + "\"") |
| |
| value = stack[-1] |
| |
| if value[0] == "$": |
| resolved_variable = resolve_variable(value, set, False) |
| if resolved_variable == None: |
| raise Exception("Failed to resolve variable " + operand + " in expression " + expression + " for " + set.name + " :: " + counter_name) |
| value = resolved_variable |
| |
| return value |
| |
| 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 + "(UNUSED struct intel_perf_config *perf,\n") |
| c_indent(len(counter.read_sym) + 1) |
| c("const struct intel_perf_query_info *query,\n") |
| c("const struct intel_perf_query_result *results)\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_custom_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 intel_perf_config *perf,\n") |
| c_indent(len(counter.read_sym) + 1) |
| c("const struct intel_perf_query_info *query,\n") |
| c("const struct intel_perf_query_result *results)\n") |
| c_outdent(len(counter.read_sym) + 1) |
| 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_units(unit): |
| return unit.replace(' ', '_').upper() |
| |
| |
| # should a unit be visible in description? |
| units_map = { |
| "bytes" : True, |
| "cycles" : True, |
| "eu atomic requests to l3 cache lines" : False, |
| "eu bytes per l3 cache line" : False, |
| "eu requests to l3 cache lines" : False, |
| "eu sends to l3 cache lines" : False, |
| "events" : True, |
| "hz" : True, |
| "messages" : True, |
| "ns" : True, |
| "number" : False, |
| "percent" : True, |
| "pixels" : True, |
| "texels" : True, |
| "threads" : True, |
| "us" : True, |
| "utilization" : False, |
| "gbps" : True, |
| } |
| |
| |
| def desc_units(unit): |
| val = units_map.get(unit) |
| if val is None: |
| raise Exception("Unknown unit: " + unit) |
| if val == False: |
| return "" |
| if unit == 'hz': |
| unit = 'Hz' |
| return "Unit: " + unit + "." |
| |
| |
| counter_key_tuple = collections.namedtuple( |
| 'counter_key', |
| [ |
| 'name', |
| 'description', |
| 'symbol_name', |
| 'mdapi_group', |
| 'semantic_type', |
| 'data_type', |
| 'units', |
| ] |
| ) |
| |
| |
| def counter_key(counter): |
| return counter_key_tuple._make([counter.get(field) for field in counter_key_tuple._fields]) |
| |
| |
| def output_counter_struct(set, counter, idx, |
| name_to_idx, desc_to_idx, |
| symbol_name_to_idx, category_to_idx): |
| data_type = counter.data_type |
| data_type_uc = data_type.upper() |
| |
| semantic_type = counter.semantic_type |
| if semantic_type in semantic_type_map: |
| semantic_type = semantic_type_map[semantic_type] |
| |
| semantic_type_uc = semantic_type.upper() |
| |
| c("[" + str(idx) + "] = {\n") |
| c_indent(3) |
| c(".name_idx = " + str(name_to_idx[counter.name]) + ",\n") |
| c(".desc_idx = " + str(desc_to_idx[counter.description + " " + desc_units(counter.units)]) + ",\n") |
| c(".symbol_name_idx = " + str(symbol_name_to_idx[counter.symbol_name]) + ",\n") |
| c(".category_idx = " + str(category_to_idx[counter.mdapi_group]) + ",\n") |
| c(".type = INTEL_PERF_COUNTER_TYPE_" + semantic_type_uc + ",\n") |
| c(".data_type = INTEL_PERF_COUNTER_DATA_TYPE_" + data_type_uc + ",\n") |
| c(".units = INTEL_PERF_COUNTER_UNITS_" + output_units(counter.units) + ",\n") |
| c_outdent(3) |
| c("},\n") |
| |
| |
| def output_counter_report(set, counter, counter_to_idx, 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) |
| |
| key = counter_key(counter) |
| idx = str(counter_to_idx[key]) |
| |
| current_offset = pot_align(current_offset, sizeof(c_type)) |
| |
| if data_type == 'uint64': |
| c("intel_perf_query_add_counter_uint64(query, " + idx + ", " + |
| str(current_offset) + ", " + |
| set.max_funcs[counter.get('symbol_name')] + "," + |
| set.read_funcs[counter.get('symbol_name')] + ");\n") |
| else: |
| c("intel_perf_query_add_counter_float(query, " + idx + ", " + |
| str(current_offset) + ", " + |
| set.max_funcs[counter.get('symbol_name')] + "," + |
| set.read_funcs[counter.get('symbol_name')] + ");\n") |
| |
| |
| if availability: |
| c_outdent(3); |
| c("}") |
| |
| return current_offset + sizeof(c_type) |
| |
| |
| def str_to_idx_table(strs): |
| sorted_strs = sorted(strs) |
| |
| str_to_idx = collections.OrderedDict() |
| str_to_idx[sorted_strs[0]] = 0 |
| previous = sorted_strs[0] |
| |
| for i in range(1, len(sorted_strs)): |
| str_to_idx[sorted_strs[i]] = str_to_idx[previous] + len(previous) + 1 |
| previous = sorted_strs[i] |
| |
| return str_to_idx |
| |
| |
| def output_str_table(name: str, str_to_idx): |
| c("\n") |
| c("static const char " + name + "[] = {\n") |
| c_indent(3) |
| c("\n".join(f"/* {idx} */ \"{val}\\0\"" for val, idx in str_to_idx.items())) |
| c_outdent(3) |
| c("};\n") |
| |
| |
| 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) |
| |
| registers = register_config.findall('register') |
| c("static const struct intel_perf_query_register_prog %s[] = {" % t) |
| c_indent(3) |
| for register in registers: |
| c("{ .reg = %s, .val = %s }," % (register.get('address'), register.get('value'))) |
| c_outdent(3) |
| c("};") |
| c("query->config.%s = %s;" % (t, t)) |
| c("query->config.n_%s = ARRAY_SIZE(%s);" % (t, t)) |
| |
| if availability: |
| c_outdent(3) |
| c("}") |
| c("\n") |
| |
| |
| # Wraps a <counter> element from the 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')) |
| self.max_sym = self.build_max_sym() |
| |
| 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_custom_max_func(self): |
| max_eq = self.xml.get('max_equation') |
| if not max_eq: |
| return False |
| |
| try: |
| val = float(max_eq) |
| if val == 100: |
| return False |
| except ValueError: |
| pass |
| |
| for token in max_eq.split(): |
| if token[0] == '$' and resolve_variable(token, self.set, True) == None: |
| print("unresolved token " + token) |
| return False |
| return True |
| |
| def build_max_sym(self): |
| max_eq = self.xml.get('max_equation') |
| if not max_eq: |
| return "NULL" |
| |
| try: |
| val = float(max_eq) |
| if val == 100: |
| if self.xml.get('data_type') == 'uint64': |
| return "percentage_max_uint64" |
| else: |
| return "percentage_max_float" |
| except ValueError: |
| pass |
| |
| assert self.has_custom_max_func() |
| return "{0}__{1}__{2}__max".format(self.set.gen.chipset, |
| self.set.underscore_name, |
| self.xml.get('underscore_name')) |
| |
| |
| # Wraps a <set> element from the oa-*.xml files. |
| class Set: |
| def __init__(self, gen, xml): |
| self.gen = gen |
| self.xml = xml |
| |
| self.counter_vars = {} |
| self.max_funcs = {} |
| 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_funcs[counter.get('symbol_name')] = counter.max_sym |
| |
| 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 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() |
| |
| c_file = open(args.code, 'w') |
| header_file = open(args.header, '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 intel_perf_config; |
| |
| """)) |
| |
| c(copyright) |
| c(textwrap.dedent("""\ |
| #include <stdint.h> |
| #include <stdbool.h> |
| |
| #include "util/hash_table.h" |
| #include "util/ralloc.h" |
| |
| """)) |
| |
| c("#include \"" + os.path.basename(args.header) + "\"") |
| |
| c(textwrap.dedent("""\ |
| #include "perf/intel_perf.h" |
| #include "perf/intel_perf_setup.h" |
| """)) |
| |
| names = builtins.set() |
| descs = builtins.set() |
| symbol_names = builtins.set() |
| categories = builtins.set() |
| for gen in gens: |
| for set in gen.sets: |
| for counter in set.counters: |
| names.add(counter.get('name')) |
| symbol_names.add(counter.get('symbol_name')) |
| descs.add(counter.get('description') + " " + desc_units(counter.get('units'))) |
| categories.add(counter.get('mdapi_group')) |
| |
| name_to_idx = str_to_idx_table(names) |
| output_str_table("name", name_to_idx) |
| |
| desc_to_idx = str_to_idx_table(descs) |
| output_str_table("desc", desc_to_idx) |
| |
| symbol_name_to_idx = str_to_idx_table(symbol_names) |
| output_str_table("symbol_name", symbol_name_to_idx) |
| |
| category_to_idx = str_to_idx_table(categories) |
| output_str_table("category", category_to_idx) |
| |
| # 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) |
| |
| c("\n") |
| c("static const struct intel_perf_query_counter_data counters[] = {\n") |
| c_indent(3) |
| |
| counter_to_idx = collections.OrderedDict() |
| idx = 0 |
| for gen in gens: |
| for set in gen.sets: |
| for counter in set.counters: |
| key = counter_key(counter) |
| if key not in counter_to_idx: |
| counter_to_idx[key] = idx |
| output_counter_struct(set, key, idx, |
| name_to_idx, |
| desc_to_idx, |
| symbol_name_to_idx, |
| category_to_idx) |
| idx += 1 |
| |
| c_outdent(3) |
| c("};\n\n") |
| |
| c(textwrap.dedent("""\ |
| static void ATTRIBUTE_NOINLINE |
| intel_perf_query_add_counter_uint64(struct intel_perf_query_info *query, |
| int counter_idx, size_t offset, |
| intel_counter_read_uint64_t oa_counter_max, |
| intel_counter_read_uint64_t oa_counter_read) |
| { |
| struct intel_perf_query_counter *dest = &query->counters[query->n_counters++]; |
| const struct intel_perf_query_counter_data *counter = &counters[counter_idx]; |
| |
| dest->name = &name[counter->name_idx]; |
| dest->desc = &desc[counter->desc_idx]; |
| dest->symbol_name = &symbol_name[counter->symbol_name_idx]; |
| dest->category = &category[counter->category_idx]; |
| |
| dest->offset = offset; |
| dest->type = counter->type; |
| dest->data_type = counter->data_type; |
| dest->units = counter->units; |
| dest->oa_counter_max_uint64 = oa_counter_max; |
| dest->oa_counter_read_uint64 = oa_counter_read; |
| } |
| |
| static void ATTRIBUTE_NOINLINE |
| intel_perf_query_add_counter_float(struct intel_perf_query_info *query, |
| int counter_idx, size_t offset, |
| intel_counter_read_float_t oa_counter_max, |
| intel_counter_read_float_t oa_counter_read) |
| { |
| struct intel_perf_query_counter *dest = &query->counters[query->n_counters++]; |
| const struct intel_perf_query_counter_data *counter = &counters[counter_idx]; |
| |
| dest->name = &name[counter->name_idx]; |
| dest->desc = &desc[counter->desc_idx]; |
| dest->symbol_name = &symbol_name[counter->symbol_name_idx]; |
| dest->category = &category[counter->category_idx]; |
| |
| dest->offset = offset; |
| dest->type = counter->type; |
| dest->data_type = counter->data_type; |
| dest->units = counter->units; |
| dest->oa_counter_max_float = oa_counter_max; |
| dest->oa_counter_read_float = oa_counter_read; |
| } |
| |
| static float ATTRIBUTE_NOINLINE |
| percentage_max_float(struct intel_perf_config *perf, |
| const struct intel_perf_query_info *query, |
| const struct intel_perf_query_result *results) |
| { |
| return 100; |
| } |
| |
| static uint64_t ATTRIBUTE_NOINLINE |
| percentage_max_uint64(struct intel_perf_config *perf, |
| const struct intel_perf_query_info *query, |
| const struct intel_perf_query_result *results) |
| { |
| return 100; |
| } |
| """)) |
| |
| # 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") |
| c("\nstatic void\n") |
| c("{0}_register_{1}_counter_query(struct intel_perf_config *perf)\n".format(gen.chipset, set.underscore_name)) |
| c("{\n") |
| c_indent(3) |
| |
| c("struct intel_perf_query_info *query = intel_query_alloc(perf, %u);\n" % len(counters)) |
| c("\n") |
| c("query->name = \"" + set.name + "\";\n") |
| c("query->symbol_name = \"" + set.symbol_name + "\";\n") |
| c("query->guid = \"" + set.hw_config_guid + "\";\n") |
| |
| c("\n") |
| c("struct intel_perf_query_counter *counter = query->counters;\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, counter_to_idx, offset) |
| |
| |
| c("\ncounter = &query->counters[query->n_counters - 1];\n") |
| c("query->data_size = counter->offset + intel_perf_query_counter_get_size(counter);\n") |
| |
| c_outdent(3) |
| c("}"); |
| |
| c("\n_mesa_hash_table_insert(perf->oa_metrics_table, query->guid, query);") |
| |
| c_outdent(3) |
| c("}\n") |
| |
| h("void intel_oa_register_queries_" + gen.chipset + "(struct intel_perf_config *perf);\n") |
| |
| c("\nvoid") |
| c("intel_oa_register_queries_" + gen.chipset + "(struct intel_perf_config *perf)") |
| c("{") |
| c_indent(3) |
| |
| for set in gen.sets: |
| c("{0}_register_{1}_counter_query(perf);".format(gen.chipset, set.underscore_name)) |
| |
| c_outdent(3) |
| c("}") |
| |
| |
| if __name__ == '__main__': |
| main() |
