Skeleton for CM3 additions and integration

Author: mhkarsten

examples/picocm3-profiling/README.md

@@ -0,0 +1,139 @@
+from EventManager.Models.RunnerEvents import RunnerEvents
+from EventManager.EventSubscriptionController import EventSubscriptionController
+from ConfigValidator.Config.Models.RunTableModel import RunTableModel
+from ConfigValidator.Config.Models.FactorModel import FactorModel
+from ConfigValidator.Config.Models.RunnerContext import RunnerContext
+from ConfigValidator.Config.Models.OperationType import OperationType
+from ProgressManager.Output.OutputProcedure import OutputProcedure as output
+
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+from os.path import dirname, realpath
+
+import os
+import signal
+import pandas as pd
+import time
+import subprocess
+import shlex
+
+class RunnerConfig:
+    ROOT_DIR = Path(dirname(realpath(__file__)))
+
+    # ================================ USER SPECIFIC CONFIG ================================
+    """The name of the experiment."""
+    name:                       str             = "new_picocm3_experiment"
+
+    """The path in which Experiment Runner will create a folder with the name `self.name`, in order to store the
+    results from this experiment. (Path does not need to exist - it will be created if necessary.)
+    Output path defaults to the config file's path, inside the folder 'experiments'"""
+    results_output_path:        Path             = ROOT_DIR / 'experiments'
+
+    """Experiment operation type. Unless you manually want to initiate each run, use `OperationType.AUTO`."""
+    operation_type:             OperationType   = OperationType.AUTO
+
+    """The time Experiment Runner will wait after a run completes.
+    This can be essential to accommodate for cooldown periods on some systems."""
+    time_between_runs_in_ms:    int             = 1000
+
+    # Dynamic configurations can be one-time satisfied here before the program takes the config as-is
+    # e.g. Setting some variable based on some criteria
+    def __init__(self):
+        """Executes immediately after program start, on config load"""
+
+        EventSubscriptionController.subscribe_to_multiple_events([
+            (RunnerEvents.BEFORE_EXPERIMENT, self.before_experiment),
+            (RunnerEvents.BEFORE_RUN       , self.before_run       ),
+            (RunnerEvents.START_RUN        , self.start_run        ),
+            (RunnerEvents.START_MEASUREMENT, self.start_measurement),
+            (RunnerEvents.INTERACT         , self.interact         ),
+            (RunnerEvents.STOP_MEASUREMENT , self.stop_measurement ),
+            (RunnerEvents.STOP_RUN         , self.stop_run         ),
+            (RunnerEvents.POPULATE_RUN_DATA, self.populate_run_data),
+            (RunnerEvents.AFTER_EXPERIMENT , self.after_experiment )
+        ])
+        self.run_table_model = None  # Initialized later
+        output.console_log("Custom config loaded")
+
+    def create_run_table_model(self) -> RunTableModel:
+        """Create and return the run_table model here. A run_table is a List (rows) of tuples (columns),
+        representing each run performed"""
+        sampling_factor = FactorModel("sampling", [10, 50, 100, 200, 500, 1000])
+        self.run_table_model = RunTableModel(
+            factors = [sampling_factor],
+            data_columns=['dram_energy', 'package_energy',
+                          'pp0_energy', 'pp1_energy']
+
+        )
+        return self.run_table_model
+
+    def before_experiment(self) -> None:
+        """Perform any activity required before starting the experiment here
+        Invoked only once during the lifetime of the program."""
+        pass
+
+    def before_run(self) -> None:
+        """Perform any activity required before starting a run.
+        No context is available here as the run is not yet active (BEFORE RUN)"""
+        pass
+
+    def start_run(self, context: RunnerContext) -> None:
+        """Perform any activity required for starting the run here.
+        For example, starting the target system to measure.
+        Activities after starting the run should also be performed here."""
+        pass
+
+    def start_measurement(self, context: RunnerContext) -> None:
+        """Perform any activity required for starting measurements."""
+        sampling_interval = context.run_variation['sampling']
+
+        profiler_cmd = f'sudo energibridge \
+                        --interval {sampling_interval} \
+                        --max-execution 20 \
+                        --output {context.run_dir / "energibridge.csv"} \
+                        --summary \
+                        python3 examples/energibridge-profiling/primer.py'
+
+        #time.sleep(1) # allow the process to run a little before measuring
+        energibridge_log = open(f'{context.run_dir}/energibridge.log', 'w')
+        self.profiler = subprocess.Popen(shlex.split(profiler_cmd), stdout=energibridge_log)
+
+    def interact(self, context: RunnerContext) -> None:
+        """Perform any interaction with the running target system here, or block here until the target finishes."""
+
+        # No interaction. We just run it for XX seconds.
+        # Another example would be to wait for the target to finish, e.g. via `self.target.wait()`
+        output.console_log("Running program for 20 seconds")
+        time.sleep(20)
+
+    def stop_measurement(self, context: RunnerContext) -> None:
+        """Perform any activity here required for stopping measurements."""
+        self.profiler.wait()
+
+    def stop_run(self, context: RunnerContext) -> None:
+        """Perform any activity here required for stopping the run.
+        Activities after stopping the run should also be performed here."""
+        pass
+    
+    def populate_run_data(self, context: RunnerContext) -> Optional[Dict[str, Any]]:
+        """Parse and process any measurement data here.
+        You can also store the raw measurement data under `context.run_dir`
+        Returns a dictionary with keys `self.run_table_model.data_columns` and their values populated"""
+
+        # energibridge.csv - Power consumption of the whole system
+        df = pd.read_csv(context.run_dir / f"energibridge.csv")
+        run_data = {
+                'dram_energy'   : round(df['DRAM_ENERGY (J)'].sum(), 3),
+                'package_energy': round(df['PACKAGE_ENERGY (J)'].sum(), 3),
+                'pp0_energy'    : round(df['PP0_ENERGY (J)'].sum(), 3),
+                'pp1_energy'    : round(df['PP1_ENERGY (J)'].sum(), 3),
+        }
+        return run_data
+
+    def after_experiment(self) -> None:
+        """Perform any activity required after stopping the experiment here
+        Invoked only once during the lifetime of the program."""
+        pass
+
+    # ================================ DO NOT ALTER BELOW THIS LINE ================================
+    experiment_path:            Path             = None

examples/picocm3-profiling/RunnerConfig.py

@@ -0,0 +1,37 @@
+import os
+import ctypes
+from picosdk.plcm3 import plcm3
+from platform import uname
+
+
+class PicoCM3(object):
+    """An integration of PicoTech CM3 current data logger (https://www.picotech.com/download/manuals/PicoLogCM3CurrentDataLoggerUsersGuide.pdf)"""
+    SAMPLE_FREQUENCY = 1000 # in ms
+    CHANNEL_SETTINGS = {
+
+    }
+    
+    def __init__(self):
+        # Check if a CM3 is present
+        pass
+
+    def mode(self, runmode):
+        pass
+
+    def log(self,timeout, logfile = None):
+        pass
+
+    # Returns a tuple (scaled_value, unit_string)
+    def apply_scaling(value, channel_mode):
+        if channel_mode == plcm3.PLCM3DataTypes["PLCM3_OFF"]:
+            return (0, "")
+        elif channel_mode == plcm3.PLCM3DataTypes["PLCM3_1_MILLIVOLT"]:
+            return (value / 1000, "A")
+        elif channel_mode == plcm3.PLCM3DataTypes["PLCM3_10_MILLIVOLTS"]:
+            return (value / 1000.0, "A")
+        elif channel_mode == plcm3.PLCM3DataTypes["PLCM3_100_MILLIVOLTS"]:
+            return (value, "mA")
+        elif channel_mode == plcm3.PLCM3DataTypes["PLCM3_VOLTAGE"]:
+            return (value / 1000.0, "mV")
+        else:
+            return (-1, "invalid mode")

experiment-runner/Plugins/Profilers/PicoCM3.py

@@ -0,0 +1,3 @@
+#
+# Copyright (C) 2018 Pico Technology Ltd. See LICENSE file for terms.
+#