Add more tests

Dockerfile.base

@@ -0,0 +1,20 @@
+FROM debian:bookworm-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    curl \
+    gnupg \
+    lsb-release \
+    wget
+RUN wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor |  tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
+RUN wget -O- https://eci.intel.com/repos/gpg-keys/GPG-PUB-KEY-INTEL-ECI.gpg | tee /usr/share/keyrings/eci-archive-keyring.gpg > /dev/null
+RUN wget -O- https://raw.githubusercontent.com/ros/rosdistro/master/ros.key | tee /usr/share/keyrings/ros-archive-keyring.gpg > /dev/null
+RUN . /etc/os-release \
+&& echo $VERSION_CODENAME && \
+bash -c 'echo "deb [signed-by=/usr/share/keyrings/eci-archive-keyring.gpg] https://eci.intel.com/repos/$(source /etc/os-release && echo $VERSION_CODENAME) isar main" | tee /etc/apt/sources.list.d/eci.list' && \
+bash -c 'echo "deb-src [signed-by=/usr/share/keyrings/eci-archive-keyring.gpg] https://eci.intel.com/repos/$(source /etc/os-release && echo $VERSION_CODENAME) isar main" | tee -a /etc/apt/sources.list.d/eci.list' && \
+bash -c 'echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | tee /etc/apt/sources.list.d/oneAPI.list' && \
+bash -c 'echo -e "Package: intel-oneapi-runtime-*\nPin: version 2024.1.*\nPin-Priority: 1001" > /etc/apt/preferences.d/oneapi' && \
+bash -c 'echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/openvino/2024 ubuntu24 main" > /etc/apt/sources.list.d/intel-openvino-2024.list' && \
+bash -c 'echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(source /etc/os-release && echo $VERSION_CODENAME) main" | tee /etc/apt/sources.list.d/ros2.list'
+RUN apt-get update && apt-get install -y intel-cmt-cat

conf/config.yaml

@@ -8,16 +8,28 @@ run:
   stressor: true
   tests_path: "tests"
 
+  resctrl:
+    - mask: "0x7ff0"
+      cpus: "3"
+    - mask: "0x7fff"
+      cpus: "0,2,4,6,8,10,12,14"
+    - mask: "0x000f"
+      cpus: "1,5,7,9,11,13,15"
+
 cpus:
   t_core: "3"
   enable_turbo: false
   disable_c_state: true
   core_freq_mhz: 3.0
 
 caterpillar:
-  n_cycles: 12000
+  n_cycles: 7200
 
 megabench:
+  no_cat_cores: "9,11,13,15"
+  no_cat_mask: "0x00ff"
+  cat_cores: "9"
+  cat_mask: "0x0003"
   caterpillar_cat: "${hydra:run.dir}/caterpillar_cat.csv"
   caterpillar_no_cat: "${hydra:run.dir}/caterpillar_no_cat.csv"
   cyclictest_cat: "${hydra:run.dir}/cyclictest_cat.csv"

main.py

@@ -175,15 +175,21 @@ def run_test(
         docker_cmd = self._build_base_docker_command(test, t_core)
 
         if test == "caterpillar":
-            return self._run_caterpillar(docker_cmd, l3_cache_mask, t_core)
+            return self._run_caterpillar(
+                docker_cmd, l3_cache_mask, t_core, self.config.benchmark_output_path
+            )
         elif test == "cyclictest":
-            return self._run_cyclictest(docker_cmd, l3_cache_mask, t_core)
+            return self._run_cyclictest(
+                docker_cmd, l3_cache_mask, t_core, self.config.benchmark_output_path
+            )
         elif test == "codesys-jitter-benchmark":
             return self._run_codesys_jitter(docker_cmd, l3_cache_mask, t_core)
         elif test == "codesys-opcua-pubsub":
             return self._run_codesys_opcua(docker_cmd, l3_cache_mask, t_core)
         elif test == "iperf3":
             return self._run_iperf3(docker_cmd, l3_cache_mask, t_core)
+        elif test == "mega-benchmark":
+            return self._run_megabench(docker_cmd, t_core)
         else:
             print(f"Error: Test '{test}' is not implemented")
             return 1
@@ -208,14 +214,14 @@ def _build_base_docker_command(self, test: str, t_core: str) -> List[str]:
         ]
 
     def _run_caterpillar(
-        self, base_cmd: List[str], l3_cache_mask: str, t_core: str
+        self, base_cmd: List[str], l3_cache_mask: str, t_core: str, path: str
     ) -> int:
         """Run caterpillar test."""
         cmd = base_cmd + [
             "caterpillar:latest",
             "/bin/bash",
             "-c",
-            f'stdbuf -oL -eL /usr/sbin/rdtset -t "l3={l3_cache_mask};cpu={t_core}" '
+            f"stdbuf -oL -eL /usr/sbin/rdtset {self._compose_rdtset()} "
             f"-c {t_core} -k /opt/benchmarking/caterpillar/caterpillar -c {t_core} -s {self.config.caterpillar.n_cycles}",
         ]
 
@@ -225,7 +231,7 @@ def _run_caterpillar(
 
         pbar = tqdm(total=self.config.caterpillar.n_cycles)
         parser = build_caterpillar_parser()
-        with open(self.config.benchmark_output_path, "w") as f:
+        with open(path, "w") as f:
             prelude = parser.prelude()
             if prelude is not None:
                 f.write(prelude)
@@ -240,15 +246,15 @@ def _run_caterpillar(
         return process.wait()
 
     def _run_cyclictest(
-        self, base_cmd: List[str], l3_cache_mask: str, t_core: str
+        self, base_cmd: List[str], l3_cache_mask: str, t_core: str, path: str
     ) -> int:
         """Run cyclictest."""
         cmd = base_cmd + [
             "cyclictest:latest",
             "/bin/bash",
             "-c",
             f'stdbuf -oL -eL /usr/sbin/rdtset -t "l3={l3_cache_mask};cpu={t_core}" -c {t_core} '
-            f"-k /usr/bin/cyclictest --threads -t 4 -p 99 -l 100000 -d 1 -D 0 -i 100000 -a {t_core}",
+            f"-k /usr/bin/cyclictest --threads -t 1 -p 99 -l 100000 -d 1 -D 0 -i 100000 -a {t_core}",
         ]
         print(" ".join(cmd))
 
@@ -258,7 +264,7 @@ def _run_cyclictest(
         pbar = tqdm(total=400000)
         last_c_value = 0
         parser = build_cyclictest_parser()
-        with open(self.config.benchmark_output_path, "w") as f:
+        with open(path, "w") as f:
             prelude = parser.prelude()
             if prelude is not None:
                 f.write(prelude)
@@ -447,35 +453,36 @@ def _run_iperf3(self, base_cmd: List[str], l3_cache_mask: str, t_core: str) -> i
 
         return result.returncode
 
-    def _run_megabench(self, base_cmd: List[str]) -> int:
-        cmd = base_cmd + [
-            "mega-benchmark:latest",
-            "/bin/bash",
-            "-c",
-            f"stdbuf -oL -eL /opt/benchmarking/mega-benchmark/48_hour_benchmark.sh",
-        ]
-        print(" ".join(cmd))
-        process = self._run_interactive_command(cmd)
-        assert process.stdout is not None
+    def _run_megabench(self, base_cmd: List[str], t_core: str) -> int:
+        self._run_caterpillar(
+            base_cmd,
+            self.config.megabench.no_cat_mask,
+            self.config.megabench.no_cat_cores,
+            self.config.megabench.caterpillar_no_cat,
+        )
 
-        with open(self.config.megabench.caterpillar_cat, "w") as caterpillar_cat, open(
-            self.config.megabench.caterpillar_no_cat, "w"
-        ) as caterpillar_no_cat, open(
-            self.config.megabench.cyclictest_cat, "w"
-        ) as cyclictest_cat, open(
-            self.config.megabench.cyclictest_no_cat, "w"
-        ) as cyclictest_no_cat, open(
-            self.config.benchmark_output_path, "w"
-        ) as raw:
-            parser = MegabenchParser(
-                caterpillar_cat, caterpillar_no_cat, cyclictest_cat, cyclictest_no_cat
-            )
-            for line in process.stdout:
-                print(line)
-                parser.parse(line)
-                raw.write(line)
+        self._run_caterpillar(
+            base_cmd,
+            self.config.megabench.cat_mask,
+            self.config.megabench.cat_cores,
+            self.config.megabench.caterpillar_cat,
+        )
 
-        return process.wait()
+        self._run_cyclictest(
+            base_cmd,
+            self.config.megabench.no_cat_mask,
+            self.config.megabench.no_cat_cores,
+            self.config.megabench.cyclictest_no_cat,
+        )
+
+        self._run_cyclictest(
+            base_cmd,
+            self.config.megabench.cat_mask,
+            self.config.megabench.cat_cores,
+            self.config.megabench.cyclictest_cat,
+        )
+
+        return 0
 
     def _start_stressor(self) -> None:
         """Start the stressor container if not already running."""
@@ -502,6 +509,13 @@ def _start_stressor(self) -> None:
         except subprocess.CalledProcessError:
             print("Warning: Could not check stressor status")
 
+    def _compose_rdtset(self) -> str:
+        ans = ""
+        for group in self.config.run.resctrl:
+            ans += f' -t "l3={group.mask};cpu={group.cpus}"'
+
+        return ans
+
     @staticmethod
     def _run_command(cmd: List[str]) -> CompletedProcess | None:
         """Run a command and return its exit code."""