Merge pull request #10 from Raiduy/energibridge-implementation

Energibridge implementation

Author: iivanoo

examples/energibridge-profiling/README.md

@@ -0,0 +1,30 @@
+# `EnergiBridge` profiler
+
+A simple Linux example, that runs a python program and measures its CPU usage
+and power consumption using [EnergiBridge](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
+
+[EnergiBridge](https://github.com/tdurieux/EnergiBridge) is assumed to be already installed.
+
+To install EnergiBridge, please follow the instructions on their GitHub repo.
+
+
+## Running
+
+From the root directory of the repo, run the following command:
+
+```bash
+python experiment-runner/ examples/energibridge-profiling/RunnerConfig.py
+```
+
+## Results
+
+The results are generated in the `examples/energibridge-profiling/experiments` folder.
+
+**!!! WARNING !!!**: COLUMNS IN THE `energibridge.csv` FILES CAN BE DIFFERENT ACROSS MACHINES.
+ADJUST THE DATAFRAME COLUMN NAMES ACCORDINGLY.
+

examples/energibridge-profiling/RunnerConfig.py

@@ -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_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.)
+    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/energibridge-profiling/primer.py

@@ -0,0 +1,23 @@
+import os
+import struct
+
+def is_prime(p):
+    if p==0 or p==1:
+        return False
+
+    for i in range(2, (p//2)+1, 1):
+        if p % i == 0:
+            return False
+    return True
+
+if __name__ == '__main__':
+    fd = os.open("/dev/urandom", os.O_RDONLY)
+
+    while True:
+        p = struct.unpack("@Q", os.read(fd, 8))[0]
+        print("Testing %lu" % p)
+        if is_prime(p):
+            print(" [*] prime")
+        else:
+            print(" [*] not prime")
+    os.close(fd)

examples/hello-world/RunnerConfig.py

@@ -10,6 +10,14 @@
 from pathlib import Path
 from os.path import dirname, realpath
 
+from Plugins.Profilers import CodecarbonWrapper
+from Plugins.Profilers.CodecarbonWrapper import DataColumns as CCDataCols
+
+@CodecarbonWrapper.emission_tracker(
+    data_columns=[CCDataCols.EMISSIONS, CCDataCols.ENERGY_CONSUMED],
+    country_iso_code="NLD" # your country code
+)
+
 
 class RunnerConfig:
     ROOT_DIR = Path(dirname(realpath(__file__)))