Most of the plugin complete, as well as most of the Runner Config

mhkarsten · mhkarsten · commit 8a55eb5d67bb · 2024-08-22T18:47:55.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -13,3 +13,5 @@ tmp/
 _trial_temp/
 pycharm-interpreter.sh
 python
+
+Session.vim
diff --git a/examples/picocm3-profiling/README.md b/examples/picocm3-profiling/README.md
@@ -0,0 +1,29 @@
+
+# `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).
+
+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
+
+The [PicoLog CM3 Driver](https://github.com/tdurieux/EnergiBridge) is assumed to be already installed.
+
+Instructions to install the drivers for your operating system can be found [here]().
+
+## Running
+
+From the root directory of the repo, run the following command:
+
+```bash
+python experiment-runner/examples/picocm3-profiling/RunnerConfig.py
+```
+
+## Results
+
+The results are generated in the `examples/picocm3-profiling/experiments` folder.
diff --git a/examples/picocm3-profiling/RunnerConfig.py b/examples/picocm3-profiling/RunnerConfig.py
@@ -6,23 +6,28 @@
 from ConfigValidator.Config.Models.OperationType import OperationType
 from ProgressManager.Output.OutputProcedure import OutputProcedure as output
 
-from typing import Dict, List, Any, Optional
+from typing import Dict, 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
 
+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__)))
 
     # ================================ USER SPECIFIC CONFIG ================================
     """The name of the experiment."""
-    name:                       str             = "new_picocm3_experiment"
+    name:                       str             = "new_runner_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.)
@@ -52,25 +57,34 @@ def __init__(self):
             (RunnerEvents.POPULATE_RUN_DATA, self.populate_run_data),
             (RunnerEvents.AFTER_EXPERIMENT , self.after_experiment )
         ])
+        
+        self.latest_measurement = 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"""
-        sampling_factor = FactorModel("sampling", [10, 50, 100, 200, 500, 1000])
+        workers_factor = FactorModel("num_workers", [1, 2, 3, 4])
+        write_factor = FactorModel("write_size", [256, 1024, 2048, 4096])
+
         self.run_table_model = RunTableModel(
-            factors = [sampling_factor],
-            data_columns=['dram_energy', 'package_energy',
-                          'pp0_energy', 'pp1_energy']
+            factors = [workers_factor, write_factor],
+            data_columns=['timestamp', 'channel_1(A)', 'channel_2(off)', 'channel_3(off)']) # Channel 1 is in Amps
 
-        )
         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
+
+        # 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})
 
     def before_run(self) -> None:
         """Perform any activity required before starting a run.
@@ -81,34 +95,43 @@ 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
+        
+        num_workers = context.run_variation['num_workers']
+        write_size = context.run_variation['write_size']
+
+        # Start stress-ng
+        stress_cmd = f"sudo stress-ng \
+                    --hdd {num_workers} \
+                    --hdd-write-size {write_size} \
+                    --hdd-ops 1000000 \
+                    --hdd-dev /dev/sda1 \
+                    --timeout 60s \
+                    --metrics-brief"
+
+        stress_log = open(f'{context.run_dir}/stress-ng-log.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."""
-        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)
-
+        
+        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)
+    
     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)
+        # Wait the maximum timeout for stress-ng to finish or time.sleep(60)
+        self.stress_ng.wait() 
 
     def stop_measurement(self, context: RunnerContext) -> None:
         """Perform any activity here required for stopping measurements."""
-        self.profiler.wait()
+        
+        # Wait for stress-ng to finish
+        self.stress_ng.wait()
 
     def stop_run(self, context: RunnerContext) -> None:
         """Perform any activity here required for stopping the run.
@@ -120,14 +143,29 @@ 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"""
 
-        # 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),
-        }
+        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])
+
         return run_data
 
     def after_experiment(self) -> None:
diff --git a/experiment-runner/Plugins/Profilers/PicoCM3.py b/experiment-runner/Plugins/Profilers/PicoCM3.py
@@ -1,25 +1,173 @@
-import os
 import ctypes
+import datetime
+import time
+import enum
+from collections.abc import Callable
+
 from picosdk.plcm3 import plcm3
-from platform import uname
+from picosdk.functions import assert_pico_ok
+from picosdk.constants import PICO_STATUS
+
+# Mapping of the PicoLog CM3 enums for convenience
+class CM3DataTypes(enum.Enum):
+    PLCM3_OFF               = 0
+    PLCM3_1_MILLIVOLT       = 1
+    PLCM3_10_MILLIVOLTS     = 2
+    PLCM3_100_MILLIVOLTS    = 3
+    PLCM3_VOLTAGE           = 4
+
+class CM3Channels(enum.Enum):
+    PLCM3_CHANNEL_1 = 1
+    PLCM3_CHANNEL_2 = 2
+    PLCM3_CHANNEL_3 = 3
 
+class CM3MainsTypes(enum.Enum):
+    PLCM3_MAINS_50HZ    = 0
+    PLCM3_MAINS_60HZ    = 1
 
 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, sample_frequency: int = None, mains_setting: int = None, channel_settings: dict[int, int] = None):
+        # Check that the picolog driver is accessible
+        if ctypes.util.find_library("plcm3") is None:
+            print("No valid PicoLog CM3 driver could be found, please check LD_LIBRARY_PATH is set properly")
+            raise RuntimeError("Driver not available")
 
-    }
+        # Check if a CM3 device is present
+        if self.list_devices() == "":
+            print("No valid PicoLog CM3 device could be found, please ensure the device is connected")
+            raise RuntimeError("Device not available")
+
+        # Some default settings
+        self.sample_frequency    = sample_frequency if sample_frequency != None else 1000   # In ms
+        self.mains_setting       = mains_setting if mains_setting != None else 0            # 50 Hz
+        self.channel_settings    = channel_settings if channel_settings != None else {      # Which channels are enabled in what mode
+            CM3Channels.PLCM3_CHANNEL_1: CM3DataTypes.PLCM3_1_MILLIVOLT,
+            CM3Channels.PLCM3_CHANNEL_2: CM3DataTypes.PLCM3_OFF,
+            CM3Channels.PLCM3_CHANNEL_3: CM3DataTypes.PLCM3_OFF}
     
-    def __init__(self):
-        # Check if a CM3 is present
-        pass
+    # Apply channel and mains settings to the picolog
+    def mode(self, handle):
+        # Validate the channel settings
+        if len(self.channel_settings.values()) < 3:
+            print("All channels should have a setting")
+            raise RuntimeError("Invalid PicoLog CM3 settings")
+        
+        for ch, setting in self.channel_settings.items():
+            if  ch not in plcm3.PLCM3Channels.values() or \
+                setting not in plcm3.PLCM3DataTypes.values():
+
+                print(f"Channel {ch} has invalid setting: {setting}")
+                raise RuntimeError("Invalid PicoLog CM3 settings")
+        
+        if self.mains_setting > 1 or self.mains_setting < 0:
+            print(f"Channel {ch} has invalid setting {setting}")
+            raise RuntimeError("Invalid PicoLog CM3 settings")
+
+        # Apply settings to channels
+        for ch in range(plcm3.PLCM3Channels["PLCM3_MAX_CHANNELS"]): 
+            status = plcm3.PLCM3SetChannel(handle, ch+1, self.channel_settings[ch+1])
+            assert_pico_ok(status)
+        
+        # Apply mains setting
+        status = plcm3.PLCM3SetMains(handle, ctypes.c_uint16(self.mains_setting))
+        assert_pico_ok(status)
+
+    def log(self, logfile = None, dev = None, timeout: int = 60, finished_fn: Callable[[], bool] = None):
+        log_data = {}
+        if logfile:
+            self.logfile = logfile
+        
+        # Open the device
+        handle = self.open_device()
+
+        # Apply channel and mains settings 
+        self.mode(handle)
+
+        print('Logging started successfully...')
+        timeout_start = time.time()       
+        finished_checker = finished_fn if finished_fn != None else lambda: time.time() < timeout_start + timeout
+        
+        # Ensure the PicoLog always gets closed
+        try:
+            while finished_checker():
+                channel_data = {}
+                # Poll every channel for data
+                for ch in range(plcm3.PLCM3Channels["PLCM3_MAX_CHANNELS"]):  
+                    ch_handle = ctypes.c_uint32(ch+1)
+                    data_handle = ctypes.c_uint32()
+                    status = plcm3.PLCM3GetValue(handle, ch_handle, ctypes.byref(data_handle))
+                    
+                    if status == PICO_STATUS["PICO_NO_SAMPLES_AVAILABLE"]:
+                        channel_data[ch+1] = (0, "")
+                    else:
+                        assert_pico_ok(status)
+                        channel_data[ch+1] = self.apply_scaling(data_handle.value, self.channel_settings[ch+1])
+                   
+                log_data[datetime.datetime.now()] = [channel_data[1], channel_data[2], channel_data[3]]
+
+                # Ensure measurement frequency
+                time.sleep(self.sample_frequency/1000)
+        except:
+            print("Error durring PicoLog CM3 data collection")
+        finally:
+            # Close the connection to the unit
+            self.close_device(handle)
+
+            # Write all of the data to a log file (if requested)
+            if self.logfile:
+                with open(self.logfile,'w') as f:
+                    for t_stamp, data in log_data.items():
+                        f.write('%s, %.2f %s, %.2f %s, %.2f %s\n' % 
+                                (t_stamp, data[0][0], data[0][1], data[1][0], data[1][1], data[2][0], data[2][1]))
+        return log_data
+    
+    def close_device(self, handle):
+        status = plcm3.PLCM3CloseUnit(handle)
+        assert_pico_ok(status)
+
+    def open_device(self, dev=None, verbose=True):
+        if dev is not None:
+            dev = ctypes.create_string_buffer(dev.encode("utf-8"))
+
+        # Open the device
+        handle = ctypes.c_int16()
+        status = plcm3.PLCM3OpenUnit(ctypes.byref(self.handle), dev) 
+        assert_pico_ok(status)
+        
+        if verbose:
+            print("Device opened: ")
+            self.print_info(handle)
+
+        return handle
+
+    def enumerate_devices(self):
+        details = ctypes.create_string_buffer(255)
+        length = ctypes.c_uint32(255)
+        com_type = ctypes.c_uint32(plcm3.PLCM3CommunicationType["PLCM3_CT_USB"])
+
+        status = plcm3.PLCM3Enumerate(details, ctypes.byref(length), com_type)
+        assert_pico_ok(status)
+
+        return details.value.decode("utf-8")
+
+    def print_info(self):
+        info_strings = ["Driver Version    :", 
+                        "USB Version       :", 
+                        "Hardware Version  :", 
+                        "Variant Info      :", 
+                        "Batch and Serial  :", 
+                        "Calibration Date  :", 
+                        "Kernel Driver Ver.:",
+                        "Mac Address       :"]
 
-    def mode(self, runmode):
-        pass
+        for i, s in enumerate(info_strings):
+            res_buf = ctypes.create_string_buffer(255)
+            required_size = ctypes.c_int16()
 
-    def log(self,timeout, logfile = None):
-        pass
+            status = plcm3.PLCM3GetUnitInfo(self.handle, res_buf, ctypes.c_int16(255), ctypes.byref(required_size), ctypes.c_uint32(i))
+            assert_pico_ok(status)
+            print(f" {s}{repr(res_buf.value).decode("utf-8")}")
 
     # Returns a tuple (scaled_value, unit_string)
     def apply_scaling(value, channel_mode):
