Doku

1 files changed, 204 insertions, 12 deletions

diff --git a/lib/dfatool.py b/lib/dfatool.py
index 3cc46dc..657a7b1 100755
--- a/lib/dfatool.py
+++ b/lib/dfatool.py
@@ -20,10 +20,23 @@ from utils import is_numeric
 arg_support_enabled = True
 
 def running_mean(x, N):
+    """
+    Compute running average.
+
+    arguments:
+    x -- NumPy array
+    N -- how many items to average
+    """
     cumsum = np.cumsum(np.insert(x, 0, 0))
     return (cumsum[N:] - cumsum[:-N]) / N
 
 def soft_cast_int(n):
+    """
+    Convert to int, if possible.
+
+    If it is empty, returns None.
+    If it is not numeric, it is left unchanged.
+    """
     if n == None or n == '':
         return None
     try:
@@ -32,6 +45,7 @@ def soft_cast_int(n):
         return n
 
 def float_or_nan(n):
+    """Convert to float (if numeric) or NaN."""
     if n == None:
         return np.nan
     try:
@@ -40,9 +54,16 @@ def float_or_nan(n):
         return np.nan
 
 def vprint(verbose, string):
+    """
+    Print string if verbose.
+
+    Prints string if verbose is a True value
+    """
     if verbose:
         print(string)
 
+    # I don't recall what these are for.
+    # --df, 2019-01-29
     def _gplearn_add_(x, y):
         return x + y
 
@@ -94,19 +115,55 @@ def _arg_name(arg_index):
     return '~arg{:02}'.format(arg_index)
 
 def append_if_set(aggregate, data, key):
+    """Append data[key] to aggregate if key in data."""
     if key in data:
         aggregate.append(data[key])
 
 def mean_or_none(arr):
+    """
+    Compute mean of NumPy array arr.
+
+    Return -1 if arr is empty.
+    """
     if len(arr):
         return np.mean(arr)
     return -1
 
 def aggregate_measures(aggregate, actual):
+    """
+    Calculate error measures for model value on data list.
+
+    arguments:
+    aggregate -- model value (float or int)
+    actual -- real-world / reference values (list of float or int)
+
+    return value:
+    See regression_measures
+    """
     aggregate_array = np.array([aggregate] * len(actual))
     return regression_measures(aggregate_array, np.array(actual))
 
 def regression_measures(predicted, actual):
+    """
+    Calculate error measures by comparing model values to reference values.
+
+    arguments:
+    predicted -- model values (np.ndarray)
+    actual -- real-world / reference values (np.ndarray)
+
+    Returns a dict containing the following measures:
+    mae -- Mean Absolute Error
+    mape -- Mean Absolute Percentage Error,
+            if all items in actual are non-zero (NaN otherwise)
+    smape -- Symmetric Mean Absolute Percentage Error,
+             if no 0,0-pairs are present in actual and predicted (NaN otherwise)
+    msd -- Mean Square Deviation
+    rmsd -- Root Mean Square Deviation
+    ssr -- Sum of Squared Residuals
+    rsq -- R^2 measure, see sklearn.metrics.r2_score
+    count -- Number of values
+    """
+
     if type(predicted) != np.ndarray:
         raise ValueError('first arg must be ndarray, is {}'.format(type(predicted)))
     if type(actual) != np.ndarray:
@@ -209,8 +266,20 @@ def _preprocess_measurement(measurement):
     return processed_data
 
 class RawData:
+    """
+    Loader for hardware model traces measured with MIMOSA.
+
+    Expects a specific trace format and UART log output (as produced by the
+    dfatool benchmark generator). Loads data, prunes bogus measurements, and
+    provides preprocessed data suitable for EnergyModel.
+    """
 
     def __init__(self, filenames):
+        """
+        Create a new RawData object.
+
+        Each filename element corresponds to a measurement run.
+        """
         self.filenames = filenames.copy()
         self.traces_by_fileno = []
         self.setup_by_fileno = []
@@ -388,17 +457,22 @@ class RawData:
             trace['id'] = i
 
     def get_preprocessed_data(self, verbose = True):
+        """
+        Return a list of DFA traces annotated with energy, timing, and parameter data.
+
+        Suitable for the EnergyModel constructor.
+        See EnergyModel(...) docstring for format details.
+        """
         self.verbose = verbose
         if self.preprocessed:
             return self.traces
         if self.version == 0:
-            self.preprocess_0()
+            self._preprocess_0()
         self.preprocessed = True
         return self.traces
 
-    # Loads raw MIMOSA data and turns it into measurements which are ready to
-    # be analyzed.
-    def preprocess_0(self):
+    def _preprocess_0(self):
+        """Load raw MIMOSA data and turn it into measurements which are ready to be analyzed."""
         mim_files = []
         for i, filename in enumerate(self.filenames):
             with tarfile.open(filename) as tf:
@@ -437,6 +511,20 @@ class RawData:
         }
 
 def _param_slice_eq(a, b, index):
+    """
+    Check if by_param keys a and b are identical, ignoring the parameter at index.
+
+    parameters:
+    a, b -- (state/transition name, [parameter0 value, parameter1 value, ...])
+    index -- parameter index to ignore (0 -> parameter0, 1 -> parameter1, etc.)
+
+    Returns True iff a and b have the same state/transition name, and all
+    parameters at positions != index are identical.
+
+    example:
+    ('foo', [1, 4]), ('foo', [2, 4]), 0 -> True
+    ('foo', [1, 4]), ('foo', [2, 4]), 1 -> False
+    """
     if (*a[1][:index], *a[1][index+1:]) == (*b[1][:index], *b[1][index+1:]) and a[0] == b[0]:
         return True
     return False
@@ -528,7 +616,7 @@ def _compute_param_statistics_parallel(args):
         'result' : _compute_param_statistics(*args['args'])
     }
 
-def all_params_are_numeric(data, param_idx):
+def _all_params_are_numeric(data, param_idx):
     param_values = list(map(lambda x: x[param_idx], data['param']))
     if len(list(filter(is_numeric, param_values))) == len(param_values):
         return True
@@ -554,13 +642,24 @@ def _compute_param_statistics(by_name, by_param, parameter_names, num_args, stat
 
     return ret
 
-# returns the mean standard deviation of all measurements of 'what'
-# (e.g. power consumption or timeout) for state/transition 'name' where
-# parameter 'index' is dynamic and all other parameters are fixed.
-# I.e., if parameters are a, b, c ∈ {1,2,3} and 'index' corresponds to b', then
-# this function returns the mean of the standard deviations of (a=1, b=*, c=1),
-# (a=1, b=*, c=2), and so on
 def _mean_std_by_param(by_param, state_or_tran, key, param_index):
+    u"""
+    Calculate the mean standard deviation for a static model where all parameters but param_index are constant.
+
+    arguments:
+    by_param -- measurements sorted by key/transition name and parameter values
+    state_or_tran -- state or transition name (-> by_param[(state_or_tran, *)])
+    key -- model attribute, e.g. 'power' or 'duration'
+           (-> by_param[(state_or_tran, *)][key])
+    param_index -- index of variable parameter
+
+    Returns the mean standard deviation of all measurements of 'key'
+    (e.g. power consumption or timeout) for state/transition 'state_or_tran' where
+    parameter 'param_index' is dynamic and all other parameters are fixed.
+    I.e., if parameters are a, b, c ∈ {1,2,3} and 'index' corresponds to b, then
+    this function returns the mean of the standard deviations of (a=1, b=*, c=1),
+    (a=1, b=*, c=2), and so on.
+    """
     partitions = []
     for param_value in filter(lambda x: x[0] == state_or_tran, by_param.keys()):
         param_partition = []
@@ -574,7 +673,7 @@ def _mean_std_by_param(by_param, state_or_tran, key, param_index):
     return np.mean([np.std(partition) for partition in partitions])
 
 def _corr_by_param(by_name, state_or_trans, key, param_index):
-    if all_params_are_numeric(by_name[state_or_trans], param_index):
+    if _all_params_are_numeric(by_name[state_or_trans], param_index):
         param_values = np.array(list((map(lambda x: x[param_index], by_name[state_or_trans]['param']))))
         try:
             return np.corrcoef(by_name[state_or_trans][key], param_values)[0, 1]
@@ -587,8 +686,101 @@ def _corr_by_param(by_name, state_or_trans, key, param_index):
         return 0.
 
 class EnergyModel:
+    """
+    parameter-aware PTA-based energy model.
+
+    Supports both static and parameter-based model attributes, and automatic detection of parameter-dependence.
+    """
 
     def __init__(self, preprocessed_data, ignore_trace_indexes = [], discard_outliers = None, function_override = {}, verbose = True, use_corrcoef = False, hwmodel = None):
+        """
+        Prepare a new PTA energy model.
+
+        Actual model generation is done on-demand by calling the respective functions.
+
+        arguments:
+        preprocessed_data -- list of preprocessed DFA traces.
+        ignore_trace_indexes -- list of trace indexes. The corresponding taces will be ignored.
+        discard_outliers -- experimental: threshold for outlier detection and removel (float).
+            Outlier detection is performed individually for each state/transition in each trace,
+            so it only works if the benchmark ran several times.
+            Given "data" (a set of measurements of the same thing, e.g. TX duration in the third benchmark trace),
+            "m" (the median of all attribute measurements with the same parameters, which may include data from other traces),
+            a data point X is considered an outlier if
+            | 0.6745 * (X - m) / median(|data - m|) | > discard_outliers .
+        function_override -- dict of overrides for automatic parameter function generation.
+            If (state or transition name, model attribute) is present in function_override,
+            the corresponding text string is the function used for analytic (parameter-aware/fitted)
+            modeling of this attribute. It is passed to AnalyticFunction, see
+            there for the required format. Note that this happens regardless of
+            parameter dependency detection: The provided analytic function will be assigned
+            even if it seems like the model attribute is static / parameter-independent.
+        verbose -- print informative output, e.g. when removing an outlier
+        use_corrcoef -- use correlation coefficient instead of stddev comparison
+            to detect whether a model attribute depends on a parameter
+        hwmodel -- hardware model suitable for PTA.from_hwmodel
+
+        Detailed layout of preprocessed_data:
+        [ ... Liste von einzelnen Läufen (d.h. eine Zustands- und Transitionsfolge UNINITIALIZED -> foo -> FOO -> bar -> BAR -> ...)
+            Jeder Lauf:
+            - id: int Nummer des Laufs, beginnend bei 1
+            - trace: [ ... Liste von Zuständen und Transitionen
+                Jeweils:
+                - name: str Name
+                - isa: str state // transition
+                - parameter: { ... globaler Parameter: aktueller wert. null falls noch nicht eingestellt }
+                - plan:
+                    Falls isa == 'state':
+                    - power: int(uW?)
+                    - time: int(us) geplante Dauer
+                    - energy: int(pJ?)
+                    Falls isa == 'transition':
+                    - timeout: int(us) oder null
+                    - energy: int (pJ?)
+                    - level: str 'user' 'epilogue'
+                - offline_attributes: [ ... Namen der in offline_aggregates gespeicherten Modellattribute, z.B. param, duration, energy, timeout ]
+                - offline_aggregates:
+                    - power: [float(uW)] Mittlere Leistung während Zustand/Transitions
+                    - power_std: [float(uW^2)] Standardabweichung der Leistung
+                    - duration: [int(us)] Dauer
+                    - energy: [float(pJ)] Energieaufnahme des Zustands / der Transition
+                    - clip_rate: [float(0..1)] Clipping
+                    - paramkeys: [[str]] Name der berücksichtigten Parameter
+                    - param: [int // str] Parameterwerte. Quasi-Duplikat von 'parameter' oben
+                    Falls isa == 'transition':
+                    - timeout: [int(us)] Dauer des vorherigen Zustands
+                    - rel_energy_prev: [int(pJ)]
+                    - rel_energy_next: [int(pJ)]
+                - offline: [ ... Während der Messung von MIMOSA o.ä. gemessene Werte
+                    -> siehe doc/MIMOSA analyze_states
+                    - isa: 'state' oder 'transition'
+                    - clip_rate: range(0..1) Anteil an Clipping im Energieverbrauch
+                    - raw_mean: Mittelwert der Rohwerte
+                    - raw_std: Standardabweichung der Rohwerte
+                    - uW_mean: Mittelwert der (kalibrierten) Leistungsaufnahme
+                    - uW_std: Standardabweichung der (kalibrierten) Leistungsaufnahme
+                    - us: Dauer
+                    Nur falls isa 'transition':
+                    - timeout: Dauer des vorherigen Zustands
+                    - uW_mean_delta_prev
+                    - uW_mean_delta_next
+                ]
+                - online: [ ... Während der Messung vom Betriebssystem bestimmte Daten
+                    Falls isa == 'state':
+                    - power: int(uW?)
+                    - time: int(us) geplante Dauer
+                    - energy: int(pJ?)
+                    Falls isa == 'transition':
+                    - timeout: int(us) oder null
+                    - energy: int (pJ?)
+                    - level: str ('user' oder 'epilogue')
+                ]
+                Falls isa == 'transition':
+                - code: [str] Name und Argumente der aufgerufenen Funktion
+                - args: [str] Argumente der aufgerufenen Funktion
+            ]
+        ]
+        """
         self.traces = preprocessed_data
         self.by_name = {}
         self.by_param = {}