carm-roofline 1.0.0.dev5__tar.gz → 1.0.1.dev0__tar.gz

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.0.dev5
+Version: 1.0.1.dev0
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                   GNU LESSER GENERAL PUBLIC LICENSE
@@ -518,7 +518,7 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: System :: Benchmark
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Operating System :: POSIX :: Linux
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -529,6 +529,7 @@ Requires-Dist: numpy>=2.0.0
 Requires-Dist: matplotlib>=3.7.2
 Requires-Dist: tomli>=2.0.0
 Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: argcomplete>=3.0.0
 Provides-Extra: gui
 Requires-Dist: dash[diskcache]; extra == "gui"
 Requires-Dist: dash-bootstrap-components; extra == "gui"

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/architecture/architecture.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any
 
 from arguments import InsertsArguments, positive_int
 from benchmark import generation as bench_gen
-from error import ConfigurationError
+from error import UserError
 from output_utils import configure_verbosity, debug, detail, format_if_container, warn
 from units import Frequency
 
@@ -28,14 +28,14 @@ def check_isa_compatibility(selected_isas: list[type[BaseISA]]) -> None:
             families.add(family)
 
     if len(families) > 1:
-        raise ConfigurationError(f"Incompatible ISA families selected: {', '.join(families)}")
+        raise UserError(f"Incompatible ISA families selected: {', '.join(families)}")
 
     # Check for special incompatibilities within the same family
     isa_set = set(selected_isas)
     for incompatible_pair in bench_gen.INCOMPATIBLE_ISAS:
         if incompatible_pair.issubset(isa_set):
             pair_names = ", ".join(isa.name for isa in incompatible_pair)
-            raise ConfigurationError(f"Incompatible ISAs selected: {pair_names}")
+            raise UserError(f"Incompatible ISAs selected: {pair_names}")
 
 
 def positive_po2_int(arg: str) -> int:
@@ -278,20 +278,18 @@ class Architecture(InsertsArguments):
         parser.add_argument(
             "-i",
             "--isa",
-            nargs="*",
+            nargs="+",
             choices=list(ISA_NAME_TO_CLASS.keys()),
             help="Set of ISAs to test. (Default: automatically detects all available ISAs)",
         )
         parser.add_argument(
             "-l",
             "--vector-length",
-            nargs="?",
             type=positive_po2_int,
             help="Vector register length in bytes. (Default: automatically detected)",
         )
         parser.add_argument(
             "--vector-lmul",
-            nargs="?",
             type=int,
             choices=(1, 2, 4, 8),
             help="Vector register group modifier (LMUL). RISC-V specific.",
@@ -309,12 +307,13 @@ class Architecture(InsertsArguments):
             "--emit-config",
             type=str,
             metavar="PATH",
+            nargs="?",
+            const="topology.toml",
             help="Generate a template TOML configuration file at the specified path and exit. "
             "Edit the template and pass it back with --topology-config.",
         )
         parser.add_argument(
             "--frequency",
-            nargs="?",
             type=Frequency.from_argparse,
             help="Processor frequency, e.g. '2GHz', '3200mhz' (Default: automatically detected if possible)",
         )

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/architecture/config.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import cast
 
-from error import ConfigurationError
+from error import UserError
 from units import Bytes
 
 from .memory import SimpleMemoryTopology
@@ -81,13 +81,13 @@ def load_memory_topology_from_toml(config_path: Path | str) -> SimpleMemoryTopol
     """
     config_path = Path(config_path)
     if not config_path.exists():
-        raise ConfigurationError(f"Config file not found: {config_path}")
+        raise UserError(f"Config file not found: {config_path}")
 
     try:
         with open(config_path, "rb") as f:
             config = tomllib.load(f)
     except Exception as e:
-        raise ConfigurationError(f"Failed to parse TOML file '{config_path}': {e}") from e
+        raise UserError(f"Failed to parse TOML file '{config_path}': {e}") from e
 
     total_cpus = _read_optional_int(config, "total_cpus")
     smt_degree = cast(int, _read_optional_int(config, "smt_degree", 1))
@@ -96,7 +96,7 @@ def load_memory_topology_from_toml(config_path: Path | str) -> SimpleMemoryTopol
     # Extract cache levels
     cache_levels_data = config.get("cache_levels", [])
     if not isinstance(cache_levels_data, list) or not cache_levels_data:
-        raise ConfigurationError("Configuration must contain at least one [[cache_levels]] section")
+        raise UserError("Configuration must contain at least one [[cache_levels]] section")
 
     # Parse and validate each cache level (processed in document order; order determines level numbers)
     level_sizes: list[Bytes] = []
@@ -104,17 +104,17 @@ def load_memory_topology_from_toml(config_path: Path | str) -> SimpleMemoryTopol
 
     for level_dict in cache_levels_data:
         if not isinstance(level_dict, dict):
-            raise ConfigurationError(f"Each [[cache_levels]] entry must be a table, got: {type(level_dict).__name__}")
+            raise UserError(f"Each [[cache_levels]] entry must be a table, got: {type(level_dict).__name__}")
         try:
             instances = level_dict["instances"]
             size_str = level_dict["size"]
         except KeyError as e:
-            raise ConfigurationError(f"Cache level section missing required field: {e}") from e
+            raise UserError(f"Cache level section missing required field: {e}") from e
 
         if not isinstance(instances, int):
-            raise ConfigurationError(f"'instances' must be an integer, got: {instances!r}")
+            raise UserError(f"'instances' must be an integer, got: {instances!r}")
         if not isinstance(size_str, str):
-            raise ConfigurationError(f"'size' must be a string, got: {size_str!r}")
+            raise UserError(f"'size' must be a string, got: {size_str!r}")
 
         size = Bytes.from_string(size_str)
         level_sizes.append(size)

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/architecture/detect.py

@@ -15,7 +15,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from error import ConfigurationError
+from error import UserError
 from output_utils import debug, detail, warn
 from units import Frequency
 
@@ -244,7 +244,7 @@ def detect_cache(ctx: TestContext) -> dict[str, Any]:
             else:
                 raise ValueError("MemoryTopology parsed but contains no CPU data")
         except Exception as e:
-            raise ConfigurationError(
+            raise UserError(
                 f"Failed to parse native system memory topology from /sys: {e}. "
                 "For non-native execution or when sysfs is unavailable, "
                 "please provide cache hierarchy explicitly with --topology-config."
@@ -424,7 +424,7 @@ def native_detect(threads: int = 1) -> DetectedArchitecture:
     """
     machine = platform.machine().lower()
     if machine == "":
-        raise ConfigurationError(
+        raise UserError(
             "Unable to detect machine architecture (platform.machine() returned empty string). Please specify the "
             "architecture manually (--isa <arch>)."
         )

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/architecture/memory.py

@@ -9,7 +9,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Protocol, runtime_checkable
 
-from error import ConfigurationError
+from error import UserError
 from output_utils import debug, format_if_container
 from units import Bytes
 
@@ -168,26 +168,26 @@ class SimpleMemoryTopology:
         """
 
         if len(level_sizes) != len(instances_per_level):
-            raise ConfigurationError(
+            raise UserError(
                 "Level sizes and instances_per_level must have same length: "
                 f"{len(level_sizes)} vs {len(instances_per_level)}"
             )
         if not level_sizes:
-            raise ConfigurationError("At least one cache level must be provided")
+            raise UserError("At least one cache level must be provided")
 
         if any(inst <= 0 for inst in instances_per_level):
-            raise ConfigurationError("All values in instances_per_level must be positive integers")
+            raise UserError("All values in instances_per_level must be positive integers")
 
         if total_cpus is not None and total_cpus <= 0:
-            raise ConfigurationError(f"total_cpus must be positive when provided, got {total_cpus}")
+            raise UserError(f"total_cpus must be positive when provided, got {total_cpus}")
 
         if cpu_offset < 0:
-            raise ConfigurationError(f"cpu_offset must be >= 0, got {cpu_offset}")
+            raise UserError(f"cpu_offset must be >= 0, got {cpu_offset}")
 
         if total_cpus is not None:
             for idx, instances in enumerate(instances_per_level, 1):
                 if instances > total_cpus:
-                    raise ConfigurationError(
+                    raise UserError(
                         f"Cache level {idx}: instances ({instances}) cannot exceed total_cpus ({total_cpus})"
                     )
 

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/benchmark/benchmarking.py

@@ -11,7 +11,7 @@ from enum import Enum
 from arguments import InsertsArguments, enum_action, positive_float, positive_int
 from benchmark.generation.code_gen.operation import ArithmeticOperation
 from output_utils import warn
-from units import Operations
+from units import Bytes, Operations
 
 from .generation import DataType
 
@@ -66,27 +66,29 @@ def ld_st_ratio_type(arg: str) -> LoadStoreRatio:
     return LoadStoreRatio(ld, st)
 
 
-def mem_test_size_type(arg: str) -> int | str:
+def mem_test_size_type(arg: str) -> Bytes | None:
     """Parse a memory test size specifier.
 
     Accepts either:
-      - A positive integer (KiB)
+      - A quantity with a binary unit (e.g. "16 KiB", "2 MiB", "8 GiB")
       - The string "auto" (case-insensitive) for automatic sizing
 
     Returns:
-        int (KiB value) or str (literal "auto")
+        Bytes or None (for "auto")
 
     Raises:
         argparse.ArgumentTypeError on invalid input.
     """
     s = str(arg).strip().lower()
     if s == "auto":
-        return "auto"
+        return None
     try:
-        return positive_int(arg)
-    except (ValueError, argparse.ArgumentTypeError) as e:
+        return Bytes.from_argparse(arg)
+    except argparse.ArgumentTypeError:
+        raise
+    except Exception as e:
         raise argparse.ArgumentTypeError(
-            f"invalid memory test size: {arg!r}. Must be a positive integer or 'auto'"
+            f"invalid memory test size: {arg!r}. Expected a binary unit string like '16 KiB', '2 MiB', or 'auto'. ({e})"
         ) from e
 
 
@@ -106,7 +108,7 @@ class Benchmarking(InsertsArguments):
         self.num_ops: Operations = Operations(args.num_ops)
         self.ld_st_ratio: LoadStoreRatio = args.ld_st_ratio
         self.arith_mem_ratio: int = args.arith_mem_ratio
-        self.mem_test_sizes: list[int | str] | None = args.mem_test_sizes
+        self.mem_test_sizes: list[Bytes | None] | None = args.mem_test_sizes
         self.verbose: int = args.verbose
         self.test_time: float = args.test_time
         if self.test_time < 10.0:
@@ -132,7 +134,6 @@ class Benchmarking(InsertsArguments):
             "-m",
             "--mem-target",
             default="all",
-            nargs="?",
             choices=["L1", "L2", "L3", "DRAM", "all"],
             help="Target memory level for 'memory' and 'mixed' tests (Default: all)",
         )
@@ -140,7 +141,6 @@ class Benchmarking(InsertsArguments):
             "-o",
             "--num-ops",
             default=32 * 1024,
-            nargs="?",
             type=positive_int,
             help="Number of arithmetic operations to perform in the arithmetic test (Default: 32768)",
         )
@@ -148,7 +148,6 @@ class Benchmarking(InsertsArguments):
             "-d",
             "--data-type",
             default=DataType.f32,
-            nargs="?",
             action=enum_action(DataType),
             help="Data type for benchmark operations (Default: f32)",
         )
@@ -171,7 +170,6 @@ class Benchmarking(InsertsArguments):
         parser.add_argument(
             "--ld-st-ratio",
             default=LoadStoreRatio(2, 1),
-            nargs="?",
             type=ld_st_ratio_type,
             help="Load-to-store ratio for memory access patterns. Format: 'LD:ST' (e.g., '2:1') or a single "
             "integer for 'N:1' ratio. Use '1:0' for load-only or '0:1' for store-only tests. (Default: 2:1)",
@@ -179,22 +177,22 @@ class Benchmarking(InsertsArguments):
         parser.add_argument(
             "--arith-mem-ratio",
             default=2,
-            nargs="?",
             type=positive_int,
             help="Ratio between arithmetic and memory operations for 'mixed' test (Default: 2)",
         )
         parser.add_argument(
             "--mem-test-sizes",
-            nargs="*",
+            nargs="+",
             type=mem_test_size_type,
-            help="Size of the test arrays for each memory level in KiB. 'auto' can be used to automatically determine "
-            "sizes based on the cache sizes, e.g. '--mem-test-sizes 32 256 2048 65536' / '--mem-test-sizes auto auto "
-            "2048 auto' for L1, L2, L3, DRAM tests respectively. (Default: auto for all levels)",
+            help="Size of the test arrays for each memory level. Accepts binary unit strings like '16KiB', '2MiB', "
+            "'8GiB', or 'auto' to automatically size based on detected caches. "
+            "e.g. '--mem-test-sizes 16KiB 256KiB 2MiB 64GiB' / "
+            "'--mem-test-sizes auto auto 2MiB auto' for L1, L2, L3, DRAM respectively. "
+            "(Default: auto for all levels)",
         )
         parser.add_argument(
             "--test-time",
             default=25.0,
-            nargs="?",
             type=positive_float,
             help="Target runtime for each individual microbenchmark, in seconds. Low runtime may lead to inaccurate "
             "results. (Default: 25.0)",

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/benchmark/generation/x86.py

@@ -172,7 +172,7 @@ class X86AVX2(X86AVX):
         super().__init__(**kwargs)
 
 
-class X86AVX512(X86Scalar):
+class X86AVX512(X86SSE):
     name = "x86_avx512"
     BITS = 512
 

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/benchmark/interface.py

@@ -9,7 +9,6 @@ This module coordinates the entire benchmark pipeline:
 
 from __future__ import annotations
 
-import tempfile
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -20,6 +19,7 @@ from test_bench.builder import (
     create_microbenchmark_header,
     run_microbenchmarks,
 )
+from workspace import workspace_context
 
 from .benchmark import BaseBenchmark
 from .result import parse_benchmark_output
@@ -120,9 +120,13 @@ def run_full_benchmark(
 
     debug(f"Flattened benchmarks for compilation: {list(flat_benchmarks.keys())}")
 
-    with tempfile.TemporaryDirectory(prefix="carm-test-bench-") as workspace_dir:
+    keep_workspace = context.run_config.dry_run or context.run_config.keep_artifacts
+    with workspace_context(keep=keep_workspace, prefix="carm-benchmark-") as workspace_dir:
         workspace = Path(workspace_dir)
 
+        if keep_workspace:
+            detail(f"Artifacts will be kept in: {workspace}")
+
         # Keep generated artifacts in a writable temporary workspace.
         # Static C sources remain in-package and are included explicitly at compile time.
         generated_header = workspace / "microbenchmarks.h"

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/benchmark/suites/memory.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from collections.abc import Iterator
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
@@ -68,6 +69,11 @@ class MemoryBenchmarkSuite(ISABenchmarkSuite):
 
         previous_size_per_thread: Bytes | None = None
 
+        # Iterator over user-provided per-level sizes (if any)
+        user_sizes: Iterator[Bytes | None] | None = None
+        if benchmark.mem_test_sizes is not None:
+            user_sizes = iter(benchmark.mem_test_sizes)
+
         mem_level_indices = architecture.memory_topology.available_cache_levels()
         # Generate memory benchmarks for each memory level
         for mem_level_idx, mem_level_info in zip(mem_level_indices, architecture.memory_topology):
@@ -76,7 +82,7 @@ class MemoryBenchmarkSuite(ISABenchmarkSuite):
             # Plan thread affinity for this memory level
             thread_affinity = architecture.memory_topology.plan_thread_affinity(benchmark.threads, mem_level_idx)
             avail_size_per_thread: Bytes = thread_affinity.total_cache_bytes // thread_affinity.num_threads
-            is_first_target = mem_level_idx == mem_level_indices[0]
+            _is_first_target = mem_level_idx == mem_level_indices[0]
             is_final_target = mem_level_idx == mem_level_indices[-1]
 
             if is_final_target and previous_size_per_thread is not None:
@@ -84,6 +90,13 @@ class MemoryBenchmarkSuite(ISABenchmarkSuite):
             else:
                 target_size_per_thread = avail_size_per_thread * _CACHE_COVERAGE
 
+            # Override with user-provided size (if any) for this cache level.
+            # A None entry in the list (from "auto") keeps the computed value.
+            if user_sizes is not None:
+                user_size = next(user_sizes, None)
+                if user_size is not None:
+                    target_size_per_thread = user_size
+
             # Warn if the per-thread dataset also fits in a smaller (closer-to-CPU) cache level.
             # E.g. targeting L3 with 16 threads, but per-thread data fits in each thread's L2:
             # the hardware will serve requests from L2, not L3, skewing the bandwidth result.
@@ -99,7 +112,8 @@ class MemoryBenchmarkSuite(ISABenchmarkSuite):
                     )
 
             # Generate memory benchmark for this level
-            layout_mode = MemoryLayoutMode.single if is_first_target else MemoryLayoutMode.split
+            # Use split layout only for the DRAM
+            layout_mode = MemoryLayoutMode.split if is_final_target else MemoryLayoutMode.single
             params = MemoryBenchmarkParams(
                 data_type=data_type,
                 thread_affinity=thread_affinity.cpu_ids,

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/benchmark/suites/roofline.py

@@ -65,7 +65,7 @@ class RooflineBenchmarkSuite(ISABenchmarkSuite):
         for bench in self.get_memory_benchmarks().values():
             if bench.cache_level is None:
                 raise ValueError(
-                    f"Memory benchmark {bench.name} missing cache level annotation for roofline benchmarking"
+                    f"Memory benchmark {bench.name} missing cache level annotation for roofline benchmarki>ng"
                 )
             if bench.results is None:
                 raise ValueError(f"Memory benchmark {bench.name} missing bandwidth result for roofline benchmarking")

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/carm.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# PYTHON_ARGCOMPLETE_OK
 from __future__ import annotations
 
 import argparse
@@ -9,6 +10,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import cast
 
+import argcomplete
 from rich_argparse import RichHelpFormatter
 
 from architecture import set_execution_interface
@@ -16,9 +18,10 @@ from arguments import InsertsArguments, TopLevelHelpFormatter
 from benchmark.interface import run_full_benchmark
 from benchmark.output import output_benchmark_results
 from context import Architecture, Benchmarking, CARMContext, ExecutionInterface, RunConfig
-from error import ConfigurationError
+from error import UserError
 from gui.config import GUIConfig
-from output_utils import configure_verbosity, debug, detail, error, info, warn
+from output_utils import configure_verbosity, debug, detail, error, info
+from profiling import ProfileConfig, profile_main
 
 RichHelpFormatter.styles.update(
     {
@@ -45,38 +48,27 @@ def _handle_benchmark(args: argparse.Namespace) -> int:
             info(f"Generated template TOML configuration: {args.emit_config}")
             return 0
         except OSError as e:
-            error(f"Failed to emit template config: {e}")
-            return 1
+            raise OSError(f"Failed to write template config: {e}") from e
 
-    try:
-        exec_iface = ExecutionInterface(args)
-        # Make exec_iface globally available for architecture feature detection
-        set_execution_interface(exec_iface)
-        architecture = Architecture(args)
-        benchmarking = Benchmarking(args)
-        run_config = RunConfig(args)
-
-        context = CARMContext(
-            architecture=architecture, benchmarking=benchmarking, run_config=run_config, exec_interface=exec_iface
-        )
+    exec_iface = ExecutionInterface(args)
+    # Make exec_iface globally available for architecture feature detection
+    set_execution_interface(exec_iface)
+    architecture = Architecture(args)
+    benchmarking = Benchmarking(args)
+    run_config = RunConfig(args)
 
-        benchmark_suites = run_full_benchmark(context)
+    context = CARMContext(
+        architecture=architecture, benchmarking=benchmarking, run_config=run_config, exec_interface=exec_iface
+    )
 
-        if run_config.dry_run:
-            detail("Dry run finished: benchmark code generated successfully.")
-            return 0
+    benchmark_suites = run_full_benchmark(context)
 
-        output_benchmark_results(context, benchmark_suites)
+    if run_config.dry_run:
+        detail("Dry run finished: benchmark code generated successfully.")
         return 0
 
-    except ConfigurationError as e:
-        error(str(e))
-        debug(str(traceback.format_exc()))
-        return 1
-    except Exception as e:
-        error(f"Unexpected error: {e.__class__.__name__}: {e}")
-        debug(str(traceback.format_exc()))
-        return 1
+    output_benchmark_results(context, benchmark_suites)
+    return 0
 
 
 def _handle_gui(args: argparse.Namespace) -> int:
@@ -93,15 +85,15 @@ def _handle_gui(args: argparse.Namespace) -> int:
         error('Failed to import GUI dependencies. Install optional GUI extras with: pip install "carm-roofline[gui]"')
         debug(str(traceback.format_exc()))
         return 1
-    except Exception as e:
-        error(f"Unexpected error: {e.__class__.__name__}: {e}")
-        debug(str(traceback.format_exc()))
-        return 1
 
 
-def _handle_profile(_args: argparse.Namespace) -> int:
-    warn("The 'profile' subcommand is not implemented yet. Use PMU_AI_Calculator.py or DBI_AI_Calculator.py for now.")
-    return 1
+def _handle_profile(args: argparse.Namespace) -> int:
+    configure_verbosity(args.verbose)
+    args_str = ", ".join(f"{k}={v}" for k, v in vars(args).items() if v is not None)
+    debug(f"parsed profile arguments: {args_str}")
+
+    config = ProfileConfig(args)
+    return profile_main(config)
 
 
 @dataclass
@@ -130,10 +122,12 @@ SUBPARSERS = (
     ),
     SubParserInfo(
         name="profile",
-        help_short="Profile applications (TBI)",
-        help_long="Profile applications with CARM metrics (TBI)",
+        help_short="Profile applications with PAPI",
+        help_long="Profile instrumented applications to compute roofline metrics (AI, GFLOP/s, bandwidth). "
+        "Supports MPI, threaded, and hybrid applications. "
+        "Usage: carm profile [options] -- <command>",
         handler=_handle_profile,
-        arg_inserting_modules=(),
+        arg_inserting_modules=(ProfileConfig,),
     ),
 )
 
@@ -168,6 +162,8 @@ def _create_parser() -> argparse.ArgumentParser:
 
 def main(argv: Sequence[str] | None = None) -> int:
     parser = _create_parser()
+    argcomplete.autocomplete(parser)
+
     if argv is None:
         argv = sys.argv[1:]
 
@@ -181,7 +177,17 @@ def main(argv: Sequence[str] | None = None) -> int:
         return 2
 
     handler = cast(Callable[[argparse.Namespace], int], args.handler)
-    return handler(args)
+
+    try:
+        return handler(args)
+    except UserError as e:
+        error(str(e))
+        debug(str(traceback.format_exc()))
+        return 1
+    except Exception as e:
+        error(f"Unexpected error: {e.__class__.__name__}: {e}")
+        debug(str(traceback.format_exc()))
+        return 1
 
 
 if __name__ == "__main__":

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/carm_roofline.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carm-roofline
-Version: 1.0.0.dev5
+Version: 1.0.1.dev0
 Summary: CARM: Cache-Aware Roofline Model benchmarking and visualization toolkit
 Author: CHaMP Team
 License:                   GNU LESSER GENERAL PUBLIC LICENSE
@@ -518,7 +518,7 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: System :: Benchmark
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Operating System :: POSIX :: Linux
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -529,6 +529,7 @@ Requires-Dist: numpy>=2.0.0
 Requires-Dist: matplotlib>=3.7.2
 Requires-Dist: tomli>=2.0.0
 Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: argcomplete>=3.0.0
 Provides-Extra: gui
 Requires-Dist: dash[diskcache]; extra == "gui"
 Requires-Dist: dash-bootstrap-components; extra == "gui"

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/carm_roofline.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ results_paths.py
 run_config.py
 units.py
 utils.py
+workspace.py
 architecture/__init__.py
 architecture/architecture.py
 architecture/arm.py
@@ -76,6 +77,14 @@ gui/assets/CARM_icon.svg
 gui/assets/CHAMP_logo.svg
 gui/assets/menu_icon.png
 gui/assets/style.css
+profiling/__init__.py
+profiling/aggregation.py
+profiling/backends.py
+profiling/config.py
+profiling/loaders.py
+profiling/metrics.py
+profiling/model.py
+profiling/output.py
 test/test_isa_codegen_integration.py
 test/test_memory_suite_generation.py
 test/test_output_module.py

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/carm_roofline.egg-info/requires.txt

@@ -4,6 +4,7 @@ numpy>=2.0.0
 matplotlib>=3.7.2
 tomli>=2.0.0
 platformdirs>=4.0.0
+argcomplete>=3.0.0
 
 [all]
 carm-roofline[dev,gui]

{carm_roofline-1.0.0.dev5 → carm_roofline-1.0.1.dev0}/carm_roofline.egg-info/top_level.txt

@@ -7,8 +7,10 @@ error
 exec_interface
 gui
 output_utils
+profiling
 results_paths
 run_config
 test_bench
 units
 utils
+workspace

carm_roofline-1.0.1.dev0/error.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+
+class UserError(Exception):
+    """Raised for "expected" errors that occur from the user misconfiguration or incompatible arguments."""