[Benchmarks] Add benchmarks logger

Author: PatKamin

devops/scripts/benchmarks/README.md

@@ -45,6 +45,22 @@ are stored [here](https://oneapi-src.github.io/unified-runtime/performance/).
 ## Output formats
 You can display the results in the form of a HTML file by using `--ouptut-html` and a markdown file by using `--output-markdown`. Due to character limits for posting PR comments, the final content of the markdown file might be reduced. In order to obtain the full markdown output, use `--output-markdown full`.
 
+## Logging
+
+The benchmark runner uses a configurable logging system with different log levels that can be set using the `--log-level` command-line option.
+
+Available log levels:
+- `debug`
+- `info` (default)
+- `warning`
+- `error`
+- `critical`
+
+To set the log level, use the `--log-level` option:
+```bash
+./main.py ~/benchmarks_workdir/ --sycl ~/llvm/build/ --log-level debug
+```
+
 ## Requirements
 
 ### Python

devops/scripts/benchmarks/main.py

@@ -21,6 +21,7 @@
 from utils.compute_runtime import *
 from utils.validate import Validate
 from utils.detect_versions import DetectVersion
+from utils.logger import log, LogLevel
 from presets import enabled_suites, presets
 
 import argparse
@@ -576,6 +577,13 @@ def validate_and_parse_env_args(env_args):
         "'Include archived runs'. PR runs typically have a shorter retention period than baselines.",
         default=options.archive_pr_days,
     )
+    parser.add_argument(
+        "--log-level",
+        type=str,
+        choices=["debug", "info", "warning", "error", "critical"],
+        help="Set the logging level",
+        default="info",
+    )
 
     args = parser.parse_args()
     additional_env_vars = validate_and_parse_env_args(args.env)
@@ -606,6 +614,12 @@ def validate_and_parse_env_args(env_args):
     options.build_jobs = args.build_jobs
     options.hip_arch = args.hip_arch
 
+    # Set the log level
+    log_level = LogLevel.from_string(args.log_level).value
+    log.logger.setLevel(log_level)
+    for handler in log.logger.handlers:
+        handler.setLevel(log_level)
+
     if args.build_igc and args.compute_runtime is None:
         parser.error("--build-igc requires --compute-runtime to be set")
     if args.compute_runtime is not None:

devops/scripts/benchmarks/utils/logger.py

@@ -0,0 +1,82 @@
+# Copyright (C) 2025 Intel Corporation
+# Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
+# See LICENSE.TXT
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import logging
+import sys
+from enum import Enum
+
+class LogLevel(Enum):
+    DEBUG = logging.DEBUG
+    INFO = logging.INFO
+    WARNING = logging.WARNING
+    ERROR = logging.ERROR
+    CRITICAL = logging.CRITICAL
+    
+    @staticmethod
+    def from_string(level_str):
+        level_map = {
+            "debug": LogLevel.DEBUG,
+            "info": LogLevel.INFO,
+            "warning": LogLevel.WARNING,
+            "error": LogLevel.ERROR,
+            "critical": LogLevel.CRITICAL
+        }
+        return level_map.get(level_str.lower(), LogLevel.INFO)
+
+class BenchmarkLogger:
+    """Logger for the Unified Runtime Benchmark Runner.
+    
+    This logger provides different log levels (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    that can be controlled via command-line arguments.
+    """
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(BenchmarkLogger, cls).__new__(cls)
+            cls._instance._initialize_logger()
+        return cls._instance
+    
+    def _initialize_logger(self):
+        """Initialize the logger with the appropriate log level."""
+        self.logger = logging.getLogger("ur_benchmarks")
+        
+        # Create console handler
+        console_handler = logging.StreamHandler(sys.stdout)
+        
+        # Set default log level (INFO)
+        self.logger.setLevel(logging.INFO)
+        console_handler.setLevel(logging.INFO)
+        
+        # Create formatter
+        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+        console_handler.setFormatter(formatter)
+        
+        # Add the handler to the logger
+        self.logger.addHandler(console_handler)
+    
+    def debug(self, message):
+        """Log a debug message."""
+        self.logger.debug(message)
+    
+    def info(self, message):
+        """Log an info message."""
+        self.logger.info(message)
+    
+    def warning(self, message):
+        """Log a warning message."""
+        self.logger.warning(message)
+    
+    def error(self, message):
+        """Log an error message."""
+        self.logger.error(message)
+    
+    def critical(self, message):
+        """Log a critical message."""
+        self.logger.critical(message)
+
+# Global logger instance
+log = BenchmarkLogger()