From 2546a93b8b2a3ecdea77bbf38332c4dd77d83239 Mon Sep 17 00:00:00 2001 From: Daniel Friesel Date: Thu, 10 Sep 2020 16:02:32 +0200 Subject: add kconfig benchmark loader and model generation --- lib/loader.py | 58 +++++++++++++++++++++++----- lib/model.py | 119 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 165 insertions(+), 12 deletions(-) (limited to 'lib') diff --git a/lib/loader.py b/lib/loader.py index 57b3d30..3f0662e 100644 --- a/lib/loader.py +++ b/lib/loader.py @@ -10,6 +10,7 @@ import re import struct import tarfile import hashlib +import kconfiglib from multiprocessing import Pool from .utils import running_mean, soft_cast_int @@ -1090,7 +1091,7 @@ def _add_trace_data_to_aggregate(aggregate, key, element): def pta_trace_to_aggregate(traces, ignore_trace_indexes=[]): - u""" + """ Convert preprocessed DFA traces from peripherals/drivers to by_name aggregate for PTAModel. arguments: @@ -1296,7 +1297,7 @@ class EnergyTraceLog: return self._ts_to_index(timestamp, mid_index, right_index) def analyze_states(self, traces, offline_index: int): - u""" + """ Split log data into states and transitions and return duration, energy, and mean power for each element. :param traces: expected traces, needed to synchronize with the measurement. @@ -1630,7 +1631,7 @@ class MIMOSA: self.errors = list() def charge_to_current_nocal(self, charge): - u""" + """ Convert charge per 10µs (in pJ) to mean currents (in µA) without accounting for calibration. :param charge: numpy array of charges (pJ per 10µs) as returned by `load_data` or `load_file` @@ -1642,7 +1643,7 @@ class MIMOSA: return charge * ua_step def _load_tf(self, tf): - u""" + """ Load MIMOSA log data from an open `tarfile` instance. :param tf: `tarfile` instance @@ -1663,7 +1664,7 @@ class MIMOSA: return charges, triggers def load_data(self, raw_data): - u""" + """ Load MIMOSA log data from a MIMOSA log file passed as raw byte string :param raw_data: MIMOSA log file, passed as raw byte string @@ -1675,7 +1676,7 @@ class MIMOSA: return self._load_tf(tf) def load_file(self, filename): - u""" + """ Load MIMOSA log data from a MIMOSA log file :param filename: MIMOSA log file @@ -1686,7 +1687,7 @@ class MIMOSA: return self._load_tf(tf) def currents_nocal(self, charges): - u""" + """ Convert charges (pJ per 10µs) to mean currents without accounting for calibration. :param charges: numpy array of charges (pJ per 10µs) @@ -1743,7 +1744,7 @@ class MIMOSA: return trigidx def calibration_edges(self, currents): - u""" + """ Return start/stop indexes of calibration measurements. :param currents: uncalibrated currents as reported by MIMOSA. For best results, @@ -1780,7 +1781,7 @@ class MIMOSA: ) def calibration_function(self, charges, cal_edges): - u""" + """ Calculate calibration function from previously determined calibration edges. :param charges: raw charges from MIMOSA @@ -1870,7 +1871,7 @@ class MIMOSA: return calfunc, caldata def analyze_states(self, charges, trigidx, ua_func): - u""" + """ Split log data into states and transitions and return duration, energy, and mean power for each element. :param charges: raw charges (each element describes the charge in pJ transferred during 10 µs) @@ -1940,3 +1941,40 @@ class MIMOSA: previdx = idx is_state = not is_state return iterdata + + +class KConfigAttributes: + def __init__(self, kconfig_path, datadir): + experiments = list() + for direntry in os.listdir(datadir): + config_path = f"{datadir}/{direntry}/.config" + attr_path = f"{datadir}/{direntry}/attributes.json" + if os.path.exists(attr_path): + experiments.append((config_path, attr_path)) + + kconf = kconfiglib.Kconfig(kconfig_path) + + self.symbols = sorted( + map( + lambda sym: sym.name, + filter( + lambda sym: kconfiglib.TYPE_TO_STR[sym.type] == "bool", + kconf.syms.values(), + ), + ) + ) + + self.data = list() + + config_vectors = set() + + for config_path, attr_path in experiments: + kconf.load_config(config_path) + with open(attr_path, "r") as f: + attr = json.load(f) + + config_vector = tuple( + map(lambda sym: kconf.syms[sym].tri_value == 2, self.symbols) + ) + config_vectors.add(config_vector) + self.data.append((config_vector, attr)) diff --git a/lib/model.py b/lib/model.py index bb4a45b..a953c46 100644 --- a/lib/model.py +++ b/lib/model.py @@ -2,6 +2,7 @@ import logging import numpy as np +import kconfiglib from scipy import optimize from sklearn.metrics import r2_score from multiprocessing import Pool @@ -375,7 +376,7 @@ def _num_args_from_by_name(by_name): class AnalyticModel: - u""" + """ Parameter-aware analytic energy/data size/... model. Supports both static and parameter-based model attributes, and automatic detection of parameter-dependence. @@ -663,7 +664,7 @@ class AnalyticModel: class PTAModel: - u""" + """ Parameter-aware PTA-based energy model. Supports both static and parameter-based model attributes, and automatic detection of parameter-dependence. @@ -1154,3 +1155,117 @@ class PTAModel: np.array(model_state_energy_list), np.array(real_energy_list) ), } + + +class KConfigModel: + class Leaf: + def __init__(self, value, stddev): + self.value = value + self.stddev = stddev + + def model(self, kconf): + return self.value + + def __repr__(self): + return f"" + + def to_json(self): + return {"value": self.value, "stddev": self.stddev} + + class Node: + def __init__(self, symbol): + self.symbol = symbol + self.child_n = None + self.child_y = None + + def set_child_n(self, child_node): + self.child_n = child_node + + def set_child_y(self, child_node): + self.child_y = child_node + + def model(self, kconf): + if kconf.syms[self.symbol].tri_value == 0 and self.child_n: + return self.child_n.model(kconf) + if kconf.syms[self.symbol].tri_value == 2 and self.child_y: + return self.child_y.model(kconf) + return None + + def __repr__(self): + return f"" + + def to_json(self): + ret = {"symbol": self.symbol} + if self.child_n: + ret["n"] = self.child_n.to_json() + else: + ret["n"] = None + if self.child_y: + ret["y"] = self.child_y.to_json() + else: + ret["y"] = None + return ret + + def __init__(self, kconfig_benchmark): + self.data = kconfig_benchmark.data + self.symbols = kconfig_benchmark.symbols + model = self.get_min(self.symbols, self.data, 0) + + output = {"model": model.to_json(), "symbols": self.symbols} + print(output) + + # with open("kconfigmodel.json", "w") as f: + # json.dump(output, f) + + def get_min(self, this_symbols, this_data, level): + + rom_sizes = list(map(lambda x: x[1]["total"]["ROM"], this_data)) + + if np.std(rom_sizes) < 100 or len(this_symbols) == 0: + return self.Leaf(np.mean(rom_sizes), np.std(rom_sizes)) + + mean_stds = list() + for i, param in enumerate(this_symbols): + enabled = list(filter(lambda vrr: vrr[0][i] == True, this_data)) + disabled = list(filter(lambda vrr: vrr[0][i] == False, this_data)) + + enabled_std_rom = np.std(list(map(lambda x: x[1]["total"]["ROM"], enabled))) + disabled_std_rom = np.std( + list(map(lambda x: x[1]["total"]["ROM"], disabled)) + ) + children = [enabled_std_rom, disabled_std_rom] + + if np.any(np.isnan(children)): + mean_stds.append(np.inf) + else: + mean_stds.append(np.mean(children)) + + symbol_index = np.argmin(mean_stds) + symbol = this_symbols[symbol_index] + enabled = list(filter(lambda vrr: vrr[0][symbol_index] == True, this_data)) + disabled = list(filter(lambda vrr: vrr[0][symbol_index] == False, this_data)) + + node = self.Node(symbol) + + new_symbols = this_symbols[:symbol_index] + this_symbols[symbol_index + 1 :] + enabled = list( + map( + lambda x: (x[0][:symbol_index] + x[0][symbol_index + 1 :], x[1]), + enabled, + ) + ) + disabled = list( + map( + lambda x: (x[0][:symbol_index] + x[0][symbol_index + 1 :], x[1]), + disabled, + ) + ) + print( + f"Level {level} split on {symbol} has {len(enabled)} children when enabled and {len(disabled)} children when disabled" + ) + if len(enabled): + node.set_child_y(self.get_min(new_symbols, enabled, level + 1)) + if len(disabled): + node.set_child_n(self.get_min(new_symbols, disabled, level + 1)) + + return node -- cgit v1.2.3