Nearly complete Fibonacci example

mhkarsten · mhkarsten · commit ecc915093fd6 · 2025-04-30T19:06:19.000+02:00
diff --git a/examples/hello-world-fibonacci/README.md b/examples/hello-world-fibonacci/README.md
@@ -0,0 +1,16 @@
+
+# Hello World
+
+A simple example that just prints on each event. This examples serves as an equivalent of a "Hello World" program.
+
+## Running
+
+From the root directory of the repo, run the following command:
+
+```bash
+python experiment-runner/ examples/hello-world/RunnerConfig.py
+```
+
+## Results
+
+The results are generated in the `examples/hello-world/experiments` folder.
diff --git a/examples/hello-world-fibonacci/RunnerConfig.py b/examples/hello-world-fibonacci/RunnerConfig.py
@@ -0,0 +1,123 @@
+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 Plugins.Profilers.EnergiBridge import EnergiBridge
+
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+from os.path import dirname, realpath
+
+
+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"""
+        factor1 = FactorModel("fib_type", ['iter', 'mem', 'rec'])
+        factor2 = FactorModel("problem_size", [10, 100, 1000, 10000])
+        self.run_table_model = RunTableModel(
+            factors=[factor1, factor2],
+            repetitions = 3,
+            data_columns=["total_power", "runtime", "avg_cpu", "avg_mem"]
+        )
+        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."""
+        fib_type = context.run_variation["fib_type"]
+        problem_size = context.run_variation["problem_size"]
+
+        self.profiler = EnergiBridge(target_program=f"./fibonacci_{fib_type}.py {problem_size}")
+        
+        self.profiler.start()
+
+    def interact(self, context: RunnerContext) -> None:
+        """Perform any interaction with the running target system here, or block here until the target finishes."""
+        pass
+
+    def stop_measurement(self, context: RunnerContext) -> None:
+        """Perform any activity here required for stopping measurements."""
+        stdout = self.profiler.stop(wait=True)
+
+    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"""
+        
+        eb_log = self.profiler.parse_log(context.run_dir / self.profiler.logfile)
+        eb_summary = self.profiler.parse_log(context.run_dir / self.profiler.summaryfile)
+
+        return {"total_power": 0, 
+                "runtime": 0, 
+                "avg_cpu": 0, 
+                "avg_mem": 0}
+
+    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
diff --git a/examples/hello-world-fibonacci/fibonacci_iter.py b/examples/hello-world-fibonacci/fibonacci_iter.py
@@ -0,0 +1,10 @@
+# Implementation by Mandy Wong (https://realpython.com/fibonacci-sequence-python/)
+
+def fib(n):
+	a, b = 0, 1
+	for i in range(0, n):
+		a, b = b, a + b
+	return a
+
+for n in range(10000):
+	print(fib(n))
diff --git a/examples/hello-world-fibonacci/fibonacci_mem.py b/examples/hello-world-fibonacci/fibonacci_mem.py
@@ -0,0 +1,13 @@
+# Implementation by Mandy Wong (https://realpython.com/fibonacci-sequence-python/)
+
+cache = {0: 0, 1: 1}
+
+def fib(n):
+	if n in cache:  # Base case
+		return cache[n]
+	# Compute and cache the Fibonacci number
+	cache[n] = fib(n - 1) + fib(n - 2)  # Recursive case
+	return cache[n]
+
+for n in range(10000):
+	print(fib(n))
diff --git a/examples/hello-world-fibonacci/fibonacci_rec.py b/examples/hello-world-fibonacci/fibonacci_rec.py
@@ -0,0 +1,9 @@
+# Implementation by Mandy Wong (https://realpython.com/fibonacci-sequence-python/)
+
+def fib(n):
+	if n in {0, 1}:  # Base case
+		return n
+	return fib(n - 1) + fib(n - 2)  # Recursive case
+
+for n in range(10000):
+	print(fib(n))
diff --git a/experiment-runner/Plugins/Profilers/DataSource.py b/experiment-runner/Plugins/Profilers/DataSource.py
@@ -89,7 +89,7 @@ def __del__(self):
 
     @staticmethod
     @abstractmethod
-    def parse_log():
+    def parse_log(logfile):
         pass
 
 
@@ -188,12 +188,13 @@ def start(self):
         
         self._validate_start()
 
-    def stop(self):
+    def stop(self, wait=False):
         if not self.process:
             return
 
         try:
-            self.process.terminate()
+            if not wait:
+                self.process.terminate()
             stdout, stderr = self.process.communicate(timeout=5)
 
         except Exception as e:
diff --git a/experiment-runner/Plugins/Profilers/EnergiBridge.py b/experiment-runner/Plugins/Profilers/EnergiBridge.py
@@ -0,0 +1,51 @@
+from pathlib import Path
+import pandas as pd
+from Plugins.Profilers.DataSource import CLISource, ParameterDict
+
+# Supported Paramters for the PowerJoular metrics plugin
+ENERGIBRIDGE_PARAMETERS = {
+    ("-o","--output"): Path,
+    ("-s","--separator"): str,
+    ("-c","--output-command"): str,
+    ("-i","--interval"): int,
+    ("-m","--max-execution"): int,
+    ("-g","--gpu"): None,
+    ("--summary",): None
+}
+
+class EnergiBridge(CLISource):
+    parameters = ParameterDict(ENERGIBRIDGE_PARAMETERS)
+    source_name = "energibridge"
+    supported_platforms = ["Linux"]
+
+    """An integration of PowerJoular into experiment-runner as a data source plugin"""
+    def __init__(self,
+                 sample_frequency:      int                 = 5000,
+                 out_file:              Path                = "energibridge.csv",
+                 summary:               bool                = True,
+                 target_program:        str                 = "sleep 1000000",
+                 additional_args:       dict                = {}):
+        
+        super().__init__()
+
+        self.target_program = target_program
+        self.logfile = out_file
+        self.args = {
+            "-o": Path(self.logfile),
+            "-i": sample_frequency,
+        }
+
+        if summary:
+            self.update_parameters(add={"--summary": None})
+
+        self.update_parameters(add=additional_args)
+
+    def _format_cmd(self):
+        cmd = super()._format_cmd()
+
+        return cmd + f" -- {self.target_program}"
+
+    @staticmethod
+    def parse_log(logfile: Path):
+        # Things are already in csv format here, no checks needed
+        return pd.read_csv(logfile).to_dict()
