apply clang-format

Author: ianayl

devops/scripts/benchmarking/aggregate.py

@@ -7,16 +7,18 @@
 from abc import ABC, abstractmethod
 import os
 
+
 class Aggregator(ABC):
     """
     Aggregator classes used to "aggregate" a pool of elements, and produce an
     "average" (precisely, some "measure of central tendency") from the elements.
     """
+
     @staticmethod
     @abstractmethod
     def get_type() -> str:
         """
-        Return a string indicating the type of average this aggregator 
+        Return a string indicating the type of average this aggregator
         produces.
         """
         pass
@@ -42,6 +44,7 @@ class SimpleMedian(Aggregator):
     Simple median calculation: if the number of samples being generated are low,
     this is the fastest median method.
     """
+
     def __init__(self):
         self.elements = []
 
@@ -105,27 +108,29 @@ def get_avg(self) -> float:
 
 class Aggregate:
     """
-    Static class providing methods for aggregating data 
+    Static class providing methods for aggregating data
     """
+
     @staticmethod
-    def hist_avg(benchmark_name: str, res_dir: str, cutoff: str,
-                aggregator = SimpleMedian):
+    def hist_avg(
+        benchmark_name: str, res_dir: str, cutoff: str, aggregator=SimpleMedian
+    ):
         if not os.path.isdir(res_dir):
             print(f"Not a directory: {res_dir}.", file=sys.stderr)
             exit(1)
 
         def csv_samples() -> list[str]:
-            """ Get all valid .csv samples from the results folder. """
+            """Get all valid .csv samples from the results folder."""
             cache_dir = Path(f"{res_dir}")
             # Filter all benchmark .csv files in the result directory:
             return filter(
                 # Make sure the .csv "file" is a file:
                 lambda f: f.is_file()
                 # Make sure timestamp of .csv file is good format:
                 # [-19:-4] corresponds to the timestamp in the filename.
-                and Validate.timestamp(str(f)[-19:-4]) 
+                and Validate.timestamp(str(f)[-19:-4])
                 # Make sure timestamp is bigger than cutoff timestamp:
-                and str(f)[-19:-4] > cutoff, 
+                and str(f)[-19:-4] > cutoff,
                 cache_dir.glob(f"{benchmark_name}-*_*.csv"),
             )
 
@@ -147,8 +152,10 @@ def csv_samples() -> list[str]:
                     for metric in SanitizedConfig.METRICS_TOLERANCES:
                         sample_value = Validate.sanitize_stat(sample[metric])
                         if not isinstance(sample_value, float):
-                            print(f"Malformatted statistic in {str(sample_path)}: " + 
-                                f"'{sample[metric]}' for {test}.")
+                            print(
+                                f"Malformatted statistic in {str(sample_path)}: "
+                                + f"'{sample[metric]}' for {test}."
+                            )
                             exit(1)
                         # Add metric from sample for current test to aggregate:
                         samples_aggregate[test][metric].add(sample_value)
@@ -158,7 +165,8 @@ def csv_samples() -> list[str]:
             f"{res_dir}/{benchmark_name}-{aggregator.get_type()}.csv", "w"
         ) as output_csv:
             writer = csv.DictWriter(
-                output_csv, fieldnames=["TestCase", *SanitizedConfig.METRICS_TOLERANCES.keys()]
+                output_csv,
+                fieldnames=["TestCase", *SanitizedConfig.METRICS_TOLERANCES.keys()],
             )
             writer.writeheader()
             for test in samples_aggregate:

devops/scripts/benchmarking/common.py

@@ -6,17 +6,15 @@
 
 
 class Validate:
-    """ Static class containing methods for validating various fields """
+    """Static class containing methods for validating various fields"""
 
     @staticmethod
     def filepath(path: str) -> bool:
-        filepath_re = re.compile(
-            r"[a-zA-Z0-9\/\._\-]+"
-        )
+        filepath_re = re.compile(r"[a-zA-Z0-9\/\._\-]+")
         return filepath_re.match(path) is not None
 
     @staticmethod
-    # TODO use config 
+    # TODO use config
     def timestamp(t: str) -> bool:
         timestamp_re = re.compile(
             # YYYYMMDD_HHMMSS
@@ -27,8 +25,8 @@ def timestamp(t: str) -> bool:
     @staticmethod
     def sanitize_stat(stat: str) -> float:
         """
-         Sanitize statistics found in compute-benchmark output csv files. Returns float if sanitized, None if not sanitizable
-         """
+        Sanitize statistics found in compute-benchmark output csv files. Returns float if sanitized, None if not sanitizable
+        """
         # Get rid of %
         if stat[-1] == "%":
             stat = stat[:-1]
@@ -47,6 +45,7 @@ class SanitizedConfig:
     Configuration option names follow <section name>_<option name> from config
     file.
     """
+
     loaded: bool = False
     # PERF_RES_PATH: str = None
     # ARTIFACT_OUTPUT_CACHE: str = None
@@ -69,20 +68,23 @@ class Configuration:
 
     def __init__(self, devops_path: str):
         """
-        Initialize this configuration handler by finding configuration files 
+        Initialize this configuration handler by finding configuration files
 
         @param devops_path Path to /devops folder in intel/llvm
         """
         self.config_path = f"{devops_path}/benchmarking/config.ini"
         self.constants_path = f"{devops_path}/benchmarking/constants.ini"
 
         if not os.path.isfile(self.config_path):
-            print(f"config.ini not found in {devops_path}/benchmarking.",
-                  file=sys.stderr)
+            print(
+                f"config.ini not found in {devops_path}/benchmarking.", file=sys.stderr
+            )
             exit(1)
         if not os.path.isfile(self.constants_path):
-            print(f"constants.ini not found in {devops_path}/benchmarking.",
-                  file=sys.stderr)
+            print(
+                f"constants.ini not found in {devops_path}/benchmarking.",
+                file=sys.stderr,
+            )
             exit(1)
 
     def __sanitize(self, value: str, field: str) -> str:
@@ -91,11 +93,10 @@ def __sanitize(self, value: str, field: str) -> str:
         files.
         """
         _alnum = list(string.ascii_letters + string.digits)
-        allowlist = _alnum + ['_', '-', '.', ',', ':', '/', '%']
+        allowlist = _alnum + ["_", "-", ".", ",", ":", "/", "%"]
 
         for illegal_ch in filter(lambda ch: ch not in allowlist, value):
-            print(f"Illegal character '{illegal_ch}' in {field}",
-                  file=sys.stderr)
+            print(f"Illegal character '{illegal_ch}' in {field}", file=sys.stderr)
             exit(1)
 
         return value
@@ -114,10 +115,10 @@ def export_var_cmd(sec: str, opt: str) -> str:
             var_name = f"SANITIZED_{sec.upper()}_{opt.upper()}"
             var_val = f"{self.__sanitize(config[sec][opt], sec + '.' + opt)}"
             return f"{var_name}={var_val}"
-        
-        export_cmds = [ export_var_cmd(sec, opt) for sec, opt in export_opts ]
+
+        export_cmds = [export_var_cmd(sec, opt) for sec, opt in export_opts]
         return "export " + " ".join(export_cmds)
-    
+
     def export_shell_configs(self) -> str:
         """
         Return shell command exporting environment variables representing
@@ -175,30 +176,30 @@ def export_python_globals(self):
         # python objects:
 
         # metrics.recorded
-        m_rec_str = \
-            self.__sanitize(all_opts["metrics"]["recorded"], "metrics.recorded")
+        m_rec_str = self.__sanitize(all_opts["metrics"]["recorded"], "metrics.recorded")
         SanitizedConfig.METRICS_RECORDED = m_rec_str.split(",")
 
         # metrics.tolerances
-        m_tol_str = \
-            self.__sanitize(all_opts["metrics"]["tolerances"],
-                            "metrics.tolerances")
-        metric_tolerances = \
-            dict([ pair_str.split(":") for pair_str in m_tol_str.split(",") ])
+        m_tol_str = self.__sanitize(
+            all_opts["metrics"]["tolerances"], "metrics.tolerances"
+        )
+        metric_tolerances = dict(
+            [pair_str.split(":") for pair_str in m_tol_str.split(",")]
+        )
 
         for metric, tolerance_str in metric_tolerances.items():
             if metric not in SanitizedConfig.METRICS_RECORDED:
-                print(f"Metric compared against {metric} is not being recorded.",
-                      file=sys.stderr)
+                print(
+                    f"Metric compared against {metric} is not being recorded.",
+                    file=sys.stderr,
+                )
                 exit(1)
             try:
                 metric_tolerances[metric] = float(tolerance_str)
             except ValueError:
-                print(f"Could not convert '{tolerance_str}' to float.",
-                      file= sys.stderr)
+                print(f"Could not convert '{tolerance_str}' to float.", file=sys.stderr)
                 exit(1)
 
         SanitizedConfig.METRICS_TOLERANCES = metric_tolerances
 
         SanitizedConfig.loaded = True
-

devops/scripts/benchmarking/compare.py

@@ -3,6 +3,7 @@
 import sys
 from common import Validate, SanitizedConfig
 
+
 class Compare:
 
     @staticmethod
@@ -14,21 +15,22 @@ def to_hist_avg(benchmark_name: str, hist_avg_path: str, test_csv_path: str):
         @param hist_avg_path  Path to historical average .csv file
         @param test_csv_path  Path to benchmark result .csv file
         """
-        hist_avg = dict() # stores historical median of the test suite of interest 
+        hist_avg = dict()  # stores historical median of the test suite of interest
 
         # Load metrics from historical median being compared against
         with open(hist_avg_path, "r") as avg_csv:
             for stat in csv.DictReader(avg_csv):
                 hist_avg[stat["TestCase"]] = {
-                    metric: float(stat[metric]) for metric in SanitizedConfig.METRICS_TOLERANCES
+                    metric: float(stat[metric])
+                    for metric in SanitizedConfig.METRICS_TOLERANCES
                 }
 
         status = 0
         failure_counts = {metric: 0 for metric in SanitizedConfig.METRICS_TOLERANCES}
         with open(test_csv_path, "r") as sample_csv:
             # For every test case in our current benchmark test suite:
             for sample in csv.DictReader(sample_csv):
-                test = sample["TestCase"] 
+                test = sample["TestCase"]
                 # Ignore test cases we haven't profiled before
                 if test not in hist_avg:
                     continue
@@ -39,16 +41,20 @@ def to_hist_avg(benchmark_name: str, hist_avg_path: str, test_csv_path: str):
                     max_tolerated = test_hist_avg[metric] * (1 + threshold)
                     sample_value = Validate.sanitize_stat(sample[metric])
                     if not isinstance(sample_value, float):
-                        print(f"Malformatted statistic in {test_csv_path}: " + 
-                              f"'{sample[metric]}' for {test}.")
+                        print(
+                            f"Malformatted statistic in {test_csv_path}: "
+                            + f"'{sample[metric]}' for {test}."
+                        )
                         exit(1)
 
                     if sample_value > max_tolerated:
                         print(f"\n-- FAILED {benchmark_name}::{test}")
                         print(
                             f"  {metric}: {sample_value} -- Historic avg. {test_hist_avg[metric]} (max tolerance {threshold*100}%: {max_tolerated})\n"
                         )
-                        with open("./artifact/benchmarks_log_failed.log", "a") as slow_log:
+                        with open(
+                            "./artifact/benchmarks_log_failed.log", "a"
+                        ) as slow_log:
                             slow_log.write(
                                 f"-- {benchmark_name}::{test}\n"
                                 f"   {metric}: {sample_value} -- Historic avg. {test_hist_avg[metric]} (max tol. {threshold*100}%: {max_tolerated})\n"
@@ -62,7 +68,9 @@ def to_hist_avg(benchmark_name: str, hist_avg_path: str, test_csv_path: str):
 
 if __name__ == "__main__":
     if len(sys.argv) < 4:
-        print(f"Usage: {sys.argv[0]} <path to /devops> <relative path to results directory> <result csv filename>")
+        print(
+            f"Usage: {sys.argv[0]} <path to /devops> <relative path to results directory> <result csv filename>"
+        )
         exit(1)
 
     if not Validate.filepath(sys.argv[1]):

devops/scripts/benchmarking/load_config.py

@@ -3,9 +3,12 @@
 
 # TODO better frontend / use argparse
 if __name__ == "__main__":
+
     def usage_and_exit():
         print(f"Usage: {sys.argv[0]} <path to /devops> [config | constants]")
-        print("Generate commands to export configuration options/constants as an environment variable.")
+        print(
+            "Generate commands to export configuration options/constants as an environment variable."
+        )
         exit(1)
 
     if len(sys.argv) != 3: