Several changes to wrap the call to the experiment runner:

- New class to handle location and status of experiments
- New method of PayuManager to run experiments
- Added implementation of method to generate experiments. Currently registers a list of existing experiments, instead of actually generating them.

Author: micaeljtoliveira

pyproject.toml

@@ -21,6 +21,8 @@ dependencies = [
     "pint-xarray",
     "matplotlib",
     "access-config-utils",
+    "experiment-runner",
+    "payu", # Extra dependency of experiment-runner, not handle correctly in conda
 ]
 
 [build-system]

src/access/profiling/access_models.py

@@ -16,7 +16,15 @@
 
 
 class ESM16Profiling(PayuManager):
-    """Handles profiling of ACCESS-ESM1.6 configurations."""
+    """Handles profiling of ACCESS-ESM1.6 configurations.
+
+    Args:
+        work_dir (Path): Path to directory used to generate and run profiling experiments.
+        config_name (str): User supplied name. It is used to build some internal paths, but has no other effect.
+    """
+
+    def __init__(self, work_dir: Path, config_name: str | None = None) -> None:
+        super().__init__(work_dir=work_dir, config_name=config_name)
 
     def get_component_logs(self, path: Path) -> dict[str, ProfilingLog]:
         """Returns available profiling logs for the components in ACCESS-ESM1.6.

src/access/profiling/manager.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from abc import ABC, abstractmethod
+from enum import Enum
 from pathlib import Path
 
 import xarray as xr
@@ -49,15 +50,46 @@ def parse(self) -> xr.Dataset:
         )
 
 
+class ProfilingExperimentStatus(Enum):
+    """Enumeration representing the status of a profiling experiment."""
+
+    NEW = 1
+    RUNNING = 2
+    DONE = 3
+
+
+class ProfilingExperiment:
+    """Represents a profiling experiment.
+
+    Args:
+        path (Path): Path to the experiment directory.
+    """
+
+    path: Path  # Path to the experiment directory
+    status: ProfilingExperimentStatus = ProfilingExperimentStatus.NEW  # Status of the experiment
+
+    def __init__(self, path: Path) -> None:
+        self.path = path
+
+
 class ProfilingManager(ABC):
     """Abstract base class to handle profiling data and workflows.
 
     This high-level class defines methods to parse different types of profiling data. Currently,
     it supports parsing and plotting scaling data.
+
+    Args:
+        work_dir (Path): Path to directory used to generate and run profiling experiments.
     """
 
+    work_dir: Path  # Path to directory used to generate and run profiling experiments.
+    experiments: dict[str, ProfilingExperiment] = {}  # Dictionary storing ProfilingExperiment instances.
     data: dict[str, xr.Dataset] = {}  # Dictionary mapping component names to their profiling datasets.
 
+    def __init__(self, work_dir: Path) -> None:
+        super().__init__()
+        self.work_dir = work_dir
+
     @abstractmethod
     def parse_profiling_data(self, path: Path) -> dict[str, xr.Dataset]:
         """Parses profiling data from the specified path.
@@ -80,27 +112,23 @@ def parse_ncpus(self, path: Path) -> int:
             int: Number of CPUs used in the experiment.
         """
 
-    def parse_scaling_data(self, paths: list[Path]):
-        """Parses profiling data from a list of experiment directories.
-
-        Args:
-            paths (list[Path]): List of paths to experiment directories.
-        """
+    def parse_scaling_data(self):
+        """Parses profiling data from the experiments."""
         self.data = {}
-        for path in paths:
-            # Parse data
-            datasets = self.parse_profiling_data(path)
-
-            # Find number of cpus used
-            ncpus = self.parse_ncpus(path)
-
-            # Add ncpus dimension and concatenate with existing data
-            for name, ds in datasets.items():
-                ds = ds.expand_dims({"ncpus": 1}).assign_coords({"ncpus": [ncpus]})
-                if name in self.data:
-                    self.data[name] = xr.concat([self.data[name], ds], dim="ncpus", join="outer")
-                else:
-                    self.data[name] = ds
+        for exp in self.experiments.values():
+            if exp.status == ProfilingExperimentStatus.DONE:
+                datasets = self.parse_profiling_data(exp.path)
+
+                # Find number of cpus used
+                ncpus = self.parse_ncpus(exp.path)
+
+                # Add ncpus dimension and concatenate with existing data
+                for name, ds in datasets.items():
+                    ds = ds.expand_dims({"ncpus": 1}).assign_coords({"ncpus": [ncpus]})
+                    if name in self.data:
+                        self.data[name] = xr.concat([self.data[name], ds], dim="ncpus", join="outer")
+                    else:
+                        self.data[name] = ds
 
     def plot_scaling_data(
         self,

src/access/profiling/payu_manager.py

@@ -7,15 +7,32 @@
 
 import xarray as xr
 from access.config import YAMLParser
+from experiment_runner.experiment_runner import ExperimentRunner
 
-from access.profiling.manager import ProfilingLog, ProfilingManager
+from access.profiling.manager import ProfilingExperiment, ProfilingExperimentStatus, ProfilingLog, ProfilingManager
 from access.profiling.payujson_parser import PayuJSONProfilingParser
 
 logger = logging.getLogger(__name__)
 
 
 class PayuManager(ProfilingManager, ABC):
-    """Abstract base class to handle profiling of Payu configurations."""
+    """Abstract base class to handle profiling of Payu configurations.
+
+    Args:
+        work_dir (Path): Path to directory used to generate and run profiling experiments.
+        config_name (str): User supplied name. It is used to build some internal paths, but has no other effect.
+    """
+
+    config_name: str  # User supplied name. It is used to build some internal paths, but has no other effect.
+    _nruns: int = 1  # Number of repetitions for the Payu experiments.
+    _startfrom_restart: str = "cold"  # Restart option for the Payu experiments.
+
+    def __init__(self, work_dir: Path, config_name: str | None = None) -> None:
+        super().__init__(work_dir=work_dir)
+        if config_name is None:
+            self.config_name = "config"
+        else:
+            self.config_name = config_name
 
     @abstractmethod
     def get_component_logs(self, path: Path) -> dict[str, ProfilingLog]:
@@ -27,6 +44,86 @@ def get_component_logs(self, path: Path) -> dict[str, ProfilingLog]:
             dict[str, ProfilingLog]: Dictionary mapping component names to their ProfilingLog instances.
         """
 
+    @property
+    def nruns(self) -> int:
+        """Returns the number of repetitions for the Payu experiments.
+
+        Returns:
+            int: Number of repetitions.
+        """
+        return self._nruns
+
+    @nruns.setter
+    def nruns(self, value: int) -> None:
+        """Sets the number of repetitions for the Payu experiments.
+
+        Args:
+            value (int): Number of repetitions.
+        """
+        if value < 1:
+            raise ValueError("Number of runs must be at least 1.")
+        self._nruns = value
+
+    @property
+    def startfrom_restart(self) -> str:
+        """Returns the restart option for the Payu experiments.
+
+        Returns:
+            str: Restart option.
+        """
+        return self._startfrom_restart
+
+    @startfrom_restart.setter
+    def startfrom_restart(self, value: str) -> None:
+        """Sets the restart option for the Payu experiments.
+
+        Args:
+            value (str): Restart option.
+        """
+        self._startfrom_restart = value
+
+    def generate_experiments(self, branches: list[str]) -> None:
+        """Generates Payu experiments for profiling data generation.
+
+        Args:
+            branches (list[str]): List of branches to generate experiments for.
+        """
+
+        for branch in branches:
+            if branch in self.experiments:
+                logger.info(f"Experiment for branch {branch} already exists. Skipping addition.")
+            else:
+                self.experiments[branch] = ProfilingExperiment(self.work_dir / branch / self.config_name)
+
+    def run_experiments(self) -> None:
+        """Runs Payu experiments for profiling data generation."""
+
+        runner_config = {
+            "test_path": self.work_dir,
+            "repository_directory": self.config_name,
+            "running_branches": [],
+            "keep_uuid": True,
+            "nruns": [],
+            "startfrom_restart": [],
+        }
+
+        for path, exp in self.experiments.items():
+            print(path, exp.status)
+            if exp.status == ProfilingExperimentStatus.NEW:
+                runner_config["running_branches"].append(path)
+                runner_config["nruns"].append(self.nruns)
+                runner_config["startfrom_restart"].append(self.startfrom_restart)
+                exp.status = ProfilingExperimentStatus.RUNNING
+
+        # Run the experiment runner
+        ExperimentRunner(runner_config).run()
+
+        # We are marking all running experiments as done here, but later this should be implemented properly
+        # so that an actual check is performed, probably somewhere else.
+        for exp in self.experiments.values():
+            if exp.status == ProfilingExperimentStatus.RUNNING:
+                exp.status = ProfilingExperimentStatus.DONE
+
     def parse_ncpus(self, path: Path) -> int:
         """Parses the number of CPUs used in a given Payu experiment.
 

tests/test_access_models.py

@@ -19,7 +19,7 @@ def test_esm16_config_profiling(mock_is_file, mock_yaml_parse, mock_path_read_te
     """Test the ESM16ConfigProfiling class."""
 
     # Instantiate ESM16ConfigProfiling
-    config_profiling = ESM16Profiling()
+    config_profiling = ESM16Profiling(Path("/fake/test_path"))
 
     # Mock the presence of all log files
     mock_is_file.side_effect = [True, True, True]

tests/test_manager.py

@@ -7,7 +7,7 @@
 import pytest
 import xarray as xr
 
-from access.profiling.manager import ProfilingLog, ProfilingManager
+from access.profiling.manager import ProfilingExperiment, ProfilingExperimentStatus, ProfilingLog, ProfilingManager
 from access.profiling.metrics import count, tavg, tmax
 
 
@@ -43,6 +43,18 @@ def test_profiling_log():
     mock_path.read_text.assert_called_once()
 
 
+def test_profiling_experiment():
+    """Test the ProfilingExperiment class."""
+
+    experiment = ProfilingExperiment(path=Path("/fake/path"))
+
+    assert experiment.path == Path("/fake/path")
+    assert experiment.status == ProfilingExperimentStatus.NEW
+
+    experiment.status = ProfilingExperimentStatus.RUNNING
+    assert experiment.status == ProfilingExperimentStatus.RUNNING
+
+
 class MockProfilingManager(ProfilingManager):
     """Test class inheriting from ProfilingManager to test its methods.
 
@@ -55,11 +67,16 @@ class MockProfilingManager(ProfilingManager):
     """
 
     def __init__(self, paths, ncpus, datasets) -> None:
-        super().__init__()
+        super().__init__(Path("/fake/work_dir"))
 
         self._mock_ncpus = dict(zip([path.name for path in paths], ncpus, strict=True))
         self._mock_datasets = dict(zip([path.name for path in paths], datasets, strict=True))
 
+        # Pre-generate experiments
+        for path in paths:
+            self.experiments[path] = ProfilingExperiment(path)
+            self.experiments[path].status = ProfilingExperimentStatus.DONE
+
     def parse_ncpus(self, path):
         """Simulate parsing number of CPUs for a given path."""
         return self._mock_ncpus[path.name]
@@ -104,7 +121,7 @@ def test_scaling_data(mock_plot, scaling_data):
     paths, ncpus, datasets = scaling_data
     config_prof = MockProfilingManager(paths, ncpus, datasets)
 
-    config_prof.parse_scaling_data(paths)
+    config_prof.parse_scaling_data()
 
     assert set(config_prof.data.keys()) == {"component"}
     assert set(config_prof.data["component"].dims) == {"ncpus", "region"}, (