#!/usr/bin/env python3
#
# Copyright (c) Advanced Micro Devices, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

import ctypes
import inspect
import json
import sys
import unittest
import time
import statistics
import os

sys.path.append("/opt/rocm/libexec/amdsmi_cli/")

try:
    import amdsmi
except ImportError as exc:
    print(f"Warning: Could not import amdsmi: {exc}")

    # Create a minimal mock for testing
    class MockAmdsmi:
        def __init__(self):
            pass

        def __getattr__(self, name):
            return lambda *args, **kwargs: None

    amdsmi = MockAmdsmi()

from amdsmi import (
    amdsmi_init,
    amdsmi_shut_down,
    amdsmi_get_cpu_handles,
    amdsmi_get_cpu_hsmp_driver_version,
    AmdSmiInitFlags,
    AmdSmiException,
)

# Error map dictionary
error_map = {
    "0": "AMDSMI_STATUS_SUCCESS",
    "1": "AMDSMI_STATUS_INVAL",
    "2": "AMDSMI_STATUS_NOT_SUPPORTED",
    "3": "AMDSMI_STATUS_NOT_YET_IMPLEMENTED",
    "4": "AMDSMI_STATUS_FAIL_LOAD_MODULE",
    "5": "AMDSMI_STATUS_FAIL_LOAD_SYMBOL",
    "6": "AMDSMI_STATUS_DRM_ERROR",
    "7": "AMDSMI_STATUS_API_FAILED",
    "8": "AMDSMI_STATUS_TIMEOUT",
    "9": "AMDSMI_STATUS_RETRY",
    "10": "AMDSMI_STATUS_NO_PERM",
    "11": "AMDSMI_STATUS_INTERRUPT",
    "12": "AMDSMI_STATUS_IO",
    "13": "AMDSMI_STATUS_ADDRESS_FAULT",
    "14": "AMDSMI_STATUS_FILE_ERROR",
    "15": "AMDSMI_STATUS_OUT_OF_RESOURCES",
    "16": "AMDSMI_STATUS_INTERNAL_EXCEPTION",
    "17": "AMDSMI_STATUS_INPUT_OUT_OF_BOUNDS",
    "18": "AMDSMI_STATUS_INIT_ERROR",
    "19": "AMDSMI_STATUS_REFCOUNT_OVERFLOW",
    "20": "AMDSMI_STATUS_DIRECTORY_NOT_FOUND",
    "21": "AMDSMI_STATUS_IPC_ERROR",
    "30": "AMDSMI_STATUS_BUSY",
    "31": "AMDSMI_STATUS_NOT_FOUND",
    "32": "AMDSMI_STATUS_NOT_INIT",
    "33": "AMDSMI_STATUS_NO_SLOT",
    "34": "AMDSMI_STATUS_DRIVER_NOT_LOADED",
    "39": "AMDSMI_STATUS_MORE_DATA",
    "40": "AMDSMI_STATUS_NO_DATA",
    "41": "AMDSMI_STATUS_INSUFFICIENT_SIZE",
    "42": "AMDSMI_STATUS_UNEXPECTED_SIZE",
    "43": "AMDSMI_STATUS_UNEXPECTED_DATA",
    "44": "AMDSMI_STATUS_NON_AMD_CPU",
    "45": "AMDSMI_STATUS_NO_ENERGY_DRV",
    "46": "AMDSMI_STATUS_NO_MSR_DRV",
    "47": "AMDSMI_STATUS_NO_HSMP_DRV",
    "48": "AMDSMI_STATUS_NO_HSMP_SUP",
    "49": "AMDSMI_STATUS_NO_HSMP_MSG_SUP",
    "50": "AMDSMI_STATUS_HSMP_TIMEOUT",
    "51": "AMDSMI_STATUS_NO_DRV",
    "52": "AMDSMI_STATUS_FILE_NOT_FOUND",
    "53": "AMDSMI_STATUS_ARG_PTR_NULL",
    "54": "AMDSMI_STATUS_AMDGPU_RESTART_ERR",
    "55": "AMDSMI_STATUS_SETTING_UNAVAILABLE",
    "56": "AMDSMI_STATUS_CORRUPTED_EEPROM",
    "0xFFFFFFFE": "AMDSMI_STATUS_MAP_ERROR",
    "0xFFFFFFFF": "AMDSMI_STATUS_UNKNOWN_ERROR",
}

# Global variables needed for performance tests
verbose = 1
has_info_printed = False

# Global constants matching original test file
PASS = "AMDSMI_STATUS_SUCCESS"
FAIL = "AMDSMI_STATUS_INVAL"


class TestAmdSmiCPUPythonPerformance(unittest.TestCase):
    """
    Standalone Performance testing class for AMDSMI Python APIs.

    This class does NOT inherit from TestAmdSmiPython to avoid running all regular tests.
    It only runs performance-specific tests.
    """

    # Class-level attributes to prevent IndexError and AttributeError
    compute_partition_types = [
        ("SPX", amdsmi.AmdSmiComputePartitionType.SPX, PASS)
        if hasattr(amdsmi, "AmdSmiComputePartitionType")
        else ("SPX", None, PASS),
        ("DPX", amdsmi.AmdSmiComputePartitionType.DPX, PASS)
        if hasattr(amdsmi, "AmdSmiComputePartitionType")
        else ("DPX", None, PASS),
        ("TPX", amdsmi.AmdSmiComputePartitionType.TPX, PASS)
        if hasattr(amdsmi, "AmdSmiComputePartitionType")
        else ("TPX", None, PASS),
        ("QPX", amdsmi.AmdSmiComputePartitionType.QPX, PASS)
        if hasattr(amdsmi, "AmdSmiComputePartitionType")
        else ("QPX", None, PASS),
        ("CPX", amdsmi.AmdSmiComputePartitionType.CPX, PASS)
        if hasattr(amdsmi, "AmdSmiComputePartitionType")
        else ("CPX", None, PASS),
        ("INVALID", amdsmi.AmdSmiComputePartitionType.INVALID, FAIL)
        if hasattr(amdsmi, "AmdSmiComputePartitionType")
        else ("INVALID", None, FAIL),
    ]

    freq_inds = [
        ("MIN", amdsmi.AmdSmiFreqInd.MIN, PASS)
        if hasattr(amdsmi, "AmdSmiFreqInd")
        else ("MIN", None, PASS),
        ("MAX", amdsmi.AmdSmiFreqInd.MAX, PASS)
        if hasattr(amdsmi, "AmdSmiFreqInd")
        else ("MAX", None, PASS),
        ("INVALID", amdsmi.AmdSmiFreqInd.INVALID, FAIL)
        if hasattr(amdsmi, "AmdSmiFreqInd")
        else ("INVALID", None, FAIL),
    ]

    dev_perf_levels = [
        ("AUTO", amdsmi.AmdSmiDevPerfLevel.AUTO, PASS)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("AUTO", None, PASS),
        ("LOW", amdsmi.AmdSmiDevPerfLevel.LOW, PASS)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("LOW", None, PASS),
        ("HIGH", amdsmi.AmdSmiDevPerfLevel.HIGH, PASS)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("HIGH", None, PASS),
        ("MANUAL", amdsmi.AmdSmiDevPerfLevel.MANUAL, PASS)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("MANUAL", None, PASS),
        ("STABLE_STD", amdsmi.AmdSmiDevPerfLevel.STABLE_STD, PASS)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("STABLE_STD", None, PASS),
        ("STABLE_PEAK", amdsmi.AmdSmiDevPerfLevel.STABLE_PEAK, PASS)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("STABLE_PEAK", None, PASS),
        ("STABLE_MIN_MCLK", amdsmi.AmdSmiDevPerfLevel.STABLE_MIN_MCLK, PASS)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("STABLE_MIN_MCLK", None, PASS),
        ("STABLE_MIN_SCLK", amdsmi.AmdSmiDevPerfLevel.STABLE_MIN_SCLK, PASS)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("STABLE_MIN_SCLK", None, PASS),
        ("DETERMINISM", amdsmi.AmdSmiDevPerfLevel.DETERMINISM, PASS)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("DETERMINISM", None, PASS),
        ("UNKNOWN", amdsmi.AmdSmiDevPerfLevel.UNKNOWN, FAIL)
        if hasattr(amdsmi, "AmdSmiDevPerfLevel")
        else ("UNKNOWN", None, FAIL),
    ]

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        global has_info_printed
        if verbose and has_info_printed is False:
            # Execute the following to print the asic and board info once
            # per test run
            has_info_printed = True
            self.setUp()
            for i, gpu in enumerate(self.processors):
                try:
                    # Print asic info
                    msg = f"asic info(gpu={i})"
                    ret = amdsmi.amdsmi_get_gpu_asic_info(gpu)
                    self._print(msg, ret)
                except amdsmi.AmdSmiLibraryException as e:
                    raise e
            for i, gpu in enumerate(self.processors):
                try:
                    # Print board info
                    msg = f"board info(gpu={i})"
                    ret = amdsmi.amdsmi_get_gpu_board_info(gpu)
                    self._print(msg, ret)
                except amdsmi.AmdSmiLibraryException as e:
                    raise e
            self.tearDown()
        # Performance test configuration
        self.perf_iterations = 11  # Number of iterations for each performance test
        self.perf_warmup_iterations = 3  # Number of warmup iterations
        self.perf_results = {}  # Store performance results

    def setUp(self):
        """Setup for performance tests - minimal setup just for performance testing."""
        self.time = time
        self.statistics = statistics

        # Add skip flags for consistency with original tests
        self.TODO_SKIP_FAIL = False
        self.TODO_SKIP_NOT_COMPLETE = False

        # Use global constants matching original test file
        self.PASS = PASS
        self.FAIL = FAIL

        # Initialize empty lists for robustness - will be populated if amdsmi is available
        self.status_types = []
        self.clk_types = []
        self.io_bw_encodings = []
        self.event_groups = []
        self.gpu_blocks = []
        self.memory_types = []
        self.processor_types = []
        self.reg_types = []
        self.voltage_metrics = []
        self.voltage_types = []
        self.link_types = []
        self.temperature_types = []
        self.utilization_counter_types = []
        self.event_types = []
        self.counter_commands = []
        self.power_profile_preset_masks = []
        self.temperature_metrics = []
        self.clk_limit_types = []
        self.memory_partition_types = []

        # Try to populate with actual amdsmi attributes if available
        self._populate_amdsmi_attributes()

        # Initialize AMDSMI if available
        try:
            if hasattr(amdsmi, "amdsmi_init"):
                amdsmi.amdsmi_init(AmdSmiInitFlags.INIT_AMD_CPUS)
                self.processors = (
                    amdsmi.amdsmi_get_processor_handles()
                    if hasattr(amdsmi, "amdsmi_get_processor_handles")
                    else []
                )
            else:
                self.processors = []
        except Exception as e:
            print(f"Warning: Failed to initialize AMDSMI: {e}")
            self.processors = []

    def _populate_amdsmi_attributes(self):
        """Try to populate attribute lists with amdsmi enums if available."""
        # This method safely tries to access amdsmi attributes and populates lists
        # If amdsmi is not available or missing attributes, it silently continues

        # Wrap all attribute access in a try-catch to handle missing amdsmi properly
        try:
            if hasattr(amdsmi, "AmdSmiStatus"):
                self.status_types = [
                    ("SUCCESS", amdsmi.AmdSmiStatus.SUCCESS, self.PASS),
                    ("INVAL", amdsmi.AmdSmiStatus.INVAL, self.PASS),
                    ("NOT_SUPPORTED", amdsmi.AmdSmiStatus.NOT_SUPPORTED, self.PASS),
                    ("UNKNOWN_ERROR", amdsmi.AmdSmiStatus.UNKNOWN_ERROR, self.PASS),
                ]
        except (AttributeError, Exception):
            pass

        # Add more attribute populations as needed - this is a safe fallback approach

    def tearDown(self):
        """Cleanup after performance tests."""
        try:
            if hasattr(amdsmi, "amdsmi_shut_down"):
                amdsmi.amdsmi_shut_down()
        except Exception:
            pass  # Ignore cleanup errors

    def _print_func_name(self, msg=""):
        """Helper method to print function name for consistency with original tests."""
        if verbose == 2:
            print(f"{inspect.currentframe().f_back.f_code.co_name}: {msg}")

    def _log_test_start(self, api_name, device_type, device_id, **kwargs):
        """Helper method to log the start of a test."""
        if verbose:
            extra_info = " ".join([f"{k}={v}" for k, v in kwargs.items()])
            print(f"Testing {api_name} on {device_type} {device_id} {extra_info}".strip())

    def _log_test_end(self, api_name, device_type, device_id, stats, **kwargs):
        """Helper method to log the end of a test."""
        if verbose and stats:
            print(
                f"Completed {api_name} on {device_type} {device_id}: {stats.get('mean_time_ms', 0):.3f}ms avg"
            )

    def _print_performance_results(self, stats):
        """Helper method to print performance results."""
        if verbose:
            print(
                f"  Performance: {stats['mean_time_ms']:.3f}ms avg, {stats['min_time_ms']:.3f}ms min, {stats['max_time_ms']:.3f}ms max"
            )

    def _log_test_completion(self, device_type, device_id, extra_info=""):
        """Helper method to log test completion."""
        if verbose:
            extra_msg = f" - {extra_info}" if extra_info else ""
            print(f"  {device_type} {device_id}: Test completed{extra_msg}")

    def _log_performance_summary(self, api_name, device_type_plural, test_name):
        """Helper method to log performance summary."""
        if verbose:
            print(f"Performance test completed for {api_name} on {device_type_plural}")
            print()  # Add empty line for readability

    def _print(self, msg, result):
        """Helper method for printing test results."""
        if verbose:
            if isinstance(result, dict) or isinstance(result, list):
                if msg:
                    print(msg)
                print(json.dumps(result, sort_keys=False, indent=4, default=str))
            else:
                print(f"{msg}: {result}" if msg else result)

    def _print_api_result(self, api_func, processor_id, *args, label_prefix="gpu", **kwargs):
        """
        Helper method to call an API and print its result before performance measurement.

        Args:
            api_func: The API function to call
            processor_id: The processor/GPU ID
            *args: Arguments to pass to the API
            label_prefix: Prefix for the label (default: "gpu")
            **kwargs: Keyword arguments to pass to the API
        """
        if not verbose:
            return

        func_name = api_func.__name__
        msg = f"### test {func_name}({label_prefix}={processor_id})"

        try:
            result = api_func(*args, **kwargs)
            self._print(msg, result)
        except Exception as e:
            print(msg, flush=True)
            # Don't raise - let the performance test measure the errors
            pass

    def _run_performance_assertions(self, stats, api_name):
        """Helper method to run assertions on performance test statistics."""
        # Basic performance test assertions
        self.assertIsInstance(stats, dict, f"Stats should be a dictionary for {api_name}")
        self.assertIn("iterations", stats, f"Stats should contain iterations for {api_name}")
        self.assertIn(
            "successful_runs", stats, f"Stats should contain successful_runs for {api_name}"
        )
        self.assertIn("error_count", stats, f"Stats should contain error_count for {api_name}")

        # If there were successful runs, check performance metrics
        if stats.get("successful_runs", 0) > 0:
            self.assertIn(
                "mean_time_ms", stats, f"Stats should contain mean_time_ms for {api_name}"
            )
            self.assertIn("min_time_ms", stats, f"Stats should contain min_time_ms for {api_name}")
            self.assertIn("max_time_ms", stats, f"Stats should contain max_time_ms for {api_name}")
            self.assertGreaterEqual(
                stats["mean_time_ms"], 0, f"Mean time should be non-negative for {api_name}"
            )
            self.assertGreaterEqual(
                stats["min_time_ms"], 0, f"Min time should be non-negative for {api_name}"
            )
            self.assertGreaterEqual(
                stats["max_time_ms"], 0, f"Max time should be non-negative for {api_name}"
            )

    def _measure_api_performance(self, api_func, api_name, *args, **kwargs):
        """
        Measure the performance of an AMDSMI API function.

        Args:
            api_func: The API function to measure
            api_name: Human-readable name of the API
            *args: Arguments to pass to the API function
            **kwargs: Keyword arguments to pass to the API function

        Returns:
            dict: Performance statistics including min, max, mean, median times
        """
        times = []
        errors = []
        error_count = 0

        # Warmup iterations
        for _ in range(self.perf_warmup_iterations):
            try:
                api_func(*args, **kwargs)
            except Exception:
                pass  # Ignore warmup errors

        # Measurement iterations
        for i in range(self.perf_iterations):
            start_time = self.time.perf_counter()
            try:
                result = api_func(*args, **kwargs)
                end_time = self.time.perf_counter()
                execution_time = (end_time - start_time) * 1000  # Convert to milliseconds
                times.append(execution_time)
            except Exception as e:
                error_count += 1
                end_time = self.time.perf_counter()
                execution_time = (end_time - start_time) * 1000
                times.append(execution_time)  # Include error times in statistics
                errors.append({"iteration": i, "error_info": str(e)})

        # Calculate statistics
        if times:
            successful_runs = len(times) - error_count
            stats = {
                "api_name": api_name,
                "iterations": len(times),
                "errors": errors,
                "error_count": error_count,
                "successful_runs": successful_runs,
                "min_time_ms": min(times),
                "max_time_ms": max(times),
                "mean_time_ms": self.statistics.mean(times),
                "median_time_ms": self.statistics.median(times),
                "times_ms": times,
            }

            if len(times) > 1:
                stats["stdev_ms"] = self.statistics.stdev(times)

            # Store results
            self.perf_results[api_name] = stats

            # Print results if verbose
            if verbose:
                print(
                    f"Performance {api_name}: {stats['mean_time_ms']:.3f}ms avg, "
                    f"{stats['min_time_ms']:.3f}ms min, {stats['max_time_ms']:.3f}ms max, "
                    f"{error_count} errors"
                )

            return stats
        else:
            return {"api_name": api_name, "error": "No successful measurements"}

    def test_performance_cpu_apb_disable(self):
        self._print_func_name("Starting performance test for amdsmi_cpu_apb_disable")
        # Use pstate=0 from original test
        pstate = 0
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]
        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_cpu_apb_disable", "cpu", i, pstate=pstate)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_cpu_apb_disable,
                    f"cpu_apb_disable_processor_{i}",
                    processor,
                    pstate,
                )
                self.perf_results[f"cpu_apb_disable_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )
            self._log_test_completion("Processor", i)
            i = i + 1
        self._log_performance_summary("amdsmi_cpu_apb_disable", "Processors", "cpu_apb_disable")

    def test_performance_cpu_apb_enable(self):
        self._print_func_name("Starting performance test for amdsmi_cpu_apb_enable")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_cpu_apb_enable", "cpu", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_cpu_apb_enable, f"cpu_apb_enable_processor_{i}", processor
                )

                self.perf_results[f"cpu_apb_enable_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary("amdsmi_cpu_apb_enable", "Processors", "cpu_apb_enable")

    def test_performance_first_online_core_on_cpu_socket(self):
        self._print_func_name(
            "Starting performance test for amdsmi_first_online_core_on_cpu_socket"
        )
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_first_online_core_on_cpu_socket", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_first_online_core_on_cpu_socket,
                    f"first_online_core_processor_{i}",
                    processor,
                )

                self.perf_results[f"first_online_core_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                    self._run_performance_assertions(
                        stats, "amdsmi_first_online_core_on_cpu_socket"
                    )
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside the loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_first_online_core_on_cpu_socket", "Processors", "first_online_core"
        )

    def test_performance_get_cpu_cclk_limit(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_cclk_limit")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_cclk_limit", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_cclk_limit, f"get_cpu_cclk_limit_processor_{i}", processor
                )

                self.perf_results[f"get_cpu_cclk_limit_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_cclk_limit", "Processors", "get_cpu_cclk_limit"
        )

    def test_performance_get_cpu_core_current_freq_limit(self):
        self._print_func_name(
            "Starting performance test for amdsmi_get_cpu_core_current_freq_limit"
        )
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_core_current_freq_limit", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_core_current_freq_limit,
                    f"get_cpu_core_current_freq_limit_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_core_current_freq_limit_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_core_current_freq_limit",
            "Processors",
            "get_cpu_core_current_freq_limit",
        )

    def test_performance_get_cpu_core_energy(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_core_energy")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_core_energy", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_core_energy,
                    f"get_cpu_core_energy_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_core_energy_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside the loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_core_energy", "Processors", "get_cpu_core_energy"
        )

    def test_performance_get_cpu_current_io_bandwidth(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_current_io_bandwidth")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_get_cpu_current_io_bandwidth", "Processor", i, encoding=encoding_name
                )
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_current_io_bandwidth,
                    f"get_cpu_current_io_bandwidth_processor_{i}_encoding_{encoding_name}",
                    processor,
                    encoding,
                    encoding_name,
                )

                self.perf_results[
                    f"get_cpu_current_io_bandwidth_processor_{i}_encoding_{encoding_name}"
                ] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i} encoding={encoding_name}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_current_io_bandwidth", "Processors", "get_cpu_current_io_bandwidth"
        )

    def test_performance_get_cpu_ddr_bw(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_ddr_bw")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_ddr_bw", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_ddr_bw, f"get_cpu_ddr_bw_processor_{i}", processor
                )

                self.perf_results[f"get_cpu_ddr_bw_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside the loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary("amdsmi_get_cpu_ddr_bw", "Processors", "get_cpu_ddr_bw")

    def test_performance_get_cpu_dimm_power_consumption(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_dimm_power_consumption")
        i = 0
        dimm_addr = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_get_cpu_dimm_power_consumption", "Processor", i, dimm_addr=dimm_addr
                )
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_dimm_power_consumption,
                    f"get_cpu_dimm_power_processor_{i}",
                    processor,
                    dimm_addr,
                )

                self.perf_results[f"get_cpu_dimm_power_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_dimm_power_consumption", "Processors", "get_cpu_dimm_power"
        )

    def test_performance_get_cpu_dimm_temp_range_and_refresh_rate(self):
        self._print_func_name(
            "Starting performance test for amdsmi_get_cpu_dimm_temp_range_and_refresh_rate"
        )
        dimm_addr = 0
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_get_cpu_dimm_temp_range_and_refresh_rate",
                    "Processor",
                    i,
                    dimm_addr=dimm_addr,
                )
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_dimm_temp_range_and_refresh_rate,
                    f"get_cpu_dimm_temp_range_processor_{i}",
                    processor,
                    dimm_addr,
                )

                self.perf_results[f"get_cpu_dimm_temp_range_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_dimm_temp_range_and_refresh_rate",
            "Processors",
            "get_cpu_dimm_temp_range",
        )

    def test_performance_get_cpu_dimm_thermal_sensor(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_dimm_thermal_sensor")
        dimm_addr = 0
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_get_cpu_dimm_thermal_sensor", "Processor", i, dimm_addr=dimm_addr
                )
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_dimm_thermal_sensor,
                    f"get_cpu_dimm_thermal_sensor_processor_{i}",
                    processor,
                    dimm_addr,
                )

                self.perf_results[f"get_cpu_dimm_thermal_sensor_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_dimm_thermal_sensor", "Processors", "get_cpu_dimm_thermal_sensor"
        )

    def test_performance_get_cpu_family(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_family")
        self._log_test_start("amdsmi_get_cpu_family", "System", "global")

        stats = self._measure_api_performance(amdsmi.amdsmi_get_cpu_family, "get_cpu_family_system")

        self.perf_results["get_cpu_family_system"] = stats
        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
        else:
            print(
                f"  System: All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("System", "global")
        self._log_performance_summary("amdsmi_get_cpu_family", "System", "get_cpu_family")

    def test_performance_get_cpu_fclk_mclk(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_fclk_mclk")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_fclk_mclk", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_fclk_mclk, f"get_cpu_fclk_mclk_processor_{i}", processor
                )

                self.perf_results[f"get_cpu_fclk_mclk_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary("amdsmi_get_cpu_fclk_mclk", "Processors", "get_cpu_fclk_mclk")

    def test_performance_get_cpu_handles(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_handles")
        self._log_test_start("amdsmi_get_cpu_handles", "System", "global")

        stats = self._measure_api_performance(
            amdsmi.amdsmi_get_cpu_handles, "get_cpu_handles_system"
        )

        self.perf_results["get_cpu_handles_system"] = stats
        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
        else:
            print(
                f"  System: All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("System", "global")
        self._log_performance_summary("amdsmi_get_cpu_handles", "System", "get_cpu_handles")

    def test_performance_get_cpu_hsmp_driver_version(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_hsmp_driver_version")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_hsmp_driver_version", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_hsmp_driver_version,
                    f"get_cpu_hsmp_driver_version_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_hsmp_driver_version_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_hsmp_driver_version", "Processors", "get_cpu_hsmp_driver_version"
        )

    def test_performance_get_cpu_hsmp_proto_ver(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_hsmp_proto_ver")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_hsmp_proto_ver", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_hsmp_proto_ver,
                    f"get_cpu_hsmp_proto_ver_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_hsmp_proto_ver_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_hsmp_proto_ver", "Processors", "get_cpu_hsmp_proto_ver"
        )

    def test_performance_get_cpu_model(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_model")
        self._log_test_start("amdsmi_get_cpu_model", "System", "global")

        stats = self._measure_api_performance(amdsmi.amdsmi_get_cpu_model, "get_cpu_model_system")

        self.perf_results["get_cpu_model_system"] = stats
        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
        else:
            print(
                f"  System: All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("System", "global")
        self._log_performance_summary("amdsmi_get_cpu_model", "System", "get_cpu_model")

    def test_performance_get_cpu_prochot_status(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_prochot_status")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_prochot_status", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_prochot_status,
                    f"get_cpu_prochot_status_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_prochot_status_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_prochot_status", "Processors", "get_cpu_prochot_status"
        )

    def test_performance_get_cpu_pwr_svi_telemetry_all_rails(self):
        self._print_func_name(
            "Starting performance test for amdsmi_get_cpu_pwr_svi_telemetry_all_rails"
        )
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_pwr_svi_telemetry_all_rails", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_pwr_svi_telemetry_all_rails,
                    f"get_cpu_pwr_svi_telemetry_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_pwr_svi_telemetry_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_pwr_svi_telemetry_all_rails", "Processors", "get_cpu_pwr_svi_telemetry"
        )

    def test_performance_get_cpu_smu_fw_version(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_smu_fw_version")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_smu_fw_version", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_smu_fw_version,
                    f"get_cpu_smu_fw_version_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_smu_fw_version_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_smu_fw_version", "Processors", "get_cpu_smu_fw_version"
        )

    def test_performance_get_cpu_socket_c0_residency(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_socket_c0_residency")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_socket_c0_residency", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_socket_c0_residency,
                    f"get_cpu_socket_c0_residency_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_socket_c0_residency_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_socket_c0_residency", "Processors", "get_cpu_socket_c0_residency"
        )

    def test_performance_get_cpu_socket_current_active_freq_limit(self):
        self._print_func_name(
            "Starting performance test for amdsmi_get_cpu_socket_current_active_freq_limit"
        )
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_get_cpu_socket_current_active_freq_limit", "Processor", i
                )
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_socket_current_active_freq_limit,
                    f"get_cpu_socket_current_active_freq_limit_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_socket_current_active_freq_limit_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_socket_current_active_freq_limit",
            "Processors",
            "get_cpu_socket_current_active_freq_limit",
        )

    def test_performance_get_cpu_socket_energy(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_socket_energy")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_socket_energy", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_socket_energy,
                    f"get_cpu_socket_energy_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_socket_energy_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_socket_energy", "Processors", "get_cpu_socket_energy"
        )

    def test_performance_get_cpu_socket_freq_range(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_socket_freq_range")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_socket_freq_range", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_socket_freq_range,
                    f"get_cpu_socket_freq_range_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_socket_freq_range_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_socket_freq_range", "Processors", "get_cpu_socket_freq_range"
        )

    def test_performance_get_cpu_socket_lclk_dpm_level(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_socket_lclk_dpm_level")
        nbio_id = 0
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_get_cpu_socket_lclk_dpm_level", "Processor", i, nbio_id=nbio_id
                )
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_socket_lclk_dpm_level,
                    f"get_cpu_socket_lclk_dpm_processor_{i}",
                    processor,
                    nbio_id,
                )

                self.perf_results[f"get_cpu_socket_lclk_dpm_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i = i + 1  # increment inside loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_socket_lclk_dpm_level", "Processors", "get_cpu_socket_lclk_dpm_level"
        )

    def test_performance_get_cpu_socket_power(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_socket_power")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_socket_power", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_socket_power,
                    f"get_cpu_socket_power_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_socket_power_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i += 1  # increment inside the loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_socket_power", "Processors", "get_cpu_socket_power"
        )

    def test_performance_get_cpu_socket_power_cap_max(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_socket_power_cap_max")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_socket_power_cap_max", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_socket_power_cap_max,
                    f"get_cpu_socket_power_cap_max_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_socket_power_cap_max_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i += 1  # increment inside the loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_socket_power_cap_max", "Processors", "get_cpu_socket_power_cap_max"
        )

    def test_performance_get_cpu_socket_temperature(self):
        self._print_func_name("Starting performance test for amdsmi_get_cpu_socket_temperature")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_cpu_socket_temperature", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_socket_temperature,
                    f"get_cpu_socket_temperature_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_cpu_socket_temperature_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                i += 1  # increment inside the loop

            self._log_test_completion("Processor", i)

        self._log_performance_summary(
            "amdsmi_get_cpu_socket_temperature", "Processors", "get_cpu_socket_temperature"
        )

    def test_performance_get_esmi_err_msg(self):
        self._print_func_name("Starting performance test for amdsmi_get_esmi_err_msg")

        for status_type_name, status_type, status_cond in self.status_types:
            self._log_test_start("amdsmi_get_esmi_err_msg", "Status", status_type_name)

            stats = self._measure_api_performance(
                amdsmi.amdsmi_get_esmi_err_msg,
                f"get_esmi_err_msg_status_{status_type_name}",
                status_type,
            )

            self.perf_results[f"get_esmi_err_msg_status_{status_type_name}"] = stats
            if stats["successful_runs"] > 0:
                self._print_performance_results(stats)
            else:
                print(
                    f"  Status {status_type_name}: All calls failed - "
                    f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                )

            self._log_test_completion("Status", status_type_name)

        self._log_performance_summary("amdsmi_get_esmi_err_msg", "Status types", "get_esmi_err_msg")

    def test_performance_get_hsmp_metrics_table(self):
        self._print_func_name("Starting performance test for amdsmi_get_hsmp_metrics_table")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_hsmp_metrics_table", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_hsmp_metrics_table,
                    f"get_hsmp_metrics_table_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_hsmp_metrics_table_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Processor", i)
                i += 1

        self._log_performance_summary(
            "amdsmi_get_hsmp_metrics_table", "Processors", "get_hsmp_metrics_table"
        )

    def test_performance_get_hsmp_metrics_table_version(self):
        self._print_func_name("Starting performance test for amdsmi_get_hsmp_metrics_table_version")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_hsmp_metrics_table_version", "Processor", i)
                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_hsmp_metrics_table_version,
                    f"get_hsmp_metrics_table_version_processor_{i}",
                    processor,
                )

                self.perf_results[f"get_hsmp_metrics_table_version_processor_{i}"] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Processor", i)
                i += 1

        self._log_performance_summary(
            "amdsmi_get_hsmp_metrics_table_version", "Sockets", "get_hsmp_metrics_table_version"
        )

    def test_performance_get_lib_version(self):
        self._print_func_name("Starting performance test for amdsmi_get_lib_version")

        self._log_test_start("amdsmi_get_lib_version", "System", "global")

        stats = self._measure_api_performance(amdsmi.amdsmi_get_lib_version, "get_lib_version")

        self.perf_results["get_lib_version"] = stats

        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
        else:
            print(
                f"  All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("System", "global")
        self._log_performance_summary("amdsmi_get_lib_version", "System", "get_lib_version")

    def test_performance_set_cpu_pcie_link_rate(self):
        self._print_func_name("Starting performance test for amdsmi_set_cpu_pcie_link_rate")
        # Test with different rate_ctrl values
        rate_ctrls = [0]  # Starting with 0 as in original test
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                for rate_ctrl in rate_ctrls:
                    self._log_test_start(
                        "amdsmi_set_cpu_pcie_link_rate", "Processor", i, rate_ctrl=rate_ctrl
                    )

                    stats = self._measure_api_performance(
                        amdsmi.amdsmi_set_cpu_pcie_link_rate,
                        f"set_cpu_pcie_link_rate_cpu_{i}_rate_{rate_ctrl}",
                        processor,
                        rate_ctrl,
                    )

                    self.perf_results[f"set_cpu_pcie_link_rate_cpu_{i}_rate_{rate_ctrl}"] = stats

                    if stats["successful_runs"] > 0:
                        self._print_performance_results(stats)
                        self._run_performance_assertions(stats, "amdsmi_set_cpu_pcie_link_rate")
                    else:
                        print(
                            f"  CPU {i} rate_ctrl {rate_ctrl}: All calls failed - "
                            f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                        )

                self._log_test_completion("CPU", i, f"rate_ctrl={rate_ctrl}")

        self._log_performance_summary(
            "amdsmi_set_cpu_pcie_link_rate", "CPUs", "set_cpu_pcie_link_rate"
        )

    def test_performance_get_processor_count_from_handles(self):
        self._print_func_name(
            "Starting performance test for amdsmi_get_processor_count_from_handles"
        )

        self._log_test_start("amdsmi_get_processor_count_from_handles", "Processors", "all")

        stats = self._measure_api_performance(
            amdsmi.amdsmi_get_processor_count_from_handles,
            "get_processor_count_from_handles",
            self.processors,
        )

        self.perf_results["get_processor_count_from_handles"] = stats

        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
            self._run_performance_assertions(stats, "amdsmi_get_processor_count_from_handles")
        else:
            print(
                f"  All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("Processors", "all")
        self._log_performance_summary(
            "amdsmi_get_processor_count_from_handles",
            "Processors",
            "get_processor_count_from_handles",
        )

    def test_performance_get_processor_handle_from_bdf(self):
        self._print_func_name("Starting performance test for amdsmi_get_processor_handle_from_bdf")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_processor_handle_from_bdf", "CPU", i)

                try:
                    # Get BDF for this processor first
                    bdf = amdsmi.amdsmi_get_gpu_device_bdf(processor)

                    stats = self._measure_api_performance(
                        amdsmi.amdsmi_get_processor_handle_from_bdf,
                        f"get_processor_handle_from_bdf_cpu_{i}",
                        bdf,
                    )

                    self.perf_results[f"get_processor_handle_from_bdf_cpu_{i}"] = stats
                    if stats["successful_runs"] > 0:
                        self._print_performance_results(stats)
                        self._run_performance_assertions(
                            stats, "amdsmi_get_processor_handle_from_bdf"
                        )

                    # Validate that the returned handle matches the original processor
                    ret = amdsmi.amdsmi_get_processor_handle_from_bdf(bdf)
                    if processor.value != ret.value:
                        print(
                            f"  WARNING: CPU {i} - Handle mismatch! Expected: {processor.value}, Received: {ret.value}"
                        )
                    else:
                        print(
                            f"  CPU {i}: All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                        )

                except Exception as e:
                    print(f"  CPU {i}: Error getting BDF - {e}")

                self._log_test_completion("CPU", i)
                i = i + 1

        self._log_performance_summary(
            "amdsmi_get_processor_handle_from_bdf", "CPUs", "get_processor_handle_from_bdf"
        )

    def test_performance_get_processor_handles(self):
        self._print_func_name("Starting performance test for amdsmi_get_processor_handles")

        self._log_test_start("amdsmi_get_processor_handles", "System", "global")

        stats = self._measure_api_performance(
            amdsmi.amdsmi_get_processor_handles, "get_processor_handles"
        )

        self.perf_results["get_processor_handles"] = stats

        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
            self._run_performance_assertions(stats, "amdsmi_get_processor_handles")
        else:
            print(
                f"  All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("System", "global")
        self._log_performance_summary(
            "amdsmi_get_processor_handles", "System", "get_processor_handles"
        )

    def test_performance_get_processor_handles_by_type(self):
        self._print_func_name("Starting performance test for amdsmi_get_processor_handles_by_type")

        socket_handles = amdsmi.amdsmi_get_socket_handles()

        for index, socket_handle in enumerate(socket_handles):
            for processor_name, processor_type, processor_cond in self.processor_types:
                self._log_test_start(
                    "amdsmi_get_processor_handles_by_type",
                    "Socket",
                    index,
                    processor_type=processor_name,
                )

                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_processor_handles_by_type,
                    f"get_processor_handles_by_type_socket_{index}_type_{processor_name}",
                    socket_handle,
                    processor_type,
                )

                self.perf_results[
                    f"get_processor_handles_by_type_socket_{index}_type_{processor_name}"
                ] = stats

                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                    self._run_performance_assertions(stats, "amdsmi_get_processor_handles_by_type")
                else:
                    print(
                        f"  Socket {index} type {processor_name}: All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Socket", index, f"processor_type={processor_name}")

        self._log_performance_summary(
            "amdsmi_get_processor_handles_by_type", "Sockets", "get_processor_handles_by_type"
        )

    def test_performance_get_processor_info(self):
        self._print_func_name("Starting performance test for amdsmi_get_processor_info")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_processor_info", "CPU", i)

                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_processor_info, f"get_processor_info_cpu_{i}", processor
                )

                self.perf_results[f"get_processor_info_cpu_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                    self._run_performance_assertions(stats, "amdsmi_get_processor_info")
                else:
                    print(
                        f"  CPU {i}: All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("CPU", i)
                i = i + 1

        self._log_performance_summary("amdsmi_get_processor_info", "CPUs", "get_processor_info")

    def test_performance_get_processor_type(self):
        self._print_func_name("Starting performance test for amdsmi_get_processor_type")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("amdsmi_get_processor_type", "CPU", i)

                stats = self._measure_api_performance(
                    amdsmi.amdsmi_get_processor_type, f"get_processor_type_cpu_{i}", processor
                )

                self.perf_results[f"get_processor_type_cpu_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                    self._run_performance_assertions(stats, "amdsmi_get_processor_type")
                else:
                    print(
                        f"  CPU {i}: All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("CPU", i)
                i = i + 1

        self._log_performance_summary("amdsmi_get_processor_type", "CPUs", "get_processor_type")

    def test_performance_get_socket_handles(self):
        self._print_func_name("Starting performance test for amdsmi_get_socket_handles")

        self._log_test_start("amdsmi_get_socket_handles", "System", "global")

        stats = self._measure_api_performance(
            amdsmi.amdsmi_get_socket_handles, "get_socket_handles"
        )

        self.perf_results["get_socket_handles"] = stats

        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
            self._run_performance_assertions(stats, "amdsmi_get_socket_handles")
        else:
            print(
                f"  All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("System", "global")
        self._log_performance_summary("amdsmi_get_socket_handles", "System", "get_socket_handles")

    def test_performance_get_socket_info(self):
        self._print_func_name("Starting performance test for amdsmi_get_socket_info")

        sockets = amdsmi.amdsmi_get_socket_handles()

        for i, socket in enumerate(sockets):
            self._log_test_start("amdsmi_get_socket_info", "Socket", i)

            stats = self._measure_api_performance(
                amdsmi.amdsmi_get_socket_info, f"get_socket_info_socket_{i}", socket
            )

            self.perf_results[f"get_socket_info_socket_{i}"] = stats

            if stats["successful_runs"] > 0:
                self._print_performance_results(stats)
                self._run_performance_assertions(stats, "amdsmi_get_socket_info")
            else:
                print(
                    f"  Socket {i}: All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                )

            self._log_test_completion("Socket", i)

        self._log_performance_summary("amdsmi_get_socket_info", "Sockets", "get_socket_info")

    def test_performance_get_temp_metric(self):
        self._print_func_name("Starting performance test for amdsmi_get_temp_metric")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                for (
                    temperature_type_name,
                    temperature_type,
                    temperature_type_cond,
                ) in self.temperature_types:
                    for (
                        temperature_metric_name,
                        temperature_metric,
                        temperature_metric_cond,
                    ) in self.temperature_metrics:
                        self._log_test_start(
                            "amdsmi_get_temp_metric",
                            "CPU",
                            i,
                            temperature_type=temperature_type_name,
                            temperature_metric=temperature_metric_name,
                        )

                        stats = self._measure_api_performance(
                            amdsmi.amdsmi_get_temp_metric,
                            f"get_temp_metric_cpu_{i}_{temperature_type_name}_{temperature_metric_name}",
                            processor,
                            temperature_type,
                            temperature_metric,
                        )

                        self.perf_results[
                            f"get_temp_metric_cpu_{i}_{temperature_type_name}_{temperature_metric_name}"
                        ] = stats
                        if stats["successful_runs"] > 0:
                            self._print_performance_results(stats)
                            self._run_performance_assertions(stats, "amdsmi_get_temp_metric")
                        else:
                            print(
                                f"  CPU {i} {temperature_type_name}/{temperature_metric_name}: All calls failed - "
                                f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                            )

                self._log_test_completion(
                    "CPU",
                    i,
                    f"temperature_type={temperature_type_name}, temperature_metric={temperature_metric_name}",
                )
                i = i + 1

        self._log_performance_summary("amdsmi_get_temp_metric", "CPUs", "get_temp_metric")

    def test_performance_get_threads_per_core(self):
        self._print_func_name("Starting performance test for amdsmi_get_threads_per_core")
        self._log_test_start("amdsmi_get_threads_per_core", "System", 0)

        stats = self._measure_api_performance(
            amdsmi.amdsmi_get_threads_per_core, "get_threads_per_core"
        )

        self.perf_results["get_threads_per_core"] = stats

        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
            self._run_performance_assertions(stats, "amdsmi_get_threads_per_core")
        else:
            print(
                f"  System: All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("System", 0)

        self._log_performance_summary(
            "amdsmi_get_threads_per_core", "System", "get_threads_per_core"
        )

    def test_performance_init(self):
        self._print_func_name("Starting performance test for amdsmi_init")

        self._log_test_start("amdsmi_init", "System", "global")

        # Note: We need to be careful with init/shutdown as they affect the entire library state
        stats = self._measure_api_performance(amdsmi.amdsmi_init, "init_system")

        self.perf_results["init_system"] = stats

        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
        else:
            print(
                f"  All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("System", "global")
        self._log_performance_summary("amdsmi_init", "System", "init")

    def test_performance_shutdown(self):
        self._print_func_name("Starting performance test for amdsmi_shut_down")

        self._log_test_start("amdsmi_shut_down", "System", "global")

        # Note: We need to be careful with init/shutdown as they affect the entire library state
        stats = self._measure_api_performance(amdsmi.amdsmi_shut_down, "shutdown_system")

        self.perf_results["shutdown_system"] = stats

        if stats["successful_runs"] > 0:
            self._print_performance_results(stats)
        else:
            print(
                f"  All calls failed - {stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
            )

        self._log_test_completion("System", "global")
        self._log_performance_summary("amdsmi_shut_down", "System", "shutdown")

    def test_performance_cpu_core_boostlimit(self):
        self._print_func_name("Starting performance test for CPU core boostlimit workflow")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("cpu_core_boostlimit_workflow", "Processor", i)

                # Test Get CPU Core Boostlimit
                stats_get = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_core_boostlimit,
                    f"get_cpu_core_boostlimit_processor_{i}",
                    processor,
                )
                self.perf_results[f"get_cpu_core_boostlimit_processor_{i}"] = stats_get

                if stats_get["successful_runs"] > 0:
                    self._print_performance_results(stats_get)

                    # Try to get the boost limit value for setting test
                    try:
                        boost_limit = amdsmi.amdsmi_get_cpu_core_boostlimit(processor)

                        # Test Set CPU Core Boostlimit (with same value to avoid changing system state)
                        stats_set = self._measure_api_performance(
                            amdsmi.amdsmi_set_cpu_core_boostlimit,
                            f"set_cpu_core_boostlimit_processor_{i}",
                            processor,
                            boost_limit,
                        )
                        self.perf_results[f"set_cpu_core_boostlimit_processor_{i}"] = stats_set
                        self._print_performance_results(stats_set)

                    except amdsmi.AmdSmiLibraryException:
                        print(f"  Processor {i}: Could not get boost_limit for set test")
                else:
                    print(
                        f"  Processor {i}: Get failed - "
                        f"{stats_get['errors'][0]['error_info'] if stats_get['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Processor", i)
                i = i + 1

        self._log_performance_summary(
            "cpu_core_boostlimit_workflow", "Processors", "cpu_core_boostlimit"
        )
        self._log_performance_summary(
            "amdsmi_cpu_core_boostlimit", "Sockets", "cpu_core_boostlimit"
        )

    def test_performance_set_cpu_df_pstate_range(self):
        self._print_func_name("Starting performance test for amdsmi_set_cpu_df_pstate_range")

        # Use TODO placeholder values like original test
        max_pstate = 0
        min_pstate = 0
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_set_cpu_df_pstate_range",
                    "Processor",
                    i,
                    max_pstate=max_pstate,
                    min_pstate=min_pstate,
                )

                stats = self._measure_api_performance(
                    amdsmi.amdsmi_set_cpu_df_pstate_range,
                    f"set_cpu_df_pstate_range_processor_{i}",
                    processor,
                    max_pstate,
                    min_pstate,
                )

                self.perf_results[f"set_cpu_df_pstate_range_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Processor", i)
                i = i + 1

        self._log_performance_summary(
            "amdsmi_set_cpu_df_pstate_range", "Processors", "set_cpu_df_pstate_range"
        )

    def test_performance_set_cpu_gmi3_link_width_range(self):
        self._print_func_name("Starting performance test for amdsmi_set_cpu_gmi3_link_width_range")

        # Use TODO placeholder values like original test
        min_link_width = 0
        max_link_width = 0
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_set_cpu_gmi3_link_width_range",
                    "Processor",
                    i,
                    min_link_width=min_link_width,
                    max_link_width=max_link_width,
                )

                stats = self._measure_api_performance(
                    amdsmi.amdsmi_set_cpu_gmi3_link_width_range,
                    f"set_cpu_gmi3_link_width_range_processor_{i}",
                    processor,
                    min_link_width,
                    max_link_width,
                )

                self.perf_results[f"set_cpu_gmi3_link_width_range_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Processor", i)
                i = i + 1

        self._log_performance_summary(
            "amdsmi_set_cpu_gmi3_link_width_range", "Processors", "set_cpu_gmi3_link_width_range"
        )

    def test_performance_set_cpu_pwr_efficiency_mode(self):
        self._print_func_name("Starting performance test for amdsmi_set_cpu_pwr_efficiency_mode")

        # Use modes from original test
        modes = [0, 1, 2]
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                for mode in modes:
                    self._log_test_start(
                        "amdsmi_set_cpu_pwr_efficiency_mode", "Processor", i, mode=mode
                    )

                    stats = self._measure_api_performance(
                        amdsmi.amdsmi_set_cpu_pwr_efficiency_mode,
                        f"set_cpu_pwr_efficiency_mode_processor_{i}_mode_{mode}",
                        processor,
                        mode,
                    )

                    self.perf_results[f"set_cpu_pwr_efficiency_mode_processor_{i}_mode_{mode}"] = (
                        stats
                    )

                    if stats["successful_runs"] > 0:
                        self._print_performance_results(stats)
                    else:
                        print(
                            f"  Processor {i} mode {mode}: All calls failed - "
                            f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                        )

                    self._log_test_completion("Processor", i, f"mode={mode}")
                i = i + 1

        self._log_performance_summary(
            "amdsmi_set_cpu_pwr_efficiency_mode", "Processors", "set_cpu_pwr_efficiency_mode"
        )

    def test_performance_cpu_socket_boostlimit(self):
        self._print_func_name("Starting performance test for amdsmi_set_cpu_socket_boostlimit")

        # Use TODO placeholder value like original test
        boost_limit = 0
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_set_cpu_socket_boostlimit", "Processor", i, boost_limit=boost_limit
                )

                stats = self._measure_api_performance(
                    amdsmi.amdsmi_set_cpu_socket_boostlimit,
                    f"set_cpu_socket_boostlimit_processor_{i}",
                    processor,
                    boost_limit,
                )

                self.perf_results[f"set_cpu_socket_boostlimit_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Processor", i)
                i = i + 1

        self._log_performance_summary(
            "amdsmi_set_cpu_socket_boostlimit", "Processors", "cpu_socket_boostlimit"
        )

    def test_performance_set_cpu_socket_lclk_dpm_level(self):
        self._print_func_name("Starting performance test for amdsmi_set_cpu_socket_lclk_dpm_level")

        # Use TODO placeholder values like original test
        nbio_id = 0
        min_val = 0
        max_val = 0
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_set_cpu_socket_lclk_dpm_level",
                    "Processor",
                    i,
                    nbio_id=nbio_id,
                    min_val=min_val,
                    max_val=max_val,
                )

                stats = self._measure_api_performance(
                    amdsmi.amdsmi_set_cpu_socket_lclk_dpm_level,
                    f"set_cpu_socket_lclk_dpm_level_processor_{i}",
                    processor,
                    nbio_id,
                    min_val,
                    max_val,
                )

                self.perf_results[f"set_cpu_socket_lclk_dpm_level_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Processor", i)
                i = i + 1

        self._log_performance_summary(
            "amdsmi_set_cpu_socket_lclk_dpm_level", "Processors", "set_cpu_socket_lclk_dpm_level"
        )

    def test_performance_cpu_socket_power_cap(self):
        self._print_func_name("Starting performance test for CPU socket power cap workflow")
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start("cpu_socket_power_cap_workflow", "Processor", i)

                # Test Get CPU Socket Power Cap
                stats_get = self._measure_api_performance(
                    amdsmi.amdsmi_get_cpu_socket_power_cap,
                    f"get_cpu_socket_power_cap_processor_{i}",
                    processor,
                )
                self.perf_results[f"get_cpu_socket_power_cap_processor_{i}"] = stats_get
                if stats_get["successful_runs"] > 0:
                    self._print_performance_results(stats_get)

                    # Try to get the power cap value for setting test
                    try:
                        power_cap = amdsmi.amdsmi_get_cpu_socket_power_cap(processor)

                        # Test Set CPU Socket Power Cap (with same value to avoid changing system state)
                        stats_set = self._measure_api_performance(
                            amdsmi.amdsmi_set_cpu_socket_power_cap,
                            f"set_cpu_socket_power_cap_processor_{i}",
                            processor,
                            power_cap,
                        )
                        self.perf_results[f"set_cpu_socket_power_cap_processor_{i}"] = stats_set
                        self._print_performance_results(stats_set)

                    except amdsmi.AmdSmiLibraryException:
                        print(f"  Processor {i}: Could not get power_cap for set test")
                else:
                    print(
                        f"  Processor {i}: Get failed - "
                        f"{stats_get['errors'][0]['error_info'] if stats_get['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Processor", i)
                i = i + 1

        self._log_performance_summary(
            "cpu_socket_power_cap_workflow", "Processors", "cpu_socket_power_cap"
        )

    def test_performance_set_cpu_xgmi_width(self):
        self._print_func_name("Starting performance test for amdsmi_set_cpu_xgmi_width")

        # Use TODO placeholder values like original test
        min_width = 0
        max_width = 0
        i = 0
        ret = amdsmi.amdsmi_get_cpu_handles()
        processor_handles = ret["processor_handles"]

        if len(processor_handles) == 0:
            print("No CPU sockets on machine")
        else:
            for processor in processor_handles:
                self._log_test_start(
                    "amdsmi_set_cpu_xgmi_width",
                    "Processor",
                    i,
                    min_width=min_width,
                    max_width=max_width,
                )

                stats = self._measure_api_performance(
                    amdsmi.amdsmi_set_cpu_xgmi_width,
                    f"set_cpu_xgmi_width_processor_{i}",
                    processor,
                    min_width,
                    max_width,
                )

                self.perf_results[f"set_cpu_xgmi_width_processor_{i}"] = stats
                if stats["successful_runs"] > 0:
                    self._print_performance_results(stats)
                else:
                    print(
                        f"  Processor {i}: All calls failed - "
                        f"{stats['errors'][0]['error_info'] if stats['errors'] else 'Unknown'}"
                    )

                self._log_test_completion("Processor", i)
                i = i + 1

        self._log_performance_summary(
            "amdsmi_set_cpu_xgmi_width", "Processors", "set_cpu_xgmi_width"
        )


# =============================================================================
# PERFORMANCE TEST REPORTING SYSTEM (Converted from perf_test.sh)
# =============================================================================


def generate_reports_from_output():
    """
    Generate enhanced and table reports from test output.
    This function replicates the Python report generation from perf_test.sh.
    """
    import os
    import re
    from datetime import datetime
    from statistics import mean

    script_dir = os.path.dirname(os.path.abspath(__file__))

    # Read the captured test output
    log_file = os.path.join(script_dir, "_perf_test.log")
    if not os.path.exists(log_file):
        print(f"⚠️  Warning: Performance log not found: {log_file}")
        return False

    with open(log_file, "r") as f:
        content = f.read()

    # Parse test results
    lines = content.split("\n")
    tests = []
    current_test = None
    workflow_tests = []

    for line in lines:
        line = line.strip()
        if not line:
            continue

        if line.startswith("Testing "):
            parts = line.replace("Testing ", "").split(" on ")
            api_name = parts[0]
            current_test = {"name": api_name}
            workflow_tests = []

        elif line.startswith("Performance ") and "avg" in line and current_test:
            avg_match = re.search(r"(\d+\.\d+)ms avg", line)
            err_match = re.search(r"(\d+) errors", line)

            if avg_match and err_match:
                perf_line_match = re.match(
                    r"Performance\s+(\S+?)(?:_processor_\d+|_gpu_\d+|_socket_\d+|_system)?:", line
                )

                perf_test = {"avg_ms": float(avg_match.group(1)), "errors": int(err_match.group(1))}

                if perf_line_match:
                    perf_test["name"] = perf_line_match.group(1)
                else:
                    perf_test["name"] = current_test["name"]

                workflow_tests.append(perf_test)

        elif "All calls failed" in line and current_test:
            if workflow_tests and "avg_ms" not in workflow_tests[-1]:
                time_match = re.search(r"(\d+\.\d+)ms avg", line)
                if time_match:
                    workflow_tests[-1]["avg_ms"] = float(time_match.group(1))
                    workflow_tests[-1]["errors"] = 11

        elif re.match(r"\s*\d+\s*\|\s*AMDSMI_STATUS_", line) and workflow_tests:
            error_match = re.search(r"(\d+)\s*\|\s*(AMDSMI_STATUS_\w+)", line)
            if error_match and workflow_tests:
                workflow_tests[-1]["error_name"] = error_match.group(2)

        elif line.startswith("Performance test completed for") and current_test:
            for perf_test in workflow_tests:
                if "avg_ms" in perf_test:
                    api_name = perf_test["name"]

                    if perf_test["errors"] > 0 and "error_name" not in perf_test:
                        if "fan" in api_name.lower() or "overdrive" in api_name.lower():
                            perf_test["error_name"] = "AMDSMI_STATUS_NOT_SUPPORTED"
                        else:
                            perf_test["error_name"] = "AMDSMI_STATUS_NOT_SUPPORTED"

                    perf_test["category"] = (
                        "FUNCTIONAL" if perf_test["errors"] == 0 else "ERROR_MEASUREMENT"
                    )
                    tests.append(perf_test)

            workflow_tests = []
            current_test = None

    # Separate tests by category
    functional_tests = sorted(
        [t for t in tests if t["category"] == "FUNCTIONAL"], key=lambda x: x["avg_ms"]
    )
    error_tests = sorted(
        [t for t in tests if t["category"] == "ERROR_MEASUREMENT"], key=lambda x: x["avg_ms"]
    )

    # Generate Enhanced Report
    enhanced_file = os.path.join(script_dir, "_perf_test_enhanced.log")
    with open(enhanced_file, "w") as f:
        f.write("╔" + "═" * 78 + "╗\n")
        f.write("║" + " AMD SMI PYTHON PERFORMANCE TEST RESULTS".center(78) + "║\n")
        f.write(
            "║"
            + f" Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
            + " " * (78 - len(f" Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"))
            + "║\n"
        )
        f.write("╚" + "═" * 78 + "╝\n\n")

        total = len(tests)
        f.write("📊 SUMMARY STATISTICS\n")
        f.write("─" * 50 + "\n")
        f.write(f"Total Tests Executed: {total}\n")
        f.write(
            f"✅ Working APIs: {len(functional_tests)} ({len(functional_tests) / total * 100:.1f}%)\n"
        )
        f.write(
            f"⚠️  APIs with Expected Errors: {len(error_tests)} ({len(error_tests) / total * 100:.1f}%)\n\n"
        )

        if functional_tests:
            avg_times = [t["avg_ms"] for t in functional_tests]
            f.write("⚡ PERFORMANCE METRICS (Working APIs Only)\n")
            f.write("─" * 50 + "\n")
            f.write(f"Fastest API: {min(avg_times):.3f}ms\n")
            f.write(f"Slowest API: {max(avg_times):.3f}ms\n")
            f.write(f"Average Time: {mean(avg_times):.3f}ms\n\n")

            f.write("🏆 TOP 10 FASTEST APIs\n")
            f.write("─" * 50 + "\n")
            for i, test in enumerate(functional_tests[:10], 1):
                f.write(f"{i:2d}. {test['name']} - {test['avg_ms']:.3f}ms\n")
            f.write("\n")

    print(f"✅ Enhanced report: {enhanced_file}")

    # Generate Table Report
    table_file = os.path.join(script_dir, "_perf_test_table.log")
    with open(table_file, "w") as f:
        f.write("╔" + "═" * 168 + "╗\n")
        f.write("║" + "AMD SMI PYTHON PERFORMANCE TEST RESULTS".center(168) + "║\n")
        f.write("║" + "TABLE FORMAT".center(168) + "║\n")
        f.write("╠" + "═" * 168 + "╣\n")
        gen_text = f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
        f.write("║ " + gen_text + " " * (166 - len(gen_text)) + " ║\n")
        f.write("╚" + "═" * 168 + "╝\n\n")

        total = len(tests)
        f.write("📊 SUMMARY STATISTICS\n")
        f.write("═" * 53 + "\n")
        f.write(f"Total Tests Executed   : {total}\n")
        f.write(
            f"✅ Functional Tests    : {len(functional_tests)} ({len(functional_tests) / total * 100:.1f}%)\n"
        )
        f.write(
            f"⚠️  Error Measurements  : {len(error_tests)} ({len(error_tests) / total * 100:.1f}%)\n\n"
        )

        if functional_tests:
            avg_times = [t["avg_ms"] for t in functional_tests]
            fastest = min(functional_tests, key=lambda x: x["avg_ms"])
            slowest = max(functional_tests, key=lambda x: x["avg_ms"])

            f.write(f"⚡ Fastest API          : {min(avg_times):.3f}ms ({fastest['name']})\n")
            f.write(f"🐌 Slowest API          : {max(avg_times):.3f}ms ({slowest['name']})\n")
            f.write(f"📈 Average Time         : {mean(avg_times):.3f}ms\n")
        f.write("\n")

        if functional_tests:
            f.write("✅ FUNCTIONAL TESTS (APIs Returning Valid Data)\n")
            f.write("═" * 53 + "\n")
            f.write(
                "┌──────┬───────────────────────────────────────────────────────────────────┬─────────────┬─────────────────────────────────────────────┐\n"
            )
            f.write(
                "│ Rank │ API Name                                                          │ Time (ms)   │ Status                                      │\n"
            )
            f.write(
                "├──────┼───────────────────────────────────────────────────────────────────┼─────────────┼─────────────────────────────────────────────┤\n"
            )

            for i, test in enumerate(functional_tests, 1):
                name = test["name"][:65] + "..." if len(test["name"]) > 65 else test["name"]
                f.write(f"│ {i:4d} │ {name:<65} │ {test['avg_ms']:>9.3f}   │ {'':<40}✅ │\n")

            f.write(
                "└──────┴───────────────────────────────────────────────────────────────────┴─────────────┴─────────────────────────────────────────────┘\n\n"
            )

        if error_tests:
            f.write("⚠️ ERROR MEASUREMENT TESTS (APIs Correctly Returning Expected Errors)\n")
            f.write("═" * 53 + "\n")
            f.write(
                "┌──────┬───────────────────────────────────────────────────────────────────┬─────────────┬──────────────────────────────────────────┐\n"
            )
            f.write(
                "│ #    │ API Name                                                          │ Time (ms)   │ Error Code                               │\n"
            )
            f.write(
                "├──────┼───────────────────────────────────────────────────────────────────┼─────────────┼──────────────────────────────────────────┤\n"
            )

            for i, test in enumerate(error_tests, 1):
                name = test["name"][:65] + "..." if len(test["name"]) > 65 else test["name"]
                error_info = test.get("error_name", f"{test['errors']} errors")
                if len(error_info) > 40:
                    error_info = error_info[:37] + "..."
                f.write(f"│ {i:4d} │ {name:<65} │ {test['avg_ms']:>9.3f}   │ {error_info:<40} │\n")

            f.write(
                "└──────┴───────────────────────────────────────────────────────────────────┴─────────────┴──────────────────────────────────────────┘\n\n"
            )

        # Performance categories
        if tests:
            f.write("🏃 PERFORMANCE CATEGORIES\n")
            f.write("═" * 53 + "\n")
            ultra_fast = [t for t in tests if t["avg_ms"] < 0.01]
            fast = [t for t in tests if 0.01 <= t["avg_ms"] < 0.1]
            medium = [t for t in tests if 0.1 <= t["avg_ms"] < 1.0]
            slow = [t for t in tests if t["avg_ms"] >= 1.0]

            f.write(f"🚀 Ultra Fast (< 0.01ms)    : {len(ultra_fast):2d} tests\n")
            f.write(f"⚡ Fast (0.01-0.1ms)        : {len(fast):2d} tests\n")
            f.write(f"🚶 Medium (0.1-1.0ms)       : {len(medium):2d} tests\n")
            f.write(f"🐌 Slow (>= 1.0ms)          : {len(slow):2d} tests\n\n")

        f.write("═" * 53 + "\n")
        f.write(f"Report generated by AMD SMI Performance Test (Python Version)\n")
        f.write(f"For detailed logs, see: _perf_test.log and _perf_test_err.log\n\n")
        f.write('📝 NOTE: "Error Measurement Tests" are successful performance measurements\n')
        f.write(
            "   of APIs that correctly return expected error codes (e.g., AMDSMI_STATUS_NOT_SUPPORTED)\n"
        )
        f.write("   These are NOT test failures - they are successful timing measurements.\n")
        f.write("═" * 53 + "\n")

    print(f"✅ Table report: {table_file}")
    print(f"✅ Raw output: {log_file}")

    return True


if __name__ == "__main__":
    import os
    import sys
    import subprocess
    from datetime import datetime

    # Check if user wants simple unittest mode (no report generation)
    if "--unittest-only" in sys.argv:
        sys.argv.remove("--unittest-only")
        unittest.main()
        sys.exit(0)

    script_dir = os.path.dirname(os.path.abspath(__file__))

    # Print header
    print("\n" + "═" * 80)
    print("AMD SMI PYTHON PERFORMANCE TEST".center(80))
    print("═" * 80 + "\n")

    print(f"📍 Test directory: {script_dir}")
    print(f"📄 Test file: {__file__}")
    print(f"🕐 Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

    # Step 1: Clean previous results
    print("\n[STEP 1] Cleaning previous results...")
    log_files = [
        "_perf_test.log",
        "_perf_test_err.log",
        "_perf_test_enhanced.log",
        "_perf_test_table.log",
    ]
    removed = 0
    for log_file in log_files:
        full_path = os.path.join(script_dir, log_file)
        if os.path.exists(full_path):
            os.remove(full_path)
            removed += 1

    if removed > 0:
        print(f"✅ Cleaned {removed} previous result file(s)")
    else:
        print("ℹ️  No previous results to clean")

    # Step 2: Run performance tests with output capture
    print("\n[STEP 2] Running performance tests...")
    print("⏳ Executing tests...")

    log_file = os.path.join(script_dir, "_perf_test.log")
    err_file = os.path.join(script_dir, "_perf_test_err.log")

    # Run tests with unittest and capture output
    with open(log_file, "w") as f_out, open(err_file, "w") as f_err:
        # Run the tests using unittest directly
        loader = unittest.TestLoader()
        suite = loader.loadTestsFromTestCase(TestAmdSmiCPUPythonPerformance)
        runner = unittest.TextTestRunner(stream=f_err, verbosity=2)

        # Redirect stdout to capture performance output
        old_stdout = sys.stdout
        sys.stdout = f_out

        result = runner.run(suite)

        sys.stdout = old_stdout

    # Also display output to console
    with open(log_file, "r") as f:
        output_preview = f.readlines()
        # Show last 20 lines of output
        print("\n".join(output_preview[-20:]))

    if result.wasSuccessful():
        print("✅ Performance tests completed successfully")
    else:
        print("⚠️  Performance tests completed with some issues")

    # Step 3: Generate reports
    print("\n[STEP 3] Generating reports...")

    if generate_reports_from_output():
        # Step 4: Show results summary
        print("\n[STEP 4] Results Summary")
        print("═" * 80)
        print("                    🎉 TEST COMPLETE".center(80))
        print("═" * 80 + "\n")

        print("📊 Generated Output Files:\n")
        for log_file in log_files:
            full_path = os.path.join(script_dir, log_file)
            if os.path.exists(full_path):
                size = os.path.getsize(full_path) / 1024
                desc = {
                    "_perf_test_enhanced.log": "Enhanced Summary Report",
                    "_perf_test_table.log": "Tabular Results Report",
                    "_perf_test_err.log": "Error Log & Test Status",
                    "_perf_test.log": "Complete Test Output",
                }.get(log_file, "Output File")

                print(f"  {desc} ({size:.1f} KB)")
                print(f"  → {full_path}\n")

        # Show preview of enhanced report
        print("📈 Quick Stats Preview:")
        print("═" * 80)
        enhanced_path = os.path.join(script_dir, "_perf_test_enhanced.log")
        if os.path.exists(enhanced_path):
            with open(enhanced_path, "r") as f:
                lines = f.readlines()
                # Show first 15 lines
                print("".join(lines[:15]))
        print("═" * 80 + "\n")

        print(f"✅ All reports generated in: {script_dir}")
        print(f"🕐 Finished: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print("\n" + "═" * 80 + "\n")
    else:
        print("⚠️  Report generation failed")
        sys.exit(1)

    # Exit with appropriate code
    sys.exit(0 if result.wasSuccessful() else 1)
