Final elements of the PicoLog CM3 Plugin + tests

+ a small change to test-standalone/runner.sh to make it work on my system
+ another small change to JSONOutputManager.py, to make it compatible with the versioning I had installed

Author: mhkarsten

.gitignore

@@ -1,5 +1,6 @@
 .idea
 .venv
+.vagrant
 */__pycache__/*
 examples/linux-ps-profiling/primer
 examples/linux-powerjoular-profiling/primer
@@ -15,3 +16,5 @@ pycharm-interpreter.sh
 python
 
 Session.vim
+
+Vagrantfile

examples/picocm3-profiling/README.md

@@ -2,28 +2,37 @@
 # `PicoLog CM3` profiler
 
 A simple Linux example that uses stress-ng on a storage device and measures power consumption 
-using a [PicoLog CM3](https://github.com/tdurieux/EnergiBridge).
+using a [PicoLog CM3](https://www.picotech.com/download/manuals/PicoLogCM3CurrentDataLoggerUsersGuide.pdf).
 
 As an example program, a simple program is used that repeatedly checks 
 if random numbers are prime or not.
 
 ## Requirements
 
-A [PicoLog CM3](https://github.com/tdurieux/EnergiBridge) device is required with a clamp of
-the correct variety for your task
+A [PicoLog CM3](https://www.picotech.com/download/manuals/PicoLogCM3CurrentDataLoggerUsersGuide.pdf) device is required with a clamp of
+the correct variety for your task.
 
-The [PicoLog CM3 Driver](https://github.com/tdurieux/EnergiBridge) is assumed to be already installed.
+The [PicoLog CM3 Driver](https://www.picotech.com/downloads/linux) is assumed to be already installed.
 
-Instructions to install the drivers for your operating system can be found [here]().
+Instructions to install the drivers for your operating system can be found [here](https://www.picotech.com/downloads/linux).
+
+For this example program, [stress-ng](https://github.com/ColinIanKing/stress-ng) is additionally required as an example of something to measure, but this can be replaced with any other program, or simply a call to sleep if the device is not controlled through software.
+
+Ensure you have the paremeters for stress-ng properly configured, such that an appropriate storage device is selected, and the PicoLog clamp has been correctly attached to the wire.
 
 ## Running
 
-From the root directory of the repo, run the following command:
+From the root directory of the repo, run the following commands:
 
 ```bash
-python experiment-runner/examples/picocm3-profiling/RunnerConfig.py
+
+# REQUIRED: Ensure this path matches where your PicoLog CM3 drivers are stored
+export LD_LIBRARY_PATH="/opt/picoscope/lib" 
+
+python experiment-runner/ examples/picocm3-profiling/RunnerConfig.py
 ```
 
 ## Results
 
 The results are generated in the `examples/picocm3-profiling/experiments` folder.
+There should be a unique log file for each variation in the experiment, as well as a run_table.csv file summarizing these log files.

examples/picocm3-profiling/RunnerConfig.py

@@ -10,18 +10,12 @@
 from pathlib import Path
 from os.path import dirname, realpath
 
-import time
 import subprocess
 import shlex
+from statistics import mean
 
 from Plugins.Profilers.PicoCM3 import PicoCM3, CM3DataTypes, CM3Channels
 
-# TODO
-# Finish parsing / averaging the values to place in the results table
-# Finish the documentation in 2 places
-# Test the implementation
-# Write actual test code to test the implementaiton
-
 class RunnerConfig:
     ROOT_DIR = Path(dirname(realpath(__file__)))
 
@@ -58,19 +52,19 @@ def __init__(self):
             (RunnerEvents.AFTER_EXPERIMENT , self.after_experiment )
         ])
 
-        self.latest_measurement = None
+        self.latest_log = None
         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"""
-        workers_factor = FactorModel("num_workers", [1, 2, 3, 4])
-        write_factor = FactorModel("write_size", [256, 1024, 2048, 4096])
+        workers_factor = FactorModel("num_workers", [2, 4])
+        write_factor = FactorModel("write_size", [1024, 4096])
 
         self.run_table_model = RunTableModel(
             factors = [workers_factor, write_factor],
-            data_columns=['timestamp', 'channel_1(A)', 'channel_2(off)', 'channel_3(off)']) # Channel 1 is in Amps
+            data_columns=['timestamp', 'channel_1(avg)', 'channel_2(off)', 'channel_3(off)']) # Channel 1 is in Amps
 
         return self.run_table_model
 
@@ -81,11 +75,13 @@ def before_experiment(self) -> None:
         # Setup the picolog cm3 here (the parameters passed are also the default)
         self.meter = PicoCM3(sample_frequency   = 1000, # Sample the CM3 every second
                              mains_setting      = 0,    # Account for 50hz mains frequency
-                             # Which channels are enabled in what mode
-                             channel_settings   = { CM3Channels.PLCM3_CHANNEL_1: CM3DataTypes.PLCM3_1_MILLIVOLT,
-                                                    CM3Channels.PLCM3_CHANNEL_2: CM3DataTypes.PLCM3_OFF,
-                                                    CM3Channels.PLCM3_CHANNEL_3: CM3DataTypes.PLCM3_OFF})
-
+                             channel_settings   = {     # Which channels are enabled in what mode
+                                CM3Channels.PLCM3_CHANNEL_1.value: CM3DataTypes.PLCM3_1_MILLIVOLT.value,
+                                CM3Channels.PLCM3_CHANNEL_2.value: CM3DataTypes.PLCM3_OFF.value,
+                                CM3Channels.PLCM3_CHANNEL_3.value: CM3DataTypes.PLCM3_OFF.value})
+        # Open the device
+        self.meter.open_device()
+        
     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)"""
@@ -108,23 +104,20 @@ def start_run(self, context: RunnerContext) -> None:
                     --timeout 60s \
                     --metrics-brief"
 
-        stress_log = open(f'{context.run_dir}/stress-ng-log.log', 'w')
+        stress_log = open(f'{context.run_dir}/stress-ng.log', 'w')
         self.stress_ng = subprocess.Popen(shlex.split(stress_cmd), stdout=stress_log)
 
     def start_measurement(self, context: RunnerContext) -> None:
         """Perform any activity required for starting measurements."""
 
-        num_workers = context.run_variation['num_workers']
-        write_size = context.run_variation['write_size']
-        
-        # Start the picologs measurements here, create a unique log file for each
-        self.latest_log = str(context.run_dir.resolve() / f'pico_run_{num_workers}_{write_size}.log')
-        self.latest_measurement = self.meter.log(lambda: self.stress_ng.poll() != None, self.latest_log)
+        # Start the picologs measurements here, create a unique log file for each (or pass the values through a variable)
+        self.latest_log = str(context.run_dir.resolve() / 'picocm3.log')
+        self.meter.log(finished_fn=lambda: self.stress_ng.poll() == None, logfile=self.latest_log)
 
     def interact(self, context: RunnerContext) -> None:
         """Perform any interaction with the running target system here, or block here until the target finishes."""
 
-        # Wait the maximum timeout for stress-ng to finish or time.sleep(60)
+        # Wait for stress-ng to finish or time.sleep(60)
         self.stress_ng.wait() 
 
     def stop_measurement(self, context: RunnerContext) -> None:
@@ -143,35 +136,23 @@ def populate_run_data(self, context: RunnerContext) -> Optional[Dict[str, Any]]:
         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"""
 
-        run_data = {k: [] for k in self.run_table_model.data_columns}
-
-        # Pass data through variables
-        if self.latest_measurement != {}:
-            for k, v in self.latest_measurement.items():
-                    run_data['timestamp'].append(k)
-                    run_data['channel_1(A)'].append(v[0][0])
-                    run_data['channel_2(off)'].append(v[1][0])
-                    run_data['channel_3(off)'].append(v[2][0])
-
-        # Or through a log file
-        else:
-            with open(self.latest_log) as f:
-                lines = f.readlines()
-
-                for line in lines:
-                    channel_vals = line.split(",")
-                    
-                    run_data['timestamp'].append(channel_vals[0])
-                    run_data['channel_1(A)'].append(channel_vals[1].split(" ")[0])
-                    run_data['channel_2(off)'].append(channel_vals[2].split(" ")[0])
-                    run_data['channel_3(off)'].append(channel_vals[3].split(" ")[0])
+        if self.latest_log == None:
+            return {}
+        
+        # Read data from the relavent CM3 log
+        log_data = self.meter.parse_log(self.latest_log)
 
-        return run_data
+        return {'timestamp': log_data['timestamp'][0] + " - " + log_data['timestamp'][-1],
+                'channel_1(avg)': mean(log_data['channel_1']),
+                'channel_2(off)': mean(log_data['channel_2']),
+                'channel_3(off)': mean(log_data['channel_3'])}
 
     def after_experiment(self) -> None:
         """Perform any activity required after stopping the experiment here
         Invoked only once during the lifetime of the program."""
-        pass
+        
+        # This must always be run
+        self.meter.close_device()
 
     # ================================ DO NOT ALTER BELOW THIS LINE ================================
     experiment_path:            Path             = None